1 /* cmservice.c: 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/sched.h> 15 #include <linux/completion.h> 16 #include "server.h" 17 #include "cell.h" 18 #include "transport.h" 19 #include <rxrpc/rxrpc.h> 20 #include <rxrpc/transport.h> 21 #include <rxrpc/connection.h> 22 #include <rxrpc/call.h> 23 #include "cmservice.h" 24 #include "internal.h" 25 26 static unsigned afscm_usage; /* AFS cache manager usage count */ 27 static struct rw_semaphore afscm_sem; /* AFS cache manager start/stop semaphore */ 28 29 static int afscm_new_call(struct rxrpc_call *call); 30 static void afscm_attention(struct rxrpc_call *call); 31 static void afscm_error(struct rxrpc_call *call); 32 static void afscm_aemap(struct rxrpc_call *call); 33 34 static void _SRXAFSCM_CallBack(struct rxrpc_call *call); 35 static void _SRXAFSCM_InitCallBackState(struct rxrpc_call *call); 36 static void _SRXAFSCM_Probe(struct rxrpc_call *call); 37 38 typedef void (*_SRXAFSCM_xxxx_t)(struct rxrpc_call *call); 39 40 static const struct rxrpc_operation AFSCM_ops[] = { 41 { 42 .id = 204, 43 .asize = RXRPC_APP_MARK_EOF, 44 .name = "CallBack", 45 .user = _SRXAFSCM_CallBack, 46 }, 47 { 48 .id = 205, 49 .asize = RXRPC_APP_MARK_EOF, 50 .name = "InitCallBackState", 51 .user = _SRXAFSCM_InitCallBackState, 52 }, 53 { 54 .id = 206, 55 .asize = RXRPC_APP_MARK_EOF, 56 .name = "Probe", 57 .user = _SRXAFSCM_Probe, 58 }, 59 #if 0 60 { 61 .id = 207, 62 .asize = RXRPC_APP_MARK_EOF, 63 .name = "GetLock", 64 .user = _SRXAFSCM_GetLock, 65 }, 66 { 67 .id = 208, 68 .asize = RXRPC_APP_MARK_EOF, 69 .name = "GetCE", 70 .user = _SRXAFSCM_GetCE, 71 }, 72 { 73 .id = 209, 74 .asize = RXRPC_APP_MARK_EOF, 75 .name = "GetXStatsVersion", 76 .user = _SRXAFSCM_GetXStatsVersion, 77 }, 78 { 79 .id = 210, 80 .asize = RXRPC_APP_MARK_EOF, 81 .name = "GetXStats", 82 .user = _SRXAFSCM_GetXStats, 83 } 84 #endif 85 }; 86 87 static struct rxrpc_service AFSCM_service = { 88 .name = "AFS/CM", 89 .owner = THIS_MODULE, 90 .link = LIST_HEAD_INIT(AFSCM_service.link), 91 .new_call = afscm_new_call, 92 .service_id = 1, 93 .attn_func = afscm_attention, 94 .error_func = afscm_error, 95 .aemap_func = afscm_aemap, 96 .ops_begin = &AFSCM_ops[0], 97 .ops_end = &AFSCM_ops[sizeof(AFSCM_ops) / sizeof(AFSCM_ops[0])], 98 }; 99 100 static DECLARE_COMPLETION(kafscmd_alive); 101 static DECLARE_COMPLETION(kafscmd_dead); 102 static DECLARE_WAIT_QUEUE_HEAD(kafscmd_sleepq); 103 static LIST_HEAD(kafscmd_attention_list); 104 static LIST_HEAD(afscm_calls); 105 static DEFINE_SPINLOCK(afscm_calls_lock); 106 static DEFINE_SPINLOCK(kafscmd_attention_lock); 107 static int kafscmd_die; 108 109 /*****************************************************************************/ 110 /* 111 * AFS Cache Manager kernel thread 112 */ 113 static int kafscmd(void *arg) 114 { 115 DECLARE_WAITQUEUE(myself, current); 116 117 struct rxrpc_call *call; 118 _SRXAFSCM_xxxx_t func; 119 int die; 120 121 printk("kAFS: Started kafscmd %d\n", current->pid); 122 123 daemonize("kafscmd"); 124 125 complete(&kafscmd_alive); 126 127 /* loop around looking for things to attend to */ 128 do { 129 if (list_empty(&kafscmd_attention_list)) { 130 set_current_state(TASK_INTERRUPTIBLE); 131 add_wait_queue(&kafscmd_sleepq, &myself); 132 133 for (;;) { 134 set_current_state(TASK_INTERRUPTIBLE); 135 if (!list_empty(&kafscmd_attention_list) || 136 signal_pending(current) || 137 kafscmd_die) 138 break; 139 140 schedule(); 141 } 142 143 remove_wait_queue(&kafscmd_sleepq, &myself); 144 set_current_state(TASK_RUNNING); 145 } 146 147 die = kafscmd_die; 148 149 /* dequeue the next call requiring attention */ 150 call = NULL; 151 spin_lock(&kafscmd_attention_lock); 152 153 if (!list_empty(&kafscmd_attention_list)) { 154 call = list_entry(kafscmd_attention_list.next, 155 struct rxrpc_call, 156 app_attn_link); 157 list_del_init(&call->app_attn_link); 158 die = 0; 159 } 160 161 spin_unlock(&kafscmd_attention_lock); 162 163 if (call) { 164 /* act upon it */ 165 _debug("@@@ Begin Attend Call %p", call); 166 167 func = call->app_user; 168 if (func) 169 func(call); 170 171 rxrpc_put_call(call); 172 173 _debug("@@@ End Attend Call %p", call); 174 } 175 176 } while(!die); 177 178 /* and that's all */ 179 complete_and_exit(&kafscmd_dead, 0); 180 181 } /* end kafscmd() */ 182 183 /*****************************************************************************/ 184 /* 185 * handle a call coming in to the cache manager 186 * - if I want to keep the call, I must increment its usage count 187 * - the return value will be negated and passed back in an abort packet if 188 * non-zero 189 * - serialised by virtue of there only being one krxiod 190 */ 191 static int afscm_new_call(struct rxrpc_call *call) 192 { 193 _enter("%p{cid=%u u=%d}", 194 call, ntohl(call->call_id), atomic_read(&call->usage)); 195 196 rxrpc_get_call(call); 197 198 /* add to my current call list */ 199 spin_lock(&afscm_calls_lock); 200 list_add(&call->app_link,&afscm_calls); 201 spin_unlock(&afscm_calls_lock); 202 203 _leave(" = 0"); 204 return 0; 205 206 } /* end afscm_new_call() */ 207 208 /*****************************************************************************/ 209 /* 210 * queue on the kafscmd queue for attention 211 */ 212 static void afscm_attention(struct rxrpc_call *call) 213 { 214 _enter("%p{cid=%u u=%d}", 215 call, ntohl(call->call_id), atomic_read(&call->usage)); 216 217 spin_lock(&kafscmd_attention_lock); 218 219 if (list_empty(&call->app_attn_link)) { 220 list_add_tail(&call->app_attn_link, &kafscmd_attention_list); 221 rxrpc_get_call(call); 222 } 223 224 spin_unlock(&kafscmd_attention_lock); 225 226 wake_up(&kafscmd_sleepq); 227 228 _leave(" {u=%d}", atomic_read(&call->usage)); 229 } /* end afscm_attention() */ 230 231 /*****************************************************************************/ 232 /* 233 * handle my call being aborted 234 * - clean up, dequeue and put my ref to the call 235 */ 236 static void afscm_error(struct rxrpc_call *call) 237 { 238 int removed; 239 240 _enter("%p{est=%s ac=%u er=%d}", 241 call, 242 rxrpc_call_error_states[call->app_err_state], 243 call->app_abort_code, 244 call->app_errno); 245 246 spin_lock(&kafscmd_attention_lock); 247 248 if (list_empty(&call->app_attn_link)) { 249 list_add_tail(&call->app_attn_link, &kafscmd_attention_list); 250 rxrpc_get_call(call); 251 } 252 253 spin_unlock(&kafscmd_attention_lock); 254 255 removed = 0; 256 spin_lock(&afscm_calls_lock); 257 if (!list_empty(&call->app_link)) { 258 list_del_init(&call->app_link); 259 removed = 1; 260 } 261 spin_unlock(&afscm_calls_lock); 262 263 if (removed) 264 rxrpc_put_call(call); 265 266 wake_up(&kafscmd_sleepq); 267 268 _leave(""); 269 } /* end afscm_error() */ 270 271 /*****************************************************************************/ 272 /* 273 * map afs abort codes to/from Linux error codes 274 * - called with call->lock held 275 */ 276 static void afscm_aemap(struct rxrpc_call *call) 277 { 278 switch (call->app_err_state) { 279 case RXRPC_ESTATE_LOCAL_ABORT: 280 call->app_abort_code = -call->app_errno; 281 break; 282 case RXRPC_ESTATE_PEER_ABORT: 283 call->app_errno = -ECONNABORTED; 284 break; 285 default: 286 break; 287 } 288 } /* end afscm_aemap() */ 289 290 /*****************************************************************************/ 291 /* 292 * start the cache manager service if not already started 293 */ 294 int afscm_start(void) 295 { 296 int ret; 297 298 down_write(&afscm_sem); 299 if (!afscm_usage) { 300 ret = kernel_thread(kafscmd, NULL, 0); 301 if (ret < 0) 302 goto out; 303 304 wait_for_completion(&kafscmd_alive); 305 306 ret = rxrpc_add_service(afs_transport, &AFSCM_service); 307 if (ret < 0) 308 goto kill; 309 310 afs_kafstimod_add_timer(&afs_mntpt_expiry_timer, 311 afs_mntpt_expiry_timeout * HZ); 312 } 313 314 afscm_usage++; 315 up_write(&afscm_sem); 316 317 return 0; 318 319 kill: 320 kafscmd_die = 1; 321 wake_up(&kafscmd_sleepq); 322 wait_for_completion(&kafscmd_dead); 323 324 out: 325 up_write(&afscm_sem); 326 return ret; 327 328 } /* end afscm_start() */ 329 330 /*****************************************************************************/ 331 /* 332 * stop the cache manager service 333 */ 334 void afscm_stop(void) 335 { 336 struct rxrpc_call *call; 337 338 down_write(&afscm_sem); 339 340 BUG_ON(afscm_usage == 0); 341 afscm_usage--; 342 343 if (afscm_usage == 0) { 344 /* don't want more incoming calls */ 345 rxrpc_del_service(afs_transport, &AFSCM_service); 346 347 /* abort any calls I've still got open (the afscm_error() will 348 * dequeue them) */ 349 spin_lock(&afscm_calls_lock); 350 while (!list_empty(&afscm_calls)) { 351 call = list_entry(afscm_calls.next, 352 struct rxrpc_call, 353 app_link); 354 355 list_del_init(&call->app_link); 356 rxrpc_get_call(call); 357 spin_unlock(&afscm_calls_lock); 358 359 rxrpc_call_abort(call, -ESRCH); /* abort, dequeue and 360 * put */ 361 362 _debug("nuking active call %08x.%d", 363 ntohl(call->conn->conn_id), 364 ntohl(call->call_id)); 365 rxrpc_put_call(call); 366 rxrpc_put_call(call); 367 368 spin_lock(&afscm_calls_lock); 369 } 370 spin_unlock(&afscm_calls_lock); 371 372 /* get rid of my daemon */ 373 kafscmd_die = 1; 374 wake_up(&kafscmd_sleepq); 375 wait_for_completion(&kafscmd_dead); 376 377 /* dispose of any calls waiting for attention */ 378 spin_lock(&kafscmd_attention_lock); 379 while (!list_empty(&kafscmd_attention_list)) { 380 call = list_entry(kafscmd_attention_list.next, 381 struct rxrpc_call, 382 app_attn_link); 383 384 list_del_init(&call->app_attn_link); 385 spin_unlock(&kafscmd_attention_lock); 386 387 rxrpc_put_call(call); 388 389 spin_lock(&kafscmd_attention_lock); 390 } 391 spin_unlock(&kafscmd_attention_lock); 392 393 afs_kafstimod_del_timer(&afs_mntpt_expiry_timer); 394 } 395 396 up_write(&afscm_sem); 397 398 } /* end afscm_stop() */ 399 400 /*****************************************************************************/ 401 /* 402 * handle the fileserver breaking a set of callbacks 403 */ 404 static void _SRXAFSCM_CallBack(struct rxrpc_call *call) 405 { 406 struct afs_server *server; 407 size_t count, qty, tmp; 408 int ret = 0, removed; 409 410 _enter("%p{acs=%s}", call, rxrpc_call_states[call->app_call_state]); 411 412 server = afs_server_get_from_peer(call->conn->peer); 413 414 switch (call->app_call_state) { 415 /* we've received the last packet 416 * - drain all the data from the call and send the reply 417 */ 418 case RXRPC_CSTATE_SRVR_GOT_ARGS: 419 ret = -EBADMSG; 420 qty = call->app_ready_qty; 421 if (qty < 8 || qty > 50 * (6 * 4) + 8) 422 break; 423 424 { 425 struct afs_callback *cb, *pcb; 426 int loop; 427 __be32 *fp, *bp; 428 429 fp = rxrpc_call_alloc_scratch(call, qty); 430 431 /* drag the entire argument block out to the scratch 432 * space */ 433 ret = rxrpc_call_read_data(call, fp, qty, 0); 434 if (ret < 0) 435 break; 436 437 /* and unmarshall the parameter block */ 438 ret = -EBADMSG; 439 count = ntohl(*fp++); 440 if (count>AFSCBMAX || 441 (count * (3 * 4) + 8 != qty && 442 count * (6 * 4) + 8 != qty)) 443 break; 444 445 bp = fp + count*3; 446 tmp = ntohl(*bp++); 447 if (tmp > 0 && tmp != count) 448 break; 449 if (tmp == 0) 450 bp = NULL; 451 452 pcb = cb = rxrpc_call_alloc_scratch_s( 453 call, struct afs_callback); 454 455 for (loop = count - 1; loop >= 0; loop--) { 456 pcb->fid.vid = ntohl(*fp++); 457 pcb->fid.vnode = ntohl(*fp++); 458 pcb->fid.unique = ntohl(*fp++); 459 if (bp) { 460 pcb->version = ntohl(*bp++); 461 pcb->expiry = ntohl(*bp++); 462 pcb->type = ntohl(*bp++); 463 } 464 else { 465 pcb->version = 0; 466 pcb->expiry = 0; 467 pcb->type = AFSCM_CB_UNTYPED; 468 } 469 pcb++; 470 } 471 472 /* invoke the actual service routine */ 473 ret = SRXAFSCM_CallBack(server, count, cb); 474 if (ret < 0) 475 break; 476 } 477 478 /* send the reply */ 479 ret = rxrpc_call_write_data(call, 0, NULL, RXRPC_LAST_PACKET, 480 GFP_KERNEL, 0, &count); 481 if (ret < 0) 482 break; 483 break; 484 485 /* operation complete */ 486 case RXRPC_CSTATE_COMPLETE: 487 call->app_user = NULL; 488 removed = 0; 489 spin_lock(&afscm_calls_lock); 490 if (!list_empty(&call->app_link)) { 491 list_del_init(&call->app_link); 492 removed = 1; 493 } 494 spin_unlock(&afscm_calls_lock); 495 496 if (removed) 497 rxrpc_put_call(call); 498 break; 499 500 /* operation terminated on error */ 501 case RXRPC_CSTATE_ERROR: 502 call->app_user = NULL; 503 break; 504 505 default: 506 break; 507 } 508 509 if (ret < 0) 510 rxrpc_call_abort(call, ret); 511 512 afs_put_server(server); 513 514 _leave(" = %d", ret); 515 516 } /* end _SRXAFSCM_CallBack() */ 517 518 /*****************************************************************************/ 519 /* 520 * handle the fileserver asking us to initialise our callback state 521 */ 522 static void _SRXAFSCM_InitCallBackState(struct rxrpc_call *call) 523 { 524 struct afs_server *server; 525 size_t count; 526 int ret = 0, removed; 527 528 _enter("%p{acs=%s}", call, rxrpc_call_states[call->app_call_state]); 529 530 server = afs_server_get_from_peer(call->conn->peer); 531 532 switch (call->app_call_state) { 533 /* we've received the last packet - drain all the data from the 534 * call */ 535 case RXRPC_CSTATE_SRVR_GOT_ARGS: 536 /* shouldn't be any args */ 537 ret = -EBADMSG; 538 break; 539 540 /* send the reply when asked for it */ 541 case RXRPC_CSTATE_SRVR_SND_REPLY: 542 /* invoke the actual service routine */ 543 ret = SRXAFSCM_InitCallBackState(server); 544 if (ret < 0) 545 break; 546 547 ret = rxrpc_call_write_data(call, 0, NULL, RXRPC_LAST_PACKET, 548 GFP_KERNEL, 0, &count); 549 if (ret < 0) 550 break; 551 break; 552 553 /* operation complete */ 554 case RXRPC_CSTATE_COMPLETE: 555 call->app_user = NULL; 556 removed = 0; 557 spin_lock(&afscm_calls_lock); 558 if (!list_empty(&call->app_link)) { 559 list_del_init(&call->app_link); 560 removed = 1; 561 } 562 spin_unlock(&afscm_calls_lock); 563 564 if (removed) 565 rxrpc_put_call(call); 566 break; 567 568 /* operation terminated on error */ 569 case RXRPC_CSTATE_ERROR: 570 call->app_user = NULL; 571 break; 572 573 default: 574 break; 575 } 576 577 if (ret < 0) 578 rxrpc_call_abort(call, ret); 579 580 afs_put_server(server); 581 582 _leave(" = %d", ret); 583 584 } /* end _SRXAFSCM_InitCallBackState() */ 585 586 /*****************************************************************************/ 587 /* 588 * handle a probe from a fileserver 589 */ 590 static void _SRXAFSCM_Probe(struct rxrpc_call *call) 591 { 592 struct afs_server *server; 593 size_t count; 594 int ret = 0, removed; 595 596 _enter("%p{acs=%s}", call, rxrpc_call_states[call->app_call_state]); 597 598 server = afs_server_get_from_peer(call->conn->peer); 599 600 switch (call->app_call_state) { 601 /* we've received the last packet - drain all the data from the 602 * call */ 603 case RXRPC_CSTATE_SRVR_GOT_ARGS: 604 /* shouldn't be any args */ 605 ret = -EBADMSG; 606 break; 607 608 /* send the reply when asked for it */ 609 case RXRPC_CSTATE_SRVR_SND_REPLY: 610 /* invoke the actual service routine */ 611 ret = SRXAFSCM_Probe(server); 612 if (ret < 0) 613 break; 614 615 ret = rxrpc_call_write_data(call, 0, NULL, RXRPC_LAST_PACKET, 616 GFP_KERNEL, 0, &count); 617 if (ret < 0) 618 break; 619 break; 620 621 /* operation complete */ 622 case RXRPC_CSTATE_COMPLETE: 623 call->app_user = NULL; 624 removed = 0; 625 spin_lock(&afscm_calls_lock); 626 if (!list_empty(&call->app_link)) { 627 list_del_init(&call->app_link); 628 removed = 1; 629 } 630 spin_unlock(&afscm_calls_lock); 631 632 if (removed) 633 rxrpc_put_call(call); 634 break; 635 636 /* operation terminated on error */ 637 case RXRPC_CSTATE_ERROR: 638 call->app_user = NULL; 639 break; 640 641 default: 642 break; 643 } 644 645 if (ret < 0) 646 rxrpc_call_abort(call, ret); 647 648 afs_put_server(server); 649 650 _leave(" = %d", ret); 651 652 } /* end _SRXAFSCM_Probe() */ 653