nfs4renewd.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147
  1. /*
  2. * fs/nfs/nfs4renewd.c
  3. *
  4. * Copyright (c) 2002 The Regents of the University of Michigan.
  5. * All rights reserved.
  6. *
  7. * Kendrick Smith <kmsmith@umich.edu>
  8. *
  9. * Redistribution and use in source and binary forms, with or without
  10. * modification, are permitted provided that the following conditions
  11. * are met:
  12. *
  13. * 1. Redistributions of source code must retain the above copyright
  14. * notice, this list of conditions and the following disclaimer.
  15. * 2. Redistributions in binary form must reproduce the above copyright
  16. * notice, this list of conditions and the following disclaimer in the
  17. * documentation and/or other materials provided with the distribution.
  18. * 3. Neither the name of the University nor the names of its
  19. * contributors may be used to endorse or promote products derived
  20. * from this software without specific prior written permission.
  21. *
  22. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  23. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  24. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  25. * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  29. * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30. * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33. *
  34. * Implementation of the NFSv4 "renew daemon", which wakes up periodically to
  35. * send a RENEW, to keep state alive on the server. The daemon is implemented
  36. * as an rpc_task, not a real kernel thread, so it always runs in rpciod's
  37. * context. There is one renewd per nfs_server.
  38. *
  39. * TODO: If the send queue gets backlogged (e.g., if the server goes down),
  40. * we will keep filling the queue with periodic RENEW requests. We need a
  41. * mechanism for ensuring that if renewd successfully sends off a request,
  42. * then it only wakes up when the request is finished. Maybe use the
  43. * child task framework of the RPC layer?
  44. */
  45. #include <linux/smp_lock.h>
  46. #include <linux/mm.h>
  47. #include <linux/pagemap.h>
  48. #include <linux/sunrpc/sched.h>
  49. #include <linux/sunrpc/clnt.h>
  50. #include <linux/nfs.h>
  51. #include <linux/nfs4.h>
  52. #include <linux/nfs_fs.h>
  53. #include "nfs4_fs.h"
  54. #include "delegation.h"
  55. #define NFSDBG_FACILITY NFSDBG_PROC
  56. void
  57. nfs4_renew_state(struct work_struct *work)
  58. {
  59. struct nfs_client *clp =
  60. container_of(work, struct nfs_client, cl_renewd.work);
  61. struct rpc_cred *cred;
  62. long lease, timeout;
  63. unsigned long last, now;
  64. down_read(&clp->cl_sem);
  65. dprintk("%s: start\n", __FUNCTION__);
  66. /* Are there any active superblocks? */
  67. if (list_empty(&clp->cl_superblocks))
  68. goto out;
  69. spin_lock(&clp->cl_lock);
  70. lease = clp->cl_lease_time;
  71. last = clp->cl_last_renewal;
  72. now = jiffies;
  73. timeout = (2 * lease) / 3 + (long)last - (long)now;
  74. /* Are we close to a lease timeout? */
  75. if (time_after(now, last + lease/3)) {
  76. cred = nfs4_get_renew_cred(clp);
  77. if (cred == NULL) {
  78. set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
  79. spin_unlock(&clp->cl_lock);
  80. nfs_expire_all_delegations(clp);
  81. goto out;
  82. }
  83. spin_unlock(&clp->cl_lock);
  84. /* Queue an asynchronous RENEW. */
  85. nfs4_proc_async_renew(clp, cred);
  86. put_rpccred(cred);
  87. timeout = (2 * lease) / 3;
  88. spin_lock(&clp->cl_lock);
  89. } else
  90. dprintk("%s: failed to call renewd. Reason: lease not expired \n",
  91. __FUNCTION__);
  92. if (timeout < 5 * HZ) /* safeguard */
  93. timeout = 5 * HZ;
  94. dprintk("%s: requeueing work. Lease period = %ld\n",
  95. __FUNCTION__, (timeout + HZ - 1) / HZ);
  96. cancel_delayed_work(&clp->cl_renewd);
  97. schedule_delayed_work(&clp->cl_renewd, timeout);
  98. spin_unlock(&clp->cl_lock);
  99. out:
  100. up_read(&clp->cl_sem);
  101. dprintk("%s: done\n", __FUNCTION__);
  102. }
  103. /* Must be called with clp->cl_sem locked for writes */
  104. void
  105. nfs4_schedule_state_renewal(struct nfs_client *clp)
  106. {
  107. long timeout;
  108. spin_lock(&clp->cl_lock);
  109. timeout = (2 * clp->cl_lease_time) / 3 + (long)clp->cl_last_renewal
  110. - (long)jiffies;
  111. if (timeout < 5 * HZ)
  112. timeout = 5 * HZ;
  113. dprintk("%s: requeueing work. Lease period = %ld\n",
  114. __FUNCTION__, (timeout + HZ - 1) / HZ);
  115. cancel_delayed_work(&clp->cl_renewd);
  116. schedule_delayed_work(&clp->cl_renewd, timeout);
  117. set_bit(NFS_CS_RENEWD, &clp->cl_res_state);
  118. spin_unlock(&clp->cl_lock);
  119. }
  120. void
  121. nfs4_renewd_prepare_shutdown(struct nfs_server *server)
  122. {
  123. flush_scheduled_work();
  124. }
  125. void
  126. nfs4_kill_renewd(struct nfs_client *clp)
  127. {
  128. down_read(&clp->cl_sem);
  129. cancel_delayed_work(&clp->cl_renewd);
  130. up_read(&clp->cl_sem);
  131. flush_scheduled_work();
  132. }
  133. /*
  134. * Local variables:
  135. * c-basic-offset: 8
  136. * End:
  137. */