2 * Copyright (c) 2011,2012 François Tigeot <ftigeot@wolpond.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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
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.
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
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>
39 #include <sys/vfs_quota.h>
40 #include <sys/spinlock.h>
41 #include <sys/spinlock2.h>
44 #include <sys/sysproto.h>
45 #include <libprop/proplib.h>
46 #include <libprop/prop_dictionary.h>
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);
54 rb_ac_unode_cmp(struct ac_unode *a, struct ac_unode *b);
56 rb_ac_gnode_cmp(struct ac_gnode *a, struct ac_gnode *b);
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);
61 struct ac_unode* unode_insert(struct mount*, uid_t);
62 struct ac_gnode* gnode_insert(struct mount*, gid_t);
65 rb_ac_unode_cmp(struct ac_unode *a, struct ac_unode *b)
67 if (a->left_bits < b->left_bits)
69 else if (a->left_bits > b->left_bits)
75 rb_ac_gnode_cmp(struct ac_gnode *a, struct ac_gnode *b)
77 if (a->left_bits < b->left_bits)
79 else if (a->left_bits > b->left_bits)
85 unode_insert(struct mount *mp, uid_t uid)
87 struct ac_unode *unp, *res;
89 unp = kmalloc(sizeof(struct ac_unode), M_MOUNT, M_ZERO | M_WAITOK);
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"));
99 gnode_insert(struct mount *mp, gid_t gid)
101 struct ac_gnode *gnp, *res;
103 gnp = kmalloc(sizeof(struct ac_gnode), M_MOUNT, M_ZERO | M_WAITOK);
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"));
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");
117 /* initializes per mount-point data structures */
119 vq_init(struct mount *mp)
122 if (!vfs_quota_enabled)
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);
130 mp->mnt_acct.ac_bytes = 0;
132 /* enable data collection */
133 mp->mnt_op->vfs_account = vfs_stdaccount;
134 /* mark this filesystem quota enabled */
135 mp->mnt_flag |= MNT_QUOTA;
137 kprintf("vfs accounting enabled for %s\n",
138 mp->mnt_stat.f_mntonname);
143 vq_done(struct mount *mp)
145 /* TODO: remove the rb trees here */
149 vfs_stdaccount(struct mount *mp, uid_t uid, gid_t gid, int64_t delta)
151 struct ac_unode ufind, *unp;
152 struct ac_gnode gfind, *gnp;
154 /* find or create address of chunk */
155 ufind.left_bits = (uid >> ACCT_CHUNK_BITS);
156 gfind.left_bits = (gid >> ACCT_CHUNK_BITS);
158 spin_lock(&mp->mnt_acct.ac_spin);
160 mp->mnt_acct.ac_bytes += delta;
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);
167 /* update existing chunk */
168 unp->uid_chunk[(uid & ACCT_CHUNK_MASK)].space += delta;
169 gnp->gid_chunk[(gid & ACCT_CHUNK_MASK)].space += delta;
171 spin_unlock(&mp->mnt_acct.ac_spin);
175 cmd_get_usage_all(struct mount *mp, prop_array_t dict_out)
177 struct ac_unode *unp;
178 struct ac_gnode *gnp;
180 prop_dictionary_t item;
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);
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);
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);
219 cmd_set_usage_all(struct mount *mp, prop_array_t args)
221 struct ac_unode ufind, *unp;
222 struct ac_gnode gfind, *gnp;
223 prop_dictionary_t item;
224 prop_object_iterator_t iter;
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
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));
237 RB_FOREACH(gnp, ac_gtree, &mp->mnt_acct.ac_groot) {
238 bzero(&gnp->gid_chunk, sizeof(gnp->gid_chunk));
241 /* args contains an array of dict */
242 iter = prop_array_iterator(args);
244 kprintf("cmd_set_usage_all(): failed to create iterator\n");
245 spin_unlock(&mp->mnt_acct.ac_spin);
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);
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);
260 gnp = gnode_insert(mp, id);
261 gnp->gid_chunk[(id & ACCT_CHUNK_MASK)].space = space;
263 mp->mnt_acct.ac_bytes = space;
266 prop_object_iterator_release(iter);
268 spin_unlock(&mp->mnt_acct.ac_spin);
273 cmd_set_limit(struct mount *mp, prop_dictionary_t args)
277 prop_dictionary_get_uint64(args, "limit", &limit);
279 spin_lock(&mp->mnt_acct.ac_spin);
280 mp->mnt_acct.ac_limit = limit;
281 spin_unlock(&mp->mnt_acct.ac_spin);
287 cmd_set_limit_uid(struct mount *mp, prop_dictionary_t args)
291 struct ac_unode ufind, *unp;
293 prop_dictionary_get_uint32(args, "uid", &uid);
294 prop_dictionary_get_uint64(args, "limit", &limit);
296 ufind.left_bits = (uid >> ACCT_CHUNK_BITS);
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);
308 cmd_set_limit_gid(struct mount *mp, prop_dictionary_t args)
312 struct ac_gnode gfind, *gnp;
314 prop_dictionary_get_uint32(args, "gid", &gid);
315 prop_dictionary_get_uint64(args, "limit", &limit);
317 gfind.left_bits = (gid >> ACCT_CHUNK_BITS);
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);
329 sys_vquotactl(struct vquotactl_args *vqa)
330 /* const char *path, struct plistref *pref */
333 struct plistref pref;
334 prop_dictionary_t dict;
340 struct nlookupdata nd;
344 if (!vfs_quota_enabled)
347 error = copyin(vqa->pref, &pref, sizeof(pref));
348 error = prop_dictionary_copyin(&pref, &dict);
352 /* we have a path, get its mount point */
353 error = nlookup_init(&nd, path, UIO_USERSPACE, 0);
356 error = nlookup(&nd);
359 mp = nd.nl_nch.mount;
362 /* get the command */
363 if (prop_dictionary_get_cstring(dict, "command", &cmd) == 0) {
364 kprintf("sys_vquotactl(): couldn't get command\n");
367 args = prop_dictionary_get(dict, "arguments");
369 kprintf("couldn't get arguments\n");
373 pa_out = prop_array_create();
377 if (strcmp(cmd, "get usage all") == 0) {
378 cmd_get_usage_all(mp, pa_out);
381 if (strcmp(cmd, "set usage all") == 0) {
382 error = cmd_set_usage_all(mp, args);
385 if (strcmp(cmd, "set limit") == 0) {
386 error = cmd_set_limit(mp, args);
389 if (strcmp(cmd, "set limit uid") == 0) {
390 error = cmd_set_limit_uid(mp, args);
393 if (strcmp(cmd, "set limit gid") == 0) {
394 error = cmd_set_limit_gid(mp, args);
400 /* kernel to userland */
401 dict = prop_dictionary_create();
402 error = prop_dictionary_set(dict, "returned data", pa_out);
404 error = prop_dictionary_copyout(&pref, dict);
405 error = copyout(&pref, vqa->pref, sizeof(pref));
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
416 vq_vptomp(struct vnode *vp)
418 /* XXX: vp->v_pfsmp may point to a freed structure
419 * we use mountlist_exists() to check if it is valid
421 if ((vp->v_pfsmp != NULL) && (mountlist_exists(vp->v_pfsmp))) {
422 /* This is a PFS, use a copy of the real mp */
425 /* Not a PFS or a PFS beeing unmounted */
431 vq_write_ok(struct mount *mp, uid_t uid, gid_t gid, uint64_t delta)
434 struct ac_unode ufind, *unp;
435 struct ac_gnode gfind, *gnp;
436 uint64_t space, limit;
438 spin_lock(&mp->mnt_acct.ac_spin);
440 if (mp->mnt_acct.ac_limit == 0)
442 if ((mp->mnt_acct.ac_bytes + delta) > mp->mnt_acct.ac_limit) {
448 ufind.left_bits = (uid >> ACCT_CHUNK_BITS);
449 if ((unp = RB_FIND(ac_utree, &mp->mnt_acct.ac_uroot, &ufind)) == NULL) {
453 space = unp->uid_chunk[(uid & ACCT_CHUNK_MASK)].space;
454 limit = unp->uid_chunk[(uid & ACCT_CHUNK_MASK)].limit;
458 if ((space + delta) > limit) {
464 gfind.left_bits = (gid >> ACCT_CHUNK_BITS);
465 if ((gnp = RB_FIND(ac_gtree, &mp->mnt_acct.ac_groot, &gfind)) == NULL) {
469 space = gnp->gid_chunk[(gid & ACCT_CHUNK_MASK)].space;
470 limit = gnp->gid_chunk[(gid & ACCT_CHUNK_MASK)].limit;
474 if ((space + delta) > limit)
478 spin_unlock(&mp->mnt_acct.ac_spin);