fs/afs/cmservice.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* AFS Cache Manager Service
   3  *
   4  * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/init.h>
  10 #include <linux/slab.h>
  11 #include <linux/sched.h>
  12 #include <linux/ip.h>
  13 #include "internal.h"
  14 #include "afs_cm.h"
  15 #include "protocol_yfs.h"
  16
  17 static int afs_deliver_cb_init_call_back_state(struct afs_call *);
  18 static int afs_deliver_cb_init_call_back_state3(struct afs_call *);
  19 static int afs_deliver_cb_probe(struct afs_call *);
  20 static int afs_deliver_cb_callback(struct afs_call *);
  21 static int afs_deliver_cb_probe_uuid(struct afs_call *);
  22 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *);
  23 static void afs_cm_destructor(struct afs_call *);
  24 static void SRXAFSCB_CallBack(struct work_struct *);
  25 static void SRXAFSCB_InitCallBackState(struct work_struct *);
  26 static void SRXAFSCB_Probe(struct work_struct *);
  27 static void SRXAFSCB_ProbeUuid(struct work_struct *);
  28 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *);
  29
  30 static int afs_deliver_yfs_cb_callback(struct afs_call *);
  31
  32 /*
  33  * CB.CallBack operation type
  34  */
  35 static const struct afs_call_type afs_SRXCBCallBack = {
  36         .name           = "CB.CallBack",
  37         .deliver        = afs_deliver_cb_callback,
  38         .destructor     = afs_cm_destructor,
  39         .work           = SRXAFSCB_CallBack,
  40 };
  41
  42 /*
  43  * CB.InitCallBackState operation type
  44  */
  45 static const struct afs_call_type afs_SRXCBInitCallBackState = {
  46         .name           = "CB.InitCallBackState",
  47         .deliver        = afs_deliver_cb_init_call_back_state,
  48         .destructor     = afs_cm_destructor,
  49         .work           = SRXAFSCB_InitCallBackState,
  50 };
  51
  52 /*
  53  * CB.InitCallBackState3 operation type
  54  */
  55 static const struct afs_call_type afs_SRXCBInitCallBackState3 = {
  56         .name           = "CB.InitCallBackState3",
  57         .deliver        = afs_deliver_cb_init_call_back_state3,
  58         .destructor     = afs_cm_destructor,
  59         .work           = SRXAFSCB_InitCallBackState,
  60 };
  61
  62 /*
  63  * CB.Probe operation type
  64  */
  65 static const struct afs_call_type afs_SRXCBProbe = {
  66         .name           = "CB.Probe",
  67         .deliver        = afs_deliver_cb_probe,
  68         .destructor     = afs_cm_destructor,
  69         .work           = SRXAFSCB_Probe,
  70 };
  71
  72 /*
  73  * CB.ProbeUuid operation type
  74  */
  75 static const struct afs_call_type afs_SRXCBProbeUuid = {
  76         .name           = "CB.ProbeUuid",
  77         .deliver        = afs_deliver_cb_probe_uuid,
  78         .destructor     = afs_cm_destructor,
  79         .work           = SRXAFSCB_ProbeUuid,
  80 };
  81
  82 /*
  83  * CB.TellMeAboutYourself operation type
  84  */
  85 static const struct afs_call_type afs_SRXCBTellMeAboutYourself = {
  86         .name           = "CB.TellMeAboutYourself",
  87         .deliver        = afs_deliver_cb_tell_me_about_yourself,
  88         .destructor     = afs_cm_destructor,
  89         .work           = SRXAFSCB_TellMeAboutYourself,
  90 };
  91
  92 /*
  93  * YFS CB.CallBack operation type
  94  */
  95 static const struct afs_call_type afs_SRXYFSCB_CallBack = {
  96         .name           = "YFSCB.CallBack",
  97         .deliver        = afs_deliver_yfs_cb_callback,
  98         .destructor     = afs_cm_destructor,
  99         .work           = SRXAFSCB_CallBack,
 100 };
 101
 102 /*
 103  * route an incoming cache manager call
 104  * - return T if supported, F if not
 105  */
 106 bool afs_cm_incoming_call(struct afs_call *call)
 107 {
 108         _enter("{%u, CB.OP %u}", call->service_id, call->operation_ID);
 109
 110         call->epoch = rxrpc_kernel_get_epoch(call->net->socket, call->rxcall);
 111
 112         switch (call->operation_ID) {
 113         case CBCallBack:
 114                 call->type = &afs_SRXCBCallBack;
 115                 return true;
 116         case CBInitCallBackState:
 117                 call->type = &afs_SRXCBInitCallBackState;
 118                 return true;
 119         case CBInitCallBackState3:
 120                 call->type = &afs_SRXCBInitCallBackState3;
 121                 return true;
 122         case CBProbe:
 123                 call->type = &afs_SRXCBProbe;
 124                 return true;
 125         case CBProbeUuid:
 126                 call->type = &afs_SRXCBProbeUuid;
 127                 return true;
 128         case CBTellMeAboutYourself:
 129                 call->type = &afs_SRXCBTellMeAboutYourself;
 130                 return true;
 131         case YFSCBCallBack:
 132                 if (call->service_id != YFS_CM_SERVICE)
 133                         return false;
 134                 call->type = &afs_SRXYFSCB_CallBack;
 135                 return true;
 136         default:
 137                 return false;
 138         }
 139 }
 140
 141 /*
 142  * Record a probe to the cache manager from a server.
 143  */
 144 static int afs_record_cm_probe(struct afs_call *call, struct afs_server *server)
 145 {
 146         _enter("");
 147
 148         if (test_bit(AFS_SERVER_FL_HAVE_EPOCH, &server->flags) &&
 149             !test_bit(AFS_SERVER_FL_PROBING, &server->flags)) {
 150                 if (server->cm_epoch == call->epoch)
 151                         return 0;
 152
 153                 if (!server->probe.said_rebooted) {
 154                         pr_notice("kAFS: FS rebooted %pU\n", &server->uuid);
 155                         server->probe.said_rebooted = true;
 156                 }
 157         }
 158
 159         spin_lock(&server->probe_lock);
 160
 161         if (!test_and_set_bit(AFS_SERVER_FL_HAVE_EPOCH, &server->flags)) {
 162                 server->cm_epoch = call->epoch;
 163                 server->probe.cm_epoch = call->epoch;
 164                 goto out;
 165         }
 166
 167         if (server->probe.cm_probed &&
 168             call->epoch != server->probe.cm_epoch &&
 169             !server->probe.said_inconsistent) {
 170                 pr_notice("kAFS: FS endpoints inconsistent %pU\n",
 171                           &server->uuid);
 172                 server->probe.said_inconsistent = true;
 173         }
 174
 175         if (!server->probe.cm_probed || call->epoch == server->cm_epoch)
 176                 server->probe.cm_epoch = server->cm_epoch;
 177
 178 out:
 179         server->probe.cm_probed = true;
 180         spin_unlock(&server->probe_lock);
 181         return 0;
 182 }
 183
 184 /*
 185  * Find the server record by peer address and record a probe to the cache
 186  * manager from a server.
 187  */
 188 static int afs_find_cm_server_by_peer(struct afs_call *call)
 189 {
 190         struct sockaddr_rxrpc srx;
 191         struct afs_server *server;
 192
 193         rxrpc_kernel_get_peer(call->net->socket, call->rxcall, &srx);
 194
 195         server = afs_find_server(call->net, &srx);
 196         if (!server) {
 197                 trace_afs_cm_no_server(call, &srx);
 198                 return 0;
 199         }
 200
 201         call->server = server;
 202         return afs_record_cm_probe(call, server);
 203 }
 204
 205 /*
 206  * Find the server record by server UUID and record a probe to the cache
 207  * manager from a server.
 208  */
 209 static int afs_find_cm_server_by_uuid(struct afs_call *call,
 210                                       struct afs_uuid *uuid)
 211 {
 212         struct afs_server *server;
 213
 214         rcu_read_lock();
 215         server = afs_find_server_by_uuid(call->net, call->request);
 216         rcu_read_unlock();
 217         if (!server) {
 218                 trace_afs_cm_no_server_u(call, call->request);
 219                 return 0;
 220         }
 221
 222         call->server = server;
 223         return afs_record_cm_probe(call, server);
 224 }
 225
 226 /*
 227  * Clean up a cache manager call.
 228  */
 229 static void afs_cm_destructor(struct afs_call *call)
 230 {
 231         kfree(call->buffer);
 232         call->buffer = NULL;
 233 }
 234
 235 /*
 236  * Abort a service call from within an action function.
 237  */
 238 static void afs_abort_service_call(struct afs_call *call, u32 abort_code, int error,
 239                                    const char *why)
 240 {
 241         rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
 242                                 abort_code, error, why);
 243         afs_set_call_complete(call, error, 0);
 244 }
 245
 246 /*
 247  * The server supplied a list of callbacks that it wanted to break.
 248  */
 249 static void SRXAFSCB_CallBack(struct work_struct *work)
 250 {
 251         struct afs_call *call = container_of(work, struct afs_call, work);
 252
 253         _enter("");
 254
 255         /* We need to break the callbacks before sending the reply as the
 256          * server holds up change visibility till it receives our reply so as
 257          * to maintain cache coherency.
 258          */
 259         if (call->server) {
 260                 trace_afs_server(call->server, atomic_read(&call->server->usage),
 261                                  afs_server_trace_callback);
 262                 afs_break_callbacks(call->server, call->count, call->request);
 263         }
 264
 265         afs_send_empty_reply(call);
 266         afs_put_call(call);
 267         _leave("");
 268 }
 269
 270 /*
 271  * deliver request data to a CB.CallBack call
 272  */
 273 static int afs_deliver_cb_callback(struct afs_call *call)
 274 {
 275         struct afs_callback_break *cb;
 276         __be32 *bp;
 277         int ret, loop;
 278
 279         _enter("{%u}", call->unmarshall);
 280
 281         switch (call->unmarshall) {
 282         case 0:
 283                 afs_extract_to_tmp(call);
 284                 call->unmarshall++;
 285
 286                 /* extract the FID array and its count in two steps */
 287                 /* fall through */
 288         case 1:
 289                 _debug("extract FID count");
 290                 ret = afs_extract_data(call, true);
 291                 if (ret < 0)
 292                         return ret;
 293
 294                 call->count = ntohl(call->tmp);
 295                 _debug("FID count: %u", call->count);
 296                 if (call->count > AFSCBMAX)
 297                         return afs_protocol_error(call, -EBADMSG,
 298                                                   afs_eproto_cb_fid_count);
 299
 300                 call->buffer = kmalloc(array3_size(call->count, 3, 4),
 301                                        GFP_KERNEL);
 302                 if (!call->buffer)
 303                         return -ENOMEM;
 304                 afs_extract_to_buf(call, call->count * 3 * 4);
 305                 call->unmarshall++;
 306
 307                 /* Fall through */
 308         case 2:
 309                 _debug("extract FID array");
 310                 ret = afs_extract_data(call, true);
 311                 if (ret < 0)
 312                         return ret;
 313
 314                 _debug("unmarshall FID array");
 315                 call->request = kcalloc(call->count,
 316                                         sizeof(struct afs_callback_break),
 317                                         GFP_KERNEL);
 318                 if (!call->request)
 319                         return -ENOMEM;
 320
 321                 cb = call->request;
 322                 bp = call->buffer;
 323                 for (loop = call->count; loop > 0; loop--, cb++) {
 324                         cb->fid.vid     = ntohl(*bp++);
 325                         cb->fid.vnode   = ntohl(*bp++);
 326                         cb->fid.unique  = ntohl(*bp++);
 327                 }
 328
 329                 afs_extract_to_tmp(call);
 330                 call->unmarshall++;
 331
 332                 /* extract the callback array and its count in two steps */
 333                 /* fall through */
 334         case 3:
 335                 _debug("extract CB count");
 336                 ret = afs_extract_data(call, true);
 337                 if (ret < 0)
 338                         return ret;
 339
 340                 call->count2 = ntohl(call->tmp);
 341                 _debug("CB count: %u", call->count2);
 342                 if (call->count2 != call->count && call->count2 != 0)
 343                         return afs_protocol_error(call, -EBADMSG,
 344                                                   afs_eproto_cb_count);
 345                 call->_iter = &call->iter;
 346                 iov_iter_discard(&call->iter, READ, call->count2 * 3 * 4);
 347                 call->unmarshall++;
 348
 349                 /* Fall through */
 350         case 4:
 351                 _debug("extract discard %zu/%u",
 352                        iov_iter_count(&call->iter), call->count2 * 3 * 4);
 353
 354                 ret = afs_extract_data(call, false);
 355                 if (ret < 0)
 356                         return ret;
 357
 358                 call->unmarshall++;
 359         case 5:
 360                 break;
 361         }
 362
 363         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 364                 return afs_io_error(call, afs_io_error_cm_reply);
 365
 366         /* we'll need the file server record as that tells us which set of
 367          * vnodes to operate upon */
 368         return afs_find_cm_server_by_peer(call);
 369 }
 370
 371 /*
 372  * allow the fileserver to request callback state (re-)initialisation
 373  */
 374 static void SRXAFSCB_InitCallBackState(struct work_struct *work)
 375 {
 376         struct afs_call *call = container_of(work, struct afs_call, work);
 377
 378         _enter("{%p}", call->server);
 379
 380         if (call->server)
 381                 afs_init_callback_state(call->server);
 382         afs_send_empty_reply(call);
 383         afs_put_call(call);
 384         _leave("");
 385 }
 386
 387 /*
 388  * deliver request data to a CB.InitCallBackState call
 389  */
 390 static int afs_deliver_cb_init_call_back_state(struct afs_call *call)
 391 {
 392         int ret;
 393
 394         _enter("");
 395
 396         afs_extract_discard(call, 0);
 397         ret = afs_extract_data(call, false);
 398         if (ret < 0)
 399                 return ret;
 400
 401         /* we'll need the file server record as that tells us which set of
 402          * vnodes to operate upon */
 403         return afs_find_cm_server_by_peer(call);
 404 }
 405
 406 /*
 407  * deliver request data to a CB.InitCallBackState3 call
 408  */
 409 static int afs_deliver_cb_init_call_back_state3(struct afs_call *call)
 410 {
 411         struct afs_uuid *r;
 412         unsigned loop;
 413         __be32 *b;
 414         int ret;
 415
 416         _enter("");
 417
 418         _enter("{%u}", call->unmarshall);
 419
 420         switch (call->unmarshall) {
 421         case 0:
 422                 call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL);
 423                 if (!call->buffer)
 424                         return -ENOMEM;
 425                 afs_extract_to_buf(call, 11 * sizeof(__be32));
 426                 call->unmarshall++;
 427
 428                 /* Fall through */
 429         case 1:
 430                 _debug("extract UUID");
 431                 ret = afs_extract_data(call, false);
 432                 switch (ret) {
 433                 case 0:         break;
 434                 case -EAGAIN:   return 0;
 435                 default:        return ret;
 436                 }
 437
 438                 _debug("unmarshall UUID");
 439                 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
 440                 if (!call->request)
 441                         return -ENOMEM;
 442
 443                 b = call->buffer;
 444                 r = call->request;
 445                 r->time_low                     = b[0];
 446                 r->time_mid                     = htons(ntohl(b[1]));
 447                 r->time_hi_and_version          = htons(ntohl(b[2]));
 448                 r->clock_seq_hi_and_reserved    = ntohl(b[3]);
 449                 r->clock_seq_low                = ntohl(b[4]);
 450
 451                 for (loop = 0; loop < 6; loop++)
 452                         r->node[loop] = ntohl(b[loop + 5]);
 453
 454                 call->unmarshall++;
 455
 456         case 2:
 457                 break;
 458         }
 459
 460         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 461                 return afs_io_error(call, afs_io_error_cm_reply);
 462
 463         /* we'll need the file server record as that tells us which set of
 464          * vnodes to operate upon */
 465         return afs_find_cm_server_by_uuid(call, call->request);
 466 }
 467
 468 /*
 469  * allow the fileserver to see if the cache manager is still alive
 470  */
 471 static void SRXAFSCB_Probe(struct work_struct *work)
 472 {
 473         struct afs_call *call = container_of(work, struct afs_call, work);
 474
 475         _enter("");
 476         afs_send_empty_reply(call);
 477         afs_put_call(call);
 478         _leave("");
 479 }
 480
 481 /*
 482  * deliver request data to a CB.Probe call
 483  */
 484 static int afs_deliver_cb_probe(struct afs_call *call)
 485 {
 486         int ret;
 487
 488         _enter("");
 489
 490         afs_extract_discard(call, 0);
 491         ret = afs_extract_data(call, false);
 492         if (ret < 0)
 493                 return ret;
 494
 495         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 496                 return afs_io_error(call, afs_io_error_cm_reply);
 497         return afs_find_cm_server_by_peer(call);
 498 }
 499
 500 /*
 501  * allow the fileserver to quickly find out if the fileserver has been rebooted
 502  */
 503 static void SRXAFSCB_ProbeUuid(struct work_struct *work)
 504 {
 505         struct afs_call *call = container_of(work, struct afs_call, work);
 506         struct afs_uuid *r = call->request;
 507
 508         _enter("");
 509
 510         if (memcmp(r, &call->net->uuid, sizeof(call->net->uuid)) == 0)
 511                 afs_send_empty_reply(call);
 512         else
 513                 afs_abort_service_call(call, 1, 1, "K-1");
 514
 515         afs_put_call(call);
 516         _leave("");
 517 }
 518
 519 /*
 520  * deliver request data to a CB.ProbeUuid call
 521  */
 522 static int afs_deliver_cb_probe_uuid(struct afs_call *call)
 523 {
 524         struct afs_uuid *r;
 525         unsigned loop;
 526         __be32 *b;
 527         int ret;
 528
 529         _enter("{%u}", call->unmarshall);
 530
 531         switch (call->unmarshall) {
 532         case 0:
 533                 call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL);
 534                 if (!call->buffer)
 535                         return -ENOMEM;
 536                 afs_extract_to_buf(call, 11 * sizeof(__be32));
 537                 call->unmarshall++;
 538
 539                 /* Fall through */
 540         case 1:
 541                 _debug("extract UUID");
 542                 ret = afs_extract_data(call, false);
 543                 switch (ret) {
 544                 case 0:         break;
 545                 case -EAGAIN:   return 0;
 546                 default:        return ret;
 547                 }
 548
 549                 _debug("unmarshall UUID");
 550                 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
 551                 if (!call->request)
 552                         return -ENOMEM;
 553
 554                 b = call->buffer;
 555                 r = call->request;
 556                 r->time_low                     = b[0];
 557                 r->time_mid                     = htons(ntohl(b[1]));
 558                 r->time_hi_and_version          = htons(ntohl(b[2]));
 559                 r->clock_seq_hi_and_reserved    = ntohl(b[3]);
 560                 r->clock_seq_low                = ntohl(b[4]);
 561
 562                 for (loop = 0; loop < 6; loop++)
 563                         r->node[loop] = ntohl(b[loop + 5]);
 564
 565                 call->unmarshall++;
 566
 567         case 2:
 568                 break;
 569         }
 570
 571         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 572                 return afs_io_error(call, afs_io_error_cm_reply);
 573         return afs_find_cm_server_by_uuid(call, call->request);
 574 }
 575
 576 /*
 577  * allow the fileserver to ask about the cache manager's capabilities
 578  */
 579 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work)
 580 {
 581         struct afs_call *call = container_of(work, struct afs_call, work);
 582         int loop;
 583
 584         struct {
 585                 struct /* InterfaceAddr */ {
 586                         __be32 nifs;
 587                         __be32 uuid[11];
 588                         __be32 ifaddr[32];
 589                         __be32 netmask[32];
 590                         __be32 mtu[32];
 591                 } ia;
 592                 struct /* Capabilities */ {
 593                         __be32 capcount;
 594                         __be32 caps[1];
 595                 } cap;
 596         } reply;
 597
 598         _enter("");
 599
 600         memset(&reply, 0, sizeof(reply));
 601
 602         reply.ia.uuid[0] = call->net->uuid.time_low;
 603         reply.ia.uuid[1] = htonl(ntohs(call->net->uuid.time_mid));
 604         reply.ia.uuid[2] = htonl(ntohs(call->net->uuid.time_hi_and_version));
 605         reply.ia.uuid[3] = htonl((s8) call->net->uuid.clock_seq_hi_and_reserved);
 606         reply.ia.uuid[4] = htonl((s8) call->net->uuid.clock_seq_low);
 607         for (loop = 0; loop < 6; loop++)
 608                 reply.ia.uuid[loop + 5] = htonl((s8) call->net->uuid.node[loop]);
 609
 610         reply.cap.capcount = htonl(1);
 611         reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION);
 612         afs_send_simple_reply(call, &reply, sizeof(reply));
 613         afs_put_call(call);
 614         _leave("");
 615 }
 616
 617 /*
 618  * deliver request data to a CB.TellMeAboutYourself call
 619  */
 620 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call)
 621 {
 622         int ret;
 623
 624         _enter("");
 625
 626         afs_extract_discard(call, 0);
 627         ret = afs_extract_data(call, false);
 628         if (ret < 0)
 629                 return ret;
 630
 631         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 632                 return afs_io_error(call, afs_io_error_cm_reply);
 633         return afs_find_cm_server_by_peer(call);
 634 }
 635
 636 /*
 637  * deliver request data to a YFS CB.CallBack call
 638  */
 639 static int afs_deliver_yfs_cb_callback(struct afs_call *call)
 640 {
 641         struct afs_callback_break *cb;
 642         struct yfs_xdr_YFSFid *bp;
 643         size_t size;
 644         int ret, loop;
 645
 646         _enter("{%u}", call->unmarshall);
 647
 648         switch (call->unmarshall) {
 649         case 0:
 650                 afs_extract_to_tmp(call);
 651                 call->unmarshall++;
 652
 653                 /* extract the FID array and its count in two steps */
 654                 /* Fall through */
 655         case 1:
 656                 _debug("extract FID count");
 657                 ret = afs_extract_data(call, true);
 658                 if (ret < 0)
 659                         return ret;
 660
 661                 call->count = ntohl(call->tmp);
 662                 _debug("FID count: %u", call->count);
 663                 if (call->count > YFSCBMAX)
 664                         return afs_protocol_error(call, -EBADMSG,
 665                                                   afs_eproto_cb_fid_count);
 666
 667                 size = array_size(call->count, sizeof(struct yfs_xdr_YFSFid));
 668                 call->buffer = kmalloc(size, GFP_KERNEL);
 669                 if (!call->buffer)
 670                         return -ENOMEM;
 671                 afs_extract_to_buf(call, size);
 672                 call->unmarshall++;
 673
 674                 /* Fall through */
 675         case 2:
 676                 _debug("extract FID array");
 677                 ret = afs_extract_data(call, false);
 678                 if (ret < 0)
 679                         return ret;
 680
 681                 _debug("unmarshall FID array");
 682                 call->request = kcalloc(call->count,
 683                                         sizeof(struct afs_callback_break),
 684                                         GFP_KERNEL);
 685                 if (!call->request)
 686                         return -ENOMEM;
 687
 688                 cb = call->request;
 689                 bp = call->buffer;
 690                 for (loop = call->count; loop > 0; loop--, cb++) {
 691                         cb->fid.vid     = xdr_to_u64(bp->volume);
 692                         cb->fid.vnode   = xdr_to_u64(bp->vnode.lo);
 693                         cb->fid.vnode_hi = ntohl(bp->vnode.hi);
 694                         cb->fid.unique  = ntohl(bp->vnode.unique);
 695                         bp++;
 696                 }
 697
 698                 afs_extract_to_tmp(call);
 699                 call->unmarshall++;
 700
 701         case 3:
 702                 break;
 703         }
 704
 705         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 706                 return afs_io_error(call, afs_io_error_cm_reply);
 707
 708         /* We'll need the file server record as that tells us which set of
 709          * vnodes to operate upon.
 710          */
 711         return afs_find_cm_server_by_peer(call);
 712 }