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