Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* AFS Volume Location Service client
3 *
4 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8#include <linux/gfp.h>
9#include <linux/init.h>
10#include <linux/sched.h>
11#include "afs_fs.h"
12#include "internal.h"
13
14/*
15 * Deliver reply data to a VL.GetEntryByNameU call.
16 */
17static int afs_deliver_vl_get_entry_by_name_u(struct afs_call *call)
18{
19 struct afs_uvldbentry__xdr *uvldb;
20 struct afs_vldb_entry *entry;
21 u32 nr_servers, vlflags;
22 int i, ret;
23
24 _enter("");
25
26 ret = afs_transfer_reply(call);
27 if (ret < 0)
28 return ret;
29
30 /* unmarshall the reply once we've received all of it */
31 uvldb = call->buffer;
32 entry = call->ret_vldb;
33
34 nr_servers = ntohl(uvldb->nServers);
35 if (nr_servers > AFS_NMAXNSERVERS)
36 nr_servers = AFS_NMAXNSERVERS;
37
38 for (i = 0; i < ARRAY_SIZE(uvldb->name) - 1; i++)
39 entry->name[i] = (u8)ntohl(uvldb->name[i]);
40 entry->name[i] = 0;
41 entry->name_len = strlen(entry->name);
42
43 vlflags = ntohl(uvldb->flags);
44 for (i = 0; i < nr_servers; i++) {
45 struct afs_uuid__xdr *xdr;
46 struct afs_uuid *uuid;
47 u32 tmp = ntohl(uvldb->serverFlags[i]);
48 int j;
49 int n = entry->nr_servers;
50
51 if (tmp & AFS_VLSF_RWVOL) {
52 entry->fs_mask[n] |= AFS_VOL_VTM_RW;
53 if (vlflags & AFS_VLF_BACKEXISTS)
54 entry->fs_mask[n] |= AFS_VOL_VTM_BAK;
55 }
56 if (tmp & AFS_VLSF_ROVOL)
57 entry->fs_mask[n] |= AFS_VOL_VTM_RO;
58 if (!entry->fs_mask[n])
59 continue;
60
61 xdr = &uvldb->serverNumber[i];
62 uuid = (struct afs_uuid *)&entry->fs_server[n];
63 uuid->time_low = xdr->time_low;
64 uuid->time_mid = htons(ntohl(xdr->time_mid));
65 uuid->time_hi_and_version = htons(ntohl(xdr->time_hi_and_version));
66 uuid->clock_seq_hi_and_reserved = (u8)ntohl(xdr->clock_seq_hi_and_reserved);
67 uuid->clock_seq_low = (u8)ntohl(xdr->clock_seq_low);
68 for (j = 0; j < 6; j++)
69 uuid->node[j] = (u8)ntohl(xdr->node[j]);
70
71 entry->vlsf_flags[n] = tmp;
72 entry->addr_version[n] = ntohl(uvldb->serverUnique[i]);
73 entry->nr_servers++;
74 }
75
76 for (i = 0; i < AFS_MAXTYPES; i++)
77 entry->vid[i] = ntohl(uvldb->volumeId[i]);
78
79 if (vlflags & AFS_VLF_RWEXISTS)
80 __set_bit(AFS_VLDB_HAS_RW, &entry->flags);
81 if (vlflags & AFS_VLF_ROEXISTS)
82 __set_bit(AFS_VLDB_HAS_RO, &entry->flags);
83 if (vlflags & AFS_VLF_BACKEXISTS)
84 __set_bit(AFS_VLDB_HAS_BAK, &entry->flags);
85
86 if (!(vlflags & (AFS_VLF_RWEXISTS | AFS_VLF_ROEXISTS | AFS_VLF_BACKEXISTS))) {
87 entry->error = -ENOMEDIUM;
88 __set_bit(AFS_VLDB_QUERY_ERROR, &entry->flags);
89 }
90
91 __set_bit(AFS_VLDB_QUERY_VALID, &entry->flags);
92 _leave(" = 0 [done]");
93 return 0;
94}
95
96/*
97 * VL.GetEntryByNameU operation type.
98 */
99static const struct afs_call_type afs_RXVLGetEntryByNameU = {
100 .name = "VL.GetEntryByNameU",
101 .op = afs_VL_GetEntryByNameU,
102 .deliver = afs_deliver_vl_get_entry_by_name_u,
103 .destructor = afs_flat_call_destructor,
104};
105
106/*
107 * Dispatch a get volume entry by name or ID operation (uuid variant). If the
108 * volname is a decimal number then it's a volume ID not a volume name.
109 */
110struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *vc,
111 const char *volname,
112 int volnamesz)
113{
114 struct afs_vldb_entry *entry;
115 struct afs_call *call;
116 struct afs_net *net = vc->cell->net;
117 size_t reqsz, padsz;
118 __be32 *bp;
119
120 _enter("");
121
122 padsz = (4 - (volnamesz & 3)) & 3;
123 reqsz = 8 + volnamesz + padsz;
124
125 entry = kzalloc(sizeof(struct afs_vldb_entry), GFP_KERNEL);
126 if (!entry)
127 return ERR_PTR(-ENOMEM);
128
129 call = afs_alloc_flat_call(net, &afs_RXVLGetEntryByNameU, reqsz,
130 sizeof(struct afs_uvldbentry__xdr));
131 if (!call) {
132 kfree(entry);
133 return ERR_PTR(-ENOMEM);
134 }
135
136 call->key = vc->key;
137 call->ret_vldb = entry;
138 call->max_lifespan = AFS_VL_MAX_LIFESPAN;
139 call->peer = rxrpc_kernel_get_peer(vc->alist->addrs[vc->addr_index].peer);
140 call->service_id = vc->server->service_id;
141
142 /* Marshall the parameters */
143 bp = call->request;
144 *bp++ = htonl(VLGETENTRYBYNAMEU);
145 *bp++ = htonl(volnamesz);
146 memcpy(bp, volname, volnamesz);
147 if (padsz > 0)
148 memset((void *)bp + volnamesz, 0, padsz);
149
150 trace_afs_make_vl_call(call);
151 afs_make_call(call, GFP_KERNEL);
152 afs_wait_for_call_to_complete(call);
153 vc->call_abort_code = call->abort_code;
154 vc->call_error = call->error;
155 vc->call_responded = call->responded;
156 afs_put_call(call);
157 if (vc->call_error) {
158 kfree(entry);
159 return ERR_PTR(vc->call_error);
160 }
161 return entry;
162}
163
164/*
165 * Deliver reply data to a VL.GetAddrsU call.
166 *
167 * GetAddrsU(IN ListAddrByAttributes *inaddr,
168 * OUT afsUUID *uuidp1,
169 * OUT uint32_t *uniquifier,
170 * OUT uint32_t *nentries,
171 * OUT bulkaddrs *blkaddrs);
172 */
173static int afs_deliver_vl_get_addrs_u(struct afs_call *call)
174{
175 struct afs_addr_list *alist;
176 __be32 *bp;
177 u32 uniquifier, nentries, count;
178 int i, ret;
179
180 _enter("{%u,%zu/%u}",
181 call->unmarshall, iov_iter_count(call->iter), call->count);
182
183 switch (call->unmarshall) {
184 case 0:
185 afs_extract_to_buf(call,
186 sizeof(struct afs_uuid__xdr) + 3 * sizeof(__be32));
187 call->unmarshall++;
188
189 /* Extract the returned uuid, uniquifier, nentries and
190 * blkaddrs size */
191 fallthrough;
192 case 1:
193 ret = afs_extract_data(call, true);
194 if (ret < 0)
195 return ret;
196
197 bp = call->buffer + sizeof(struct afs_uuid__xdr);
198 uniquifier = ntohl(*bp++);
199 nentries = ntohl(*bp++);
200 count = ntohl(*bp);
201
202 nentries = min(nentries, count);
203 alist = afs_alloc_addrlist(nentries);
204 if (!alist)
205 return -ENOMEM;
206 alist->version = uniquifier;
207 call->ret_alist = alist;
208 call->count = count;
209 call->count2 = nentries;
210 call->unmarshall++;
211
212 more_entries:
213 count = min(call->count, 4U);
214 afs_extract_to_buf(call, count * sizeof(__be32));
215
216 fallthrough; /* and extract entries */
217 case 2:
218 ret = afs_extract_data(call, call->count > 4);
219 if (ret < 0)
220 return ret;
221
222 alist = call->ret_alist;
223 bp = call->buffer;
224 count = min(call->count, 4U);
225 for (i = 0; i < count; i++) {
226 if (alist->nr_addrs < call->count2) {
227 ret = afs_merge_fs_addr4(call->net, alist, *bp++, AFS_FS_PORT);
228 if (ret < 0)
229 return ret;
230 }
231 }
232
233 call->count -= count;
234 if (call->count > 0)
235 goto more_entries;
236 call->unmarshall++;
237 break;
238 }
239
240 _leave(" = 0 [done]");
241 return 0;
242}
243
244/*
245 * VL.GetAddrsU operation type.
246 */
247static const struct afs_call_type afs_RXVLGetAddrsU = {
248 .name = "VL.GetAddrsU",
249 .op = afs_VL_GetAddrsU,
250 .deliver = afs_deliver_vl_get_addrs_u,
251 .destructor = afs_flat_call_destructor,
252};
253
254/*
255 * Dispatch an operation to get the addresses for a server, where the server is
256 * nominated by UUID.
257 */
258struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *vc,
259 const uuid_t *uuid)
260{
261 struct afs_ListAddrByAttributes__xdr *r;
262 struct afs_addr_list *alist;
263 const struct afs_uuid *u = (const struct afs_uuid *)uuid;
264 struct afs_call *call;
265 struct afs_net *net = vc->cell->net;
266 __be32 *bp;
267 int i;
268
269 _enter("");
270
271 call = afs_alloc_flat_call(net, &afs_RXVLGetAddrsU,
272 sizeof(__be32) + sizeof(struct afs_ListAddrByAttributes__xdr),
273 sizeof(struct afs_uuid__xdr) + 3 * sizeof(__be32));
274 if (!call)
275 return ERR_PTR(-ENOMEM);
276
277 call->key = vc->key;
278 call->ret_alist = NULL;
279 call->max_lifespan = AFS_VL_MAX_LIFESPAN;
280 call->peer = rxrpc_kernel_get_peer(vc->alist->addrs[vc->addr_index].peer);
281 call->service_id = vc->server->service_id;
282
283 /* Marshall the parameters */
284 bp = call->request;
285 *bp++ = htonl(VLGETADDRSU);
286 r = (struct afs_ListAddrByAttributes__xdr *)bp;
287 r->Mask = htonl(AFS_VLADDR_UUID);
288 r->ipaddr = 0;
289 r->index = 0;
290 r->spare = 0;
291 r->uuid.time_low = u->time_low;
292 r->uuid.time_mid = htonl(ntohs(u->time_mid));
293 r->uuid.time_hi_and_version = htonl(ntohs(u->time_hi_and_version));
294 r->uuid.clock_seq_hi_and_reserved = htonl(u->clock_seq_hi_and_reserved);
295 r->uuid.clock_seq_low = htonl(u->clock_seq_low);
296 for (i = 0; i < 6; i++)
297 r->uuid.node[i] = htonl(u->node[i]);
298
299 trace_afs_make_vl_call(call);
300 afs_make_call(call, GFP_KERNEL);
301 afs_wait_for_call_to_complete(call);
302 vc->call_abort_code = call->abort_code;
303 vc->call_error = call->error;
304 vc->call_responded = call->responded;
305 alist = call->ret_alist;
306 afs_put_call(call);
307 if (vc->call_error) {
308 afs_put_addrlist(alist, afs_alist_trace_put_getaddru);
309 return ERR_PTR(vc->call_error);
310 }
311 return alist;
312}
313
314/*
315 * Deliver reply data to an VL.GetCapabilities operation.
316 */
317static int afs_deliver_vl_get_capabilities(struct afs_call *call)
318{
319 u32 count;
320 int ret;
321
322 _enter("{%u,%zu/%u}",
323 call->unmarshall, iov_iter_count(call->iter), call->count);
324
325 switch (call->unmarshall) {
326 case 0:
327 afs_extract_to_tmp(call);
328 call->unmarshall++;
329
330 fallthrough; /* and extract the capabilities word count */
331 case 1:
332 ret = afs_extract_data(call, true);
333 if (ret < 0)
334 return ret;
335
336 count = ntohl(call->tmp);
337 call->count = count;
338 call->count2 = count;
339
340 call->unmarshall++;
341 afs_extract_discard(call, count * sizeof(__be32));
342
343 fallthrough; /* and extract capabilities words */
344 case 2:
345 ret = afs_extract_data(call, false);
346 if (ret < 0)
347 return ret;
348
349 /* TODO: Examine capabilities */
350
351 call->unmarshall++;
352 break;
353 }
354
355 _leave(" = 0 [done]");
356 return 0;
357}
358
359static void afs_destroy_vl_get_capabilities(struct afs_call *call)
360{
361 afs_put_addrlist(call->vl_probe, afs_alist_trace_put_vlgetcaps);
362 afs_put_vlserver(call->net, call->vlserver);
363 afs_flat_call_destructor(call);
364}
365
366/*
367 * VL.GetCapabilities operation type
368 */
369static const struct afs_call_type afs_RXVLGetCapabilities = {
370 .name = "VL.GetCapabilities",
371 .op = afs_VL_GetCapabilities,
372 .deliver = afs_deliver_vl_get_capabilities,
373 .done = afs_vlserver_probe_result,
374 .destructor = afs_destroy_vl_get_capabilities,
375};
376
377/*
378 * Probe a volume server for the capabilities that it supports. This can
379 * return up to 196 words.
380 *
381 * We use this to probe for service upgrade to determine what the server at the
382 * other end supports.
383 */
384struct afs_call *afs_vl_get_capabilities(struct afs_net *net,
385 struct afs_addr_list *alist,
386 unsigned int addr_index,
387 struct key *key,
388 struct afs_vlserver *server,
389 unsigned int server_index)
390{
391 struct afs_call *call;
392 __be32 *bp;
393
394 _enter("");
395
396 call = afs_alloc_flat_call(net, &afs_RXVLGetCapabilities, 1 * 4, 16 * 4);
397 if (!call)
398 return ERR_PTR(-ENOMEM);
399
400 call->key = key;
401 call->vlserver = afs_get_vlserver(server);
402 call->server_index = server_index;
403 call->peer = rxrpc_kernel_get_peer(alist->addrs[addr_index].peer);
404 call->vl_probe = afs_get_addrlist(alist, afs_alist_trace_get_vlgetcaps);
405 call->probe_index = addr_index;
406 call->service_id = server->service_id;
407 call->upgrade = true;
408 call->async = true;
409 call->max_lifespan = AFS_PROBE_MAX_LIFESPAN;
410
411 /* marshall the parameters */
412 bp = call->request;
413 *bp++ = htonl(VLGETCAPABILITIES);
414
415 /* Can't take a ref on server */
416 trace_afs_make_vl_call(call);
417 afs_make_call(call, GFP_KERNEL);
418 return call;
419}
420
421/*
422 * Deliver reply data to a YFSVL.GetEndpoints call.
423 *
424 * GetEndpoints(IN yfsServerAttributes *attr,
425 * OUT opr_uuid *uuid,
426 * OUT afs_int32 *uniquifier,
427 * OUT endpoints *fsEndpoints,
428 * OUT endpoints *volEndpoints)
429 */
430static int afs_deliver_yfsvl_get_endpoints(struct afs_call *call)
431{
432 struct afs_addr_list *alist;
433 __be32 *bp;
434 u32 uniquifier, size;
435 int ret;
436
437 _enter("{%u,%zu,%u}",
438 call->unmarshall, iov_iter_count(call->iter), call->count2);
439
440 switch (call->unmarshall) {
441 case 0:
442 afs_extract_to_buf(call, sizeof(uuid_t) + 3 * sizeof(__be32));
443 call->unmarshall = 1;
444
445 /* Extract the returned uuid, uniquifier, fsEndpoints count and
446 * either the first fsEndpoint type or the volEndpoints
447 * count if there are no fsEndpoints. */
448 fallthrough;
449 case 1:
450 ret = afs_extract_data(call, true);
451 if (ret < 0)
452 return ret;
453
454 bp = call->buffer + sizeof(uuid_t);
455 uniquifier = ntohl(*bp++);
456 call->count = ntohl(*bp++);
457 call->count2 = ntohl(*bp); /* Type or next count */
458
459 if (call->count > YFS_MAXENDPOINTS)
460 return afs_protocol_error(call, afs_eproto_yvl_fsendpt_num);
461
462 alist = afs_alloc_addrlist(call->count);
463 if (!alist)
464 return -ENOMEM;
465 alist->version = uniquifier;
466 call->ret_alist = alist;
467
468 if (call->count == 0)
469 goto extract_volendpoints;
470
471 next_fsendpoint:
472 switch (call->count2) {
473 case YFS_ENDPOINT_IPV4:
474 size = sizeof(__be32) * (1 + 1 + 1);
475 break;
476 case YFS_ENDPOINT_IPV6:
477 size = sizeof(__be32) * (1 + 4 + 1);
478 break;
479 default:
480 return afs_protocol_error(call, afs_eproto_yvl_fsendpt_type);
481 }
482
483 size += sizeof(__be32);
484 afs_extract_to_buf(call, size);
485 call->unmarshall = 2;
486
487 fallthrough; /* and extract fsEndpoints[] entries */
488 case 2:
489 ret = afs_extract_data(call, true);
490 if (ret < 0)
491 return ret;
492
493 alist = call->ret_alist;
494 bp = call->buffer;
495 switch (call->count2) {
496 case YFS_ENDPOINT_IPV4:
497 if (ntohl(bp[0]) != sizeof(__be32) * 2)
498 return afs_protocol_error(
499 call, afs_eproto_yvl_fsendpt4_len);
500 ret = afs_merge_fs_addr4(call->net, alist, bp[1], ntohl(bp[2]));
501 if (ret < 0)
502 return ret;
503 bp += 3;
504 break;
505 case YFS_ENDPOINT_IPV6:
506 if (ntohl(bp[0]) != sizeof(__be32) * 5)
507 return afs_protocol_error(
508 call, afs_eproto_yvl_fsendpt6_len);
509 ret = afs_merge_fs_addr6(call->net, alist, bp + 1, ntohl(bp[5]));
510 if (ret < 0)
511 return ret;
512 bp += 6;
513 break;
514 default:
515 return afs_protocol_error(call, afs_eproto_yvl_fsendpt_type);
516 }
517
518 /* Got either the type of the next entry or the count of
519 * volEndpoints if no more fsEndpoints.
520 */
521 call->count2 = ntohl(*bp++);
522
523 call->count--;
524 if (call->count > 0)
525 goto next_fsendpoint;
526
527 extract_volendpoints:
528 /* Extract the list of volEndpoints. */
529 call->count = call->count2;
530 if (!call->count)
531 goto end;
532 if (call->count > YFS_MAXENDPOINTS)
533 return afs_protocol_error(call, afs_eproto_yvl_vlendpt_type);
534
535 afs_extract_to_buf(call, 1 * sizeof(__be32));
536 call->unmarshall = 3;
537
538 /* Extract the type of volEndpoints[0]. Normally we would
539 * extract the type of the next endpoint when we extract the
540 * data of the current one, but this is the first...
541 */
542 fallthrough;
543 case 3:
544 ret = afs_extract_data(call, true);
545 if (ret < 0)
546 return ret;
547
548 bp = call->buffer;
549
550 next_volendpoint:
551 call->count2 = ntohl(*bp++);
552 switch (call->count2) {
553 case YFS_ENDPOINT_IPV4:
554 size = sizeof(__be32) * (1 + 1 + 1);
555 break;
556 case YFS_ENDPOINT_IPV6:
557 size = sizeof(__be32) * (1 + 4 + 1);
558 break;
559 default:
560 return afs_protocol_error(call, afs_eproto_yvl_vlendpt_type);
561 }
562
563 if (call->count > 1)
564 size += sizeof(__be32); /* Get next type too */
565 afs_extract_to_buf(call, size);
566 call->unmarshall = 4;
567
568 fallthrough; /* and extract volEndpoints[] entries */
569 case 4:
570 ret = afs_extract_data(call, true);
571 if (ret < 0)
572 return ret;
573
574 bp = call->buffer;
575 switch (call->count2) {
576 case YFS_ENDPOINT_IPV4:
577 if (ntohl(bp[0]) != sizeof(__be32) * 2)
578 return afs_protocol_error(
579 call, afs_eproto_yvl_vlendpt4_len);
580 bp += 3;
581 break;
582 case YFS_ENDPOINT_IPV6:
583 if (ntohl(bp[0]) != sizeof(__be32) * 5)
584 return afs_protocol_error(
585 call, afs_eproto_yvl_vlendpt6_len);
586 bp += 6;
587 break;
588 default:
589 return afs_protocol_error(call, afs_eproto_yvl_vlendpt_type);
590 }
591
592 /* Got either the type of the next entry or the count of
593 * volEndpoints if no more fsEndpoints.
594 */
595 call->count--;
596 if (call->count > 0)
597 goto next_volendpoint;
598
599 end:
600 afs_extract_discard(call, 0);
601 call->unmarshall = 5;
602
603 fallthrough; /* Done */
604 case 5:
605 ret = afs_extract_data(call, false);
606 if (ret < 0)
607 return ret;
608 call->unmarshall = 6;
609 fallthrough;
610
611 case 6:
612 break;
613 }
614
615 _leave(" = 0 [done]");
616 return 0;
617}
618
619/*
620 * YFSVL.GetEndpoints operation type.
621 */
622static const struct afs_call_type afs_YFSVLGetEndpoints = {
623 .name = "YFSVL.GetEndpoints",
624 .op = afs_YFSVL_GetEndpoints,
625 .deliver = afs_deliver_yfsvl_get_endpoints,
626 .destructor = afs_flat_call_destructor,
627};
628
629/*
630 * Dispatch an operation to get the addresses for a server, where the server is
631 * nominated by UUID.
632 */
633struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *vc,
634 const uuid_t *uuid)
635{
636 struct afs_addr_list *alist;
637 struct afs_call *call;
638 struct afs_net *net = vc->cell->net;
639 __be32 *bp;
640
641 _enter("");
642
643 call = afs_alloc_flat_call(net, &afs_YFSVLGetEndpoints,
644 sizeof(__be32) * 2 + sizeof(*uuid),
645 sizeof(struct in6_addr) + sizeof(__be32) * 3);
646 if (!call)
647 return ERR_PTR(-ENOMEM);
648
649 call->key = vc->key;
650 call->ret_alist = NULL;
651 call->max_lifespan = AFS_VL_MAX_LIFESPAN;
652 call->peer = rxrpc_kernel_get_peer(vc->alist->addrs[vc->addr_index].peer);
653 call->service_id = vc->server->service_id;
654
655 /* Marshall the parameters */
656 bp = call->request;
657 *bp++ = htonl(YVLGETENDPOINTS);
658 *bp++ = htonl(YFS_SERVER_UUID);
659 memcpy(bp, uuid, sizeof(*uuid)); /* Type opr_uuid */
660
661 trace_afs_make_vl_call(call);
662 afs_make_call(call, GFP_KERNEL);
663 afs_wait_for_call_to_complete(call);
664 vc->call_abort_code = call->abort_code;
665 vc->call_error = call->error;
666 vc->call_responded = call->responded;
667 alist = call->ret_alist;
668 afs_put_call(call);
669 if (vc->call_error) {
670 afs_put_addrlist(alist, afs_alist_trace_put_getaddru);
671 return ERR_PTR(vc->call_error);
672 }
673 return alist;
674}
675
676/*
677 * Deliver reply data to a YFSVL.GetCellName operation.
678 */
679static int afs_deliver_yfsvl_get_cell_name(struct afs_call *call)
680{
681 char *cell_name;
682 u32 namesz, paddedsz;
683 int ret;
684
685 _enter("{%u,%zu/%u}",
686 call->unmarshall, iov_iter_count(call->iter), call->count);
687
688 switch (call->unmarshall) {
689 case 0:
690 afs_extract_to_tmp(call);
691 call->unmarshall++;
692
693 fallthrough; /* and extract the cell name length */
694 case 1:
695 ret = afs_extract_data(call, true);
696 if (ret < 0)
697 return ret;
698
699 namesz = ntohl(call->tmp);
700 if (namesz > YFS_VL_MAXCELLNAME)
701 return afs_protocol_error(call, afs_eproto_cellname_len);
702 paddedsz = (namesz + 3) & ~3;
703 call->count = namesz;
704 call->count2 = paddedsz - namesz;
705
706 cell_name = kmalloc(namesz + 1, GFP_KERNEL);
707 if (!cell_name)
708 return -ENOMEM;
709 cell_name[namesz] = 0;
710 call->ret_str = cell_name;
711
712 afs_extract_begin(call, cell_name, namesz);
713 call->unmarshall++;
714
715 fallthrough; /* and extract cell name */
716 case 2:
717 ret = afs_extract_data(call, true);
718 if (ret < 0)
719 return ret;
720
721 afs_extract_discard(call, call->count2);
722 call->unmarshall++;
723
724 fallthrough; /* and extract padding */
725 case 3:
726 ret = afs_extract_data(call, false);
727 if (ret < 0)
728 return ret;
729
730 call->unmarshall++;
731 break;
732 }
733
734 _leave(" = 0 [done]");
735 return 0;
736}
737
738/*
739 * VL.GetCapabilities operation type
740 */
741static const struct afs_call_type afs_YFSVLGetCellName = {
742 .name = "YFSVL.GetCellName",
743 .op = afs_YFSVL_GetCellName,
744 .deliver = afs_deliver_yfsvl_get_cell_name,
745 .destructor = afs_flat_call_destructor,
746};
747
748/*
749 * Probe a volume server for the capabilities that it supports. This can
750 * return up to 196 words.
751 *
752 * We use this to probe for service upgrade to determine what the server at the
753 * other end supports.
754 */
755char *afs_yfsvl_get_cell_name(struct afs_vl_cursor *vc)
756{
757 struct afs_call *call;
758 struct afs_net *net = vc->cell->net;
759 __be32 *bp;
760 char *cellname;
761
762 _enter("");
763
764 call = afs_alloc_flat_call(net, &afs_YFSVLGetCellName, 1 * 4, 0);
765 if (!call)
766 return ERR_PTR(-ENOMEM);
767
768 call->key = vc->key;
769 call->ret_str = NULL;
770 call->max_lifespan = AFS_VL_MAX_LIFESPAN;
771 call->peer = rxrpc_kernel_get_peer(vc->alist->addrs[vc->addr_index].peer);
772 call->service_id = vc->server->service_id;
773
774 /* marshall the parameters */
775 bp = call->request;
776 *bp++ = htonl(YVLGETCELLNAME);
777
778 /* Can't take a ref on server */
779 trace_afs_make_vl_call(call);
780 afs_make_call(call, GFP_KERNEL);
781 afs_wait_for_call_to_complete(call);
782 vc->call_abort_code = call->abort_code;
783 vc->call_error = call->error;
784 vc->call_responded = call->responded;
785 cellname = call->ret_str;
786 afs_put_call(call);
787 if (vc->call_error) {
788 kfree(cellname);
789 return ERR_PTR(vc->call_error);
790 }
791 return cellname;
792}
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* AFS Volume Location Service client
3 *
4 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8#include <linux/gfp.h>
9#include <linux/init.h>
10#include <linux/sched.h>
11#include "afs_fs.h"
12#include "internal.h"
13
14/*
15 * Deliver reply data to a VL.GetEntryByNameU call.
16 */
17static int afs_deliver_vl_get_entry_by_name_u(struct afs_call *call)
18{
19 struct afs_uvldbentry__xdr *uvldb;
20 struct afs_vldb_entry *entry;
21 bool new_only = false;
22 u32 tmp, nr_servers, vlflags;
23 int i, ret;
24
25 _enter("");
26
27 ret = afs_transfer_reply(call);
28 if (ret < 0)
29 return ret;
30
31 /* unmarshall the reply once we've received all of it */
32 uvldb = call->buffer;
33 entry = call->ret_vldb;
34
35 nr_servers = ntohl(uvldb->nServers);
36 if (nr_servers > AFS_NMAXNSERVERS)
37 nr_servers = AFS_NMAXNSERVERS;
38
39 for (i = 0; i < ARRAY_SIZE(uvldb->name) - 1; i++)
40 entry->name[i] = (u8)ntohl(uvldb->name[i]);
41 entry->name[i] = 0;
42 entry->name_len = strlen(entry->name);
43
44 /* If there is a new replication site that we can use, ignore all the
45 * sites that aren't marked as new.
46 */
47 for (i = 0; i < nr_servers; i++) {
48 tmp = ntohl(uvldb->serverFlags[i]);
49 if (!(tmp & AFS_VLSF_DONTUSE) &&
50 (tmp & AFS_VLSF_NEWREPSITE))
51 new_only = true;
52 }
53
54 vlflags = ntohl(uvldb->flags);
55 for (i = 0; i < nr_servers; i++) {
56 struct afs_uuid__xdr *xdr;
57 struct afs_uuid *uuid;
58 int j;
59 int n = entry->nr_servers;
60
61 tmp = ntohl(uvldb->serverFlags[i]);
62 if (tmp & AFS_VLSF_DONTUSE ||
63 (new_only && !(tmp & AFS_VLSF_NEWREPSITE)))
64 continue;
65 if (tmp & AFS_VLSF_RWVOL) {
66 entry->fs_mask[n] |= AFS_VOL_VTM_RW;
67 if (vlflags & AFS_VLF_BACKEXISTS)
68 entry->fs_mask[n] |= AFS_VOL_VTM_BAK;
69 }
70 if (tmp & AFS_VLSF_ROVOL)
71 entry->fs_mask[n] |= AFS_VOL_VTM_RO;
72 if (!entry->fs_mask[n])
73 continue;
74
75 xdr = &uvldb->serverNumber[i];
76 uuid = (struct afs_uuid *)&entry->fs_server[n];
77 uuid->time_low = xdr->time_low;
78 uuid->time_mid = htons(ntohl(xdr->time_mid));
79 uuid->time_hi_and_version = htons(ntohl(xdr->time_hi_and_version));
80 uuid->clock_seq_hi_and_reserved = (u8)ntohl(xdr->clock_seq_hi_and_reserved);
81 uuid->clock_seq_low = (u8)ntohl(xdr->clock_seq_low);
82 for (j = 0; j < 6; j++)
83 uuid->node[j] = (u8)ntohl(xdr->node[j]);
84
85 entry->nr_servers++;
86 }
87
88 for (i = 0; i < AFS_MAXTYPES; i++)
89 entry->vid[i] = ntohl(uvldb->volumeId[i]);
90
91 if (vlflags & AFS_VLF_RWEXISTS)
92 __set_bit(AFS_VLDB_HAS_RW, &entry->flags);
93 if (vlflags & AFS_VLF_ROEXISTS)
94 __set_bit(AFS_VLDB_HAS_RO, &entry->flags);
95 if (vlflags & AFS_VLF_BACKEXISTS)
96 __set_bit(AFS_VLDB_HAS_BAK, &entry->flags);
97
98 if (!(vlflags & (AFS_VLF_RWEXISTS | AFS_VLF_ROEXISTS | AFS_VLF_BACKEXISTS))) {
99 entry->error = -ENOMEDIUM;
100 __set_bit(AFS_VLDB_QUERY_ERROR, &entry->flags);
101 }
102
103 __set_bit(AFS_VLDB_QUERY_VALID, &entry->flags);
104 _leave(" = 0 [done]");
105 return 0;
106}
107
108static void afs_destroy_vl_get_entry_by_name_u(struct afs_call *call)
109{
110 kfree(call->ret_vldb);
111 afs_flat_call_destructor(call);
112}
113
114/*
115 * VL.GetEntryByNameU operation type.
116 */
117static const struct afs_call_type afs_RXVLGetEntryByNameU = {
118 .name = "VL.GetEntryByNameU",
119 .op = afs_VL_GetEntryByNameU,
120 .deliver = afs_deliver_vl_get_entry_by_name_u,
121 .destructor = afs_destroy_vl_get_entry_by_name_u,
122};
123
124/*
125 * Dispatch a get volume entry by name or ID operation (uuid variant). If the
126 * volname is a decimal number then it's a volume ID not a volume name.
127 */
128struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *vc,
129 const char *volname,
130 int volnamesz)
131{
132 struct afs_vldb_entry *entry;
133 struct afs_call *call;
134 struct afs_net *net = vc->cell->net;
135 size_t reqsz, padsz;
136 __be32 *bp;
137
138 _enter("");
139
140 padsz = (4 - (volnamesz & 3)) & 3;
141 reqsz = 8 + volnamesz + padsz;
142
143 entry = kzalloc(sizeof(struct afs_vldb_entry), GFP_KERNEL);
144 if (!entry)
145 return ERR_PTR(-ENOMEM);
146
147 call = afs_alloc_flat_call(net, &afs_RXVLGetEntryByNameU, reqsz,
148 sizeof(struct afs_uvldbentry__xdr));
149 if (!call) {
150 kfree(entry);
151 return ERR_PTR(-ENOMEM);
152 }
153
154 call->key = vc->key;
155 call->ret_vldb = entry;
156 call->max_lifespan = AFS_VL_MAX_LIFESPAN;
157
158 /* Marshall the parameters */
159 bp = call->request;
160 *bp++ = htonl(VLGETENTRYBYNAMEU);
161 *bp++ = htonl(volnamesz);
162 memcpy(bp, volname, volnamesz);
163 if (padsz > 0)
164 memset((void *)bp + volnamesz, 0, padsz);
165
166 trace_afs_make_vl_call(call);
167 afs_make_call(&vc->ac, call, GFP_KERNEL);
168 return (struct afs_vldb_entry *)afs_wait_for_call_to_complete(call, &vc->ac);
169}
170
171/*
172 * Deliver reply data to a VL.GetAddrsU call.
173 *
174 * GetAddrsU(IN ListAddrByAttributes *inaddr,
175 * OUT afsUUID *uuidp1,
176 * OUT uint32_t *uniquifier,
177 * OUT uint32_t *nentries,
178 * OUT bulkaddrs *blkaddrs);
179 */
180static int afs_deliver_vl_get_addrs_u(struct afs_call *call)
181{
182 struct afs_addr_list *alist;
183 __be32 *bp;
184 u32 uniquifier, nentries, count;
185 int i, ret;
186
187 _enter("{%u,%zu/%u}",
188 call->unmarshall, iov_iter_count(call->_iter), call->count);
189
190 switch (call->unmarshall) {
191 case 0:
192 afs_extract_to_buf(call,
193 sizeof(struct afs_uuid__xdr) + 3 * sizeof(__be32));
194 call->unmarshall++;
195
196 /* Extract the returned uuid, uniquifier, nentries and
197 * blkaddrs size */
198 /* Fall through */
199 case 1:
200 ret = afs_extract_data(call, true);
201 if (ret < 0)
202 return ret;
203
204 bp = call->buffer + sizeof(struct afs_uuid__xdr);
205 uniquifier = ntohl(*bp++);
206 nentries = ntohl(*bp++);
207 count = ntohl(*bp);
208
209 nentries = min(nentries, count);
210 alist = afs_alloc_addrlist(nentries, FS_SERVICE, AFS_FS_PORT);
211 if (!alist)
212 return -ENOMEM;
213 alist->version = uniquifier;
214 call->ret_alist = alist;
215 call->count = count;
216 call->count2 = nentries;
217 call->unmarshall++;
218
219 more_entries:
220 count = min(call->count, 4U);
221 afs_extract_to_buf(call, count * sizeof(__be32));
222
223 /* Fall through - and extract entries */
224 case 2:
225 ret = afs_extract_data(call, call->count > 4);
226 if (ret < 0)
227 return ret;
228
229 alist = call->ret_alist;
230 bp = call->buffer;
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);
235
236 call->count -= count;
237 if (call->count > 0)
238 goto more_entries;
239 call->unmarshall++;
240 break;
241 }
242
243 _leave(" = 0 [done]");
244 return 0;
245}
246
247static void afs_vl_get_addrs_u_destructor(struct afs_call *call)
248{
249 afs_put_addrlist(call->ret_alist);
250 return afs_flat_call_destructor(call);
251}
252
253/*
254 * VL.GetAddrsU operation type.
255 */
256static const struct afs_call_type afs_RXVLGetAddrsU = {
257 .name = "VL.GetAddrsU",
258 .op = afs_VL_GetAddrsU,
259 .deliver = afs_deliver_vl_get_addrs_u,
260 .destructor = afs_vl_get_addrs_u_destructor,
261};
262
263/*
264 * Dispatch an operation to get the addresses for a server, where the server is
265 * nominated by UUID.
266 */
267struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *vc,
268 const uuid_t *uuid)
269{
270 struct afs_ListAddrByAttributes__xdr *r;
271 const struct afs_uuid *u = (const struct afs_uuid *)uuid;
272 struct afs_call *call;
273 struct afs_net *net = vc->cell->net;
274 __be32 *bp;
275 int i;
276
277 _enter("");
278
279 call = afs_alloc_flat_call(net, &afs_RXVLGetAddrsU,
280 sizeof(__be32) + sizeof(struct afs_ListAddrByAttributes__xdr),
281 sizeof(struct afs_uuid__xdr) + 3 * sizeof(__be32));
282 if (!call)
283 return ERR_PTR(-ENOMEM);
284
285 call->key = vc->key;
286 call->ret_alist = NULL;
287 call->max_lifespan = AFS_VL_MAX_LIFESPAN;
288
289 /* Marshall the parameters */
290 bp = call->request;
291 *bp++ = htonl(VLGETADDRSU);
292 r = (struct afs_ListAddrByAttributes__xdr *)bp;
293 r->Mask = htonl(AFS_VLADDR_UUID);
294 r->ipaddr = 0;
295 r->index = 0;
296 r->spare = 0;
297 r->uuid.time_low = u->time_low;
298 r->uuid.time_mid = htonl(ntohs(u->time_mid));
299 r->uuid.time_hi_and_version = htonl(ntohs(u->time_hi_and_version));
300 r->uuid.clock_seq_hi_and_reserved = htonl(u->clock_seq_hi_and_reserved);
301 r->uuid.clock_seq_low = htonl(u->clock_seq_low);
302 for (i = 0; i < 6; i++)
303 r->uuid.node[i] = htonl(u->node[i]);
304
305 trace_afs_make_vl_call(call);
306 afs_make_call(&vc->ac, call, GFP_KERNEL);
307 return (struct afs_addr_list *)afs_wait_for_call_to_complete(call, &vc->ac);
308}
309
310/*
311 * Deliver reply data to an VL.GetCapabilities operation.
312 */
313static int afs_deliver_vl_get_capabilities(struct afs_call *call)
314{
315 u32 count;
316 int ret;
317
318 _enter("{%u,%zu/%u}",
319 call->unmarshall, iov_iter_count(call->_iter), call->count);
320
321 switch (call->unmarshall) {
322 case 0:
323 afs_extract_to_tmp(call);
324 call->unmarshall++;
325
326 /* Fall through - and extract the capabilities word count */
327 case 1:
328 ret = afs_extract_data(call, true);
329 if (ret < 0)
330 return ret;
331
332 count = ntohl(call->tmp);
333 call->count = count;
334 call->count2 = count;
335
336 call->unmarshall++;
337 afs_extract_discard(call, count * sizeof(__be32));
338
339 /* Fall through - and extract capabilities words */
340 case 2:
341 ret = afs_extract_data(call, false);
342 if (ret < 0)
343 return ret;
344
345 /* TODO: Examine capabilities */
346
347 call->unmarshall++;
348 break;
349 }
350
351 _leave(" = 0 [done]");
352 return 0;
353}
354
355static void afs_destroy_vl_get_capabilities(struct afs_call *call)
356{
357 afs_put_vlserver(call->net, call->vlserver);
358 afs_flat_call_destructor(call);
359}
360
361/*
362 * VL.GetCapabilities operation type
363 */
364static const struct afs_call_type afs_RXVLGetCapabilities = {
365 .name = "VL.GetCapabilities",
366 .op = afs_VL_GetCapabilities,
367 .deliver = afs_deliver_vl_get_capabilities,
368 .done = afs_vlserver_probe_result,
369 .destructor = afs_destroy_vl_get_capabilities,
370};
371
372/*
373 * Probe a volume server for the capabilities that it supports. This can
374 * return up to 196 words.
375 *
376 * We use this to probe for service upgrade to determine what the server at the
377 * other end supports.
378 */
379struct afs_call *afs_vl_get_capabilities(struct afs_net *net,
380 struct afs_addr_cursor *ac,
381 struct key *key,
382 struct afs_vlserver *server,
383 unsigned int server_index)
384{
385 struct afs_call *call;
386 __be32 *bp;
387
388 _enter("");
389
390 call = afs_alloc_flat_call(net, &afs_RXVLGetCapabilities, 1 * 4, 16 * 4);
391 if (!call)
392 return ERR_PTR(-ENOMEM);
393
394 call->key = key;
395 call->vlserver = afs_get_vlserver(server);
396 call->server_index = server_index;
397 call->upgrade = true;
398 call->async = true;
399 call->max_lifespan = AFS_PROBE_MAX_LIFESPAN;
400
401 /* marshall the parameters */
402 bp = call->request;
403 *bp++ = htonl(VLGETCAPABILITIES);
404
405 /* Can't take a ref on server */
406 trace_afs_make_vl_call(call);
407 afs_make_call(ac, call, GFP_KERNEL);
408 return call;
409}
410
411/*
412 * Deliver reply data to a YFSVL.GetEndpoints call.
413 *
414 * GetEndpoints(IN yfsServerAttributes *attr,
415 * OUT opr_uuid *uuid,
416 * OUT afs_int32 *uniquifier,
417 * OUT endpoints *fsEndpoints,
418 * OUT endpoints *volEndpoints)
419 */
420static int afs_deliver_yfsvl_get_endpoints(struct afs_call *call)
421{
422 struct afs_addr_list *alist;
423 __be32 *bp;
424 u32 uniquifier, size;
425 int ret;
426
427 _enter("{%u,%zu,%u}",
428 call->unmarshall, iov_iter_count(call->_iter), call->count2);
429
430 switch (call->unmarshall) {
431 case 0:
432 afs_extract_to_buf(call, sizeof(uuid_t) + 3 * sizeof(__be32));
433 call->unmarshall = 1;
434
435 /* Extract the returned uuid, uniquifier, fsEndpoints count and
436 * either the first fsEndpoint type or the volEndpoints
437 * count if there are no fsEndpoints. */
438 /* Fall through */
439 case 1:
440 ret = afs_extract_data(call, true);
441 if (ret < 0)
442 return ret;
443
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 */
448
449 if (call->count > YFS_MAXENDPOINTS)
450 return afs_protocol_error(call, -EBADMSG,
451 afs_eproto_yvl_fsendpt_num);
452
453 alist = afs_alloc_addrlist(call->count, FS_SERVICE, AFS_FS_PORT);
454 if (!alist)
455 return -ENOMEM;
456 alist->version = uniquifier;
457 call->ret_alist = alist;
458
459 if (call->count == 0)
460 goto extract_volendpoints;
461
462 next_fsendpoint:
463 switch (call->count2) {
464 case YFS_ENDPOINT_IPV4:
465 size = sizeof(__be32) * (1 + 1 + 1);
466 break;
467 case YFS_ENDPOINT_IPV6:
468 size = sizeof(__be32) * (1 + 4 + 1);
469 break;
470 default:
471 return afs_protocol_error(call, -EBADMSG,
472 afs_eproto_yvl_fsendpt_type);
473 }
474
475 size += sizeof(__be32);
476 afs_extract_to_buf(call, size);
477 call->unmarshall = 2;
478
479 /* Fall through - and extract fsEndpoints[] entries */
480 case 2:
481 ret = afs_extract_data(call, true);
482 if (ret < 0)
483 return ret;
484
485 alist = call->ret_alist;
486 bp = call->buffer;
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]));
493 bp += 3;
494 break;
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]));
500 bp += 6;
501 break;
502 default:
503 return afs_protocol_error(call, -EBADMSG,
504 afs_eproto_yvl_fsendpt_type);
505 }
506
507 /* Got either the type of the next entry or the count of
508 * volEndpoints if no more fsEndpoints.
509 */
510 call->count2 = ntohl(*bp++);
511
512 call->count--;
513 if (call->count > 0)
514 goto next_fsendpoint;
515
516 extract_volendpoints:
517 /* Extract the list of volEndpoints. */
518 call->count = call->count2;
519 if (!call->count)
520 goto end;
521 if (call->count > YFS_MAXENDPOINTS)
522 return afs_protocol_error(call, -EBADMSG,
523 afs_eproto_yvl_vlendpt_type);
524
525 afs_extract_to_buf(call, 1 * sizeof(__be32));
526 call->unmarshall = 3;
527
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...
531 */
532 /* Fall through */
533 case 3:
534 ret = afs_extract_data(call, true);
535 if (ret < 0)
536 return ret;
537
538 bp = call->buffer;
539
540 next_volendpoint:
541 call->count2 = ntohl(*bp++);
542 switch (call->count2) {
543 case YFS_ENDPOINT_IPV4:
544 size = sizeof(__be32) * (1 + 1 + 1);
545 break;
546 case YFS_ENDPOINT_IPV6:
547 size = sizeof(__be32) * (1 + 4 + 1);
548 break;
549 default:
550 return afs_protocol_error(call, -EBADMSG,
551 afs_eproto_yvl_vlendpt_type);
552 }
553
554 if (call->count > 1)
555 size += sizeof(__be32); /* Get next type too */
556 afs_extract_to_buf(call, size);
557 call->unmarshall = 4;
558
559 /* Fall through - and extract volEndpoints[] entries */
560 case 4:
561 ret = afs_extract_data(call, true);
562 if (ret < 0)
563 return ret;
564
565 bp = call->buffer;
566 switch (call->count2) {
567 case YFS_ENDPOINT_IPV4:
568 if (ntohl(bp[0]) != sizeof(__be32) * 2)
569 return afs_protocol_error(call, -EBADMSG,
570 afs_eproto_yvl_vlendpt4_len);
571 bp += 3;
572 break;
573 case YFS_ENDPOINT_IPV6:
574 if (ntohl(bp[0]) != sizeof(__be32) * 5)
575 return afs_protocol_error(call, -EBADMSG,
576 afs_eproto_yvl_vlendpt6_len);
577 bp += 6;
578 break;
579 default:
580 return afs_protocol_error(call, -EBADMSG,
581 afs_eproto_yvl_vlendpt_type);
582 }
583
584 /* Got either the type of the next entry or the count of
585 * volEndpoints if no more fsEndpoints.
586 */
587 call->count--;
588 if (call->count > 0)
589 goto next_volendpoint;
590
591 end:
592 afs_extract_discard(call, 0);
593 call->unmarshall = 5;
594
595 /* Fall through - Done */
596 case 5:
597 ret = afs_extract_data(call, false);
598 if (ret < 0)
599 return ret;
600 call->unmarshall = 6;
601
602 case 6:
603 break;
604 }
605
606 _leave(" = 0 [done]");
607 return 0;
608}
609
610/*
611 * YFSVL.GetEndpoints operation type.
612 */
613static 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,
618};
619
620/*
621 * Dispatch an operation to get the addresses for a server, where the server is
622 * nominated by UUID.
623 */
624struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *vc,
625 const uuid_t *uuid)
626{
627 struct afs_call *call;
628 struct afs_net *net = vc->cell->net;
629 __be32 *bp;
630
631 _enter("");
632
633 call = afs_alloc_flat_call(net, &afs_YFSVLGetEndpoints,
634 sizeof(__be32) * 2 + sizeof(*uuid),
635 sizeof(struct in6_addr) + sizeof(__be32) * 3);
636 if (!call)
637 return ERR_PTR(-ENOMEM);
638
639 call->key = vc->key;
640 call->ret_alist = NULL;
641 call->max_lifespan = AFS_VL_MAX_LIFESPAN;
642
643 /* Marshall the parameters */
644 bp = call->request;
645 *bp++ = htonl(YVLGETENDPOINTS);
646 *bp++ = htonl(YFS_SERVER_UUID);
647 memcpy(bp, uuid, sizeof(*uuid)); /* Type opr_uuid */
648
649 trace_afs_make_vl_call(call);
650 afs_make_call(&vc->ac, call, GFP_KERNEL);
651 return (struct afs_addr_list *)afs_wait_for_call_to_complete(call, &vc->ac);
652}