svclock.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697
  1. /*
  2. * linux/fs/lockd/svclock.c
  3. *
  4. * Handling of server-side locks, mostly of the blocked variety.
  5. * This is the ugliest part of lockd because we tread on very thin ice.
  6. * GRANT and CANCEL calls may get stuck, meet in mid-flight, etc.
  7. * IMNSHO introducing the grant callback into the NLM protocol was one
  8. * of the worst ideas Sun ever had. Except maybe for the idea of doing
  9. * NFS file locking at all.
  10. *
  11. * I'm trying hard to avoid race conditions by protecting most accesses
  12. * to a file's list of blocked locks through a semaphore. The global
  13. * list of blocked locks is not protected in this fashion however.
  14. * Therefore, some functions (such as the RPC callback for the async grant
  15. * call) move blocked locks towards the head of the list *while some other
  16. * process might be traversing it*. This should not be a problem in
  17. * practice, because this will only cause functions traversing the list
  18. * to visit some blocks twice.
  19. *
  20. * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
  21. */
  22. #include <linux/types.h>
  23. #include <linux/errno.h>
  24. #include <linux/kernel.h>
  25. #include <linux/sched.h>
  26. #include <linux/smp_lock.h>
  27. #include <linux/sunrpc/clnt.h>
  28. #include <linux/sunrpc/svc.h>
  29. #include <linux/lockd/nlm.h>
  30. #include <linux/lockd/lockd.h>
  31. #define NLMDBG_FACILITY NLMDBG_SVCLOCK
  32. #ifdef CONFIG_LOCKD_V4
  33. #define nlm_deadlock nlm4_deadlock
  34. #else
  35. #define nlm_deadlock nlm_lck_denied
  36. #endif
  37. static void nlmsvc_release_block(struct nlm_block *block);
  38. static void nlmsvc_insert_block(struct nlm_block *block, unsigned long);
  39. static void nlmsvc_remove_block(struct nlm_block *block);
  40. static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock);
  41. static void nlmsvc_freegrantargs(struct nlm_rqst *call);
  42. static const struct rpc_call_ops nlmsvc_grant_ops;
  43. /*
  44. * The list of blocked locks to retry
  45. */
  46. static LIST_HEAD(nlm_blocked);
  47. /*
  48. * Insert a blocked lock into the global list
  49. */
  50. static void
  51. nlmsvc_insert_block(struct nlm_block *block, unsigned long when)
  52. {
  53. struct nlm_block *b;
  54. struct list_head *pos;
  55. dprintk("lockd: nlmsvc_insert_block(%p, %ld)\n", block, when);
  56. if (list_empty(&block->b_list)) {
  57. kref_get(&block->b_count);
  58. } else {
  59. list_del_init(&block->b_list);
  60. }
  61. pos = &nlm_blocked;
  62. if (when != NLM_NEVER) {
  63. if ((when += jiffies) == NLM_NEVER)
  64. when ++;
  65. list_for_each(pos, &nlm_blocked) {
  66. b = list_entry(pos, struct nlm_block, b_list);
  67. if (time_after(b->b_when,when) || b->b_when == NLM_NEVER)
  68. break;
  69. }
  70. /* On normal exit from the loop, pos == &nlm_blocked,
  71. * so we will be adding to the end of the list - good
  72. */
  73. }
  74. list_add_tail(&block->b_list, pos);
  75. block->b_when = when;
  76. }
  77. /*
  78. * Remove a block from the global list
  79. */
  80. static inline void
  81. nlmsvc_remove_block(struct nlm_block *block)
  82. {
  83. if (!list_empty(&block->b_list)) {
  84. list_del_init(&block->b_list);
  85. nlmsvc_release_block(block);
  86. }
  87. }
  88. /*
  89. * Find a block for a given lock
  90. */
  91. static struct nlm_block *
  92. nlmsvc_lookup_block(struct nlm_file *file, struct nlm_lock *lock)
  93. {
  94. struct nlm_block *block;
  95. struct file_lock *fl;
  96. dprintk("lockd: nlmsvc_lookup_block f=%p pd=%d %Ld-%Ld ty=%d\n",
  97. file, lock->fl.fl_pid,
  98. (long long)lock->fl.fl_start,
  99. (long long)lock->fl.fl_end, lock->fl.fl_type);
  100. list_for_each_entry(block, &nlm_blocked, b_list) {
  101. fl = &block->b_call->a_args.lock.fl;
  102. dprintk("lockd: check f=%p pd=%d %Ld-%Ld ty=%d cookie=%s\n",
  103. block->b_file, fl->fl_pid,
  104. (long long)fl->fl_start,
  105. (long long)fl->fl_end, fl->fl_type,
  106. nlmdbg_cookie2a(&block->b_call->a_args.cookie));
  107. if (block->b_file == file && nlm_compare_locks(fl, &lock->fl)) {
  108. kref_get(&block->b_count);
  109. return block;
  110. }
  111. }
  112. return NULL;
  113. }
  114. static inline int nlm_cookie_match(struct nlm_cookie *a, struct nlm_cookie *b)
  115. {
  116. if(a->len != b->len)
  117. return 0;
  118. if(memcmp(a->data,b->data,a->len))
  119. return 0;
  120. return 1;
  121. }
  122. /*
  123. * Find a block with a given NLM cookie.
  124. */
  125. static inline struct nlm_block *
  126. nlmsvc_find_block(struct nlm_cookie *cookie)
  127. {
  128. struct nlm_block *block;
  129. list_for_each_entry(block, &nlm_blocked, b_list) {
  130. if (nlm_cookie_match(&block->b_call->a_args.cookie,cookie))
  131. goto found;
  132. }
  133. return NULL;
  134. found:
  135. dprintk("nlmsvc_find_block(%s): block=%p\n", nlmdbg_cookie2a(cookie), block);
  136. kref_get(&block->b_count);
  137. return block;
  138. }
  139. /*
  140. * Create a block and initialize it.
  141. *
  142. * Note: we explicitly set the cookie of the grant reply to that of
  143. * the blocked lock request. The spec explicitly mentions that the client
  144. * should _not_ rely on the callback containing the same cookie as the
  145. * request, but (as I found out later) that's because some implementations
  146. * do just this. Never mind the standards comittees, they support our
  147. * logging industries.
  148. *
  149. * 10 years later: I hope we can safely ignore these old and broken
  150. * clients by now. Let's fix this so we can uniquely identify an incoming
  151. * GRANTED_RES message by cookie, without having to rely on the client's IP
  152. * address. --okir
  153. */
  154. static inline struct nlm_block *
  155. nlmsvc_create_block(struct svc_rqst *rqstp, struct nlm_file *file,
  156. struct nlm_lock *lock, struct nlm_cookie *cookie)
  157. {
  158. struct nlm_block *block;
  159. struct nlm_host *host;
  160. struct nlm_rqst *call = NULL;
  161. /* Create host handle for callback */
  162. host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len);
  163. if (host == NULL)
  164. return NULL;
  165. call = nlm_alloc_call(host);
  166. if (call == NULL)
  167. return NULL;
  168. /* Allocate memory for block, and initialize arguments */
  169. block = kzalloc(sizeof(*block), GFP_KERNEL);
  170. if (block == NULL)
  171. goto failed;
  172. kref_init(&block->b_count);
  173. INIT_LIST_HEAD(&block->b_list);
  174. INIT_LIST_HEAD(&block->b_flist);
  175. if (!nlmsvc_setgrantargs(call, lock))
  176. goto failed_free;
  177. /* Set notifier function for VFS, and init args */
  178. call->a_args.lock.fl.fl_flags |= FL_SLEEP;
  179. call->a_args.lock.fl.fl_lmops = &nlmsvc_lock_operations;
  180. nlmclnt_next_cookie(&call->a_args.cookie);
  181. dprintk("lockd: created block %p...\n", block);
  182. /* Create and initialize the block */
  183. block->b_daemon = rqstp->rq_server;
  184. block->b_host = host;
  185. block->b_file = file;
  186. file->f_count++;
  187. /* Add to file's list of blocks */
  188. list_add(&block->b_flist, &file->f_blocks);
  189. /* Set up RPC arguments for callback */
  190. block->b_call = call;
  191. call->a_flags = RPC_TASK_ASYNC;
  192. call->a_block = block;
  193. return block;
  194. failed_free:
  195. kfree(block);
  196. failed:
  197. nlm_release_call(call);
  198. return NULL;
  199. }
  200. /*
  201. * Delete a block. If the lock was cancelled or the grant callback
  202. * failed, unlock is set to 1.
  203. * It is the caller's responsibility to check whether the file
  204. * can be closed hereafter.
  205. */
  206. static int nlmsvc_unlink_block(struct nlm_block *block)
  207. {
  208. int status;
  209. dprintk("lockd: unlinking block %p...\n", block);
  210. /* Remove block from list */
  211. status = posix_unblock_lock(block->b_file->f_file, &block->b_call->a_args.lock.fl);
  212. nlmsvc_remove_block(block);
  213. return status;
  214. }
  215. static void nlmsvc_free_block(struct kref *kref)
  216. {
  217. struct nlm_block *block = container_of(kref, struct nlm_block, b_count);
  218. struct nlm_file *file = block->b_file;
  219. dprintk("lockd: freeing block %p...\n", block);
  220. /* Remove block from file's list of blocks */
  221. mutex_lock(&file->f_mutex);
  222. list_del_init(&block->b_flist);
  223. mutex_unlock(&file->f_mutex);
  224. nlmsvc_freegrantargs(block->b_call);
  225. nlm_release_call(block->b_call);
  226. nlm_release_file(block->b_file);
  227. kfree(block);
  228. }
  229. static void nlmsvc_release_block(struct nlm_block *block)
  230. {
  231. if (block != NULL)
  232. kref_put(&block->b_count, nlmsvc_free_block);
  233. }
  234. /*
  235. * Loop over all blocks and delete blocks held by
  236. * a matching host.
  237. */
  238. void nlmsvc_traverse_blocks(struct nlm_host *host,
  239. struct nlm_file *file,
  240. nlm_host_match_fn_t match)
  241. {
  242. struct nlm_block *block, *next;
  243. restart:
  244. mutex_lock(&file->f_mutex);
  245. list_for_each_entry_safe(block, next, &file->f_blocks, b_flist) {
  246. if (!match(block->b_host, host))
  247. continue;
  248. /* Do not destroy blocks that are not on
  249. * the global retry list - why? */
  250. if (list_empty(&block->b_list))
  251. continue;
  252. kref_get(&block->b_count);
  253. mutex_unlock(&file->f_mutex);
  254. nlmsvc_unlink_block(block);
  255. nlmsvc_release_block(block);
  256. goto restart;
  257. }
  258. mutex_unlock(&file->f_mutex);
  259. }
  260. /*
  261. * Initialize arguments for GRANTED call. The nlm_rqst structure
  262. * has been cleared already.
  263. */
  264. static int nlmsvc_setgrantargs(struct nlm_rqst *call, struct nlm_lock *lock)
  265. {
  266. locks_copy_lock(&call->a_args.lock.fl, &lock->fl);
  267. memcpy(&call->a_args.lock.fh, &lock->fh, sizeof(call->a_args.lock.fh));
  268. call->a_args.lock.caller = utsname()->nodename;
  269. call->a_args.lock.oh.len = lock->oh.len;
  270. /* set default data area */
  271. call->a_args.lock.oh.data = call->a_owner;
  272. call->a_args.lock.svid = lock->fl.fl_pid;
  273. if (lock->oh.len > NLMCLNT_OHSIZE) {
  274. void *data = kmalloc(lock->oh.len, GFP_KERNEL);
  275. if (!data)
  276. return 0;
  277. call->a_args.lock.oh.data = (u8 *) data;
  278. }
  279. memcpy(call->a_args.lock.oh.data, lock->oh.data, lock->oh.len);
  280. return 1;
  281. }
  282. static void nlmsvc_freegrantargs(struct nlm_rqst *call)
  283. {
  284. if (call->a_args.lock.oh.data != call->a_owner)
  285. kfree(call->a_args.lock.oh.data);
  286. }
  287. /*
  288. * Attempt to establish a lock, and if it can't be granted, block it
  289. * if required.
  290. */
  291. __be32
  292. nlmsvc_lock(struct svc_rqst *rqstp, struct nlm_file *file,
  293. struct nlm_lock *lock, int wait, struct nlm_cookie *cookie)
  294. {
  295. struct nlm_block *block, *newblock = NULL;
  296. int error;
  297. __be32 ret;
  298. dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
  299. file->f_file->f_path.dentry->d_inode->i_sb->s_id,
  300. file->f_file->f_path.dentry->d_inode->i_ino,
  301. lock->fl.fl_type, lock->fl.fl_pid,
  302. (long long)lock->fl.fl_start,
  303. (long long)lock->fl.fl_end,
  304. wait);
  305. lock->fl.fl_flags &= ~FL_SLEEP;
  306. again:
  307. /* Lock file against concurrent access */
  308. mutex_lock(&file->f_mutex);
  309. /* Get existing block (in case client is busy-waiting) */
  310. block = nlmsvc_lookup_block(file, lock);
  311. if (block == NULL) {
  312. if (newblock != NULL)
  313. lock = &newblock->b_call->a_args.lock;
  314. } else
  315. lock = &block->b_call->a_args.lock;
  316. error = posix_lock_file(file->f_file, &lock->fl);
  317. lock->fl.fl_flags &= ~FL_SLEEP;
  318. dprintk("lockd: posix_lock_file returned %d\n", error);
  319. switch(error) {
  320. case 0:
  321. ret = nlm_granted;
  322. goto out;
  323. case -EAGAIN:
  324. break;
  325. case -EDEADLK:
  326. ret = nlm_deadlock;
  327. goto out;
  328. default: /* includes ENOLCK */
  329. ret = nlm_lck_denied_nolocks;
  330. goto out;
  331. }
  332. ret = nlm_lck_denied;
  333. if (!wait)
  334. goto out;
  335. ret = nlm_lck_blocked;
  336. if (block != NULL)
  337. goto out;
  338. /* If we don't have a block, create and initialize it. Then
  339. * retry because we may have slept in kmalloc. */
  340. /* We have to release f_mutex as nlmsvc_create_block may try to
  341. * to claim it while doing host garbage collection */
  342. if (newblock == NULL) {
  343. mutex_unlock(&file->f_mutex);
  344. dprintk("lockd: blocking on this lock (allocating).\n");
  345. if (!(newblock = nlmsvc_create_block(rqstp, file, lock, cookie)))
  346. return nlm_lck_denied_nolocks;
  347. goto again;
  348. }
  349. /* Append to list of blocked */
  350. nlmsvc_insert_block(newblock, NLM_NEVER);
  351. out:
  352. mutex_unlock(&file->f_mutex);
  353. nlmsvc_release_block(newblock);
  354. nlmsvc_release_block(block);
  355. dprintk("lockd: nlmsvc_lock returned %u\n", ret);
  356. return ret;
  357. }
  358. /*
  359. * Test for presence of a conflicting lock.
  360. */
  361. __be32
  362. nlmsvc_testlock(struct nlm_file *file, struct nlm_lock *lock,
  363. struct nlm_lock *conflock)
  364. {
  365. dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
  366. file->f_file->f_path.dentry->d_inode->i_sb->s_id,
  367. file->f_file->f_path.dentry->d_inode->i_ino,
  368. lock->fl.fl_type,
  369. (long long)lock->fl.fl_start,
  370. (long long)lock->fl.fl_end);
  371. if (posix_test_lock(file->f_file, &lock->fl, &conflock->fl)) {
  372. dprintk("lockd: conflicting lock(ty=%d, %Ld-%Ld)\n",
  373. conflock->fl.fl_type,
  374. (long long)conflock->fl.fl_start,
  375. (long long)conflock->fl.fl_end);
  376. conflock->caller = "somehost"; /* FIXME */
  377. conflock->len = strlen(conflock->caller);
  378. conflock->oh.len = 0; /* don't return OH info */
  379. conflock->svid = conflock->fl.fl_pid;
  380. return nlm_lck_denied;
  381. }
  382. return nlm_granted;
  383. }
  384. /*
  385. * Remove a lock.
  386. * This implies a CANCEL call: We send a GRANT_MSG, the client replies
  387. * with a GRANT_RES call which gets lost, and calls UNLOCK immediately
  388. * afterwards. In this case the block will still be there, and hence
  389. * must be removed.
  390. */
  391. __be32
  392. nlmsvc_unlock(struct nlm_file *file, struct nlm_lock *lock)
  393. {
  394. int error;
  395. dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
  396. file->f_file->f_path.dentry->d_inode->i_sb->s_id,
  397. file->f_file->f_path.dentry->d_inode->i_ino,
  398. lock->fl.fl_pid,
  399. (long long)lock->fl.fl_start,
  400. (long long)lock->fl.fl_end);
  401. /* First, cancel any lock that might be there */
  402. nlmsvc_cancel_blocked(file, lock);
  403. lock->fl.fl_type = F_UNLCK;
  404. error = posix_lock_file(file->f_file, &lock->fl);
  405. return (error < 0)? nlm_lck_denied_nolocks : nlm_granted;
  406. }
  407. /*
  408. * Cancel a previously blocked request.
  409. *
  410. * A cancel request always overrides any grant that may currently
  411. * be in progress.
  412. * The calling procedure must check whether the file can be closed.
  413. */
  414. __be32
  415. nlmsvc_cancel_blocked(struct nlm_file *file, struct nlm_lock *lock)
  416. {
  417. struct nlm_block *block;
  418. int status = 0;
  419. dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
  420. file->f_file->f_path.dentry->d_inode->i_sb->s_id,
  421. file->f_file->f_path.dentry->d_inode->i_ino,
  422. lock->fl.fl_pid,
  423. (long long)lock->fl.fl_start,
  424. (long long)lock->fl.fl_end);
  425. mutex_lock(&file->f_mutex);
  426. block = nlmsvc_lookup_block(file, lock);
  427. mutex_unlock(&file->f_mutex);
  428. if (block != NULL) {
  429. status = nlmsvc_unlink_block(block);
  430. nlmsvc_release_block(block);
  431. }
  432. return status ? nlm_lck_denied : nlm_granted;
  433. }
  434. /*
  435. * Unblock a blocked lock request. This is a callback invoked from the
  436. * VFS layer when a lock on which we blocked is removed.
  437. *
  438. * This function doesn't grant the blocked lock instantly, but rather moves
  439. * the block to the head of nlm_blocked where it can be picked up by lockd.
  440. */
  441. static void
  442. nlmsvc_notify_blocked(struct file_lock *fl)
  443. {
  444. struct nlm_block *block;
  445. dprintk("lockd: VFS unblock notification for block %p\n", fl);
  446. list_for_each_entry(block, &nlm_blocked, b_list) {
  447. if (nlm_compare_locks(&block->b_call->a_args.lock.fl, fl)) {
  448. nlmsvc_insert_block(block, 0);
  449. svc_wake_up(block->b_daemon);
  450. return;
  451. }
  452. }
  453. printk(KERN_WARNING "lockd: notification for unknown block!\n");
  454. }
  455. static int nlmsvc_same_owner(struct file_lock *fl1, struct file_lock *fl2)
  456. {
  457. return fl1->fl_owner == fl2->fl_owner && fl1->fl_pid == fl2->fl_pid;
  458. }
  459. struct lock_manager_operations nlmsvc_lock_operations = {
  460. .fl_compare_owner = nlmsvc_same_owner,
  461. .fl_notify = nlmsvc_notify_blocked,
  462. };
  463. /*
  464. * Try to claim a lock that was previously blocked.
  465. *
  466. * Note that we use both the RPC_GRANTED_MSG call _and_ an async
  467. * RPC thread when notifying the client. This seems like overkill...
  468. * Here's why:
  469. * - we don't want to use a synchronous RPC thread, otherwise
  470. * we might find ourselves hanging on a dead portmapper.
  471. * - Some lockd implementations (e.g. HP) don't react to
  472. * RPC_GRANTED calls; they seem to insist on RPC_GRANTED_MSG calls.
  473. */
  474. static void
  475. nlmsvc_grant_blocked(struct nlm_block *block)
  476. {
  477. struct nlm_file *file = block->b_file;
  478. struct nlm_lock *lock = &block->b_call->a_args.lock;
  479. int error;
  480. dprintk("lockd: grant blocked lock %p\n", block);
  481. /* Unlink block request from list */
  482. nlmsvc_unlink_block(block);
  483. /* If b_granted is true this means we've been here before.
  484. * Just retry the grant callback, possibly refreshing the RPC
  485. * binding */
  486. if (block->b_granted) {
  487. nlm_rebind_host(block->b_host);
  488. goto callback;
  489. }
  490. /* Try the lock operation again */
  491. lock->fl.fl_flags |= FL_SLEEP;
  492. error = posix_lock_file(file->f_file, &lock->fl);
  493. lock->fl.fl_flags &= ~FL_SLEEP;
  494. switch (error) {
  495. case 0:
  496. break;
  497. case -EAGAIN:
  498. dprintk("lockd: lock still blocked\n");
  499. nlmsvc_insert_block(block, NLM_NEVER);
  500. return;
  501. default:
  502. printk(KERN_WARNING "lockd: unexpected error %d in %s!\n",
  503. -error, __FUNCTION__);
  504. nlmsvc_insert_block(block, 10 * HZ);
  505. return;
  506. }
  507. callback:
  508. /* Lock was granted by VFS. */
  509. dprintk("lockd: GRANTing blocked lock.\n");
  510. block->b_granted = 1;
  511. /* Schedule next grant callback in 30 seconds */
  512. nlmsvc_insert_block(block, 30 * HZ);
  513. /* Call the client */
  514. kref_get(&block->b_count);
  515. nlm_async_call(block->b_call, NLMPROC_GRANTED_MSG, &nlmsvc_grant_ops);
  516. }
  517. /*
  518. * This is the callback from the RPC layer when the NLM_GRANTED_MSG
  519. * RPC call has succeeded or timed out.
  520. * Like all RPC callbacks, it is invoked by the rpciod process, so it
  521. * better not sleep. Therefore, we put the blocked lock on the nlm_blocked
  522. * chain once more in order to have it removed by lockd itself (which can
  523. * then sleep on the file semaphore without disrupting e.g. the nfs client).
  524. */
  525. static void nlmsvc_grant_callback(struct rpc_task *task, void *data)
  526. {
  527. struct nlm_rqst *call = data;
  528. struct nlm_block *block = call->a_block;
  529. unsigned long timeout;
  530. dprintk("lockd: GRANT_MSG RPC callback\n");
  531. /* Technically, we should down the file semaphore here. Since we
  532. * move the block towards the head of the queue only, no harm
  533. * can be done, though. */
  534. if (task->tk_status < 0) {
  535. /* RPC error: Re-insert for retransmission */
  536. timeout = 10 * HZ;
  537. } else {
  538. /* Call was successful, now wait for client callback */
  539. timeout = 60 * HZ;
  540. }
  541. nlmsvc_insert_block(block, timeout);
  542. svc_wake_up(block->b_daemon);
  543. }
  544. static void nlmsvc_grant_release(void *data)
  545. {
  546. struct nlm_rqst *call = data;
  547. nlmsvc_release_block(call->a_block);
  548. }
  549. static const struct rpc_call_ops nlmsvc_grant_ops = {
  550. .rpc_call_done = nlmsvc_grant_callback,
  551. .rpc_release = nlmsvc_grant_release,
  552. };
  553. /*
  554. * We received a GRANT_RES callback. Try to find the corresponding
  555. * block.
  556. */
  557. void
  558. nlmsvc_grant_reply(struct nlm_cookie *cookie, __be32 status)
  559. {
  560. struct nlm_block *block;
  561. dprintk("grant_reply: looking for cookie %x, s=%d \n",
  562. *(unsigned int *)(cookie->data), status);
  563. if (!(block = nlmsvc_find_block(cookie)))
  564. return;
  565. if (block) {
  566. if (status == nlm_lck_denied_grace_period) {
  567. /* Try again in a couple of seconds */
  568. nlmsvc_insert_block(block, 10 * HZ);
  569. } else {
  570. /* Lock is now held by client, or has been rejected.
  571. * In both cases, the block should be removed. */
  572. nlmsvc_unlink_block(block);
  573. }
  574. }
  575. nlmsvc_release_block(block);
  576. }
  577. /*
  578. * Retry all blocked locks that have been notified. This is where lockd
  579. * picks up locks that can be granted, or grant notifications that must
  580. * be retransmitted.
  581. */
  582. unsigned long
  583. nlmsvc_retry_blocked(void)
  584. {
  585. unsigned long timeout = MAX_SCHEDULE_TIMEOUT;
  586. struct nlm_block *block;
  587. while (!list_empty(&nlm_blocked)) {
  588. block = list_entry(nlm_blocked.next, struct nlm_block, b_list);
  589. if (block->b_when == NLM_NEVER)
  590. break;
  591. if (time_after(block->b_when,jiffies)) {
  592. timeout = block->b_when - jiffies;
  593. break;
  594. }
  595. dprintk("nlmsvc_retry_blocked(%p, when=%ld)\n",
  596. block, block->b_when);
  597. kref_get(&block->b_count);
  598. nlmsvc_grant_blocked(block);
  599. nlmsvc_release_block(block);
  600. }
  601. return timeout;
  602. }