Cleanup:
[dragonfly.git] / sbin / mountctl / mountctl.c
1 /*
2  * Copyright (c) 2003,2004 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  * 
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  * 
34  * $DragonFly: src/sbin/mountctl/mountctl.c,v 1.8 2005/11/06 12:42:26 swildner Exp $
35  */
36 /*
37  * This utility implements the userland mountctl command which is used to
38  * manage high level journaling on mount points.
39  */
40
41 #include <sys/types.h>
42 #include <sys/param.h>
43 #include <sys/ucred.h>
44 #include <sys/mount.h>
45 #include <sys/time.h>
46 #include <sys/mountctl.h>
47 #include <stdio.h>
48 #include <fcntl.h>
49 #include <string.h>
50 #include <unistd.h>
51 #include <errno.h>
52
53 static volatile void usage(void);
54 static void parse_option_keyword(const char *opt, 
55                 const char **wopt, const char **xopt);
56 static int64_t getsize(const char *str);
57 static const char *numtostr(int64_t num);
58
59 static int mountctl_scan(void (*func)(const char *, const char *, int, void *),
60                 const char *keyword, const char *mountpt, int fd);
61 static void mountctl_list(const char *keyword, const char *mountpt,
62                 int __unused fd, void *info);
63 static void mountctl_add(const char *keyword, const char *mountpt, int fd);
64 static void mountctl_restart(const char *keyword, const char *mountpt, 
65                 int fd, void __unused *);
66 static void mountctl_delete(const char *keyword, const char *mountpt,
67                 int __unused fd, void __unused *);
68 static void mountctl_modify(const char *keyword, const char *mountpt, int fd, void __unused *);
69
70 /*
71  * For all options 0 means unspecified, -1 means noOPT or nonOPT, and a
72  * positive number indicates enabling or execution of the option.
73  */
74 static int exitCode;
75 static int freeze_opt;
76 static int start_opt;
77 static int close_opt;
78 static int abort_opt;
79 static int flush_opt;
80 static int reversable_opt;
81 static int twoway_opt;
82 static int output_safety_override_opt;
83 static int64_t memfifo_opt;
84 static int64_t swapfifo_opt;
85
86 int
87 main(int ac, char **av)
88 {
89     int fd;
90     int ch;
91     int aopt = 0;
92     int dopt = 0;
93     int fopt = 0;
94     int lopt = 0;
95     int mopt = 0;
96     int ropt = 0;
97     int mimplied = 0;
98     const char *wopt = NULL;
99     const char *xopt = NULL;
100     const char *keyword = NULL;
101     const char *mountpt = NULL;
102     char *tmp;
103
104     while ((ch = getopt(ac, av, "2adflmo:rw:x:ACFSW:X:Z")) != -1) {
105         switch(ch) {
106         case '2':
107             twoway_opt = 1;
108             break;
109         case 'r':
110             ropt = 1;
111             if (aopt + dopt + lopt + mopt + ropt != 1) {
112                 fprintf(stderr, "too many action options specified\n");
113                 usage();
114             }
115             break;
116         case 'a':
117             aopt = 1;
118             if (aopt + dopt + lopt + mopt + ropt != 1) {
119                 fprintf(stderr, "too many action options specified\n");
120                 usage();
121             }
122             break;
123         case 'd':
124             dopt = 1;
125             if (aopt + dopt + lopt + mopt + ropt != 1) {
126                 fprintf(stderr, "too many action options specified\n");
127                 usage();
128             }
129             break;
130         case 'f':
131             fopt = 1;
132             break;
133         case 'l':
134             lopt = 1;
135             if (aopt + dopt + lopt + mopt + ropt != 1) {
136                 fprintf(stderr, "too many action options specified\n");
137                 usage();
138             }
139             break;
140         case 'o':
141             parse_option_keyword(optarg, &wopt, &xopt);
142             break;
143         case 'm':
144             mopt = 1;
145             if (aopt + dopt + lopt + mopt + ropt != 1) {
146                 fprintf(stderr, "too many action options specified\n");
147                 usage();
148             }
149             break;
150         case 'W':
151             output_safety_override_opt = 1;
152             /* fall through */
153         case 'w':
154             wopt = optarg;
155             mimplied = 1;
156             break;
157         case 'X':
158             output_safety_override_opt = 1;
159             /* fall through */
160         case 'x':
161             xopt = optarg;
162             mimplied = 1;
163             break;
164         case 'A':
165             mimplied = 1;
166             abort_opt = 1;
167             break;
168         case 'C':
169             mimplied = 1;
170             close_opt = 1;
171             break;
172         case 'F':
173             mimplied = 1;
174             flush_opt = 1;
175             break;
176         case 'S':
177             mimplied = 1;
178             start_opt = 1;
179             break;
180         case 'Z':
181             mimplied = 1;
182             freeze_opt = 1;
183             break;
184         default:
185             fprintf(stderr, "unknown option: -%c\n", optopt);
186             usage();
187         }
188     }
189     ac -= optind;
190     av += optind;
191
192     /*
193      * Parse the keyword and/or mount point.
194      */
195     switch(ac) {
196     case 0:
197         if (aopt || ropt) {
198             fprintf(stderr, "action requires a tag and/or mount "
199                             "point to be specified\n");
200             usage();
201         }
202         break;
203     case 1:
204         if (av[0][0] == '/') {
205             mountpt = av[0];
206             if ((keyword = strchr(mountpt, ':')) != NULL) {
207                 ++keyword;
208                 tmp = strdup(mountpt);
209                 *strchr(tmp, ':') = 0;
210                 mountpt = tmp;
211             }
212         } else {
213             keyword = av[0];
214         }
215         break;
216     default:
217         fprintf(stderr, "unexpected extra arguments to command\n");
218         usage();
219     }
220
221     /*
222      * Additional sanity checks
223      */
224     if (aopt + dopt + lopt + mopt + ropt + mimplied == 0) {
225         fprintf(stderr, "no action or implied action options were specified\n");
226         usage();
227     }
228     if (mimplied && aopt + dopt + lopt + ropt == 0)
229         mopt = 1;
230     if ((wopt || xopt) && !(aopt || ropt || mopt)) {
231         fprintf(stderr, "-w/-x/path/fd options may only be used with -m/-a/-r\n");
232         usage();
233     }
234     if (aopt && (keyword == NULL || mountpt == NULL)) {
235         fprintf(stderr, "a keyword AND a mountpt must be specified "
236                         "when adding a journal\n");
237         usage();
238     }
239     if (fopt == 0 && mopt + dopt && keyword == NULL && mountpt == NULL) {
240         fprintf(stderr, "a keyword, a mountpt, or both must be specified "
241                         "when modifying or deleting a journal, unless "
242                         "-f is also specified for safety\n");
243         usage();
244     }
245
246     /*
247      * Open the journaling file descriptor if required.
248      */
249     if (wopt && xopt) {
250         fprintf(stderr, "you must specify only one of -w/-x/path/fd\n");
251         exit(1);
252     } else if (wopt) {
253         if ((fd = open(wopt, O_RDWR|O_CREAT|O_APPEND, 0666)) < 0) {
254             fprintf(stderr, "unable to create %s: %s\n", wopt, strerror(errno));
255             exit(1);
256         }
257     } else if (xopt) {
258         fd = strtol(xopt, NULL, 0);
259     } else if (aopt || ropt) {
260         fd = 1;         /* stdout default for -a */
261     } else {
262         fd = -1;
263     }
264
265     /*
266      * And finally execute the core command.
267      */
268     if (lopt)
269         mountctl_scan(mountctl_list, keyword, mountpt, fd);
270     if (aopt)
271         mountctl_add(keyword, mountpt, fd);
272     if (ropt) {
273         ch = mountctl_scan(mountctl_restart, keyword, mountpt, fd);
274         if (ch)
275             fprintf(stderr, "%d journals restarted\n", ch);
276         else
277             fprintf(stderr, "Unable to locate any matching journals\n");
278     }
279     if (dopt) {
280         ch = mountctl_scan(mountctl_delete, keyword, mountpt, -1);
281         if (ch)
282             fprintf(stderr, "%d journals deleted\n", ch);
283         else
284             fprintf(stderr, "Unable to locate any matching journals\n");
285     }
286     if (mopt) {
287         ch = mountctl_scan(mountctl_modify, keyword, mountpt, fd);
288         if (ch)
289             fprintf(stderr, "%d journals modified\n", ch);
290         else
291             fprintf(stderr, "Unable to locate any matching journals\n");
292     }
293
294     return(exitCode);
295 }
296
297 static void
298 parse_option_keyword(const char *opt, const char **wopt, const char **xopt)
299 {
300     char *str = strdup(opt);
301     char *name;
302     char *val;
303     int negate;
304     int hasval;
305     int cannotnegate;
306
307     /*
308      * multiple comma delimited options may be specified.
309      */
310     while ((name = strsep(&str, ",")) != NULL) {
311         /*
312          * some options have associated data.
313          */
314         if ((val = strchr(name, '=')) != NULL)
315             *val++ = 0;
316
317         /*
318          * options beginning with 'no' or 'non' are negated.  A positive
319          * number means not negated, a negative number means negated.
320          */
321         negate = 1;
322         cannotnegate = 0;
323         hasval = 0;
324         if (strncmp(name, "non", 3) == 0) {
325             name += 3;
326             negate = -1;
327         } else if (strncmp(name, "no", 2) == 0) {
328             name += 2;
329             negate = -1;
330         }
331
332         /*
333          * Parse supported options
334          */
335         if (strcmp(name, "undo") == 0) {
336             reversable_opt = negate;
337         } else if (strcmp(name, "reversable") == 0) {
338             reversable_opt = negate;
339         } else if (strcmp(name, "twoway") == 0) {
340             twoway_opt = negate;
341         } else if (strcmp(name, "memfifo") == 0) {
342             cannotnegate = 1;
343             hasval = 1;
344             if (val) {
345                 if ((memfifo_opt = getsize(val)) == 0)
346                     memfifo_opt = -1;
347             }
348         } else if (strcmp(name, "swapfifo") == 0) {
349             if (val) {
350                 hasval = 1;
351                 if ((swapfifo_opt = getsize(val)) == 0)
352                     swapfifo_opt = -1;
353             } else if (negate < 0) {
354                 swapfifo_opt = -1;
355             } else {
356                 hasval = 1;     /* force error */
357             }
358         } else if (strcmp(name, "fd") == 0) {
359             cannotnegate = 1;
360             hasval = 1;
361             if (val)
362                 *xopt = val;
363         } else if (strcmp(name, "path") == 0) {
364             cannotnegate = 1;
365             hasval = 1;
366             if (val)
367                 *wopt = val;
368         } else if (strcmp(name, "freeze") == 0 || strcmp(name, "stop") == 0) {
369             if (negate < 0)
370                 start_opt = -negate;
371             else
372                 freeze_opt = negate;
373         } else if (strcmp(name, "start") == 0) {
374             if (negate < 0)
375                 freeze_opt = -negate;
376             else
377                 start_opt = negate;
378         } else if (strcmp(name, "close") == 0) {
379             close_opt = negate;
380         } else if (strcmp(name, "abort") == 0) {
381             abort_opt = negate;
382         } else if (strcmp(name, "flush") == 0) {
383             flush_opt = negate;
384         } else {
385             fprintf(stderr, "unknown option keyword: %s\n", name);
386             exit(1);
387         }
388
389         /*
390          * Sanity checks
391          */
392         if (cannotnegate && negate < 0) {
393             fprintf(stderr, "option %s may not be negated\n", name);
394             exit(1);
395         }
396         if (hasval && val == NULL) {
397             fprintf(stderr, "option %s requires assigned data\n", name);
398             exit(1);
399         }
400         if (hasval == 0 && val) {
401             fprintf(stderr, "option %s does not take an assignment\n", name);
402             exit(1);
403         }
404
405     }
406 }
407
408 static int
409 mountctl_scan(void (*func)(const char *, const char *, int, void *),
410             const char *keyword, const char *mountpt, int fd)
411 {
412     struct statfs *sfs;
413     int count;
414     int calls;
415     int i;
416     struct mountctl_status_journal statreq;
417     struct mountctl_journal_ret_status rstat[4];        /* BIG */
418
419     calls = 0;
420     if (mountpt) {
421         bzero(&statreq, sizeof(statreq));
422         if (keyword) {
423             statreq.index = MC_JOURNAL_INDEX_ID;
424             count = strlen(keyword);
425             if (count > JIDMAX)
426                 count = JIDMAX;
427             bcopy(keyword, statreq.id, count);
428         } else {
429             statreq.index = MC_JOURNAL_INDEX_ALL;
430         }
431         count = mountctl(mountpt, MOUNTCTL_STATUS_VFS_JOURNAL, -1,
432                         &statreq, sizeof(statreq), &rstat, sizeof(rstat));
433         if (count > 0 && rstat[0].recsize != sizeof(rstat[0])) {
434             fprintf(stderr, "Unable to access status, "
435                             "structure size mismatch\n");
436             exit(1);
437         }
438         if (count > 0) {
439             count /= sizeof(rstat[0]);
440             for (i = 0; i < count; ++i) {
441                 func(rstat[i].id, mountpt, fd, &rstat[i]);
442                 ++calls;
443             }
444         }
445     } else {
446         if ((count = getmntinfo(&sfs, MNT_WAIT)) > 0) {
447             for (i = 0; i < count; ++i) {
448                 calls += mountctl_scan(func, keyword, sfs[i].f_mntonname, fd);
449             }
450         } else if (count < 0) {
451             /* XXX */
452         }
453     }
454     return(calls);
455 }
456
457 static void
458 mountctl_list(const char *keyword, const char *mountpt, int __unused fd, void *info)
459 {
460     struct mountctl_journal_ret_status *rstat = info;
461
462     printf("%s:%s\n", mountpt, rstat->id[0] ? rstat->id : "<NOID>");
463     printf("    membufsize=%s\n", numtostr(rstat->membufsize));
464     printf("    membufused=%s\n", numtostr(rstat->membufused));
465     printf("    membufunacked=%s\n", numtostr(rstat->membufunacked));
466     printf("    total_bytes=%s\n", numtostr(rstat->bytessent));
467     printf("    fifo_stalls=%lld\n", rstat->fifostalls);
468 }
469
470 static void
471 mountctl_add(const char *keyword, const char *mountpt, int fd)
472 {
473     struct mountctl_install_journal joinfo;
474     struct stat st1;
475     struct stat st2;
476     int error;
477
478     /*
479      * Make sure the file descriptor is not on the same filesystem as the
480      * mount point.  This isn't a perfect test, but it should catch most
481      * foot shooting.
482      */
483     if (output_safety_override_opt == 0 &&
484         fstat(fd, &st1) == 0 && S_ISREG(st1.st_mode) &&
485         stat(mountpt, &st2) == 0 && st1.st_dev == st2.st_dev
486     ) {
487         fprintf(stderr, "%s:%s failed to add, the journal cannot be on the "
488                         "same filesystem being journaled!\n",
489                         mountpt, keyword);
490         exitCode = 1;
491         return;
492     }
493
494     /*
495      * Setup joinfo and issue the add
496      */
497     bzero(&joinfo, sizeof(joinfo));
498     snprintf(joinfo.id, sizeof(joinfo.id), "%s", keyword);
499     if (memfifo_opt > 0)
500         joinfo.membufsize = memfifo_opt;
501     if (twoway_opt > 0)
502         joinfo.flags |= MC_JOURNAL_WANT_FULLDUPLEX;
503     if (reversable_opt > 0)
504         joinfo.flags |= MC_JOURNAL_WANT_REVERSABLE;
505
506     error = mountctl(mountpt, MOUNTCTL_INSTALL_VFS_JOURNAL, fd,
507                         &joinfo, sizeof(joinfo), NULL, 0);
508     if (error == 0) {
509         fprintf(stderr, "%s:%s added\n", mountpt, joinfo.id);
510     } else {
511         fprintf(stderr, "%s:%s failed to add, error %s\n", mountpt, joinfo.id, strerror(errno));
512         exitCode = 1;
513     }
514 }
515
516 static void
517 mountctl_restart(const char *keyword, const char *mountpt, 
518                  int fd, void __unused *info)
519 {
520     struct mountctl_restart_journal joinfo;
521     int error;
522
523     /* XXX make sure descriptor is not on same filesystem as journal */
524
525     bzero(&joinfo, sizeof(joinfo));
526
527     snprintf(joinfo.id, sizeof(joinfo.id), "%s", keyword);
528     if (twoway_opt > 0)
529         joinfo.flags |= MC_JOURNAL_WANT_FULLDUPLEX;
530     if (reversable_opt > 0)
531         joinfo.flags |= MC_JOURNAL_WANT_REVERSABLE;
532
533     error = mountctl(mountpt, MOUNTCTL_RESTART_VFS_JOURNAL, fd,
534                         &joinfo, sizeof(joinfo), NULL, 0);
535     if (error == 0) {
536         fprintf(stderr, "%s:%s restarted\n", mountpt, joinfo.id);
537     } else {
538         fprintf(stderr, "%s:%s restart failed, error %s\n", mountpt, joinfo.id, strerror(errno));
539     }
540 }
541
542 static void
543 mountctl_delete(const char *keyword, const char *mountpt, 
544                 int __unused fd, void __unused *info)
545 {
546     struct mountctl_remove_journal joinfo;
547     int error;
548
549     bzero(&joinfo, sizeof(joinfo));
550     snprintf(joinfo.id, sizeof(joinfo.id), "%s", keyword);
551     error = mountctl(mountpt, MOUNTCTL_REMOVE_VFS_JOURNAL, -1,
552                         &joinfo, sizeof(joinfo), NULL, 0);
553     if (error == 0) {
554         fprintf(stderr, "%s:%s deleted\n", mountpt, joinfo.id);
555     } else {
556         fprintf(stderr, "%s:%s deletion failed, error %s\n", mountpt, joinfo.id, strerror(errno));
557     }
558 }
559
560 static void
561 mountctl_modify(const char *keyword, const char *mountpt, int fd, void __unused *info)
562 {
563     fprintf(stderr, "modify not yet implemented\n");
564 }
565
566
567 static volatile void
568 usage(void)
569 {
570     printf(
571         " mountctl -l [tag/mountpt | mountpt:tag]\n"
572         " mountctl -a [-w output_path] [-x filedesc]\n"
573         "             [-o option] [-o option ...] mountpt:tag\n"
574         " mountctl -d [tag/mountpt | mountpt:tag]\n"
575         " mountctl -m [-o option] [-o option ...] [tag/mountpt | mountpt:tag]\n"
576         " mountctl -FZSCA [tag/mountpt | mountpt:tag]\n"
577     );
578     exit(1);
579 }
580
581 static int64_t
582 getsize(const char *str)
583 {
584     const char *suffix;
585     int64_t val;
586
587     val = strtoll(str, &suffix, 0);
588     if (suffix) {
589         switch(*suffix) {
590         case 'b':
591             break;
592         case 't':
593             val *= 1024;
594             /* fall through */
595         case 'g':
596             val *= 1024;
597             /* fall through */
598         case 'm':
599             val *= 1024;
600             /* fall through */
601         case 'k':
602             val *= 1024;
603             /* fall through */
604             break;
605         default:
606             fprintf(stderr, "data value '%s' has unknown suffix\n", str);
607             exit(1);
608         }
609     }
610     return(val);
611 }
612
613 static const char *
614 numtostr(int64_t num)
615 {
616     static char buf[64];
617     int n;
618     double v = num;
619
620     if (num < 1024)
621         snprintf(buf, sizeof(buf), "%lld", num);
622     else if (num < 10 * 1024)
623         snprintf(buf, sizeof(buf), "%3.2fK", num / 1024.0);
624     else if (num < 1024 * 1024)
625         snprintf(buf, sizeof(buf), "%3.0fK", num / 1024.0);
626     else if (num < 10 * 1024 * 1024)
627         snprintf(buf, sizeof(buf), "%3.2fM", num / (1024.0 * 1024.0));
628     else if (num < 1024 * 1024 * 1024)
629         snprintf(buf, sizeof(buf), "%3.0fM", num / (1024.0 * 1024.0));
630     else if (num < 10LL * 1024 * 1024 * 1024)
631         snprintf(buf, sizeof(buf), "%3.2fG", num / (1024.0 * 1024.0 * 1024.0));
632     else
633         snprintf(buf, sizeof(buf), "%3.0fG", num / (1024.0 * 1024.0 * 1024.0));
634     return(buf);
635 }
636