xref: /openbmc/linux/fs/afs/fsclient.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /* fsclient.c: AFS File Server client stubs
2  *
3  * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  */
11 
12 #include <linux/init.h>
13 #include <linux/sched.h>
14 #include <rxrpc/rxrpc.h>
15 #include <rxrpc/transport.h>
16 #include <rxrpc/connection.h>
17 #include <rxrpc/call.h>
18 #include "fsclient.h"
19 #include "cmservice.h"
20 #include "vnode.h"
21 #include "server.h"
22 #include "errors.h"
23 #include "internal.h"
24 
25 #define FSFETCHSTATUS		132	/* AFS Fetch file status */
26 #define FSFETCHDATA		130	/* AFS Fetch file data */
27 #define FSGIVEUPCALLBACKS	147	/* AFS Discard callback promises */
28 #define FSGETVOLUMEINFO		148	/* AFS Get root volume information */
29 #define FSGETROOTVOLUME		151	/* AFS Get root volume name */
30 #define FSLOOKUP		161	/* AFS lookup file in directory */
31 
32 /*****************************************************************************/
33 /*
34  * map afs abort codes to/from Linux error codes
35  * - called with call->lock held
36  */
37 static void afs_rxfs_aemap(struct rxrpc_call *call)
38 {
39 	switch (call->app_err_state) {
40 	case RXRPC_ESTATE_LOCAL_ABORT:
41 		call->app_abort_code = -call->app_errno;
42 		break;
43 	case RXRPC_ESTATE_PEER_ABORT:
44 		call->app_errno = afs_abort_to_error(call->app_abort_code);
45 		break;
46 	default:
47 		break;
48 	}
49 } /* end afs_rxfs_aemap() */
50 
51 /*****************************************************************************/
52 /*
53  * get the root volume name from a fileserver
54  * - this operation doesn't seem to work correctly in OpenAFS server 1.2.2
55  */
56 #if 0
57 int afs_rxfs_get_root_volume(struct afs_server *server,
58 			     char *buf, size_t *buflen)
59 {
60 	struct rxrpc_connection *conn;
61 	struct rxrpc_call *call;
62 	struct kvec piov[2];
63 	size_t sent;
64 	int ret;
65 	u32 param[1];
66 
67 	DECLARE_WAITQUEUE(myself, current);
68 
69 	kenter("%p,%p,%u",server, buf, *buflen);
70 
71 	/* get hold of the fileserver connection */
72 	ret = afs_server_get_fsconn(server, &conn);
73 	if (ret < 0)
74 		goto out;
75 
76 	/* create a call through that connection */
77 	ret = rxrpc_create_call(conn, NULL, NULL, afs_rxfs_aemap, &call);
78 	if (ret < 0) {
79 		printk("kAFS: Unable to create call: %d\n", ret);
80 		goto out_put_conn;
81 	}
82 	call->app_opcode = FSGETROOTVOLUME;
83 
84 	/* we want to get event notifications from the call */
85 	add_wait_queue(&call->waitq, &myself);
86 
87 	/* marshall the parameters */
88 	param[0] = htonl(FSGETROOTVOLUME);
89 
90 	piov[0].iov_len = sizeof(param);
91 	piov[0].iov_base = param;
92 
93 	/* send the parameters to the server */
94 	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
95 				    0, &sent);
96 	if (ret < 0)
97 		goto abort;
98 
99 	/* wait for the reply to completely arrive */
100 	for (;;) {
101 		set_current_state(TASK_INTERRUPTIBLE);
102 		if (call->app_call_state != RXRPC_CSTATE_CLNT_RCV_REPLY ||
103 		    signal_pending(current))
104 			break;
105 		schedule();
106 	}
107 	set_current_state(TASK_RUNNING);
108 
109 	ret = -EINTR;
110 	if (signal_pending(current))
111 		goto abort;
112 
113 	switch (call->app_call_state) {
114 	case RXRPC_CSTATE_ERROR:
115 		ret = call->app_errno;
116 		kdebug("Got Error: %d", ret);
117 		goto out_unwait;
118 
119 	case RXRPC_CSTATE_CLNT_GOT_REPLY:
120 		/* read the reply */
121 		kdebug("Got Reply: qty=%d", call->app_ready_qty);
122 
123 		ret = -EBADMSG;
124 		if (call->app_ready_qty <= 4)
125 			goto abort;
126 
127 		ret = rxrpc_call_read_data(call, NULL, call->app_ready_qty, 0);
128 		if (ret < 0)
129 			goto abort;
130 
131 #if 0
132 		/* unmarshall the reply */
133 		bp = buffer;
134 		for (loop = 0; loop < 65; loop++)
135 			entry->name[loop] = ntohl(*bp++);
136 		entry->name[64] = 0;
137 
138 		entry->type = ntohl(*bp++);
139 		entry->num_servers = ntohl(*bp++);
140 
141 		for (loop = 0; loop < 8; loop++)
142 			entry->servers[loop].addr.s_addr = *bp++;
143 
144 		for (loop = 0; loop < 8; loop++)
145 			entry->servers[loop].partition = ntohl(*bp++);
146 
147 		for (loop = 0; loop < 8; loop++)
148 			entry->servers[loop].flags = ntohl(*bp++);
149 
150 		for (loop = 0; loop < 3; loop++)
151 			entry->volume_ids[loop] = ntohl(*bp++);
152 
153 		entry->clone_id = ntohl(*bp++);
154 		entry->flags = ntohl(*bp);
155 #endif
156 
157 		/* success */
158 		ret = 0;
159 		goto out_unwait;
160 
161 	default:
162 		BUG();
163 	}
164 
165  abort:
166 	set_current_state(TASK_UNINTERRUPTIBLE);
167 	rxrpc_call_abort(call, ret);
168 	schedule();
169  out_unwait:
170 	set_current_state(TASK_RUNNING);
171 	remove_wait_queue(&call->waitq, &myself);
172 	rxrpc_put_call(call);
173  out_put_conn:
174 	afs_server_release_fsconn(server, conn);
175  out:
176 	kleave("");
177 	return ret;
178 } /* end afs_rxfs_get_root_volume() */
179 #endif
180 
181 /*****************************************************************************/
182 /*
183  * get information about a volume
184  */
185 #if 0
186 int afs_rxfs_get_volume_info(struct afs_server *server,
187 			     const char *name,
188 			     struct afs_volume_info *vinfo)
189 {
190 	struct rxrpc_connection *conn;
191 	struct rxrpc_call *call;
192 	struct kvec piov[3];
193 	size_t sent;
194 	int ret;
195 	u32 param[2], *bp, zero;
196 
197 	DECLARE_WAITQUEUE(myself, current);
198 
199 	_enter("%p,%s,%p", server, name, vinfo);
200 
201 	/* get hold of the fileserver connection */
202 	ret = afs_server_get_fsconn(server, &conn);
203 	if (ret < 0)
204 		goto out;
205 
206 	/* create a call through that connection */
207 	ret = rxrpc_create_call(conn, NULL, NULL, afs_rxfs_aemap, &call);
208 	if (ret < 0) {
209 		printk("kAFS: Unable to create call: %d\n", ret);
210 		goto out_put_conn;
211 	}
212 	call->app_opcode = FSGETVOLUMEINFO;
213 
214 	/* we want to get event notifications from the call */
215 	add_wait_queue(&call->waitq, &myself);
216 
217 	/* marshall the parameters */
218 	piov[1].iov_len = strlen(name);
219 	piov[1].iov_base = (char *) name;
220 
221 	zero = 0;
222 	piov[2].iov_len = (4 - (piov[1].iov_len & 3)) & 3;
223 	piov[2].iov_base = &zero;
224 
225 	param[0] = htonl(FSGETVOLUMEINFO);
226 	param[1] = htonl(piov[1].iov_len);
227 
228 	piov[0].iov_len = sizeof(param);
229 	piov[0].iov_base = param;
230 
231 	/* send the parameters to the server */
232 	ret = rxrpc_call_write_data(call, 3, piov, RXRPC_LAST_PACKET, GFP_NOFS,
233 				    0, &sent);
234 	if (ret < 0)
235 		goto abort;
236 
237 	/* wait for the reply to completely arrive */
238 	bp = rxrpc_call_alloc_scratch(call, 64);
239 
240 	ret = rxrpc_call_read_data(call, bp, 64,
241 				   RXRPC_CALL_READ_BLOCK |
242 				   RXRPC_CALL_READ_ALL);
243 	if (ret < 0) {
244 		if (ret == -ECONNABORTED) {
245 			ret = call->app_errno;
246 			goto out_unwait;
247 		}
248 		goto abort;
249 	}
250 
251 	/* unmarshall the reply */
252 	vinfo->vid = ntohl(*bp++);
253 	vinfo->type = ntohl(*bp++);
254 
255 	vinfo->type_vids[0] = ntohl(*bp++);
256 	vinfo->type_vids[1] = ntohl(*bp++);
257 	vinfo->type_vids[2] = ntohl(*bp++);
258 	vinfo->type_vids[3] = ntohl(*bp++);
259 	vinfo->type_vids[4] = ntohl(*bp++);
260 
261 	vinfo->nservers = ntohl(*bp++);
262 	vinfo->servers[0].addr.s_addr = *bp++;
263 	vinfo->servers[1].addr.s_addr = *bp++;
264 	vinfo->servers[2].addr.s_addr = *bp++;
265 	vinfo->servers[3].addr.s_addr = *bp++;
266 	vinfo->servers[4].addr.s_addr = *bp++;
267 	vinfo->servers[5].addr.s_addr = *bp++;
268 	vinfo->servers[6].addr.s_addr = *bp++;
269 	vinfo->servers[7].addr.s_addr = *bp++;
270 
271 	ret = -EBADMSG;
272 	if (vinfo->nservers > 8)
273 		goto abort;
274 
275 	/* success */
276 	ret = 0;
277 
278  out_unwait:
279 	set_current_state(TASK_RUNNING);
280 	remove_wait_queue(&call->waitq, &myself);
281 	rxrpc_put_call(call);
282  out_put_conn:
283 	afs_server_release_fsconn(server, conn);
284  out:
285 	_leave("");
286 	return ret;
287 
288  abort:
289 	set_current_state(TASK_UNINTERRUPTIBLE);
290 	rxrpc_call_abort(call, ret);
291 	schedule();
292 	goto out_unwait;
293 
294 } /* end afs_rxfs_get_volume_info() */
295 #endif
296 
297 /*****************************************************************************/
298 /*
299  * fetch the status information for a file
300  */
301 int afs_rxfs_fetch_file_status(struct afs_server *server,
302 			       struct afs_vnode *vnode,
303 			       struct afs_volsync *volsync)
304 {
305 	struct afs_server_callslot callslot;
306 	struct rxrpc_call *call;
307 	struct kvec piov[1];
308 	size_t sent;
309 	int ret;
310 	__be32 *bp;
311 
312 	DECLARE_WAITQUEUE(myself, current);
313 
314 	_enter("%p,{%u,%u,%u}",
315 	       server, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
316 
317 	/* get hold of the fileserver connection */
318 	ret = afs_server_request_callslot(server, &callslot);
319 	if (ret < 0)
320 		goto out;
321 
322 	/* create a call through that connection */
323 	ret = rxrpc_create_call(callslot.conn, NULL, NULL, afs_rxfs_aemap,
324 				&call);
325 	if (ret < 0) {
326 		printk("kAFS: Unable to create call: %d\n", ret);
327 		goto out_put_conn;
328 	}
329 	call->app_opcode = FSFETCHSTATUS;
330 
331 	/* we want to get event notifications from the call */
332 	add_wait_queue(&call->waitq, &myself);
333 
334 	/* marshall the parameters */
335 	bp = rxrpc_call_alloc_scratch(call, 16);
336 	bp[0] = htonl(FSFETCHSTATUS);
337 	bp[1] = htonl(vnode->fid.vid);
338 	bp[2] = htonl(vnode->fid.vnode);
339 	bp[3] = htonl(vnode->fid.unique);
340 
341 	piov[0].iov_len = 16;
342 	piov[0].iov_base = bp;
343 
344 	/* send the parameters to the server */
345 	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
346 				    0, &sent);
347 	if (ret < 0)
348 		goto abort;
349 
350 	/* wait for the reply to completely arrive */
351 	bp = rxrpc_call_alloc_scratch(call, 120);
352 
353 	ret = rxrpc_call_read_data(call, bp, 120,
354 				   RXRPC_CALL_READ_BLOCK |
355 				   RXRPC_CALL_READ_ALL);
356 	if (ret < 0) {
357 		if (ret == -ECONNABORTED) {
358 			ret = call->app_errno;
359 			goto out_unwait;
360 		}
361 		goto abort;
362 	}
363 
364 	/* unmarshall the reply */
365 	vnode->status.if_version	= ntohl(*bp++);
366 	vnode->status.type		= ntohl(*bp++);
367 	vnode->status.nlink		= ntohl(*bp++);
368 	vnode->status.size		= ntohl(*bp++);
369 	vnode->status.version		= ntohl(*bp++);
370 	vnode->status.author		= ntohl(*bp++);
371 	vnode->status.owner		= ntohl(*bp++);
372 	vnode->status.caller_access	= ntohl(*bp++);
373 	vnode->status.anon_access	= ntohl(*bp++);
374 	vnode->status.mode		= ntohl(*bp++);
375 	vnode->status.parent.vid	= vnode->fid.vid;
376 	vnode->status.parent.vnode	= ntohl(*bp++);
377 	vnode->status.parent.unique	= ntohl(*bp++);
378 	bp++; /* seg size */
379 	vnode->status.mtime_client	= ntohl(*bp++);
380 	vnode->status.mtime_server	= ntohl(*bp++);
381 	bp++; /* group */
382 	bp++; /* sync counter */
383 	vnode->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
384 	bp++; /* spare2 */
385 	bp++; /* spare3 */
386 	bp++; /* spare4 */
387 
388 	vnode->cb_version		= ntohl(*bp++);
389 	vnode->cb_expiry		= ntohl(*bp++);
390 	vnode->cb_type			= ntohl(*bp++);
391 
392 	if (volsync) {
393 		volsync->creation	= ntohl(*bp++);
394 		bp++; /* spare2 */
395 		bp++; /* spare3 */
396 		bp++; /* spare4 */
397 		bp++; /* spare5 */
398 		bp++; /* spare6 */
399 	}
400 
401 	/* success */
402 	ret = 0;
403 
404  out_unwait:
405 	set_current_state(TASK_RUNNING);
406 	remove_wait_queue(&call->waitq, &myself);
407 	rxrpc_put_call(call);
408  out_put_conn:
409 	afs_server_release_callslot(server, &callslot);
410  out:
411 	_leave("");
412 	return ret;
413 
414  abort:
415 	set_current_state(TASK_UNINTERRUPTIBLE);
416 	rxrpc_call_abort(call, ret);
417 	schedule();
418 	goto out_unwait;
419 } /* end afs_rxfs_fetch_file_status() */
420 
421 /*****************************************************************************/
422 /*
423  * fetch the contents of a file or directory
424  */
425 int afs_rxfs_fetch_file_data(struct afs_server *server,
426 			     struct afs_vnode *vnode,
427 			     struct afs_rxfs_fetch_descriptor *desc,
428 			     struct afs_volsync *volsync)
429 {
430 	struct afs_server_callslot callslot;
431 	struct rxrpc_call *call;
432 	struct kvec piov[1];
433 	size_t sent;
434 	int ret;
435 	__be32 *bp;
436 
437 	DECLARE_WAITQUEUE(myself, current);
438 
439 	_enter("%p,{fid={%u,%u,%u},sz=%Zu,of=%lu}",
440 	       server,
441 	       desc->fid.vid,
442 	       desc->fid.vnode,
443 	       desc->fid.unique,
444 	       desc->size,
445 	       desc->offset);
446 
447 	/* get hold of the fileserver connection */
448 	ret = afs_server_request_callslot(server, &callslot);
449 	if (ret < 0)
450 		goto out;
451 
452 	/* create a call through that connection */
453 	ret = rxrpc_create_call(callslot.conn, NULL, NULL, afs_rxfs_aemap, &call);
454 	if (ret < 0) {
455 		printk("kAFS: Unable to create call: %d\n", ret);
456 		goto out_put_conn;
457 	}
458 	call->app_opcode = FSFETCHDATA;
459 
460 	/* we want to get event notifications from the call */
461 	add_wait_queue(&call->waitq, &myself);
462 
463 	/* marshall the parameters */
464 	bp = rxrpc_call_alloc_scratch(call, 24);
465 	bp[0] = htonl(FSFETCHDATA);
466 	bp[1] = htonl(desc->fid.vid);
467 	bp[2] = htonl(desc->fid.vnode);
468 	bp[3] = htonl(desc->fid.unique);
469 	bp[4] = htonl(desc->offset);
470 	bp[5] = htonl(desc->size);
471 
472 	piov[0].iov_len = 24;
473 	piov[0].iov_base = bp;
474 
475 	/* send the parameters to the server */
476 	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
477 				    0, &sent);
478 	if (ret < 0)
479 		goto abort;
480 
481 	/* wait for the data count to arrive */
482 	ret = rxrpc_call_read_data(call, bp, 4, RXRPC_CALL_READ_BLOCK);
483 	if (ret < 0)
484 		goto read_failed;
485 
486 	desc->actual = ntohl(bp[0]);
487 	if (desc->actual != desc->size) {
488 		ret = -EBADMSG;
489 		goto abort;
490 	}
491 
492 	/* call the app to read the actual data */
493 	rxrpc_call_reset_scratch(call);
494 
495 	ret = rxrpc_call_read_data(call, desc->buffer, desc->actual,
496 				   RXRPC_CALL_READ_BLOCK);
497 	if (ret < 0)
498 		goto read_failed;
499 
500 	/* wait for the rest of the reply to completely arrive */
501 	rxrpc_call_reset_scratch(call);
502 	bp = rxrpc_call_alloc_scratch(call, 120);
503 
504 	ret = rxrpc_call_read_data(call, bp, 120,
505 				   RXRPC_CALL_READ_BLOCK |
506 				   RXRPC_CALL_READ_ALL);
507 	if (ret < 0)
508 		goto read_failed;
509 
510 	/* unmarshall the reply */
511 	vnode->status.if_version	= ntohl(*bp++);
512 	vnode->status.type		= ntohl(*bp++);
513 	vnode->status.nlink		= ntohl(*bp++);
514 	vnode->status.size		= ntohl(*bp++);
515 	vnode->status.version		= ntohl(*bp++);
516 	vnode->status.author		= ntohl(*bp++);
517 	vnode->status.owner		= ntohl(*bp++);
518 	vnode->status.caller_access	= ntohl(*bp++);
519 	vnode->status.anon_access	= ntohl(*bp++);
520 	vnode->status.mode		= ntohl(*bp++);
521 	vnode->status.parent.vid	= desc->fid.vid;
522 	vnode->status.parent.vnode	= ntohl(*bp++);
523 	vnode->status.parent.unique	= ntohl(*bp++);
524 	bp++; /* seg size */
525 	vnode->status.mtime_client	= ntohl(*bp++);
526 	vnode->status.mtime_server	= ntohl(*bp++);
527 	bp++; /* group */
528 	bp++; /* sync counter */
529 	vnode->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
530 	bp++; /* spare2 */
531 	bp++; /* spare3 */
532 	bp++; /* spare4 */
533 
534 	vnode->cb_version		= ntohl(*bp++);
535 	vnode->cb_expiry		= ntohl(*bp++);
536 	vnode->cb_type			= ntohl(*bp++);
537 
538 	if (volsync) {
539 		volsync->creation	= ntohl(*bp++);
540 		bp++; /* spare2 */
541 		bp++; /* spare3 */
542 		bp++; /* spare4 */
543 		bp++; /* spare5 */
544 		bp++; /* spare6 */
545 	}
546 
547 	/* success */
548 	ret = 0;
549 
550  out_unwait:
551 	set_current_state(TASK_RUNNING);
552 	remove_wait_queue(&call->waitq,&myself);
553 	rxrpc_put_call(call);
554  out_put_conn:
555 	afs_server_release_callslot(server, &callslot);
556  out:
557 	_leave(" = %d", ret);
558 	return ret;
559 
560  read_failed:
561 	if (ret == -ECONNABORTED) {
562 		ret = call->app_errno;
563 		goto out_unwait;
564 	}
565 
566  abort:
567 	set_current_state(TASK_UNINTERRUPTIBLE);
568 	rxrpc_call_abort(call, ret);
569 	schedule();
570 	goto out_unwait;
571 
572 } /* end afs_rxfs_fetch_file_data() */
573 
574 /*****************************************************************************/
575 /*
576  * ask the AFS fileserver to discard a callback request on a file
577  */
578 int afs_rxfs_give_up_callback(struct afs_server *server,
579 			      struct afs_vnode *vnode)
580 {
581 	struct afs_server_callslot callslot;
582 	struct rxrpc_call *call;
583 	struct kvec piov[1];
584 	size_t sent;
585 	int ret;
586 	__be32 *bp;
587 
588 	DECLARE_WAITQUEUE(myself, current);
589 
590 	_enter("%p,{%u,%u,%u}",
591 	       server, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique);
592 
593 	/* get hold of the fileserver connection */
594 	ret = afs_server_request_callslot(server, &callslot);
595 	if (ret < 0)
596 		goto out;
597 
598 	/* create a call through that connection */
599 	ret = rxrpc_create_call(callslot.conn, NULL, NULL, afs_rxfs_aemap, &call);
600 	if (ret < 0) {
601 		printk("kAFS: Unable to create call: %d\n", ret);
602 		goto out_put_conn;
603 	}
604 	call->app_opcode = FSGIVEUPCALLBACKS;
605 
606 	/* we want to get event notifications from the call */
607 	add_wait_queue(&call->waitq, &myself);
608 
609 	/* marshall the parameters */
610 	bp = rxrpc_call_alloc_scratch(call, (1 + 4 + 4) * 4);
611 
612 	piov[0].iov_len = (1 + 4 + 4) * 4;
613 	piov[0].iov_base = bp;
614 
615 	*bp++ = htonl(FSGIVEUPCALLBACKS);
616 	*bp++ = htonl(1);
617 	*bp++ = htonl(vnode->fid.vid);
618 	*bp++ = htonl(vnode->fid.vnode);
619 	*bp++ = htonl(vnode->fid.unique);
620 	*bp++ = htonl(1);
621 	*bp++ = htonl(vnode->cb_version);
622 	*bp++ = htonl(vnode->cb_expiry);
623 	*bp++ = htonl(vnode->cb_type);
624 
625 	/* send the parameters to the server */
626 	ret = rxrpc_call_write_data(call, 1, piov, RXRPC_LAST_PACKET, GFP_NOFS,
627 				    0, &sent);
628 	if (ret < 0)
629 		goto abort;
630 
631 	/* wait for the reply to completely arrive */
632 	for (;;) {
633 		set_current_state(TASK_INTERRUPTIBLE);
634 		if (call->app_call_state != RXRPC_CSTATE_CLNT_RCV_REPLY ||
635 		    signal_pending(current))
636 			break;
637 		schedule();
638 	}
639 	set_current_state(TASK_RUNNING);
640 
641 	ret = -EINTR;
642 	if (signal_pending(current))
643 		goto abort;
644 
645 	switch (call->app_call_state) {
646 	case RXRPC_CSTATE_ERROR:
647 		ret = call->app_errno;
648 		goto out_unwait;
649 
650 	case RXRPC_CSTATE_CLNT_GOT_REPLY:
651 		ret = 0;
652 		goto out_unwait;
653 
654 	default:
655 		BUG();
656 	}
657 
658  out_unwait:
659 	set_current_state(TASK_RUNNING);
660 	remove_wait_queue(&call->waitq, &myself);
661 	rxrpc_put_call(call);
662  out_put_conn:
663 	afs_server_release_callslot(server, &callslot);
664  out:
665 	_leave("");
666 	return ret;
667 
668  abort:
669 	set_current_state(TASK_UNINTERRUPTIBLE);
670 	rxrpc_call_abort(call, ret);
671 	schedule();
672 	goto out_unwait;
673 } /* end afs_rxfs_give_up_callback() */
674 
675 /*****************************************************************************/
676 /*
677  * look a filename up in a directory
678  * - this operation doesn't seem to work correctly in OpenAFS server 1.2.2
679  */
680 #if 0
681 int afs_rxfs_lookup(struct afs_server *server,
682 		    struct afs_vnode *dir,
683 		    const char *filename,
684 		    struct afs_vnode *vnode,
685 		    struct afs_volsync *volsync)
686 {
687 	struct rxrpc_connection *conn;
688 	struct rxrpc_call *call;
689 	struct kvec piov[3];
690 	size_t sent;
691 	int ret;
692 	u32 *bp, zero;
693 
694 	DECLARE_WAITQUEUE(myself, current);
695 
696 	kenter("%p,{%u,%u,%u},%s",
697 	       server, fid->vid, fid->vnode, fid->unique, filename);
698 
699 	/* get hold of the fileserver connection */
700 	ret = afs_server_get_fsconn(server, &conn);
701 	if (ret < 0)
702 		goto out;
703 
704 	/* create a call through that connection */
705 	ret = rxrpc_create_call(conn, NULL, NULL, afs_rxfs_aemap, &call);
706 	if (ret < 0) {
707 		printk("kAFS: Unable to create call: %d\n", ret);
708 		goto out_put_conn;
709 	}
710 	call->app_opcode = FSLOOKUP;
711 
712 	/* we want to get event notifications from the call */
713 	add_wait_queue(&call->waitq,&myself);
714 
715 	/* marshall the parameters */
716 	bp = rxrpc_call_alloc_scratch(call, 20);
717 
718 	zero = 0;
719 
720 	piov[0].iov_len = 20;
721 	piov[0].iov_base = bp;
722 	piov[1].iov_len = strlen(filename);
723 	piov[1].iov_base = (char *) filename;
724 	piov[2].iov_len = (4 - (piov[1].iov_len & 3)) & 3;
725 	piov[2].iov_base = &zero;
726 
727 	*bp++ = htonl(FSLOOKUP);
728 	*bp++ = htonl(dirfid->vid);
729 	*bp++ = htonl(dirfid->vnode);
730 	*bp++ = htonl(dirfid->unique);
731 	*bp++ = htonl(piov[1].iov_len);
732 
733 	/* send the parameters to the server */
734 	ret = rxrpc_call_write_data(call, 3, piov, RXRPC_LAST_PACKET, GFP_NOFS,
735 				    0, &sent);
736 	if (ret < 0)
737 		goto abort;
738 
739 	/* wait for the reply to completely arrive */
740 	bp = rxrpc_call_alloc_scratch(call, 220);
741 
742 	ret = rxrpc_call_read_data(call, bp, 220,
743 				   RXRPC_CALL_READ_BLOCK |
744 				   RXRPC_CALL_READ_ALL);
745 	if (ret < 0) {
746 		if (ret == -ECONNABORTED) {
747 			ret = call->app_errno;
748 			goto out_unwait;
749 		}
750 		goto abort;
751 	}
752 
753 	/* unmarshall the reply */
754 	fid->vid		= ntohl(*bp++);
755 	fid->vnode		= ntohl(*bp++);
756 	fid->unique		= ntohl(*bp++);
757 
758 	vnode->status.if_version	= ntohl(*bp++);
759 	vnode->status.type		= ntohl(*bp++);
760 	vnode->status.nlink		= ntohl(*bp++);
761 	vnode->status.size		= ntohl(*bp++);
762 	vnode->status.version		= ntohl(*bp++);
763 	vnode->status.author		= ntohl(*bp++);
764 	vnode->status.owner		= ntohl(*bp++);
765 	vnode->status.caller_access	= ntohl(*bp++);
766 	vnode->status.anon_access	= ntohl(*bp++);
767 	vnode->status.mode		= ntohl(*bp++);
768 	vnode->status.parent.vid	= dirfid->vid;
769 	vnode->status.parent.vnode	= ntohl(*bp++);
770 	vnode->status.parent.unique	= ntohl(*bp++);
771 	bp++; /* seg size */
772 	vnode->status.mtime_client	= ntohl(*bp++);
773 	vnode->status.mtime_server	= ntohl(*bp++);
774 	bp++; /* group */
775 	bp++; /* sync counter */
776 	vnode->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
777 	bp++; /* spare2 */
778 	bp++; /* spare3 */
779 	bp++; /* spare4 */
780 
781 	dir->status.if_version		= ntohl(*bp++);
782 	dir->status.type		= ntohl(*bp++);
783 	dir->status.nlink		= ntohl(*bp++);
784 	dir->status.size		= ntohl(*bp++);
785 	dir->status.version		= ntohl(*bp++);
786 	dir->status.author		= ntohl(*bp++);
787 	dir->status.owner		= ntohl(*bp++);
788 	dir->status.caller_access	= ntohl(*bp++);
789 	dir->status.anon_access		= ntohl(*bp++);
790 	dir->status.mode		= ntohl(*bp++);
791 	dir->status.parent.vid		= dirfid->vid;
792 	dir->status.parent.vnode	= ntohl(*bp++);
793 	dir->status.parent.unique	= ntohl(*bp++);
794 	bp++; /* seg size */
795 	dir->status.mtime_client	= ntohl(*bp++);
796 	dir->status.mtime_server	= ntohl(*bp++);
797 	bp++; /* group */
798 	bp++; /* sync counter */
799 	dir->status.version |= ((unsigned long long) ntohl(*bp++)) << 32;
800 	bp++; /* spare2 */
801 	bp++; /* spare3 */
802 	bp++; /* spare4 */
803 
804 	callback->fid		= *fid;
805 	callback->version	= ntohl(*bp++);
806 	callback->expiry	= ntohl(*bp++);
807 	callback->type		= ntohl(*bp++);
808 
809 	if (volsync) {
810 		volsync->creation	= ntohl(*bp++);
811 		bp++; /* spare2 */
812 		bp++; /* spare3 */
813 		bp++; /* spare4 */
814 		bp++; /* spare5 */
815 		bp++; /* spare6 */
816 	}
817 
818 	/* success */
819 	ret = 0;
820 
821  out_unwait:
822 	set_current_state(TASK_RUNNING);
823 	remove_wait_queue(&call->waitq, &myself);
824 	rxrpc_put_call(call);
825  out_put_conn:
826 	afs_server_release_fsconn(server, conn);
827  out:
828 	kleave("");
829 	return ret;
830 
831  abort:
832 	set_current_state(TASK_UNINTERRUPTIBLE);
833 	rxrpc_call_abort(call, ret);
834 	schedule();
835 	goto out_unwait;
836 } /* end afs_rxfs_lookup() */
837 #endif
838