kernel/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 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         list_add(&lm->list, grace_list);
  34         spin_unlock(&grace_lock);
  35 }
  36 EXPORT_SYMBOL_GPL(locks_start_grace);
  37
  38 /**
  39  * locks_end_grace
  40  * @net: net namespace that this lock manager belongs to
  41  * @lm: who this grace period is for
  42  *
  43  * Call this function to state that the given lock manager is ready to
  44  * resume regular locking.  The grace period will not end until all lock
  45  * managers that called locks_start_grace() also call locks_end_grace().
  46  * Note that callers count on it being safe to call this more than once,
  47  * and the second call should be a no-op.
  48  */
  49 void
  50 locks_end_grace(struct lock_manager *lm)
  51 {
  52         spin_lock(&grace_lock);
  53         list_del_init(&lm->list);
  54         spin_unlock(&grace_lock);
  55 }
  56 EXPORT_SYMBOL_GPL(locks_end_grace);
  57
  58 /**
  59  * locks_in_grace
  60  *
  61  * Lock managers call this function to determine when it is OK for them
  62  * to answer ordinary lock requests, and when they should accept only
  63  * lock reclaims.
  64  */
  65 int
  66 locks_in_grace(struct net *net)
  67 {
  68         struct list_head *grace_list = net_generic(net, grace_net_id);
  69
  70         return !list_empty(grace_list);
  71 }
  72 EXPORT_SYMBOL_GPL(locks_in_grace);
  73
  74 static int __net_init
  75 grace_init_net(struct net *net)
  76 {
  77         struct list_head *grace_list = net_generic(net, grace_net_id);
  78
  79         INIT_LIST_HEAD(grace_list);
  80         return 0;
  81 }
  82
  83 static void __net_exit
  84 grace_exit_net(struct net *net)
  85 {
  86         struct list_head *grace_list = net_generic(net, grace_net_id);
  87
  88         BUG_ON(!list_empty(grace_list));
  89 }
  90
  91 static struct pernet_operations grace_net_ops = {
  92         .init = grace_init_net,
  93         .exit = grace_exit_net,
  94         .id   = &grace_net_id,
  95         .size = sizeof(struct list_head),
  96 };
  97
  98 static int __init
  99 init_grace(void)
 100 {
 101         return register_pernet_subsys(&grace_net_ops);
 102 }
 103
 104 static void __exit
 105 exit_grace(void)
 106 {
 107         unregister_pernet_subsys(&grace_net_ops);
 108 }
 109
 110 MODULE_AUTHOR("Jeff Layton <jlayton@primarydata.com>");
 111 MODULE_LICENSE("GPL");
 112 module_init(init_grace)
 113 module_exit(exit_grace)