1 /* AFS Volume Location Service client
3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
12 #include <linux/gfp.h>
13 #include <linux/init.h>
14 #include <linux/sched.h>
19 * Deliver reply data to a VL.GetEntryByNameU call.
21 static int afs_deliver_vl_get_entry_by_name_u(struct afs_call
*call
)
23 struct afs_uvldbentry__xdr
*uvldb
;
24 struct afs_vldb_entry
*entry
;
25 bool new_only
= false;
26 u32 tmp
, nr_servers
, vlflags
;
31 ret
= afs_transfer_reply(call
);
35 /* unmarshall the reply once we've received all of it */
37 entry
= call
->reply
[0];
39 nr_servers
= ntohl(uvldb
->nServers
);
40 if (nr_servers
> AFS_NMAXNSERVERS
)
41 nr_servers
= AFS_NMAXNSERVERS
;
43 for (i
= 0; i
< ARRAY_SIZE(uvldb
->name
) - 1; i
++)
44 entry
->name
[i
] = (u8
)ntohl(uvldb
->name
[i
]);
46 entry
->name_len
= strlen(entry
->name
);
48 /* If there is a new replication site that we can use, ignore all the
49 * sites that aren't marked as new.
51 for (i
= 0; i
< nr_servers
; i
++) {
52 tmp
= ntohl(uvldb
->serverFlags
[i
]);
53 if (!(tmp
& AFS_VLSF_DONTUSE
) &&
54 (tmp
& AFS_VLSF_NEWREPSITE
))
58 vlflags
= ntohl(uvldb
->flags
);
59 for (i
= 0; i
< nr_servers
; i
++) {
60 struct afs_uuid__xdr
*xdr
;
61 struct afs_uuid
*uuid
;
64 tmp
= ntohl(uvldb
->serverFlags
[i
]);
65 if (tmp
& AFS_VLSF_DONTUSE
||
66 (new_only
&& !(tmp
& AFS_VLSF_NEWREPSITE
)))
68 if (tmp
& AFS_VLSF_RWVOL
) {
69 entry
->fs_mask
[i
] |= AFS_VOL_VTM_RW
;
70 if (vlflags
& AFS_VLF_BACKEXISTS
)
71 entry
->fs_mask
[i
] |= AFS_VOL_VTM_BAK
;
73 if (tmp
& AFS_VLSF_ROVOL
)
74 entry
->fs_mask
[i
] |= AFS_VOL_VTM_RO
;
75 if (!entry
->fs_mask
[i
])
78 xdr
= &uvldb
->serverNumber
[i
];
79 uuid
= (struct afs_uuid
*)&entry
->fs_server
[i
];
80 uuid
->time_low
= xdr
->time_low
;
81 uuid
->time_mid
= htons(ntohl(xdr
->time_mid
));
82 uuid
->time_hi_and_version
= htons(ntohl(xdr
->time_hi_and_version
));
83 uuid
->clock_seq_hi_and_reserved
= (u8
)ntohl(xdr
->clock_seq_hi_and_reserved
);
84 uuid
->clock_seq_low
= (u8
)ntohl(xdr
->clock_seq_low
);
85 for (j
= 0; j
< 6; j
++)
86 uuid
->node
[j
] = (u8
)ntohl(xdr
->node
[j
]);
91 for (i
= 0; i
< AFS_MAXTYPES
; i
++)
92 entry
->vid
[i
] = ntohl(uvldb
->volumeId
[i
]);
94 if (vlflags
& AFS_VLF_RWEXISTS
)
95 __set_bit(AFS_VLDB_HAS_RW
, &entry
->flags
);
96 if (vlflags
& AFS_VLF_ROEXISTS
)
97 __set_bit(AFS_VLDB_HAS_RO
, &entry
->flags
);
98 if (vlflags
& AFS_VLF_BACKEXISTS
)
99 __set_bit(AFS_VLDB_HAS_BAK
, &entry
->flags
);
101 if (!(vlflags
& (AFS_VLF_RWEXISTS
| AFS_VLF_ROEXISTS
| AFS_VLF_BACKEXISTS
))) {
102 entry
->error
= -ENOMEDIUM
;
103 __set_bit(AFS_VLDB_QUERY_ERROR
, &entry
->flags
);
106 __set_bit(AFS_VLDB_QUERY_VALID
, &entry
->flags
);
107 _leave(" = 0 [done]");
111 static void afs_destroy_vl_get_entry_by_name_u(struct afs_call
*call
)
113 kfree(call
->reply
[0]);
114 afs_flat_call_destructor(call
);
118 * VL.GetEntryByNameU operation type.
120 static const struct afs_call_type afs_RXVLGetEntryByNameU
= {
121 .name
= "VL.GetEntryByNameU",
122 .op
= afs_VL_GetEntryByNameU
,
123 .deliver
= afs_deliver_vl_get_entry_by_name_u
,
124 .destructor
= afs_destroy_vl_get_entry_by_name_u
,
128 * Dispatch a get volume entry by name or ID operation (uuid variant). If the
129 * volname is a decimal number then it's a volume ID not a volume name.
131 struct afs_vldb_entry
*afs_vl_get_entry_by_name_u(struct afs_vl_cursor
*vc
,
135 struct afs_vldb_entry
*entry
;
136 struct afs_call
*call
;
137 struct afs_net
*net
= vc
->cell
->net
;
143 padsz
= (4 - (volnamesz
& 3)) & 3;
144 reqsz
= 8 + volnamesz
+ padsz
;
146 entry
= kzalloc(sizeof(struct afs_vldb_entry
), GFP_KERNEL
);
148 return ERR_PTR(-ENOMEM
);
150 call
= afs_alloc_flat_call(net
, &afs_RXVLGetEntryByNameU
, reqsz
,
151 sizeof(struct afs_uvldbentry__xdr
));
154 return ERR_PTR(-ENOMEM
);
158 call
->reply
[0] = entry
;
159 call
->ret_reply0
= true;
161 /* Marshall the parameters */
163 *bp
++ = htonl(VLGETENTRYBYNAMEU
);
164 *bp
++ = htonl(volnamesz
);
165 memcpy(bp
, volname
, volnamesz
);
167 memset((void *)bp
+ volnamesz
, 0, padsz
);
169 trace_afs_make_vl_call(call
);
170 return (struct afs_vldb_entry
*)afs_make_call(&vc
->ac
, call
, GFP_KERNEL
, false);
174 * Deliver reply data to a VL.GetAddrsU call.
176 * GetAddrsU(IN ListAddrByAttributes *inaddr,
177 * OUT afsUUID *uuidp1,
178 * OUT uint32_t *uniquifier,
179 * OUT uint32_t *nentries,
180 * OUT bulkaddrs *blkaddrs);
182 static int afs_deliver_vl_get_addrs_u(struct afs_call
*call
)
184 struct afs_addr_list
*alist
;
186 u32 uniquifier
, nentries
, count
;
189 _enter("{%u,%zu/%u}",
190 call
->unmarshall
, iov_iter_count(call
->_iter
), call
->count
);
192 switch (call
->unmarshall
) {
194 afs_extract_to_buf(call
,
195 sizeof(struct afs_uuid__xdr
) + 3 * sizeof(__be32
));
198 /* Extract the returned uuid, uniquifier, nentries and blkaddrs size */
200 ret
= afs_extract_data(call
, true);
204 bp
= call
->buffer
+ sizeof(struct afs_uuid__xdr
);
205 uniquifier
= ntohl(*bp
++);
206 nentries
= ntohl(*bp
++);
209 nentries
= min(nentries
, count
);
210 alist
= afs_alloc_addrlist(nentries
, FS_SERVICE
, AFS_FS_PORT
);
213 alist
->version
= uniquifier
;
214 call
->reply
[0] = alist
;
216 call
->count2
= nentries
;
220 count
= min(call
->count
, 4U);
221 afs_extract_to_buf(call
, count
* sizeof(__be32
));
223 /* Extract entries */
225 ret
= afs_extract_data(call
, call
->count
> 4);
229 alist
= call
->reply
[0];
231 count
= min(call
->count
, 4U);
232 for (i
= 0; i
< count
; i
++)
233 if (alist
->nr_addrs
< call
->count2
)
234 afs_merge_fs_addr4(alist
, *bp
++, AFS_FS_PORT
);
236 call
->count
-= count
;
243 _leave(" = 0 [done]");
247 static void afs_vl_get_addrs_u_destructor(struct afs_call
*call
)
249 afs_put_server(call
->net
, (struct afs_server
*)call
->reply
[0]);
250 kfree(call
->reply
[1]);
251 return afs_flat_call_destructor(call
);
255 * VL.GetAddrsU operation type.
257 static const struct afs_call_type afs_RXVLGetAddrsU
= {
258 .name
= "VL.GetAddrsU",
259 .op
= afs_VL_GetAddrsU
,
260 .deliver
= afs_deliver_vl_get_addrs_u
,
261 .destructor
= afs_vl_get_addrs_u_destructor
,
265 * Dispatch an operation to get the addresses for a server, where the server is
268 struct afs_addr_list
*afs_vl_get_addrs_u(struct afs_vl_cursor
*vc
,
271 struct afs_ListAddrByAttributes__xdr
*r
;
272 const struct afs_uuid
*u
= (const struct afs_uuid
*)uuid
;
273 struct afs_call
*call
;
274 struct afs_net
*net
= vc
->cell
->net
;
280 call
= afs_alloc_flat_call(net
, &afs_RXVLGetAddrsU
,
281 sizeof(__be32
) + sizeof(struct afs_ListAddrByAttributes__xdr
),
282 sizeof(struct afs_uuid__xdr
) + 3 * sizeof(__be32
));
284 return ERR_PTR(-ENOMEM
);
287 call
->reply
[0] = NULL
;
288 call
->ret_reply0
= true;
290 /* Marshall the parameters */
292 *bp
++ = htonl(VLGETADDRSU
);
293 r
= (struct afs_ListAddrByAttributes__xdr
*)bp
;
294 r
->Mask
= htonl(AFS_VLADDR_UUID
);
298 r
->uuid
.time_low
= u
->time_low
;
299 r
->uuid
.time_mid
= htonl(ntohs(u
->time_mid
));
300 r
->uuid
.time_hi_and_version
= htonl(ntohs(u
->time_hi_and_version
));
301 r
->uuid
.clock_seq_hi_and_reserved
= htonl(u
->clock_seq_hi_and_reserved
);
302 r
->uuid
.clock_seq_low
= htonl(u
->clock_seq_low
);
303 for (i
= 0; i
< 6; i
++)
304 r
->uuid
.node
[i
] = htonl(u
->node
[i
]);
306 trace_afs_make_vl_call(call
);
307 return (struct afs_addr_list
*)afs_make_call(&vc
->ac
, call
, GFP_KERNEL
, false);
311 * Deliver reply data to an VL.GetCapabilities operation.
313 static int afs_deliver_vl_get_capabilities(struct afs_call
*call
)
318 _enter("{%u,%zu/%u}",
319 call
->unmarshall
, iov_iter_count(call
->_iter
), call
->count
);
321 switch (call
->unmarshall
) {
323 afs_extract_to_tmp(call
);
326 /* Extract the capabilities word count */
328 ret
= afs_extract_data(call
, true);
332 count
= ntohl(call
->tmp
);
334 call
->count2
= count
;
337 afs_extract_discard(call
, count
* sizeof(__be32
));
339 /* Extract capabilities words */
341 ret
= afs_extract_data(call
, false);
345 /* TODO: Examine capabilities */
351 _leave(" = 0 [done]");
355 static void afs_destroy_vl_get_capabilities(struct afs_call
*call
)
357 struct afs_vlserver
*server
= call
->reply
[0];
359 afs_put_vlserver(call
->net
, server
);
360 afs_flat_call_destructor(call
);
364 * VL.GetCapabilities operation type
366 static const struct afs_call_type afs_RXVLGetCapabilities
= {
367 .name
= "VL.GetCapabilities",
368 .op
= afs_VL_GetCapabilities
,
369 .deliver
= afs_deliver_vl_get_capabilities
,
370 .done
= afs_vlserver_probe_result
,
371 .destructor
= afs_destroy_vl_get_capabilities
,
375 * Probe a volume server for the capabilities that it supports. This can
376 * return up to 196 words.
378 * We use this to probe for service upgrade to determine what the server at the
379 * other end supports.
381 int afs_vl_get_capabilities(struct afs_net
*net
,
382 struct afs_addr_cursor
*ac
,
384 struct afs_vlserver
*server
,
385 unsigned int server_index
,
388 struct afs_call
*call
;
393 call
= afs_alloc_flat_call(net
, &afs_RXVLGetCapabilities
, 1 * 4, 16 * 4);
398 call
->reply
[0] = afs_get_vlserver(server
);
399 call
->reply
[1] = (void *)(long)server_index
;
400 call
->upgrade
= true;
401 call
->want_reply_time
= true;
403 /* marshall the parameters */
405 *bp
++ = htonl(VLGETCAPABILITIES
);
407 /* Can't take a ref on server */
408 trace_afs_make_vl_call(call
);
409 return afs_make_call(ac
, call
, GFP_KERNEL
, async
);
413 * Deliver reply data to a YFSVL.GetEndpoints call.
415 * GetEndpoints(IN yfsServerAttributes *attr,
416 * OUT opr_uuid *uuid,
417 * OUT afs_int32 *uniquifier,
418 * OUT endpoints *fsEndpoints,
419 * OUT endpoints *volEndpoints)
421 static int afs_deliver_yfsvl_get_endpoints(struct afs_call
*call
)
423 struct afs_addr_list
*alist
;
425 u32 uniquifier
, size
;
428 _enter("{%u,%zu,%u}",
429 call
->unmarshall
, iov_iter_count(call
->_iter
), call
->count2
);
431 switch (call
->unmarshall
) {
433 afs_extract_to_buf(call
, sizeof(uuid_t
) + 3 * sizeof(__be32
));
434 call
->unmarshall
= 1;
436 /* Extract the returned uuid, uniquifier, fsEndpoints count and
437 * either the first fsEndpoint type or the volEndpoints
438 * count if there are no fsEndpoints. */
440 ret
= afs_extract_data(call
, true);
444 bp
= call
->buffer
+ sizeof(uuid_t
);
445 uniquifier
= ntohl(*bp
++);
446 call
->count
= ntohl(*bp
++);
447 call
->count2
= ntohl(*bp
); /* Type or next count */
449 if (call
->count
> YFS_MAXENDPOINTS
)
450 return afs_protocol_error(call
, -EBADMSG
,
451 afs_eproto_yvl_fsendpt_num
);
453 alist
= afs_alloc_addrlist(call
->count
, FS_SERVICE
, AFS_FS_PORT
);
456 alist
->version
= uniquifier
;
457 call
->reply
[0] = alist
;
459 if (call
->count
== 0)
460 goto extract_volendpoints
;
463 switch (call
->count2
) {
464 case YFS_ENDPOINT_IPV4
:
465 size
= sizeof(__be32
) * (1 + 1 + 1);
467 case YFS_ENDPOINT_IPV6
:
468 size
= sizeof(__be32
) * (1 + 4 + 1);
471 return afs_protocol_error(call
, -EBADMSG
,
472 afs_eproto_yvl_fsendpt_type
);
475 size
+= sizeof(__be32
);
476 afs_extract_to_buf(call
, size
);
477 call
->unmarshall
= 2;
479 /* Extract fsEndpoints[] entries */
481 ret
= afs_extract_data(call
, true);
485 alist
= call
->reply
[0];
487 switch (call
->count2
) {
488 case YFS_ENDPOINT_IPV4
:
489 if (ntohl(bp
[0]) != sizeof(__be32
) * 2)
490 return afs_protocol_error(call
, -EBADMSG
,
491 afs_eproto_yvl_fsendpt4_len
);
492 afs_merge_fs_addr4(alist
, bp
[1], ntohl(bp
[2]));
495 case YFS_ENDPOINT_IPV6
:
496 if (ntohl(bp
[0]) != sizeof(__be32
) * 5)
497 return afs_protocol_error(call
, -EBADMSG
,
498 afs_eproto_yvl_fsendpt6_len
);
499 afs_merge_fs_addr6(alist
, bp
+ 1, ntohl(bp
[5]));
503 return afs_protocol_error(call
, -EBADMSG
,
504 afs_eproto_yvl_fsendpt_type
);
507 /* Got either the type of the next entry or the count of
508 * volEndpoints if no more fsEndpoints.
510 call
->count2
= ntohl(*bp
++);
514 goto next_fsendpoint
;
516 extract_volendpoints
:
517 /* Extract the list of volEndpoints. */
518 call
->count
= call
->count2
;
521 if (call
->count
> YFS_MAXENDPOINTS
)
522 return afs_protocol_error(call
, -EBADMSG
,
523 afs_eproto_yvl_vlendpt_type
);
525 afs_extract_to_buf(call
, 1 * sizeof(__be32
));
526 call
->unmarshall
= 3;
528 /* Extract the type of volEndpoints[0]. Normally we would
529 * extract the type of the next endpoint when we extract the
530 * data of the current one, but this is the first...
533 ret
= afs_extract_data(call
, true);
540 call
->count2
= ntohl(*bp
++);
541 switch (call
->count2
) {
542 case YFS_ENDPOINT_IPV4
:
543 size
= sizeof(__be32
) * (1 + 1 + 1);
545 case YFS_ENDPOINT_IPV6
:
546 size
= sizeof(__be32
) * (1 + 4 + 1);
549 return afs_protocol_error(call
, -EBADMSG
,
550 afs_eproto_yvl_vlendpt_type
);
554 size
+= sizeof(__be32
); /* Get next type too */
555 afs_extract_to_buf(call
, size
);
556 call
->unmarshall
= 4;
558 /* Extract volEndpoints[] entries */
560 ret
= afs_extract_data(call
, true);
565 switch (call
->count2
) {
566 case YFS_ENDPOINT_IPV4
:
567 if (ntohl(bp
[0]) != sizeof(__be32
) * 2)
568 return afs_protocol_error(call
, -EBADMSG
,
569 afs_eproto_yvl_vlendpt4_len
);
572 case YFS_ENDPOINT_IPV6
:
573 if (ntohl(bp
[0]) != sizeof(__be32
) * 5)
574 return afs_protocol_error(call
, -EBADMSG
,
575 afs_eproto_yvl_vlendpt6_len
);
579 return afs_protocol_error(call
, -EBADMSG
,
580 afs_eproto_yvl_vlendpt_type
);
583 /* Got either the type of the next entry or the count of
584 * volEndpoints if no more fsEndpoints.
588 goto next_volendpoint
;
591 afs_extract_discard(call
, 0);
592 call
->unmarshall
= 5;
596 ret
= afs_extract_data(call
, false);
599 call
->unmarshall
= 6;
605 alist
= call
->reply
[0];
606 _leave(" = 0 [done]");
611 * YFSVL.GetEndpoints operation type.
613 static const struct afs_call_type afs_YFSVLGetEndpoints
= {
614 .name
= "YFSVL.GetEndpoints",
615 .op
= afs_YFSVL_GetEndpoints
,
616 .deliver
= afs_deliver_yfsvl_get_endpoints
,
617 .destructor
= afs_vl_get_addrs_u_destructor
,
621 * Dispatch an operation to get the addresses for a server, where the server is
624 struct afs_addr_list
*afs_yfsvl_get_endpoints(struct afs_vl_cursor
*vc
,
627 struct afs_call
*call
;
628 struct afs_net
*net
= vc
->cell
->net
;
633 call
= afs_alloc_flat_call(net
, &afs_YFSVLGetEndpoints
,
634 sizeof(__be32
) * 2 + sizeof(*uuid
),
635 sizeof(struct in6_addr
) + sizeof(__be32
) * 3);
637 return ERR_PTR(-ENOMEM
);
640 call
->reply
[0] = NULL
;
641 call
->ret_reply0
= true;
643 /* Marshall the parameters */
645 *bp
++ = htonl(YVLGETENDPOINTS
);
646 *bp
++ = htonl(YFS_SERVER_UUID
);
647 memcpy(bp
, uuid
, sizeof(*uuid
)); /* Type opr_uuid */
649 trace_afs_make_vl_call(call
);
650 return (struct afs_addr_list
*)afs_make_call(&vc
->ac
, call
, GFP_KERNEL
, false);