net/sunrpc/svc.c

   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 #define __KERNEL_SYSCALLS__
  10 #include <linux/linkage.h>
  11 #include <linux/sched.h>
  12 #include <linux/errno.h>
  13 #include <linux/net.h>
  14 #include <linux/in.h>
  15 #include <linux/unistd.h>
  16
  17 #include <linux/sunrpc/types.h>
  18 #include <linux/sunrpc/xdr.h>
  19 #include <linux/sunrpc/stats.h>
  20 #include <linux/sunrpc/svcsock.h>
  21 #include <linux/sunrpc/clnt.h>
  22
  23 #define RPCDBG_FACILITY RPCDBG_SVCDSP
  24 #define RPC_PARANOIA 1
  25
  26 /*
  27  * Create an RPC service
  28  */
  29 struct svc_serv *
  30 svc_create(struct svc_program *prog, unsigned int bufsize, unsigned int xdrsize)
  31 {
  32         struct svc_serv *serv;
  33
  34         xdr_init();
  35 #ifdef RPC_DEBUG
  36         rpc_register_sysctl();
  37 #endif
  38
  39         if (!(serv = (struct svc_serv *) kmalloc(sizeof(*serv), GFP_KERNEL)))
  40                 return NULL;
  41
  42         memset(serv, 0, sizeof(*serv));
  43         serv->sv_program   = prog;
  44         serv->sv_nrthreads = 1;
  45         serv->sv_stats     = prog->pg_stats;
  46         serv->sv_bufsz     = bufsize? bufsize : 4096;
  47         serv->sv_xdrsize   = xdrsize;
  48         spin_lock_init(&serv->sv_lock);
  49
  50         serv->sv_name      = prog->pg_name;
  51
  52         /* Remove any stale portmap registrations */
  53         svc_register(serv, 0, 0);
  54
  55         return serv;
  56 }
  57
  58 /*
  59  * Destroy an RPC service
  60  */
  61 void
  62 svc_destroy(struct svc_serv *serv)
  63 {
  64         struct svc_sock *svsk;
  65
  66         dprintk("RPC: svc_destroy(%s, %d)\n",
  67                                 serv->sv_program->pg_name,
  68                                 serv->sv_nrthreads);
  69
  70         if (serv->sv_nrthreads) {
  71                 if (--(serv->sv_nrthreads) != 0)
  72                         return;
  73         } else
  74                 printk("svc_destroy: no threads for serv=%p!\n", serv);
  75
  76         while ((svsk = serv->sv_allsocks) != NULL)
  77                 svc_delete_socket(svsk);
  78
  79         /* Unregister service with the portmapper */
  80         svc_register(serv, 0, 0);
  81         kfree(serv);
  82 }
  83
  84 /*
  85  * Allocate an RPC server buffer
  86  * Later versions may do nifty things by allocating multiple pages
  87  * of memory directly and putting them into the bufp->iov.
  88  */
  89 int
  90 svc_init_buffer(struct svc_buf *bufp, unsigned int size)
  91 {
  92         if (!(bufp->area = (u32 *) kmalloc(size, GFP_KERNEL)))
  93                 return 0;
  94         bufp->base   = bufp->area;
  95         bufp->buf    = bufp->area;
  96         bufp->len    = 0;
  97         bufp->buflen = size >> 2;
  98
  99         bufp->iov[0].iov_base = bufp->area;
 100         bufp->iov[0].iov_len  = size;
 101         bufp->nriov = 1;
 102
 103         return 1;
 104 }
 105
 106 /*
 107  * Release an RPC server buffer
 108  */
 109 void
 110 svc_release_buffer(struct svc_buf *bufp)
 111 {
 112         kfree(bufp->area);
 113         bufp->area = 0;
 114 }
 115
 116 /*
 117  * Create a server thread
 118  */
 119 int
 120 svc_create_thread(svc_thread_fn func, struct svc_serv *serv)
 121 {
 122         struct svc_rqst *rqstp;
 123         int             error = -ENOMEM;
 124
 125         rqstp = kmalloc(sizeof(*rqstp), GFP_KERNEL);
 126         if (!rqstp)
 127                 goto out;
 128
 129         memset(rqstp, 0, sizeof(*rqstp));
 130         init_waitqueue_head(&rqstp->rq_wait);
 131
 132         if (!(rqstp->rq_argp = (u32 *) kmalloc(serv->sv_xdrsize, GFP_KERNEL))
 133          || !(rqstp->rq_resp = (u32 *) kmalloc(serv->sv_xdrsize, GFP_KERNEL))
 134          || !svc_init_buffer(&rqstp->rq_defbuf, serv->sv_bufsz))
 135                 goto out_thread;
 136
 137         serv->sv_nrthreads++;
 138         rqstp->rq_server = serv;
 139         error = kernel_thread((int (*)(void *)) func, rqstp, 0);
 140         if (error < 0)
 141                 goto out_thread;
 142         error = 0;
 143 out:
 144         return error;
 145
 146 out_thread:
 147         svc_exit_thread(rqstp);
 148         goto out;
 149 }
 150
 151 /*
 152  * Destroy an RPC server thread
 153  */
 154 void
 155 svc_exit_thread(struct svc_rqst *rqstp)
 156 {
 157         struct svc_serv *serv = rqstp->rq_server;
 158
 159         svc_release_buffer(&rqstp->rq_defbuf);
 160         if (rqstp->rq_resp)
 161                 kfree(rqstp->rq_resp);
 162         if (rqstp->rq_argp)
 163                 kfree(rqstp->rq_argp);
 164         kfree(rqstp);
 165
 166         /* Release the server */
 167         if (serv)
 168                 svc_destroy(serv);
 169 }
 170
 171 /*
 172  * Register an RPC service with the local portmapper.
 173  * To unregister a service, call this routine with
 174  * proto and port == 0.
 175  */
 176 int
 177 svc_register(struct svc_serv *serv, int proto, unsigned short port)
 178 {
 179         struct svc_program      *progp;
 180         unsigned long           flags;
 181         int                     i, error = 0, dummy;
 182
 183         progp = serv->sv_program;
 184
 185         dprintk("RPC: svc_register(%s, %s, %d)\n",
 186                 progp->pg_name, proto == IPPROTO_UDP? "udp" : "tcp", port);
 187
 188         if (!port)
 189                 current->sigpending = 0;
 190
 191         for (i = 0; i < progp->pg_nvers; i++) {
 192                 if (progp->pg_vers[i] == NULL)
 193                         continue;
 194                 error = rpc_register(progp->pg_prog, i, proto, port, &dummy);
 195                 if (error < 0)
 196                         break;
 197                 if (port && !dummy) {
 198                         error = -EACCES;
 199                         break;
 200                 }
 201         }
 202
 203         if (!port) {
 204                 spin_lock_irqsave(&current->sigmask_lock, flags);
 205                 recalc_sigpending(current);
 206                 spin_unlock_irqrestore(&current->sigmask_lock, flags);
 207         }
 208
 209         return error;
 210 }
 211
 212 /*
 213  * Process the RPC request.
 214  */
 215 int
 216 svc_process(struct svc_serv *serv, struct svc_rqst *rqstp)
 217 {
 218         struct svc_program      *progp;
 219         struct svc_version      *versp = NULL;  /* compiler food */
 220         struct svc_procedure    *procp = NULL;
 221         struct svc_buf *        argp = &rqstp->rq_argbuf;
 222         struct svc_buf *        resp = &rqstp->rq_resbuf;
 223         kxdrproc_t              xdr;
 224         u32                     *bufp, *statp;
 225         u32                     dir, prog, vers, proc,
 226                                 auth_stat, rpc_stat;
 227
 228         rpc_stat = rpc_success;
 229         bufp = argp->buf;
 230
 231         if (argp->len < 5)
 232                 goto err_short_len;
 233
 234         dir  = ntohl(*bufp++);
 235         vers = ntohl(*bufp++);
 236
 237         /* First words of reply: */
 238         svc_putlong(resp, xdr_one);             /* REPLY */
 239         svc_putlong(resp, xdr_zero);            /* ACCEPT */
 240
 241         if (dir != 0)           /* direction != CALL */
 242                 goto err_bad_dir;
 243         if (vers != 2)          /* RPC version number */
 244                 goto err_bad_rpc;
 245
 246         rqstp->rq_prog = prog = ntohl(*bufp++); /* program number */
 247         rqstp->rq_vers = vers = ntohl(*bufp++); /* version number */
 248         rqstp->rq_proc = proc = ntohl(*bufp++); /* procedure number */
 249
 250         argp->buf += 5;
 251         argp->len -= 5;
 252
 253         /* Used by nfsd to only allow the NULL procedure for amd. */
 254         if (rqstp->rq_auth && !rqstp->rq_client && proc) {
 255                 auth_stat = rpc_autherr_badcred;
 256                 goto err_bad_auth;
 257         }
 258
 259         /*
 260          * Decode auth data, and add verifier to reply buffer.
 261          * We do this before anything else in order to get a decent
 262          * auth verifier.
 263          */
 264         svc_authenticate(rqstp, &rpc_stat, &auth_stat);
 265
 266         if (rpc_stat != rpc_success)
 267                 goto err_garbage;
 268
 269         if (auth_stat != rpc_auth_ok)
 270                 goto err_bad_auth;
 271
 272         progp = serv->sv_program;
 273         if (prog != progp->pg_prog)
 274                 goto err_bad_prog;
 275
 276         if (vers >= progp->pg_nvers ||
 277           !(versp = progp->pg_vers[vers]))
 278                 goto err_bad_vers;
 279
 280         procp = versp->vs_proc + proc;
 281         if (proc >= versp->vs_nproc || !procp->pc_func)
 282                 goto err_bad_proc;
 283         rqstp->rq_server   = serv;
 284         rqstp->rq_procinfo = procp;
 285
 286         /* Syntactic check complete */
 287         serv->sv_stats->rpccnt++;
 288
 289         /* Build the reply header. */
 290         statp = resp->buf;
 291         svc_putlong(resp, rpc_success);         /* RPC_SUCCESS */
 292
 293         /* Bump per-procedure stats counter */
 294         procp->pc_count++;
 295
 296         /* Initialize storage for argp and resp */
 297         memset(rqstp->rq_argp, 0, procp->pc_argsize);
 298         memset(rqstp->rq_resp, 0, procp->pc_ressize);
 299
 300         /* Call the function that processes the request. */
 301         if (!versp->vs_dispatch) {
 302                 /* Decode arguments */
 303                 xdr = procp->pc_decode;
 304                 if (xdr && !xdr(rqstp, rqstp->rq_argbuf.buf, rqstp->rq_argp))
 305                         goto err_garbage;
 306
 307                 *statp = procp->pc_func(rqstp, rqstp->rq_argp, rqstp->rq_resp);
 308
 309                 /* Encode reply */
 310                 if (*statp == rpc_success && (xdr = procp->pc_encode)
 311                  && !xdr(rqstp, rqstp->rq_resbuf.buf, rqstp->rq_resp)) {
 312                         dprintk("svc: failed to encode reply\n");
 313                         /* serv->sv_stats->rpcsystemerr++; */
 314                         *statp = rpc_system_err;
 315                 }
 316         } else {
 317                 dprintk("svc: calling dispatcher\n");
 318                 if (!versp->vs_dispatch(rqstp, statp))
 319                         goto dropit;
 320         }
 321
 322         /* Check RPC status result */
 323         if (*statp != rpc_success)
 324                 resp->len = statp + 1 - resp->base;
 325
 326         /* Release reply info */
 327         if (procp->pc_release)
 328                 procp->pc_release(rqstp, NULL, rqstp->rq_resp);
 329
 330         if (procp->pc_encode == NULL)
 331                 goto dropit;
 332 sendit:
 333         return svc_send(rqstp);
 334
 335 dropit:
 336         dprintk("svc: svc_process dropit\n");
 337         svc_drop(rqstp);
 338         return 0;
 339
 340 err_short_len:
 341 #ifdef RPC_PARANOIA
 342         printk("svc: short len %d, dropping request\n", argp->len);
 343 #endif
 344         goto dropit;                    /* drop request */
 345
 346 err_bad_dir:
 347 #ifdef RPC_PARANOIA
 348         printk("svc: bad direction %d, dropping request\n", dir);
 349 #endif
 350         serv->sv_stats->rpcbadfmt++;
 351         goto dropit;                    /* drop request */
 352
 353 err_bad_rpc:
 354         serv->sv_stats->rpcbadfmt++;
 355         resp->buf[-1] = xdr_one;        /* REJECT */
 356         svc_putlong(resp, xdr_zero);    /* RPC_MISMATCH */
 357         svc_putlong(resp, xdr_two);     /* Only RPCv2 supported */
 358         svc_putlong(resp, xdr_two);
 359         goto sendit;
 360
 361 err_bad_auth:
 362         dprintk("svc: authentication failed (%d)\n", ntohl(auth_stat));
 363         serv->sv_stats->rpcbadauth++;
 364         resp->buf[-1] = xdr_one;        /* REJECT */
 365         svc_putlong(resp, xdr_one);     /* AUTH_ERROR */
 366         svc_putlong(resp, auth_stat);   /* status */
 367         goto sendit;
 368
 369 err_bad_prog:
 370 #ifdef RPC_PARANOIA
 371         printk("svc: unknown program %d (me %d)\n", prog, progp->pg_prog);
 372 #endif
 373         serv->sv_stats->rpcbadfmt++;
 374         svc_putlong(resp, rpc_prog_unavail);
 375         goto sendit;
 376
 377 err_bad_vers:
 378 #ifdef RPC_PARANOIA
 379         printk("svc: unknown version (%d)\n", vers);
 380 #endif
 381         serv->sv_stats->rpcbadfmt++;
 382         svc_putlong(resp, rpc_prog_mismatch);
 383         svc_putlong(resp, htonl(progp->pg_lovers));
 384         svc_putlong(resp, htonl(progp->pg_hivers));
 385         goto sendit;
 386
 387 err_bad_proc:
 388 #ifdef RPC_PARANOIA
 389         printk("svc: unknown procedure (%d)\n", proc);
 390 #endif
 391         serv->sv_stats->rpcbadfmt++;
 392         svc_putlong(resp, rpc_proc_unavail);
 393         goto sendit;
 394
 395 err_garbage:
 396 #ifdef RPC_PARANOIA
 397         printk("svc: failed to decode args\n");
 398 #endif
 399         serv->sv_stats->rpcbadfmt++;
 400         svc_putlong(resp, rpc_garbage_args);
 401         goto sendit;
 402 }