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