]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - fs/afs/vlclient.c
projects / mirror_ubuntu-focal-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 152
[mirror_ubuntu-focal-kernel.git] / fs / afs / vlclient.c
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 */
17 static 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
60 tmp = ntohl(uvldb->serverFlags[i]);
61 if (tmp & AFS_VLSF_DONTUSE ||
62 (new_only && !(tmp & AFS_VLSF_NEWREPSITE)))
63 continue;
64 if (tmp & AFS_VLSF_RWVOL) {
65 entry->fs_mask[i] |= AFS_VOL_VTM_RW;
66 if (vlflags & AFS_VLF_BACKEXISTS)
67 entry->fs_mask[i] |= AFS_VOL_VTM_BAK;
68 }
69 if (tmp & AFS_VLSF_ROVOL)
70 entry->fs_mask[i] |= AFS_VOL_VTM_RO;
71 if (!entry->fs_mask[i])
72 continue;
73
74 xdr = &uvldb->serverNumber[i];
75 uuid = (struct afs_uuid *)&entry->fs_server[i];
76 uuid->time_low = xdr->time_low;
77 uuid->time_mid = htons(ntohl(xdr->time_mid));
78 uuid->time_hi_and_version = htons(ntohl(xdr->time_hi_and_version));
79 uuid->clock_seq_hi_and_reserved = (u8)ntohl(xdr->clock_seq_hi_and_reserved);
80 uuid->clock_seq_low = (u8)ntohl(xdr->clock_seq_low);
81 for (j = 0; j < 6; j++)
82 uuid->node[j] = (u8)ntohl(xdr->node[j]);
83
84 entry->nr_servers++;
85 }
86
87 for (i = 0; i < AFS_MAXTYPES; i++)
88 entry->vid[i] = ntohl(uvldb->volumeId[i]);
89
90 if (vlflags & AFS_VLF_RWEXISTS)
91 __set_bit(AFS_VLDB_HAS_RW, &entry->flags);
92 if (vlflags & AFS_VLF_ROEXISTS)
93 __set_bit(AFS_VLDB_HAS_RO, &entry->flags);
94 if (vlflags & AFS_VLF_BACKEXISTS)
95 __set_bit(AFS_VLDB_HAS_BAK, &entry->flags);
96
97 if (!(vlflags & (AFS_VLF_RWEXISTS | AFS_VLF_ROEXISTS | AFS_VLF_BACKEXISTS))) {
98 entry->error = -ENOMEDIUM;
99 __set_bit(AFS_VLDB_QUERY_ERROR, &entry->flags);
100 }
101
102 __set_bit(AFS_VLDB_QUERY_VALID, &entry->flags);
103 _leave(" = 0 [done]");
104 return 0;
105 }
106
107 static void afs_destroy_vl_get_entry_by_name_u(struct afs_call *call)
108 {
109 kfree(call->ret_vldb);
110 afs_flat_call_destructor(call);
111 }
112
113 /*
114 * VL.GetEntryByNameU operation type.
115 */
116 static const struct afs_call_type afs_RXVLGetEntryByNameU = {
117 .name = "VL.GetEntryByNameU",
118 .op = afs_VL_GetEntryByNameU,
119 .deliver = afs_deliver_vl_get_entry_by_name_u,
120 .destructor = afs_destroy_vl_get_entry_by_name_u,
121 };
122
123 /*
124 * Dispatch a get volume entry by name or ID operation (uuid variant). If the
125 * volname is a decimal number then it's a volume ID not a volume name.
126 */
127 struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *vc,
128 const char *volname,
129 int volnamesz)
130 {
131 struct afs_vldb_entry *entry;
132 struct afs_call *call;
133 struct afs_net *net = vc->cell->net;
134 size_t reqsz, padsz;
135 __be32 *bp;
136
137 _enter("");
138
139 padsz = (4 - (volnamesz & 3)) & 3;
140 reqsz = 8 + volnamesz + padsz;
141
142 entry = kzalloc(sizeof(struct afs_vldb_entry), GFP_KERNEL);
143 if (!entry)
144 return ERR_PTR(-ENOMEM);
145
146 call = afs_alloc_flat_call(net, &afs_RXVLGetEntryByNameU, reqsz,
147 sizeof(struct afs_uvldbentry__xdr));
148 if (!call) {
149 kfree(entry);
150 return ERR_PTR(-ENOMEM);
151 }
152
153 call->key = vc->key;
154 call->ret_vldb = entry;
155 call->max_lifespan = AFS_VL_MAX_LIFESPAN;
156
157 /* Marshall the parameters */
158 bp = call->request;
159 *bp++ = htonl(VLGETENTRYBYNAMEU);
160 *bp++ = htonl(volnamesz);
161 memcpy(bp, volname, volnamesz);
162 if (padsz > 0)
163 memset((void *)bp + volnamesz, 0, padsz);
164
165 trace_afs_make_vl_call(call);
166 afs_make_call(&vc->ac, call, GFP_KERNEL);
167 return (struct afs_vldb_entry *)afs_wait_for_call_to_complete(call, &vc->ac);
168 }
169
170 /*
171 * Deliver reply data to a VL.GetAddrsU call.
172 *
173 * GetAddrsU(IN ListAddrByAttributes *inaddr,
174 * OUT afsUUID *uuidp1,
175 * OUT uint32_t *uniquifier,
176 * OUT uint32_t *nentries,
177 * OUT bulkaddrs *blkaddrs);
178 */
179 static int afs_deliver_vl_get_addrs_u(struct afs_call *call)
180 {
181 struct afs_addr_list *alist;
182 __be32 *bp;
183 u32 uniquifier, nentries, count;
184 int i, ret;
185
186 _enter("{%u,%zu/%u}",
187 call->unmarshall, iov_iter_count(call->_iter), call->count);
188
189 switch (call->unmarshall) {
190 case 0:
191 afs_extract_to_buf(call,
192 sizeof(struct afs_uuid__xdr) + 3 * sizeof(__be32));
193 call->unmarshall++;
194
195 /* Extract the returned uuid, uniquifier, nentries and
196 * blkaddrs size */
197 /* Fall through */
198 case 1:
199 ret = afs_extract_data(call, true);
200 if (ret < 0)
201 return ret;
202
203 bp = call->buffer + sizeof(struct afs_uuid__xdr);
204 uniquifier = ntohl(*bp++);
205 nentries = ntohl(*bp++);
206 count = ntohl(*bp);
207
208 nentries = min(nentries, count);
209 alist = afs_alloc_addrlist(nentries, FS_SERVICE, AFS_FS_PORT);
210 if (!alist)
211 return -ENOMEM;
212 alist->version = uniquifier;
213 call->ret_alist = alist;
214 call->count = count;
215 call->count2 = nentries;
216 call->unmarshall++;
217
218 more_entries:
219 count = min(call->count, 4U);
220 afs_extract_to_buf(call, count * sizeof(__be32));
221
222 /* Fall through - and extract entries */
223 case 2:
224 ret = afs_extract_data(call, call->count > 4);
225 if (ret < 0)
226 return ret;
227
228 alist = call->ret_alist;
229 bp = call->buffer;
230 count = min(call->count, 4U);
231 for (i = 0; i < count; i++)
232 if (alist->nr_addrs < call->count2)
233 afs_merge_fs_addr4(alist, *bp++, AFS_FS_PORT);
234
235 call->count -= count;
236 if (call->count > 0)
237 goto more_entries;
238 call->unmarshall++;
239 break;
240 }
241
242 _leave(" = 0 [done]");
243 return 0;
244 }
245
246 static void afs_vl_get_addrs_u_destructor(struct afs_call *call)
247 {
248 afs_put_addrlist(call->ret_alist);
249 return afs_flat_call_destructor(call);
250 }
251
252 /*
253 * VL.GetAddrsU operation type.
254 */
255 static const struct afs_call_type afs_RXVLGetAddrsU = {
256 .name = "VL.GetAddrsU",
257 .op = afs_VL_GetAddrsU,
258 .deliver = afs_deliver_vl_get_addrs_u,
259 .destructor = afs_vl_get_addrs_u_destructor,
260 };
261
262 /*
263 * Dispatch an operation to get the addresses for a server, where the server is
264 * nominated by UUID.
265 */
266 struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *vc,
267 const uuid_t *uuid)
268 {
269 struct afs_ListAddrByAttributes__xdr *r;
270 const struct afs_uuid *u = (const struct afs_uuid *)uuid;
271 struct afs_call *call;
272 struct afs_net *net = vc->cell->net;
273 __be32 *bp;
274 int i;
275
276 _enter("");
277
278 call = afs_alloc_flat_call(net, &afs_RXVLGetAddrsU,
279 sizeof(__be32) + sizeof(struct afs_ListAddrByAttributes__xdr),
280 sizeof(struct afs_uuid__xdr) + 3 * sizeof(__be32));
281 if (!call)
282 return ERR_PTR(-ENOMEM);
283
284 call->key = vc->key;
285 call->ret_alist = NULL;
286 call->max_lifespan = AFS_VL_MAX_LIFESPAN;
287
288 /* Marshall the parameters */
289 bp = call->request;
290 *bp++ = htonl(VLGETADDRSU);
291 r = (struct afs_ListAddrByAttributes__xdr *)bp;
292 r->Mask = htonl(AFS_VLADDR_UUID);
293 r->ipaddr = 0;
294 r->index = 0;
295 r->spare = 0;
296 r->uuid.time_low = u->time_low;
297 r->uuid.time_mid = htonl(ntohs(u->time_mid));
298 r->uuid.time_hi_and_version = htonl(ntohs(u->time_hi_and_version));
299 r->uuid.clock_seq_hi_and_reserved = htonl(u->clock_seq_hi_and_reserved);
300 r->uuid.clock_seq_low = htonl(u->clock_seq_low);
301 for (i = 0; i < 6; i++)
302 r->uuid.node[i] = htonl(u->node[i]);
303
304 trace_afs_make_vl_call(call);
305 afs_make_call(&vc->ac, call, GFP_KERNEL);
306 return (struct afs_addr_list *)afs_wait_for_call_to_complete(call, &vc->ac);
307 }
308
309 /*
310 * Deliver reply data to an VL.GetCapabilities operation.
311 */
312 static int afs_deliver_vl_get_capabilities(struct afs_call *call)
313 {
314 u32 count;
315 int ret;
316
317 _enter("{%u,%zu/%u}",
318 call->unmarshall, iov_iter_count(call->_iter), call->count);
319
320 switch (call->unmarshall) {
321 case 0:
322 afs_extract_to_tmp(call);
323 call->unmarshall++;
324
325 /* Fall through - and extract the capabilities word count */
326 case 1:
327 ret = afs_extract_data(call, true);
328 if (ret < 0)
329 return ret;
330
331 count = ntohl(call->tmp);
332 call->count = count;
333 call->count2 = count;
334
335 call->unmarshall++;
336 afs_extract_discard(call, count * sizeof(__be32));
337
338 /* Fall through - and extract capabilities words */
339 case 2:
340 ret = afs_extract_data(call, false);
341 if (ret < 0)
342 return ret;
343
344 /* TODO: Examine capabilities */
345
346 call->unmarshall++;
347 break;
348 }
349
350 _leave(" = 0 [done]");
351 return 0;
352 }
353
354 static void afs_destroy_vl_get_capabilities(struct afs_call *call)
355 {
356 afs_put_vlserver(call->net, call->vlserver);
357 afs_flat_call_destructor(call);
358 }
359
360 /*
361 * VL.GetCapabilities operation type
362 */
363 static const struct afs_call_type afs_RXVLGetCapabilities = {
364 .name = "VL.GetCapabilities",
365 .op = afs_VL_GetCapabilities,
366 .deliver = afs_deliver_vl_get_capabilities,
367 .done = afs_vlserver_probe_result,
368 .destructor = afs_destroy_vl_get_capabilities,
369 };
370
371 /*
372 * Probe a volume server for the capabilities that it supports. This can
373 * return up to 196 words.
374 *
375 * We use this to probe for service upgrade to determine what the server at the
376 * other end supports.
377 */
378 struct afs_call *afs_vl_get_capabilities(struct afs_net *net,
379 struct afs_addr_cursor *ac,
380 struct key *key,
381 struct afs_vlserver *server,
382 unsigned int server_index)
383 {
384 struct afs_call *call;
385 __be32 *bp;
386
387 _enter("");
388
389 call = afs_alloc_flat_call(net, &afs_RXVLGetCapabilities, 1 * 4, 16 * 4);
390 if (!call)
391 return ERR_PTR(-ENOMEM);
392
393 call->key = key;
394 call->vlserver = afs_get_vlserver(server);
395 call->server_index = server_index;
396 call->upgrade = true;
397 call->async = true;
398 call->max_lifespan = AFS_PROBE_MAX_LIFESPAN;
399
400 /* marshall the parameters */
401 bp = call->request;
402 *bp++ = htonl(VLGETCAPABILITIES);
403
404 /* Can't take a ref on server */
405 trace_afs_make_vl_call(call);
406 afs_make_call(ac, call, GFP_KERNEL);
407 return call;
408 }
409
410 /*
411 * Deliver reply data to a YFSVL.GetEndpoints call.
412 *
413 * GetEndpoints(IN yfsServerAttributes *attr,
414 * OUT opr_uuid *uuid,
415 * OUT afs_int32 *uniquifier,
416 * OUT endpoints *fsEndpoints,
417 * OUT endpoints *volEndpoints)
418 */
419 static int afs_deliver_yfsvl_get_endpoints(struct afs_call *call)
420 {
421 struct afs_addr_list *alist;
422 __be32 *bp;
423 u32 uniquifier, size;
424 int ret;
425
426 _enter("{%u,%zu,%u}",
427 call->unmarshall, iov_iter_count(call->_iter), call->count2);
428
429 switch (call->unmarshall) {
430 case 0:
431 afs_extract_to_buf(call, sizeof(uuid_t) + 3 * sizeof(__be32));
432 call->unmarshall = 1;
433
434 /* Extract the returned uuid, uniquifier, fsEndpoints count and
435 * either the first fsEndpoint type or the volEndpoints
436 * count if there are no fsEndpoints. */
437 /* Fall through */
438 case 1:
439 ret = afs_extract_data(call, true);
440 if (ret < 0)
441 return ret;
442
443 bp = call->buffer + sizeof(uuid_t);
444 uniquifier = ntohl(*bp++);
445 call->count = ntohl(*bp++);
446 call->count2 = ntohl(*bp); /* Type or next count */
447
448 if (call->count > YFS_MAXENDPOINTS)
449 return afs_protocol_error(call, -EBADMSG,
450 afs_eproto_yvl_fsendpt_num);
451
452 alist = afs_alloc_addrlist(call->count, FS_SERVICE, AFS_FS_PORT);
453 if (!alist)
454 return -ENOMEM;
455 alist->version = uniquifier;
456 call->ret_alist = alist;
457
458 if (call->count == 0)
459 goto extract_volendpoints;
460
461 next_fsendpoint:
462 switch (call->count2) {
463 case YFS_ENDPOINT_IPV4:
464 size = sizeof(__be32) * (1 + 1 + 1);
465 break;
466 case YFS_ENDPOINT_IPV6:
467 size = sizeof(__be32) * (1 + 4 + 1);
468 break;
469 default:
470 return afs_protocol_error(call, -EBADMSG,
471 afs_eproto_yvl_fsendpt_type);
472 }
473
474 size += sizeof(__be32);
475 afs_extract_to_buf(call, size);
476 call->unmarshall = 2;
477
478 /* Fall through - and extract fsEndpoints[] entries */
479 case 2:
480 ret = afs_extract_data(call, true);
481 if (ret < 0)
482 return ret;
483
484 alist = call->ret_alist;
485 bp = call->buffer;
486 switch (call->count2) {
487 case YFS_ENDPOINT_IPV4:
488 if (ntohl(bp[0]) != sizeof(__be32) * 2)
489 return afs_protocol_error(call, -EBADMSG,
490 afs_eproto_yvl_fsendpt4_len);
491 afs_merge_fs_addr4(alist, bp[1], ntohl(bp[2]));
492 bp += 3;
493 break;
494 case YFS_ENDPOINT_IPV6:
495 if (ntohl(bp[0]) != sizeof(__be32) * 5)
496 return afs_protocol_error(call, -EBADMSG,
497 afs_eproto_yvl_fsendpt6_len);
498 afs_merge_fs_addr6(alist, bp + 1, ntohl(bp[5]));
499 bp += 6;
500 break;
501 default:
502 return afs_protocol_error(call, -EBADMSG,
503 afs_eproto_yvl_fsendpt_type);
504 }
505
506 /* Got either the type of the next entry or the count of
507 * volEndpoints if no more fsEndpoints.
508 */
509 call->count2 = ntohl(*bp++);
510
511 call->count--;
512 if (call->count > 0)
513 goto next_fsendpoint;
514
515 extract_volendpoints:
516 /* Extract the list of volEndpoints. */
517 call->count = call->count2;
518 if (!call->count)
519 goto end;
520 if (call->count > YFS_MAXENDPOINTS)
521 return afs_protocol_error(call, -EBADMSG,
522 afs_eproto_yvl_vlendpt_type);
523
524 afs_extract_to_buf(call, 1 * sizeof(__be32));
525 call->unmarshall = 3;
526
527 /* Extract the type of volEndpoints[0]. Normally we would
528 * extract the type of the next endpoint when we extract the
529 * data of the current one, but this is the first...
530 */
531 /* Fall through */
532 case 3:
533 ret = afs_extract_data(call, true);
534 if (ret < 0)
535 return ret;
536
537 bp = call->buffer;
538
539 next_volendpoint:
540 call->count2 = ntohl(*bp++);
541 switch (call->count2) {
542 case YFS_ENDPOINT_IPV4:
543 size = sizeof(__be32) * (1 + 1 + 1);
544 break;
545 case YFS_ENDPOINT_IPV6:
546 size = sizeof(__be32) * (1 + 4 + 1);
547 break;
548 default:
549 return afs_protocol_error(call, -EBADMSG,
550 afs_eproto_yvl_vlendpt_type);
551 }
552
553 if (call->count > 1)
554 size += sizeof(__be32); /* Get next type too */
555 afs_extract_to_buf(call, size);
556 call->unmarshall = 4;
557
558 /* Fall through - and extract volEndpoints[] entries */
559 case 4:
560 ret = afs_extract_data(call, true);
561 if (ret < 0)
562 return ret;
563
564 bp = call->buffer;
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);
570 bp += 3;
571 break;
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);
576 bp += 6;
577 break;
578 default:
579 return afs_protocol_error(call, -EBADMSG,
580 afs_eproto_yvl_vlendpt_type);
581 }
582
583 /* Got either the type of the next entry or the count of
584 * volEndpoints if no more fsEndpoints.
585 */
586 call->count--;
587 if (call->count > 0)
588 goto next_volendpoint;
589
590 end:
591 afs_extract_discard(call, 0);
592 call->unmarshall = 5;
593
594 /* Fall through - Done */
595 case 5:
596 ret = afs_extract_data(call, false);
597 if (ret < 0)
598 return ret;
599 call->unmarshall = 6;
600
601 case 6:
602 break;
603 }
604
605 _leave(" = 0 [done]");
606 return 0;
607 }
608
609 /*
610 * YFSVL.GetEndpoints operation type.
611 */
612 static const struct afs_call_type afs_YFSVLGetEndpoints = {
613 .name = "YFSVL.GetEndpoints",
614 .op = afs_YFSVL_GetEndpoints,
615 .deliver = afs_deliver_yfsvl_get_endpoints,
616 .destructor = afs_vl_get_addrs_u_destructor,
617 };
618
619 /*
620 * Dispatch an operation to get the addresses for a server, where the server is
621 * nominated by UUID.
622 */
623 struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *vc,
624 const uuid_t *uuid)
625 {
626 struct afs_call *call;
627 struct afs_net *net = vc->cell->net;
628 __be32 *bp;
629
630 _enter("");
631
632 call = afs_alloc_flat_call(net, &afs_YFSVLGetEndpoints,
633 sizeof(__be32) * 2 + sizeof(*uuid),
634 sizeof(struct in6_addr) + sizeof(__be32) * 3);
635 if (!call)
636 return ERR_PTR(-ENOMEM);
637
638 call->key = vc->key;
639 call->ret_alist = NULL;
640 call->max_lifespan = AFS_VL_MAX_LIFESPAN;
641
642 /* Marshall the parameters */
643 bp = call->request;
644 *bp++ = htonl(YVLGETENDPOINTS);
645 *bp++ = htonl(YFS_SERVER_UUID);
646 memcpy(bp, uuid, sizeof(*uuid)); /* Type opr_uuid */
647
648 trace_afs_make_vl_call(call);
649 afs_make_call(&vc->ac, call, GFP_KERNEL);
650 return (struct afs_addr_list *)afs_wait_for_call_to_complete(call, &vc->ac);
651 }
Ubuntu Focal Linux kernel mirror