fs/nfs_common/grace.c

   1 /*
   2  * Common code for control of lockd and nfsv4 grace periods.
   3  *
   4  * Transplanted from lockd code
   5  */
   6
   7 #include <linux/module.h>
   8 #include <net/net_namespace.h>
   9 #include <net/netns/generic.h>
  10 #include <linux/fs.h>
  11
  12 static unsigned int grace_net_id;
  13 static DEFINE_SPINLOCK(grace_lock);
  14
  15 /**
  16  * locks_start_grace
  17  * @net: net namespace that this lock manager belongs to
  18  * @lm: who this grace period is for
  19  *
  20  * A grace period is a period during which locks should not be given
  21  * out.  Currently grace periods are only enforced by the two lock
  22  * managers (lockd and nfsd), using the locks_in_grace() function to
  23  * check when they are in a grace period.
  24  *
  25  * This function is called to start a grace period.
  26  */
  27 void
  28 locks_start_grace(struct net *net, struct lock_manager *lm)
  29 {
  30         struct list_head *grace_list = net_generic(net, grace_net_id);
  31
  32         spin_lock(&grace_lock);
  33         if (list_empty(&lm->list))
  34                 list_add(&lm->list, grace_list);
  35         else
  36                 WARN(1, "double list_add attempt detected in net %x %s\n",
  37                      net->ns.inum, (net == &init_net) ? "(init_net)" : "");
  38         spin_unlock(&grace_lock);
  39 }
  40 EXPORT_SYMBOL_GPL(locks_start_grace);
  41
  42 /**
  43  * locks_end_grace
  44  * @net: net namespace that this lock manager belongs to
  45  * @lm: who this grace period is for
  46  *
  47  * Call this function to state that the given lock manager is ready to
  48  * resume regular locking.  The grace period will not end until all lock
  49  * managers that called locks_start_grace() also call locks_end_grace().
  50  * Note that callers count on it being safe to call this more than once,
  51  * and the second call should be a no-op.
  52  */
  53 void
  54 locks_end_grace(struct lock_manager *lm)
  55 {
  56         spin_lock(&grace_lock);
  57         list_del_init(&lm->list);
  58         spin_unlock(&grace_lock);
  59 }
  60 EXPORT_SYMBOL_GPL(locks_end_grace);
  61
  62 /**
  63  * locks_in_grace
  64  *
  65  * Lock managers call this function to determine when it is OK for them
  66  * to answer ordinary lock requests, and when they should accept only
  67  * lock reclaims.
  68  */
  69 int
  70 __state_in_grace(struct net *net, bool open)
  71 {
  72         struct list_head *grace_list = net_generic(net, grace_net_id);
  73         struct lock_manager *lm;
  74
  75         if (!open)
  76                 return !list_empty(grace_list);
  77
  78         spin_lock(&grace_lock);
  79         list_for_each_entry(lm, grace_list, list) {
  80                 if (lm->block_opens) {
  81                         spin_unlock(&grace_lock);
  82                         return true;
  83                 }
  84         }
  85         spin_unlock(&grace_lock);
  86         return false;
  87 }
  88
  89 int locks_in_grace(struct net *net)
  90 {
  91         return __state_in_grace(net, 0);
  92 }
  93 EXPORT_SYMBOL_GPL(locks_in_grace);
  94
  95 int opens_in_grace(struct net *net)
  96 {
  97         return __state_in_grace(net, 1);
  98 }
  99 EXPORT_SYMBOL_GPL(opens_in_grace);
 100
 101 static int __net_init
 102 grace_init_net(struct net *net)
 103 {
 104         struct list_head *grace_list = net_generic(net, grace_net_id);
 105
 106         INIT_LIST_HEAD(grace_list);
 107         return 0;
 108 }
 109
 110 static void __net_exit
 111 grace_exit_net(struct net *net)
 112 {
 113         struct list_head *grace_list = net_generic(net, grace_net_id);
 114
 115         WARN_ONCE(!list_empty(grace_list),
 116                   "net %x %s: grace_list is not empty\n",
 117                   net->ns.inum, __func__);
 118 }
 119
 120 static struct pernet_operations grace_net_ops = {
 121         .init = grace_init_net,
 122         .exit = grace_exit_net,
 123         .id   = &grace_net_id,
 124         .size = sizeof(struct list_head),
 125 };
 126
 127 static int __init
 128 init_grace(void)
 129 {
 130         return register_pernet_subsys(&grace_net_ops);
 131 }
 132
 133 static void __exit
 134 exit_grace(void)
 135 {
 136         unregister_pernet_subsys(&grace_net_ops);
 137 }
 138
 139 MODULE_AUTHOR("Jeff Layton <jlayton@primarydata.com>");
 140 MODULE_LICENSE("GPL");
 141 module_init(init_grace)
 142 module_exit(exit_grace)