vfs_quota.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*
    2  * Copyright (c) 2011,2012 François Tigeot <ftigeot@wolpond.org>
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  *
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in
   13  *    the documentation and/or other materials provided with the
   14  *    distribution.
   15  * 3. Neither the name of The DragonFly Project nor the names of its
   16  *    contributors may be used to endorse or promote products derived
   17  *    from this software without specific, prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
   22  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
   23  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   24  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
   25  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
   27  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   28  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   29  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  */
   32 
   33 #include <sys/sysctl.h>
   34 #include <sys/mount.h>
   35 #include <sys/systm.h>
   36 #include <sys/nlookup.h>
   37 #include <sys/vnode.h>
   38 #include <sys/stat.h>
   39 #include <sys/vfs_quota.h>
   40 #include <sys/spinlock.h>
   41 #include <sys/spinlock2.h>
   42 #include <inttypes.h>
   43 
   44 #include <sys/sysproto.h>
   45 #include <libprop/proplib.h>
   46 #include <libprop/prop_dictionary.h>
   47 
   48 /* in-memory accounting, red-black tree based */
   49 /* FIXME: code duplication caused by uid_t / gid_t differences */
   50 RB_PROTOTYPE(ac_utree, ac_unode, rb_entry, rb_ac_unode_cmp);
   51 RB_PROTOTYPE(ac_gtree, ac_gnode, rb_entry, rb_ac_gnode_cmp);
   52 
   53 static int
   54 rb_ac_unode_cmp(struct ac_unode *a, struct ac_unode *b);
   55 static int
   56 rb_ac_gnode_cmp(struct ac_gnode *a, struct ac_gnode *b);
   57 
   58 RB_GENERATE(ac_utree, ac_unode, rb_entry, rb_ac_unode_cmp);
   59 RB_GENERATE(ac_gtree, ac_gnode, rb_entry, rb_ac_gnode_cmp);
   60 
   61 struct ac_unode* unode_insert(struct mount*, uid_t);
   62 struct ac_gnode* gnode_insert(struct mount*, gid_t);
   63 
   64 static int
   65 rb_ac_unode_cmp(struct ac_unode *a, struct ac_unode *b)
   66 {
   67         if (a->left_bits < b->left_bits)
   68                 return(-1);
   69         else if (a->left_bits > b->left_bits)
   70                 return(1);
   71         return(0);
   72 }
   73 
   74 static int
   75 rb_ac_gnode_cmp(struct ac_gnode *a, struct ac_gnode *b)
   76 {
   77         if (a->left_bits < b->left_bits)
   78                 return(-1);
   79         else if (a->left_bits > b->left_bits)
   80                 return(1);
   81         return(0);
   82 }
   83 
   84 struct ac_unode*
   85 unode_insert(struct mount *mp, uid_t uid)
   86 {
   87         struct ac_unode *unp, *res;
   88 
   89         unp = kmalloc(sizeof(struct ac_unode), M_MOUNT, M_ZERO | M_WAITOK);
   90 
   91         unp->left_bits = (uid >> ACCT_CHUNK_BITS);
   92         res = RB_INSERT(ac_utree, &mp->mnt_acct.ac_uroot, unp);
   93         KASSERT(res == NULL, ("unode_insert(): RB_INSERT didn't return NULL"));
   94 
   95         return unp;
   96 }
   97 
   98 struct ac_gnode*
   99 gnode_insert(struct mount *mp, gid_t gid)
  100 {
  101         struct ac_gnode *gnp, *res;
  102 
  103         gnp = kmalloc(sizeof(struct ac_gnode), M_MOUNT, M_ZERO | M_WAITOK);
  104 
  105         gnp->left_bits = (gid >> ACCT_CHUNK_BITS);
  106         res = RB_INSERT(ac_gtree, &mp->mnt_acct.ac_groot, gnp);
  107         KASSERT(res == NULL, ("gnode_insert(): RB_INSERT didn't return NULL"));
  108 
  109         return gnp;
  110 }
  111 
  112 int vfs_quota_enabled = 0;
  113 TUNABLE_INT("vfs.quota_enabled", &vfs_quota_enabled);
  114 SYSCTL_INT(_vfs, OID_AUTO, quota_enabled, CTLFLAG_RD,
  115                  &vfs_quota_enabled, 0, "Enable VFS quota");
  116 
  117 /* initializes per mount-point data structures */
  118 void
  119 vq_init(struct mount *mp)
  120 {
  121 
  122         if (!vfs_quota_enabled)
  123                 return;
  124 
  125         /* initialize the rb trees */
  126         RB_INIT(&mp->mnt_acct.ac_uroot);
  127         RB_INIT(&mp->mnt_acct.ac_groot);
  128         spin_init(&mp->mnt_acct.ac_spin);
  129 
  130         mp->mnt_acct.ac_bytes = 0;
  131 
  132         /* enable data collection */
  133         mp->mnt_op->vfs_account = vfs_stdaccount;
  134         /* mark this filesystem quota enabled */
  135         mp->mnt_flag |= MNT_QUOTA;
  136         if (bootverbose)
  137                 kprintf("vfs accounting enabled for %s\n",
  138                     mp->mnt_stat.f_mntonname);
  139 }
  140 
  141 
  142 void
  143 vq_done(struct mount *mp)
  144 {
  145         /* TODO: remove the rb trees here */
  146 }
  147 
  148 void
  149 vfs_stdaccount(struct mount *mp, uid_t uid, gid_t gid, int64_t delta)
  150 {
  151         struct ac_unode ufind, *unp;
  152         struct ac_gnode gfind, *gnp;
  153 
  154         /* find or create address of chunk */
  155         ufind.left_bits = (uid >> ACCT_CHUNK_BITS);
  156         gfind.left_bits = (gid >> ACCT_CHUNK_BITS);
  157 
  158         spin_lock(&mp->mnt_acct.ac_spin);
  159 
  160         mp->mnt_acct.ac_bytes += delta;
  161 
  162         if ((unp = RB_FIND(ac_utree, &mp->mnt_acct.ac_uroot, &ufind)) == NULL)
  163                 unp = unode_insert(mp, uid);
  164         if ((gnp = RB_FIND(ac_gtree, &mp->mnt_acct.ac_groot, &gfind)) == NULL)
  165                 gnp = gnode_insert(mp, gid);
  166 
  167         /* update existing chunk */
  168         unp->uid_chunk[(uid & ACCT_CHUNK_MASK)].space += delta;
  169         gnp->gid_chunk[(gid & ACCT_CHUNK_MASK)].space += delta;
  170 
  171         spin_unlock(&mp->mnt_acct.ac_spin);
  172 }
  173 
  174 static void
  175 cmd_get_usage_all(struct mount *mp, prop_array_t dict_out)
  176 {
  177         struct ac_unode *unp;
  178         struct ac_gnode *gnp;
  179         int i;
  180         prop_dictionary_t item;
  181 
  182         item = prop_dictionary_create();
  183         (void) prop_dictionary_set_uint64(item, "space used", mp->mnt_acct.ac_bytes);
  184         (void) prop_dictionary_set_uint64(item, "limit", mp->mnt_acct.ac_limit);
  185         prop_array_add_and_rel(dict_out, item);
  186 
  187         RB_FOREACH(unp, ac_utree, &mp->mnt_acct.ac_uroot) {
  188                 for (i=0; i<ACCT_CHUNK_NIDS; i++) {
  189                         if (unp->uid_chunk[i].space != 0) {
  190                                 item = prop_dictionary_create();
  191                                 (void) prop_dictionary_set_uint32(item, "uid",
  192                                         (unp->left_bits << ACCT_CHUNK_BITS) + i);
  193                                 (void) prop_dictionary_set_uint64(item, "space used",
  194                                         unp->uid_chunk[i].space);
  195                                 (void) prop_dictionary_set_uint64(item, "limit",
  196                                         unp->uid_chunk[i].limit);
  197                                 prop_array_add_and_rel(dict_out, item);
  198                         }
  199                 }
  200         }
  201 
  202         RB_FOREACH(gnp, ac_gtree, &mp->mnt_acct.ac_groot) {
  203                 for (i=0; i<ACCT_CHUNK_NIDS; i++) {
  204                         if (gnp->gid_chunk[i].space != 0) {
  205                                 item = prop_dictionary_create();
  206                                 (void) prop_dictionary_set_uint32(item, "gid",
  207                                         (gnp->left_bits << ACCT_CHUNK_BITS) + i);
  208                                 (void) prop_dictionary_set_uint64(item, "space used",
  209                                         gnp->gid_chunk[i].space);
  210                                 (void) prop_dictionary_set_uint64(item, "limit",
  211                                         gnp->gid_chunk[i].limit);
  212                                 prop_array_add_and_rel(dict_out, item);
  213                         }
  214                 }
  215         }
  216 }
  217 
  218 static int
  219 cmd_set_usage_all(struct mount *mp, prop_array_t args)
  220 {
  221         struct ac_unode ufind, *unp;
  222         struct ac_gnode gfind, *gnp;
  223         prop_dictionary_t item;
  224         prop_object_iterator_t iter;
  225         uint32_t id;
  226         uint64_t space;
  227 
  228         spin_lock(&mp->mnt_acct.ac_spin);
  229         /* 0. zero all statistics */
  230         /* we don't bother to free up memory, most of it would probably be
  231          * re-allocated immediately anyway. just bzeroing the existing nodes
  232          * is fine */
  233         mp->mnt_acct.ac_bytes = 0;
  234         RB_FOREACH(unp, ac_utree, &mp->mnt_acct.ac_uroot) {
  235                 bzero(&unp->uid_chunk, sizeof(unp->uid_chunk));
  236         }
  237         RB_FOREACH(gnp, ac_gtree, &mp->mnt_acct.ac_groot) {
  238                 bzero(&gnp->gid_chunk, sizeof(gnp->gid_chunk));
  239         }
  240 
  241         /* args contains an array of dict */
  242         iter = prop_array_iterator(args);
  243         if (iter == NULL) {
  244                 kprintf("cmd_set_usage_all(): failed to create iterator\n");
  245                 spin_unlock(&mp->mnt_acct.ac_spin);
  246                 return 1;
  247         }
  248         while ((item = prop_object_iterator_next(iter)) != NULL) {
  249                 prop_dictionary_get_uint64(item, "space used", &space);
  250                 if (prop_dictionary_get_uint32(item, "uid", &id)) {
  251                         ufind.left_bits = (id >> ACCT_CHUNK_BITS);
  252                         unp = RB_FIND(ac_utree, &mp->mnt_acct.ac_uroot, &ufind);
  253                         if (unp == NULL)
  254                                 unp = unode_insert(mp, id);
  255                         unp->uid_chunk[(id & ACCT_CHUNK_MASK)].space = space;
  256                 } else if (prop_dictionary_get_uint32(item, "gid", &id)) {
  257                         gfind.left_bits = (id >> ACCT_CHUNK_BITS);
  258                         gnp = RB_FIND(ac_gtree, &mp->mnt_acct.ac_groot, &gfind);
  259                         if (gnp == NULL)
  260                                 gnp = gnode_insert(mp, id);
  261                         gnp->gid_chunk[(id & ACCT_CHUNK_MASK)].space = space;
  262                 } else {
  263                         mp->mnt_acct.ac_bytes = space;
  264                 }
  265         }
  266         prop_object_iterator_release(iter);
  267 
  268         spin_unlock(&mp->mnt_acct.ac_spin);
  269         return 0;
  270 }
  271 
  272 static int
  273 cmd_set_limit(struct mount *mp, prop_dictionary_t args)
  274 {
  275         uint64_t limit;
  276 
  277         prop_dictionary_get_uint64(args, "limit", &limit);
  278 
  279         spin_lock(&mp->mnt_acct.ac_spin);
  280         mp->mnt_acct.ac_limit = limit;
  281         spin_unlock(&mp->mnt_acct.ac_spin);
  282 
  283         return 0;
  284 }
  285 
  286 static int
  287 cmd_set_limit_uid(struct mount *mp, prop_dictionary_t args)
  288 {
  289         uint64_t limit;
  290         uid_t uid;
  291         struct ac_unode ufind, *unp;
  292 
  293         prop_dictionary_get_uint32(args, "uid", &uid);
  294         prop_dictionary_get_uint64(args, "limit", &limit);
  295 
  296         ufind.left_bits = (uid >> ACCT_CHUNK_BITS);
  297 
  298         spin_lock(&mp->mnt_acct.ac_spin);
  299         if ((unp = RB_FIND(ac_utree, &mp->mnt_acct.ac_uroot, &ufind)) == NULL)
  300                 unp = unode_insert(mp, uid);
  301         unp->uid_chunk[(uid & ACCT_CHUNK_MASK)].limit = limit;
  302         spin_unlock(&mp->mnt_acct.ac_spin);
  303 
  304         return 0;
  305 }
  306 
  307 static int
  308 cmd_set_limit_gid(struct mount *mp, prop_dictionary_t args)
  309 {
  310         uint64_t limit;
  311         gid_t gid;
  312         struct ac_gnode gfind, *gnp;
  313 
  314         prop_dictionary_get_uint32(args, "gid", &gid);
  315         prop_dictionary_get_uint64(args, "limit", &limit);
  316 
  317         gfind.left_bits = (gid >> ACCT_CHUNK_BITS);
  318 
  319         spin_lock(&mp->mnt_acct.ac_spin);
  320         if ((gnp = RB_FIND(ac_gtree, &mp->mnt_acct.ac_groot, &gfind)) == NULL)
  321                 gnp = gnode_insert(mp, gid);
  322         gnp->gid_chunk[(gid & ACCT_CHUNK_MASK)].limit = limit;
  323         spin_unlock(&mp->mnt_acct.ac_spin);
  324 
  325         return 0;
  326 }
  327 
  328 int
  329 sys_vquotactl(struct vquotactl_args *vqa)
  330 /* const char *path, struct plistref *pref */
  331 {
  332         const char *path;
  333         struct plistref pref;
  334         prop_dictionary_t dict;
  335         prop_object_t args;
  336         char *cmd;
  337 
  338         prop_array_t pa_out;
  339 
  340         struct nlookupdata nd;
  341         struct mount *mp;
  342         int error;
  343 
  344         if (!vfs_quota_enabled)
  345                 return EOPNOTSUPP;
  346         path = vqa->path;
  347         error = copyin(vqa->pref, &pref, sizeof(pref));
  348         error = prop_dictionary_copyin(&pref, &dict);
  349         if (error != 0)
  350                 return(error);
  351 
  352         /* we have a path, get its mount point */
  353         error = nlookup_init(&nd, path, UIO_USERSPACE, 0);
  354         if (error != 0)
  355                 return (error);
  356         error = nlookup(&nd);
  357         if (error != 0)
  358                 return (error);
  359         mp = nd.nl_nch.mount;
  360         nlookup_done(&nd);
  361 
  362         /* get the command */
  363         if (prop_dictionary_get_cstring(dict, "command", &cmd) == 0) {
  364                 kprintf("sys_vquotactl(): couldn't get command\n");
  365                 return EINVAL;
  366         }
  367         args = prop_dictionary_get(dict, "arguments");
  368         if (args == NULL) {
  369                 kprintf("couldn't get arguments\n");
  370                 return EINVAL;
  371         }
  372 
  373         pa_out = prop_array_create();
  374         if (pa_out == NULL)
  375                 return ENOMEM;
  376 
  377         if (strcmp(cmd, "get usage all") == 0) {
  378                 cmd_get_usage_all(mp, pa_out);
  379                 goto done;
  380         }
  381         if (strcmp(cmd, "set usage all") == 0) {
  382                 error = cmd_set_usage_all(mp, args);
  383                 goto done;
  384         }
  385         if (strcmp(cmd, "set limit") == 0) {
  386                 error = cmd_set_limit(mp, args);
  387                 goto done;
  388         }
  389         if (strcmp(cmd, "set limit uid") == 0) {
  390                 error = cmd_set_limit_uid(mp, args);
  391                 goto done;
  392         }
  393         if (strcmp(cmd, "set limit gid") == 0) {
  394                 error = cmd_set_limit_gid(mp, args);
  395                 goto done;
  396         }
  397         return EINVAL;
  398 
  399 done:
  400         /* kernel to userland */
  401         dict = prop_dictionary_create();
  402         error = prop_dictionary_set(dict, "returned data", pa_out);
  403 
  404         error = prop_dictionary_copyout(&pref, dict);
  405         error = copyout(&pref, vqa->pref, sizeof(pref));
  406 
  407         return error;
  408 }
  409 
  410 /*
  411  * Returns a valid mount point for accounting purposes
  412  * We cannot simply use vp->v_mount if the vnode belongs
  413  * to a PFS mount point
  414  */
  415 struct mount*
  416 vq_vptomp(struct vnode *vp)
  417 {
  418         /* XXX: vp->v_pfsmp may point to a freed structure
  419         * we use mountlist_exists() to check if it is valid
  420         * before using it */
  421         if ((vp->v_pfsmp != NULL) && (mountlist_exists(vp->v_pfsmp))) {
  422                 /* This is a PFS, use a copy of the real mp */
  423                 return vp->v_pfsmp;
  424         } else {
  425                 /* Not a PFS or a PFS beeing unmounted */
  426                 return vp->v_mount;
  427         }
  428 }
  429 
  430 int
  431 vq_write_ok(struct mount *mp, uid_t uid, gid_t gid, uint64_t delta)
  432 {
  433         int rv = 1;
  434         struct ac_unode ufind, *unp;
  435         struct ac_gnode gfind, *gnp;
  436         uint64_t space, limit;
  437 
  438         spin_lock(&mp->mnt_acct.ac_spin);
  439 
  440         if (mp->mnt_acct.ac_limit == 0)
  441                 goto check_uid;
  442         if ((mp->mnt_acct.ac_bytes + delta) > mp->mnt_acct.ac_limit) {
  443                 rv = 0;
  444                 goto done;
  445         }
  446 
  447 check_uid:
  448         ufind.left_bits = (uid >> ACCT_CHUNK_BITS);
  449         if ((unp = RB_FIND(ac_utree, &mp->mnt_acct.ac_uroot, &ufind)) == NULL) {
  450                 space = 0;
  451                 limit = 0;
  452         } else {
  453                 space = unp->uid_chunk[(uid & ACCT_CHUNK_MASK)].space;
  454                 limit = unp->uid_chunk[(uid & ACCT_CHUNK_MASK)].limit;
  455         }
  456         if (limit == 0)
  457                 goto check_gid;
  458         if ((space + delta) > limit) {
  459                 rv = 0;
  460                 goto done;
  461         }
  462 
  463 check_gid:
  464         gfind.left_bits = (gid >> ACCT_CHUNK_BITS);
  465         if ((gnp = RB_FIND(ac_gtree, &mp->mnt_acct.ac_groot, &gfind)) == NULL) {
  466                 space = 0;
  467                 limit = 0;
  468         } else {
  469                 space = gnp->gid_chunk[(gid & ACCT_CHUNK_MASK)].space;
  470                 limit = gnp->gid_chunk[(gid & ACCT_CHUNK_MASK)].limit;
  471         }
  472         if (limit == 0)
  473                 goto done;
  474         if ((space + delta) > limit)
  475                 rv = 0;
  476 
  477 done:
  478         spin_unlock(&mp->mnt_acct.ac_spin);
  479         return rv;
  480 }
Cache object: ebb54cca1c2da1a05b6429abeef5d3b7
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/kern/vfs_quota.c

FreeBSD/Linux Kernel Cross Reference
sys/kern/vfs_quota.c
