VFS quota: add a command to set a group quota
[dragonfly.git] / sbin / vquota / vquota.c
1 /*
2  * Copyright (c) 2011, 2012 Fran├žois Tigeot <ftigeot@wolfpond.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/stat.h>
34 #include <sys/mount.h>
35 #include <sys/vfs_quota.h>
36
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <err.h>
40 #include <string.h>
41 #include <fts.h>
42 #include <libprop/proplib.h>
43 #include <unistd.h>
44 #include <sys/tree.h>
45 #include <errno.h>
46 #include <inttypes.h>
47 #include <sys/types.h>
48 #include <libutil.h>
49 #include <pwd.h>
50 #include <grp.h>
51
52 static bool flag_debug = 0;
53 static bool flag_humanize = 0;
54 static bool flag_resolve_ids = 1;
55
56 static void usage(int);
57 static int get_dirsize(char *);
58 static int get_fslist(void);
59
60 static void
61 usage(int retcode)
62 {
63         fprintf(stderr, "usage: vquota [-Dhn] check directory\n");
64         fprintf(stderr, "       vquota [-Dhn] lsfs\n");
65         fprintf(stderr, "       vquota [-Dhn] limit mount_point size\n");
66         fprintf(stderr, "       vquota [-Dhn] ulim  mount_point user  size\n");
67         fprintf(stderr, "       vquota [-Dhn] glim  mount_point group size\n");
68         fprintf(stderr, "       vquota [-Dhn] show mount_point\n");
69         fprintf(stderr, "       vquota [-Dhn] sync mount_point\n");
70         exit(retcode);
71 }
72
73 /*
74  * Inode numbers with more than one hard link often come in groups;
75  * use linear arrays of 1024 ones as the basic unit of allocation.
76  * We only need to check if the inodes have been previously processed,
77  * bit arrays are perfect for that purpose.
78  */
79 #define HL_CHUNK_BITS           10
80 #define HL_CHUNK_ENTRIES        (1<<HL_CHUNK_BITS)
81 #define HL_CHUNK_MASK           (HL_CHUNK_ENTRIES - 1)
82 #define BA_UINT64_BITS          6
83 #define BA_UINT64_ENTRIES       (1<<BA_UINT64_BITS)
84 #define BA_UINT64_MASK          (BA_UINT64_ENTRIES - 1)
85
86 struct hl_node {
87         RB_ENTRY(hl_node)       rb_entry;
88         ino_t                   ino_left_bits;
89         uint64_t                hl_chunk[HL_CHUNK_ENTRIES/64];
90 };
91
92 RB_HEAD(hl_tree,hl_node)        hl_root;
93
94 RB_PROTOTYPE(hl_tree, hl_node, rb_entry, rb_hl_node_cmp);
95
96 static int
97 rb_hl_node_cmp(struct hl_node *a, struct hl_node *b);
98
99 RB_GENERATE(hl_tree, hl_node, rb_entry, rb_hl_node_cmp);
100
101 struct hl_node* hl_node_insert(ino_t);
102
103
104 static int
105 rb_hl_node_cmp(struct hl_node *a, struct hl_node *b)
106 {
107         if (a->ino_left_bits < b->ino_left_bits)
108                 return(-1);
109         else if (a->ino_left_bits > b->ino_left_bits)
110                 return(1);
111         return(0);
112 }
113
114 struct hl_node* hl_node_insert(ino_t inode)
115 {
116         struct hl_node *hlp, *res;
117
118         hlp = malloc(sizeof(struct hl_node));
119         if (hlp == NULL) {
120                 /* shouldn't happen */
121                 printf("hl_node_insert(): malloc failed\n");
122                 exit(ENOMEM);
123         }
124         bzero(hlp, sizeof(struct hl_node));
125
126         hlp->ino_left_bits = (inode >> HL_CHUNK_BITS);
127         res = RB_INSERT(hl_tree, &hl_root, hlp);
128
129         if (res != NULL)        /* shouldn't happen */
130                 printf("hl_node_insert(): RB_INSERT didn't return NULL\n");
131
132         return hlp;
133 }
134
135 /*
136  * hl_register: register an inode number in a rb-tree of bit arrays
137  * returns:
138  * - true if the inode was already processed
139  * - false otherwise
140  */
141 static bool
142 hl_register(ino_t inode)
143 {
144         struct hl_node hl_find, *hlp;
145         uint64_t ino_right_bits, ba_index, ba_offset;
146         uint64_t bitmask, bitval;
147         bool retval = false;
148
149         /* calculate the different addresses of the wanted bit */
150         hl_find.ino_left_bits = (inode >> HL_CHUNK_BITS);
151
152         ino_right_bits = inode & HL_CHUNK_MASK;
153         ba_index  = ino_right_bits >> BA_UINT64_BITS;
154         ba_offset = ino_right_bits & BA_UINT64_MASK;
155
156         /* no existing node? create and initialize it */
157         if ((hlp = RB_FIND(hl_tree, &hl_root, &hl_find)) == NULL) {
158                 hlp = hl_node_insert(inode);
159         }
160
161         /* node was found, check the bit value */
162         bitmask = 1 << ba_offset;
163         bitval = hlp->hl_chunk[ba_index] & bitmask;
164         if (bitval != 0) {
165                 retval = true;
166         }
167
168         /* set the bit */
169         hlp->hl_chunk[ba_index] |= bitmask;
170
171         return retval;
172 }
173
174 /* global variable used by get_dir_size() */
175 uint64_t global_size;
176
177 /* storage for collected id numbers */
178 /* FIXME: same data structures used in kernel, should find a way to
179  * deduplicate this code */
180
181 static int
182 rb_ac_unode_cmp(struct ac_unode*, struct ac_unode*);
183 static int
184 rb_ac_gnode_cmp(struct ac_gnode*, struct ac_gnode*);
185
186 RB_HEAD(ac_utree,ac_unode) ac_uroot;
187 RB_HEAD(ac_gtree,ac_gnode) ac_groot;
188 RB_PROTOTYPE(ac_utree, ac_unode, rb_entry, rb_ac_unode_cmp);
189 RB_PROTOTYPE(ac_gtree, ac_gnode, rb_entry, rb_ac_gnode_cmp);
190 RB_GENERATE(ac_utree, ac_unode, rb_entry, rb_ac_unode_cmp);
191 RB_GENERATE(ac_gtree, ac_gnode, rb_entry, rb_ac_gnode_cmp);
192
193 static int
194 rb_ac_unode_cmp(struct ac_unode *a, struct ac_unode *b)
195 {
196         if (a->left_bits < b->left_bits)
197                 return(-1);
198         else if (a->left_bits > b->left_bits)
199                 return(1);
200         return(0);
201 }
202
203 static int
204 rb_ac_gnode_cmp(struct ac_gnode *a, struct ac_gnode *b)
205 {
206         if (a->left_bits < b->left_bits)
207                 return(-1);
208         else if (a->left_bits > b->left_bits)
209                 return(1);
210         return(0);
211 }
212
213 static struct ac_unode*
214 unode_insert(uid_t uid)
215 {
216         struct ac_unode *unp, *res;
217
218         unp = malloc(sizeof(struct ac_unode));
219         if (unp == NULL) {
220                 printf("unode_insert(): malloc failed\n");
221                 exit(ENOMEM);
222         }
223         bzero(unp, sizeof(struct ac_unode));
224
225         unp->left_bits = (uid >> ACCT_CHUNK_BITS);
226         res = RB_INSERT(ac_utree, &ac_uroot, unp);
227
228         if (res != NULL)        /* shouldn't happen */
229                 printf("unode_insert(): RB_INSERT didn't return NULL\n");
230
231         return unp;
232 }
233
234 static struct ac_gnode*
235 gnode_insert(gid_t gid)
236 {
237         struct ac_gnode *gnp, *res;
238
239         gnp = malloc(sizeof(struct ac_gnode));
240         if (gnp == NULL) {
241                 printf("gnode_insert(): malloc failed\n");
242                 exit(ENOMEM);
243         }
244         bzero(gnp, sizeof(struct ac_gnode));
245
246         gnp->left_bits = (gid >> ACCT_CHUNK_BITS);
247         res = RB_INSERT(ac_gtree, &ac_groot, gnp);
248
249         if (res != NULL)        /* shouldn't happen */
250                 printf("gnode_insert(): RB_INSERT didn't return NULL\n");
251
252         return gnp;
253 }
254
255 /*
256  * get_dirsize(): walks a directory tree in the same filesystem
257  * output:
258  * - global rb-trees ac_uroot and ac_groot
259  * - global variable global_size
260  */
261 static int
262 get_dirsize(char* dirname)
263 {
264         FTS             *fts;
265         FTSENT          *p;
266         char*           fts_args[2];
267         int             retval = 0;
268
269         /* what we need */
270         ino_t           file_inode;
271         off_t           file_size;
272         uid_t           file_uid;
273         gid_t           file_gid;
274
275         struct ac_unode *unp, ufind;
276         struct ac_gnode *gnp, gfind;
277
278         /* TODO: check directory name sanity */
279         fts_args[0] = dirname;
280         fts_args[1] = NULL;
281
282         if ((fts = fts_open(fts_args, FTS_PHYSICAL|FTS_XDEV, NULL)) == NULL)
283                 err(1, "fts_open() failed");
284
285         while ((p = fts_read(fts)) != NULL) {
286                 switch (p->fts_info) {
287                 /* directories, ignore them */
288                 case FTS_D:
289                 case FTS_DC:
290                 case FTS_DP:
291                         break;
292                 /* read errors, warn, continue and flag */
293                 case FTS_DNR:
294                 case FTS_ERR:
295                 case FTS_NS:
296                         warnx("%s: %s", p->fts_path, strerror(p->fts_errno));
297                         retval = 1;
298                         break;
299                 default:
300                         file_inode = p->fts_statp->st_ino;
301                         file_size = p->fts_statp->st_size;
302                         file_uid = p->fts_statp->st_uid;
303                         file_gid = p->fts_statp->st_gid;
304
305                         /* files with more than one hard link: */
306                         /* process them only once */
307                         if (p->fts_statp->st_nlink > 1)
308                                 if (hl_register(file_inode))
309                                         break;
310
311                         global_size += file_size;
312                         ufind.left_bits = (file_uid >> ACCT_CHUNK_BITS);
313                         gfind.left_bits = (file_gid >> ACCT_CHUNK_BITS);
314                         if ((unp = RB_FIND(ac_utree, &ac_uroot, &ufind)) == NULL)
315                                 unp = unode_insert(file_uid);
316                         if ((gnp = RB_FIND(ac_gtree, &ac_groot, &gfind)) == NULL)
317                                 gnp = gnode_insert(file_gid);
318                         unp->uid_chunk[(file_uid & ACCT_CHUNK_MASK)].space += file_size;
319                         gnp->gid_chunk[(file_gid & ACCT_CHUNK_MASK)].space += file_size;
320                 }
321         }
322         fts_close(fts);
323
324         return retval;
325 }
326
327 static void
328 print_user(uid_t uid)
329 {
330         struct passwd *pw;
331
332         if (flag_resolve_ids && ((pw = getpwuid(uid)) != NULL)) {
333                 printf("user %s:", pw->pw_name);
334         } else {
335                 printf("uid %u:", uid);
336         }
337 }
338
339 static void
340 print_group(gid_t gid)
341 {
342         struct group *gr;
343
344         if (flag_resolve_ids && ((gr = getgrgid(gid)) != NULL)) {
345                 printf("group %s:", gr->gr_name);
346         } else {
347                 printf("gid %u:", gid);
348         }
349 }
350
351 static int
352 cmd_check(char* dirname)
353 {
354         int32_t uid, gid;
355         char    hbuf[5];
356         struct  ac_unode *unp;
357         struct  ac_gnode *gnp;
358         int     rv, i;
359
360         rv = get_dirsize(dirname);
361
362         if (flag_humanize) {
363                 humanize_number(hbuf, sizeof(hbuf), global_size, "",
364                     HN_AUTOSCALE, HN_NOSPACE);
365                 printf("total: %s\n", hbuf);
366         } else {
367                 printf("total: %"PRIu64"\n", global_size);
368         }
369         RB_FOREACH(unp, ac_utree, &ac_uroot) {
370             for (i=0; i<ACCT_CHUNK_NIDS; i++) {
371                 if (unp->uid_chunk[i].space != 0) {
372                     uid = (unp->left_bits << ACCT_CHUNK_BITS) + i;
373                     print_user(uid);
374                     if (flag_humanize) {
375                         humanize_number(hbuf, sizeof(hbuf),
376                         unp->uid_chunk[i].space, "", HN_AUTOSCALE, HN_NOSPACE);
377                         printf(" %s\n", hbuf);
378                     } else {
379                         printf(" %" PRIu64 "\n", unp->uid_chunk[i].space);
380                     }
381                 }
382             }
383         }
384         RB_FOREACH(gnp, ac_gtree, &ac_groot) {
385             for (i=0; i<ACCT_CHUNK_NIDS; i++) {
386                 if (gnp->gid_chunk[i].space != 0) {
387                     gid = (gnp->left_bits << ACCT_CHUNK_BITS) + i;
388                     print_group(gid);
389                     if (flag_humanize) {
390                         humanize_number(hbuf, sizeof(hbuf),
391                         gnp->gid_chunk[i].space, "", HN_AUTOSCALE, HN_NOSPACE);
392                         printf(" %s\n", hbuf);
393                     } else {
394                         printf(" %" PRIu64 "\n", gnp->gid_chunk[i].space);
395                     }
396                 }
397             }
398         }
399
400         return rv;
401 }
402
403 /* print a list of filesystems with accounting enabled */
404 static int
405 get_fslist(void)
406 {
407         struct statfs *mntbufp;
408         int nloc, i;
409
410         /* read mount table from kernel */
411         nloc = getmntinfo(&mntbufp, MNT_NOWAIT|MNT_LOCAL);
412         if (nloc <= 0) {
413                 perror("getmntinfo");
414                 exit(1);
415         }
416
417         /* iterate mounted filesystems */
418         for (i=0; i<nloc; i++) {
419             /* vfs accounting enabled on this one ? */
420             if (mntbufp[i].f_flags & MNT_ACCOUNTING)
421                 printf("%s on %s\n", mntbufp[i].f_mntfromname,
422                     mntbufp[i].f_mntonname);
423         }
424
425         return 0;
426 }
427
428 static bool
429 send_command(const char *path, const char *cmd,
430                 prop_object_t args, prop_dictionary_t *res)
431 {
432         prop_dictionary_t dict;
433         struct plistref pref;
434
435         bool rv;
436         int error;
437
438         dict = prop_dictionary_create();
439
440         if (dict == NULL) {
441                 printf("send_command(): couldn't create dictionary\n");
442                 return false;
443         }
444
445         rv = prop_dictionary_set_cstring(dict, "command", cmd);
446         if (rv== false) {
447                 printf("send_command(): couldn't initialize dictionary\n");
448                 return false;
449         }
450
451         rv = prop_dictionary_set(dict, "arguments", args);
452         if (rv == false) {
453                 printf("prop_dictionary_set() failed\n");
454                 return false;
455         }
456
457         error = prop_dictionary_send_syscall(dict, &pref);
458         if (error != 0) {
459                 printf("prop_dictionary_send_syscall() failed\n");
460                 prop_object_release(dict);
461                 return false;
462         }
463
464         if (flag_debug)
465                 printf("Message to kernel:\n%s\n",
466                     prop_dictionary_externalize(dict));
467
468         error = vquotactl(path, &pref);
469         if (error != 0) {
470                 printf("send_command: vquotactl = %d\n", error);
471                 return false;
472         }
473
474         error = prop_dictionary_recv_syscall(&pref, res);
475         if (error != 0) {
476                 printf("prop_dictionary_recv_syscall() failed\n");
477         }
478
479         if (flag_debug)
480                 printf("Message from kernel:\n%s\n",
481                     prop_dictionary_externalize(*res));
482
483         return true;
484 }
485
486 /* show collected statistics on mount point */
487 static int
488 show_mp(char *path)
489 {
490         prop_dictionary_t args, res;
491         prop_array_t reslist;
492         bool rv;
493         prop_object_iterator_t  iter;
494         prop_dictionary_t item;
495         uint32_t id;
496         uint64_t space, limit=0;
497         char hbuf[5];
498
499         args = prop_dictionary_create();
500         res  = prop_dictionary_create();
501         if (args == NULL)
502                 printf("show_mp(): couldn't create args dictionary\n");
503         res  = prop_dictionary_create();
504         if (res == NULL)
505                 printf("show_mp(): couldn't create res dictionary\n");
506
507         rv = send_command(path, "get usage all", args, &res);
508         if (rv == false) {
509                 printf("show-mp(): failed to send message to kernel\n");
510                 goto end;
511         }
512
513         reslist = prop_dictionary_get(res, "returned data");
514         if (reslist == NULL) {
515                 printf("show_mp(): failed to get array of results");
516                 rv = false;
517                 goto end;
518         }
519
520         iter = prop_array_iterator(reslist);
521         if (iter == NULL) {
522                 printf("show_mp(): failed to create iterator\n");
523                 rv = false;
524                 goto end;
525         }
526
527         while ((item = prop_object_iterator_next(iter)) != NULL) {
528                 rv = prop_dictionary_get_uint64(item, "space used", &space);
529                 rv = prop_dictionary_get_uint64(item, "limit", &limit);
530                 if (prop_dictionary_get_uint32(item, "uid", &id))
531                         print_user(id);
532                 else if (prop_dictionary_get_uint32(item, "gid", &id))
533                         print_group(id);
534                 else
535                         printf("total:");
536                 if (flag_humanize) {
537                         humanize_number(hbuf, sizeof(hbuf), space, "", HN_AUTOSCALE, HN_NOSPACE);
538                         printf(" %s", hbuf);
539                 } else {
540                         printf(" %"PRIu64, space);
541                 }
542                 if (limit == 0) {
543                         printf("\n");
544                         continue;
545                 }
546                 if (flag_humanize) {
547                         humanize_number(hbuf, sizeof(hbuf), limit, "", HN_AUTOSCALE, HN_NOSPACE);
548                         printf(", limit = %s\n", hbuf);
549                 } else {
550                         printf(", limit = %"PRIu64"\n", limit);
551                 }
552         }
553         prop_object_iterator_release(iter);
554
555 end:
556         prop_object_release(args);
557         prop_object_release(res);
558         return (rv == true);
559 }
560
561 /* sync the in-kernel counters to the actual file system usage */
562 static int cmd_sync(char *dirname)
563 {
564         prop_dictionary_t res, item;
565         prop_array_t args;
566         struct ac_unode *unp;
567         struct ac_gnode *gnp;
568         int rv = 0, i;
569
570         args = prop_array_create();
571         if (args == NULL)
572                 printf("cmd_sync(): couldn't create args dictionary\n");
573         res  = prop_dictionary_create();
574         if (res == NULL)
575                 printf("cmd_sync(): couldn't create res dictionary\n");
576
577         rv = get_dirsize(dirname);
578
579         item = prop_dictionary_create();
580         if (item == NULL)
581                 printf("cmd_sync(): couldn't create item dictionary\n");
582         (void) prop_dictionary_set_uint64(item, "space used", global_size);
583         prop_array_add_and_rel(args, item);
584
585         RB_FOREACH(unp, ac_utree, &ac_uroot) {
586             for (i=0; i<ACCT_CHUNK_NIDS; i++) {
587                 if (unp->uid_chunk[i].space != 0) {
588                     item = prop_dictionary_create();
589                     (void) prop_dictionary_set_uint32(item, "uid",
590                                 (unp->left_bits << ACCT_CHUNK_BITS) + i);
591                     (void) prop_dictionary_set_uint64(item, "space used",
592                                 unp->uid_chunk[i].space);
593                     prop_array_add_and_rel(args, item);
594                 }
595             }
596         }
597         RB_FOREACH(gnp, ac_gtree, &ac_groot) {
598             for (i=0; i<ACCT_CHUNK_NIDS; i++) {
599                 if (gnp->gid_chunk[i].space != 0) {
600                     item = prop_dictionary_create();
601                     (void) prop_dictionary_set_uint32(item, "gid",
602                                 (gnp->left_bits << ACCT_CHUNK_BITS) + i);
603                     (void) prop_dictionary_set_uint64(item, "space used",
604                                 gnp->gid_chunk[i].space);
605                     prop_array_add_and_rel(args, item);
606                 }
607             }
608         }
609
610         if (send_command(dirname, "set usage all", args, &res) == false) {
611                 printf("Failed to send message to kernel\n");
612                 rv = 1;
613         }
614
615         prop_object_release(args);
616         prop_object_release(res);
617
618         return rv;
619 }
620
621 static int
622 cmd_limit(char *dirname, uint64_t limit)
623 {
624         prop_dictionary_t res, args;
625         int rv = 0;
626
627         args = prop_dictionary_create();
628         if (args == NULL)
629                 printf("cmd_limit(): couldn't create args dictionary\n");
630         res  = prop_dictionary_create();
631         if (res == NULL)
632                 printf("cmd_limit(): couldn't create res dictionary\n");
633
634         (void) prop_dictionary_set_uint64(args, "limit", limit);
635
636         if (send_command(dirname, "set limit", args, &res) == false) {
637                 printf("Failed to send message to kernel\n");
638                 rv = 1;
639         }
640
641         prop_object_release(args);
642         prop_object_release(res);
643
644         return rv;
645 }
646
647 static int
648 cmd_limit_uid(char *dirname, uid_t uid, uint64_t limit)
649 {
650         prop_dictionary_t res, args;
651         int rv = 0;
652
653         args = prop_dictionary_create();
654         if (args == NULL)
655                 printf("cmd_limit_uid(): couldn't create args dictionary\n");
656         res  = prop_dictionary_create();
657         if (res == NULL)
658                 printf("cmd_limit_uid(): couldn't create res dictionary\n");
659
660         (void) prop_dictionary_set_uint32(args, "uid", uid);
661         (void) prop_dictionary_set_uint64(args, "limit", limit);
662
663         if (send_command(dirname, "set limit uid", args, &res) == false) {
664                 printf("Failed to send message to kernel\n");
665                 rv = 1;
666         }
667
668         prop_object_release(args);
669         prop_object_release(res);
670
671         return rv;
672 }
673
674 static int
675 cmd_limit_gid(char *dirname, gid_t gid, uint64_t limit)
676 {
677         prop_dictionary_t res, args;
678         int rv = 0;
679
680         args = prop_dictionary_create();
681         if (args == NULL)
682                 printf("cmd_limit_gid(): couldn't create args dictionary\n");
683         res  = prop_dictionary_create();
684         if (res == NULL)
685                 printf("cmd_limit_gid(): couldn't create res dictionary\n");
686
687         (void) prop_dictionary_set_uint32(args, "gid", gid);
688         (void) prop_dictionary_set_uint64(args, "limit", limit);
689
690         if (send_command(dirname, "set limit gid", args, &res) == false) {
691                 printf("Failed to send message to kernel\n");
692                 rv = 1;
693         }
694
695         prop_object_release(args);
696         prop_object_release(res);
697
698         return rv;
699 }
700
701 int
702 main(int argc, char **argv)
703 {
704         int ch;
705         uint64_t limit;
706
707         while ((ch = getopt(argc, argv, "Dhn")) != -1) {
708                 switch(ch) {
709                 case 'D':
710                         flag_debug = 1;
711                         break;
712                 case 'h':
713                         flag_humanize = 1;
714                         break;
715                 case 'n':
716                         flag_resolve_ids = 0;
717                         break;
718                 }
719         }
720         argc -= optind;
721         argv += optind;
722         if (argc < 1)
723                 usage(1);
724         
725         if (strcmp(argv[0], "check") == 0) {
726                 if (argc != 2)
727                         usage(1);
728                 return cmd_check(argv[1]);
729         }
730         if (strcmp(argv[0], "lsfs") == 0) {
731                 return get_fslist();
732         }
733         if (strcmp(argv[0], "limit") == 0) {
734                 if (argc != 3)
735                         usage(1);
736                 if (dehumanize_number(argv[2], &limit) < 0)
737                         err(1, "bad number for option: %s", argv[2]);
738
739                 return cmd_limit(argv[1], limit);
740         }
741         if (strcmp(argv[0], "show") == 0) {
742                 if (argc != 2)
743                         usage(1);
744                 return show_mp(argv[1]);
745         }
746         if (strcmp(argv[0], "sync") == 0) {
747                 if (argc != 2)
748                         usage(1);
749                 return cmd_sync(argv[1]);
750         }
751         if (strcmp(argv[0], "ulim") == 0) {
752                 struct passwd *pwd;
753                 if (argc != 4)
754                         usage(1);
755                 if ((pwd = getpwnam(argv[2])) == NULL)
756                         errx(1, "%s: no such user", argv[2]);
757                 if (dehumanize_number(argv[3], &limit) < 0)
758                         err(1, "bad number for option: %s", argv[2]);
759
760                 return cmd_limit_uid(argv[1], pwd->pw_uid, limit);
761         }
762         if (strcmp(argv[0], "glim") == 0) {
763                 struct group *grp;
764                 if (argc != 4)
765                         usage(1);
766                 if ((grp = getgrnam(argv[2])) == NULL)
767                         errx(1, "%s: no such group", argv[2]);
768                 if (dehumanize_number(argv[3], &limit) < 0)
769                         err(1, "bad number for option: %s", argv[2]);
770
771                 return cmd_limit_gid(argv[1], grp->gr_gid, limit);
772         }
773
774         usage(0);
775 }