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
  20 static int afs_deliver_cb_init_call_back_state(struct afs_call *);
  21 static int afs_deliver_cb_init_call_back_state3(struct afs_call *);
  22 static int afs_deliver_cb_probe(struct afs_call *);
  23 static int afs_deliver_cb_callback(struct afs_call *);
  24 static int afs_deliver_cb_probe_uuid(struct afs_call *);
  25 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *);
  26 static void afs_cm_destructor(struct afs_call *);
  27 static void SRXAFSCB_CallBack(struct work_struct *);
  28 static void SRXAFSCB_InitCallBackState(struct work_struct *);
  29 static void SRXAFSCB_Probe(struct work_struct *);
  30 static void SRXAFSCB_ProbeUuid(struct work_struct *);
  31 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *);
  32
  33 #define CM_NAME(name) \
  34         const char afs_SRXCB##name##_name[] __tracepoint_string =       \
  35                 "CB." #name
  36
  37 /*
  38  * CB.CallBack operation type
  39  */
  40 static CM_NAME(CallBack);
  41 static const struct afs_call_type afs_SRXCBCallBack = {
  42         .name           = afs_SRXCBCallBack_name,
  43         .deliver        = afs_deliver_cb_callback,
  44         .abort_to_error = afs_abort_to_error,
  45         .destructor     = afs_cm_destructor,
  46         .work           = SRXAFSCB_CallBack,
  47 };
  48
  49 /*
  50  * CB.InitCallBackState operation type
  51  */
  52 static CM_NAME(InitCallBackState);
  53 static const struct afs_call_type afs_SRXCBInitCallBackState = {
  54         .name           = afs_SRXCBInitCallBackState_name,
  55         .deliver        = afs_deliver_cb_init_call_back_state,
  56         .abort_to_error = afs_abort_to_error,
  57         .destructor     = afs_cm_destructor,
  58         .work           = SRXAFSCB_InitCallBackState,
  59 };
  60
  61 /*
  62  * CB.InitCallBackState3 operation type
  63  */
  64 static CM_NAME(InitCallBackState3);
  65 static const struct afs_call_type afs_SRXCBInitCallBackState3 = {
  66         .name           = afs_SRXCBInitCallBackState3_name,
  67         .deliver        = afs_deliver_cb_init_call_back_state3,
  68         .abort_to_error = afs_abort_to_error,
  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         .abort_to_error = afs_abort_to_error,
  81         .destructor     = afs_cm_destructor,
  82         .work           = SRXAFSCB_Probe,
  83 };
  84
  85 /*
  86  * CB.ProbeUuid operation type
  87  */
  88 static CM_NAME(ProbeUuid);
  89 static const struct afs_call_type afs_SRXCBProbeUuid = {
  90         .name           = afs_SRXCBProbeUuid_name,
  91         .deliver        = afs_deliver_cb_probe_uuid,
  92         .abort_to_error = afs_abort_to_error,
  93         .destructor     = afs_cm_destructor,
  94         .work           = SRXAFSCB_ProbeUuid,
  95 };
  96
  97 /*
  98  * CB.TellMeAboutYourself operation type
  99  */
 100 static CM_NAME(TellMeAboutYourself);
 101 static const struct afs_call_type afs_SRXCBTellMeAboutYourself = {
 102         .name           = afs_SRXCBTellMeAboutYourself_name,
 103         .deliver        = afs_deliver_cb_tell_me_about_yourself,
 104         .abort_to_error = afs_abort_to_error,
 105         .destructor     = afs_cm_destructor,
 106         .work           = SRXAFSCB_TellMeAboutYourself,
 107 };
 108
 109 /*
 110  * route an incoming cache manager call
 111  * - return T if supported, F if not
 112  */
 113 bool afs_cm_incoming_call(struct afs_call *call)
 114 {
 115         _enter("{CB.OP %u}", call->operation_ID);
 116
 117         switch (call->operation_ID) {
 118         case CBCallBack:
 119                 call->type = &afs_SRXCBCallBack;
 120                 return true;
 121         case CBInitCallBackState:
 122                 call->type = &afs_SRXCBInitCallBackState;
 123                 return true;
 124         case CBInitCallBackState3:
 125                 call->type = &afs_SRXCBInitCallBackState3;
 126                 return true;
 127         case CBProbe:
 128                 call->type = &afs_SRXCBProbe;
 129                 return true;
 130         case CBProbeUuid:
 131                 call->type = &afs_SRXCBProbeUuid;
 132                 return true;
 133         case CBTellMeAboutYourself:
 134                 call->type = &afs_SRXCBTellMeAboutYourself;
 135                 return true;
 136         default:
 137                 return false;
 138         }
 139 }
 140
 141 /*
 142  * clean up a cache manager call
 143  */
 144 static void afs_cm_destructor(struct afs_call *call)
 145 {
 146         _enter("");
 147
 148         /* Break the callbacks here so that we do it after the final ACK is
 149          * received.  The step number here must match the final number in
 150          * afs_deliver_cb_callback().
 151          */
 152         if (call->unmarshall == 5) {
 153                 ASSERT(call->server && call->count && call->request);
 154                 afs_break_callbacks(call->server, call->count, call->request);
 155         }
 156
 157         afs_put_server(call->server);
 158         call->server = NULL;
 159         kfree(call->buffer);
 160         call->buffer = NULL;
 161 }
 162
 163 /*
 164  * allow the fileserver to see if the cache manager is still alive
 165  */
 166 static void SRXAFSCB_CallBack(struct work_struct *work)
 167 {
 168         struct afs_call *call = container_of(work, struct afs_call, work);
 169
 170         _enter("");
 171
 172         /* be sure to send the reply *before* attempting to spam the AFS server
 173          * with FSFetchStatus requests on the vnodes with broken callbacks lest
 174          * the AFS server get into a vicious cycle of trying to break further
 175          * callbacks because it hadn't received completion of the CBCallBack op
 176          * yet */
 177         afs_send_empty_reply(call);
 178
 179         afs_break_callbacks(call->server, call->count, call->request);
 180         afs_put_call(call);
 181         _leave("");
 182 }
 183
 184 /*
 185  * deliver request data to a CB.CallBack call
 186  */
 187 static int afs_deliver_cb_callback(struct afs_call *call)
 188 {
 189         struct sockaddr_rxrpc srx;
 190         struct afs_callback *cb;
 191         struct afs_server *server;
 192         __be32 *bp;
 193         int ret, loop;
 194
 195         _enter("{%u}", call->unmarshall);
 196
 197         switch (call->unmarshall) {
 198         case 0:
 199                 rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);
 200                 call->offset = 0;
 201                 call->unmarshall++;
 202
 203                 /* extract the FID array and its count in two steps */
 204         case 1:
 205                 _debug("extract FID count");
 206                 ret = afs_extract_data(call, &call->tmp, 4, true);
 207                 if (ret < 0)
 208                         return ret;
 209
 210                 call->count = ntohl(call->tmp);
 211                 _debug("FID count: %u", call->count);
 212                 if (call->count > AFSCBMAX)
 213                         return -EBADMSG;
 214
 215                 call->buffer = kmalloc(call->count * 3 * 4, GFP_KERNEL);
 216                 if (!call->buffer)
 217                         return -ENOMEM;
 218                 call->offset = 0;
 219                 call->unmarshall++;
 220
 221         case 2:
 222                 _debug("extract FID array");
 223                 ret = afs_extract_data(call, call->buffer,
 224                                        call->count * 3 * 4, true);
 225                 if (ret < 0)
 226                         return ret;
 227
 228                 _debug("unmarshall FID array");
 229                 call->request = kcalloc(call->count,
 230                                         sizeof(struct afs_callback),
 231                                         GFP_KERNEL);
 232                 if (!call->request)
 233                         return -ENOMEM;
 234
 235                 cb = call->request;
 236                 bp = call->buffer;
 237                 for (loop = call->count; loop > 0; loop--, cb++) {
 238                         cb->fid.vid     = ntohl(*bp++);
 239                         cb->fid.vnode   = ntohl(*bp++);
 240                         cb->fid.unique  = ntohl(*bp++);
 241                         cb->type        = AFSCM_CB_UNTYPED;
 242                 }
 243
 244                 call->offset = 0;
 245                 call->unmarshall++;
 246
 247                 /* extract the callback array and its count in two steps */
 248         case 3:
 249                 _debug("extract CB count");
 250                 ret = afs_extract_data(call, &call->tmp, 4, true);
 251                 if (ret < 0)
 252                         return ret;
 253
 254                 call->count2 = ntohl(call->tmp);
 255                 _debug("CB count: %u", call->count2);
 256                 if (call->count2 != call->count && call->count2 != 0)
 257                         return -EBADMSG;
 258                 call->offset = 0;
 259                 call->unmarshall++;
 260
 261         case 4:
 262                 _debug("extract CB array");
 263                 ret = afs_extract_data(call, call->buffer,
 264                                        call->count2 * 3 * 4, false);
 265                 if (ret < 0)
 266                         return ret;
 267
 268                 _debug("unmarshall CB array");
 269                 cb = call->request;
 270                 bp = call->buffer;
 271                 for (loop = call->count2; loop > 0; loop--, cb++) {
 272                         cb->version     = ntohl(*bp++);
 273                         cb->expiry      = ntohl(*bp++);
 274                         cb->type        = ntohl(*bp++);
 275                 }
 276
 277                 call->offset = 0;
 278                 call->unmarshall++;
 279
 280                 /* Record that the message was unmarshalled successfully so
 281                  * that the call destructor can know do the callback breaking
 282                  * work, even if the final ACK isn't received.
 283                  *
 284                  * If the step number changes, then afs_cm_destructor() must be
 285                  * updated also.
 286                  */
 287                 call->unmarshall++;
 288         case 5:
 289                 break;
 290         }
 291
 292         call->state = AFS_CALL_REPLYING;
 293
 294         /* we'll need the file server record as that tells us which set of
 295          * vnodes to operate upon */
 296         server = afs_find_server(&srx);
 297         if (!server)
 298                 return -ENOTCONN;
 299         call->server = server;
 300
 301         return afs_queue_call_work(call);
 302 }
 303
 304 /*
 305  * allow the fileserver to request callback state (re-)initialisation
 306  */
 307 static void SRXAFSCB_InitCallBackState(struct work_struct *work)
 308 {
 309         struct afs_call *call = container_of(work, struct afs_call, work);
 310
 311         _enter("{%p}", call->server);
 312
 313         afs_init_callback_state(call->server);
 314         afs_send_empty_reply(call);
 315         afs_put_call(call);
 316         _leave("");
 317 }
 318
 319 /*
 320  * deliver request data to a CB.InitCallBackState call
 321  */
 322 static int afs_deliver_cb_init_call_back_state(struct afs_call *call)
 323 {
 324         struct sockaddr_rxrpc srx;
 325         struct afs_server *server;
 326         int ret;
 327
 328         _enter("");
 329
 330         rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);
 331
 332         ret = afs_extract_data(call, NULL, 0, false);
 333         if (ret < 0)
 334                 return ret;
 335
 336         /* no unmarshalling required */
 337         call->state = AFS_CALL_REPLYING;
 338
 339         /* we'll need the file server record as that tells us which set of
 340          * vnodes to operate upon */
 341         server = afs_find_server(&srx);
 342         if (!server)
 343                 return -ENOTCONN;
 344         call->server = server;
 345
 346         return afs_queue_call_work(call);
 347 }
 348
 349 /*
 350  * deliver request data to a CB.InitCallBackState3 call
 351  */
 352 static int afs_deliver_cb_init_call_back_state3(struct afs_call *call)
 353 {
 354         struct sockaddr_rxrpc srx;
 355         struct afs_server *server;
 356         struct afs_uuid *r;
 357         unsigned loop;
 358         __be32 *b;
 359         int ret;
 360
 361         _enter("");
 362
 363         rxrpc_kernel_get_peer(afs_socket, call->rxcall, &srx);
 364
 365         _enter("{%u}", call->unmarshall);
 366
 367         switch (call->unmarshall) {
 368         case 0:
 369                 call->offset = 0;
 370                 call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL);
 371                 if (!call->buffer)
 372                         return -ENOMEM;
 373                 call->unmarshall++;
 374
 375         case 1:
 376                 _debug("extract UUID");
 377                 ret = afs_extract_data(call, call->buffer,
 378                                        11 * sizeof(__be32), false);
 379                 switch (ret) {
 380                 case 0:         break;
 381                 case -EAGAIN:   return 0;
 382                 default:        return ret;
 383                 }
 384
 385                 _debug("unmarshall UUID");
 386                 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
 387                 if (!call->request)
 388                         return -ENOMEM;
 389
 390                 b = call->buffer;
 391                 r = call->request;
 392                 r->time_low                     = b[0];
 393                 r->time_mid                     = htons(ntohl(b[1]));
 394                 r->time_hi_and_version          = htons(ntohl(b[2]));
 395                 r->clock_seq_hi_and_reserved    = ntohl(b[3]);
 396                 r->clock_seq_low                = ntohl(b[4]);
 397
 398                 for (loop = 0; loop < 6; loop++)
 399                         r->node[loop] = ntohl(b[loop + 5]);
 400
 401                 call->offset = 0;
 402                 call->unmarshall++;
 403
 404         case 2:
 405                 break;
 406         }
 407
 408         /* no unmarshalling required */
 409         call->state = AFS_CALL_REPLYING;
 410
 411         /* we'll need the file server record as that tells us which set of
 412          * vnodes to operate upon */
 413         server = afs_find_server(&srx);
 414         if (!server)
 415                 return -ENOTCONN;
 416         call->server = server;
 417
 418         return afs_queue_call_work(call);
 419 }
 420
 421 /*
 422  * allow the fileserver to see if the cache manager is still alive
 423  */
 424 static void SRXAFSCB_Probe(struct work_struct *work)
 425 {
 426         struct afs_call *call = container_of(work, struct afs_call, work);
 427
 428         _enter("");
 429         afs_send_empty_reply(call);
 430         afs_put_call(call);
 431         _leave("");
 432 }
 433
 434 /*
 435  * deliver request data to a CB.Probe call
 436  */
 437 static int afs_deliver_cb_probe(struct afs_call *call)
 438 {
 439         int ret;
 440
 441         _enter("");
 442
 443         ret = afs_extract_data(call, NULL, 0, false);
 444         if (ret < 0)
 445                 return ret;
 446
 447         /* no unmarshalling required */
 448         call->state = AFS_CALL_REPLYING;
 449
 450         return afs_queue_call_work(call);
 451 }
 452
 453 /*
 454  * allow the fileserver to quickly find out if the fileserver has been rebooted
 455  */
 456 static void SRXAFSCB_ProbeUuid(struct work_struct *work)
 457 {
 458         struct afs_call *call = container_of(work, struct afs_call, work);
 459         struct afs_uuid *r = call->request;
 460
 461         struct {
 462                 __be32  match;
 463         } reply;
 464
 465         _enter("");
 466
 467         if (memcmp(r, &afs_uuid, sizeof(afs_uuid)) == 0)
 468                 reply.match = htonl(0);
 469         else
 470                 reply.match = htonl(1);
 471
 472         afs_send_simple_reply(call, &reply, sizeof(reply));
 473         afs_put_call(call);
 474         _leave("");
 475 }
 476
 477 /*
 478  * deliver request data to a CB.ProbeUuid call
 479  */
 480 static int afs_deliver_cb_probe_uuid(struct afs_call *call)
 481 {
 482         struct afs_uuid *r;
 483         unsigned loop;
 484         __be32 *b;
 485         int ret;
 486
 487         _enter("{%u}", call->unmarshall);
 488
 489         switch (call->unmarshall) {
 490         case 0:
 491                 call->offset = 0;
 492                 call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL);
 493                 if (!call->buffer)
 494                         return -ENOMEM;
 495                 call->unmarshall++;
 496
 497         case 1:
 498                 _debug("extract UUID");
 499                 ret = afs_extract_data(call, call->buffer,
 500                                        11 * sizeof(__be32), false);
 501                 switch (ret) {
 502                 case 0:         break;
 503                 case -EAGAIN:   return 0;
 504                 default:        return ret;
 505                 }
 506
 507                 _debug("unmarshall UUID");
 508                 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
 509                 if (!call->request)
 510                         return -ENOMEM;
 511
 512                 b = call->buffer;
 513                 r = call->request;
 514                 r->time_low                     = ntohl(b[0]);
 515                 r->time_mid                     = ntohl(b[1]);
 516                 r->time_hi_and_version          = ntohl(b[2]);
 517                 r->clock_seq_hi_and_reserved    = ntohl(b[3]);
 518                 r->clock_seq_low                = ntohl(b[4]);
 519
 520                 for (loop = 0; loop < 6; loop++)
 521                         r->node[loop] = ntohl(b[loop + 5]);
 522
 523                 call->offset = 0;
 524                 call->unmarshall++;
 525
 526         case 2:
 527                 break;
 528         }
 529
 530         call->state = AFS_CALL_REPLYING;
 531
 532         return afs_queue_call_work(call);
 533 }
 534
 535 /*
 536  * allow the fileserver to ask about the cache manager's capabilities
 537  */
 538 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work)
 539 {
 540         struct afs_interface *ifs;
 541         struct afs_call *call = container_of(work, struct afs_call, work);
 542         int loop, nifs;
 543
 544         struct {
 545                 struct /* InterfaceAddr */ {
 546                         __be32 nifs;
 547                         __be32 uuid[11];
 548                         __be32 ifaddr[32];
 549                         __be32 netmask[32];
 550                         __be32 mtu[32];
 551                 } ia;
 552                 struct /* Capabilities */ {
 553                         __be32 capcount;
 554                         __be32 caps[1];
 555                 } cap;
 556         } reply;
 557
 558         _enter("");
 559
 560         nifs = 0;
 561         ifs = kcalloc(32, sizeof(*ifs), GFP_KERNEL);
 562         if (ifs) {
 563                 nifs = afs_get_ipv4_interfaces(ifs, 32, false);
 564                 if (nifs < 0) {
 565                         kfree(ifs);
 566                         ifs = NULL;
 567                         nifs = 0;
 568                 }
 569         }
 570
 571         memset(&reply, 0, sizeof(reply));
 572         reply.ia.nifs = htonl(nifs);
 573
 574         reply.ia.uuid[0] = afs_uuid.time_low;
 575         reply.ia.uuid[1] = htonl(ntohs(afs_uuid.time_mid));
 576         reply.ia.uuid[2] = htonl(ntohs(afs_uuid.time_hi_and_version));
 577         reply.ia.uuid[3] = htonl((s8) afs_uuid.clock_seq_hi_and_reserved);
 578         reply.ia.uuid[4] = htonl((s8) afs_uuid.clock_seq_low);
 579         for (loop = 0; loop < 6; loop++)
 580                 reply.ia.uuid[loop + 5] = htonl((s8) afs_uuid.node[loop]);
 581
 582         if (ifs) {
 583                 for (loop = 0; loop < nifs; loop++) {
 584                         reply.ia.ifaddr[loop] = ifs[loop].address.s_addr;
 585                         reply.ia.netmask[loop] = ifs[loop].netmask.s_addr;
 586                         reply.ia.mtu[loop] = htonl(ifs[loop].mtu);
 587                 }
 588                 kfree(ifs);
 589         }
 590
 591         reply.cap.capcount = htonl(1);
 592         reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION);
 593         afs_send_simple_reply(call, &reply, sizeof(reply));
 594         afs_put_call(call);
 595         _leave("");
 596 }
 597
 598 /*
 599  * deliver request data to a CB.TellMeAboutYourself call
 600  */
 601 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call)
 602 {
 603         int ret;
 604
 605         _enter("");
 606
 607         ret = afs_extract_data(call, NULL, 0, false);
 608         if (ret < 0)
 609                 return ret;
 610
 611         /* no unmarshalling required */
 612         call->state = AFS_CALL_REPLYING;
 613
 614         return afs_queue_call_work(call);
 615 }