1 /*
2 * Copyright (c) 2001 Dima Dorfman.
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 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 /*
28 * mdmfs (md/MFS) is a wrapper around mdconfig(8),
29 * newfs(8), and mount(8) that mimics the command line option set of
30 * the deprecated mount_mfs(8).
31 */
32
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35
36 #include <sys/param.h>
37 #include <sys/mdioctl.h>
38 #include <sys/mount.h>
39 #include <sys/stat.h>
40 #include <sys/wait.h>
41
42 #include <assert.h>
43 #include <err.h>
44 #include <fcntl.h>
45 #include <grp.h>
46 #include <paths.h>
47 #include <pwd.h>
48 #include <stdarg.h>
49 #include <stdio.h>
50 #include <stdlib.h>
51 #include <string.h>
52 #include <ctype.h>
53 #include <unistd.h>
54
55 typedef enum { false, true } bool;
56
57 struct mtpt_info {
58 uid_t mi_uid;
59 bool mi_have_uid;
60 gid_t mi_gid;
61 bool mi_have_gid;
62 mode_t mi_mode;
63 bool mi_have_mode;
64 bool mi_forced_pw;
65 };
66
67 static bool debug; /* Emit debugging information? */
68 static bool loudsubs; /* Suppress output from helper programs? */
69 static bool norun; /* Actually run the helper programs? */
70 static int unit; /* The unit we're working with. */
71 static const char *mdname; /* Name of memory disk device (e.g., "md"). */
72 static const char *mdsuffix; /* Suffix of memory disk device (e.g., ".uzip"). */
73 static size_t mdnamelen; /* Length of mdname. */
74 static const char *path_mdconfig =_PATH_MDCONFIG;
75
76 static void argappend(char **, const char *, ...) __printflike(2, 3);
77 static void debugprintf(const char *, ...) __printflike(1, 2);
78 static void do_mdconfig_attach(const char *, const enum md_types);
79 static void do_mdconfig_attach_au(const char *, const enum md_types);
80 static void do_mdconfig_detach(void);
81 static void do_mount(const char *, const char *);
82 static void do_mtptsetup(const char *, struct mtpt_info *);
83 static void do_newfs(const char *);
84 static void extract_ugid(const char *, struct mtpt_info *);
85 static int run(int *, const char *, ...) __printflike(2, 3);
86 static void usage(void);
87
88 int
main(int argc,char ** argv)89 main(int argc, char **argv)
90 {
91 struct mtpt_info mi; /* Mountpoint info. */
92 char *mdconfig_arg, *newfs_arg, /* Args to helper programs. */
93 *mount_arg;
94 enum md_types mdtype; /* The type of our memory disk. */
95 bool have_mdtype;
96 bool detach, softdep, autounit, newfs;
97 char *mtpoint, *unitstr;
98 char *p;
99 int ch;
100 void *set;
101 unsigned long ul;
102
103 /* Misc. initialization. */
104 (void)memset(&mi, '\0', sizeof(mi));
105 detach = true;
106 softdep = true;
107 autounit = false;
108 newfs = true;
109 have_mdtype = false;
110 mdtype = MD_SWAP;
111 mdname = MD_NAME;
112 mdnamelen = strlen(mdname);
113 /*
114 * Can't set these to NULL. They may be passed to the
115 * respective programs without modification. I.e., we may not
116 * receive any command-line options which will caused them to
117 * be modified.
118 */
119 mdconfig_arg = strdup("");
120 newfs_arg = strdup("");
121 mount_arg = strdup("");
122
123 /* If we were started as mount_mfs or mfs, imply -C. */
124 if (strcmp(getprogname(), "mount_mfs") == 0 ||
125 strcmp(getprogname(), "mfs") == 0) {
126 /* Make compatibility assumptions. */
127 mi.mi_mode = 01777;
128 mi.mi_have_mode = true;
129 }
130
131 while ((ch = getopt(argc, argv,
132 "a:b:Cc:Dd:E:e:F:f:hi:LlMm:NnO:o:Pp:Ss:tUv:w:X")) != -1)
133 switch (ch) {
134 case 'a':
135 argappend(&newfs_arg, "-a %s", optarg);
136 break;
137 case 'b':
138 argappend(&newfs_arg, "-b %s", optarg);
139 break;
140 case 'C':
141 /* Ignored for compatibility. */
142 break;
143 case 'c':
144 argappend(&newfs_arg, "-c %s", optarg);
145 break;
146 case 'D':
147 detach = false;
148 break;
149 case 'd':
150 argappend(&newfs_arg, "-d %s", optarg);
151 break;
152 case 'E':
153 path_mdconfig = optarg;
154 break;
155 case 'e':
156 argappend(&newfs_arg, "-e %s", optarg);
157 break;
158 case 'F':
159 if (have_mdtype)
160 usage();
161 mdtype = MD_VNODE;
162 have_mdtype = true;
163 argappend(&mdconfig_arg, "-f %s", optarg);
164 break;
165 case 'f':
166 argappend(&newfs_arg, "-f %s", optarg);
167 break;
168 case 'h':
169 usage();
170 break;
171 case 'i':
172 argappend(&newfs_arg, "-i %s", optarg);
173 break;
174 case 'L':
175 loudsubs = true;
176 break;
177 case 'l':
178 argappend(&newfs_arg, "-l");
179 break;
180 case 'M':
181 if (have_mdtype)
182 usage();
183 mdtype = MD_MALLOC;
184 have_mdtype = true;
185 break;
186 case 'm':
187 argappend(&newfs_arg, "-m %s", optarg);
188 break;
189 case 'N':
190 norun = true;
191 break;
192 case 'n':
193 argappend(&newfs_arg, "-n");
194 break;
195 case 'O':
196 argappend(&newfs_arg, "-o %s", optarg);
197 break;
198 case 'o':
199 argappend(&mount_arg, "-o %s", optarg);
200 break;
201 case 'P':
202 newfs = false;
203 break;
204 case 'p':
205 if ((set = setmode(optarg)) == NULL)
206 usage();
207 mi.mi_mode = getmode(set, S_IRWXU | S_IRWXG | S_IRWXO);
208 mi.mi_have_mode = true;
209 mi.mi_forced_pw = true;
210 free(set);
211 break;
212 case 'S':
213 softdep = false;
214 break;
215 case 's':
216 argappend(&mdconfig_arg, "-s %s", optarg);
217 break;
218 case 't':
219 argappend(&newfs_arg, "-t");
220 break;
221 case 'U':
222 softdep = true;
223 break;
224 case 'v':
225 argappend(&newfs_arg, "-O %s", optarg);
226 break;
227 case 'w':
228 extract_ugid(optarg, &mi);
229 mi.mi_forced_pw = true;
230 break;
231 case 'X':
232 debug = true;
233 break;
234 default:
235 usage();
236 }
237 argc -= optind;
238 argv += optind;
239 if (argc < 2)
240 usage();
241
242 /* Derive 'unit' (global). */
243 unitstr = argv[0];
244 if (strncmp(unitstr, "/dev/", 5) == 0)
245 unitstr += 5;
246 if (strncmp(unitstr, mdname, mdnamelen) == 0)
247 unitstr += mdnamelen;
248 if (!isdigit(*unitstr)) {
249 autounit = true;
250 unit = -1;
251 mdsuffix = unitstr;
252 } else {
253 ul = strtoul(unitstr, &p, 10);
254 if (ul == ULONG_MAX)
255 errx(1, "bad device unit: %s", unitstr);
256 unit = ul;
257 mdsuffix = p; /* can be empty */
258 }
259
260 mtpoint = argv[1];
261 if (!have_mdtype)
262 mdtype = MD_SWAP;
263 if (softdep)
264 argappend(&newfs_arg, "-U");
265 if (mdtype != MD_VNODE && !newfs)
266 errx(1, "-P requires a vnode-backed disk");
267
268 /* Do the work. */
269 if (detach && !autounit)
270 do_mdconfig_detach();
271 if (autounit)
272 do_mdconfig_attach_au(mdconfig_arg, mdtype);
273 else
274 do_mdconfig_attach(mdconfig_arg, mdtype);
275 if (newfs)
276 do_newfs(newfs_arg);
277 do_mount(mount_arg, mtpoint);
278 do_mtptsetup(mtpoint, &mi);
279
280 return (0);
281 }
282
283 /*
284 * Append the expansion of 'fmt' to the buffer pointed to by '*dstp';
285 * reallocate as required.
286 */
287 static void
argappend(char ** dstp,const char * fmt,...)288 argappend(char **dstp, const char *fmt, ...)
289 {
290 char *old, *new;
291 va_list ap;
292
293 old = *dstp;
294 assert(old != NULL);
295
296 va_start(ap, fmt);
297 if (vasprintf(&new, fmt,ap) == -1)
298 errx(1, "vasprintf");
299 va_end(ap);
300
301 *dstp = new;
302 if (asprintf(&new, "%s %s", old, new) == -1)
303 errx(1, "asprintf");
304 free(*dstp);
305 free(old);
306
307 *dstp = new;
308 }
309
310 /*
311 * If run-time debugging is enabled, print the expansion of 'fmt'.
312 * Otherwise, do nothing.
313 */
314 static void
debugprintf(const char * fmt,...)315 debugprintf(const char *fmt, ...)
316 {
317 va_list ap;
318
319 if (!debug)
320 return;
321 fprintf(stderr, "DEBUG: ");
322 va_start(ap, fmt);
323 vfprintf(stderr, fmt, ap);
324 va_end(ap);
325 fprintf(stderr, "\n");
326 fflush(stderr);
327 }
328
329 /*
330 * Attach a memory disk with a known unit.
331 */
332 static void
do_mdconfig_attach(const char * args,const enum md_types mdtype)333 do_mdconfig_attach(const char *args, const enum md_types mdtype)
334 {
335 int rv;
336 const char *ta; /* Type arg. */
337
338 switch (mdtype) {
339 case MD_SWAP:
340 ta = "-t swap";
341 break;
342 case MD_VNODE:
343 ta = "-t vnode";
344 break;
345 case MD_MALLOC:
346 ta = "-t malloc";
347 break;
348 default:
349 abort();
350 }
351 rv = run(NULL, "%s -a %s%s -u %s%d", path_mdconfig, ta, args,
352 mdname, unit);
353 if (rv)
354 errx(1, "mdconfig (attach) exited with error code %d", rv);
355 }
356
357 /*
358 * Attach a memory disk with an unknown unit; use autounit.
359 */
360 static void
do_mdconfig_attach_au(const char * args,const enum md_types mdtype)361 do_mdconfig_attach_au(const char *args, const enum md_types mdtype)
362 {
363 const char *ta; /* Type arg. */
364 char *linep, *linebuf; /* Line pointer, line buffer. */
365 int fd; /* Standard output of mdconfig invocation. */
366 FILE *sfd;
367 int rv;
368 char *p;
369 size_t linelen;
370 unsigned long ul;
371
372 switch (mdtype) {
373 case MD_SWAP:
374 ta = "-t swap";
375 break;
376 case MD_VNODE:
377 ta = "-t vnode";
378 break;
379 case MD_MALLOC:
380 ta = "-t malloc";
381 break;
382 default:
383 abort();
384 }
385 rv = run(&fd, "%s -a %s%s", path_mdconfig, ta, args);
386 if (rv)
387 errx(1, "mdconfig (attach) exited with error code %d", rv);
388
389 /* Receive the unit number. */
390 if (norun) { /* Since we didn't run, we can't read. Fake it. */
391 unit = 0;
392 return;
393 }
394 sfd = fdopen(fd, "r");
395 if (sfd == NULL)
396 err(1, "fdopen");
397 linep = fgetln(sfd, &linelen);
398 if (linep == NULL && linelen < mdnamelen + 1)
399 errx(1, "unexpected output from mdconfig (attach)");
400 /* If the output format changes, we want to know about it. */
401 assert(strncmp(linep, mdname, mdnamelen) == 0);
402 linebuf = malloc(linelen - mdnamelen + 1);
403 assert(linebuf != NULL);
404 /* Can't use strlcpy because linep is not NULL-terminated. */
405 strncpy(linebuf, linep + mdnamelen, linelen);
406 linebuf[linelen] = '\0';
407 ul = strtoul(linebuf, &p, 10);
408 if (ul == ULONG_MAX || *p != '\n')
409 errx(1, "unexpected output from mdconfig (attach)");
410 unit = ul;
411
412 fclose(sfd);
413 close(fd);
414 }
415
416 /*
417 * Detach a memory disk.
418 */
419 static void
do_mdconfig_detach(void)420 do_mdconfig_detach(void)
421 {
422 int rv;
423
424 rv = run(NULL, "%s -d -u %s%d", path_mdconfig, mdname, unit);
425 if (rv && debug) /* This is allowed to fail. */
426 warnx("mdconfig (detach) exited with error code %d (ignored)",
427 rv);
428 }
429
430 /*
431 * Mount the configured memory disk.
432 */
433 static void
do_mount(const char * args,const char * mtpoint)434 do_mount(const char *args, const char *mtpoint)
435 {
436 int rv;
437
438 rv = run(NULL, "%s%s /dev/%s%d%s %s", _PATH_MOUNT, args,
439 mdname, unit, mdsuffix, mtpoint);
440 if (rv)
441 errx(1, "mount exited with error code %d", rv);
442 }
443
444 /*
445 * Various configuration of the mountpoint. Mostly, enact 'mip'.
446 */
447 static void
do_mtptsetup(const char * mtpoint,struct mtpt_info * mip)448 do_mtptsetup(const char *mtpoint, struct mtpt_info *mip)
449 {
450 struct statfs sfs;
451
452 if (!mip->mi_have_mode && !mip->mi_have_uid && !mip->mi_have_gid)
453 return;
454
455 if (!norun) {
456 if (statfs(mtpoint, &sfs) == -1) {
457 warn("statfs: %s", mtpoint);
458 return;
459 }
460 if ((sfs.f_flags & MNT_RDONLY) != 0) {
461 if (mip->mi_forced_pw) {
462 warnx(
463 "Not changing mode/owner of %s since it is read-only",
464 mtpoint);
465 } else {
466 debugprintf(
467 "Not changing mode/owner of %s since it is read-only",
468 mtpoint);
469 }
470 return;
471 }
472 }
473
474 if (mip->mi_have_mode) {
475 debugprintf("changing mode of %s to %o.", mtpoint,
476 mip->mi_mode);
477 if (!norun)
478 if (chmod(mtpoint, mip->mi_mode) == -1)
479 err(1, "chmod: %s", mtpoint);
480 }
481 /*
482 * We have to do these separately because the user may have
483 * only specified one of them.
484 */
485 if (mip->mi_have_uid) {
486 debugprintf("changing owner (user) or %s to %u.", mtpoint,
487 mip->mi_uid);
488 if (!norun)
489 if (chown(mtpoint, mip->mi_uid, -1) == -1)
490 err(1, "chown %s to %u (user)", mtpoint,
491 mip->mi_uid);
492 }
493 if (mip->mi_have_gid) {
494 debugprintf("changing owner (group) or %s to %u.", mtpoint,
495 mip->mi_gid);
496 if (!norun)
497 if (chown(mtpoint, -1, mip->mi_gid) == -1)
498 err(1, "chown %s to %u (group)", mtpoint,
499 mip->mi_gid);
500 }
501 }
502
503 /*
504 * Put a file system on the memory disk.
505 */
506 static void
do_newfs(const char * args)507 do_newfs(const char *args)
508 {
509 int rv;
510
511 rv = run(NULL, "%s%s /dev/%s%d", _PATH_NEWFS, args, mdname, unit);
512 if (rv)
513 errx(1, "newfs exited with error code %d", rv);
514 }
515
516 /*
517 * 'str' should be a user and group name similar to the last argument
518 * to chown(1); i.e., a user, followed by a colon, followed by a
519 * group. The user and group in 'str' may be either a [ug]id or a
520 * name. Upon return, the uid and gid fields in 'mip' will contain
521 * the uid and gid of the user and group name in 'str', respectively.
522 *
523 * In other words, this derives a user and group id from a string
524 * formatted like the last argument to chown(1).
525 *
526 * Notice: At this point we don't support only a username or only a
527 * group name. do_mtptsetup already does, so when this feature is
528 * desired, this is the only routine that needs to be changed.
529 */
530 static void
extract_ugid(const char * str,struct mtpt_info * mip)531 extract_ugid(const char *str, struct mtpt_info *mip)
532 {
533 char *ug; /* Writable 'str'. */
534 char *user, *group; /* Result of extracton. */
535 struct passwd *pw;
536 struct group *gr;
537 char *p;
538 uid_t *uid;
539 gid_t *gid;
540
541 uid = &mip->mi_uid;
542 gid = &mip->mi_gid;
543 mip->mi_have_uid = mip->mi_have_gid = false;
544
545 /* Extract the user and group from 'str'. Format above. */
546 ug = strdup(str);
547 assert(ug != NULL);
548 group = ug;
549 user = strsep(&group, ":");
550 if (user == NULL || group == NULL || *user == '\0' || *group == '\0')
551 usage();
552
553 /* Derive uid. */
554 *uid = strtoul(user, &p, 10);
555 if (*uid == (uid_t)ULONG_MAX)
556 usage();
557 if (*p != '\0') {
558 pw = getpwnam(user);
559 if (pw == NULL)
560 errx(1, "invalid user: %s", user);
561 *uid = pw->pw_uid;
562 }
563 mip->mi_have_uid = true;
564
565 /* Derive gid. */
566 *gid = strtoul(group, &p, 10);
567 if (*gid == (gid_t)ULONG_MAX)
568 usage();
569 if (*p != '\0') {
570 gr = getgrnam(group);
571 if (gr == NULL)
572 errx(1, "invalid group: %s", group);
573 *gid = gr->gr_gid;
574 }
575 mip->mi_have_gid = true;
576
577 free(ug);
578 }
579
580 /*
581 * Run a process with command name and arguments pointed to by the
582 * formatted string 'cmdline'. Since system(3) is not used, the first
583 * space-delimited token of 'cmdline' must be the full pathname of the
584 * program to run. The return value is the return code of the process
585 * spawned. If 'ofd' is non-NULL, it is set to the standard output of
586 * the program spawned (i.e., you can read from ofd and get the output
587 * of the program).
588 */
589 static int
run(int * ofd,const char * cmdline,...)590 run(int *ofd, const char *cmdline, ...)
591 {
592 char **argv, **argvp; /* Result of splitting 'cmd'. */
593 int argc;
594 char *cmd; /* Expansion of 'cmdline'. */
595 int pid, status; /* Child info. */
596 int pfd[2]; /* Pipe to the child. */
597 int nfd; /* Null (/dev/null) file descriptor. */
598 bool dup2dn; /* Dup /dev/null to stdout? */
599 va_list ap;
600 char *p;
601 int rv, i;
602
603 dup2dn = true;
604 va_start(ap, cmdline);
605 rv = vasprintf(&cmd, cmdline, ap);
606 if (rv == -1)
607 err(1, "vasprintf");
608 va_end(ap);
609
610 /* Split up 'cmd' into 'argv' for use with execve. */
611 for (argc = 1, p = cmd; (p = strchr(p, ' ')) != NULL; p++)
612 argc++; /* 'argc' generation loop. */
613 argv = (char **)malloc(sizeof(*argv) * (argc + 1));
614 assert(argv != NULL);
615 for (p = cmd, argvp = argv; (*argvp = strsep(&p, " ")) != NULL;)
616 if (**argvp != '\0')
617 if (++argvp >= &argv[argc]) {
618 *argvp = NULL;
619 break;
620 }
621 assert(*argv);
622 /* The argv array ends up NULL-terminated here. */
623
624 /* Make sure the above loop works as expected. */
625 if (debug) {
626 /*
627 * We can't, but should, use debugprintf here. First,
628 * it appends a trailing newline to the output, and
629 * second it prepends "DEBUG: " to the output. The
630 * former is a problem for this would-be first call,
631 * and the latter for the would-be call inside the
632 * loop.
633 */
634 (void)fprintf(stderr, "DEBUG: running:");
635 /* Should be equivalent to 'cmd' (before strsep, of course). */
636 for (i = 0; argv[i] != NULL; i++)
637 (void)fprintf(stderr, " %s", argv[i]);
638 (void)fprintf(stderr, "\n");
639 }
640
641 /* Create a pipe if necessary and fork the helper program. */
642 if (ofd != NULL) {
643 if (pipe(&pfd[0]) == -1)
644 err(1, "pipe");
645 *ofd = pfd[0];
646 dup2dn = false;
647 }
648 pid = fork();
649 switch (pid) {
650 case 0:
651 /* XXX can we call err() in here? */
652 if (norun)
653 _exit(0);
654 if (ofd != NULL)
655 if (dup2(pfd[1], STDOUT_FILENO) < 0)
656 err(1, "dup2");
657 if (!loudsubs) {
658 nfd = open(_PATH_DEVNULL, O_RDWR);
659 if (nfd == -1)
660 err(1, "open: %s", _PATH_DEVNULL);
661 if (dup2(nfd, STDIN_FILENO) < 0)
662 err(1, "dup2");
663 if (dup2dn)
664 if (dup2(nfd, STDOUT_FILENO) < 0)
665 err(1, "dup2");
666 if (dup2(nfd, STDERR_FILENO) < 0)
667 err(1, "dup2");
668 }
669
670 (void)execv(argv[0], argv);
671 warn("exec: %s", argv[0]);
672 _exit(-1);
673 case -1:
674 err(1, "fork");
675 }
676
677 free(cmd);
678 free(argv);
679 while (waitpid(pid, &status, 0) != pid)
680 ;
681 return (WEXITSTATUS(status));
682 }
683
684 static void
usage(void)685 usage(void)
686 {
687
688 fprintf(stderr,
689 "usage: %s [-DLlMNnPStUX] [-a maxcontig] [-b block-size]\n"
690 "\t[-c blocks-per-cylinder-group][-d max-extent-size] [-E path-mdconfig]\n"
691 "\t[-e maxbpg] [-F file] [-f frag-size] [-i bytes] [-m percent-free]\n"
692 "\t[-O optimization] [-o mount-options]\n"
693 "\t[-p permissions] [-s size] [-v version] [-w user:group]\n"
694 "\tmd-device mount-point\n", getprogname());
695 exit(1);
696 }
697