Annotation of src/sbin/newfs_ext2fs/newfs_ext2fs.c, Revision 1.5
1.5 ! christos 1: /* $NetBSD: newfs_ext2fs.c,v 1.4 2008/07/20 01:20:23 lukem Exp $ */
1.1 tsutsui 2:
3: /*
4: * Copyright (c) 1983, 1989, 1993, 1994
5: * The Regents of the University of California. All rights reserved.
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: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. Neither the name of the University nor the names of its contributors
16: * may be used to endorse or promote products derived from this software
17: * without specific prior written permission.
18: *
19: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29: * SUCH DAMAGE.
30: */
31:
32: #include <sys/cdefs.h>
33: #ifndef lint
1.4 lukem 34: __COPYRIGHT("@(#) Copyright (c) 1983, 1989, 1993, 1994\
35: The Regents of the University of California. All rights reserved.");
1.1 tsutsui 36: #endif /* not lint */
37:
38: #ifndef lint
39: #if 0
40: static char sccsid[] = "@(#)newfs.c 8.13 (Berkeley) 5/1/95";
41: #else
1.5 ! christos 42: __RCSID("$NetBSD: newfs_ext2fs.c,v 1.4 2008/07/20 01:20:23 lukem Exp $");
1.1 tsutsui 43: #endif
44: #endif /* not lint */
45:
46: /*
47: * newfs: friendly front end to mke2fs
48: */
49: #include <sys/param.h>
50: #include <sys/ioctl.h>
51: #include <sys/disklabel.h>
52: #include <sys/disk.h>
53: #include <sys/file.h>
54: #include <sys/mount.h>
55:
56: #include <ufs/ext2fs/ext2fs.h>
57:
58: #include <disktab.h>
59: #include <err.h>
60: #include <errno.h>
61: #include <limits.h>
62: #include <paths.h>
63: #include <stdio.h>
64: #include <stdlib.h>
65: #include <string.h>
66: #include <unistd.h>
67: #include <util.h>
68: #include <mntopts.h>
69:
70: #include "extern.h"
71: #include "partutil.h"
72:
73: static int64_t strsuftoi64(const char *, const char *, int64_t, int64_t, int *);
1.3 perry 74: static void usage(void) __dead;
1.1 tsutsui 75:
76: /*
77: * For file systems smaller than SMALL_FSSIZE we use the S_DFL_* defaults,
78: * otherwise if less than MEDIUM_FSSIZE use M_DFL_*, otherwise use
79: * L_DFL_*.
80: */
81: #define SMALL_FSSIZE ((4 * 1024 * 1024) / sectorsize) /* 4MB */
82: #define S_DFL_BSIZE 1024
83: #define MEDIUM_FSSIZE ((512 * 1024 * 1024) / sectorsize) /* 512MB */
84: #define M_DFL_BSIZE 1024
85: #define L_DFL_BSIZE 4096
86:
87: /*
88: * Each file system has a number of inodes statically allocated.
89: * We allocate one inode slot per 2, 4, or 8 blocks, expecting this
90: * to be far more than we will ever need.
91: */
92: #define S_DFL_NINODE(blocks) ((blocks) / 8)
93: #define M_DFL_NINODE(blocks) ((blocks) / 4)
94: #define L_DFL_NINODE(blocks) ((blocks) / 2)
95:
96: /*
97: * Default sector size.
98: */
99: #define DFL_SECSIZE 512
100:
101: int Nflag; /* run without writing file system */
102: int Oflag = 0; /* format as conservative REV0 by default */
103: int verbosity; /* amount of printf() output */
104: #define DEFAULT_VERBOSITY 3 /* 4 is traditional behavior of newfs(8) */
105: int64_t fssize; /* file system size */
106: uint sectorsize; /* bytes/sector */
1.5 ! christos 107: uint16_t inodesize = 128; /* inode size */
1.1 tsutsui 108: uint fsize = 0; /* fragment size */
109: uint bsize = 0; /* block size */
110: uint minfree = MINFREE; /* free space threshold */
111: uint density; /* number of bytes per inode */
112: uint num_inodes; /* number of inodes (overrides density) */
113: char *volname = NULL; /* volume name */
114:
115: static char *disktype = NULL;
116: static char device[MAXPATHLEN];
117:
118: static const char lmsg[] = "%s: can't read disk label";
119:
120: int
121: main(int argc, char *argv[])
122: {
123: struct disk_geom geo;
124: struct dkwedge_info dkw;
125: struct statvfs *mp;
126: struct stat sb;
127: int ch, fsi, fso, len, n, Fflag, Iflag, Zflag;
128: char *cp, *s1, *s2, *special;
129: const char *opstring;
130: int byte_sized;
131: uint blocks; /* number of blocks */
132:
133: cp = NULL;
134: fsi = fso = -1;
135: Fflag = Iflag = Zflag = 0;
136: verbosity = -1;
1.5 ! christos 137: opstring = "D:FINO:S:V:Zb:f:i:l:m:n:s:v:";
1.1 tsutsui 138: byte_sized = 0;
139: while ((ch = getopt(argc, argv, opstring)) != -1)
140: switch (ch) {
1.5 ! christos 141: case 'D':
! 142: inodesize = (uint16_t)strtol(optarg, &s1, 0);
! 143: if (*s1 || inodesize != 128 || inodesize != 256)
! 144: errx(1, "Bad inode size %d "
! 145: "(only 128 and 256 supported)", inodesize);
! 146: break;
1.1 tsutsui 147: case 'F':
148: Fflag = 1;
149: break;
150: case 'I':
151: Iflag = 1;
152: break;
153: case 'N':
154: Nflag = 1;
155: if (verbosity == -1)
156: verbosity = DEFAULT_VERBOSITY;
157: break;
158: case 'O':
159: Oflag = strsuftoi64("format", optarg, 0, 1, NULL);
160: break;
161: case 'S':
162: /*
163: * XXX:
164: * non-512 byte sectors almost certainly don't work.
165: */
166: sectorsize = strsuftoi64("sector size",
167: optarg, 512, 65536, NULL);
168: if (!powerof2(sectorsize))
169: errx(EXIT_FAILURE,
170: "sector size `%s' is not a power of 2.",
171: optarg);
172: break;
173: case 'V':
174: verbosity = strsuftoi64("verbose", optarg, 0, 4, NULL);
175: break;
176: case 'Z':
177: Zflag = 1;
178: break;
179: case 'b':
180: bsize = strsuftoi64("block size",
1.2 tsutsui 181: optarg, MINBSIZE, EXT2_MAXBSIZE, NULL);
1.1 tsutsui 182: break;
183: case 'f':
184: fsize = strsuftoi64("fragment size",
1.2 tsutsui 185: optarg, MINBSIZE, EXT2_MAXBSIZE, NULL);
1.1 tsutsui 186: break;
187: case 'i':
188: density = strsuftoi64("bytes per inode",
189: optarg, 1, INT_MAX, NULL);
190: break;
191: case 'm':
192: minfree = strsuftoi64("free space %",
193: optarg, 0, 99, NULL);
194: break;
195: case 'n':
196: num_inodes = strsuftoi64("number of inodes",
197: optarg, 1, INT_MAX, NULL);
198: break;
199: case 's':
200: fssize = strsuftoi64("file system size",
201: optarg, INT64_MIN, INT64_MAX, &byte_sized);
202: break;
203: case 'v':
204: volname = optarg;
205: if (volname[0] == '\0')
206: errx(EXIT_FAILURE,
207: "Volume name cannot be zero length");
208: break;
209: case '?':
210: default:
211: usage();
212: }
213: argc -= optind;
214: argv += optind;
215:
216: if (verbosity == -1)
217: /* Default to showing cg info */
218: verbosity = DEFAULT_VERBOSITY;
219:
220: if (argc != 1)
221: usage();
222:
223: memset(&sb, 0, sizeof(sb));
224: memset(&dkw, 0, sizeof(dkw));
225: special = argv[0];
226: if (Fflag) {
227: int fl;
228: /*
229: * It's a file system image
230: * no label, use fixed default for sectorsize.
231: */
232: if (sectorsize == 0)
233: sectorsize = DFL_SECSIZE;
234:
235: /* creating image in a regular file */
236: if (Nflag)
237: fl = O_RDONLY;
238: else {
239: if (fssize > 0)
240: fl = O_RDWR | O_CREAT;
241: else
242: fl = O_RDWR;
243: }
244: fsi = open(special, fl, 0777);
245: if (fsi == -1)
246: err(EXIT_FAILURE, "can't open file %s", special);
247: if (fstat(fsi, &sb) == -1)
248: err(EXIT_FAILURE, "can't fstat opened %s", special);
249: if (!Nflag)
250: fso = fsi;
251: } else { /* !Fflag */
252: fsi = opendisk(special, O_RDONLY, device, sizeof(device), 0);
253: special = device;
254: if (fsi < 0 || fstat(fsi, &sb) == -1)
255: err(EXIT_FAILURE, "%s: open for read", special);
256:
257: if (!Nflag) {
258: fso = open(special, O_WRONLY, 0);
259: if (fso < 0)
260: err(EXIT_FAILURE,
261: "%s: open for write", special);
262:
263: /* Bail if target special is mounted */
264: n = getmntinfo(&mp, MNT_NOWAIT);
265: if (n == 0)
266: err(EXIT_FAILURE, "%s: getmntinfo", special);
267:
268: len = sizeof(_PATH_DEV) - 1;
269: s1 = special;
270: if (strncmp(_PATH_DEV, s1, len) == 0)
271: s1 += len;
272:
273: while (--n >= 0) {
274: s2 = mp->f_mntfromname;
275: if (strncmp(_PATH_DEV, s2, len) == 0) {
276: s2 += len - 1;
277: *s2 = 'r';
278: }
279: if (strcmp(s1, s2) == 0 ||
280: strcmp(s1, &s2[1]) == 0)
281: errx(EXIT_FAILURE,
282: "%s is mounted on %s",
283: special, mp->f_mntonname);
284: ++mp;
285: }
286: }
287:
288: if (getdiskinfo(special, fsi, disktype, &geo, &dkw) == -1)
289: errx(EXIT_FAILURE, lmsg, special);
290:
291: if (sectorsize == 0) {
292: sectorsize = geo.dg_secsize;
293: if (sectorsize <= 0)
294: errx(EXIT_FAILURE, "no default sector size");
295: }
296:
297: if (dkw.dkw_parent[0]) {
298: if (dkw.dkw_size == 0)
299: errx(EXIT_FAILURE,
300: "%s partition is unavailable", special);
301:
302: if (!Iflag) {
303: static const char m[] =
304: "%s partition type is not `%s' (or use -I)";
305: if (strcmp(dkw.dkw_ptype, DKW_PTYPE_EXT2FS))
306: errx(EXIT_FAILURE, m,
307: special, "Linux Ext2");
308: }
309: }
310: }
311:
312: if (byte_sized)
313: fssize /= sectorsize;
314: if (fssize <= 0) {
315: if (sb.st_size != 0)
316: fssize += sb.st_size / sectorsize;
317: else
318: fssize += dkw.dkw_size;
319: if (fssize <= 0)
320: errx(EXIT_FAILURE,
321: "Unable to determine file system size");
322: }
323:
324: if (dkw.dkw_parent[0] && fssize > dkw.dkw_size)
325: errx(EXIT_FAILURE,
326: "size %" PRIu64 " exceeds maximum file system size on "
327: "`%s' of %" PRIu64 " sectors",
328: fssize, special, dkw.dkw_size);
329:
330: /* XXXLUKEM: only ftruncate() regular files ? (dsl: or at all?) */
331: if (Fflag && fso != -1
332: && ftruncate(fso, (off_t)fssize * sectorsize) == -1)
333: err(1, "can't ftruncate %s to %" PRId64, special, fssize);
334:
335: if (Zflag && fso != -1) { /* pre-zero (and de-sparce) the file */
336: char *buf;
337: int bufsize, i;
338: off_t bufrem;
339: struct statvfs sfs;
340:
341: if (fstatvfs(fso, &sfs) == -1) {
342: warn("can't fstatvfs `%s'", special);
343: bufsize = 8192;
344: } else
345: bufsize = sfs.f_iosize;
346:
347: if ((buf = calloc(1, bufsize)) == NULL)
348: err(1, "can't malloc buffer of %d",
349: bufsize);
350: bufrem = fssize * sectorsize;
351: if (verbosity > 0)
352: printf("Creating file system image in `%s', "
353: "size %" PRId64 " bytes, in %d byte chunks.\n",
354: special, bufrem, bufsize);
355: while (bufrem > 0) {
356: i = write(fso, buf, MIN(bufsize, bufrem));
357: if (i == -1)
358: err(1, "writing image");
359: bufrem -= i;
360: }
361: free(buf);
362: }
363:
364: /* Sort out fragment and block sizes */
365: if (bsize == 0) {
366: bsize = fsize;
367: if (bsize == 0) {
368: if (fssize < SMALL_FSSIZE)
369: bsize = S_DFL_BSIZE;
370: else if (fssize < MEDIUM_FSSIZE)
371: bsize = M_DFL_BSIZE;
372: else
373: bsize = L_DFL_BSIZE;
374: }
375: }
376: if (fsize == 0)
377: fsize = bsize;
378:
379: blocks = fssize * sectorsize / bsize;
380:
381: if (num_inodes == 0) {
382: if (density != 0)
383: num_inodes = fssize / density;
384: else {
385: if (fssize < SMALL_FSSIZE)
386: num_inodes = S_DFL_NINODE(blocks);
387: else if (fssize < MEDIUM_FSSIZE)
388: num_inodes = M_DFL_NINODE(blocks);
389: else
390: num_inodes = L_DFL_NINODE(blocks);
391: }
392: }
393: mke2fs(special, fsi, fso);
394:
395: if (fsi != -1)
396: close(fsi);
397: if (fso != -1 && fso != fsi)
398: close(fso);
399: exit(EXIT_SUCCESS);
400: }
401:
402: static int64_t
403: strsuftoi64(const char *desc, const char *arg, int64_t min, int64_t max,
404: int *num_suffix)
405: {
406: int64_t result, r1;
407: int shift = 0;
408: char *ep;
409:
410: errno = 0;
411: r1 = strtoll(arg, &ep, 10);
412: if (ep[0] != '\0' && ep[1] != '\0')
413: errx(EXIT_FAILURE,
414: "%s `%s' is not a valid number.", desc, arg);
415: switch (ep[0]) {
416: case '\0':
417: case 's':
418: case 'S':
419: if (num_suffix != NULL)
420: *num_suffix = 0;
421: break;
422: case 'g':
423: case 'G':
424: shift += 10;
425: /* FALLTHROUGH */
426: case 'm':
427: case 'M':
428: shift += 10;
429: /* FALLTHROUGH */
430: case 'k':
431: case 'K':
432: shift += 10;
433: /* FALLTHROUGH */
434: case 'b':
435: case 'B':
436: if (num_suffix != NULL)
437: *num_suffix = 1;
438: break;
439: default:
440: errx(EXIT_FAILURE,
441: "`%s' is not a valid suffix for %s.", ep, desc);
442: }
443: result = r1 << shift;
444: if (errno == ERANGE || result >> shift != r1)
445: errx(EXIT_FAILURE,
446: "%s `%s' is too large to convert.", desc, arg);
447: if (result < min)
448: errx(EXIT_FAILURE,
449: "%s `%s' (%" PRId64 ") is less than the minimum (%"
450: PRId64 ").", desc, arg, result, min);
451: if (result > max)
452: errx(EXIT_FAILURE,
453: "%s `%s' (%" PRId64 ") is greater than the maximum (%"
454: PRId64 ").", desc, arg, result, max);
455: return result;
456: }
457:
458: static const char help_strings[] =
1.5 ! christos 459: "\t-D inodesize\tsize of an inode in bytes (128 or 256)\n"
1.1 tsutsui 460: "\t-F \t\tcreate file system image in regular file\n"
461: "\t-I \t\tdo not check that the file system type is `Linux Ext2'\n"
462: "\t-N \t\tdo not create file system, just print out parameters\n"
463: "\t-O N\t\tfilesystem revision: 0 ==> REV0, 1 ==> REV1 (default 0)\n"
464: "\t-S secsize\tsector size\n"
465: "\t-V verbose\toutput verbosity: 0 ==> none, 4 ==> max\n"
466: "\t-Z \t\tpre-zero the image file\n"
467: "\t-b bsize\tblock size\n"
468: "\t-f fsize\tfragment size\n"
469: "\t-i density\tnumber of bytes per inode\n"
470: "\t-m minfree\tminimum free space %\n"
471: "\t-n inodes\tnumber of inodes (overrides -i density)\n"
472: "\t-s fssize\tfile system size (sectors)\n"
473: "\t-v volname\text2fs volume name\n";
474:
475: static void
476: usage(void)
477: {
478:
479: fprintf(stderr,
480: "usage: %s [ fsoptions ] special-device\n", getprogname());
481: fprintf(stderr, "where fsoptions are:\n");
482: fprintf(stderr, "%s", help_strings);
483:
484: exit(EXIT_FAILURE);
485: }
CVSweb <webmaster@jp.NetBSD.org>