?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge commit 'ad3ad82ad2fb99c424a8482bd1908d08b990ccea'
[unleashed.git] / usr / src / cmd / fs.d / switchout.c
blob51196833eb731478eeafbe1b0df2f6b0913feb0b
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
23 /* All Rights Reserved */
24
25
26 /*
27 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
28 * Use is subject to license terms.
29 */
30
31 #pragma ident "%Z%%M% %I% %E% SMI"
32
33 #include <stdio.h>
34 #include <limits.h>
35 #include <locale.h>
36 #include <libintl.h>
37 #include <sys/fstyp.h>
38 #include <errno.h>
39 #include <sys/vfstab.h>
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <fcntl.h>
43 #include <string.h>
44 #include <libdiskmgt.h>
45 #include "fslib.h"
46
47
48 static int match(char **opts, char *s);
49 static int has_Nflag(char *opts);
50
51 #define FSTYPE_MAX 8
52 #define ARGV_MAX 1024
53 #define VFS_PATH "/usr/lib/fs"
54 #define ALT_PATH "/etc/fs"
55
56 extern char *default_fstype();
57 void stat_snap(char *, char *, char *);
58 char *special = NULL; /* device special name */
59 char *fstype = NULL; /* fstype name is filled in here */
60 char *cbasename; /* name of command */
61 char *newargv[ARGV_MAX]; /* args for the fstype specific command */
62 char vfstab[] = VFSTAB;
63 int newargc = 2;
64
65 /*
66 * TRANSLATION_NOTE - the usage strings in the c_usgstr[] of the
67 * following structures should be given a translation; the call to gettext
68 * is in the usage() function. The strings are the ones containing
69 * "[-F FSType]".
70 */
71
72 struct commands {
73 char *c_basename;
74 char *c_optstr;
75 char *c_usgstr[4]; /* make sure as large as largest array size */
76 } cmd_data[] = {
77 "clri", "F:o:?V",
78 {
79 "[-F FSType] [-V] special inumber ...",
80 NULL
81 },
82 "mkfs", "F:o:mb:?V",
83 {
84 "[-F FSType] [-V] [-m] [-o specific_options] special ",
85 "[operands]", NULL
86 },
87 "dcopy", "F:o:?V",
88 {
89 "[-F FSType] [-V] special inumber ...",
90 NULL
91 },
92 "fsdb", "F:o:z:?V",
93 {
94 "[-F FSType] [-V] [-o specific_options] special",
95 NULL
96 },
97 "fssnap", "F:dio:?V",
98 {
99 "[-F FSType] [-V] -o special_options /mount/point",
100 "-d [-F FSType] [-V] /mount/point | dev",
101 "-i [-F FSType] [-V] [-o special-options] [/mount/point | dev]",
102 NULL
103 },
104 "labelit", "F:o:?nV",
105 {
106 "[-F FSType] [-V] [-o specific_options] special [operands]",
107 NULL
108 },
109 NULL, "F:o:?V",
110 {
111 "[-F FSType] [-V] [-o specific_options] special [operands]",
112 NULL
113 }
114 };
115 struct commands *c_ptr;
116
117 static void usage(char *cmd, char **usg);
118 static void lookup(void);
119
120 int
121 main(int argc, char *argv[])
122 {
123 char *ptr;
124 char full_path[PATH_MAX];
125 char *vfs_path = VFS_PATH;
126 char *alt_path = ALT_PATH;
127 int i;
128 int j;
129 int verbose = 0; /* set if -V is specified */
130 int F_flg = 0;
131 int mflag = 0;
132 int Nflag = 0;
133 char *oopts = NULL;
134 char *tmpopts = NULL; /* used for in use checking */
135 int iflag = 0;
136 int usgflag = 0;
137 int arg; /* argument from getopt() */
138 char *msg;
139 int error;
140 extern char *optarg; /* getopt specific */
141 extern int optind;
142 extern int opterr;
143
144 (void) setlocale(LC_ALL, "");
145
146 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
147 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
148 #endif
149
150 (void) textdomain(TEXT_DOMAIN);
151
152 cbasename = ptr = argv[0];
153 while (*ptr) {
154 if (*ptr++ == '/')
155 cbasename = ptr;
156 }
157
158
159 if (argc == 1) {
160 for (c_ptr = cmd_data; ((c_ptr->c_basename != NULL) &&
161 (strcmp(c_ptr->c_basename, cbasename) != 0)); c_ptr++)
162 ;
163 usage(cbasename, c_ptr->c_usgstr);
164 exit(2);
165 }
166
167 for (c_ptr = cmd_data; ((c_ptr->c_basename != NULL) &&
168 (strcmp(c_ptr->c_basename, cbasename) != 0)); c_ptr++)
169 ;
170 while ((arg = getopt(argc, argv, c_ptr->c_optstr)) != -1) {
171 switch (arg) {
172 case 'V': /* echo complete command line */
173 verbose = 1;
174 break;
175 case 'F': /* FSType specified */
176 F_flg++;
177 fstype = optarg;
178 break;
179 case 'o': /* FSType specific arguments */
180 newargv[newargc++] = "-o";
181 newargv[newargc++] = optarg;
182 oopts = optarg;
183 if (!Nflag) {
184 tmpopts = optarg;
185 Nflag = has_Nflag(tmpopts);
186 }
187 break;
188 case '?': /* print usage message */
189 newargv[newargc++] = "-?";
190 usgflag = 1;
191 break;
192 case 'm': /* FSType specific arguments */
193 mflag = 1;
194 newargv[newargc] = (char *)malloc(3);
195 sprintf(newargv[newargc++], "-%c", arg);
196 if (optarg)
197 newargv[newargc++] = optarg;
198 break;
199 case 'i': /* fssnap only */
200 iflag = 1;
201 /*FALLTHROUGH*/
202 default:
203 newargv[newargc] = (char *)malloc(3);
204 sprintf(newargv[newargc++], "-%c", arg);
205 if (optarg)
206 newargv[newargc++] = optarg;
207 break;
208 }
209 optarg = NULL;
210 }
211 if (F_flg > 1) {
212 (void) fprintf(stderr,
213 gettext("%s: more than one FSType specified\n"),
214 cbasename);
215 usage(cbasename, c_ptr->c_usgstr);
216 exit(2);
217 }
218 if (fstype != NULL) {
219 if (strlen(fstype) > FSTYPE_MAX) {
220 (void) fprintf(stderr,
221 gettext("%s: FSType %s exceeds %d characters\n"),
222 cbasename, fstype, FSTYPE_MAX);
223 exit(2);
224 }
225 }
226
227 /* perform a lookup if fstype is not specified */
228 special = argv[optind];
229 optind++;
230
231 /* handle -i (fssnap command only) */
232 if (iflag) {
233 int diff = argc - optind;
234 /*
235 * There is no reason to ever call a file system specific
236 * version since its all in kstats.
237 */
238 if (diff > 0) /* gave more than one mountpoint or device */
239 usage(cbasename, c_ptr->c_usgstr);
240 stat_snap(cbasename, diff == 0 ? argv[argc-1] : NULL, oopts);
241 exit(0);
242 }
243
244 if ((special == NULL) && (!usgflag)) {
245 (void) fprintf(stderr, gettext("%s: special not specified\n"),
246 cbasename);
247 usage(cbasename, c_ptr->c_usgstr);
248 exit(2);
249 }
250
251 if ((fstype == NULL) && (usgflag))
252 usage(cbasename, c_ptr->c_usgstr);
253 if (fstype == NULL)
254 lookup();
255 if (fstype == NULL) {
256 (void) fprintf(stderr,
257 gettext("%s: FSType cannot be identified\n"), cbasename);
258 usage(cbasename, c_ptr->c_usgstr);
259 exit(2);
260 }
261 newargv[newargc++] = special;
262 for (; optind < argc; optind++)
263 newargv[newargc++] = argv[optind];
264
265 /* build the full pathname of the fstype dependent command */
266 sprintf(full_path, "%s/%s/%s", vfs_path, fstype, cbasename);
267
268 newargv[1] = cbasename;
269
270 if (verbose) {
271 printf("%s -F %s ", cbasename, fstype);
272 for (i = 2; newargv[i]; i++)
273 printf("%s ", newargv[i]);
274 printf("\n");
275 exit(0);
276 }
277
278 /*
279 * Prior to executing the command for mkfs check for device in use.
280 * If the mflag is set, user wants to see command that created
281 * an already existing filesystem. Do not check for in use in this
282 * case. If Nflag is set user wants to see what the parameters
283 * would be to create the filesystem. Do not check for in use in
284 * this case.
285 */
286 if (strcmp(cbasename, "mkfs") == 0 && !mflag && !Nflag) {
287 if (dm_inuse(special, &msg, DM_WHO_MKFS, &error) ||
288 error) {
289 if (error != 0) {
290 (void) fprintf(stderr, gettext("Error occurred"
291 " with device in use checking: %s\n"),
292 strerror(error));
293 } else {
294 (void) fprintf(stderr, "%s", msg);
295 free(msg);
296 exit(2);
297 }
298 }
299 }
300
301 /*
302 * Execute the FSType specific command.
303 */
304 execv(full_path, &newargv[1]);
305 if ((errno == ENOENT) || (errno == EACCES)) {
306 /* build the alternate pathname */
307 sprintf(full_path, "%s/%s/%s", alt_path, fstype, cbasename);
308 if (verbose) {
309 printf("%s -F %s ", cbasename, fstype);
310 for (i = 2; newargv[i]; i++)
311 printf("%s ", newargv[i]);
312 printf("\n");
313 exit(0);
314 }
315 execv(full_path, &newargv[1]);
316 }
317 if (errno == ENOEXEC) {
318 newargv[0] = "sh";
319 newargv[1] = full_path;
320 execv("/sbin/sh", &newargv[0]);
321 }
322 if (errno != ENOENT) {
323 perror(cbasename);
324 (void) fprintf(stderr, gettext("%s: cannot execute %s\n"),
325 cbasename, full_path);
326 exit(2);
327 }
328
329 if (sysfs(GETFSIND, fstype) == (-1)) {
330 (void) fprintf(stderr,
331 gettext("%s: FSType %s not installed in the kernel\n"),
332 cbasename, fstype);
333 exit(2);
334 }
335 (void) fprintf(stderr,
336 gettext("%s: Operation not applicable for FSType %s \n"),
337 cbasename, fstype);
338 return (2);
339 }
340
341 static void
342 usage(char *cmd, char **usg)
343 {
344 int i;
345 (void) fprintf(stderr, gettext("Usage:\n"));
346 for (i = 0; usg[i] != NULL; i++)
347 (void) fprintf(stderr, "%s %s\n", gettext(cmd),
348 gettext(usg[i]));
349 exit(2);
350 }
351
352
353 /*
354 * This looks up the /etc/vfstab entry given the device 'special'.
355 * It is called when the fstype is not specified on the command line.
356 *
357 * The following global variables are used:
358 * special, fstype
359 */
360
361 static void
362 lookup(void)
363 {
364 FILE *fd;
365 int ret;
366 struct vfstab vget, vref;
367
368 if ((fd = fopen(vfstab, "r")) == NULL) {
369 (void) fprintf(stderr, gettext("%s: cannot open vfstab\n"),
370 cbasename);
371 exit(1);
372 }
373 vfsnull(&vref);
374 vref.vfs_special = special;
375 ret = getvfsany(fd, &vget, &vref);
376 if (ret == -1) {
377 rewind(fd);
378 vfsnull(&vref);
379 vref.vfs_fsckdev = special;
380 ret = getvfsany(fd, &vget, &vref);
381 }
382 fclose(fd);
383
384 switch (ret) {
385 case -1:
386 fstype = default_fstype(special);
387 break;
388 case 0:
389 fstype = vget.vfs_fstype;
390 break;
391 case VFS_TOOLONG:
392 (void) fprintf(stderr,
393 gettext("%s: line in vfstab exceeds %d characters\n"),
394 cbasename, VFS_LINE_MAX-2);
395 exit(1);
396 break;
397 case VFS_TOOFEW:
398 (void) fprintf(stderr,
399 gettext("%s: line in vfstab has too few entries\n"),
400 cbasename);
401 exit(1);
402 break;
403 }
404 }
405
406 void
407 stat_snap(char *cmd, char *mountpoint, char *opts)
408 {
409 int fd; /* check mount point if given */
410 int en;
411 char *errstr;
412
413 if (mountpoint) {
414 if ((fd = open(mountpoint, O_RDONLY)) < 0) {
415 en = errno;
416 errstr = strerror(errno);
417 if (errstr == NULL)
418 errstr = gettext("Unknown error");
419
420 (void) fprintf(stderr,
421 gettext("%s: %s: error %d: %s\n"),
422 cmd, mountpoint, en, errstr);
423
424 exit(2);
425 }
426 close(fd);
427 }
428 fssnap_show_status(mountpoint, opts, 1, (opts ? 0 : 1));
429 }
430 static int
431 has_Nflag(char *opts)
432 {
433 while (opts != NULL && *opts != '\0') {
434 if (match(&opts, "N")) {
435 return (1);
436 }
437 if (!opts)
438 break;
439 if (*opts == ',')
440 opts ++;
441 if (*opts == ' ')
442 opts ++;
443 }
444 return (0);
445 }
446 /*
447 * Parses the -o [fs specific options string] to search for the UFS -N flag.
448 * Return the opts string pointing to the next position in the string if
449 * match is not found. A delimiter of , or ' ' can be used depending on the
450 * caller, newfs or mkfs.
451 */
452 static int
453 match(char **opts, char *s)
454 {
455 char *cs;
456 char *tmp_str;
457
458 cs = *opts;
459
460 while (*cs++ == *s) {
461 if (*s++ == '\0') {
462 goto t;
463 }
464 }
465 if (*s != '\0') {
466 /*
467 * If we cannot find the delimiter it means we
468 * have hit the end of the string.
469 */
470 tmp_str = strchr(*opts, ',');
471 if (!tmp_str)
472 tmp_str = strchr(*opts, ' ');
473
474 *opts = tmp_str;
475 return (0);
476 }
477 t:
478 cs--;
479 *opts = cs;
480 return (1);
481 }
Unleashed OS