]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * mkfs.bfs - Create SCO BFS filesystem - aeb, 1999-09-07 | |
3 | * | |
4 | * Usage: mkfs.bfs [-N nr-of-inodes] [-V volume-name] [-F fsname] device | |
5 | */ | |
6 | ||
7 | #include <errno.h> | |
8 | #include <fcntl.h> | |
9 | #include <getopt.h> | |
10 | #include <limits.h> | |
11 | #include <stdio.h> | |
12 | #include <stdlib.h> | |
13 | #include <string.h> | |
14 | #include <sys/stat.h> | |
15 | #include <time.h> | |
16 | #include <unistd.h> | |
17 | ||
18 | #include "blkdev.h" | |
19 | #include "c.h" | |
20 | #include "closestream.h" | |
21 | #include "nls.h" | |
22 | #include "strutils.h" | |
23 | #include "xalloc.h" | |
24 | #include "bitops.h" | |
25 | ||
26 | #define BFS_ROOT_INO 2 | |
27 | #define BFS_NAMELEN 14 | |
28 | #define BFS_BLOCKSIZE 512 | |
29 | #define BFS_SUPER_MAGIC 0x1badface | |
30 | ||
31 | /* superblock - 512 bytes */ | |
32 | struct bfssb { | |
33 | uint32_t s_magic; | |
34 | uint32_t s_start; /* byte offset of start of data */ | |
35 | uint32_t s_end; /* sizeof(slice)-1 */ | |
36 | ||
37 | /* for recovery during compaction */ | |
38 | uint32_t s_from, s_to; /* src and dest block of current transfer */ | |
39 | int32_t s_backup_from, s_backup_to; | |
40 | ||
41 | /* labels - may well contain garbage */ | |
42 | char s_fsname[6]; | |
43 | char s_volume[6]; | |
44 | char s_pad[472]; | |
45 | }; | |
46 | ||
47 | /* inode - 64 bytes */ | |
48 | struct bfsi { | |
49 | uint16_t i_ino; | |
50 | unsigned char i_pad1[2]; | |
51 | uint32_t i_first_block; | |
52 | uint32_t i_last_block; | |
53 | uint32_t i_bytes_to_end; | |
54 | uint32_t i_type; /* 1: file, 2: the unique dir */ | |
55 | uint32_t i_mode; | |
56 | uint32_t i_uid, i_gid; | |
57 | uint32_t i_nlinks; | |
58 | uint32_t i_atime, i_mtime, i_ctime; | |
59 | unsigned char i_pad2[16]; | |
60 | }; | |
61 | ||
62 | #define BFS_DIR_TYPE 2 | |
63 | ||
64 | /* directory entry - 16 bytes */ | |
65 | struct bfsde { | |
66 | uint16_t d_ino; | |
67 | char d_name[BFS_NAMELEN]; | |
68 | }; | |
69 | ||
70 | static void __attribute__((__noreturn__)) usage(void) | |
71 | { | |
72 | FILE *out = stdout; | |
73 | fprintf(out, | |
74 | _("Usage: %s [options] device [block-count]\n"), | |
75 | program_invocation_short_name); | |
76 | ||
77 | fputs(USAGE_SEPARATOR, out); | |
78 | fputs(_("Make an SCO bfs filesystem.\n"), out); | |
79 | ||
80 | fprintf(out, _("\nOptions:\n" | |
81 | " -N, --inodes=NUM specify desired number of inodes\n" | |
82 | " -V, --vname=NAME specify volume name\n" | |
83 | " -F, --fname=NAME specify file system name\n" | |
84 | " -v, --verbose explain what is being done\n" | |
85 | " -c this option is silently ignored\n" | |
86 | " -l this option is silently ignored\n" | |
87 | )); | |
88 | printf(USAGE_HELP_OPTIONS(21)); | |
89 | ||
90 | printf(USAGE_MAN_TAIL("mkfs.bfs(8)")); | |
91 | exit(EXIT_SUCCESS); | |
92 | } | |
93 | ||
94 | int main(int argc, char **argv) | |
95 | { | |
96 | char *device, *volume, *fsname; | |
97 | long inodes; | |
98 | unsigned long long total_blocks, ino_bytes, ino_blocks, data_blocks; | |
99 | unsigned long long user_specified_total_blocks = 0; | |
100 | int verbose = 0; | |
101 | int fd; | |
102 | uint32_t first_block; | |
103 | struct bfssb sb; | |
104 | struct bfsi ri; | |
105 | struct bfsde de; | |
106 | struct stat statbuf; | |
107 | time_t now; | |
108 | int c, i, len; | |
109 | ||
110 | enum { VERSION_OPTION = CHAR_MAX + 1 }; | |
111 | static const struct option longopts[] = { | |
112 | {"inodes", required_argument, NULL, 'N'}, | |
113 | {"vname", required_argument, NULL, 'V'}, | |
114 | {"fname", required_argument, NULL, 'F'}, | |
115 | {"verbose", no_argument, NULL, 'v'}, | |
116 | {"version", no_argument, NULL, VERSION_OPTION}, | |
117 | {"help", no_argument, NULL, 'h'}, | |
118 | {NULL, 0, NULL, 0} | |
119 | }; | |
120 | ||
121 | setlocale(LC_ALL, ""); | |
122 | bindtextdomain(PACKAGE, LOCALEDIR); | |
123 | textdomain(PACKAGE); | |
124 | close_stdout_atexit(); | |
125 | ||
126 | if (argc < 2) { | |
127 | warnx(_("not enough arguments")); | |
128 | errtryhelp(EXIT_FAILURE); | |
129 | } | |
130 | if (argc == 2 && !strcmp(argv[1], "-V")) | |
131 | print_version(EXIT_SUCCESS); | |
132 | ||
133 | volume = fsname = " "; /* is there a default? */ | |
134 | inodes = 0; | |
135 | ||
136 | while ((c = getopt_long(argc, argv, "N:V:F:vhcl", longopts, NULL)) != -1) { | |
137 | switch (c) { | |
138 | case 'N': | |
139 | inodes = strtol_or_err(optarg, _("invalid number of inodes")); | |
140 | break; | |
141 | ||
142 | case 'V': | |
143 | len = strlen(optarg); | |
144 | if (len <= 0 || len > 6) | |
145 | errx(EXIT_FAILURE, _("volume name too long")); | |
146 | volume = xstrdup(optarg); | |
147 | break; | |
148 | ||
149 | case 'F': | |
150 | len = strlen(optarg); | |
151 | if (len <= 0 || len > 6) | |
152 | errx(EXIT_FAILURE, _("fsname name too long")); | |
153 | fsname = xstrdup(optarg); | |
154 | break; | |
155 | ||
156 | case 'v': | |
157 | verbose = 1; | |
158 | break; | |
159 | ||
160 | case 'c': | |
161 | case 'l': | |
162 | /* when called via mkfs we may get options c,l,v */ | |
163 | break; | |
164 | ||
165 | case VERSION_OPTION: | |
166 | print_version(EXIT_SUCCESS); | |
167 | case 'h': | |
168 | usage(); | |
169 | default: | |
170 | errtryhelp(EXIT_FAILURE); | |
171 | } | |
172 | } | |
173 | ||
174 | if (optind == argc) { | |
175 | warnx(_("no device specified")); | |
176 | errtryhelp(EXIT_FAILURE); | |
177 | } | |
178 | ||
179 | device = argv[optind++]; | |
180 | ||
181 | if (stat(device, &statbuf) < 0) | |
182 | err(EXIT_FAILURE, _("stat of %s failed"), device); | |
183 | ||
184 | fd = open_blkdev_or_file(&statbuf, device, O_RDWR); | |
185 | if (fd < 0) | |
186 | err(EXIT_FAILURE, _("cannot open %s"), device); | |
187 | ||
188 | if (optind == argc - 1) | |
189 | user_specified_total_blocks = | |
190 | strtou64_or_err(argv[optind], _("invalid block-count")); | |
191 | else if (optind != argc) { | |
192 | warnx(_("bad usage")); | |
193 | errtryhelp(EXIT_FAILURE); | |
194 | } | |
195 | ||
196 | if (blkdev_get_sectors(fd, &total_blocks) == -1) { | |
197 | if (!user_specified_total_blocks) | |
198 | err(EXIT_FAILURE, _("cannot get size of %s"), device); | |
199 | total_blocks = user_specified_total_blocks; | |
200 | } else if (user_specified_total_blocks) { | |
201 | if (user_specified_total_blocks > total_blocks) | |
202 | errx(EXIT_FAILURE, | |
203 | _("blocks argument too large, max is %llu"), | |
204 | total_blocks); | |
205 | total_blocks = user_specified_total_blocks; | |
206 | } | |
207 | ||
208 | if (!inodes) { | |
209 | /* pick some reasonable default */ | |
210 | inodes = 8 * (total_blocks / 800); | |
211 | if (inodes < 48) | |
212 | inodes = 48; | |
213 | if (512 < inodes) | |
214 | inodes = 512; | |
215 | } else { | |
216 | /* believe the user */ | |
217 | if (512 < inodes) | |
218 | errx(EXIT_FAILURE, _("too many inodes - max is 512")); | |
219 | } | |
220 | ||
221 | ino_bytes = inodes * sizeof(struct bfsi); | |
222 | ino_blocks = (ino_bytes + BFS_BLOCKSIZE - 1) / BFS_BLOCKSIZE; | |
223 | data_blocks = total_blocks - ino_blocks - 1; | |
224 | ||
225 | /* mimic the behavior of SCO's mkfs - maybe this limit is needed */ | |
226 | if (data_blocks < 32) | |
227 | errx(EXIT_FAILURE, | |
228 | _("not enough space, need at least %llu blocks"), | |
229 | ino_blocks + 33); | |
230 | ||
231 | memset(&sb, 0, sizeof(sb)); | |
232 | sb.s_magic = cpu_to_le32(BFS_SUPER_MAGIC); | |
233 | sb.s_start = cpu_to_le32(ino_bytes + sizeof(struct bfssb)); | |
234 | sb.s_end = cpu_to_le32(total_blocks * BFS_BLOCKSIZE - 1); | |
235 | sb.s_from = sb.s_to = sb.s_backup_from = sb.s_backup_to = -1; | |
236 | memcpy(sb.s_fsname, fsname, 6); | |
237 | memcpy(sb.s_volume, volume, 6); | |
238 | ||
239 | if (verbose) { | |
240 | fprintf(stderr, _("Device: %s\n"), device); | |
241 | fprintf(stderr, _("Volume: <%-6s>\n"), volume); | |
242 | fprintf(stderr, _("FSname: <%-6s>\n"), fsname); | |
243 | fprintf(stderr, _("BlockSize: %d\n"), BFS_BLOCKSIZE); | |
244 | if (ino_blocks == 1) | |
245 | fprintf(stderr, _("Inodes: %ld (in 1 block)\n"), | |
246 | inodes); | |
247 | else | |
248 | fprintf(stderr, _("Inodes: %ld (in %llu blocks)\n"), | |
249 | inodes, ino_blocks); | |
250 | fprintf(stderr, _("Blocks: %llu\n"), total_blocks); | |
251 | fprintf(stderr, _("Inode end: %d, Data end: %d\n"), | |
252 | le32_to_cpu(sb.s_start) - 1, le32_to_cpu(sb.s_end)); | |
253 | } | |
254 | ||
255 | if (write(fd, &sb, sizeof(sb)) != sizeof(sb)) | |
256 | err(EXIT_FAILURE, _("error writing superblock")); | |
257 | ||
258 | memset(&ri, 0, sizeof(ri)); | |
259 | ri.i_ino = cpu_to_le16(BFS_ROOT_INO); | |
260 | first_block = 1 + ino_blocks; | |
261 | ri.i_first_block = cpu_to_le32(first_block); | |
262 | ri.i_last_block = cpu_to_le32(first_block + | |
263 | (inodes * sizeof(de) - 1) / BFS_BLOCKSIZE); | |
264 | ri.i_bytes_to_end = cpu_to_le32(first_block * BFS_BLOCKSIZE | |
265 | + 2 * sizeof(struct bfsde) - 1); | |
266 | ri.i_type = cpu_to_le32(BFS_DIR_TYPE); | |
267 | ri.i_mode = cpu_to_le32(S_IFDIR | 0755); /* or just 0755 */ | |
268 | ri.i_uid = cpu_to_le32(0); | |
269 | ri.i_gid = cpu_to_le32(1); /* random */ | |
270 | ri.i_nlinks = 2; | |
271 | time(&now); | |
272 | ri.i_atime = cpu_to_le32(now); | |
273 | ri.i_mtime = cpu_to_le32(now); | |
274 | ri.i_ctime = cpu_to_le32(now); | |
275 | ||
276 | if (write(fd, &ri, sizeof(ri)) != sizeof(ri)) | |
277 | err(EXIT_FAILURE, _("error writing root inode")); | |
278 | ||
279 | memset(&ri, 0, sizeof(ri)); | |
280 | for (i = 1; i < inodes; i++) | |
281 | if (write(fd, &ri, sizeof(ri)) != sizeof(ri)) | |
282 | err(EXIT_FAILURE, _("error writing inode")); | |
283 | ||
284 | if (lseek(fd, (1 + ino_blocks) * BFS_BLOCKSIZE, SEEK_SET) == -1) | |
285 | err(EXIT_FAILURE, _("seek error")); | |
286 | ||
287 | memset(&de, 0, sizeof(de)); | |
288 | de.d_ino = cpu_to_le16(BFS_ROOT_INO); | |
289 | memcpy(de.d_name, ".", 1); | |
290 | if (write(fd, &de, sizeof(de)) != sizeof(de)) | |
291 | err(EXIT_FAILURE, _("error writing . entry")); | |
292 | ||
293 | memcpy(de.d_name, "..", 2); | |
294 | if (write(fd, &de, sizeof(de)) != sizeof(de)) | |
295 | err(EXIT_FAILURE, _("error writing .. entry")); | |
296 | ||
297 | if (close_fd(fd) != 0) | |
298 | err(EXIT_FAILURE, _("error closing %s"), device); | |
299 | ||
300 | return EXIT_SUCCESS; | |
301 | } |