1 /* 2 * linux/net/sunrpc/svc.c 3 * 4 * High-level RPC service routines 5 * 6 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de> 7 */ 8 9 #include <linux/linkage.h> 10 #include <linux/sched.h> 11 #include <linux/errno.h> 12 #include <linux/net.h> 13 #include <linux/in.h> 14 #include <linux/mm.h> 15 16 #include <linux/sunrpc/types.h> 17 #include <linux/sunrpc/xdr.h> 18 #include <linux/sunrpc/stats.h> 19 #include <linux/sunrpc/svcsock.h> 20 #include <linux/sunrpc/clnt.h> 21 22 #define RPCDBG_FACILITY RPCDBG_SVCDSP 23 #define RPC_PARANOIA 1 24 25 /* 26 * Create an RPC service 27 */ 28 struct svc_serv * 29 svc_create(struct svc_program *prog, unsigned int bufsize) 30 { 31 struct svc_serv *serv; 32 int vers; 33 unsigned int xdrsize; 34 35 if (!(serv = (struct svc_serv *) kmalloc(sizeof(*serv), GFP_KERNEL))) 36 return NULL; 37 memset(serv, 0, sizeof(*serv)); 38 serv->sv_name = prog->pg_name; 39 serv->sv_program = prog; 40 serv->sv_nrthreads = 1; 41 serv->sv_stats = prog->pg_stats; 42 serv->sv_bufsz = bufsize? bufsize : 4096; 43 xdrsize = 0; 44 while (prog) { 45 prog->pg_lovers = prog->pg_nvers-1; 46 for (vers=0; vers<prog->pg_nvers ; vers++) 47 if (prog->pg_vers[vers]) { 48 prog->pg_hivers = vers; 49 if (prog->pg_lovers > vers) 50 prog->pg_lovers = vers; 51 if (prog->pg_vers[vers]->vs_xdrsize > xdrsize) 52 xdrsize = prog->pg_vers[vers]->vs_xdrsize; 53 } 54 prog = prog->pg_next; 55 } 56 serv->sv_xdrsize = xdrsize; 57 INIT_LIST_HEAD(&serv->sv_threads); 58 INIT_LIST_HEAD(&serv->sv_sockets); 59 INIT_LIST_HEAD(&serv->sv_tempsocks); 60 INIT_LIST_HEAD(&serv->sv_permsocks); 61 spin_lock_init(&serv->sv_lock); 62 63 /* Remove any stale portmap registrations */ 64 svc_register(serv, 0, 0); 65 66 return serv; 67 } 68 69 /* 70 * Destroy an RPC service 71 */ 72 void 73 svc_destroy(struct svc_serv *serv) 74 { 75 struct svc_sock *svsk; 76 77 dprintk("RPC: svc_destroy(%s, %d)\n", 78 serv->sv_program->pg_name, 79 serv->sv_nrthreads); 80 81 if (serv->sv_nrthreads) { 82 if (--(serv->sv_nrthreads) != 0) { 83 svc_sock_update_bufs(serv); 84 return; 85 } 86 } else 87 printk("svc_destroy: no threads for serv=%p!\n", serv); 88 89 while (!list_empty(&serv->sv_tempsocks)) { 90 svsk = list_entry(serv->sv_tempsocks.next, 91 struct svc_sock, 92 sk_list); 93 svc_delete_socket(svsk); 94 } 95 while (!list_empty(&serv->sv_permsocks)) { 96 svsk = list_entry(serv->sv_permsocks.next, 97 struct svc_sock, 98 sk_list); 99 svc_delete_socket(svsk); 100 } 101 102 cache_clean_deferred(serv); 103 104 /* Unregister service with the portmapper */ 105 svc_register(serv, 0, 0); 106 kfree(serv); 107 } 108 109 /* 110 * Allocate an RPC server's buffer space. 111 * We allocate pages and place them in rq_argpages. 112 */ 113 static int 114 svc_init_buffer(struct svc_rqst *rqstp, unsigned int size) 115 { 116 int pages; 117 int arghi; 118 119 if (size > RPCSVC_MAXPAYLOAD) 120 size = RPCSVC_MAXPAYLOAD; 121 pages = 2 + (size+ PAGE_SIZE -1) / PAGE_SIZE; 122 rqstp->rq_argused = 0; 123 rqstp->rq_resused = 0; 124 arghi = 0; 125 if (pages > RPCSVC_MAXPAGES) 126 BUG(); 127 while (pages) { 128 struct page *p = alloc_page(GFP_KERNEL); 129 if (!p) 130 break; 131 rqstp->rq_argpages[arghi++] = p; 132 pages--; 133 } 134 rqstp->rq_arghi = arghi; 135 return ! pages; 136 } 137 138 /* 139 * Release an RPC server buffer 140 */ 141 static void 142 svc_release_buffer(struct svc_rqst *rqstp) 143 { 144 while (rqstp->rq_arghi) 145 put_page(rqstp->rq_argpages[--rqstp->rq_arghi]); 146 while (rqstp->rq_resused) { 147 if (rqstp->rq_respages[--rqstp->rq_resused] == NULL) 148 continue; 149 put_page(rqstp->rq_respages[rqstp->rq_resused]); 150 } 151 rqstp->rq_argused = 0; 152 } 153 154 /* 155 * Create a server thread 156 */ 157 int 158 svc_create_thread(svc_thread_fn func, struct svc_serv *serv) 159 { 160 struct svc_rqst *rqstp; 161 int error = -ENOMEM; 162 163 rqstp = kmalloc(sizeof(*rqstp), GFP_KERNEL); 164 if (!rqstp) 165 goto out; 166 167 memset(rqstp, 0, sizeof(*rqstp)); 168 init_waitqueue_head(&rqstp->rq_wait); 169 170 if (!(rqstp->rq_argp = (u32 *) kmalloc(serv->sv_xdrsize, GFP_KERNEL)) 171 || !(rqstp->rq_resp = (u32 *) kmalloc(serv->sv_xdrsize, GFP_KERNEL)) 172 || !svc_init_buffer(rqstp, serv->sv_bufsz)) 173 goto out_thread; 174 175 serv->sv_nrthreads++; 176 rqstp->rq_server = serv; 177 error = kernel_thread((int (*)(void *)) func, rqstp, 0); 178 if (error < 0) 179 goto out_thread; 180 svc_sock_update_bufs(serv); 181 error = 0; 182 out: 183 return error; 184 185 out_thread: 186 svc_exit_thread(rqstp); 187 goto out; 188 } 189 190 /* 191 * Destroy an RPC server thread 192 */ 193 void 194 svc_exit_thread(struct svc_rqst *rqstp) 195 { 196 struct svc_serv *serv = rqstp->rq_server; 197 198 svc_release_buffer(rqstp); 199 if (rqstp->rq_resp) 200 kfree(rqstp->rq_resp); 201 if (rqstp->rq_argp) 202 kfree(rqstp->rq_argp); 203 if (rqstp->rq_auth_data) 204 kfree(rqstp->rq_auth_data); 205 kfree(rqstp); 206 207 /* Release the server */ 208 if (serv) 209 svc_destroy(serv); 210 } 211 212 /* 213 * Register an RPC service with the local portmapper. 214 * To unregister a service, call this routine with 215 * proto and port == 0. 216 */ 217 int 218 svc_register(struct svc_serv *serv, int proto, unsigned short port) 219 { 220 struct svc_program *progp; 221 unsigned long flags; 222 int i, error = 0, dummy; 223 224 progp = serv->sv_program; 225 226 dprintk("RPC: svc_register(%s, %s, %d)\n", 227 progp->pg_name, proto == IPPROTO_UDP? "udp" : "tcp", port); 228 229 if (!port) 230 clear_thread_flag(TIF_SIGPENDING); 231 232 for (i = 0; i < progp->pg_nvers; i++) { 233 if (progp->pg_vers[i] == NULL) 234 continue; 235 error = rpc_register(progp->pg_prog, i, proto, port, &dummy); 236 if (error < 0) 237 break; 238 if (port && !dummy) { 239 error = -EACCES; 240 break; 241 } 242 } 243 244 if (!port) { 245 spin_lock_irqsave(¤t->sighand->siglock, flags); 246 recalc_sigpending(); 247 spin_unlock_irqrestore(¤t->sighand->siglock, flags); 248 } 249 250 return error; 251 } 252 253 /* 254 * Process the RPC request. 255 */ 256 int 257 svc_process(struct svc_serv *serv, struct svc_rqst *rqstp) 258 { 259 struct svc_program *progp; 260 struct svc_version *versp = NULL; /* compiler food */ 261 struct svc_procedure *procp = NULL; 262 struct kvec * argv = &rqstp->rq_arg.head[0]; 263 struct kvec * resv = &rqstp->rq_res.head[0]; 264 kxdrproc_t xdr; 265 u32 *statp; 266 u32 dir, prog, vers, proc, 267 auth_stat, rpc_stat; 268 int auth_res; 269 u32 *accept_statp; 270 271 rpc_stat = rpc_success; 272 273 if (argv->iov_len < 6*4) 274 goto err_short_len; 275 276 /* setup response xdr_buf. 277 * Initially it has just one page 278 */ 279 svc_take_page(rqstp); /* must succeed */ 280 resv->iov_base = page_address(rqstp->rq_respages[0]); 281 resv->iov_len = 0; 282 rqstp->rq_res.pages = rqstp->rq_respages+1; 283 rqstp->rq_res.len = 0; 284 rqstp->rq_res.page_base = 0; 285 rqstp->rq_res.page_len = 0; 286 rqstp->rq_res.buflen = PAGE_SIZE; 287 rqstp->rq_res.tail[0].iov_len = 0; 288 /* tcp needs a space for the record length... */ 289 if (rqstp->rq_prot == IPPROTO_TCP) 290 svc_putu32(resv, 0); 291 292 rqstp->rq_xid = svc_getu32(argv); 293 svc_putu32(resv, rqstp->rq_xid); 294 295 dir = ntohl(svc_getu32(argv)); 296 vers = ntohl(svc_getu32(argv)); 297 298 /* First words of reply: */ 299 svc_putu32(resv, xdr_one); /* REPLY */ 300 301 if (dir != 0) /* direction != CALL */ 302 goto err_bad_dir; 303 if (vers != 2) /* RPC version number */ 304 goto err_bad_rpc; 305 306 /* Save position in case we later decide to reject: */ 307 accept_statp = resv->iov_base + resv->iov_len; 308 309 svc_putu32(resv, xdr_zero); /* ACCEPT */ 310 311 rqstp->rq_prog = prog = ntohl(svc_getu32(argv)); /* program number */ 312 rqstp->rq_vers = vers = ntohl(svc_getu32(argv)); /* version number */ 313 rqstp->rq_proc = proc = ntohl(svc_getu32(argv)); /* procedure number */ 314 315 progp = serv->sv_program; 316 /* 317 * Decode auth data, and add verifier to reply buffer. 318 * We do this before anything else in order to get a decent 319 * auth verifier. 320 */ 321 auth_res = svc_authenticate(rqstp, &auth_stat); 322 /* Also give the program a chance to reject this call: */ 323 if (auth_res == SVC_OK) { 324 auth_stat = rpc_autherr_badcred; 325 auth_res = progp->pg_authenticate(rqstp); 326 } 327 switch (auth_res) { 328 case SVC_OK: 329 break; 330 case SVC_GARBAGE: 331 rpc_stat = rpc_garbage_args; 332 goto err_bad; 333 case SVC_SYSERR: 334 rpc_stat = rpc_system_err; 335 goto err_bad; 336 case SVC_DENIED: 337 goto err_bad_auth; 338 case SVC_DROP: 339 goto dropit; 340 case SVC_COMPLETE: 341 goto sendit; 342 } 343 344 for (progp = serv->sv_program; progp; progp = progp->pg_next) 345 if (prog == progp->pg_prog) 346 break; 347 if (progp == NULL) 348 goto err_bad_prog; 349 350 if (vers >= progp->pg_nvers || 351 !(versp = progp->pg_vers[vers])) 352 goto err_bad_vers; 353 354 procp = versp->vs_proc + proc; 355 if (proc >= versp->vs_nproc || !procp->pc_func) 356 goto err_bad_proc; 357 rqstp->rq_server = serv; 358 rqstp->rq_procinfo = procp; 359 360 /* Syntactic check complete */ 361 serv->sv_stats->rpccnt++; 362 363 /* Build the reply header. */ 364 statp = resv->iov_base +resv->iov_len; 365 svc_putu32(resv, rpc_success); /* RPC_SUCCESS */ 366 367 /* Bump per-procedure stats counter */ 368 procp->pc_count++; 369 370 /* Initialize storage for argp and resp */ 371 memset(rqstp->rq_argp, 0, procp->pc_argsize); 372 memset(rqstp->rq_resp, 0, procp->pc_ressize); 373 374 /* un-reserve some of the out-queue now that we have a 375 * better idea of reply size 376 */ 377 if (procp->pc_xdrressize) 378 svc_reserve(rqstp, procp->pc_xdrressize<<2); 379 380 /* Call the function that processes the request. */ 381 if (!versp->vs_dispatch) { 382 /* Decode arguments */ 383 xdr = procp->pc_decode; 384 if (xdr && !xdr(rqstp, argv->iov_base, rqstp->rq_argp)) 385 goto err_garbage; 386 387 *statp = procp->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp); 388 389 /* Encode reply */ 390 if (*statp == rpc_success && (xdr = procp->pc_encode) 391 && !xdr(rqstp, resv->iov_base+resv->iov_len, rqstp->rq_resp)) { 392 dprintk("svc: failed to encode reply\n"); 393 /* serv->sv_stats->rpcsystemerr++; */ 394 *statp = rpc_system_err; 395 } 396 } else { 397 dprintk("svc: calling dispatcher\n"); 398 if (!versp->vs_dispatch(rqstp, statp)) { 399 /* Release reply info */ 400 if (procp->pc_release) 401 procp->pc_release(rqstp, NULL, rqstp->rq_resp); 402 goto dropit; 403 } 404 } 405 406 /* Check RPC status result */ 407 if (*statp != rpc_success) 408 resv->iov_len = ((void*)statp) - resv->iov_base + 4; 409 410 /* Release reply info */ 411 if (procp->pc_release) 412 procp->pc_release(rqstp, NULL, rqstp->rq_resp); 413 414 if (procp->pc_encode == NULL) 415 goto dropit; 416 417 sendit: 418 if (svc_authorise(rqstp)) 419 goto dropit; 420 return svc_send(rqstp); 421 422 dropit: 423 svc_authorise(rqstp); /* doesn't hurt to call this twice */ 424 dprintk("svc: svc_process dropit\n"); 425 svc_drop(rqstp); 426 return 0; 427 428 err_short_len: 429 #ifdef RPC_PARANOIA 430 printk("svc: short len %Zd, dropping request\n", argv->iov_len); 431 #endif 432 goto dropit; /* drop request */ 433 434 err_bad_dir: 435 #ifdef RPC_PARANOIA 436 printk("svc: bad direction %d, dropping request\n", dir); 437 #endif 438 serv->sv_stats->rpcbadfmt++; 439 goto dropit; /* drop request */ 440 441 err_bad_rpc: 442 serv->sv_stats->rpcbadfmt++; 443 svc_putu32(resv, xdr_one); /* REJECT */ 444 svc_putu32(resv, xdr_zero); /* RPC_MISMATCH */ 445 svc_putu32(resv, xdr_two); /* Only RPCv2 supported */ 446 svc_putu32(resv, xdr_two); 447 goto sendit; 448 449 err_bad_auth: 450 dprintk("svc: authentication failed (%d)\n", ntohl(auth_stat)); 451 serv->sv_stats->rpcbadauth++; 452 /* Restore write pointer to location of accept status: */ 453 xdr_ressize_check(rqstp, accept_statp); 454 svc_putu32(resv, xdr_one); /* REJECT */ 455 svc_putu32(resv, xdr_one); /* AUTH_ERROR */ 456 svc_putu32(resv, auth_stat); /* status */ 457 goto sendit; 458 459 err_bad_prog: 460 dprintk("svc: unknown program %d\n", prog); 461 serv->sv_stats->rpcbadfmt++; 462 svc_putu32(resv, rpc_prog_unavail); 463 goto sendit; 464 465 err_bad_vers: 466 #ifdef RPC_PARANOIA 467 printk("svc: unknown version (%d)\n", vers); 468 #endif 469 serv->sv_stats->rpcbadfmt++; 470 svc_putu32(resv, rpc_prog_mismatch); 471 svc_putu32(resv, htonl(progp->pg_lovers)); 472 svc_putu32(resv, htonl(progp->pg_hivers)); 473 goto sendit; 474 475 err_bad_proc: 476 #ifdef RPC_PARANOIA 477 printk("svc: unknown procedure (%d)\n", proc); 478 #endif 479 serv->sv_stats->rpcbadfmt++; 480 svc_putu32(resv, rpc_proc_unavail); 481 goto sendit; 482 483 err_garbage: 484 #ifdef RPC_PARANOIA 485 printk("svc: failed to decode args\n"); 486 #endif 487 rpc_stat = rpc_garbage_args; 488 err_bad: 489 serv->sv_stats->rpcbadfmt++; 490 svc_putu32(resv, rpc_stat); 491 goto sendit; 492 } 493