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