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         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  */
  99 static 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  */
 110 struct 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  */
 173 static 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  */
 247 static 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  */
 258 struct 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  */
 317 static 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
 359 static 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  */
 369 static 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  */
 384 struct 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  */
 430 static 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  */
 622 static 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  */
 633 struct 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  */
 679 static 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 > AFS_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  */
 741 static 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  */
 755 char *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 }