]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - fs/afs/vlclient.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'usb-4.15-rc8' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb
[mirror_ubuntu-bionic-kernel.git] / fs / afs / vlclient.c
1 /* AFS Volume Location Service client
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/gfp.h>
13 #include <linux/init.h>
14 #include <linux/sched.h>
15 #include "afs_fs.h"
16 #include "internal.h"
17
18 /*
19 * Deliver reply data to a VL.GetEntryByNameU call.
20 */
21 static int afs_deliver_vl_get_entry_by_name_u(struct afs_call *call)
22 {
23 struct afs_uvldbentry__xdr *uvldb;
24 struct afs_vldb_entry *entry;
25 bool new_only = false;
26 u32 tmp;
27 int i, ret;
28
29 _enter("");
30
31 ret = afs_transfer_reply(call);
32 if (ret < 0)
33 return ret;
34
35 /* unmarshall the reply once we've received all of it */
36 uvldb = call->buffer;
37 entry = call->reply[0];
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 < AFS_NMAXNSERVERS; 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 for (i = 0; i < AFS_NMAXNSERVERS; i++) {
55 struct afs_uuid__xdr *xdr;
56 struct afs_uuid *uuid;
57 int j;
58
59 tmp = ntohl(uvldb->serverFlags[i]);
60 if (tmp & AFS_VLSF_DONTUSE ||
61 (new_only && !(tmp & AFS_VLSF_NEWREPSITE)))
62 continue;
63 if (tmp & AFS_VLSF_RWVOL)
64 entry->fs_mask[i] |= AFS_VOL_VTM_RW;
65 if (tmp & AFS_VLSF_ROVOL)
66 entry->fs_mask[i] |= AFS_VOL_VTM_RO;
67 if (tmp & AFS_VLSF_BACKVOL)
68 entry->fs_mask[i] |= AFS_VOL_VTM_BAK;
69 if (!entry->fs_mask[i])
70 continue;
71
72 xdr = &uvldb->serverNumber[i];
73 uuid = (struct afs_uuid *)&entry->fs_server[i];
74 uuid->time_low = xdr->time_low;
75 uuid->time_mid = htons(ntohl(xdr->time_mid));
76 uuid->time_hi_and_version = htons(ntohl(xdr->time_hi_and_version));
77 uuid->clock_seq_hi_and_reserved = (u8)ntohl(xdr->clock_seq_hi_and_reserved);
78 uuid->clock_seq_low = (u8)ntohl(xdr->clock_seq_low);
79 for (j = 0; j < 6; j++)
80 uuid->node[j] = (u8)ntohl(xdr->node[j]);
81
82 entry->nr_servers++;
83 }
84
85 for (i = 0; i < AFS_MAXTYPES; i++)
86 entry->vid[i] = ntohl(uvldb->volumeId[i]);
87
88 tmp = ntohl(uvldb->flags);
89 if (tmp & AFS_VLF_RWEXISTS)
90 __set_bit(AFS_VLDB_HAS_RW, &entry->flags);
91 if (tmp & AFS_VLF_ROEXISTS)
92 __set_bit(AFS_VLDB_HAS_RO, &entry->flags);
93 if (tmp & AFS_VLF_BACKEXISTS)
94 __set_bit(AFS_VLDB_HAS_BAK, &entry->flags);
95
96 if (!(tmp & (AFS_VLF_RWEXISTS | AFS_VLF_ROEXISTS | AFS_VLF_BACKEXISTS))) {
97 entry->error = -ENOMEDIUM;
98 __set_bit(AFS_VLDB_QUERY_ERROR, &entry->flags);
99 }
100
101 __set_bit(AFS_VLDB_QUERY_VALID, &entry->flags);
102 _leave(" = 0 [done]");
103 return 0;
104 }
105
106 static void afs_destroy_vl_get_entry_by_name_u(struct afs_call *call)
107 {
108 kfree(call->reply[0]);
109 afs_flat_call_destructor(call);
110 }
111
112 /*
113 * VL.GetEntryByNameU operation type.
114 */
115 static const struct afs_call_type afs_RXVLGetEntryByNameU = {
116 .name = "VL.GetEntryByNameU",
117 .op = afs_VL_GetEntryByNameU,
118 .deliver = afs_deliver_vl_get_entry_by_name_u,
119 .destructor = afs_destroy_vl_get_entry_by_name_u,
120 };
121
122 /*
123 * Dispatch a get volume entry by name or ID operation (uuid variant). If the
124 * volname is a decimal number then it's a volume ID not a volume name.
125 */
126 struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_net *net,
127 struct afs_addr_cursor *ac,
128 struct key *key,
129 const char *volname,
130 int volnamesz)
131 {
132 struct afs_vldb_entry *entry;
133 struct afs_call *call;
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 = key;
154 call->reply[0] = entry;
155 call->ret_reply0 = true;
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 return (struct afs_vldb_entry *)afs_make_call(ac, call, GFP_KERNEL, false);
167 }
168
169 /*
170 * Deliver reply data to a VL.GetAddrsU call.
171 *
172 * GetAddrsU(IN ListAddrByAttributes *inaddr,
173 * OUT afsUUID *uuidp1,
174 * OUT uint32_t *uniquifier,
175 * OUT uint32_t *nentries,
176 * OUT bulkaddrs *blkaddrs);
177 */
178 static int afs_deliver_vl_get_addrs_u(struct afs_call *call)
179 {
180 struct afs_addr_list *alist;
181 __be32 *bp;
182 u32 uniquifier, nentries, count;
183 int i, ret;
184
185 _enter("{%u,%zu/%u}", call->unmarshall, call->offset, call->count);
186
187 again:
188 switch (call->unmarshall) {
189 case 0:
190 call->offset = 0;
191 call->unmarshall++;
192
193 /* Extract the returned uuid, uniquifier, nentries and blkaddrs size */
194 case 1:
195 ret = afs_extract_data(call, call->buffer,
196 sizeof(struct afs_uuid__xdr) + 3 * sizeof(__be32),
197 true);
198 if (ret < 0)
199 return ret;
200
201 bp = call->buffer + sizeof(struct afs_uuid__xdr);
202 uniquifier = ntohl(*bp++);
203 nentries = ntohl(*bp++);
204 count = ntohl(*bp);
205
206 nentries = min(nentries, count);
207 alist = afs_alloc_addrlist(nentries, FS_SERVICE, AFS_FS_PORT);
208 if (!alist)
209 return -ENOMEM;
210 alist->version = uniquifier;
211 call->reply[0] = alist;
212 call->count = count;
213 call->count2 = nentries;
214 call->offset = 0;
215 call->unmarshall++;
216
217 /* Extract entries */
218 case 2:
219 count = min(call->count, 4U);
220 ret = afs_extract_data(call, call->buffer,
221 count * sizeof(__be32),
222 call->count > 4);
223 if (ret < 0)
224 return ret;
225
226 alist = call->reply[0];
227 bp = call->buffer;
228 for (i = 0; i < count; i++)
229 if (alist->nr_addrs < call->count2)
230 afs_merge_fs_addr4(alist, *bp++, AFS_FS_PORT);
231
232 call->count -= count;
233 if (call->count > 0)
234 goto again;
235 call->offset = 0;
236 call->unmarshall++;
237 break;
238 }
239
240 _leave(" = 0 [done]");
241 return 0;
242 }
243
244 static void afs_vl_get_addrs_u_destructor(struct afs_call *call)
245 {
246 afs_put_server(call->net, (struct afs_server *)call->reply[0]);
247 kfree(call->reply[1]);
248 return afs_flat_call_destructor(call);
249 }
250
251 /*
252 * VL.GetAddrsU operation type.
253 */
254 static const struct afs_call_type afs_RXVLGetAddrsU = {
255 .name = "VL.GetAddrsU",
256 .op = afs_VL_GetAddrsU,
257 .deliver = afs_deliver_vl_get_addrs_u,
258 .destructor = afs_vl_get_addrs_u_destructor,
259 };
260
261 /*
262 * Dispatch an operation to get the addresses for a server, where the server is
263 * nominated by UUID.
264 */
265 struct afs_addr_list *afs_vl_get_addrs_u(struct afs_net *net,
266 struct afs_addr_cursor *ac,
267 struct key *key,
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 __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 = key;
285 call->reply[0] = NULL;
286 call->ret_reply0 = true;
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] = ntohl(u->node[i]);
303
304 trace_afs_make_vl_call(call);
305 return (struct afs_addr_list *)afs_make_call(ac, call, GFP_KERNEL, false);
306 }
307
308 /*
309 * Deliver reply data to an VL.GetCapabilities operation.
310 */
311 static int afs_deliver_vl_get_capabilities(struct afs_call *call)
312 {
313 u32 count;
314 int ret;
315
316 _enter("{%u,%zu/%u}", call->unmarshall, call->offset, call->count);
317
318 again:
319 switch (call->unmarshall) {
320 case 0:
321 call->offset = 0;
322 call->unmarshall++;
323
324 /* Extract the capabilities word count */
325 case 1:
326 ret = afs_extract_data(call, &call->tmp,
327 1 * sizeof(__be32),
328 true);
329 if (ret < 0)
330 return ret;
331
332 count = ntohl(call->tmp);
333
334 call->count = count;
335 call->count2 = count;
336 call->offset = 0;
337 call->unmarshall++;
338
339 /* Extract capabilities words */
340 case 2:
341 count = min(call->count, 16U);
342 ret = afs_extract_data(call, call->buffer,
343 count * sizeof(__be32),
344 call->count > 16);
345 if (ret < 0)
346 return ret;
347
348 /* TODO: Examine capabilities */
349
350 call->count -= count;
351 if (call->count > 0)
352 goto again;
353 call->offset = 0;
354 call->unmarshall++;
355 break;
356 }
357
358 call->reply[0] = (void *)(unsigned long)call->service_id;
359
360 _leave(" = 0 [done]");
361 return 0;
362 }
363
364 /*
365 * VL.GetCapabilities operation type
366 */
367 static const struct afs_call_type afs_RXVLGetCapabilities = {
368 .name = "VL.GetCapabilities",
369 .op = afs_VL_GetCapabilities,
370 .deliver = afs_deliver_vl_get_capabilities,
371 .destructor = afs_flat_call_destructor,
372 };
373
374 /*
375 * Probe a fileserver for the capabilities that it supports. This can
376 * return up to 196 words.
377 *
378 * We use this to probe for service upgrade to determine what the server at the
379 * other end supports.
380 */
381 int afs_vl_get_capabilities(struct afs_net *net,
382 struct afs_addr_cursor *ac,
383 struct key *key)
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 -ENOMEM;
393
394 call->key = key;
395 call->upgrade = true; /* Let's see if this is a YFS server */
396 call->reply[0] = (void *)VLGETCAPABILITIES;
397 call->ret_reply0 = true;
398
399 /* marshall the parameters */
400 bp = call->request;
401 *bp++ = htonl(VLGETCAPABILITIES);
402
403 /* Can't take a ref on server */
404 trace_afs_make_vl_call(call);
405 return afs_make_call(ac, call, GFP_KERNEL, false);
406 }
407
408 /*
409 * Deliver reply data to a YFSVL.GetEndpoints call.
410 *
411 * GetEndpoints(IN yfsServerAttributes *attr,
412 * OUT opr_uuid *uuid,
413 * OUT afs_int32 *uniquifier,
414 * OUT endpoints *fsEndpoints,
415 * OUT endpoints *volEndpoints)
416 */
417 static int afs_deliver_yfsvl_get_endpoints(struct afs_call *call)
418 {
419 struct afs_addr_list *alist;
420 __be32 *bp;
421 u32 uniquifier, size;
422 int ret;
423
424 _enter("{%u,%zu/%u,%u}", call->unmarshall, call->offset, call->count, call->count2);
425
426 again:
427 switch (call->unmarshall) {
428 case 0:
429 call->offset = 0;
430 call->unmarshall = 1;
431
432 /* Extract the returned uuid, uniquifier, fsEndpoints count and
433 * either the first fsEndpoint type or the volEndpoints
434 * count if there are no fsEndpoints. */
435 case 1:
436 ret = afs_extract_data(call, call->buffer,
437 sizeof(uuid_t) +
438 3 * sizeof(__be32),
439 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 -EBADMSG;
450
451 alist = afs_alloc_addrlist(call->count, FS_SERVICE, AFS_FS_PORT);
452 if (!alist)
453 return -ENOMEM;
454 alist->version = uniquifier;
455 call->reply[0] = alist;
456 call->offset = 0;
457
458 if (call->count == 0)
459 goto extract_volendpoints;
460
461 call->unmarshall = 2;
462
463 /* Extract fsEndpoints[] entries */
464 case 2:
465 switch (call->count2) {
466 case YFS_ENDPOINT_IPV4:
467 size = sizeof(__be32) * (1 + 1 + 1);
468 break;
469 case YFS_ENDPOINT_IPV6:
470 size = sizeof(__be32) * (1 + 4 + 1);
471 break;
472 default:
473 return -EBADMSG;
474 }
475
476 size += sizeof(__be32);
477 ret = afs_extract_data(call, call->buffer, size, true);
478 if (ret < 0)
479 return ret;
480
481 alist = call->reply[0];
482 bp = call->buffer;
483 switch (call->count2) {
484 case YFS_ENDPOINT_IPV4:
485 if (ntohl(bp[0]) != sizeof(__be32) * 2)
486 return -EBADMSG;
487 afs_merge_fs_addr4(alist, bp[1], ntohl(bp[2]));
488 bp += 3;
489 break;
490 case YFS_ENDPOINT_IPV6:
491 if (ntohl(bp[0]) != sizeof(__be32) * 5)
492 return -EBADMSG;
493 afs_merge_fs_addr6(alist, bp + 1, ntohl(bp[5]));
494 bp += 6;
495 break;
496 default:
497 return -EBADMSG;
498 }
499
500 /* Got either the type of the next entry or the count of
501 * volEndpoints if no more fsEndpoints.
502 */
503 call->count2 = htonl(*bp++);
504
505 call->offset = 0;
506 call->count--;
507 if (call->count > 0)
508 goto again;
509
510 extract_volendpoints:
511 /* Extract the list of volEndpoints. */
512 call->count = call->count2;
513 if (!call->count)
514 goto end;
515 if (call->count > YFS_MAXENDPOINTS)
516 return -EBADMSG;
517
518 call->unmarshall = 3;
519
520 /* Extract the type of volEndpoints[0]. Normally we would
521 * extract the type of the next endpoint when we extract the
522 * data of the current one, but this is the first...
523 */
524 case 3:
525 ret = afs_extract_data(call, call->buffer, sizeof(__be32), true);
526 if (ret < 0)
527 return ret;
528
529 bp = call->buffer;
530 call->count2 = htonl(*bp++);
531 call->offset = 0;
532 call->unmarshall = 4;
533
534 /* Extract volEndpoints[] entries */
535 case 4:
536 switch (call->count2) {
537 case YFS_ENDPOINT_IPV4:
538 size = sizeof(__be32) * (1 + 1 + 1);
539 break;
540 case YFS_ENDPOINT_IPV6:
541 size = sizeof(__be32) * (1 + 4 + 1);
542 break;
543 default:
544 return -EBADMSG;
545 }
546
547 if (call->count > 1)
548 size += sizeof(__be32);
549 ret = afs_extract_data(call, call->buffer, size, true);
550 if (ret < 0)
551 return ret;
552
553 bp = call->buffer;
554 switch (call->count2) {
555 case YFS_ENDPOINT_IPV4:
556 if (ntohl(bp[0]) != sizeof(__be32) * 2)
557 return -EBADMSG;
558 bp += 3;
559 break;
560 case YFS_ENDPOINT_IPV6:
561 if (ntohl(bp[0]) != sizeof(__be32) * 5)
562 return -EBADMSG;
563 bp += 6;
564 break;
565 default:
566 return -EBADMSG;
567 }
568
569 /* Got either the type of the next entry or the count of
570 * volEndpoints if no more fsEndpoints.
571 */
572 call->offset = 0;
573 call->count--;
574 if (call->count > 0) {
575 call->count2 = htonl(*bp++);
576 goto again;
577 }
578
579 end:
580 call->unmarshall = 5;
581
582 /* Done */
583 case 5:
584 ret = afs_extract_data(call, call->buffer, 0, false);
585 if (ret < 0)
586 return ret;
587 call->unmarshall = 6;
588
589 case 6:
590 break;
591 }
592
593 alist = call->reply[0];
594
595 /* Start with IPv6 if available. */
596 if (alist->nr_ipv4 < alist->nr_addrs)
597 alist->index = alist->nr_ipv4;
598
599 _leave(" = 0 [done]");
600 return 0;
601 }
602
603 /*
604 * YFSVL.GetEndpoints operation type.
605 */
606 static const struct afs_call_type afs_YFSVLGetEndpoints = {
607 .name = "YFSVL.GetEndpoints",
608 .op = afs_YFSVL_GetEndpoints,
609 .deliver = afs_deliver_yfsvl_get_endpoints,
610 .destructor = afs_vl_get_addrs_u_destructor,
611 };
612
613 /*
614 * Dispatch an operation to get the addresses for a server, where the server is
615 * nominated by UUID.
616 */
617 struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_net *net,
618 struct afs_addr_cursor *ac,
619 struct key *key,
620 const uuid_t *uuid)
621 {
622 struct afs_call *call;
623 __be32 *bp;
624
625 _enter("");
626
627 call = afs_alloc_flat_call(net, &afs_YFSVLGetEndpoints,
628 sizeof(__be32) * 2 + sizeof(*uuid),
629 sizeof(struct in6_addr) + sizeof(__be32) * 3);
630 if (!call)
631 return ERR_PTR(-ENOMEM);
632
633 call->key = key;
634 call->reply[0] = NULL;
635 call->ret_reply0 = true;
636
637 /* Marshall the parameters */
638 bp = call->request;
639 *bp++ = htonl(YVLGETENDPOINTS);
640 *bp++ = htonl(YFS_SERVER_UUID);
641 memcpy(bp, uuid, sizeof(*uuid)); /* Type opr_uuid */
642
643 trace_afs_make_vl_call(call);
644 return (struct afs_addr_list *)afs_make_call(ac, call, GFP_KERNEL, false);
645 }
ubuntu-bionic-kernel mirror