callback.c 11 KB

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