callback.c 5.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214
  1. /*
  2. * linux/fs/nfs/callback.c
  3. *
  4. * Copyright (C) 2004 Trond Myklebust
  5. *
  6. * NFSv4 callback handling
  7. */
  8. #include <linux/completion.h>
  9. #include <linux/ip.h>
  10. #include <linux/module.h>
  11. #include <linux/smp_lock.h>
  12. #include <linux/sunrpc/svc.h>
  13. #include <linux/sunrpc/svcsock.h>
  14. #include <linux/nfs_fs.h>
  15. #include <linux/mutex.h>
  16. #include <net/inet_sock.h>
  17. #include "nfs4_fs.h"
  18. #include "callback.h"
  19. #include "internal.h"
  20. #define NFSDBG_FACILITY NFSDBG_CALLBACK
  21. struct nfs_callback_data {
  22. unsigned int users;
  23. struct svc_serv *serv;
  24. pid_t pid;
  25. struct completion started;
  26. struct completion stopped;
  27. };
  28. static struct nfs_callback_data nfs_callback_info;
  29. static DEFINE_MUTEX(nfs_callback_mutex);
  30. static struct svc_program nfs4_callback_program;
  31. unsigned int nfs_callback_set_tcpport;
  32. unsigned short nfs_callback_tcpport;
  33. static const int nfs_set_port_min = 0;
  34. static const int nfs_set_port_max = 65535;
  35. static int param_set_port(const char *val, struct kernel_param *kp)
  36. {
  37. char *endp;
  38. int num = simple_strtol(val, &endp, 0);
  39. if (endp == val || *endp || num < nfs_set_port_min || num > nfs_set_port_max)
  40. return -EINVAL;
  41. *((int *)kp->arg) = num;
  42. return 0;
  43. }
  44. module_param_call(callback_tcpport, param_set_port, param_get_int,
  45. &nfs_callback_set_tcpport, 0644);
  46. /*
  47. * This is the callback kernel thread.
  48. */
  49. static void nfs_callback_svc(struct svc_rqst *rqstp)
  50. {
  51. int err;
  52. __module_get(THIS_MODULE);
  53. lock_kernel();
  54. nfs_callback_info.pid = current->pid;
  55. daemonize("nfsv4-svc");
  56. /* Process request with signals blocked, but allow SIGKILL. */
  57. allow_signal(SIGKILL);
  58. complete(&nfs_callback_info.started);
  59. for(;;) {
  60. char buf[RPC_MAX_ADDRBUFLEN];
  61. if (signalled()) {
  62. if (nfs_callback_info.users == 0)
  63. break;
  64. flush_signals(current);
  65. }
  66. /*
  67. * Listen for a request on the socket
  68. */
  69. err = svc_recv(rqstp, MAX_SCHEDULE_TIMEOUT);
  70. if (err == -EAGAIN || err == -EINTR)
  71. continue;
  72. if (err < 0) {
  73. printk(KERN_WARNING
  74. "%s: terminating on error %d\n",
  75. __FUNCTION__, -err);
  76. break;
  77. }
  78. dprintk("%s: request from %s\n", __FUNCTION__,
  79. svc_print_addr(rqstp, buf, sizeof(buf)));
  80. svc_process(rqstp);
  81. }
  82. svc_exit_thread(rqstp);
  83. nfs_callback_info.pid = 0;
  84. complete(&nfs_callback_info.stopped);
  85. unlock_kernel();
  86. module_put_and_exit(0);
  87. }
  88. /*
  89. * Bring up the server process if it is not already up.
  90. */
  91. int nfs_callback_up(void)
  92. {
  93. struct svc_serv *serv;
  94. int ret = 0;
  95. lock_kernel();
  96. mutex_lock(&nfs_callback_mutex);
  97. if (nfs_callback_info.users++ || nfs_callback_info.pid != 0)
  98. goto out;
  99. init_completion(&nfs_callback_info.started);
  100. init_completion(&nfs_callback_info.stopped);
  101. serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, NULL);
  102. ret = -ENOMEM;
  103. if (!serv)
  104. goto out_err;
  105. ret = svc_makesock(serv, IPPROTO_TCP, nfs_callback_set_tcpport,
  106. SVC_SOCK_ANONYMOUS);
  107. if (ret <= 0)
  108. goto out_destroy;
  109. nfs_callback_tcpport = ret;
  110. dprintk("Callback port = 0x%x\n", nfs_callback_tcpport);
  111. ret = svc_create_thread(nfs_callback_svc, serv);
  112. if (ret < 0)
  113. goto out_destroy;
  114. nfs_callback_info.serv = serv;
  115. wait_for_completion(&nfs_callback_info.started);
  116. out:
  117. mutex_unlock(&nfs_callback_mutex);
  118. unlock_kernel();
  119. return ret;
  120. out_destroy:
  121. dprintk("Couldn't create callback socket or server thread; err = %d\n",
  122. ret);
  123. svc_destroy(serv);
  124. out_err:
  125. nfs_callback_info.users--;
  126. goto out;
  127. }
  128. /*
  129. * Kill the server process if it is not already up.
  130. */
  131. void nfs_callback_down(void)
  132. {
  133. lock_kernel();
  134. mutex_lock(&nfs_callback_mutex);
  135. nfs_callback_info.users--;
  136. do {
  137. if (nfs_callback_info.users != 0 || nfs_callback_info.pid == 0)
  138. break;
  139. if (kill_proc(nfs_callback_info.pid, SIGKILL, 1) < 0)
  140. break;
  141. } while (wait_for_completion_timeout(&nfs_callback_info.stopped, 5*HZ) == 0);
  142. mutex_unlock(&nfs_callback_mutex);
  143. unlock_kernel();
  144. }
  145. static int nfs_callback_authenticate(struct svc_rqst *rqstp)
  146. {
  147. struct sockaddr_in *addr = svc_addr_in(rqstp);
  148. struct nfs_client *clp;
  149. char buf[RPC_MAX_ADDRBUFLEN];
  150. /* Don't talk to strangers */
  151. clp = nfs_find_client(addr, 4);
  152. if (clp == NULL)
  153. return SVC_DROP;
  154. dprintk("%s: %s NFSv4 callback!\n", __FUNCTION__,
  155. svc_print_addr(rqstp, buf, sizeof(buf)));
  156. nfs_put_client(clp);
  157. switch (rqstp->rq_authop->flavour) {
  158. case RPC_AUTH_NULL:
  159. if (rqstp->rq_proc != CB_NULL)
  160. return SVC_DENIED;
  161. break;
  162. case RPC_AUTH_UNIX:
  163. break;
  164. case RPC_AUTH_GSS:
  165. /* FIXME: RPCSEC_GSS handling? */
  166. default:
  167. return SVC_DENIED;
  168. }
  169. return SVC_OK;
  170. }
  171. /*
  172. * Define NFS4 callback program
  173. */
  174. static struct svc_version *nfs4_callback_version[] = {
  175. [1] = &nfs4_callback_version1,
  176. };
  177. static struct svc_stat nfs4_callback_stats;
  178. static struct svc_program nfs4_callback_program = {
  179. .pg_prog = NFS4_CALLBACK, /* RPC service number */
  180. .pg_nvers = ARRAY_SIZE(nfs4_callback_version), /* Number of entries */
  181. .pg_vers = nfs4_callback_version, /* version table */
  182. .pg_name = "NFSv4 callback", /* service name */
  183. .pg_class = "nfs", /* authentication class */
  184. .pg_stats = &nfs4_callback_stats,
  185. .pg_authenticate = nfs_callback_authenticate,
  186. };