fs/afs/cmservice.c

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