svc4proc.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524
  1. /*
  2. * linux/fs/lockd/svc4proc.c
  3. *
  4. * Lockd server procedures. We don't implement the NLM_*_RES
  5. * procedures because we don't use the async procedures.
  6. *
  7. * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
  8. */
  9. #include <linux/types.h>
  10. #include <linux/time.h>
  11. #include <linux/slab.h>
  12. #include <linux/in.h>
  13. #include <linux/sunrpc/svc.h>
  14. #include <linux/sunrpc/clnt.h>
  15. #include <linux/nfsd/nfsd.h>
  16. #include <linux/lockd/lockd.h>
  17. #include <linux/lockd/share.h>
  18. #include <linux/lockd/sm_inter.h>
  19. #define NLMDBG_FACILITY NLMDBG_CLIENT
  20. /*
  21. * Obtain client and file from arguments
  22. */
  23. static __be32
  24. nlm4svc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp,
  25. struct nlm_host **hostp, struct nlm_file **filp)
  26. {
  27. struct nlm_host *host = NULL;
  28. struct nlm_file *file = NULL;
  29. struct nlm_lock *lock = &argp->lock;
  30. __be32 error = 0;
  31. /* nfsd callbacks must have been installed for this procedure */
  32. if (!nlmsvc_ops)
  33. return nlm_lck_denied_nolocks;
  34. /* Obtain host handle */
  35. if (!(host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len))
  36. || (argp->monitor && nsm_monitor(host) < 0))
  37. goto no_locks;
  38. *hostp = host;
  39. /* Obtain file pointer. Not used by FREE_ALL call. */
  40. if (filp != NULL) {
  41. if ((error = nlm_lookup_file(rqstp, &file, &lock->fh)) != 0)
  42. goto no_locks;
  43. *filp = file;
  44. /* Set up the missing parts of the file_lock structure */
  45. lock->fl.fl_file = file->f_file;
  46. lock->fl.fl_owner = (fl_owner_t) host;
  47. lock->fl.fl_lmops = &nlmsvc_lock_operations;
  48. }
  49. return 0;
  50. no_locks:
  51. if (host)
  52. nlm_release_host(host);
  53. if (error)
  54. return error;
  55. return nlm_lck_denied_nolocks;
  56. }
  57. /*
  58. * NULL: Test for presence of service
  59. */
  60. static __be32
  61. nlm4svc_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
  62. {
  63. dprintk("lockd: NULL called\n");
  64. return rpc_success;
  65. }
  66. /*
  67. * TEST: Check for conflicting lock
  68. */
  69. static __be32
  70. nlm4svc_proc_test(struct svc_rqst *rqstp, struct nlm_args *argp,
  71. struct nlm_res *resp)
  72. {
  73. struct nlm_host *host;
  74. struct nlm_file *file;
  75. dprintk("lockd: TEST4 called\n");
  76. resp->cookie = argp->cookie;
  77. /* Don't accept test requests during grace period */
  78. if (nlmsvc_grace_period) {
  79. resp->status = nlm_lck_denied_grace_period;
  80. return rpc_success;
  81. }
  82. /* Obtain client and file */
  83. if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
  84. return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
  85. /* Now check for conflicting locks */
  86. resp->status = nlmsvc_testlock(file, &argp->lock, &resp->lock);
  87. dprintk("lockd: TEST4 status %d\n", ntohl(resp->status));
  88. nlm_release_host(host);
  89. nlm_release_file(file);
  90. return rpc_success;
  91. }
  92. static __be32
  93. nlm4svc_proc_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
  94. struct nlm_res *resp)
  95. {
  96. struct nlm_host *host;
  97. struct nlm_file *file;
  98. dprintk("lockd: LOCK called\n");
  99. resp->cookie = argp->cookie;
  100. /* Don't accept new lock requests during grace period */
  101. if (nlmsvc_grace_period && !argp->reclaim) {
  102. resp->status = nlm_lck_denied_grace_period;
  103. return rpc_success;
  104. }
  105. /* Obtain client and file */
  106. if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
  107. return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
  108. #if 0
  109. /* If supplied state doesn't match current state, we assume it's
  110. * an old request that time-warped somehow. Any error return would
  111. * do in this case because it's irrelevant anyway.
  112. *
  113. * NB: We don't retrieve the remote host's state yet.
  114. */
  115. if (host->h_nsmstate && host->h_nsmstate != argp->state) {
  116. resp->status = nlm_lck_denied_nolocks;
  117. } else
  118. #endif
  119. /* Now try to lock the file */
  120. resp->status = nlmsvc_lock(rqstp, file, &argp->lock,
  121. argp->block, &argp->cookie);
  122. dprintk("lockd: LOCK status %d\n", ntohl(resp->status));
  123. nlm_release_host(host);
  124. nlm_release_file(file);
  125. return rpc_success;
  126. }
  127. static __be32
  128. nlm4svc_proc_cancel(struct svc_rqst *rqstp, struct nlm_args *argp,
  129. struct nlm_res *resp)
  130. {
  131. struct nlm_host *host;
  132. struct nlm_file *file;
  133. dprintk("lockd: CANCEL called\n");
  134. resp->cookie = argp->cookie;
  135. /* Don't accept requests during grace period */
  136. if (nlmsvc_grace_period) {
  137. resp->status = nlm_lck_denied_grace_period;
  138. return rpc_success;
  139. }
  140. /* Obtain client and file */
  141. if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
  142. return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
  143. /* Try to cancel request. */
  144. resp->status = nlmsvc_cancel_blocked(file, &argp->lock);
  145. dprintk("lockd: CANCEL status %d\n", ntohl(resp->status));
  146. nlm_release_host(host);
  147. nlm_release_file(file);
  148. return rpc_success;
  149. }
  150. /*
  151. * UNLOCK: release a lock
  152. */
  153. static __be32
  154. nlm4svc_proc_unlock(struct svc_rqst *rqstp, struct nlm_args *argp,
  155. struct nlm_res *resp)
  156. {
  157. struct nlm_host *host;
  158. struct nlm_file *file;
  159. dprintk("lockd: UNLOCK called\n");
  160. resp->cookie = argp->cookie;
  161. /* Don't accept new lock requests during grace period */
  162. if (nlmsvc_grace_period) {
  163. resp->status = nlm_lck_denied_grace_period;
  164. return rpc_success;
  165. }
  166. /* Obtain client and file */
  167. if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
  168. return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
  169. /* Now try to remove the lock */
  170. resp->status = nlmsvc_unlock(file, &argp->lock);
  171. dprintk("lockd: UNLOCK status %d\n", ntohl(resp->status));
  172. nlm_release_host(host);
  173. nlm_release_file(file);
  174. return rpc_success;
  175. }
  176. /*
  177. * GRANTED: A server calls us to tell that a process' lock request
  178. * was granted
  179. */
  180. static __be32
  181. nlm4svc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
  182. struct nlm_res *resp)
  183. {
  184. resp->cookie = argp->cookie;
  185. dprintk("lockd: GRANTED called\n");
  186. resp->status = nlmclnt_grant(svc_addr_in(rqstp), &argp->lock);
  187. dprintk("lockd: GRANTED status %d\n", ntohl(resp->status));
  188. return rpc_success;
  189. }
  190. /*
  191. * This is the generic lockd callback for async RPC calls
  192. */
  193. static void nlm4svc_callback_exit(struct rpc_task *task, void *data)
  194. {
  195. dprintk("lockd: %5u callback returned %d\n", task->tk_pid,
  196. -task->tk_status);
  197. }
  198. static void nlm4svc_callback_release(void *data)
  199. {
  200. nlm_release_call(data);
  201. }
  202. static const struct rpc_call_ops nlm4svc_callback_ops = {
  203. .rpc_call_done = nlm4svc_callback_exit,
  204. .rpc_release = nlm4svc_callback_release,
  205. };
  206. /*
  207. * `Async' versions of the above service routines. They aren't really,
  208. * because we send the callback before the reply proper. I hope this
  209. * doesn't break any clients.
  210. */
  211. static __be32 nlm4svc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args *argp,
  212. __be32 (*func)(struct svc_rqst *, struct nlm_args *, struct nlm_res *))
  213. {
  214. struct nlm_host *host;
  215. struct nlm_rqst *call;
  216. __be32 stat;
  217. host = nlmsvc_lookup_host(rqstp,
  218. argp->lock.caller,
  219. argp->lock.len);
  220. if (host == NULL)
  221. return rpc_system_err;
  222. call = nlm_alloc_call(host);
  223. if (call == NULL)
  224. return rpc_system_err;
  225. stat = func(rqstp, argp, &call->a_res);
  226. if (stat != 0) {
  227. nlm_release_call(call);
  228. return stat;
  229. }
  230. call->a_flags = RPC_TASK_ASYNC;
  231. if (nlm_async_reply(call, proc, &nlm4svc_callback_ops) < 0)
  232. return rpc_system_err;
  233. return rpc_success;
  234. }
  235. static __be32 nlm4svc_proc_test_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
  236. void *resp)
  237. {
  238. dprintk("lockd: TEST_MSG called\n");
  239. return nlm4svc_callback(rqstp, NLMPROC_TEST_RES, argp, nlm4svc_proc_test);
  240. }
  241. static __be32 nlm4svc_proc_lock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
  242. void *resp)
  243. {
  244. dprintk("lockd: LOCK_MSG called\n");
  245. return nlm4svc_callback(rqstp, NLMPROC_LOCK_RES, argp, nlm4svc_proc_lock);
  246. }
  247. static __be32 nlm4svc_proc_cancel_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
  248. void *resp)
  249. {
  250. dprintk("lockd: CANCEL_MSG called\n");
  251. return nlm4svc_callback(rqstp, NLMPROC_CANCEL_RES, argp, nlm4svc_proc_cancel);
  252. }
  253. static __be32 nlm4svc_proc_unlock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
  254. void *resp)
  255. {
  256. dprintk("lockd: UNLOCK_MSG called\n");
  257. return nlm4svc_callback(rqstp, NLMPROC_UNLOCK_RES, argp, nlm4svc_proc_unlock);
  258. }
  259. static __be32 nlm4svc_proc_granted_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
  260. void *resp)
  261. {
  262. dprintk("lockd: GRANTED_MSG called\n");
  263. return nlm4svc_callback(rqstp, NLMPROC_GRANTED_RES, argp, nlm4svc_proc_granted);
  264. }
  265. /*
  266. * SHARE: create a DOS share or alter existing share.
  267. */
  268. static __be32
  269. nlm4svc_proc_share(struct svc_rqst *rqstp, struct nlm_args *argp,
  270. struct nlm_res *resp)
  271. {
  272. struct nlm_host *host;
  273. struct nlm_file *file;
  274. dprintk("lockd: SHARE called\n");
  275. resp->cookie = argp->cookie;
  276. /* Don't accept new lock requests during grace period */
  277. if (nlmsvc_grace_period && !argp->reclaim) {
  278. resp->status = nlm_lck_denied_grace_period;
  279. return rpc_success;
  280. }
  281. /* Obtain client and file */
  282. if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
  283. return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
  284. /* Now try to create the share */
  285. resp->status = nlmsvc_share_file(host, file, argp);
  286. dprintk("lockd: SHARE status %d\n", ntohl(resp->status));
  287. nlm_release_host(host);
  288. nlm_release_file(file);
  289. return rpc_success;
  290. }
  291. /*
  292. * UNSHARE: Release a DOS share.
  293. */
  294. static __be32
  295. nlm4svc_proc_unshare(struct svc_rqst *rqstp, struct nlm_args *argp,
  296. struct nlm_res *resp)
  297. {
  298. struct nlm_host *host;
  299. struct nlm_file *file;
  300. dprintk("lockd: UNSHARE called\n");
  301. resp->cookie = argp->cookie;
  302. /* Don't accept requests during grace period */
  303. if (nlmsvc_grace_period) {
  304. resp->status = nlm_lck_denied_grace_period;
  305. return rpc_success;
  306. }
  307. /* Obtain client and file */
  308. if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
  309. return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
  310. /* Now try to lock the file */
  311. resp->status = nlmsvc_unshare_file(host, file, argp);
  312. dprintk("lockd: UNSHARE status %d\n", ntohl(resp->status));
  313. nlm_release_host(host);
  314. nlm_release_file(file);
  315. return rpc_success;
  316. }
  317. /*
  318. * NM_LOCK: Create an unmonitored lock
  319. */
  320. static __be32
  321. nlm4svc_proc_nm_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
  322. struct nlm_res *resp)
  323. {
  324. dprintk("lockd: NM_LOCK called\n");
  325. argp->monitor = 0; /* just clean the monitor flag */
  326. return nlm4svc_proc_lock(rqstp, argp, resp);
  327. }
  328. /*
  329. * FREE_ALL: Release all locks and shares held by client
  330. */
  331. static __be32
  332. nlm4svc_proc_free_all(struct svc_rqst *rqstp, struct nlm_args *argp,
  333. void *resp)
  334. {
  335. struct nlm_host *host;
  336. /* Obtain client */
  337. if (nlm4svc_retrieve_args(rqstp, argp, &host, NULL))
  338. return rpc_success;
  339. nlmsvc_free_host_resources(host);
  340. nlm_release_host(host);
  341. return rpc_success;
  342. }
  343. /*
  344. * SM_NOTIFY: private callback from statd (not part of official NLM proto)
  345. */
  346. static __be32
  347. nlm4svc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp,
  348. void *resp)
  349. {
  350. struct sockaddr_in saddr;
  351. memcpy(&saddr, svc_addr_in(rqstp), sizeof(saddr));
  352. dprintk("lockd: SM_NOTIFY called\n");
  353. if (saddr.sin_addr.s_addr != htonl(INADDR_LOOPBACK)
  354. || ntohs(saddr.sin_port) >= 1024) {
  355. char buf[RPC_MAX_ADDRBUFLEN];
  356. printk(KERN_WARNING "lockd: rejected NSM callback from %s\n",
  357. svc_print_addr(rqstp, buf, sizeof(buf)));
  358. return rpc_system_err;
  359. }
  360. /* Obtain the host pointer for this NFS server and try to
  361. * reclaim all locks we hold on this server.
  362. */
  363. memset(&saddr, 0, sizeof(saddr));
  364. saddr.sin_addr.s_addr = argp->addr;
  365. nlm_host_rebooted(&saddr, argp->mon, argp->len, argp->state);
  366. return rpc_success;
  367. }
  368. /*
  369. * client sent a GRANTED_RES, let's remove the associated block
  370. */
  371. static __be32
  372. nlm4svc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res *argp,
  373. void *resp)
  374. {
  375. if (!nlmsvc_ops)
  376. return rpc_success;
  377. dprintk("lockd: GRANTED_RES called\n");
  378. nlmsvc_grant_reply(&argp->cookie, argp->status);
  379. return rpc_success;
  380. }
  381. /*
  382. * NLM Server procedures.
  383. */
  384. #define nlm4svc_encode_norep nlm4svc_encode_void
  385. #define nlm4svc_decode_norep nlm4svc_decode_void
  386. #define nlm4svc_decode_testres nlm4svc_decode_void
  387. #define nlm4svc_decode_lockres nlm4svc_decode_void
  388. #define nlm4svc_decode_unlockres nlm4svc_decode_void
  389. #define nlm4svc_decode_cancelres nlm4svc_decode_void
  390. #define nlm4svc_decode_grantedres nlm4svc_decode_void
  391. #define nlm4svc_proc_none nlm4svc_proc_null
  392. #define nlm4svc_proc_test_res nlm4svc_proc_null
  393. #define nlm4svc_proc_lock_res nlm4svc_proc_null
  394. #define nlm4svc_proc_cancel_res nlm4svc_proc_null
  395. #define nlm4svc_proc_unlock_res nlm4svc_proc_null
  396. struct nlm_void { int dummy; };
  397. #define PROC(name, xargt, xrest, argt, rest, respsize) \
  398. { .pc_func = (svc_procfunc) nlm4svc_proc_##name, \
  399. .pc_decode = (kxdrproc_t) nlm4svc_decode_##xargt, \
  400. .pc_encode = (kxdrproc_t) nlm4svc_encode_##xrest, \
  401. .pc_release = NULL, \
  402. .pc_argsize = sizeof(struct nlm_##argt), \
  403. .pc_ressize = sizeof(struct nlm_##rest), \
  404. .pc_xdrressize = respsize, \
  405. }
  406. #define Ck (1+XDR_QUADLEN(NLM_MAXCOOKIELEN)) /* cookie */
  407. #define No (1+1024/4) /* netobj */
  408. #define St 1 /* status */
  409. #define Rg 4 /* range (offset + length) */
  410. struct svc_procedure nlmsvc_procedures4[] = {
  411. PROC(null, void, void, void, void, 1),
  412. PROC(test, testargs, testres, args, res, Ck+St+2+No+Rg),
  413. PROC(lock, lockargs, res, args, res, Ck+St),
  414. PROC(cancel, cancargs, res, args, res, Ck+St),
  415. PROC(unlock, unlockargs, res, args, res, Ck+St),
  416. PROC(granted, testargs, res, args, res, Ck+St),
  417. PROC(test_msg, testargs, norep, args, void, 1),
  418. PROC(lock_msg, lockargs, norep, args, void, 1),
  419. PROC(cancel_msg, cancargs, norep, args, void, 1),
  420. PROC(unlock_msg, unlockargs, norep, args, void, 1),
  421. PROC(granted_msg, testargs, norep, args, void, 1),
  422. PROC(test_res, testres, norep, res, void, 1),
  423. PROC(lock_res, lockres, norep, res, void, 1),
  424. PROC(cancel_res, cancelres, norep, res, void, 1),
  425. PROC(unlock_res, unlockres, norep, res, void, 1),
  426. PROC(granted_res, res, norep, res, void, 1),
  427. /* statd callback */
  428. PROC(sm_notify, reboot, void, reboot, void, 1),
  429. PROC(none, void, void, void, void, 0),
  430. PROC(none, void, void, void, void, 0),
  431. PROC(none, void, void, void, void, 0),
  432. PROC(share, shareargs, shareres, args, res, Ck+St+1),
  433. PROC(unshare, shareargs, shareres, args, res, Ck+St+1),
  434. PROC(nm_lock, lockargs, res, args, res, Ck+St),
  435. PROC(free_all, notify, void, args, void, 1),
  436. };