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         switch (call->operation_ID) {
 111         case CBCallBack:
 112                 call->type = &afs_SRXCBCallBack;
 113                 return true;
 114         case CBInitCallBackState:
 115                 call->type = &afs_SRXCBInitCallBackState;
 116                 return true;
 117         case CBInitCallBackState3:
 118                 call->type = &afs_SRXCBInitCallBackState3;
 119                 return true;
 120         case CBProbe:
 121                 call->type = &afs_SRXCBProbe;
 122                 return true;
 123         case CBProbeUuid:
 124                 call->type = &afs_SRXCBProbeUuid;
 125                 return true;
 126         case CBTellMeAboutYourself:
 127                 call->type = &afs_SRXCBTellMeAboutYourself;
 128                 return true;
 129         case YFSCBCallBack:
 130                 if (call->service_id != YFS_CM_SERVICE)
 131                         return false;
 132                 call->type = &afs_SRXYFSCB_CallBack;
 133                 return true;
 134         default:
 135                 return false;
 136         }
 137 }
 138
 139 /*
 140  * Find the server record by peer address and record a probe to the cache
 141  * manager from a server.
 142  */
 143 static int afs_find_cm_server_by_peer(struct afs_call *call)
 144 {
 145         struct sockaddr_rxrpc srx;
 146         struct afs_server *server;
 147
 148         rxrpc_kernel_get_peer(call->net->socket, call->rxcall, &srx);
 149
 150         server = afs_find_server(call->net, &srx);
 151         if (!server) {
 152                 trace_afs_cm_no_server(call, &srx);
 153                 return 0;
 154         }
 155
 156         call->server = server;
 157         return 0;
 158 }
 159
 160 /*
 161  * Find the server record by server UUID and record a probe to the cache
 162  * manager from a server.
 163  */
 164 static int afs_find_cm_server_by_uuid(struct afs_call *call,
 165                                       struct afs_uuid *uuid)
 166 {
 167         struct afs_server *server;
 168
 169         rcu_read_lock();
 170         server = afs_find_server_by_uuid(call->net, call->request);
 171         rcu_read_unlock();
 172         if (!server) {
 173                 trace_afs_cm_no_server_u(call, call->request);
 174                 return 0;
 175         }
 176
 177         call->server = server;
 178         return 0;
 179 }
 180
 181 /*
 182  * Clean up a cache manager call.
 183  */
 184 static void afs_cm_destructor(struct afs_call *call)
 185 {
 186         kfree(call->buffer);
 187         call->buffer = NULL;
 188 }
 189
 190 /*
 191  * Abort a service call from within an action function.
 192  */
 193 static void afs_abort_service_call(struct afs_call *call, u32 abort_code, int error,
 194                                    const char *why)
 195 {
 196         rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
 197                                 abort_code, error, why);
 198         afs_set_call_complete(call, error, 0);
 199 }
 200
 201 /*
 202  * The server supplied a list of callbacks that it wanted to break.
 203  */
 204 static void SRXAFSCB_CallBack(struct work_struct *work)
 205 {
 206         struct afs_call *call = container_of(work, struct afs_call, work);
 207
 208         _enter("");
 209
 210         /* We need to break the callbacks before sending the reply as the
 211          * server holds up change visibility till it receives our reply so as
 212          * to maintain cache coherency.
 213          */
 214         if (call->server) {
 215                 trace_afs_server(call->server,
 216                                  atomic_read(&call->server->ref),
 217                                  atomic_read(&call->server->active),
 218                                  afs_server_trace_callback);
 219                 afs_break_callbacks(call->server, call->count, call->request);
 220         }
 221
 222         afs_send_empty_reply(call);
 223         afs_put_call(call);
 224         _leave("");
 225 }
 226
 227 /*
 228  * deliver request data to a CB.CallBack call
 229  */
 230 static int afs_deliver_cb_callback(struct afs_call *call)
 231 {
 232         struct afs_callback_break *cb;
 233         __be32 *bp;
 234         int ret, loop;
 235
 236         _enter("{%u}", call->unmarshall);
 237
 238         switch (call->unmarshall) {
 239         case 0:
 240                 afs_extract_to_tmp(call);
 241                 call->unmarshall++;
 242
 243                 /* extract the FID array and its count in two steps */
 244                 fallthrough;
 245         case 1:
 246                 _debug("extract FID count");
 247                 ret = afs_extract_data(call, true);
 248                 if (ret < 0)
 249                         return ret;
 250
 251                 call->count = ntohl(call->tmp);
 252                 _debug("FID count: %u", call->count);
 253                 if (call->count > AFSCBMAX)
 254                         return afs_protocol_error(call, afs_eproto_cb_fid_count);
 255
 256                 call->buffer = kmalloc(array3_size(call->count, 3, 4),
 257                                        GFP_KERNEL);
 258                 if (!call->buffer)
 259                         return -ENOMEM;
 260                 afs_extract_to_buf(call, call->count * 3 * 4);
 261                 call->unmarshall++;
 262
 263                 fallthrough;
 264         case 2:
 265                 _debug("extract FID array");
 266                 ret = afs_extract_data(call, true);
 267                 if (ret < 0)
 268                         return ret;
 269
 270                 _debug("unmarshall FID array");
 271                 call->request = kcalloc(call->count,
 272                                         sizeof(struct afs_callback_break),
 273                                         GFP_KERNEL);
 274                 if (!call->request)
 275                         return -ENOMEM;
 276
 277                 cb = call->request;
 278                 bp = call->buffer;
 279                 for (loop = call->count; loop > 0; loop--, cb++) {
 280                         cb->fid.vid     = ntohl(*bp++);
 281                         cb->fid.vnode   = ntohl(*bp++);
 282                         cb->fid.unique  = ntohl(*bp++);
 283                 }
 284
 285                 afs_extract_to_tmp(call);
 286                 call->unmarshall++;
 287
 288                 /* extract the callback array and its count in two steps */
 289                 fallthrough;
 290         case 3:
 291                 _debug("extract CB count");
 292                 ret = afs_extract_data(call, true);
 293                 if (ret < 0)
 294                         return ret;
 295
 296                 call->count2 = ntohl(call->tmp);
 297                 _debug("CB count: %u", call->count2);
 298                 if (call->count2 != call->count && call->count2 != 0)
 299                         return afs_protocol_error(call, afs_eproto_cb_count);
 300                 call->iter = &call->def_iter;
 301                 iov_iter_discard(&call->def_iter, READ, call->count2 * 3 * 4);
 302                 call->unmarshall++;
 303
 304                 fallthrough;
 305         case 4:
 306                 _debug("extract discard %zu/%u",
 307                        iov_iter_count(call->iter), call->count2 * 3 * 4);
 308
 309                 ret = afs_extract_data(call, false);
 310                 if (ret < 0)
 311                         return ret;
 312
 313                 call->unmarshall++;
 314                 fallthrough;
 315
 316         case 5:
 317                 break;
 318         }
 319
 320         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 321                 return afs_io_error(call, afs_io_error_cm_reply);
 322
 323         /* we'll need the file server record as that tells us which set of
 324          * vnodes to operate upon */
 325         return afs_find_cm_server_by_peer(call);
 326 }
 327
 328 /*
 329  * allow the fileserver to request callback state (re-)initialisation
 330  */
 331 static void SRXAFSCB_InitCallBackState(struct work_struct *work)
 332 {
 333         struct afs_call *call = container_of(work, struct afs_call, work);
 334
 335         _enter("{%p}", call->server);
 336
 337         if (call->server)
 338                 afs_init_callback_state(call->server);
 339         afs_send_empty_reply(call);
 340         afs_put_call(call);
 341         _leave("");
 342 }
 343
 344 /*
 345  * deliver request data to a CB.InitCallBackState call
 346  */
 347 static int afs_deliver_cb_init_call_back_state(struct afs_call *call)
 348 {
 349         int ret;
 350
 351         _enter("");
 352
 353         afs_extract_discard(call, 0);
 354         ret = afs_extract_data(call, false);
 355         if (ret < 0)
 356                 return ret;
 357
 358         /* we'll need the file server record as that tells us which set of
 359          * vnodes to operate upon */
 360         return afs_find_cm_server_by_peer(call);
 361 }
 362
 363 /*
 364  * deliver request data to a CB.InitCallBackState3 call
 365  */
 366 static int afs_deliver_cb_init_call_back_state3(struct afs_call *call)
 367 {
 368         struct afs_uuid *r;
 369         unsigned loop;
 370         __be32 *b;
 371         int ret;
 372
 373         _enter("");
 374
 375         _enter("{%u}", call->unmarshall);
 376
 377         switch (call->unmarshall) {
 378         case 0:
 379                 call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL);
 380                 if (!call->buffer)
 381                         return -ENOMEM;
 382                 afs_extract_to_buf(call, 11 * sizeof(__be32));
 383                 call->unmarshall++;
 384
 385                 fallthrough;
 386         case 1:
 387                 _debug("extract UUID");
 388                 ret = afs_extract_data(call, false);
 389                 switch (ret) {
 390                 case 0:         break;
 391                 case -EAGAIN:   return 0;
 392                 default:        return ret;
 393                 }
 394
 395                 _debug("unmarshall UUID");
 396                 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
 397                 if (!call->request)
 398                         return -ENOMEM;
 399
 400                 b = call->buffer;
 401                 r = call->request;
 402                 r->time_low                     = b[0];
 403                 r->time_mid                     = htons(ntohl(b[1]));
 404                 r->time_hi_and_version          = htons(ntohl(b[2]));
 405                 r->clock_seq_hi_and_reserved    = ntohl(b[3]);
 406                 r->clock_seq_low                = ntohl(b[4]);
 407
 408                 for (loop = 0; loop < 6; loop++)
 409                         r->node[loop] = ntohl(b[loop + 5]);
 410
 411                 call->unmarshall++;
 412                 fallthrough;
 413
 414         case 2:
 415                 break;
 416         }
 417
 418         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 419                 return afs_io_error(call, afs_io_error_cm_reply);
 420
 421         /* we'll need the file server record as that tells us which set of
 422          * vnodes to operate upon */
 423         return afs_find_cm_server_by_uuid(call, call->request);
 424 }
 425
 426 /*
 427  * allow the fileserver to see if the cache manager is still alive
 428  */
 429 static void SRXAFSCB_Probe(struct work_struct *work)
 430 {
 431         struct afs_call *call = container_of(work, struct afs_call, work);
 432
 433         _enter("");
 434         afs_send_empty_reply(call);
 435         afs_put_call(call);
 436         _leave("");
 437 }
 438
 439 /*
 440  * deliver request data to a CB.Probe call
 441  */
 442 static int afs_deliver_cb_probe(struct afs_call *call)
 443 {
 444         int ret;
 445
 446         _enter("");
 447
 448         afs_extract_discard(call, 0);
 449         ret = afs_extract_data(call, false);
 450         if (ret < 0)
 451                 return ret;
 452
 453         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 454                 return afs_io_error(call, afs_io_error_cm_reply);
 455         return afs_find_cm_server_by_peer(call);
 456 }
 457
 458 /*
 459  * Allow the fileserver to quickly find out if the cache manager has been
 460  * rebooted.
 461  */
 462 static void SRXAFSCB_ProbeUuid(struct work_struct *work)
 463 {
 464         struct afs_call *call = container_of(work, struct afs_call, work);
 465         struct afs_uuid *r = call->request;
 466
 467         _enter("");
 468
 469         if (memcmp(r, &call->net->uuid, sizeof(call->net->uuid)) == 0)
 470                 afs_send_empty_reply(call);
 471         else
 472                 afs_abort_service_call(call, 1, 1, "K-1");
 473
 474         afs_put_call(call);
 475         _leave("");
 476 }
 477
 478 /*
 479  * deliver request data to a CB.ProbeUuid call
 480  */
 481 static int afs_deliver_cb_probe_uuid(struct afs_call *call)
 482 {
 483         struct afs_uuid *r;
 484         unsigned loop;
 485         __be32 *b;
 486         int ret;
 487
 488         _enter("{%u}", call->unmarshall);
 489
 490         switch (call->unmarshall) {
 491         case 0:
 492                 call->buffer = kmalloc_array(11, sizeof(__be32), GFP_KERNEL);
 493                 if (!call->buffer)
 494                         return -ENOMEM;
 495                 afs_extract_to_buf(call, 11 * sizeof(__be32));
 496                 call->unmarshall++;
 497
 498                 fallthrough;
 499         case 1:
 500                 _debug("extract UUID");
 501                 ret = afs_extract_data(call, false);
 502                 switch (ret) {
 503                 case 0:         break;
 504                 case -EAGAIN:   return 0;
 505                 default:        return ret;
 506                 }
 507
 508                 _debug("unmarshall UUID");
 509                 call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
 510                 if (!call->request)
 511                         return -ENOMEM;
 512
 513                 b = call->buffer;
 514                 r = call->request;
 515                 r->time_low                     = b[0];
 516                 r->time_mid                     = htons(ntohl(b[1]));
 517                 r->time_hi_and_version          = htons(ntohl(b[2]));
 518                 r->clock_seq_hi_and_reserved    = ntohl(b[3]);
 519                 r->clock_seq_low                = ntohl(b[4]);
 520
 521                 for (loop = 0; loop < 6; loop++)
 522                         r->node[loop] = ntohl(b[loop + 5]);
 523
 524                 call->unmarshall++;
 525                 fallthrough;
 526
 527         case 2:
 528                 break;
 529         }
 530
 531         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 532                 return afs_io_error(call, afs_io_error_cm_reply);
 533         return afs_find_cm_server_by_peer(call);
 534 }
 535
 536 /*
 537  * allow the fileserver to ask about the cache manager's capabilities
 538  */
 539 static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work)
 540 {
 541         struct afs_call *call = container_of(work, struct afs_call, work);
 542         int loop;
 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         memset(&reply, 0, sizeof(reply));
 561
 562         reply.ia.uuid[0] = call->net->uuid.time_low;
 563         reply.ia.uuid[1] = htonl(ntohs(call->net->uuid.time_mid));
 564         reply.ia.uuid[2] = htonl(ntohs(call->net->uuid.time_hi_and_version));
 565         reply.ia.uuid[3] = htonl((s8) call->net->uuid.clock_seq_hi_and_reserved);
 566         reply.ia.uuid[4] = htonl((s8) call->net->uuid.clock_seq_low);
 567         for (loop = 0; loop < 6; loop++)
 568                 reply.ia.uuid[loop + 5] = htonl((s8) call->net->uuid.node[loop]);
 569
 570         reply.cap.capcount = htonl(1);
 571         reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION);
 572         afs_send_simple_reply(call, &reply, sizeof(reply));
 573         afs_put_call(call);
 574         _leave("");
 575 }
 576
 577 /*
 578  * deliver request data to a CB.TellMeAboutYourself call
 579  */
 580 static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call)
 581 {
 582         int ret;
 583
 584         _enter("");
 585
 586         afs_extract_discard(call, 0);
 587         ret = afs_extract_data(call, false);
 588         if (ret < 0)
 589                 return ret;
 590
 591         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 592                 return afs_io_error(call, afs_io_error_cm_reply);
 593         return afs_find_cm_server_by_peer(call);
 594 }
 595
 596 /*
 597  * deliver request data to a YFS CB.CallBack call
 598  */
 599 static int afs_deliver_yfs_cb_callback(struct afs_call *call)
 600 {
 601         struct afs_callback_break *cb;
 602         struct yfs_xdr_YFSFid *bp;
 603         size_t size;
 604         int ret, loop;
 605
 606         _enter("{%u}", call->unmarshall);
 607
 608         switch (call->unmarshall) {
 609         case 0:
 610                 afs_extract_to_tmp(call);
 611                 call->unmarshall++;
 612
 613                 /* extract the FID array and its count in two steps */
 614                 fallthrough;
 615         case 1:
 616                 _debug("extract FID count");
 617                 ret = afs_extract_data(call, true);
 618                 if (ret < 0)
 619                         return ret;
 620
 621                 call->count = ntohl(call->tmp);
 622                 _debug("FID count: %u", call->count);
 623                 if (call->count > YFSCBMAX)
 624                         return afs_protocol_error(call, afs_eproto_cb_fid_count);
 625
 626                 size = array_size(call->count, sizeof(struct yfs_xdr_YFSFid));
 627                 call->buffer = kmalloc(size, GFP_KERNEL);
 628                 if (!call->buffer)
 629                         return -ENOMEM;
 630                 afs_extract_to_buf(call, size);
 631                 call->unmarshall++;
 632
 633                 fallthrough;
 634         case 2:
 635                 _debug("extract FID array");
 636                 ret = afs_extract_data(call, false);
 637                 if (ret < 0)
 638                         return ret;
 639
 640                 _debug("unmarshall FID array");
 641                 call->request = kcalloc(call->count,
 642                                         sizeof(struct afs_callback_break),
 643                                         GFP_KERNEL);
 644                 if (!call->request)
 645                         return -ENOMEM;
 646
 647                 cb = call->request;
 648                 bp = call->buffer;
 649                 for (loop = call->count; loop > 0; loop--, cb++) {
 650                         cb->fid.vid     = xdr_to_u64(bp->volume);
 651                         cb->fid.vnode   = xdr_to_u64(bp->vnode.lo);
 652                         cb->fid.vnode_hi = ntohl(bp->vnode.hi);
 653                         cb->fid.unique  = ntohl(bp->vnode.unique);
 654                         bp++;
 655                 }
 656
 657                 afs_extract_to_tmp(call);
 658                 call->unmarshall++;
 659                 fallthrough;
 660
 661         case 3:
 662                 break;
 663         }
 664
 665         if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING))
 666                 return afs_io_error(call, afs_io_error_cm_reply);
 667
 668         /* We'll need the file server record as that tells us which set of
 669          * vnodes to operate upon.
 670          */
 671         return afs_find_cm_server_by_peer(call);
 672 }