callback.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466
  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/sunrpc/svc.h>
  12. #include <linux/sunrpc/svcsock.h>
  13. #include <linux/nfs_fs.h>
  14. #include <linux/mutex.h>
  15. #include <linux/freezer.h>
  16. #include <linux/kthread.h>
  17. #include <linux/sunrpc/svcauth_gss.h>
  18. #include <linux/sunrpc/bc_xprt.h>
  19. #include <net/inet_sock.h>
  20. #include "nfs4_fs.h"
  21. #include "callback.h"
  22. #include "internal.h"
  23. #define NFSDBG_FACILITY NFSDBG_CALLBACK
  24. struct nfs_callback_data {
  25. unsigned int users;
  26. struct svc_serv *serv;
  27. struct svc_rqst *rqst;
  28. struct task_struct *task;
  29. };
  30. static struct nfs_callback_data nfs_callback_info[NFS4_MAX_MINOR_VERSION + 1];
  31. static DEFINE_MUTEX(nfs_callback_mutex);
  32. static struct svc_program nfs4_callback_program;
  33. unsigned short nfs_callback_tcpport6;
  34. static int nfs4_callback_up_net(struct svc_serv *serv, struct net *net)
  35. {
  36. int ret;
  37. ret = svc_create_xprt(serv, "tcp", net, PF_INET,
  38. nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
  39. if (ret <= 0)
  40. goto out_err;
  41. nfs_callback_tcpport = ret;
  42. dprintk("NFS: Callback listener port = %u (af %u, net %p)\n",
  43. nfs_callback_tcpport, PF_INET, net);
  44. ret = svc_create_xprt(serv, "tcp", net, PF_INET6,
  45. nfs_callback_set_tcpport, SVC_SOCK_ANONYMOUS);
  46. if (ret > 0) {
  47. nfs_callback_tcpport6 = ret;
  48. dprintk("NFS: Callback listener port = %u (af %u, net %p)\n",
  49. nfs_callback_tcpport6, PF_INET6, net);
  50. } else if (ret != -EAFNOSUPPORT)
  51. goto out_err;
  52. return 0;
  53. out_err:
  54. return (ret) ? ret : -ENOMEM;
  55. }
  56. /*
  57. * This is the NFSv4 callback kernel thread.
  58. */
  59. static int
  60. nfs4_callback_svc(void *vrqstp)
  61. {
  62. int err, preverr = 0;
  63. struct svc_rqst *rqstp = vrqstp;
  64. set_freezable();
  65. while (!kthread_should_stop()) {
  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. preverr = err;
  72. continue;
  73. }
  74. if (err < 0) {
  75. if (err != preverr) {
  76. printk(KERN_WARNING "NFS: %s: unexpected error "
  77. "from svc_recv (%d)\n", __func__, err);
  78. preverr = err;
  79. }
  80. schedule_timeout_uninterruptible(HZ);
  81. continue;
  82. }
  83. preverr = err;
  84. svc_process(rqstp);
  85. }
  86. return 0;
  87. }
  88. /*
  89. * Prepare to bring up the NFSv4 callback service
  90. */
  91. static struct svc_rqst *
  92. nfs4_callback_up(struct svc_serv *serv, struct rpc_xprt *xprt)
  93. {
  94. return svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);
  95. }
  96. #if defined(CONFIG_NFS_V4_1)
  97. static int nfs41_callback_up_net(struct svc_serv *serv, struct net *net)
  98. {
  99. /*
  100. * Create an svc_sock for the back channel service that shares the
  101. * fore channel connection.
  102. * Returns the input port (0) and sets the svc_serv bc_xprt on success
  103. */
  104. return svc_create_xprt(serv, "tcp-bc", net, PF_INET, 0,
  105. SVC_SOCK_ANONYMOUS);
  106. }
  107. /*
  108. * The callback service for NFSv4.1 callbacks
  109. */
  110. static int
  111. nfs41_callback_svc(void *vrqstp)
  112. {
  113. struct svc_rqst *rqstp = vrqstp;
  114. struct svc_serv *serv = rqstp->rq_server;
  115. struct rpc_rqst *req;
  116. int error;
  117. DEFINE_WAIT(wq);
  118. set_freezable();
  119. while (!kthread_should_stop()) {
  120. prepare_to_wait(&serv->sv_cb_waitq, &wq, TASK_INTERRUPTIBLE);
  121. spin_lock_bh(&serv->sv_cb_lock);
  122. if (!list_empty(&serv->sv_cb_list)) {
  123. req = list_first_entry(&serv->sv_cb_list,
  124. struct rpc_rqst, rq_bc_list);
  125. list_del(&req->rq_bc_list);
  126. spin_unlock_bh(&serv->sv_cb_lock);
  127. dprintk("Invoking bc_svc_process()\n");
  128. error = bc_svc_process(serv, req, rqstp);
  129. dprintk("bc_svc_process() returned w/ error code= %d\n",
  130. error);
  131. } else {
  132. spin_unlock_bh(&serv->sv_cb_lock);
  133. schedule();
  134. }
  135. finish_wait(&serv->sv_cb_waitq, &wq);
  136. }
  137. return 0;
  138. }
  139. /*
  140. * Bring up the NFSv4.1 callback service
  141. */
  142. static struct svc_rqst *
  143. nfs41_callback_up(struct svc_serv *serv, struct rpc_xprt *xprt)
  144. {
  145. struct svc_rqst *rqstp;
  146. /*
  147. * Save the svc_serv in the transport so that it can
  148. * be referenced when the session backchannel is initialized
  149. */
  150. xprt->bc_serv = serv;
  151. INIT_LIST_HEAD(&serv->sv_cb_list);
  152. spin_lock_init(&serv->sv_cb_lock);
  153. init_waitqueue_head(&serv->sv_cb_waitq);
  154. rqstp = svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);
  155. if (IS_ERR(rqstp)) {
  156. svc_xprt_put(serv->sv_bc_xprt);
  157. serv->sv_bc_xprt = NULL;
  158. }
  159. dprintk("--> %s return %ld\n", __func__,
  160. IS_ERR(rqstp) ? PTR_ERR(rqstp) : 0);
  161. return rqstp;
  162. }
  163. static inline int nfs_minorversion_callback_svc_setup(u32 minorversion,
  164. struct svc_serv *serv, struct rpc_xprt *xprt,
  165. struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))
  166. {
  167. if (minorversion) {
  168. *rqstpp = nfs41_callback_up(serv, xprt);
  169. *callback_svc = nfs41_callback_svc;
  170. }
  171. return minorversion;
  172. }
  173. static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
  174. struct nfs_callback_data *cb_info)
  175. {
  176. if (minorversion)
  177. xprt->bc_serv = cb_info->serv;
  178. }
  179. #else
  180. static int nfs41_callback_up_net(struct svc_serv *serv, struct net *net)
  181. {
  182. return 0;
  183. }
  184. static inline int nfs_minorversion_callback_svc_setup(u32 minorversion,
  185. struct svc_serv *serv, struct rpc_xprt *xprt,
  186. struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))
  187. {
  188. return 0;
  189. }
  190. static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,
  191. struct nfs_callback_data *cb_info)
  192. {
  193. }
  194. #endif /* CONFIG_NFS_V4_1 */
  195. static int nfs_callback_up_net(int minorversion, struct svc_serv *serv, struct net *net)
  196. {
  197. int ret;
  198. dprintk("NFS: create per-net callback data; net=%p\n", net);
  199. ret = svc_bind(serv, net);
  200. if (ret < 0) {
  201. printk(KERN_WARNING "NFS: bind callback service failed\n");
  202. goto err_bind;
  203. }
  204. switch (minorversion) {
  205. case 0:
  206. ret = nfs4_callback_up_net(serv, net);
  207. break;
  208. case 1:
  209. ret = nfs41_callback_up_net(serv, net);
  210. break;
  211. default:
  212. printk(KERN_ERR "NFS: unknown callback version: %d\n",
  213. minorversion);
  214. ret = -EINVAL;
  215. break;
  216. }
  217. if (ret < 0) {
  218. printk(KERN_ERR "NFS: callback service start failed\n");
  219. goto err_socks;
  220. }
  221. return 0;
  222. err_socks:
  223. svc_rpcb_cleanup(serv, net);
  224. err_bind:
  225. return ret;
  226. }
  227. static struct svc_serv *nfs_callback_create_svc(int minorversion)
  228. {
  229. struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
  230. struct svc_serv *serv;
  231. /*
  232. * Check whether we're already up and running.
  233. */
  234. if (cb_info->task) {
  235. /*
  236. * Note: increase service usage, because later in case of error
  237. * svc_destroy() will be called.
  238. */
  239. svc_get(cb_info->serv);
  240. return cb_info->serv;
  241. }
  242. /*
  243. * Sanity check: if there's no task,
  244. * we should be the first user ...
  245. */
  246. if (cb_info->users)
  247. printk(KERN_WARNING "nfs_callback_create_svc: no kthread, %d users??\n",
  248. cb_info->users);
  249. serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, NULL);
  250. if (!serv) {
  251. printk(KERN_ERR "nfs_callback_create_svc: create service failed\n");
  252. return ERR_PTR(-ENOMEM);
  253. }
  254. /* As there is only one thread we need to over-ride the
  255. * default maximum of 80 connections
  256. */
  257. serv->sv_maxconn = 1024;
  258. dprintk("nfs_callback_create_svc: service created\n");
  259. return serv;
  260. }
  261. /*
  262. * Bring up the callback thread if it is not already up.
  263. */
  264. int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt)
  265. {
  266. struct svc_serv *serv;
  267. struct svc_rqst *rqstp;
  268. int (*callback_svc)(void *vrqstp);
  269. struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
  270. char svc_name[12];
  271. int ret = 0;
  272. int minorversion_setup;
  273. struct net *net = xprt->xprt_net;
  274. mutex_lock(&nfs_callback_mutex);
  275. serv = nfs_callback_create_svc(minorversion);
  276. if (IS_ERR(serv)) {
  277. ret = PTR_ERR(serv);
  278. goto err_create;
  279. }
  280. if (cb_info->users++ || cb_info->task != NULL) {
  281. nfs_callback_bc_serv(minorversion, xprt, cb_info);
  282. goto out;
  283. }
  284. ret = nfs_callback_up_net(minorversion, serv, net);
  285. if (ret < 0)
  286. goto err_net;
  287. minorversion_setup = nfs_minorversion_callback_svc_setup(minorversion,
  288. serv, xprt, &rqstp, &callback_svc);
  289. if (!minorversion_setup) {
  290. /* v4.0 callback setup */
  291. rqstp = nfs4_callback_up(serv, xprt);
  292. callback_svc = nfs4_callback_svc;
  293. }
  294. if (IS_ERR(rqstp)) {
  295. ret = PTR_ERR(rqstp);
  296. goto out_err;
  297. }
  298. svc_sock_update_bufs(serv);
  299. sprintf(svc_name, "nfsv4.%u-svc", minorversion);
  300. cb_info->serv = serv;
  301. cb_info->rqst = rqstp;
  302. cb_info->task = kthread_run(callback_svc, cb_info->rqst, svc_name);
  303. if (IS_ERR(cb_info->task)) {
  304. ret = PTR_ERR(cb_info->task);
  305. svc_exit_thread(cb_info->rqst);
  306. cb_info->rqst = NULL;
  307. cb_info->task = NULL;
  308. goto out_err;
  309. }
  310. out:
  311. /*
  312. * svc_create creates the svc_serv with sv_nrthreads == 1, and then
  313. * svc_prepare_thread increments that. So we need to call svc_destroy
  314. * on both success and failure so that the refcount is 1 when the
  315. * thread exits.
  316. */
  317. svc_destroy(serv);
  318. err_create:
  319. mutex_unlock(&nfs_callback_mutex);
  320. return ret;
  321. out_err:
  322. svc_shutdown_net(serv, net);
  323. err_net:
  324. dprintk("NFS: Couldn't create callback socket or server thread; "
  325. "err = %d\n", ret);
  326. cb_info->users--;
  327. goto out;
  328. }
  329. /*
  330. * Kill the callback thread if it's no longer being used.
  331. */
  332. void nfs_callback_down(int minorversion, struct net *net)
  333. {
  334. struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];
  335. mutex_lock(&nfs_callback_mutex);
  336. cb_info->users--;
  337. if (cb_info->users == 0 && cb_info->task != NULL) {
  338. kthread_stop(cb_info->task);
  339. svc_shutdown_net(cb_info->serv, net);
  340. svc_exit_thread(cb_info->rqst);
  341. cb_info->serv = NULL;
  342. cb_info->rqst = NULL;
  343. cb_info->task = NULL;
  344. }
  345. mutex_unlock(&nfs_callback_mutex);
  346. }
  347. /* Boolean check of RPC_AUTH_GSS principal */
  348. int
  349. check_gss_callback_principal(struct nfs_client *clp, struct svc_rqst *rqstp)
  350. {
  351. char *p = rqstp->rq_cred.cr_principal;
  352. if (rqstp->rq_authop->flavour != RPC_AUTH_GSS)
  353. return 1;
  354. /* No RPC_AUTH_GSS on NFSv4.1 back channel yet */
  355. if (clp->cl_minorversion != 0)
  356. return 0;
  357. /*
  358. * It might just be a normal user principal, in which case
  359. * userspace won't bother to tell us the name at all.
  360. */
  361. if (p == NULL)
  362. return 0;
  363. /* Expect a GSS_C_NT_HOSTBASED_NAME like "nfs@serverhostname" */
  364. if (memcmp(p, "nfs@", 4) != 0)
  365. return 0;
  366. p += 4;
  367. if (strcmp(p, clp->cl_hostname) != 0)
  368. return 0;
  369. return 1;
  370. }
  371. /*
  372. * pg_authenticate method for nfsv4 callback threads.
  373. *
  374. * The authflavor has been negotiated, so an incorrect flavor is a server
  375. * bug. Drop packets with incorrect authflavor.
  376. *
  377. * All other checking done after NFS decoding where the nfs_client can be
  378. * found in nfs4_callback_compound
  379. */
  380. static int nfs_callback_authenticate(struct svc_rqst *rqstp)
  381. {
  382. switch (rqstp->rq_authop->flavour) {
  383. case RPC_AUTH_NULL:
  384. if (rqstp->rq_proc != CB_NULL)
  385. return SVC_DROP;
  386. break;
  387. case RPC_AUTH_GSS:
  388. /* No RPC_AUTH_GSS support yet in NFSv4.1 */
  389. if (svc_is_backchannel(rqstp))
  390. return SVC_DROP;
  391. }
  392. return SVC_OK;
  393. }
  394. /*
  395. * Define NFS4 callback program
  396. */
  397. static struct svc_version *nfs4_callback_version[] = {
  398. [1] = &nfs4_callback_version1,
  399. [4] = &nfs4_callback_version4,
  400. };
  401. static struct svc_stat nfs4_callback_stats;
  402. static struct svc_program nfs4_callback_program = {
  403. .pg_prog = NFS4_CALLBACK, /* RPC service number */
  404. .pg_nvers = ARRAY_SIZE(nfs4_callback_version), /* Number of entries */
  405. .pg_vers = nfs4_callback_version, /* version table */
  406. .pg_name = "NFSv4 callback", /* service name */
  407. .pg_class = "nfs", /* authentication class */
  408. .pg_stats = &nfs4_callback_stats,
  409. .pg_authenticate = nfs_callback_authenticate,
  410. };