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