fs/quota/netlink.c

   1 #include <linux/cred.h>
   2 #include <linux/init.h>
   3 #include <linux/kernel.h>
   4 #include <linux/quotaops.h>
   5 #include <linux/sched.h>
   6 #include <linux/slab.h>
   7 #include <net/netlink.h>
   8 #include <net/genetlink.h>
   9
  10 static const struct genl_multicast_group quota_mcgrps[] = {
  11         { .name = "events", },
  12 };
  13
  14 /* Netlink family structure for quota */
  15 static struct genl_family quota_genl_family __ro_after_init = {
  16         .module = THIS_MODULE,
  17         .hdrsize = 0,
  18         .name = "VFS_DQUOT",
  19         .version = 1,
  20         .maxattr = QUOTA_NL_A_MAX,
  21         .mcgrps = quota_mcgrps,
  22         .n_mcgrps = ARRAY_SIZE(quota_mcgrps),
  23 };
  24
  25 /**
  26  * quota_send_warning - Send warning to userspace about exceeded quota
  27  * @qid: The kernel internal quota identifier.
  28  * @dev: The device on which the fs is mounted (sb->s_dev)
  29  * @warntype: The type of the warning: QUOTA_NL_...
  30  *
  31  * This can be used by filesystems (including those which don't use
  32  * dquot) to send a message to userspace relating to quota limits.
  33  *
  34  */
  35
  36 void quota_send_warning(struct kqid qid, dev_t dev,
  37                         const char warntype)
  38 {
  39         static atomic_t seq;
  40         struct sk_buff *skb;
  41         void *msg_head;
  42         int ret;
  43         int msg_size = 4 * nla_total_size(sizeof(u32)) +
  44                        2 * nla_total_size_64bit(sizeof(u64));
  45
  46         /* We have to allocate using GFP_NOFS as we are called from a
  47          * filesystem performing write and thus further recursion into
  48          * the fs to free some data could cause deadlocks. */
  49         skb = genlmsg_new(msg_size, GFP_NOFS);
  50         if (!skb) {
  51                 printk(KERN_ERR
  52                   "VFS: Not enough memory to send quota warning.\n");
  53                 return;
  54         }
  55         msg_head = genlmsg_put(skb, 0, atomic_add_return(1, &seq),
  56                         &quota_genl_family, 0, QUOTA_NL_C_WARNING);
  57         if (!msg_head) {
  58                 printk(KERN_ERR
  59                   "VFS: Cannot store netlink header in quota warning.\n");
  60                 goto err_out;
  61         }
  62         ret = nla_put_u32(skb, QUOTA_NL_A_QTYPE, qid.type);
  63         if (ret)
  64                 goto attr_err_out;
  65         ret = nla_put_u64_64bit(skb, QUOTA_NL_A_EXCESS_ID,
  66                                 from_kqid_munged(&init_user_ns, qid),
  67                                 QUOTA_NL_A_PAD);
  68         if (ret)
  69                 goto attr_err_out;
  70         ret = nla_put_u32(skb, QUOTA_NL_A_WARNING, warntype);
  71         if (ret)
  72                 goto attr_err_out;
  73         ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MAJOR, MAJOR(dev));
  74         if (ret)
  75                 goto attr_err_out;
  76         ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MINOR, MINOR(dev));
  77         if (ret)
  78                 goto attr_err_out;
  79         ret = nla_put_u64_64bit(skb, QUOTA_NL_A_CAUSED_ID,
  80                                 from_kuid_munged(&init_user_ns, current_uid()),
  81                                 QUOTA_NL_A_PAD);
  82         if (ret)
  83                 goto attr_err_out;
  84         genlmsg_end(skb, msg_head);
  85
  86         genlmsg_multicast(&quota_genl_family, skb, 0, 0, GFP_NOFS);
  87         return;
  88 attr_err_out:
  89         printk(KERN_ERR "VFS: Not enough space to compose quota message!\n");
  90 err_out:
  91         kfree_skb(skb);
  92 }
  93 EXPORT_SYMBOL(quota_send_warning);
  94
  95 static int __init quota_init(void)
  96 {
  97         if (genl_register_family(&quota_genl_family) != 0)
  98                 printk(KERN_ERR
  99                        "VFS: Failed to create quota netlink interface.\n");
 100         return 0;
 101 };
 102 fs_initcall(quota_init);