Add journaling restart support, required to produce a robust journaling
[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.6 2005/07/13 02:00:19 dillon 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 int64_t memfifo_opt;
83 static int64_t swapfifo_opt;
84
85 int
86 main(int ac, char **av)
87 {
88     int fd;
89     int ch;
90     int aopt = 0;
91     int dopt = 0;
92     int fopt = 0;
93     int lopt = 0;
94     int mopt = 0;
95     int ropt = 0;
96     int mimplied = 0;
97     const char *wopt = NULL;
98     const char *xopt = NULL;
99     const char *keyword = NULL;
100     const char *mountpt = NULL;
101     char *tmp;
102
103     while ((ch = getopt(ac, av, "2adflmo:rw:x:ACFSZ")) != -1) {
104         switch(ch) {
105         case '2':
106             twoway_opt = 1;
107             break;
108         case 'r':
109             ropt = 1;
110             if (aopt + dopt + lopt + mopt + ropt != 1) {
111                 fprintf(stderr, "too many action options specified\n");
112                 usage();
113             }
114             break;
115         case 'a':
116             aopt = 1;
117             if (aopt + dopt + lopt + mopt + ropt != 1) {
118                 fprintf(stderr, "too many action options specified\n");
119                 usage();
120             }
121             break;
122         case 'd':
123             dopt = 1;
124             if (aopt + dopt + lopt + mopt + ropt != 1) {
125                 fprintf(stderr, "too many action options specified\n");
126                 usage();
127             }
128             break;
129         case 'f':
130             fopt = 1;
131             break;
132         case 'l':
133             lopt = 1;
134             if (aopt + dopt + lopt + mopt + ropt != 1) {
135                 fprintf(stderr, "too many action options specified\n");
136                 usage();
137             }
138             break;
139         case 'o':
140             parse_option_keyword(optarg, &wopt, &xopt);
141             break;
142         case 'm':
143             mopt = 1;
144             if (aopt + dopt + lopt + mopt + ropt != 1) {
145                 fprintf(stderr, "too many action options specified\n");
146                 usage();
147             }
148             break;
149         case 'w':
150             wopt = optarg;
151             mimplied = 1;
152             break;
153         case 'x':
154             xopt = optarg;
155             mimplied = 1;
156             break;
157         case 'A':
158             mimplied = 1;
159             abort_opt = 1;
160             break;
161         case 'C':
162             mimplied = 1;
163             close_opt = 1;
164             break;
165         case 'F':
166             mimplied = 1;
167             flush_opt = 1;
168             break;
169         case 'S':
170             mimplied = 1;
171             start_opt = 1;
172             break;
173         case 'Z':
174             mimplied = 1;
175             freeze_opt = 1;
176             break;
177         default:
178             fprintf(stderr, "unknown option: -%c\n", optopt);
179             usage();
180         }
181     }
182     ac -= optind;
183     av += optind;
184
185     /*
186      * Parse the keyword and/or mount point.
187      */
188     switch(ac) {
189     case 0:
190         if (aopt || ropt) {
191             fprintf(stderr, "action requires a tag and/or mount "
192                             "point to be specified\n");
193             usage();
194         }
195         break;
196     case 1:
197         if (av[0][0] == '/') {
198             mountpt = av[0];
199             if ((keyword = strchr(mountpt, ':')) != NULL) {
200                 ++keyword;
201                 tmp = strdup(mountpt);
202                 *strchr(tmp, ':') = 0;
203                 mountpt = tmp;
204             }
205         } else {
206             keyword = av[0];
207         }
208         break;
209     default:
210         fprintf(stderr, "unexpected extra arguments to command\n");
211         usage();
212     }
213
214     /*
215      * Additional sanity checks
216      */
217     if (aopt + dopt + lopt + mopt + ropt + mimplied == 0) {
218         fprintf(stderr, "no action or implied action options were specified\n");
219         usage();
220     }
221     if (mimplied && aopt + dopt + lopt + ropt == 0)
222         mopt = 1;
223     if ((wopt || xopt) && !(aopt || ropt || mopt)) {
224         fprintf(stderr, "-w/-x/path/fd options may only be used with -m/-a/-r\n");
225         usage();
226     }
227     if (aopt && (keyword == NULL || mountpt == NULL)) {
228         fprintf(stderr, "a keyword AND a mountpt must be specified "
229                         "when adding a journal\n");
230         usage();
231     }
232     if (fopt == 0 && mopt + dopt && keyword == NULL && mountpt == NULL) {
233         fprintf(stderr, "a keyword, a mountpt, or both must be specified "
234                         "when modifying or deleting a journal, unless "
235                         "-f is also specified for safety\n");
236         usage();
237     }
238
239     /*
240      * Open the journaling file descriptor if required.
241      */
242     if (wopt && xopt) {
243         fprintf(stderr, "you must specify only one of -w/-x/path/fd\n");
244         exit(1);
245     } else if (wopt) {
246         if ((fd = open(wopt, O_RDWR|O_CREAT|O_APPEND, 0666)) < 0) {
247             fprintf(stderr, "unable to create %s: %s\n", wopt, strerror(errno));
248             exit(1);
249         }
250     } else if (xopt) {
251         fd = strtol(xopt, NULL, 0);
252     } else if (aopt || ropt) {
253         fd = 1;         /* stdout default for -a */
254     } else {
255         fd = -1;
256     }
257
258     /*
259      * And finally execute the core command.
260      */
261     if (lopt)
262         mountctl_scan(mountctl_list, keyword, mountpt, fd);
263     if (aopt)
264         mountctl_add(keyword, mountpt, fd);
265     if (ropt) {
266         ch = mountctl_scan(mountctl_restart, keyword, mountpt, fd);
267         if (ch)
268             fprintf(stderr, "%d journals restarted\n", ch);
269         else
270             fprintf(stderr, "Unable to locate any matching journals\n");
271     }
272     if (dopt) {
273         ch = mountctl_scan(mountctl_delete, keyword, mountpt, -1);
274         if (ch)
275             fprintf(stderr, "%d journals deleted\n", ch);
276         else
277             fprintf(stderr, "Unable to locate any matching journals\n");
278     }
279     if (mopt) {
280         ch = mountctl_scan(mountctl_modify, keyword, mountpt, fd);
281         if (ch)
282             fprintf(stderr, "%d journals modified\n", ch);
283         else
284             fprintf(stderr, "Unable to locate any matching journals\n");
285     }
286
287     return(exitCode);
288 }
289
290 static void
291 parse_option_keyword(const char *opt, const char **wopt, const char **xopt)
292 {
293     char *str = strdup(opt);
294     char *name;
295     char *val;
296     int negate;
297     int hasval;
298     int cannotnegate;
299
300     /*
301      * multiple comma delimited options may be specified.
302      */
303     while ((name = strsep(&str, ",")) != NULL) {
304         /*
305          * some options have associated data.
306          */
307         if ((val = strchr(name, '=')) != NULL)
308             *val++ = 0;
309
310         /*
311          * options beginning with 'no' or 'non' are negated.  A positive
312          * number means not negated, a negative number means negated.
313          */
314         negate = 1;
315         cannotnegate = 0;
316         hasval = 0;
317         if (strncmp(name, "non", 3) == 0) {
318             name += 3;
319             negate = -1;
320         } else if (strncmp(name, "no", 2) == 0) {
321             name += 2;
322             negate = -1;
323         }
324
325         /*
326          * Parse supported options
327          */
328         if (strcmp(name, "reversable") == 0) {
329             reversable_opt = negate;
330         } else if (strcmp(name, "twoway") == 0) {
331             twoway_opt = negate;
332         } else if (strcmp(name, "memfifo") == 0) {
333             cannotnegate = 1;
334             hasval = 1;
335             if (val) {
336                 if ((memfifo_opt = getsize(val)) == 0)
337                     memfifo_opt = -1;
338             }
339         } else if (strcmp(name, "swapfifo") == 0) {
340             if (val) {
341                 hasval = 1;
342                 if ((swapfifo_opt = getsize(val)) == 0)
343                     swapfifo_opt = -1;
344             } else if (negate < 0) {
345                 swapfifo_opt = -1;
346             } else {
347                 hasval = 1;     /* force error */
348             }
349         } else if (strcmp(name, "fd") == 0) {
350             cannotnegate = 1;
351             hasval = 1;
352             if (val)
353                 *xopt = val;
354         } else if (strcmp(name, "path") == 0) {
355             cannotnegate = 1;
356             hasval = 1;
357             if (val)
358                 *wopt = val;
359         } else if (strcmp(name, "freeze") == 0 || strcmp(name, "stop") == 0) {
360             if (negate < 0)
361                 start_opt = -negate;
362             else
363                 freeze_opt = negate;
364         } else if (strcmp(name, "start") == 0) {
365             if (negate < 0)
366                 freeze_opt = -negate;
367             else
368                 start_opt = negate;
369         } else if (strcmp(name, "close") == 0) {
370             close_opt = negate;
371         } else if (strcmp(name, "abort") == 0) {
372             abort_opt = negate;
373         } else if (strcmp(name, "flush") == 0) {
374             flush_opt = negate;
375         } else {
376             fprintf(stderr, "unknown option keyword: %s\n", name);
377             exit(1);
378         }
379
380         /*
381          * Sanity checks
382          */
383         if (cannotnegate && negate < 0) {
384             fprintf(stderr, "option %s may not be negated\n", name);
385             exit(1);
386         }
387         if (hasval && val == NULL) {
388             fprintf(stderr, "option %s requires assigned data\n", name);
389             exit(1);
390         }
391         if (hasval == 0 && val) {
392             fprintf(stderr, "option %s does not take an assignment\n", name);
393             exit(1);
394         }
395
396     }
397 }
398
399 static int
400 mountctl_scan(void (*func)(const char *, const char *, int, void *),
401             const char *keyword, const char *mountpt, int fd)
402 {
403     struct statfs *sfs;
404     int count;
405     int calls;
406     int i;
407     struct mountctl_status_journal statreq;
408     struct mountctl_journal_ret_status rstat[4];        /* BIG */
409
410     calls = 0;
411     if (mountpt) {
412         bzero(&statreq, sizeof(statreq));
413         if (keyword) {
414             statreq.index = MC_JOURNAL_INDEX_ID;
415             count = strlen(keyword);
416             if (count > JIDMAX)
417                 count = JIDMAX;
418             bcopy(keyword, statreq.id, count);
419         } else {
420             statreq.index = MC_JOURNAL_INDEX_ALL;
421         }
422         count = mountctl(mountpt, MOUNTCTL_STATUS_VFS_JOURNAL, -1,
423                         &statreq, sizeof(statreq), &rstat, sizeof(rstat));
424         if (count > 0 && rstat[0].recsize != sizeof(rstat[0])) {
425             fprintf(stderr, "Unable to access status, "
426                             "structure size mismatch\n");
427             exit(1);
428         }
429         if (count > 0) {
430             count /= sizeof(rstat[0]);
431             for (i = 0; i < count; ++i) {
432                 func(rstat[i].id, mountpt, fd, &rstat[i]);
433                 ++calls;
434             }
435         }
436     } else {
437         if ((count = getmntinfo(&sfs, MNT_WAIT)) > 0) {
438             for (i = 0; i < count; ++i) {
439                 calls += mountctl_scan(func, keyword, sfs[i].f_mntonname, fd);
440             }
441         } else if (count < 0) {
442             /* XXX */
443         }
444     }
445     return(calls);
446 }
447
448 static void
449 mountctl_list(const char *keyword, const char *mountpt, int __unused fd, void *info)
450 {
451     struct mountctl_journal_ret_status *rstat = info;
452
453     printf("%s:%s\n", mountpt, rstat->id[0] ? rstat->id : "<NOID>");
454     printf("    membufsize=%s\n", numtostr(rstat->membufsize));
455     printf("    membufused=%s\n", numtostr(rstat->membufused));
456     printf("    membufunacked=%s\n", numtostr(rstat->membufunacked));
457     printf("    total_bytes=%s\n", numtostr(rstat->bytessent));
458     printf("    fifo_stalls=%lld\n", rstat->fifostalls);
459 }
460
461 static void
462 mountctl_add(const char *keyword, const char *mountpt, int fd)
463 {
464     struct mountctl_install_journal joinfo;
465     struct stat st1;
466     struct stat st2;
467     int error;
468
469     /*
470      * Make sure the file descriptor is not on the same filesystem as the
471      * mount point.  This isn't a perfect test, but it should catch most
472      * foot shooting.
473      */
474     if (fstat(fd, &st1) == 0 && S_ISREG(st1.st_mode) &&
475         stat(mountpt, &st2) == 0 && st1.st_dev == st2.st_dev
476     ) {
477         fprintf(stderr, "%s:%s failed to add, the journal cannot be on the "
478                         "same filesystem being journaled!\n",
479                         mountpt, keyword);
480         exitCode = 1;
481         return;
482     }
483
484     /*
485      * Setup joinfo and issue the add
486      */
487     bzero(&joinfo, sizeof(joinfo));
488     snprintf(joinfo.id, sizeof(joinfo.id), "%s", keyword);
489     if (memfifo_opt > 0)
490         joinfo.membufsize = memfifo_opt;
491     if (twoway_opt > 0)
492         joinfo.flags |= MC_JOURNAL_WANT_FULLDUPLEX;
493     if (reversable_opt > 0)
494         joinfo.flags |= MC_JOURNAL_WANT_REVERSABLE;
495
496     error = mountctl(mountpt, MOUNTCTL_INSTALL_VFS_JOURNAL, fd,
497                         &joinfo, sizeof(joinfo), NULL, 0);
498     if (error == 0) {
499         fprintf(stderr, "%s:%s added\n", mountpt, joinfo.id);
500     } else {
501         fprintf(stderr, "%s:%s failed to add, error %s\n", mountpt, joinfo.id, strerror(errno));
502         exitCode = 1;
503     }
504 }
505
506 static void
507 mountctl_restart(const char *keyword, const char *mountpt, 
508                  int fd, void __unused *info)
509 {
510     struct mountctl_restart_journal joinfo;
511     int error;
512
513     /* XXX make sure descriptor is not on same filesystem as journal */
514
515     bzero(&joinfo, sizeof(joinfo));
516
517     snprintf(joinfo.id, sizeof(joinfo.id), "%s", keyword);
518     if (twoway_opt > 0)
519         joinfo.flags |= MC_JOURNAL_WANT_FULLDUPLEX;
520     if (reversable_opt > 0)
521         joinfo.flags |= MC_JOURNAL_WANT_REVERSABLE;
522
523     error = mountctl(mountpt, MOUNTCTL_RESTART_VFS_JOURNAL, fd,
524                         &joinfo, sizeof(joinfo), NULL, 0);
525     if (error == 0) {
526         fprintf(stderr, "%s:%s restarted\n", mountpt, joinfo.id);
527     } else {
528         fprintf(stderr, "%s:%s restart failed, error %s\n", mountpt, joinfo.id, strerror(errno));
529     }
530 }
531
532 static void
533 mountctl_delete(const char *keyword, const char *mountpt, 
534                 int __unused fd, void __unused *info)
535 {
536     struct mountctl_remove_journal joinfo;
537     int error;
538
539     bzero(&joinfo, sizeof(joinfo));
540     snprintf(joinfo.id, sizeof(joinfo.id), "%s", keyword);
541     error = mountctl(mountpt, MOUNTCTL_REMOVE_VFS_JOURNAL, -1,
542                         &joinfo, sizeof(joinfo), NULL, 0);
543     if (error == 0) {
544         fprintf(stderr, "%s:%s deleted\n", mountpt, joinfo.id);
545     } else {
546         fprintf(stderr, "%s:%s deletion failed, error %s\n", mountpt, joinfo.id, strerror(errno));
547     }
548 }
549
550 static void
551 mountctl_modify(const char *keyword, const char *mountpt, int fd, void __unused *info)
552 {
553     fprintf(stderr, "modify not yet implemented\n");
554 }
555
556
557 static volatile
558 void
559 usage(void)
560 {
561     printf(
562         " mountctl -l [tag/mountpt | mountpt:tag]\n"
563         " mountctl -a [-w output_path] [-x filedesc]\n"
564         "             [-o option] [-o option ...] mountpt:tag\n"
565         " mountctl -d [tag/mountpt | mountpt:tag]\n"
566         " mountctl -m [-o option] [-o option ...] [tag/mountpt | mountpt:tag]\n"
567         " mountctl -FZSCA [tag/mountpt | mountpt:tag]\n"
568     );
569     exit(1);
570 }
571
572 static
573 int64_t
574 getsize(const char *str)
575 {
576     const char *suffix;
577     int64_t val;
578
579     val = strtoll(str, &suffix, 0);
580     if (suffix) {
581         switch(*suffix) {
582         case 'b':
583             break;
584         case 't':
585             val *= 1024;
586             /* fall through */
587         case 'g':
588             val *= 1024;
589             /* fall through */
590         case 'm':
591             val *= 1024;
592             /* fall through */
593         case 'k':
594             val *= 1024;
595             /* fall through */
596             break;
597         default:
598             fprintf(stderr, "data value '%s' has unknown suffix\n", str);
599             exit(1);
600         }
601     }
602     return(val);
603 }
604
605 static
606 const char *
607 numtostr(int64_t num)
608 {
609     static char buf[64];
610     int n;
611     double v = num;
612
613     if (num < 1024)
614         snprintf(buf, sizeof(buf), "%lld", num);
615     else if (num < 10 * 1024)
616         snprintf(buf, sizeof(buf), "%3.2fK", num / 1024.0);
617     else if (num < 1024 * 1024)
618         snprintf(buf, sizeof(buf), "%3.0fK", num / 1024.0);
619     else if (num < 10 * 1024 * 1024)
620         snprintf(buf, sizeof(buf), "%3.2fM", num / (1024.0 * 1024.0));
621     else if (num < 1024 * 1024 * 1024)
622         snprintf(buf, sizeof(buf), "%3.0fM", num / (1024.0 * 1024.0));
623     else if (num < 10LL * 1024 * 1024 * 1024)
624         snprintf(buf, sizeof(buf), "%3.2fG", num / (1024.0 * 1024.0 * 1024.0));
625     else
626         snprintf(buf, sizeof(buf), "%3.0fG", num / (1024.0 * 1024.0 * 1024.0));
627     return(buf);
628 }
629