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 kfree(rqstp->rq_resp); 200 kfree(rqstp->rq_argp); 201 kfree(rqstp->rq_auth_data); 202 kfree(rqstp); 203 204 /* Release the server */ 205 if (serv) 206 svc_destroy(serv); 207 } 208 209 /* 210 * Register an RPC service with the local portmapper. 211 * To unregister a service, call this routine with 212 * proto and port == 0. 213 */ 214 int 215 svc_register(struct svc_serv *serv, int proto, unsigned short port) 216 { 217 struct svc_program *progp; 218 unsigned long flags; 219 int i, error = 0, dummy; 220 221 progp = serv->sv_program; 222 223 dprintk("RPC: svc_register(%s, %s, %d)\n", 224 progp->pg_name, proto == IPPROTO_UDP? "udp" : "tcp", port); 225 226 if (!port) 227 clear_thread_flag(TIF_SIGPENDING); 228 229 for (i = 0; i < progp->pg_nvers; i++) { 230 if (progp->pg_vers[i] == NULL) 231 continue; 232 error = rpc_register(progp->pg_prog, i, proto, port, &dummy); 233 if (error < 0) 234 break; 235 if (port && !dummy) { 236 error = -EACCES; 237 break; 238 } 239 } 240 241 if (!port) { 242 spin_lock_irqsave(¤t->sighand->siglock, flags); 243 recalc_sigpending(); 244 spin_unlock_irqrestore(¤t->sighand->siglock, flags); 245 } 246 247 return error; 248 } 249 250 /* 251 * Process the RPC request. 252 */ 253 int 254 svc_process(struct svc_serv *serv, struct svc_rqst *rqstp) 255 { 256 struct svc_program *progp; 257 struct svc_version *versp = NULL; /* compiler food */ 258 struct svc_procedure *procp = NULL; 259 struct kvec * argv = &rqstp->rq_arg.head[0]; 260 struct kvec * resv = &rqstp->rq_res.head[0]; 261 kxdrproc_t xdr; 262 u32 *statp; 263 u32 dir, prog, vers, proc, 264 auth_stat, rpc_stat; 265 int auth_res; 266 u32 *accept_statp; 267 268 rpc_stat = rpc_success; 269 270 if (argv->iov_len < 6*4) 271 goto err_short_len; 272 273 /* setup response xdr_buf. 274 * Initially it has just one page 275 */ 276 svc_take_page(rqstp); /* must succeed */ 277 resv->iov_base = page_address(rqstp->rq_respages[0]); 278 resv->iov_len = 0; 279 rqstp->rq_res.pages = rqstp->rq_respages+1; 280 rqstp->rq_res.len = 0; 281 rqstp->rq_res.page_base = 0; 282 rqstp->rq_res.page_len = 0; 283 rqstp->rq_res.buflen = PAGE_SIZE; 284 rqstp->rq_res.tail[0].iov_len = 0; 285 /* tcp needs a space for the record length... */ 286 if (rqstp->rq_prot == IPPROTO_TCP) 287 svc_putu32(resv, 0); 288 289 rqstp->rq_xid = svc_getu32(argv); 290 svc_putu32(resv, rqstp->rq_xid); 291 292 dir = ntohl(svc_getu32(argv)); 293 vers = ntohl(svc_getu32(argv)); 294 295 /* First words of reply: */ 296 svc_putu32(resv, xdr_one); /* REPLY */ 297 298 if (dir != 0) /* direction != CALL */ 299 goto err_bad_dir; 300 if (vers != 2) /* RPC version number */ 301 goto err_bad_rpc; 302 303 /* Save position in case we later decide to reject: */ 304 accept_statp = resv->iov_base + resv->iov_len; 305 306 svc_putu32(resv, xdr_zero); /* ACCEPT */ 307 308 rqstp->rq_prog = prog = ntohl(svc_getu32(argv)); /* program number */ 309 rqstp->rq_vers = vers = ntohl(svc_getu32(argv)); /* version number */ 310 rqstp->rq_proc = proc = ntohl(svc_getu32(argv)); /* procedure number */ 311 312 progp = serv->sv_program; 313 314 for (progp = serv->sv_program; progp; progp = progp->pg_next) 315 if (prog == progp->pg_prog) 316 break; 317 318 /* 319 * Decode auth data, and add verifier to reply buffer. 320 * We do this before anything else in order to get a decent 321 * auth verifier. 322 */ 323 auth_res = svc_authenticate(rqstp, &auth_stat); 324 /* Also give the program a chance to reject this call: */ 325 if (auth_res == SVC_OK && progp) { 326 auth_stat = rpc_autherr_badcred; 327 auth_res = progp->pg_authenticate(rqstp); 328 } 329 switch (auth_res) { 330 case SVC_OK: 331 break; 332 case SVC_GARBAGE: 333 rpc_stat = rpc_garbage_args; 334 goto err_bad; 335 case SVC_SYSERR: 336 rpc_stat = rpc_system_err; 337 goto err_bad; 338 case SVC_DENIED: 339 goto err_bad_auth; 340 case SVC_DROP: 341 goto dropit; 342 case SVC_COMPLETE: 343 goto sendit; 344 } 345 346 if (progp == NULL) 347 goto err_bad_prog; 348 349 if (vers >= progp->pg_nvers || 350 !(versp = progp->pg_vers[vers])) 351 goto err_bad_vers; 352 353 procp = versp->vs_proc + proc; 354 if (proc >= versp->vs_nproc || !procp->pc_func) 355 goto err_bad_proc; 356 rqstp->rq_server = serv; 357 rqstp->rq_procinfo = procp; 358 359 /* Syntactic check complete */ 360 serv->sv_stats->rpccnt++; 361 362 /* Build the reply header. */ 363 statp = resv->iov_base +resv->iov_len; 364 svc_putu32(resv, rpc_success); /* RPC_SUCCESS */ 365 366 /* Bump per-procedure stats counter */ 367 procp->pc_count++; 368 369 /* Initialize storage for argp and resp */ 370 memset(rqstp->rq_argp, 0, procp->pc_argsize); 371 memset(rqstp->rq_resp, 0, procp->pc_ressize); 372 373 /* un-reserve some of the out-queue now that we have a 374 * better idea of reply size 375 */ 376 if (procp->pc_xdrressize) 377 svc_reserve(rqstp, procp->pc_xdrressize<<2); 378 379 /* Call the function that processes the request. */ 380 if (!versp->vs_dispatch) { 381 /* Decode arguments */ 382 xdr = procp->pc_decode; 383 if (xdr && !xdr(rqstp, argv->iov_base, rqstp->rq_argp)) 384 goto err_garbage; 385 386 *statp = procp->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp); 387 388 /* Encode reply */ 389 if (*statp == rpc_success && (xdr = procp->pc_encode) 390 && !xdr(rqstp, resv->iov_base+resv->iov_len, rqstp->rq_resp)) { 391 dprintk("svc: failed to encode reply\n"); 392 /* serv->sv_stats->rpcsystemerr++; */ 393 *statp = rpc_system_err; 394 } 395 } else { 396 dprintk("svc: calling dispatcher\n"); 397 if (!versp->vs_dispatch(rqstp, statp)) { 398 /* Release reply info */ 399 if (procp->pc_release) 400 procp->pc_release(rqstp, NULL, rqstp->rq_resp); 401 goto dropit; 402 } 403 } 404 405 /* Check RPC status result */ 406 if (*statp != rpc_success) 407 resv->iov_len = ((void*)statp) - resv->iov_base + 4; 408 409 /* Release reply info */ 410 if (procp->pc_release) 411 procp->pc_release(rqstp, NULL, rqstp->rq_resp); 412 413 if (procp->pc_encode == NULL) 414 goto dropit; 415 416 sendit: 417 if (svc_authorise(rqstp)) 418 goto dropit; 419 return svc_send(rqstp); 420 421 dropit: 422 svc_authorise(rqstp); /* doesn't hurt to call this twice */ 423 dprintk("svc: svc_process dropit\n"); 424 svc_drop(rqstp); 425 return 0; 426 427 err_short_len: 428 #ifdef RPC_PARANOIA 429 printk("svc: short len %Zd, dropping request\n", argv->iov_len); 430 #endif 431 goto dropit; /* drop request */ 432 433 err_bad_dir: 434 #ifdef RPC_PARANOIA 435 printk("svc: bad direction %d, dropping request\n", dir); 436 #endif 437 serv->sv_stats->rpcbadfmt++; 438 goto dropit; /* drop request */ 439 440 err_bad_rpc: 441 serv->sv_stats->rpcbadfmt++; 442 svc_putu32(resv, xdr_one); /* REJECT */ 443 svc_putu32(resv, xdr_zero); /* RPC_MISMATCH */ 444 svc_putu32(resv, xdr_two); /* Only RPCv2 supported */ 445 svc_putu32(resv, xdr_two); 446 goto sendit; 447 448 err_bad_auth: 449 dprintk("svc: authentication failed (%d)\n", ntohl(auth_stat)); 450 serv->sv_stats->rpcbadauth++; 451 /* Restore write pointer to location of accept status: */ 452 xdr_ressize_check(rqstp, accept_statp); 453 svc_putu32(resv, xdr_one); /* REJECT */ 454 svc_putu32(resv, xdr_one); /* AUTH_ERROR */ 455 svc_putu32(resv, auth_stat); /* status */ 456 goto sendit; 457 458 err_bad_prog: 459 dprintk("svc: unknown program %d\n", prog); 460 serv->sv_stats->rpcbadfmt++; 461 svc_putu32(resv, rpc_prog_unavail); 462 goto sendit; 463 464 err_bad_vers: 465 #ifdef RPC_PARANOIA 466 printk("svc: unknown version (%d)\n", vers); 467 #endif 468 serv->sv_stats->rpcbadfmt++; 469 svc_putu32(resv, rpc_prog_mismatch); 470 svc_putu32(resv, htonl(progp->pg_lovers)); 471 svc_putu32(resv, htonl(progp->pg_hivers)); 472 goto sendit; 473 474 err_bad_proc: 475 #ifdef RPC_PARANOIA 476 printk("svc: unknown procedure (%d)\n", proc); 477 #endif 478 serv->sv_stats->rpcbadfmt++; 479 svc_putu32(resv, rpc_proc_unavail); 480 goto sendit; 481 482 err_garbage: 483 #ifdef RPC_PARANOIA 484 printk("svc: failed to decode args\n"); 485 #endif 486 rpc_stat = rpc_garbage_args; 487 err_bad: 488 serv->sv_stats->rpcbadfmt++; 489 svc_putu32(resv, rpc_stat); 490 goto sendit; 491 } 492