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 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 108 static 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 */ 117 static 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 */ 128 struct 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 */ 180 static 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 247 static 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 */ 256 static 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 */ 267 struct 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 */ 313 static 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 355 static 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 */ 364 static 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 */ 379 struct 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 */ 420 static 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 */ 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, 618 }; 619 620 /* 621 * Dispatch an operation to get the addresses for a server, where the server is 622 * nominated by UUID. 623 */ 624 struct 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 } 653