]> git.ipfire.org Git - thirdparty/xfsprogs-dev.git/blob - mkfs/xfs_mkfs.c
projects / thirdparty / xfsprogs-dev.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
mkfs: move 'mounted' check before 'existing fs' check
[thirdparty/xfsprogs-dev.git] / mkfs / xfs_mkfs.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
6 #include "libfrog.h"
7 #include "libxfs.h"
8 #include <ctype.h>
9 #include "xfs_multidisk.h"
10 #include "libxcmd.h"
11 #include "fsgeom.h"
12
13
14 #define TERABYTES(count, blog) ((uint64_t)(count) << (40 - (blog)))
15 #define GIGABYTES(count, blog) ((uint64_t)(count) << (30 - (blog)))
16 #define MEGABYTES(count, blog) ((uint64_t)(count) << (20 - (blog)))
17
18 /*
19 * Use this macro before we have superblock and mount structure to
20 * convert from basic blocks to filesystem blocks.
21 */
22 #define DTOBT(d, bl) ((xfs_rfsblock_t)((d) >> ((bl) - BBSHIFT)))
23
24 /*
25 * amount (in bytes) we zero at the beginning and end of the device to
26 * remove traces of other filesystems, raid superblocks, etc.
27 */
28 #define WHACK_SIZE (128 * 1024)
29
30 /*
31 * XXX: The configured block and sector sizes are defined as global variables so
32 * that they don't need to be passed to getnum/cvtnum().
33 */
34 unsigned int blocksize;
35 unsigned int sectorsize;
36
37 /*
38 * Enums for each CLI parameter type are declared first so we can calculate the
39 * maximum array size needed to hold them automatically.
40 */
41 enum {
42 B_SIZE = 0,
43 B_MAX_OPTS,
44 };
45
46 enum {
47 D_AGCOUNT = 0,
48 D_FILE,
49 D_NAME,
50 D_SIZE,
51 D_SUNIT,
52 D_SWIDTH,
53 D_AGSIZE,
54 D_SU,
55 D_SW,
56 D_SECTSIZE,
57 D_NOALIGN,
58 D_RTINHERIT,
59 D_PROJINHERIT,
60 D_EXTSZINHERIT,
61 D_COWEXTSIZE,
62 D_MAX_OPTS,
63 };
64
65 enum {
66 I_ALIGN = 0,
67 I_MAXPCT,
68 I_PERBLOCK,
69 I_SIZE,
70 I_ATTR,
71 I_PROJID32BIT,
72 I_SPINODES,
73 I_MAX_OPTS,
74 };
75
76 enum {
77 L_AGNUM = 0,
78 L_INTERNAL,
79 L_SIZE,
80 L_VERSION,
81 L_SUNIT,
82 L_SU,
83 L_DEV,
84 L_SECTSIZE,
85 L_FILE,
86 L_NAME,
87 L_LAZYSBCNTR,
88 L_MAX_OPTS,
89 };
90
91 enum {
92 N_SIZE = 0,
93 N_VERSION,
94 N_FTYPE,
95 N_MAX_OPTS,
96 };
97
98 enum {
99 R_EXTSIZE = 0,
100 R_SIZE,
101 R_DEV,
102 R_FILE,
103 R_NAME,
104 R_NOALIGN,
105 R_MAX_OPTS,
106 };
107
108 enum {
109 S_SIZE = 0,
110 S_SECTSIZE,
111 S_MAX_OPTS,
112 };
113
114 enum {
115 M_CRC = 0,
116 M_FINOBT,
117 M_UUID,
118 M_RMAPBT,
119 M_REFLINK,
120 M_MAX_OPTS,
121 };
122
123 /* Just define the max options array size manually right now */
124 #define MAX_SUBOPTS D_MAX_OPTS
125
126 #define SUBOPT_NEEDS_VAL (-1LL)
127 #define MAX_CONFLICTS 8
128 #define LAST_CONFLICT (-1)
129
130 /*
131 * Table for parsing mkfs parameters.
132 *
133 * Description of the structure members follows:
134 *
135 * name MANDATORY
136 * Name is a single char, e.g., for '-d file', name is 'd'.
137 *
138 * subopts MANDATORY
139 * Subopts is a list of strings naming suboptions. In the example above,
140 * it would contain "file". The last entry of this list has to be NULL.
141 *
142 * subopt_params MANDATORY
143 * This is a list of structs tied with subopts. For each entry in subopts,
144 * a corresponding entry has to be defined:
145 *
146 * subopt_params struct:
147 * index MANDATORY
148 * This number, starting from zero, denotes which item in subopt_params
149 * it is. The index has to be the same as is the order in subopts list,
150 * so we can access the right item both in subopt_param and subopts.
151 *
152 * seen INTERNAL
153 * Do not set this flag when definning a subopt. It is used to remeber that
154 * this subopt was already seen, for example for conflicts detection.
155 *
156 * str_seen INTERNAL
157 * Do not set. It is used internally for respecification, when some options
158 * has to be parsed twice - at first as a string, then later as a number.
159 *
160 * convert OPTIONAL
161 * A flag signalling whether the user-given value can use suffixes.
162 * If you want to allow the use of user-friendly values like 13k, 42G,
163 * set it to true.
164 *
165 * is_power_2 OPTIONAL
166 * An optional flag for subopts where the given value has to be a power
167 * of two.
168 *
169 * conflicts MANDATORY
170 * If your subopt is in a conflict with some other option, specify it.
171 * Accepts the .index values of the conflicting subopts and the last
172 * member of this list has to be LAST_CONFLICT.
173 *
174 * minval, maxval OPTIONAL
175 * These options are used for automatic range check and they have to be
176 * always used together in pair. If you don't want to limit the max value,
177 * use something like UINT_MAX. If no value is given, then you must either
178 * supply your own validation, or refuse any value in the 'case
179 * X_SOMETHING' block. If you forget to define the min and max value, but
180 * call a standard function for validating user's value, it will cause an
181 * error message notifying you about this issue.
182 *
183 * (Said in another way, you can't have minval and maxval both equal
184 * to zero. But if one value is different: minval=0 and maxval=1,
185 * then it is OK.)
186 *
187 * defaultval MANDATORY
188 * The value used if user specifies the subopt, but no value.
189 * If the subopt accepts some values (-d file=[1|0]), then this
190 * sets what is used with simple specifying the subopt (-d file).
191 * A special SUBOPT_NEEDS_VAL can be used to require a user-given
192 * value in any case.
193 */
194 struct opt_params {
195 const char name;
196 const char *subopts[MAX_SUBOPTS];
197
198 struct subopt_param {
199 int index;
200 bool seen;
201 bool str_seen;
202 bool convert;
203 bool is_power_2;
204 struct _conflict {
205 struct opt_params *opts;
206 int subopt;
207 } conflicts[MAX_CONFLICTS];
208 long long minval;
209 long long maxval;
210 long long defaultval;
211 } subopt_params[MAX_SUBOPTS];
212 };
213
214 /*
215 * The two dimensional conflict array requires some initialisations to know
216 * about tables that haven't yet been defined. Work around this ordering
217 * issue with extern definitions here.
218 */
219 extern struct opt_params sopts;
220
221 struct opt_params bopts = {
222 .name = 'b',
223 .subopts = {
224 [B_SIZE] = "size",
225 },
226 .subopt_params = {
227 { .index = B_SIZE,
228 .convert = true,
229 .is_power_2 = true,
230 .conflicts = { { NULL, LAST_CONFLICT } },
231 .minval = XFS_MIN_BLOCKSIZE,
232 .maxval = XFS_MAX_BLOCKSIZE,
233 .defaultval = SUBOPT_NEEDS_VAL,
234 },
235 },
236 };
237
238 struct opt_params dopts = {
239 .name = 'd',
240 .subopts = {
241 [D_AGCOUNT] = "agcount",
242 [D_FILE] = "file",
243 [D_NAME] = "name",
244 [D_SIZE] = "size",
245 [D_SUNIT] = "sunit",
246 [D_SWIDTH] = "swidth",
247 [D_AGSIZE] = "agsize",
248 [D_SU] = "su",
249 [D_SW] = "sw",
250 [D_SECTSIZE] = "sectsize",
251 [D_NOALIGN] = "noalign",
252 [D_RTINHERIT] = "rtinherit",
253 [D_PROJINHERIT] = "projinherit",
254 [D_EXTSZINHERIT] = "extszinherit",
255 [D_COWEXTSIZE] = "cowextsize",
256 },
257 .subopt_params = {
258 { .index = D_AGCOUNT,
259 .conflicts = { { &dopts, D_AGSIZE },
260 { NULL, LAST_CONFLICT } },
261 .minval = 1,
262 .maxval = XFS_MAX_AGNUMBER,
263 .defaultval = SUBOPT_NEEDS_VAL,
264 },
265 { .index = D_FILE,
266 .conflicts = { { NULL, LAST_CONFLICT } },
267 .minval = 0,
268 .maxval = 1,
269 .defaultval = 1,
270 },
271 { .index = D_NAME,
272 .conflicts = { { NULL, LAST_CONFLICT } },
273 .defaultval = SUBOPT_NEEDS_VAL,
274 },
275 { .index = D_SIZE,
276 .conflicts = { { NULL, LAST_CONFLICT } },
277 .convert = true,
278 .minval = XFS_AG_MIN_BYTES,
279 .maxval = LLONG_MAX,
280 .defaultval = SUBOPT_NEEDS_VAL,
281 },
282 { .index = D_SUNIT,
283 .conflicts = { { &dopts, D_NOALIGN },
284 { &dopts, D_SU },
285 { &dopts, D_SW },
286 { NULL, LAST_CONFLICT } },
287 .minval = 0,
288 .maxval = UINT_MAX,
289 .defaultval = SUBOPT_NEEDS_VAL,
290 },
291 { .index = D_SWIDTH,
292 .conflicts = { { &dopts, D_NOALIGN },
293 { &dopts, D_SU },
294 { &dopts, D_SW },
295 { NULL, LAST_CONFLICT } },
296 .minval = 0,
297 .maxval = UINT_MAX,
298 .defaultval = SUBOPT_NEEDS_VAL,
299 },
300 { .index = D_AGSIZE,
301 .conflicts = { { &dopts, D_AGCOUNT },
302 { NULL, LAST_CONFLICT } },
303 .convert = true,
304 .minval = XFS_AG_MIN_BYTES,
305 .maxval = XFS_AG_MAX_BYTES,
306 .defaultval = SUBOPT_NEEDS_VAL,
307 },
308 { .index = D_SU,
309 .conflicts = { { &dopts, D_NOALIGN },
310 { &dopts, D_SUNIT },
311 { &dopts, D_SWIDTH },
312 { NULL, LAST_CONFLICT } },
313 .convert = true,
314 .minval = 0,
315 .maxval = UINT_MAX,
316 .defaultval = SUBOPT_NEEDS_VAL,
317 },
318 { .index = D_SW,
319 .conflicts = { { &dopts, D_NOALIGN },
320 { &dopts, D_SUNIT },
321 { &dopts, D_SWIDTH },
322 { NULL, LAST_CONFLICT } },
323 .minval = 0,
324 .maxval = UINT_MAX,
325 .defaultval = SUBOPT_NEEDS_VAL,
326 },
327 { .index = D_SECTSIZE,
328 .conflicts = { { &sopts, S_SIZE },
329 { &sopts, S_SECTSIZE },
330 { NULL, LAST_CONFLICT } },
331 .convert = true,
332 .is_power_2 = true,
333 .minval = XFS_MIN_SECTORSIZE,
334 .maxval = XFS_MAX_SECTORSIZE,
335 .defaultval = SUBOPT_NEEDS_VAL,
336 },
337 { .index = D_NOALIGN,
338 .conflicts = { { &dopts, D_SU },
339 { &dopts, D_SW },
340 { &dopts, D_SUNIT },
341 { &dopts, D_SWIDTH },
342 { NULL, LAST_CONFLICT } },
343 .minval = 0,
344 .maxval = 1,
345 .defaultval = 1,
346 },
347 { .index = D_RTINHERIT,
348 .conflicts = { { NULL, LAST_CONFLICT } },
349 .minval = 1,
350 .maxval = 1,
351 .defaultval = 1,
352 },
353 { .index = D_PROJINHERIT,
354 .conflicts = { { NULL, LAST_CONFLICT } },
355 .minval = 0,
356 .maxval = UINT_MAX,
357 .defaultval = SUBOPT_NEEDS_VAL,
358 },
359 { .index = D_EXTSZINHERIT,
360 .conflicts = { { NULL, LAST_CONFLICT } },
361 .minval = 0,
362 .maxval = UINT_MAX,
363 .defaultval = SUBOPT_NEEDS_VAL,
364 },
365 { .index = D_COWEXTSIZE,
366 .conflicts = { { NULL, LAST_CONFLICT } },
367 .minval = 0,
368 .maxval = UINT_MAX,
369 .defaultval = SUBOPT_NEEDS_VAL,
370 },
371 },
372 };
373
374
375 struct opt_params iopts = {
376 .name = 'i',
377 .subopts = {
378 [I_ALIGN] = "align",
379 [I_MAXPCT] = "maxpct",
380 [I_PERBLOCK] = "perblock",
381 [I_SIZE] = "size",
382 [I_ATTR] = "attr",
383 [I_PROJID32BIT] = "projid32bit",
384 [I_SPINODES] = "sparse",
385 },
386 .subopt_params = {
387 { .index = I_ALIGN,
388 .conflicts = { { NULL, LAST_CONFLICT } },
389 .minval = 0,
390 .maxval = 1,
391 .defaultval = 1,
392 },
393 { .index = I_MAXPCT,
394 .conflicts = { { NULL, LAST_CONFLICT } },
395 .minval = 0,
396 .maxval = 100,
397 .defaultval = SUBOPT_NEEDS_VAL,
398 },
399 { .index = I_PERBLOCK,
400 .conflicts = { { &iopts, I_SIZE },
401 { NULL, LAST_CONFLICT } },
402 .is_power_2 = true,
403 .minval = XFS_MIN_INODE_PERBLOCK,
404 .maxval = XFS_MAX_BLOCKSIZE / XFS_DINODE_MIN_SIZE,
405 .defaultval = SUBOPT_NEEDS_VAL,
406 },
407 { .index = I_SIZE,
408 .conflicts = { { &iopts, I_PERBLOCK },
409 { NULL, LAST_CONFLICT } },
410 .is_power_2 = true,
411 .minval = XFS_DINODE_MIN_SIZE,
412 .maxval = XFS_DINODE_MAX_SIZE,
413 .defaultval = SUBOPT_NEEDS_VAL,
414 },
415 { .index = I_ATTR,
416 .conflicts = { { NULL, LAST_CONFLICT } },
417 .minval = 0,
418 .maxval = 2,
419 .defaultval = SUBOPT_NEEDS_VAL,
420 },
421 { .index = I_PROJID32BIT,
422 .conflicts = { { NULL, LAST_CONFLICT } },
423 .minval = 0,
424 .maxval = 1,
425 .defaultval = 1,
426 },
427 { .index = I_SPINODES,
428 .conflicts = { { NULL, LAST_CONFLICT } },
429 .minval = 0,
430 .maxval = 1,
431 .defaultval = 1,
432 },
433 },
434 };
435
436 struct opt_params lopts = {
437 .name = 'l',
438 .subopts = {
439 [L_AGNUM] = "agnum",
440 [L_INTERNAL] = "internal",
441 [L_SIZE] = "size",
442 [L_VERSION] = "version",
443 [L_SUNIT] = "sunit",
444 [L_SU] = "su",
445 [L_DEV] = "logdev",
446 [L_SECTSIZE] = "sectsize",
447 [L_FILE] = "file",
448 [L_NAME] = "name",
449 [L_LAZYSBCNTR] = "lazy-count",
450 },
451 .subopt_params = {
452 { .index = L_AGNUM,
453 .conflicts = { { &lopts, L_DEV },
454 { NULL, LAST_CONFLICT } },
455 .minval = 0,
456 .maxval = UINT_MAX,
457 .defaultval = SUBOPT_NEEDS_VAL,
458 },
459 { .index = L_INTERNAL,
460 .conflicts = { { &lopts, L_FILE },
461 { &lopts, L_DEV },
462 { &lopts, L_SECTSIZE },
463 { NULL, LAST_CONFLICT } },
464 .minval = 0,
465 .maxval = 1,
466 .defaultval = 1,
467 },
468 { .index = L_SIZE,
469 .conflicts = { { NULL, LAST_CONFLICT } },
470 .convert = true,
471 .minval = 2 * 1024 * 1024LL, /* XXX: XFS_MIN_LOG_BYTES */
472 .maxval = XFS_MAX_LOG_BYTES,
473 .defaultval = SUBOPT_NEEDS_VAL,
474 },
475 { .index = L_VERSION,
476 .conflicts = { { NULL, LAST_CONFLICT } },
477 .minval = 1,
478 .maxval = 2,
479 .defaultval = SUBOPT_NEEDS_VAL,
480 },
481 { .index = L_SUNIT,
482 .conflicts = { { &lopts, L_SU },
483 { NULL, LAST_CONFLICT } },
484 .minval = 1,
485 .maxval = BTOBB(XLOG_MAX_RECORD_BSIZE),
486 .defaultval = SUBOPT_NEEDS_VAL,
487 },
488 { .index = L_SU,
489 .conflicts = { { &lopts, L_SUNIT },
490 { NULL, LAST_CONFLICT } },
491 .convert = true,
492 .minval = BBTOB(1),
493 .maxval = XLOG_MAX_RECORD_BSIZE,
494 .defaultval = SUBOPT_NEEDS_VAL,
495 },
496 { .index = L_DEV,
497 .conflicts = { { &lopts, L_AGNUM },
498 { &lopts, L_NAME },
499 { &lopts, L_INTERNAL },
500 { NULL, LAST_CONFLICT } },
501 .defaultval = SUBOPT_NEEDS_VAL,
502 },
503 { .index = L_SECTSIZE,
504 .conflicts = { { &lopts, L_INTERNAL },
505 { NULL, LAST_CONFLICT } },
506 .convert = true,
507 .is_power_2 = true,
508 .minval = XFS_MIN_SECTORSIZE,
509 .maxval = XFS_MAX_SECTORSIZE,
510 .defaultval = SUBOPT_NEEDS_VAL,
511 },
512 { .index = L_FILE,
513 .conflicts = { { &lopts, L_INTERNAL },
514 { NULL, LAST_CONFLICT } },
515 .minval = 0,
516 .maxval = 1,
517 .defaultval = 1,
518 },
519 { .index = L_NAME,
520 .conflicts = { { &lopts, L_AGNUM },
521 { &lopts, L_DEV },
522 { &lopts, L_INTERNAL },
523 { NULL, LAST_CONFLICT } },
524 .defaultval = SUBOPT_NEEDS_VAL,
525 },
526 { .index = L_LAZYSBCNTR,
527 .conflicts = { { NULL, LAST_CONFLICT } },
528 .minval = 0,
529 .maxval = 1,
530 .defaultval = 1,
531 },
532 },
533 };
534
535 struct opt_params nopts = {
536 .name = 'n',
537 .subopts = {
538 [N_SIZE] = "size",
539 [N_VERSION] = "version",
540 [N_FTYPE] = "ftype",
541 },
542 .subopt_params = {
543 { .index = N_SIZE,
544 .conflicts = { { NULL, LAST_CONFLICT } },
545 .convert = true,
546 .is_power_2 = true,
547 .minval = 1 << XFS_MIN_REC_DIRSIZE,
548 .maxval = XFS_MAX_BLOCKSIZE,
549 .defaultval = SUBOPT_NEEDS_VAL,
550 },
551 { .index = N_VERSION,
552 .conflicts = { { NULL, LAST_CONFLICT } },
553 .minval = 2,
554 .maxval = 2,
555 .defaultval = SUBOPT_NEEDS_VAL,
556 },
557 { .index = N_FTYPE,
558 .conflicts = { { NULL, LAST_CONFLICT } },
559 .minval = 0,
560 .maxval = 1,
561 .defaultval = 1,
562 },
563 },
564 };
565
566 struct opt_params ropts = {
567 .name = 'r',
568 .subopts = {
569 [R_EXTSIZE] = "extsize",
570 [R_SIZE] = "size",
571 [R_DEV] = "rtdev",
572 [R_FILE] = "file",
573 [R_NAME] = "name",
574 [R_NOALIGN] = "noalign",
575 },
576 .subopt_params = {
577 { .index = R_EXTSIZE,
578 .conflicts = { { NULL, LAST_CONFLICT } },
579 .convert = true,
580 .minval = XFS_MIN_RTEXTSIZE,
581 .maxval = XFS_MAX_RTEXTSIZE,
582 .defaultval = SUBOPT_NEEDS_VAL,
583 },
584 { .index = R_SIZE,
585 .conflicts = { { NULL, LAST_CONFLICT } },
586 .convert = true,
587 .minval = 0,
588 .maxval = LLONG_MAX,
589 .defaultval = SUBOPT_NEEDS_VAL,
590 },
591 { .index = R_DEV,
592 .conflicts = { { &ropts, R_NAME },
593 { NULL, LAST_CONFLICT } },
594 .defaultval = SUBOPT_NEEDS_VAL,
595 },
596 { .index = R_FILE,
597 .minval = 0,
598 .maxval = 1,
599 .defaultval = 1,
600 .conflicts = { { NULL, LAST_CONFLICT } },
601 },
602 { .index = R_NAME,
603 .conflicts = { { &ropts, R_DEV },
604 { NULL, LAST_CONFLICT } },
605 .defaultval = SUBOPT_NEEDS_VAL,
606 },
607 { .index = R_NOALIGN,
608 .minval = 0,
609 .maxval = 1,
610 .defaultval = 1,
611 .conflicts = { { NULL, LAST_CONFLICT } },
612 },
613 },
614 };
615
616 struct opt_params sopts = {
617 .name = 's',
618 .subopts = {
619 [S_SIZE] = "size",
620 [S_SECTSIZE] = "sectsize",
621 },
622 .subopt_params = {
623 { .index = S_SIZE,
624 .conflicts = { { &sopts, S_SECTSIZE },
625 { &dopts, D_SECTSIZE },
626 { NULL, LAST_CONFLICT } },
627 .convert = true,
628 .is_power_2 = true,
629 .minval = XFS_MIN_SECTORSIZE,
630 .maxval = XFS_MAX_SECTORSIZE,
631 .defaultval = SUBOPT_NEEDS_VAL,
632 },
633 { .index = S_SECTSIZE,
634 .conflicts = { { &sopts, S_SIZE },
635 { &dopts, D_SECTSIZE },
636 { NULL, LAST_CONFLICT } },
637 .convert = true,
638 .is_power_2 = true,
639 .minval = XFS_MIN_SECTORSIZE,
640 .maxval = XFS_MAX_SECTORSIZE,
641 .defaultval = SUBOPT_NEEDS_VAL,
642 },
643 },
644 };
645
646 struct opt_params mopts = {
647 .name = 'm',
648 .subopts = {
649 [M_CRC] = "crc",
650 [M_FINOBT] = "finobt",
651 [M_UUID] = "uuid",
652 [M_RMAPBT] = "rmapbt",
653 [M_REFLINK] = "reflink",
654 },
655 .subopt_params = {
656 { .index = M_CRC,
657 .conflicts = { { NULL, LAST_CONFLICT } },
658 .minval = 0,
659 .maxval = 1,
660 .defaultval = 1,
661 },
662 { .index = M_FINOBT,
663 .conflicts = { { NULL, LAST_CONFLICT } },
664 .minval = 0,
665 .maxval = 1,
666 .defaultval = 1,
667 },
668 { .index = M_UUID,
669 .conflicts = { { NULL, LAST_CONFLICT } },
670 .defaultval = SUBOPT_NEEDS_VAL,
671 },
672 { .index = M_RMAPBT,
673 .conflicts = { { NULL, LAST_CONFLICT } },
674 .minval = 0,
675 .maxval = 1,
676 .defaultval = 1,
677 },
678 { .index = M_REFLINK,
679 .conflicts = { { NULL, LAST_CONFLICT } },
680 .minval = 0,
681 .maxval = 1,
682 .defaultval = 1,
683 },
684 },
685 };
686
687 /* quick way of checking if a parameter was set on the CLI */
688 static bool
689 cli_opt_set(
690 struct opt_params *opts,
691 int subopt)
692 {
693 return opts->subopt_params[subopt].seen ||
694 opts->subopt_params[subopt].str_seen;
695 }
696
697 /*
698 * Options configured on the command line.
699 *
700 * This stores all the specific config parameters the user sets on the command
701 * line. We do not use these values directly - they are inputs to the mkfs
702 * geometry validation and override any default configuration value we have.
703 *
704 * We don't keep flags to indicate what parameters are set - if we need to check
705 * if an option was set on the command line, we check the relevant entry in the
706 * option table which records whether it was specified in the .seen and
707 * .str_seen variables in the table.
708 *
709 * Some parameters are stored as strings for post-parsing after their dependent
710 * options have been resolved (e.g. block size and sector size have been parsed
711 * and validated).
712 *
713 * This allows us to check that values have been set without needing separate
714 * flags for each value, and hence avoids needing to record and check for each
715 * specific option that can set the value later on in the code. In the cases
716 * where we don't have a cli_params structure around, the above cli_opt_set()
717 * function can be used.
718 */
719 struct sb_feat_args {
720 int log_version;
721 int attr_version;
722 int dir_version;
723 bool inode_align; /* XFS_SB_VERSION_ALIGNBIT */
724 bool nci; /* XFS_SB_VERSION_BORGBIT */
725 bool lazy_sb_counters; /* XFS_SB_VERSION2_LAZYSBCOUNTBIT */
726 bool parent_pointers; /* XFS_SB_VERSION2_PARENTBIT */
727 bool projid32bit; /* XFS_SB_VERSION2_PROJID32BIT */
728 bool crcs_enabled; /* XFS_SB_VERSION2_CRCBIT */
729 bool dirftype; /* XFS_SB_VERSION2_FTYPE */
730 bool finobt; /* XFS_SB_FEAT_RO_COMPAT_FINOBT */
731 bool spinodes; /* XFS_SB_FEAT_INCOMPAT_SPINODES */
732 bool rmapbt; /* XFS_SB_FEAT_RO_COMPAT_RMAPBT */
733 bool reflink; /* XFS_SB_FEAT_RO_COMPAT_REFLINK */
734 bool nodalign;
735 bool nortalign;
736 };
737
738 struct cli_params {
739 int sectorsize;
740 int blocksize;
741
742 /* parameters that depend on sector/block size being validated. */
743 char *dsize;
744 char *agsize;
745 char *dsu;
746 char *dirblocksize;
747 char *logsize;
748 char *lsu;
749 char *rtextsize;
750 char *rtsize;
751
752 /* parameters where 0 is a valid CLI value */
753 int dsunit;
754 int dswidth;
755 int dsw;
756 int64_t logagno;
757 int loginternal;
758 int lsunit;
759
760 /* parameters where 0 is not a valid value */
761 int64_t agcount;
762 int inodesize;
763 int inopblock;
764 int imaxpct;
765 int lsectorsize;
766 uuid_t uuid;
767
768 /* feature flags that are set */
769 struct sb_feat_args sb_feat;
770
771 /* root inode characteristics */
772 struct fsxattr fsx;
773
774 /* libxfs device setup */
775 struct libxfs_xinit *xi;
776 };
777
778 /*
779 * Calculated filesystem feature and geometry information.
780 *
781 * This structure contains the information we will use to create the on-disk
782 * filesystem from. The validation and calculation code uses it to store all the
783 * temporary and final config state for the filesystem.
784 *
785 * The information in this structure will contain a mix of validated CLI input
786 * variables, default feature state and calculated values that are needed to
787 * construct the superblock and other on disk features. These are all in one
788 * place so that we don't have to pass handfuls of seemingly arbitrary variables
789 * around to different functions to do the work we need to do.
790 */
791 struct mkfs_params {
792 int blocksize;
793 int blocklog;
794 int sectorsize;
795 int sectorlog;
796 int lsectorsize;
797 int lsectorlog;
798 int dirblocksize;
799 int dirblocklog;
800 int inodesize;
801 int inodelog;
802 int inopblock;
803
804 uint64_t dblocks;
805 uint64_t logblocks;
806 uint64_t rtblocks;
807 uint64_t rtextblocks;
808 uint64_t rtextents;
809 uint64_t rtbmblocks; /* rt bitmap blocks */
810
811 int dsunit; /* in FSBs */
812 int dswidth; /* in FSBs */
813 int lsunit; /* in FSBs */
814
815 uint64_t agsize;
816 uint64_t agcount;
817
818 int imaxpct;
819
820 bool loginternal;
821 uint64_t logstart;
822 uint64_t logagno;
823
824 uuid_t uuid;
825 char *label;
826
827 struct sb_feat_args sb_feat;
828 };
829
830 /*
831 * Default filesystem features and configuration values
832 *
833 * This structure contains the default mkfs values that are to be used when
834 * a user does not specify the option on the command line. We do not use these
835 * values directly - they are inputs to the mkfs geometry validation and
836 * calculations.
837 */
838 struct mkfs_default_params {
839 char *source; /* where the defaults came from */
840
841 int sectorsize;
842 int blocksize;
843
844 /* feature flags that are set */
845 struct sb_feat_args sb_feat;
846
847 /* root inode characteristics */
848 struct fsxattr fsx;
849 };
850
851 static void __attribute__((noreturn))
852 usage( void )
853 {
854 fprintf(stderr, _("Usage: %s\n\
855 /* blocksize */ [-b size=num]\n\
856 /* metadata */ [-m crc=0|1,finobt=0|1,uuid=xxx,rmapbt=0|1,reflink=0|1]\n\
857 /* data subvol */ [-d agcount=n,agsize=n,file,name=xxx,size=num,\n\
858 (sunit=value,swidth=value|su=num,sw=num|noalign),\n\
859 sectsize=num\n\
860 /* force overwrite */ [-f]\n\
861 /* inode size */ [-i log=n|perblock=n|size=num,maxpct=n,attr=0|1|2,\n\
862 projid32bit=0|1,sparse=0|1]\n\
863 /* no discard */ [-K]\n\
864 /* log subvol */ [-l agnum=n,internal,size=num,logdev=xxx,version=n\n\
865 sunit=value|su=num,sectsize=num,lazy-count=0|1]\n\
866 /* label */ [-L label (maximum 12 characters)]\n\
867 /* naming */ [-n size=num,version=2|ci,ftype=0|1]\n\
868 /* no-op info only */ [-N]\n\
869 /* prototype file */ [-p fname]\n\
870 /* quiet */ [-q]\n\
871 /* realtime subvol */ [-r extsize=num,size=num,rtdev=xxx]\n\
872 /* sectorsize */ [-s size=num]\n\
873 /* version */ [-V]\n\
874 devicename\n\
875 <devicename> is required unless -d name=xxx is given.\n\
876 <num> is xxx (bytes), xxxs (sectors), xxxb (fs blocks), xxxk (xxx KiB),\n\
877 xxxm (xxx MiB), xxxg (xxx GiB), xxxt (xxx TiB) or xxxp (xxx PiB).\n\
878 <value> is xxx (512 byte blocks).\n"),
879 progname);
880 exit(1);
881 }
882
883 static void
884 conflict(
885 struct opt_params *opts,
886 int option,
887 struct opt_params *con_opts,
888 int conflict)
889 {
890 fprintf(stderr, _("Cannot specify both -%c %s and -%c %s\n"),
891 con_opts->name, con_opts->subopts[conflict],
892 opts->name, opts->subopts[option]);
893 usage();
894 }
895
896
897 static void
898 illegal(
899 const char *value,
900 const char *opt)
901 {
902 fprintf(stderr, _("Invalid value %s for -%s option\n"), value, opt);
903 usage();
904 }
905
906 static int
907 ispow2(
908 unsigned int i)
909 {
910 return (i & (i - 1)) == 0;
911 }
912
913 static void __attribute__((noreturn))
914 reqval(
915 char opt,
916 const char *tab[],
917 int idx)
918 {
919 fprintf(stderr, _("-%c %s option requires a value\n"), opt, tab[idx]);
920 usage();
921 }
922
923 static void
924 respec(
925 char opt,
926 const char *tab[],
927 int idx)
928 {
929 fprintf(stderr, "-%c ", opt);
930 if (tab)
931 fprintf(stderr, "%s ", tab[idx]);
932 fprintf(stderr, _("option respecified\n"));
933 usage();
934 }
935
936 static void
937 unknown(
938 char opt,
939 char *s)
940 {
941 fprintf(stderr, _("unknown option -%c %s\n"), opt, s);
942 usage();
943 }
944
945 long long
946 cvtnum(
947 unsigned int blksize,
948 unsigned int sectsize,
949 const char *s)
950 {
951 long long i;
952 char *sp;
953 int c;
954
955 i = strtoll(s, &sp, 0);
956 if (i == 0 && sp == s)
957 return -1LL;
958 if (*sp == '\0')
959 return i;
960
961 if (sp[1] != '\0')
962 return -1LL;
963
964 if (*sp == 'b') {
965 if (!blksize) {
966 fprintf(stderr,
967 _("Blocksize must be provided prior to using 'b' suffix.\n"));
968 usage();
969 } else {
970 return i * blksize;
971 }
972 }
973 if (*sp == 's') {
974 if (!sectsize) {
975 fprintf(stderr,
976 _("Sectorsize must be specified prior to using 's' suffix.\n"));
977 usage();
978 } else {
979 return i * sectsize;
980 }
981 }
982
983 c = tolower(*sp);
984 switch (c) {
985 case 'e':
986 i *= 1024LL;
987 /* fall through */
988 case 'p':
989 i *= 1024LL;
990 /* fall through */
991 case 't':
992 i *= 1024LL;
993 /* fall through */
994 case 'g':
995 i *= 1024LL;
996 /* fall through */
997 case 'm':
998 i *= 1024LL;
999 /* fall through */
1000 case 'k':
1001 return i * 1024LL;
1002 default:
1003 break;
1004 }
1005 return -1LL;
1006 }
1007
1008 static void
1009 check_device_type(
1010 const char *name,
1011 int *isfile,
1012 bool no_size,
1013 bool no_name,
1014 int *create,
1015 const char *optname)
1016 {
1017 struct stat statbuf;
1018
1019 if (*isfile && (no_size || no_name)) {
1020 fprintf(stderr,
1021 _("if -%s file then -%s name and -%s size are required\n"),
1022 optname, optname, optname);
1023 usage();
1024 }
1025
1026 if (!name) {
1027 fprintf(stderr, _("No device name specified\n"));
1028 usage();
1029 }
1030
1031 if (stat(name, &statbuf)) {
1032 if (errno == ENOENT && *isfile) {
1033 if (create)
1034 *create = 1;
1035 return;
1036 }
1037
1038 fprintf(stderr,
1039 _("Error accessing specified device %s: %s\n"),
1040 name, strerror(errno));
1041 usage();
1042 return;
1043 }
1044
1045 /*
1046 * We only want to completely truncate and recreate an existing file if
1047 * we were specifically told it was a file. Set the create flag only in
1048 * this case to trigger that behaviour.
1049 */
1050 if (S_ISREG(statbuf.st_mode)) {
1051 if (!*isfile)
1052 *isfile = 1;
1053 else if (create)
1054 *create = 1;
1055 return;
1056 }
1057
1058 if (S_ISBLK(statbuf.st_mode)) {
1059 if (*isfile) {
1060 fprintf(stderr,
1061 _("specified \"-%s file\" on a block device %s\n"),
1062 optname, name);
1063 usage();
1064 }
1065 return;
1066 }
1067
1068 fprintf(stderr,
1069 _("specified device %s not a file or block device\n"),
1070 name);
1071 usage();
1072 }
1073
1074 static void
1075 validate_overwrite(
1076 const char *name,
1077 bool force_overwrite)
1078 {
1079 if (!force_overwrite && check_overwrite(name)) {
1080 fprintf(stderr,
1081 _("%s: Use the -f option to force overwrite.\n"),
1082 progname);
1083 exit(1);
1084 }
1085
1086 }
1087
1088 static void
1089 validate_ag_geometry(
1090 int blocklog,
1091 uint64_t dblocks,
1092 uint64_t agsize,
1093 uint64_t agcount)
1094 {
1095 if (agsize < XFS_AG_MIN_BLOCKS(blocklog)) {
1096 fprintf(stderr,
1097 _("agsize (%lld blocks) too small, need at least %lld blocks\n"),
1098 (long long)agsize,
1099 (long long)XFS_AG_MIN_BLOCKS(blocklog));
1100 usage();
1101 }
1102
1103 if (agsize > XFS_AG_MAX_BLOCKS(blocklog)) {
1104 fprintf(stderr,
1105 _("agsize (%lld blocks) too big, maximum is %lld blocks\n"),
1106 (long long)agsize,
1107 (long long)XFS_AG_MAX_BLOCKS(blocklog));
1108 usage();
1109 }
1110
1111 if (agsize > dblocks) {
1112 fprintf(stderr,
1113 _("agsize (%lld blocks) too big, data area is %lld blocks\n"),
1114 (long long)agsize, (long long)dblocks);
1115 usage();
1116 }
1117
1118 if (agsize < XFS_AG_MIN_BLOCKS(blocklog)) {
1119 fprintf(stderr,
1120 _("too many allocation groups for size = %lld\n"),
1121 (long long)agsize);
1122 fprintf(stderr, _("need at most %lld allocation groups\n"),
1123 (long long)(dblocks / XFS_AG_MIN_BLOCKS(blocklog) +
1124 (dblocks % XFS_AG_MIN_BLOCKS(blocklog) != 0)));
1125 usage();
1126 }
1127
1128 if (agsize > XFS_AG_MAX_BLOCKS(blocklog)) {
1129 fprintf(stderr,
1130 _("too few allocation groups for size = %lld\n"), (long long)agsize);
1131 fprintf(stderr,
1132 _("need at least %lld allocation groups\n"),
1133 (long long)(dblocks / XFS_AG_MAX_BLOCKS(blocklog) +
1134 (dblocks % XFS_AG_MAX_BLOCKS(blocklog) != 0)));
1135 usage();
1136 }
1137
1138 /*
1139 * If the last AG is too small, reduce the filesystem size
1140 * and drop the blocks.
1141 */
1142 if ( dblocks % agsize != 0 &&
1143 (dblocks % agsize < XFS_AG_MIN_BLOCKS(blocklog))) {
1144 fprintf(stderr,
1145 _("last AG size %lld blocks too small, minimum size is %lld blocks\n"),
1146 (long long)(dblocks % agsize),
1147 (long long)XFS_AG_MIN_BLOCKS(blocklog));
1148 usage();
1149 }
1150
1151 /*
1152 * If agcount is too large, make it smaller.
1153 */
1154 if (agcount > XFS_MAX_AGNUMBER + 1) {
1155 fprintf(stderr,
1156 _("%lld allocation groups is too many, maximum is %lld\n"),
1157 (long long)agcount, (long long)XFS_MAX_AGNUMBER + 1);
1158 usage();
1159 }
1160 }
1161
1162 static void
1163 zero_old_xfs_structures(
1164 libxfs_init_t *xi,
1165 xfs_sb_t *new_sb)
1166 {
1167 void *buf;
1168 xfs_sb_t sb;
1169 uint32_t bsize;
1170 int i;
1171 xfs_off_t off;
1172
1173 /*
1174 * We open regular files with O_TRUNC|O_CREAT. Nothing to do here...
1175 */
1176 if (xi->disfile && xi->dcreat)
1177 return;
1178
1179 /*
1180 * read in existing filesystem superblock, use its geometry
1181 * settings and zero the existing secondary superblocks.
1182 */
1183 buf = memalign(libxfs_device_alignment(), new_sb->sb_sectsize);
1184 if (!buf) {
1185 fprintf(stderr,
1186 _("error reading existing superblock -- failed to memalign buffer\n"));
1187 return;
1188 }
1189 memset(buf, 0, new_sb->sb_sectsize);
1190
1191 /*
1192 * If we are creating an image file, it might be of zero length at this
1193 * point in time. Hence reading the existing superblock is going to
1194 * return zero bytes. It's not a failure we need to warn about in this
1195 * case.
1196 */
1197 off = pread(xi->dfd, buf, new_sb->sb_sectsize, 0);
1198 if (off != new_sb->sb_sectsize) {
1199 if (!xi->disfile)
1200 fprintf(stderr,
1201 _("error reading existing superblock: %s\n"),
1202 strerror(errno));
1203 goto done;
1204 }
1205 libxfs_sb_from_disk(&sb, buf);
1206
1207 /*
1208 * perform same basic superblock validation to make sure we
1209 * actually zero secondary blocks
1210 */
1211 if (sb.sb_magicnum != XFS_SB_MAGIC || sb.sb_blocksize == 0)
1212 goto done;
1213
1214 for (bsize = 1, i = 0; bsize < sb.sb_blocksize &&
1215 i < sizeof(sb.sb_blocksize) * NBBY; i++)
1216 bsize <<= 1;
1217
1218 if (i < XFS_MIN_BLOCKSIZE_LOG || i > XFS_MAX_BLOCKSIZE_LOG ||
1219 i != sb.sb_blocklog)
1220 goto done;
1221
1222 if (sb.sb_dblocks > ((uint64_t)sb.sb_agcount * sb.sb_agblocks) ||
1223 sb.sb_dblocks < ((uint64_t)(sb.sb_agcount - 1) *
1224 sb.sb_agblocks + XFS_MIN_AG_BLOCKS))
1225 goto done;
1226
1227 /*
1228 * block size and basic geometry seems alright, zero the secondaries.
1229 */
1230 memset(buf, 0, new_sb->sb_sectsize);
1231 off = 0;
1232 for (i = 1; i < sb.sb_agcount; i++) {
1233 off += sb.sb_agblocks;
1234 if (pwrite(xi->dfd, buf, new_sb->sb_sectsize,
1235 off << sb.sb_blocklog) == -1)
1236 break;
1237 }
1238 done:
1239 free(buf);
1240 }
1241
1242 static void
1243 discard_blocks(dev_t dev, uint64_t nsectors)
1244 {
1245 int fd;
1246
1247 /*
1248 * We intentionally ignore errors from the discard ioctl. It is
1249 * not necessary for the mkfs functionality but just an optimization.
1250 */
1251 fd = libxfs_device_to_fd(dev);
1252 if (fd > 0)
1253 platform_discard_blocks(fd, 0, nsectors << 9);
1254 }
1255
1256 static __attribute__((noreturn)) void
1257 illegal_option(
1258 const char *value,
1259 struct opt_params *opts,
1260 int index,
1261 const char *reason)
1262 {
1263 fprintf(stderr,
1264 _("Invalid value %s for -%c %s option. %s\n"),
1265 value, opts->name, opts->subopts[index],
1266 reason);
1267 usage();
1268 }
1269
1270 /*
1271 * Check for conflicts and option respecification.
1272 */
1273 static void
1274 check_opt(
1275 struct opt_params *opts,
1276 int index,
1277 bool str_seen)
1278 {
1279 struct subopt_param *sp = &opts->subopt_params[index];
1280 int i;
1281
1282 if (sp->index != index) {
1283 fprintf(stderr,
1284 _("Developer screwed up option parsing (%d/%d)! Please report!\n"),
1285 sp->index, index);
1286 reqval(opts->name, opts->subopts, index);
1287 }
1288
1289 /*
1290 * Check for respecification of the option. This is more complex than it
1291 * seems because some options are parsed twice - once as a string during
1292 * input parsing, then later the string is passed to getnum for
1293 * conversion into a number and bounds checking. Hence the two variables
1294 * used to track the different uses based on the @str parameter passed
1295 * to us.
1296 */
1297 if (!str_seen) {
1298 if (sp->seen)
1299 respec(opts->name, opts->subopts, index);
1300 sp->seen = true;
1301 } else {
1302 if (sp->str_seen)
1303 respec(opts->name, opts->subopts, index);
1304 sp->str_seen = true;
1305 }
1306
1307 /* check for conflicts with the option */
1308 for (i = 0; i < MAX_CONFLICTS; i++) {
1309 struct _conflict *con = &sp->conflicts[i];
1310
1311 if (con->subopt == LAST_CONFLICT)
1312 break;
1313 if (con->opts->subopt_params[con->subopt].seen ||
1314 con->opts->subopt_params[con->subopt].str_seen)
1315 conflict(opts, index, con->opts, con->subopt);
1316 }
1317 }
1318
1319 static long long
1320 getnum(
1321 const char *str,
1322 struct opt_params *opts,
1323 int index)
1324 {
1325 struct subopt_param *sp = &opts->subopt_params[index];
1326 long long c;
1327
1328 check_opt(opts, index, false);
1329 /* empty strings might just return a default value */
1330 if (!str || *str == '\0') {
1331 if (sp->defaultval == SUBOPT_NEEDS_VAL)
1332 reqval(opts->name, opts->subopts, index);
1333 return sp->defaultval;
1334 }
1335
1336 if (sp->minval == 0 && sp->maxval == 0) {
1337 fprintf(stderr,
1338 _("Option -%c %s has undefined minval/maxval."
1339 "Can't verify value range. This is a bug.\n"),
1340 opts->name, opts->subopts[index]);
1341 exit(1);
1342 }
1343
1344 /*
1345 * Some values are pure numbers, others can have suffixes that define
1346 * the units of the number. Those get passed to cvtnum(), otherwise we
1347 * convert it ourselves to guarantee there is no trailing garbage in the
1348 * number.
1349 */
1350 if (sp->convert)
1351 c = cvtnum(blocksize, sectorsize, str);
1352 else {
1353 char *str_end;
1354
1355 c = strtoll(str, &str_end, 0);
1356 if (c == 0 && str_end == str)
1357 illegal_option(str, opts, index,
1358 _("Value not recognized as number."));
1359 if (*str_end != '\0')
1360 illegal_option(str, opts, index,
1361 _("Unit suffixes are not allowed."));
1362 }
1363
1364 /* Validity check the result. */
1365 if (c < sp->minval)
1366 illegal_option(str, opts, index, _("Value is too small."));
1367 else if (c > sp->maxval)
1368 illegal_option(str, opts, index, _("Value is too large."));
1369 if (sp->is_power_2 && !ispow2(c))
1370 illegal_option(str, opts, index, _("Value must be a power of 2."));
1371 return c;
1372 }
1373
1374 /*
1375 * Option is a string - do all the option table work, and check there
1376 * is actually an option string. Otherwise we don't do anything with the string
1377 * here - validation will be done later when the string is converted to a value
1378 * or used as a file/device path.
1379 */
1380 static char *
1381 getstr(
1382 char *str,
1383 struct opt_params *opts,
1384 int index)
1385 {
1386 check_opt(opts, index, true);
1387
1388 /* empty strings for string options are not valid */
1389 if (!str || *str == '\0')
1390 reqval(opts->name, opts->subopts, index);
1391 return str;
1392 }
1393
1394 static int
1395 block_opts_parser(
1396 struct opt_params *opts,
1397 int subopt,
1398 char *value,
1399 struct cli_params *cli)
1400 {
1401 switch (subopt) {
1402 case B_SIZE:
1403 cli->blocksize = getnum(value, opts, subopt);
1404 break;
1405 default:
1406 return -EINVAL;
1407 }
1408 return 0;
1409 }
1410
1411 static int
1412 data_opts_parser(
1413 struct opt_params *opts,
1414 int subopt,
1415 char *value,
1416 struct cli_params *cli)
1417 {
1418 switch (subopt) {
1419 case D_AGCOUNT:
1420 cli->agcount = getnum(value, opts, subopt);
1421 break;
1422 case D_AGSIZE:
1423 cli->agsize = getstr(value, opts, subopt);
1424 break;
1425 case D_FILE:
1426 cli->xi->disfile = getnum(value, opts, subopt);
1427 break;
1428 case D_NAME:
1429 cli->xi->dname = getstr(value, opts, subopt);
1430 break;
1431 case D_SIZE:
1432 cli->dsize = getstr(value, opts, subopt);
1433 break;
1434 case D_SUNIT:
1435 cli->dsunit = getnum(value, opts, subopt);
1436 break;
1437 case D_SWIDTH:
1438 cli->dswidth = getnum(value, opts, subopt);
1439 break;
1440 case D_SU:
1441 cli->dsu = getstr(value, opts, subopt);
1442 break;
1443 case D_SW:
1444 cli->dsw = getnum(value, opts, subopt);
1445 break;
1446 case D_NOALIGN:
1447 cli->sb_feat.nodalign = getnum(value, opts, subopt);
1448 break;
1449 case D_SECTSIZE:
1450 cli->sectorsize = getnum(value, opts, subopt);
1451 break;
1452 case D_RTINHERIT:
1453 if (getnum(value, opts, subopt))
1454 cli->fsx.fsx_xflags |= XFS_DIFLAG_RTINHERIT;
1455 break;
1456 case D_PROJINHERIT:
1457 cli->fsx.fsx_projid = getnum(value, opts, subopt);
1458 cli->fsx.fsx_xflags |= XFS_DIFLAG_PROJINHERIT;
1459 break;
1460 case D_EXTSZINHERIT:
1461 cli->fsx.fsx_extsize = getnum(value, opts, subopt);
1462 cli->fsx.fsx_xflags |= XFS_DIFLAG_EXTSZINHERIT;
1463 break;
1464 case D_COWEXTSIZE:
1465 cli->fsx.fsx_cowextsize = getnum(value, opts, subopt);
1466 cli->fsx.fsx_xflags |= FS_XFLAG_COWEXTSIZE;
1467 break;
1468 default:
1469 return -EINVAL;
1470 }
1471 return 0;
1472 }
1473
1474 static int
1475 inode_opts_parser(
1476 struct opt_params *opts,
1477 int subopt,
1478 char *value,
1479 struct cli_params *cli)
1480 {
1481 switch (subopt) {
1482 case I_ALIGN:
1483 cli->sb_feat.inode_align = getnum(value, opts, subopt);
1484 break;
1485 case I_MAXPCT:
1486 cli->imaxpct = getnum(value, opts, subopt);
1487 break;
1488 case I_PERBLOCK:
1489 cli->inopblock = getnum(value, opts, subopt);
1490 break;
1491 case I_SIZE:
1492 cli->inodesize = getnum(value, opts, subopt);
1493 break;
1494 case I_ATTR:
1495 cli->sb_feat.attr_version = getnum(value, opts, subopt);
1496 break;
1497 case I_PROJID32BIT:
1498 cli->sb_feat.projid32bit = getnum(value, opts, subopt);
1499 break;
1500 case I_SPINODES:
1501 cli->sb_feat.spinodes = getnum(value, opts, subopt);
1502 break;
1503 default:
1504 return -EINVAL;
1505 }
1506 return 0;
1507 }
1508
1509 static int
1510 log_opts_parser(
1511 struct opt_params *opts,
1512 int subopt,
1513 char *value,
1514 struct cli_params *cli)
1515 {
1516 switch (subopt) {
1517 case L_AGNUM:
1518 cli->logagno = getnum(value, opts, subopt);
1519 break;
1520 case L_FILE:
1521 cli->xi->lisfile = getnum(value, opts, subopt);
1522 break;
1523 case L_INTERNAL:
1524 cli->loginternal = getnum(value, opts, subopt);
1525 break;
1526 case L_SU:
1527 cli->lsu = getstr(value, opts, subopt);
1528 break;
1529 case L_SUNIT:
1530 cli->lsunit = getnum(value, opts, subopt);
1531 break;
1532 case L_NAME:
1533 case L_DEV:
1534 cli->xi->logname = getstr(value, opts, subopt);
1535 cli->loginternal = 0;
1536 break;
1537 case L_VERSION:
1538 cli->sb_feat.log_version = getnum(value, opts, subopt);
1539 break;
1540 case L_SIZE:
1541 cli->logsize = getstr(value, opts, subopt);
1542 break;
1543 case L_SECTSIZE:
1544 cli->lsectorsize = getnum(value, opts, subopt);
1545 break;
1546 case L_LAZYSBCNTR:
1547 cli->sb_feat.lazy_sb_counters = getnum(value, opts, subopt);
1548 break;
1549 default:
1550 return -EINVAL;
1551 }
1552 return 0;
1553 }
1554
1555 static int
1556 meta_opts_parser(
1557 struct opt_params *opts,
1558 int subopt,
1559 char *value,
1560 struct cli_params *cli)
1561 {
1562 switch (subopt) {
1563 case M_CRC:
1564 cli->sb_feat.crcs_enabled = getnum(value, opts, subopt);
1565 if (cli->sb_feat.crcs_enabled)
1566 cli->sb_feat.dirftype = true;
1567 break;
1568 case M_FINOBT:
1569 cli->sb_feat.finobt = getnum(value, opts, subopt);
1570 break;
1571 case M_UUID:
1572 if (!value || *value == '\0')
1573 reqval('m', opts->subopts, subopt);
1574 if (platform_uuid_parse(value, &cli->uuid))
1575 illegal(value, "m uuid");
1576 break;
1577 case M_RMAPBT:
1578 cli->sb_feat.rmapbt = getnum(value, opts, subopt);
1579 break;
1580 case M_REFLINK:
1581 cli->sb_feat.reflink = getnum(value, opts, subopt);
1582 break;
1583 default:
1584 return -EINVAL;
1585 }
1586 return 0;
1587 }
1588
1589 static int
1590 naming_opts_parser(
1591 struct opt_params *opts,
1592 int subopt,
1593 char *value,
1594 struct cli_params *cli)
1595 {
1596 switch (subopt) {
1597 case N_SIZE:
1598 cli->dirblocksize = getstr(value, opts, subopt);
1599 break;
1600 case N_VERSION:
1601 value = getstr(value, &nopts, subopt);
1602 if (!strcasecmp(value, "ci")) {
1603 /* ASCII CI mode */
1604 cli->sb_feat.nci = true;
1605 } else {
1606 cli->sb_feat.dir_version = getnum(value, opts, subopt);
1607 }
1608 break;
1609 case N_FTYPE:
1610 cli->sb_feat.dirftype = getnum(value, opts, subopt);
1611 break;
1612 default:
1613 return -EINVAL;
1614 }
1615 return 0;
1616 }
1617
1618 static int
1619 rtdev_opts_parser(
1620 struct opt_params *opts,
1621 int subopt,
1622 char *value,
1623 struct cli_params *cli)
1624 {
1625 switch (subopt) {
1626 case R_EXTSIZE:
1627 cli->rtextsize = getstr(value, opts, subopt);
1628 break;
1629 case R_FILE:
1630 cli->xi->risfile = getnum(value, opts, subopt);
1631 break;
1632 case R_NAME:
1633 case R_DEV:
1634 cli->xi->rtname = getstr(value, opts, subopt);
1635 break;
1636 case R_SIZE:
1637 cli->rtsize = getstr(value, opts, subopt);
1638 break;
1639 case R_NOALIGN:
1640 cli->sb_feat.nortalign = getnum(value, opts, subopt);
1641 break;
1642 default:
1643 return -EINVAL;
1644 }
1645 return 0;
1646 }
1647
1648 static int
1649 sector_opts_parser(
1650 struct opt_params *opts,
1651 int subopt,
1652 char *value,
1653 struct cli_params *cli)
1654 {
1655 switch (subopt) {
1656 case S_SIZE:
1657 case S_SECTSIZE:
1658 cli->sectorsize = getnum(value, opts, subopt);
1659 cli->lsectorsize = cli->sectorsize;
1660 break;
1661 default:
1662 return -EINVAL;
1663 }
1664 return 0;
1665 }
1666
1667 struct subopts {
1668 char opt;
1669 struct opt_params *opts;
1670 int (*parser)();
1671 } subopt_tab[] = {
1672 { 'b', &bopts, block_opts_parser },
1673 { 'd', &dopts, data_opts_parser },
1674 { 'i', &iopts, inode_opts_parser },
1675 { 'l', &lopts, log_opts_parser },
1676 { 'm', &mopts, meta_opts_parser },
1677 { 'n', &nopts, naming_opts_parser },
1678 { 'r', &ropts, rtdev_opts_parser },
1679 { 's', &sopts, sector_opts_parser },
1680 { '\0', NULL, NULL },
1681 };
1682
1683 static void
1684 parse_subopts(
1685 char opt,
1686 char *arg,
1687 struct cli_params *cli)
1688 {
1689 struct subopts *sop = &subopt_tab[0];
1690 char *p;
1691 int ret = 0;
1692
1693 while (sop->opts) {
1694 if (sop->opt == opt)
1695 break;
1696 sop++;
1697 }
1698
1699 /* should never happen */
1700 if (!sop->opts)
1701 return;
1702
1703 p = arg;
1704 while (*p != '\0') {
1705 char **subopts = (char **)sop->opts->subopts;
1706 char *value;
1707 int subopt;
1708
1709 subopt = getsubopt(&p, subopts, &value);
1710
1711 ret = (sop->parser)(sop->opts, subopt, value, cli);
1712 if (ret)
1713 unknown(opt, value);
1714 }
1715 }
1716
1717 static void
1718 validate_sectorsize(
1719 struct mkfs_params *cfg,
1720 struct cli_params *cli,
1721 struct mkfs_default_params *dft,
1722 struct fs_topology *ft,
1723 char *dfile,
1724 int dry_run,
1725 int force_overwrite)
1726 {
1727 /* set configured sector sizes in preparation for checks */
1728 if (!cli->sectorsize) {
1729 cfg->sectorsize = dft->sectorsize;
1730 } else {
1731 cfg->sectorsize = cli->sectorsize;
1732 }
1733 cfg->sectorlog = libxfs_highbit32(cfg->sectorsize);
1734
1735 /*
1736 * Before anything else, verify that we are correctly operating on
1737 * files or block devices and set the control parameters correctly.
1738 */
1739 check_device_type(dfile, &cli->xi->disfile, !cli->dsize, !dfile,
1740 dry_run ? NULL : &cli->xi->dcreat, "d");
1741 if (!cli->loginternal)
1742 check_device_type(cli->xi->logname, &cli->xi->lisfile,
1743 !cli->logsize, !cli->xi->logname,
1744 dry_run ? NULL : &cli->xi->lcreat, "l");
1745 if (cli->xi->rtname)
1746 check_device_type(cli->xi->rtname, &cli->xi->risfile,
1747 !cli->rtsize, !cli->xi->rtname,
1748 dry_run ? NULL : &cli->xi->rcreat, "r");
1749
1750 /*
1751 * Explicitly disable direct IO for image files so we don't error out on
1752 * sector size mismatches between the new filesystem and the underlying
1753 * host filesystem.
1754 */
1755 if (cli->xi->disfile || cli->xi->lisfile || cli->xi->risfile)
1756 cli->xi->isdirect = 0;
1757
1758 memset(ft, 0, sizeof(*ft));
1759 get_topology(cli->xi, ft, force_overwrite);
1760
1761 if (!cli->sectorsize) {
1762 /*
1763 * Unless specified manually on the command line use the
1764 * advertised sector size of the device. We use the physical
1765 * sector size unless the requested block size is smaller
1766 * than that, then we can use logical, but warn about the
1767 * inefficiency.
1768 *
1769 * Set the topology sectors if they were not probed to the
1770 * minimum supported sector size.
1771 */
1772
1773 if (!ft->lsectorsize)
1774 ft->lsectorsize = XFS_MIN_SECTORSIZE;
1775
1776 /* Older kernels may not have physical/logical distinction */
1777 if (!ft->psectorsize)
1778 ft->psectorsize = ft->lsectorsize;
1779
1780 cfg->sectorsize = ft->psectorsize;
1781 if (cfg->blocksize < cfg->sectorsize &&
1782 cfg->blocksize >= ft->lsectorsize) {
1783 fprintf(stderr,
1784 _("specified blocksize %d is less than device physical sector size %d\n"
1785 "switching to logical sector size %d\n"),
1786 cfg->blocksize, ft->psectorsize,
1787 ft->lsectorsize);
1788 cfg->sectorsize = ft->lsectorsize;
1789 }
1790
1791 cfg->sectorlog = libxfs_highbit32(cfg->sectorsize);
1792 }
1793
1794 /* validate specified/probed sector size */
1795 if (cfg->sectorsize < XFS_MIN_SECTORSIZE ||
1796 cfg->sectorsize > XFS_MAX_SECTORSIZE) {
1797 fprintf(stderr, _("illegal sector size %d\n"), cfg->sectorsize);
1798 usage();
1799 }
1800
1801 if (cfg->blocksize < cfg->sectorsize) {
1802 fprintf(stderr,
1803 _("block size %d cannot be smaller than sector size %d\n"),
1804 cfg->blocksize, cfg->sectorsize);
1805 usage();
1806 }
1807
1808 if (cfg->sectorsize < ft->lsectorsize) {
1809 fprintf(stderr, _("illegal sector size %d; hw sector is %d\n"),
1810 cfg->sectorsize, ft->lsectorsize);
1811 usage();
1812 }
1813 }
1814
1815 static void
1816 validate_blocksize(
1817 struct mkfs_params *cfg,
1818 struct cli_params *cli,
1819 struct mkfs_default_params *dft)
1820 {
1821 /*
1822 * Blocksize and sectorsize first, other things depend on them
1823 * For RAID4/5/6 we want to align sector size and block size,
1824 * so we need to start with the device geometry extraction too.
1825 */
1826 if (!cli->blocksize)
1827 cfg->blocksize = dft->blocksize;
1828 else
1829 cfg->blocksize = cli->blocksize;
1830 cfg->blocklog = libxfs_highbit32(cfg->blocksize);
1831
1832 /* validate block sizes are in range */
1833 if (cfg->blocksize < XFS_MIN_BLOCKSIZE ||
1834 cfg->blocksize > XFS_MAX_BLOCKSIZE) {
1835 fprintf(stderr, _("illegal block size %d\n"), cfg->blocksize);
1836 usage();
1837 }
1838
1839 if (cli->sb_feat.crcs_enabled &&
1840 cfg->blocksize < XFS_MIN_CRC_BLOCKSIZE) {
1841 fprintf(stderr,
1842 _("Minimum block size for CRC enabled filesystems is %d bytes.\n"),
1843 XFS_MIN_CRC_BLOCKSIZE);
1844 usage();
1845 }
1846
1847 }
1848
1849 /*
1850 * Grab log sector size and validate.
1851 *
1852 * XXX: should we probe sector size on external log device rather than using
1853 * the data device sector size?
1854 */
1855 static void
1856 validate_log_sectorsize(
1857 struct mkfs_params *cfg,
1858 struct cli_params *cli,
1859 struct mkfs_default_params *dft)
1860 {
1861
1862 if (cli->loginternal && cli->lsectorsize &&
1863 cli->lsectorsize != cfg->sectorsize) {
1864 fprintf(stderr,
1865 _("Can't change sector size on internal log!\n"));
1866 usage();
1867 }
1868
1869 if (cli->lsectorsize)
1870 cfg->lsectorsize = cli->lsectorsize;
1871 else if (cli->loginternal)
1872 cfg->lsectorsize = cfg->sectorsize;
1873 else
1874 cfg->lsectorsize = dft->sectorsize;
1875 cfg->lsectorlog = libxfs_highbit32(cfg->lsectorsize);
1876
1877 if (cfg->lsectorsize < XFS_MIN_SECTORSIZE ||
1878 cfg->lsectorsize > XFS_MAX_SECTORSIZE ||
1879 cfg->lsectorsize > cfg->blocksize) {
1880 fprintf(stderr, _("illegal log sector size %d\n"),
1881 cfg->lsectorsize);
1882 usage();
1883 }
1884 if (cfg->lsectorsize > XFS_MIN_SECTORSIZE) {
1885 if (cli->sb_feat.log_version < 2) {
1886 /* user specified non-default log version */
1887 fprintf(stderr,
1888 _("Version 1 logs do not support sector size %d\n"),
1889 cfg->lsectorsize);
1890 usage();
1891 }
1892 }
1893
1894 /* if lsu or lsunit was specified, automatically use v2 logs */
1895 if ((cli_opt_set(&lopts, L_SU) || cli_opt_set(&lopts, L_SUNIT)) &&
1896 cli->sb_feat.log_version == 1) {
1897 fprintf(stderr,
1898 _("log stripe unit specified, using v2 logs\n"));
1899 cli->sb_feat.log_version = 2;
1900 }
1901
1902 }
1903
1904 /*
1905 * Check that the incoming features make sense. The CLI structure was
1906 * initialised with the default values before parsing, so we can just
1907 * check it and copy it straight across to the cfg structure if it
1908 * checks out.
1909 */
1910 static void
1911 validate_sb_features(
1912 struct mkfs_params *cfg,
1913 struct cli_params *cli)
1914 {
1915 /*
1916 * Now we have blocks and sector sizes set up, check parameters that are
1917 * no longer optional for CRC enabled filesystems. Catch them up front
1918 * here before doing anything else.
1919 */
1920 if (cli->sb_feat.crcs_enabled) {
1921 /* minimum inode size is 512 bytes, rest checked later */
1922 if (cli->inodesize &&
1923 cli->inodesize < (1 << XFS_DINODE_DFL_CRC_LOG)) {
1924 fprintf(stderr,
1925 _("Minimum inode size for CRCs is %d bytes\n"),
1926 1 << XFS_DINODE_DFL_CRC_LOG);
1927 usage();
1928 }
1929
1930 /* inodes always aligned */
1931 if (!cli->sb_feat.inode_align) {
1932 fprintf(stderr,
1933 _("Inodes always aligned for CRC enabled filesystems\n"));
1934 usage();
1935 }
1936
1937 /* lazy sb counters always on */
1938 if (!cli->sb_feat.lazy_sb_counters) {
1939 fprintf(stderr,
1940 _("Lazy superblock counters always enabled for CRC enabled filesystems\n"));
1941 usage();
1942 }
1943
1944 /* version 2 logs always on */
1945 if (cli->sb_feat.log_version != 2) {
1946 fprintf(stderr,
1947 _("V2 logs always enabled for CRC enabled filesystems\n"));
1948 usage();
1949 }
1950
1951 /* attr2 always on */
1952 if (cli->sb_feat.attr_version != 2) {
1953 fprintf(stderr,
1954 _("V2 attribute format always enabled on CRC enabled filesystems\n"));
1955 usage();
1956 }
1957
1958 /* 32 bit project quota always on */
1959 /* attr2 always on */
1960 if (!cli->sb_feat.projid32bit) {
1961 fprintf(stderr,
1962 _("32 bit Project IDs always enabled on CRC enabled filesystems\n"));
1963 usage();
1964 }
1965
1966 /* ftype always on */
1967 if (!cli->sb_feat.dirftype) {
1968 fprintf(stderr,
1969 _("Directory ftype field always enabled on CRC enabled filesystems\n"));
1970 usage();
1971 }
1972
1973 } else {
1974 /*
1975 * The kernel doesn't currently support crc=0,finobt=1
1976 * filesystems. If crcs are not enabled and the user has not
1977 * explicitly turned finobt on, then silently turn it off to
1978 * avoid an unnecessary warning.
1979 * If the user explicitly tried to use crc=0,finobt=1,
1980 * then issue an error.
1981 * The same is also for sparse inodes.
1982 */
1983 if (cli->sb_feat.finobt && cli_opt_set(&mopts, M_FINOBT)) {
1984 fprintf(stderr,
1985 _("finobt not supported without CRC support\n"));
1986 usage();
1987 }
1988 cli->sb_feat.finobt = false;
1989
1990 if (cli->sb_feat.spinodes && cli_opt_set(&iopts, I_SPINODES)) {
1991 fprintf(stderr,
1992 _("sparse inodes not supported without CRC support\n"));
1993 usage();
1994 }
1995 cli->sb_feat.spinodes = false;
1996
1997 if (cli->sb_feat.rmapbt) {
1998 fprintf(stderr,
1999 _("rmapbt not supported without CRC support\n"));
2000 usage();
2001 }
2002 cli->sb_feat.rmapbt = false;
2003
2004 if (cli->sb_feat.reflink) {
2005 fprintf(stderr,
2006 _("reflink not supported without CRC support\n"));
2007 usage();
2008 }
2009 cli->sb_feat.reflink = false;
2010 }
2011
2012 if ((cli->fsx.fsx_xflags & FS_XFLAG_COWEXTSIZE) &&
2013 !cli->sb_feat.reflink) {
2014 fprintf(stderr,
2015 _("cowextsize not supported without reflink support\n"));
2016 usage();
2017 }
2018
2019 if (cli->sb_feat.reflink && cli->xi->rtname) {
2020 fprintf(stderr,
2021 _("reflink not supported with realtime devices\n"));
2022 usage();
2023 cli->sb_feat.reflink = false;
2024 }
2025
2026 if (cli->sb_feat.rmapbt && cli->xi->rtname) {
2027 fprintf(stderr,
2028 _("rmapbt not supported with realtime devices\n"));
2029 usage();
2030 cli->sb_feat.rmapbt = false;
2031 }
2032
2033 /*
2034 * Copy features across to config structure now.
2035 */
2036 cfg->sb_feat = cli->sb_feat;
2037 if (!platform_uuid_is_null(&cli->uuid))
2038 platform_uuid_copy(&cfg->uuid, &cli->uuid);
2039 }
2040
2041 static void
2042 validate_dirblocksize(
2043 struct mkfs_params *cfg,
2044 struct cli_params *cli)
2045 {
2046
2047 if (cli->dirblocksize)
2048 cfg->dirblocksize = getnum(cli->dirblocksize, &nopts, N_SIZE);
2049
2050 if (cfg->dirblocksize) {
2051 if (cfg->dirblocksize < cfg->blocksize ||
2052 cfg->dirblocksize > XFS_MAX_BLOCKSIZE) {
2053 fprintf(stderr, _("illegal directory block size %d\n"),
2054 cfg->dirblocksize);
2055 usage();
2056 }
2057 cfg->dirblocklog = libxfs_highbit32(cfg->dirblocksize);
2058 return;
2059 }
2060
2061 /* use default size based on current block size */
2062 if (cfg->blocksize < (1 << XFS_MIN_REC_DIRSIZE))
2063 cfg->dirblocklog = XFS_MIN_REC_DIRSIZE;
2064 else
2065 cfg->dirblocklog = cfg->blocklog;
2066 cfg->dirblocksize = 1 << cfg->dirblocklog;
2067 }
2068
2069 static void
2070 validate_inodesize(
2071 struct mkfs_params *cfg,
2072 struct cli_params *cli)
2073 {
2074
2075 if (cli->inopblock)
2076 cfg->inodelog = cfg->blocklog - libxfs_highbit32(cli->inopblock);
2077 else if (cli->inodesize)
2078 cfg->inodelog = libxfs_highbit32(cli->inodesize);
2079 else if (cfg->sb_feat.crcs_enabled)
2080 cfg->inodelog = XFS_DINODE_DFL_CRC_LOG;
2081 else
2082 cfg->inodelog = XFS_DINODE_DFL_LOG;
2083
2084 cfg->inodesize = 1 << cfg->inodelog;
2085 cfg->inopblock = cfg->blocksize / cfg->inodesize;
2086
2087 /* input parsing has already validated non-crc inode size range */
2088 if (cfg->sb_feat.crcs_enabled &&
2089 cfg->inodelog < XFS_DINODE_DFL_CRC_LOG) {
2090 fprintf(stderr,
2091 _("Minimum inode size for CRCs is %d bytes\n"),
2092 1 << XFS_DINODE_DFL_CRC_LOG);
2093 usage();
2094 }
2095
2096 if (cfg->inodesize > cfg->blocksize / XFS_MIN_INODE_PERBLOCK ||
2097 cfg->inopblock < XFS_MIN_INODE_PERBLOCK ||
2098 cfg->inodesize < XFS_DINODE_MIN_SIZE ||
2099 cfg->inodesize > XFS_DINODE_MAX_SIZE) {
2100 int maxsz;
2101
2102 fprintf(stderr, _("illegal inode size %d\n"), cfg->inodesize);
2103 maxsz = min(cfg->blocksize / XFS_MIN_INODE_PERBLOCK,
2104 XFS_DINODE_MAX_SIZE);
2105 if (XFS_DINODE_MIN_SIZE == maxsz)
2106 fprintf(stderr,
2107 _("allowable inode size with %d byte blocks is %d\n"),
2108 cfg->blocksize, XFS_DINODE_MIN_SIZE);
2109 else
2110 fprintf(stderr,
2111 _("allowable inode size with %d byte blocks is between %d and %d\n"),
2112 cfg->blocksize, XFS_DINODE_MIN_SIZE, maxsz);
2113 exit(1);
2114 }
2115 }
2116
2117 static xfs_rfsblock_t
2118 calc_dev_size(
2119 char *size,
2120 struct mkfs_params *cfg,
2121 struct opt_params *opts,
2122 int sizeopt,
2123 char *type)
2124 {
2125 uint64_t dbytes;
2126 xfs_rfsblock_t dblocks;
2127
2128 if (!size)
2129 return 0;
2130
2131 dbytes = getnum(size, opts, sizeopt);
2132 if (dbytes % XFS_MIN_BLOCKSIZE) {
2133 fprintf(stderr,
2134 _("illegal %s length %lld, not a multiple of %d\n"),
2135 type, (long long)dbytes, XFS_MIN_BLOCKSIZE);
2136 usage();
2137 }
2138 dblocks = (xfs_rfsblock_t)(dbytes >> cfg->blocklog);
2139 if (dbytes % cfg->blocksize) {
2140 fprintf(stderr,
2141 _("warning: %s length %lld not a multiple of %d, truncated to %lld\n"),
2142 type, (long long)dbytes, cfg->blocksize,
2143 (long long)(dblocks << cfg->blocklog));
2144 }
2145 return dblocks;
2146 }
2147
2148 static void
2149 validate_rtextsize(
2150 struct mkfs_params *cfg,
2151 struct cli_params *cli,
2152 struct fs_topology *ft)
2153 {
2154 uint64_t rtextbytes;
2155
2156 /*
2157 * If specified, check rt extent size against its constraints.
2158 */
2159 if (cli->rtextsize) {
2160
2161 rtextbytes = getnum(cli->rtextsize, &ropts, R_EXTSIZE);
2162 if (rtextbytes % cfg->blocksize) {
2163 fprintf(stderr,
2164 _("illegal rt extent size %lld, not a multiple of %d\n"),
2165 (long long)rtextbytes, cfg->blocksize);
2166 usage();
2167 }
2168 cfg->rtextblocks = (xfs_extlen_t)(rtextbytes >> cfg->blocklog);
2169 } else {
2170 /*
2171 * If realtime extsize has not been specified by the user,
2172 * and the underlying volume is striped, then set rtextblocks
2173 * to the stripe width.
2174 */
2175 uint64_t rswidth;
2176
2177 if (!cfg->sb_feat.nortalign && !cli->xi->risfile &&
2178 !(!cli->rtsize && cli->xi->disfile))
2179 rswidth = ft->rtswidth;
2180 else
2181 rswidth = 0;
2182
2183 /* check that rswidth is a multiple of fs blocksize */
2184 if (!cfg->sb_feat.nortalign && rswidth &&
2185 !(BBTOB(rswidth) % cfg->blocksize)) {
2186 rswidth = DTOBT(rswidth, cfg->blocklog);
2187 rtextbytes = rswidth << cfg->blocklog;
2188 if (rtextbytes > XFS_MIN_RTEXTSIZE &&
2189 rtextbytes <= XFS_MAX_RTEXTSIZE) {
2190 cfg->rtextblocks = rswidth;
2191 }
2192 }
2193 if (!cfg->rtextblocks) {
2194 cfg->rtextblocks = (cfg->blocksize < XFS_MIN_RTEXTSIZE)
2195 ? XFS_MIN_RTEXTSIZE >> cfg->blocklog
2196 : 1;
2197 }
2198 }
2199 ASSERT(cfg->rtextblocks);
2200 }
2201
2202 /*
2203 * Validate the configured stripe geometry, or is none is specified, pull
2204 * the configuration from the underlying device.
2205 *
2206 * CLI parameters come in as different units, go out as filesystem blocks.
2207 */
2208 static void
2209 calc_stripe_factors(
2210 struct mkfs_params *cfg,
2211 struct cli_params *cli,
2212 struct fs_topology *ft)
2213 {
2214 long long int big_dswidth;
2215 int dsunit = 0;
2216 int dswidth = 0;
2217 int lsunit = 0;
2218 int dsu = 0;
2219 int dsw = 0;
2220 int lsu = 0;
2221 bool use_dev = false;
2222
2223 if (cli_opt_set(&dopts, D_SUNIT))
2224 dsunit = cli->dsunit;
2225 if (cli_opt_set(&dopts, D_SWIDTH))
2226 dswidth = cli->dswidth;
2227
2228 if (cli_opt_set(&dopts, D_SU))
2229 dsu = getnum(cli->dsu, &dopts, D_SU);
2230 if (cli_opt_set(&dopts, D_SW))
2231 dsw = cli->dsw;
2232
2233 /* data sunit/swidth options */
2234 if (cli_opt_set(&dopts, D_SUNIT) != cli_opt_set(&dopts, D_SWIDTH)) {
2235 fprintf(stderr,
2236 _("both data sunit and data swidth options must be specified\n"));
2237 usage();
2238 }
2239
2240 /* convert dsu/dsw to dsunit/dswidth and use them from now on */
2241 if (dsu || dsw) {
2242 if (cli_opt_set(&dopts, D_SU) != cli_opt_set(&dopts, D_SW)) {
2243 fprintf(stderr,
2244 _("both data su and data sw options must be specified\n"));
2245 usage();
2246 }
2247
2248 if (dsu % cfg->sectorsize) {
2249 fprintf(stderr,
2250 _("data su must be a multiple of the sector size (%d)\n"), cfg->sectorsize);
2251 usage();
2252 }
2253
2254 dsunit = (int)BTOBBT(dsu);
2255 big_dswidth = (long long int)dsunit * dsw;
2256 if (big_dswidth > INT_MAX) {
2257 fprintf(stderr,
2258 _("data stripe width (%lld) is too large of a multiple of the data stripe unit (%d)\n"),
2259 big_dswidth, dsunit);
2260 usage();
2261 }
2262 dswidth = big_dswidth;
2263 }
2264
2265 if ((dsunit && !dswidth) || (!dsunit && dswidth) ||
2266 (dsunit && (dswidth % dsunit != 0))) {
2267 fprintf(stderr,
2268 _("data stripe width (%d) must be a multiple of the data stripe unit (%d)\n"),
2269 dswidth, dsunit);
2270 usage();
2271 }
2272
2273 /* If sunit & swidth were manually specified as 0, same as noalign */
2274 if ((cli_opt_set(&dopts, D_SUNIT) || cli_opt_set(&dopts, D_SU)) &&
2275 !dsunit && !dswidth)
2276 cfg->sb_feat.nodalign = true;
2277
2278 /* if we are not using alignment, don't apply device defaults */
2279 if (cfg->sb_feat.nodalign) {
2280 cfg->dsunit = 0;
2281 cfg->dswidth = 0;
2282 goto check_lsunit;
2283 }
2284
2285 /* if no stripe config set, use the device default */
2286 if (!dsunit) {
2287 /* Ignore nonsense from device. XXX add more validation */
2288 if (ft->dsunit && ft->dswidth == 0) {
2289 fprintf(stderr,
2290 _("%s: Volume reports stripe unit of %d bytes and stripe width of 0, ignoring.\n"),
2291 progname, BBTOB(ft->dsunit));
2292 ft->dsunit = 0;
2293 ft->dswidth = 0;
2294 } else {
2295 dsunit = ft->dsunit;
2296 dswidth = ft->dswidth;
2297 use_dev = true;
2298 }
2299 } else {
2300 /* check and warn if user-specified alignment is sub-optimal */
2301 if (ft->dsunit && ft->dsunit != dsunit) {
2302 fprintf(stderr,
2303 _("%s: Specified data stripe unit %d is not the same as the volume stripe unit %d\n"),
2304 progname, dsunit, ft->dsunit);
2305 }
2306 if (ft->dswidth && ft->dswidth != dswidth) {
2307 fprintf(stderr,
2308 _("%s: Specified data stripe width %d is not the same as the volume stripe width %d\n"),
2309 progname, dswidth, ft->dswidth);
2310 }
2311 }
2312
2313 /*
2314 * now we have our stripe config, check it's a multiple of block
2315 * size.
2316 */
2317 if ((BBTOB(dsunit) % cfg->blocksize) ||
2318 (BBTOB(dswidth) % cfg->blocksize)) {
2319 /*
2320 * If we are using device defaults, just clear them and we're
2321 * good to go. Otherwise bail out with an error.
2322 */
2323 if (!use_dev) {
2324 fprintf(stderr,
2325 _("%s: Stripe unit(%d) or stripe width(%d) is not a multiple of the block size(%d)\n"),
2326 progname, BBTOB(dsunit), BBTOB(dswidth),
2327 cfg->blocksize);
2328 exit(1);
2329 }
2330 dsunit = 0;
2331 dswidth = 0;
2332 cfg->sb_feat.nodalign = true;
2333 }
2334
2335 /* convert from 512 byte blocks to fs blocksize */
2336 cfg->dsunit = DTOBT(dsunit, cfg->blocklog);
2337 cfg->dswidth = DTOBT(dswidth, cfg->blocklog);
2338
2339 check_lsunit:
2340 /* log sunit options */
2341 if (cli_opt_set(&lopts, L_SUNIT))
2342 lsunit = cli->lsunit;
2343 else if (cli_opt_set(&lopts, L_SU))
2344 lsu = getnum(cli->lsu, &lopts, L_SU);
2345 else if (cfg->lsectorsize > XLOG_HEADER_SIZE)
2346 lsu = cfg->blocksize; /* lsunit matches filesystem block size */
2347
2348 if (lsu) {
2349 /* verify if lsu is a multiple block size */
2350 if (lsu % cfg->blocksize != 0) {
2351 fprintf(stderr,
2352 _("log stripe unit (%d) must be a multiple of the block size (%d)\n"),
2353 lsu, cfg->blocksize);
2354 usage();
2355 }
2356 lsunit = (int)BTOBBT(lsu);
2357 }
2358 if (BBTOB(lsunit) % cfg->blocksize != 0) {
2359 fprintf(stderr,
2360 _("log stripe unit (%d) must be a multiple of the block size (%d)\n"),
2361 BBTOB(lsunit), cfg->blocksize);
2362 usage();
2363 }
2364
2365 /*
2366 * check that log sunit is modulo fsblksize or default it to dsunit.
2367 */
2368 if (lsunit) {
2369 /* convert from 512 byte blocks to fs blocks */
2370 cfg->lsunit = DTOBT(lsunit, cfg->blocklog);
2371 } else if (cfg->sb_feat.log_version == 2 &&
2372 cfg->loginternal && cfg->dsunit) {
2373 /* lsunit and dsunit now in fs blocks */
2374 cfg->lsunit = cfg->dsunit;
2375 }
2376
2377 if (cfg->sb_feat.log_version == 2 &&
2378 cfg->lsunit * cfg->blocksize > 256 * 1024) {
2379 /* Warn only if specified on commandline */
2380 if (cli->lsu || cli->lsunit != -1) {
2381 fprintf(stderr,
2382 _("log stripe unit (%d bytes) is too large (maximum is 256KiB)\n"
2383 "log stripe unit adjusted to 32KiB\n"),
2384 (cfg->lsunit * cfg->blocksize));
2385 }
2386 /* XXX: 64k block size? */
2387 cfg->lsunit = (32 * 1024) / cfg->blocksize;
2388 }
2389
2390 }
2391
2392 static void
2393 open_devices(
2394 struct mkfs_params *cfg,
2395 struct libxfs_xinit *xi)
2396 {
2397 uint64_t sector_mask;
2398
2399 /*
2400 * Initialize. This will open the log and rt devices as well.
2401 */
2402 xi->setblksize = cfg->sectorsize;
2403 if (!libxfs_init(xi))
2404 usage();
2405 if (!xi->ddev) {
2406 fprintf(stderr, _("no device name given in argument list\n"));
2407 usage();
2408 }
2409
2410 /*
2411 * Ok, Linux only has a 1024-byte resolution on device _size_,
2412 * and the sizes below are in basic 512-byte blocks,
2413 * so if we have (size % 2), on any partition, we can't get
2414 * to the last 512 bytes. The same issue exists for larger
2415 * sector sizes - we cannot write past the last sector.
2416 *
2417 * So, we reduce the size (in basic blocks) to a perfect
2418 * multiple of the sector size, or 1024, whichever is larger.
2419 */
2420 sector_mask = (uint64_t)-1 << (max(cfg->sectorlog, 10) - BBSHIFT);
2421 xi->dsize &= sector_mask;
2422 xi->rtsize &= sector_mask;
2423 xi->logBBsize &= (uint64_t)-1 << (max(cfg->lsectorlog, 10) - BBSHIFT);
2424 }
2425
2426 static void
2427 discard_devices(
2428 struct libxfs_xinit *xi)
2429 {
2430 /*
2431 * This function has to be called after libxfs has been initialized.
2432 */
2433
2434 if (!xi->disfile)
2435 discard_blocks(xi->ddev, xi->dsize);
2436 if (xi->rtdev && !xi->risfile)
2437 discard_blocks(xi->rtdev, xi->rtsize);
2438 if (xi->logdev && xi->logdev != xi->ddev && !xi->lisfile)
2439 discard_blocks(xi->logdev, xi->logBBsize);
2440 }
2441
2442 static void
2443 validate_datadev(
2444 struct mkfs_params *cfg,
2445 struct cli_params *cli)
2446 {
2447 struct libxfs_xinit *xi = cli->xi;
2448
2449 if (!xi->dsize) {
2450 /*
2451 * if the device is a file, we can't validate the size here.
2452 * Instead, the file will be truncated to the correct length
2453 * later on. if it's not a file, we've got a dud device.
2454 */
2455 if (!xi->disfile) {
2456 fprintf(stderr, _("can't get size of data subvolume\n"));
2457 usage();
2458 }
2459 ASSERT(cfg->dblocks);
2460 } else if (cfg->dblocks) {
2461 /* check the size fits into the underlying device */
2462 if (cfg->dblocks > DTOBT(xi->dsize, cfg->blocklog)) {
2463 fprintf(stderr,
2464 _("size %s specified for data subvolume is too large, maximum is %lld blocks\n"),
2465 cli->dsize,
2466 (long long)DTOBT(xi->dsize, cfg->blocklog));
2467 usage();
2468 }
2469 } else {
2470 /* no user size, so use the full block device */
2471 cfg->dblocks = DTOBT(xi->dsize, cfg->blocklog);
2472 }
2473
2474 if (cfg->dblocks < XFS_MIN_DATA_BLOCKS) {
2475 fprintf(stderr,
2476 _("size %lld of data subvolume is too small, minimum %d blocks\n"),
2477 (long long)cfg->dblocks, XFS_MIN_DATA_BLOCKS);
2478 usage();
2479 }
2480
2481 if (xi->dbsize > cfg->sectorsize) {
2482 fprintf(stderr, _(
2483 "Warning: the data subvolume sector size %u is less than the sector size \n\
2484 reported by the device (%u).\n"),
2485 cfg->sectorsize, xi->dbsize);
2486 }
2487 }
2488
2489 /*
2490 * This is more complex than it needs to be because we still support volume
2491 * based external logs. They are only discovered *after* the devices have been
2492 * opened, hence the crazy "is this really an internal log" checks here.
2493 */
2494 static void
2495 validate_logdev(
2496 struct mkfs_params *cfg,
2497 struct cli_params *cli,
2498 char **devname)
2499 {
2500 struct libxfs_xinit *xi = cli->xi;
2501
2502 *devname = NULL;
2503
2504 /* check for volume log first */
2505 if (cli->loginternal && xi->volname && xi->logdev) {
2506 *devname = _("volume log");
2507 cfg->loginternal = false;
2508 } else
2509 cfg->loginternal = cli->loginternal;
2510
2511 /* now run device checks */
2512 if (cfg->loginternal) {
2513 if (xi->logdev) {
2514 fprintf(stderr,
2515 _("can't have both external and internal logs\n"));
2516 usage();
2517 }
2518
2519 /*
2520 * if no sector size has been specified on the command line,
2521 * use what has been configured and validated for the data
2522 * device.
2523 */
2524 if (!cli->lsectorsize) {
2525 cfg->lsectorsize = cfg->sectorsize;
2526 cfg->lsectorlog = cfg->sectorlog;
2527 }
2528
2529 if (cfg->sectorsize != cfg->lsectorsize) {
2530 fprintf(stderr,
2531 _("data and log sector sizes must be equal for internal logs\n"));
2532 usage();
2533 }
2534 if (cli->logsize && cfg->logblocks >= cfg->dblocks) {
2535 fprintf(stderr,
2536 _("log size %lld too large for internal log\n"),
2537 (long long)cfg->logblocks);
2538 usage();
2539 }
2540 *devname = _("internal log");
2541 return;
2542 }
2543
2544 /* External/log subvolume checks */
2545 if (xi->logname)
2546 *devname = xi->logname;
2547 if (!*devname || !xi->logdev) {
2548 fprintf(stderr, _("no log subvolume or external log.\n"));
2549 usage();
2550 }
2551
2552 if (!cfg->logblocks) {
2553 if (xi->logBBsize == 0) {
2554 fprintf(stderr,
2555 _("unable to get size of the log subvolume.\n"));
2556 usage();
2557 }
2558 cfg->logblocks = DTOBT(xi->logBBsize, cfg->blocklog);
2559 } else if (cfg->logblocks > DTOBT(xi->logBBsize, cfg->blocklog)) {
2560 fprintf(stderr,
2561 _("size %s specified for log subvolume is too large, maximum is %lld blocks\n"),
2562 cli->logsize,
2563 (long long)DTOBT(xi->logBBsize, cfg->blocklog));
2564 usage();
2565 }
2566
2567 if (xi->lbsize > cfg->lsectorsize) {
2568 fprintf(stderr, _(
2569 "Warning: the log subvolume sector size %u is less than the sector size\n\
2570 reported by the device (%u).\n"),
2571 cfg->lsectorsize, xi->lbsize);
2572 }
2573 }
2574
2575 static void
2576 validate_rtdev(
2577 struct mkfs_params *cfg,
2578 struct cli_params *cli,
2579 char **devname)
2580 {
2581 struct libxfs_xinit *xi = cli->xi;
2582
2583 *devname = NULL;
2584
2585 if (!xi->rtdev) {
2586 if (cli->rtsize) {
2587 fprintf(stderr,
2588 _("size specified for non-existent rt subvolume\n"));
2589 usage();
2590 }
2591
2592 *devname = _("none");
2593 cfg->rtblocks = 0;
2594 cfg->rtextents = 0;
2595 cfg->rtbmblocks = 0;
2596 return;
2597 }
2598 if (!xi->rtsize) {
2599 fprintf(stderr, _("Invalid zero length rt subvolume found\n"));
2600 usage();
2601 }
2602
2603 /* volume rtdev */
2604 if (xi->volname)
2605 *devname = _("volume rt");
2606 else
2607 *devname = xi->rtname;
2608
2609 if (cli->rtsize) {
2610 if (cfg->rtblocks > DTOBT(xi->rtsize, cfg->blocklog)) {
2611 fprintf(stderr,
2612 _("size %s specified for rt subvolume is too large, maxi->um is %lld blocks\n"),
2613 cli->rtsize,
2614 (long long)DTOBT(xi->rtsize, cfg->blocklog));
2615 usage();
2616 }
2617 if (xi->rtbsize > cfg->sectorsize) {
2618 fprintf(stderr, _(
2619 "Warning: the realtime subvolume sector size %u is less than the sector size\n\
2620 reported by the device (%u).\n"),
2621 cfg->sectorsize, xi->rtbsize);
2622 }
2623 } else {
2624 /* grab volume size */
2625 cfg->rtblocks = DTOBT(xi->rtsize, cfg->blocklog);
2626 }
2627
2628 cfg->rtextents = cfg->rtblocks / cfg->rtextblocks;
2629 cfg->rtbmblocks = (xfs_extlen_t)howmany(cfg->rtextents,
2630 NBBY * cfg->blocksize);
2631 }
2632
2633 static void
2634 calculate_initial_ag_geometry(
2635 struct mkfs_params *cfg,
2636 struct cli_params *cli)
2637 {
2638 if (cli->agsize) { /* User-specified AG size */
2639 cfg->agsize = getnum(cli->agsize, &dopts, D_AGSIZE);
2640
2641 /*
2642 * Check specified agsize is a multiple of blocksize.
2643 */
2644 if (cfg->agsize % cfg->blocksize) {
2645 fprintf(stderr,
2646 _("agsize (%s) not a multiple of fs blk size (%d)\n"),
2647 cli->agsize, cfg->blocksize);
2648 usage();
2649 }
2650 cfg->agsize /= cfg->blocksize;
2651 cfg->agcount = cfg->dblocks / cfg->agsize +
2652 (cfg->dblocks % cfg->agsize != 0);
2653
2654 } else if (cli->agcount) { /* User-specified AG count */
2655 cfg->agcount = cli->agcount;
2656 cfg->agsize = cfg->dblocks / cfg->agcount +
2657 (cfg->dblocks % cfg->agcount != 0);
2658 } else {
2659 calc_default_ag_geometry(cfg->blocklog, cfg->dblocks,
2660 cfg->dsunit, &cfg->agsize,
2661 &cfg->agcount);
2662 }
2663 }
2664
2665 /*
2666 * Align the AG size to stripe geometry. If this fails and we are using
2667 * discovered stripe geometry, tell the caller to clear the stripe geometry.
2668 * Otherwise, set the aligned geometry (valid or invalid!) so that the
2669 * validation call will fail and exit.
2670 */
2671 static void
2672 align_ag_geometry(
2673 struct mkfs_params *cfg)
2674 {
2675 uint64_t tmp_agsize;
2676 int dsunit = cfg->dsunit;
2677
2678 if (!dsunit)
2679 goto validate;
2680
2681 /*
2682 * agsize is not a multiple of dsunit
2683 */
2684 if ((cfg->agsize % dsunit) != 0) {
2685 /*
2686 * Round up to stripe unit boundary. Also make sure
2687 * that agsize is still larger than
2688 * XFS_AG_MIN_BLOCKS(blocklog)
2689 */
2690 tmp_agsize = ((cfg->agsize + dsunit - 1) / dsunit) * dsunit;
2691 /*
2692 * Round down to stripe unit boundary if rounding up
2693 * created an AG size that is larger than the AG max.
2694 */
2695 if (tmp_agsize > XFS_AG_MAX_BLOCKS(cfg->blocklog))
2696 tmp_agsize = (cfg->agsize / dsunit) * dsunit;
2697
2698 if (tmp_agsize < XFS_AG_MIN_BLOCKS(cfg->blocklog) &&
2699 tmp_agsize > XFS_AG_MAX_BLOCKS(cfg->blocklog)) {
2700
2701 /*
2702 * If the AG size is invalid and we are using device
2703 * probed stripe alignment, just clear the alignment
2704 * and continue on.
2705 */
2706 if (!cli_opt_set(&dopts, D_SUNIT) &&
2707 !cli_opt_set(&dopts, D_SU)) {
2708 cfg->dsunit = 0;
2709 cfg->dswidth = 0;
2710 goto validate;
2711 }
2712 /*
2713 * set the agsize to the invalid value so the following
2714 * validation of the ag will fail and print a nice error
2715 * and exit.
2716 */
2717 cfg->agsize = tmp_agsize;
2718 goto validate;
2719 }
2720
2721 /* update geometry to be stripe unit aligned */
2722 cfg->agsize = tmp_agsize;
2723 if (!cli_opt_set(&dopts, D_AGCOUNT))
2724 cfg->agcount = cfg->dblocks / cfg->agsize +
2725 (cfg->dblocks % cfg->agsize != 0);
2726 if (cli_opt_set(&dopts, D_AGSIZE))
2727 fprintf(stderr,
2728 _("agsize rounded to %lld, sunit = %d\n"),
2729 (long long)cfg->agsize, dsunit);
2730 }
2731
2732 if ((cfg->agsize % cfg->dswidth) == 0 &&
2733 cfg->dswidth != cfg->dsunit &&
2734 cfg->agcount > 1) {
2735
2736 if (cli_opt_set(&dopts, D_AGCOUNT) ||
2737 cli_opt_set(&dopts, D_AGSIZE)) {
2738 fprintf(stderr, _(
2739 "Warning: AG size is a multiple of stripe width. This can cause performance\n\
2740 problems by aligning all AGs on the same disk. To avoid this, run mkfs with\n\
2741 an AG size that is one stripe unit smaller or larger, for example %llu.\n"),
2742 (unsigned long long)cfg->agsize - dsunit);
2743 goto validate;
2744 }
2745
2746 /*
2747 * This is a non-optimal configuration because all AGs start on
2748 * the same disk in the stripe. Changing the AG size by one
2749 * sunit will guarantee that this does not happen.
2750 */
2751 tmp_agsize = cfg->agsize - dsunit;
2752 if (tmp_agsize < XFS_AG_MIN_BLOCKS(cfg->blocklog)) {
2753 tmp_agsize = cfg->agsize + dsunit;
2754 if (cfg->dblocks < cfg->agsize) {
2755 /* oh well, nothing to do */
2756 tmp_agsize = cfg->agsize;
2757 }
2758 }
2759
2760 cfg->agsize = tmp_agsize;
2761 cfg->agcount = cfg->dblocks / cfg->agsize +
2762 (cfg->dblocks % cfg->agsize != 0);
2763 }
2764
2765 validate:
2766 /*
2767 * If the last AG is too small, reduce the filesystem size
2768 * and drop the blocks.
2769 */
2770 if (cfg->dblocks % cfg->agsize != 0 &&
2771 (cfg->dblocks % cfg->agsize < XFS_AG_MIN_BLOCKS(cfg->blocklog))) {
2772 ASSERT(!cli_opt_set(&dopts, D_AGCOUNT));
2773 cfg->dblocks = (xfs_rfsblock_t)((cfg->agcount - 1) * cfg->agsize);
2774 cfg->agcount--;
2775 ASSERT(cfg->agcount != 0);
2776 }
2777
2778 validate_ag_geometry(cfg->blocklog, cfg->dblocks,
2779 cfg->agsize, cfg->agcount);
2780 }
2781
2782 static void
2783 calculate_imaxpct(
2784 struct mkfs_params *cfg,
2785 struct cli_params *cli)
2786 {
2787 cfg->imaxpct = cli->imaxpct;
2788 if (cfg->imaxpct)
2789 return;
2790
2791 /*
2792 * This returns the % of the disk space that is used for
2793 * inodes, it changes relatively to the FS size:
2794 * - over 50 TB, use 1%,
2795 * - 1TB - 50 TB, use 5%,
2796 * - under 1 TB, use XFS_DFL_IMAXIMUM_PCT (25%).
2797 */
2798
2799 if (cfg->dblocks < TERABYTES(1, cfg->blocklog))
2800 cfg->imaxpct = XFS_DFL_IMAXIMUM_PCT;
2801 else if (cfg->dblocks < TERABYTES(50, cfg->blocklog))
2802 cfg->imaxpct = 5;
2803 else
2804 cfg->imaxpct = 1;
2805 }
2806
2807 /*
2808 * Set up the initial state of the superblock so we can start using the
2809 * libxfs geometry macros.
2810 */
2811 static void
2812 sb_set_features(
2813 struct mkfs_params *cfg,
2814 struct xfs_sb *sbp)
2815 {
2816 struct sb_feat_args *fp = &cfg->sb_feat;
2817
2818 sbp->sb_versionnum = XFS_DFL_SB_VERSION_BITS;
2819 if (fp->crcs_enabled)
2820 sbp->sb_versionnum |= XFS_SB_VERSION_5;
2821 else
2822 sbp->sb_versionnum |= XFS_SB_VERSION_4;
2823
2824 if (fp->inode_align) {
2825 int cluster_size = XFS_INODE_BIG_CLUSTER_SIZE;
2826
2827 sbp->sb_versionnum |= XFS_SB_VERSION_ALIGNBIT;
2828 if (cfg->sb_feat.crcs_enabled)
2829 cluster_size *= cfg->inodesize / XFS_DINODE_MIN_SIZE;
2830 sbp->sb_inoalignmt = cluster_size >> cfg->blocklog;
2831 } else
2832 sbp->sb_inoalignmt = 0;
2833
2834 if (cfg->dsunit)
2835 sbp->sb_versionnum |= XFS_SB_VERSION_DALIGNBIT;
2836 if (fp->log_version == 2)
2837 sbp->sb_versionnum |= XFS_SB_VERSION_LOGV2BIT;
2838 if (fp->attr_version == 1)
2839 sbp->sb_versionnum |= XFS_SB_VERSION_ATTRBIT;
2840 if (fp->nci)
2841 sbp->sb_versionnum |= XFS_SB_VERSION_BORGBIT;
2842
2843 if (cfg->sectorsize > BBSIZE || cfg->lsectorsize > BBSIZE) {
2844 sbp->sb_versionnum |= XFS_SB_VERSION_SECTORBIT;
2845 sbp->sb_logsectlog = (uint8_t)cfg->lsectorlog;
2846 sbp->sb_logsectsize = (uint16_t)cfg->lsectorsize;
2847 } else {
2848 sbp->sb_logsectlog = 0;
2849 sbp->sb_logsectsize = 0;
2850 }
2851
2852 sbp->sb_features2 = 0;
2853 if (fp->lazy_sb_counters)
2854 sbp->sb_features2 |= XFS_SB_VERSION2_LAZYSBCOUNTBIT;
2855 if (fp->projid32bit)
2856 sbp->sb_features2 |= XFS_SB_VERSION2_PROJID32BIT;
2857 if (fp->parent_pointers)
2858 sbp->sb_features2 |= XFS_SB_VERSION2_PARENTBIT;
2859 if (fp->crcs_enabled)
2860 sbp->sb_features2 |= XFS_SB_VERSION2_CRCBIT;
2861 if (fp->attr_version == 2)
2862 sbp->sb_features2 |= XFS_SB_VERSION2_ATTR2BIT;
2863
2864 /* v5 superblocks have their own feature bit for dirftype */
2865 if (fp->dirftype && !fp->crcs_enabled)
2866 sbp->sb_features2 |= XFS_SB_VERSION2_FTYPE;
2867
2868 /* update whether extended features are in use */
2869 if (sbp->sb_features2 != 0)
2870 sbp->sb_versionnum |= XFS_SB_VERSION_MOREBITSBIT;
2871
2872 /*
2873 * Due to a structure alignment issue, sb_features2 ended up in one
2874 * of two locations, the second "incorrect" location represented by
2875 * the sb_bad_features2 field. To avoid older kernels mounting
2876 * filesystems they shouldn't, set both field to the same value.
2877 */
2878 sbp->sb_bad_features2 = sbp->sb_features2;
2879
2880 if (!fp->crcs_enabled)
2881 return;
2882
2883 /* default features for v5 filesystems */
2884 sbp->sb_features_compat = 0;
2885 sbp->sb_features_ro_compat = 0;
2886 sbp->sb_features_incompat = XFS_SB_FEAT_INCOMPAT_FTYPE;
2887 sbp->sb_features_log_incompat = 0;
2888
2889 if (fp->finobt)
2890 sbp->sb_features_ro_compat = XFS_SB_FEAT_RO_COMPAT_FINOBT;
2891 if (fp->rmapbt)
2892 sbp->sb_features_ro_compat |= XFS_SB_FEAT_RO_COMPAT_RMAPBT;
2893 if (fp->reflink)
2894 sbp->sb_features_ro_compat |= XFS_SB_FEAT_RO_COMPAT_REFLINK;
2895
2896 /*
2897 * Sparse inode chunk support has two main inode alignment requirements.
2898 * First, sparse chunk alignment must match the cluster size. Second,
2899 * full chunk alignment must match the inode chunk size.
2900 *
2901 * Copy the already calculated/scaled inoalignmt to spino_align and
2902 * update the former to the full inode chunk size.
2903 */
2904 if (fp->spinodes) {
2905 sbp->sb_spino_align = sbp->sb_inoalignmt;
2906 sbp->sb_inoalignmt = XFS_INODES_PER_CHUNK *
2907 cfg->inodesize >> cfg->blocklog;
2908 sbp->sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_SPINODES;
2909 }
2910
2911 }
2912
2913 /*
2914 * Make sure that the log size is a multiple of the stripe unit
2915 */
2916 static void
2917 align_log_size(
2918 struct mkfs_params *cfg,
2919 int sunit)
2920 {
2921 uint64_t tmp_logblocks;
2922
2923 /* nothing to do if it's already aligned. */
2924 if ((cfg->logblocks % sunit) == 0)
2925 return;
2926
2927 if (cli_opt_set(&lopts, L_SIZE)) {
2928 fprintf(stderr,
2929 _("log size %lld is not a multiple of the log stripe unit %d\n"),
2930 (long long) cfg->logblocks, sunit);
2931 usage();
2932 }
2933
2934 tmp_logblocks = ((cfg->logblocks + (sunit - 1)) / sunit) * sunit;
2935
2936 /* If the log is too large, round down instead of round up */
2937 if ((tmp_logblocks > XFS_MAX_LOG_BLOCKS) ||
2938 ((tmp_logblocks << cfg->blocklog) > XFS_MAX_LOG_BYTES)) {
2939 tmp_logblocks = (cfg->logblocks / sunit) * sunit;
2940 }
2941 cfg->logblocks = tmp_logblocks;
2942 }
2943
2944 /*
2945 * Make sure that the internal log is correctly aligned to the specified
2946 * stripe unit.
2947 */
2948 static void
2949 align_internal_log(
2950 struct mkfs_params *cfg,
2951 struct xfs_mount *mp,
2952 int sunit)
2953 {
2954 /* round up log start if necessary */
2955 if ((cfg->logstart % sunit) != 0)
2956 cfg->logstart = ((cfg->logstart + (sunit - 1)) / sunit) * sunit;
2957
2958 /* round up/down the log size now */
2959 align_log_size(cfg, sunit);
2960
2961 /* check the aligned log still fits in an AG. */
2962 if (cfg->logblocks > cfg->agsize - XFS_FSB_TO_AGBNO(mp, cfg->logstart)) {
2963 fprintf(stderr,
2964 _("Due to stripe alignment, the internal log size (%lld) is too large.\n"
2965 "Must fit within an allocation group.\n"),
2966 (long long) cfg->logblocks);
2967 usage();
2968 }
2969 }
2970
2971 void
2972 validate_log_size(uint64_t logblocks, int blocklog, int min_logblocks)
2973 {
2974 if (logblocks < min_logblocks) {
2975 fprintf(stderr,
2976 _("log size %lld blocks too small, minimum size is %d blocks\n"),
2977 (long long)logblocks, min_logblocks);
2978 usage();
2979 }
2980 if (logblocks > XFS_MAX_LOG_BLOCKS) {
2981 fprintf(stderr,
2982 _("log size %lld blocks too large, maximum size is %lld blocks\n"),
2983 (long long)logblocks, XFS_MAX_LOG_BLOCKS);
2984 usage();
2985 }
2986 if ((logblocks << blocklog) > XFS_MAX_LOG_BYTES) {
2987 fprintf(stderr,
2988 _("log size %lld bytes too large, maximum size is %lld bytes\n"),
2989 (long long)(logblocks << blocklog), XFS_MAX_LOG_BYTES);
2990 usage();
2991 }
2992 }
2993
2994 static void
2995 calculate_log_size(
2996 struct mkfs_params *cfg,
2997 struct cli_params *cli,
2998 struct xfs_mount *mp)
2999 {
3000 struct xfs_sb *sbp = &mp->m_sb;
3001 int min_logblocks;
3002 struct xfs_mount mount;
3003
3004 /* we need a temporary mount to calculate the minimum log size. */
3005 memset(&mount, 0, sizeof(mount));
3006 mount.m_sb = *sbp;
3007 libxfs_mount(&mount, &mp->m_sb, 0, 0, 0, 0);
3008 min_logblocks = libxfs_log_calc_minimum_size(&mount);
3009 libxfs_umount(&mount);
3010
3011 ASSERT(min_logblocks);
3012 min_logblocks = max(XFS_MIN_LOG_BLOCKS, min_logblocks);
3013
3014 /* if we have lots of blocks, check against XFS_MIN_LOG_BYTES, too */
3015 if (!cli->logsize &&
3016 cfg->dblocks >= (1024*1024*1024) >> cfg->blocklog)
3017 min_logblocks = max(min_logblocks,
3018 XFS_MIN_LOG_BYTES >> cfg->blocklog);
3019
3020 /*
3021 * external logs will have a device and size by now, so all we have
3022 * to do is validate it against minimum size and align it.
3023 */
3024 if (!cfg->loginternal) {
3025 if (min_logblocks > cfg->logblocks) {
3026 fprintf(stderr,
3027 _("external log device %lld too small, must be at least %lld blocks\n"),
3028 (long long)cfg->logblocks,
3029 (long long)min_logblocks);
3030 usage();
3031 }
3032 cfg->logstart = 0;
3033 cfg->logagno = 0;
3034 if (cfg->lsunit)
3035 align_log_size(cfg, cfg->lsunit);
3036
3037 validate_log_size(cfg->logblocks, cfg->blocklog, min_logblocks);
3038 return;
3039 }
3040
3041 /* internal log - if no size specified, calculate automatically */
3042 if (!cfg->logblocks) {
3043 if (cfg->dblocks < GIGABYTES(1, cfg->blocklog)) {
3044 /* tiny filesystems get minimum sized logs. */
3045 cfg->logblocks = min_logblocks;
3046 } else if (cfg->dblocks < GIGABYTES(16, cfg->blocklog)) {
3047
3048 /*
3049 * For small filesystems, we want to use the
3050 * XFS_MIN_LOG_BYTES for filesystems smaller than 16G if
3051 * at all possible, ramping up to 128MB at 256GB.
3052 */
3053 cfg->logblocks = min(XFS_MIN_LOG_BYTES >> cfg->blocklog,
3054 min_logblocks * XFS_DFL_LOG_FACTOR);
3055 } else {
3056 /*
3057 * With a 2GB max log size, default to maximum size
3058 * at 4TB. This keeps the same ratio from the older
3059 * max log size of 128M at 256GB fs size. IOWs,
3060 * the ratio of fs size to log size is 2048:1.
3061 */
3062 cfg->logblocks = (cfg->dblocks << cfg->blocklog) / 2048;
3063 cfg->logblocks = cfg->logblocks >> cfg->blocklog;
3064 }
3065
3066 /* Ensure the chosen size meets minimum log size requirements */
3067 cfg->logblocks = max(min_logblocks, cfg->logblocks);
3068
3069 /*
3070 * Make sure the log fits wholly within an AG
3071 *
3072 * XXX: If agf->freeblks ends up as 0 because the log uses all
3073 * the free space, it causes the kernel all sorts of problems
3074 * with per-ag reservations. Right now just back it off one
3075 * block, but there's a whole can of worms here that needs to be
3076 * opened to decide what is the valid maximum size of a log in
3077 * an AG.
3078 */
3079 cfg->logblocks = min(cfg->logblocks,
3080 libxfs_alloc_ag_max_usable(mp) - 1);
3081
3082 /* and now clamp the size to the maximum supported size */
3083 cfg->logblocks = min(cfg->logblocks, XFS_MAX_LOG_BLOCKS);
3084 if ((cfg->logblocks << cfg->blocklog) > XFS_MAX_LOG_BYTES)
3085 cfg->logblocks = XFS_MAX_LOG_BYTES >> cfg->blocklog;
3086
3087 validate_log_size(cfg->logblocks, cfg->blocklog, min_logblocks);
3088 }
3089
3090 if (cfg->logblocks > sbp->sb_agblocks - libxfs_prealloc_blocks(mp)) {
3091 fprintf(stderr,
3092 _("internal log size %lld too large, must fit in allocation group\n"),
3093 (long long)cfg->logblocks);
3094 usage();
3095 }
3096
3097 if (cli_opt_set(&lopts, L_AGNUM)) {
3098 if (cli->logagno >= sbp->sb_agcount) {
3099 fprintf(stderr,
3100 _("log ag number %lld too large, must be less than %lld\n"),
3101 (long long)cli->logagno,
3102 (long long)sbp->sb_agcount);
3103 usage();
3104 }
3105 cfg->logagno = cli->logagno;
3106 } else
3107 cfg->logagno = (xfs_agnumber_t)(sbp->sb_agcount / 2);
3108
3109 cfg->logstart = XFS_AGB_TO_FSB(mp, cfg->logagno,
3110 libxfs_prealloc_blocks(mp));
3111
3112 /*
3113 * Align the logstart at stripe unit boundary.
3114 */
3115 if (cfg->lsunit) {
3116 align_internal_log(cfg, mp, cfg->lsunit);
3117 } else if (cfg->dsunit) {
3118 align_internal_log(cfg, mp, cfg->dsunit);
3119 }
3120 validate_log_size(cfg->logblocks, cfg->blocklog, min_logblocks);
3121 }
3122
3123 /*
3124 * Set up superblock with the minimum parameters required for
3125 * the libxfs macros needed by the log sizing code to run successfully.
3126 * This includes a minimum log size calculation, so we need everything
3127 * that goes into that calculation to be setup here including feature
3128 * flags.
3129 */
3130 static void
3131 start_superblock_setup(
3132 struct mkfs_params *cfg,
3133 struct xfs_mount *mp,
3134 struct xfs_sb *sbp)
3135 {
3136 sbp->sb_magicnum = XFS_SB_MAGIC;
3137 sbp->sb_sectsize = (uint16_t)cfg->sectorsize;
3138 sbp->sb_sectlog = (uint8_t)cfg->sectorlog;
3139 sbp->sb_blocksize = cfg->blocksize;
3140 sbp->sb_blocklog = (uint8_t)cfg->blocklog;
3141
3142 sbp->sb_agblocks = (xfs_agblock_t)cfg->agsize;
3143 sbp->sb_agblklog = (uint8_t)log2_roundup(cfg->agsize);
3144 sbp->sb_agcount = (xfs_agnumber_t)cfg->agcount;
3145
3146 sbp->sb_inodesize = (uint16_t)cfg->inodesize;
3147 sbp->sb_inodelog = (uint8_t)cfg->inodelog;
3148 sbp->sb_inopblock = (uint16_t)(cfg->blocksize / cfg->inodesize);
3149 sbp->sb_inopblog = (uint8_t)(cfg->blocklog - cfg->inodelog);
3150
3151 sbp->sb_dirblklog = cfg->dirblocklog - cfg->blocklog;
3152
3153 sb_set_features(cfg, sbp);
3154
3155 /*
3156 * log stripe unit is stored in bytes on disk and cannot be zero
3157 * for v2 logs.
3158 */
3159 if (cfg->sb_feat.log_version == 2) {
3160 if (cfg->lsunit)
3161 sbp->sb_logsunit = XFS_FSB_TO_B(mp, cfg->lsunit);
3162 else
3163 sbp->sb_logsunit = 1;
3164 } else
3165 sbp->sb_logsunit = 0;
3166
3167 }
3168
3169 static void
3170 initialise_mount(
3171 struct mkfs_params *cfg,
3172 struct xfs_mount *mp,
3173 struct xfs_sb *sbp)
3174 {
3175 /* Minimum needed for libxfs_prealloc_blocks() */
3176 mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT;
3177 mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT;
3178 }
3179
3180 /*
3181 * Format everything from the generated config into the superblock that
3182 * will be used to initialise the on-disk superblock. This is the in-memory
3183 * copy, so no need to care about endian swapping here.
3184 */
3185 static void
3186 finish_superblock_setup(
3187 struct mkfs_params *cfg,
3188 struct xfs_mount *mp,
3189 struct xfs_sb *sbp)
3190 {
3191 if (cfg->label)
3192 strncpy(sbp->sb_fname, cfg->label, sizeof(sbp->sb_fname));
3193
3194 sbp->sb_dblocks = cfg->dblocks;
3195 sbp->sb_rblocks = cfg->rtblocks;
3196 sbp->sb_rextents = cfg->rtextents;
3197 platform_uuid_copy(&sbp->sb_uuid, &cfg->uuid);
3198 /* Only in memory; libxfs expects this as if read from disk */
3199 platform_uuid_copy(&sbp->sb_meta_uuid, &cfg->uuid);
3200 sbp->sb_logstart = cfg->logstart;
3201 sbp->sb_rootino = sbp->sb_rbmino = sbp->sb_rsumino = NULLFSINO;
3202 sbp->sb_rextsize = cfg->rtextblocks;
3203 sbp->sb_agcount = (xfs_agnumber_t)cfg->agcount;
3204 sbp->sb_rbmblocks = cfg->rtbmblocks;
3205 sbp->sb_logblocks = (xfs_extlen_t)cfg->logblocks;
3206 sbp->sb_rextslog = (uint8_t)(cfg->rtextents ?
3207 libxfs_highbit32((unsigned int)cfg->rtextents) : 0);
3208 sbp->sb_inprogress = 1; /* mkfs is in progress */
3209 sbp->sb_imax_pct = cfg->imaxpct;
3210 sbp->sb_icount = 0;
3211 sbp->sb_ifree = 0;
3212 sbp->sb_fdblocks = cfg->dblocks -
3213 cfg->agcount * libxfs_prealloc_blocks(mp) -
3214 (cfg->loginternal ? cfg->logblocks : 0);
3215 sbp->sb_frextents = 0; /* will do a free later */
3216 sbp->sb_uquotino = sbp->sb_gquotino = sbp->sb_pquotino = 0;
3217 sbp->sb_qflags = 0;
3218 sbp->sb_unit = cfg->dsunit;
3219 sbp->sb_width = cfg->dswidth;
3220
3221 }
3222
3223 /*
3224 * Sanitise the data and log devices and prepare them so libxfs can mount the
3225 * device successfully. Also check we can access the rt device if configured.
3226 */
3227 static void
3228 prepare_devices(
3229 struct mkfs_params *cfg,
3230 struct libxfs_xinit *xi,
3231 struct xfs_mount *mp,
3232 struct xfs_sb *sbp,
3233 bool clear_stale)
3234 {
3235 struct xfs_buf *buf;
3236 int whack_blks = BTOBB(WHACK_SIZE);
3237 int lsunit;
3238
3239 /*
3240 * If there's an old XFS filesystem on the device with enough intact
3241 * information that we can parse the superblock, there's enough
3242 * information on disk to confuse a future xfs_repair call. To avoid
3243 * this, whack all the old secondary superblocks that we can find.
3244 */
3245 if (clear_stale)
3246 zero_old_xfs_structures(xi, sbp);
3247
3248 /*
3249 * If the data device is a file, grow out the file to its final size if
3250 * needed so that the reads for the end of the device in the mount code
3251 * will succeed.
3252 */
3253 if (xi->disfile &&
3254 xi->dsize * xi->dbsize < cfg->dblocks * cfg->blocksize) {
3255 if (ftruncate(xi->dfd, cfg->dblocks * cfg->blocksize) < 0) {
3256 fprintf(stderr,
3257 _("%s: Growing the data section failed\n"),
3258 progname);
3259 exit(1);
3260 }
3261
3262 /* update size to be able to whack blocks correctly */
3263 xi->dsize = BTOBB(cfg->dblocks * cfg->blocksize);
3264 }
3265
3266 /*
3267 * Zero out the end to obliterate any old MD RAID (or other) metadata at
3268 * the end of the device. (MD sb is ~64k from the end, take out a wider
3269 * swath to be sure)
3270 */
3271 buf = libxfs_getbuf(mp->m_ddev_targp, (xi->dsize - whack_blks),
3272 whack_blks);
3273 memset(buf->b_addr, 0, WHACK_SIZE);
3274 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3275 libxfs_purgebuf(buf);
3276
3277 /*
3278 * Now zero out the beginning of the device, to obliterate any old
3279 * filesystem signatures out there. This should take care of
3280 * swap (somewhere around the page size), jfs (32k),
3281 * ext[2,3] and reiserfs (64k) - and hopefully all else.
3282 */
3283 buf = libxfs_getbuf(mp->m_ddev_targp, 0, whack_blks);
3284 memset(buf->b_addr, 0, WHACK_SIZE);
3285 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3286 libxfs_purgebuf(buf);
3287
3288 /* OK, now write the superblock... */
3289 buf = libxfs_getbuf(mp->m_ddev_targp, XFS_SB_DADDR, XFS_FSS_TO_BB(mp, 1));
3290 buf->b_ops = &xfs_sb_buf_ops;
3291 memset(buf->b_addr, 0, cfg->sectorsize);
3292 libxfs_sb_to_disk(buf->b_addr, sbp);
3293 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3294 libxfs_purgebuf(buf);
3295
3296 /* ...and zero the log.... */
3297 lsunit = sbp->sb_logsunit;
3298 if (lsunit == 1)
3299 lsunit = sbp->sb_logsectsize;
3300
3301 libxfs_log_clear(mp->m_logdev_targp, NULL,
3302 XFS_FSB_TO_DADDR(mp, cfg->logstart),
3303 (xfs_extlen_t)XFS_FSB_TO_BB(mp, cfg->logblocks),
3304 &sbp->sb_uuid, cfg->sb_feat.log_version,
3305 lsunit, XLOG_FMT, XLOG_INIT_CYCLE, false);
3306
3307 /* finally, check we can write the last block in the realtime area */
3308 if (mp->m_rtdev_targp->dev && cfg->rtblocks > 0) {
3309 buf = libxfs_getbuf(mp->m_rtdev_targp,
3310 XFS_FSB_TO_BB(mp, cfg->rtblocks - 1LL),
3311 BTOBB(cfg->blocksize));
3312 memset(buf->b_addr, 0, cfg->blocksize);
3313 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3314 libxfs_purgebuf(buf);
3315 }
3316
3317 }
3318
3319 /*
3320 * XXX: this code is mostly common with the kernel growfs code.
3321 * These initialisations should be pulled into libxfs to keep the
3322 * kernel/userspace header initialisation code the same.
3323 */
3324 static void
3325 initialise_ag_headers(
3326 struct mkfs_params *cfg,
3327 struct xfs_mount *mp,
3328 struct xfs_sb *sbp,
3329 xfs_agnumber_t agno,
3330 int *worst_freelist)
3331 {
3332 struct xfs_perag *pag = libxfs_perag_get(mp, agno);
3333 struct xfs_agfl *agfl;
3334 struct xfs_agf *agf;
3335 struct xfs_agi *agi;
3336 struct xfs_buf *buf;
3337 struct xfs_btree_block *block;
3338 struct xfs_alloc_rec *arec;
3339 struct xfs_alloc_rec *nrec;
3340 int bucket;
3341 uint64_t agsize = cfg->agsize;
3342 xfs_agblock_t agblocks;
3343 bool is_log_ag = false;
3344 int c;
3345
3346 if (cfg->loginternal && agno == cfg->logagno)
3347 is_log_ag = true;
3348
3349 /*
3350 * Superblock.
3351 */
3352 buf = libxfs_getbuf(mp->m_ddev_targp,
3353 XFS_AG_DADDR(mp, agno, XFS_SB_DADDR),
3354 XFS_FSS_TO_BB(mp, 1));
3355 buf->b_ops = &xfs_sb_buf_ops;
3356 memset(buf->b_addr, 0, cfg->sectorsize);
3357 libxfs_sb_to_disk(buf->b_addr, sbp);
3358 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3359
3360 /*
3361 * AG header block: freespace
3362 */
3363 buf = libxfs_getbuf(mp->m_ddev_targp,
3364 XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
3365 XFS_FSS_TO_BB(mp, 1));
3366 buf->b_ops = &xfs_agf_buf_ops;
3367 agf = XFS_BUF_TO_AGF(buf);
3368 memset(agf, 0, cfg->sectorsize);
3369 if (agno == cfg->agcount - 1)
3370 agsize = cfg->dblocks - (xfs_rfsblock_t)(agno * agsize);
3371 agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
3372 agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
3373 agf->agf_seqno = cpu_to_be32(agno);
3374 agf->agf_length = cpu_to_be32(agsize);
3375 agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
3376 agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
3377 agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
3378 agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
3379 pag->pagf_levels[XFS_BTNUM_BNOi] = 1;
3380 pag->pagf_levels[XFS_BTNUM_CNTi] = 1;
3381
3382 if (xfs_sb_version_hasrmapbt(sbp)) {
3383 agf->agf_roots[XFS_BTNUM_RMAPi] = cpu_to_be32(XFS_RMAP_BLOCK(mp));
3384 agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);
3385 agf->agf_rmap_blocks = cpu_to_be32(1);
3386 }
3387
3388 if (xfs_sb_version_hasreflink(sbp)) {
3389 agf->agf_refcount_root = cpu_to_be32(libxfs_refc_block(mp));
3390 agf->agf_refcount_level = cpu_to_be32(1);
3391 agf->agf_refcount_blocks = cpu_to_be32(1);
3392 }
3393
3394 agf->agf_flfirst = 0;
3395 agf->agf_fllast = cpu_to_be32(libxfs_agfl_size(mp) - 1);
3396 agf->agf_flcount = 0;
3397 agblocks = (xfs_agblock_t)(agsize - libxfs_prealloc_blocks(mp));
3398 agf->agf_freeblks = cpu_to_be32(agblocks);
3399 agf->agf_longest = cpu_to_be32(agblocks);
3400
3401 if (xfs_sb_version_hascrc(sbp))
3402 platform_uuid_copy(&agf->agf_uuid, &sbp->sb_uuid);
3403
3404 if (is_log_ag) {
3405 be32_add_cpu(&agf->agf_freeblks, -(int64_t)cfg->logblocks);
3406 agf->agf_longest = cpu_to_be32(agsize -
3407 XFS_FSB_TO_AGBNO(mp, cfg->logstart) - cfg->logblocks);
3408 }
3409 if (libxfs_alloc_min_freelist(mp, pag) > *worst_freelist)
3410 *worst_freelist = libxfs_alloc_min_freelist(mp, pag);
3411 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3412
3413 /*
3414 * AG freelist header block
3415 */
3416 buf = libxfs_getbuf(mp->m_ddev_targp,
3417 XFS_AG_DADDR(mp, agno, XFS_AGFL_DADDR(mp)),
3418 XFS_FSS_TO_BB(mp, 1));
3419 buf->b_ops = &xfs_agfl_buf_ops;
3420 agfl = XFS_BUF_TO_AGFL(buf);
3421 /* setting to 0xff results in initialisation to NULLAGBLOCK */
3422 memset(agfl, 0xff, cfg->sectorsize);
3423 if (xfs_sb_version_hascrc(sbp)) {
3424 agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);
3425 agfl->agfl_seqno = cpu_to_be32(agno);
3426 platform_uuid_copy(&agfl->agfl_uuid, &sbp->sb_uuid);
3427 for (bucket = 0; bucket < libxfs_agfl_size(mp); bucket++)
3428 agfl->agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);
3429 }
3430
3431 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3432
3433 /*
3434 * AG header block: inodes
3435 */
3436 buf = libxfs_getbuf(mp->m_ddev_targp,
3437 XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
3438 XFS_FSS_TO_BB(mp, 1));
3439 agi = XFS_BUF_TO_AGI(buf);
3440 buf->b_ops = &xfs_agi_buf_ops;
3441 memset(agi, 0, cfg->sectorsize);
3442 agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
3443 agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
3444 agi->agi_seqno = cpu_to_be32(agno);
3445 agi->agi_length = cpu_to_be32(agsize);
3446 agi->agi_count = 0;
3447 agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
3448 agi->agi_level = cpu_to_be32(1);
3449 if (xfs_sb_version_hasfinobt(sbp)) {
3450 agi->agi_free_root = cpu_to_be32(XFS_FIBT_BLOCK(mp));
3451 agi->agi_free_level = cpu_to_be32(1);
3452 }
3453 agi->agi_freecount = 0;
3454 agi->agi_newino = cpu_to_be32(NULLAGINO);
3455 agi->agi_dirino = cpu_to_be32(NULLAGINO);
3456 if (xfs_sb_version_hascrc(sbp))
3457 platform_uuid_copy(&agi->agi_uuid, &sbp->sb_uuid);
3458 for (c = 0; c < XFS_AGI_UNLINKED_BUCKETS; c++)
3459 agi->agi_unlinked[c] = cpu_to_be32(NULLAGINO);
3460 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3461
3462 /*
3463 * BNO btree root block
3464 */
3465 buf = libxfs_getbuf(mp->m_ddev_targp,
3466 XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
3467 BTOBB(cfg->blocksize));
3468 buf->b_ops = &xfs_allocbt_buf_ops;
3469 block = XFS_BUF_TO_BLOCK(buf);
3470 memset(block, 0, cfg->blocksize);
3471 libxfs_btree_init_block(mp, buf, XFS_BTNUM_BNO, 0, 1, agno, 0);
3472
3473 arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
3474 arec->ar_startblock = cpu_to_be32(libxfs_prealloc_blocks(mp));
3475 if (is_log_ag) {
3476 xfs_agblock_t start = XFS_FSB_TO_AGBNO(mp, cfg->logstart);
3477
3478 ASSERT(start >= libxfs_prealloc_blocks(mp));
3479 if (start != libxfs_prealloc_blocks(mp)) {
3480 /*
3481 * Modify first record to pad stripe align of log
3482 */
3483 arec->ar_blockcount = cpu_to_be32(start -
3484 libxfs_prealloc_blocks(mp));
3485 nrec = arec + 1;
3486 /*
3487 * Insert second record at start of internal log
3488 * which then gets trimmed.
3489 */
3490 nrec->ar_startblock = cpu_to_be32(
3491 be32_to_cpu(arec->ar_startblock) +
3492 be32_to_cpu(arec->ar_blockcount));
3493 arec = nrec;
3494 be16_add_cpu(&block->bb_numrecs, 1);
3495 }
3496 /*
3497 * Change record start to after the internal log
3498 */
3499 be32_add_cpu(&arec->ar_startblock, cfg->logblocks);
3500 }
3501 /*
3502 * Calculate the record block count and check for the case where
3503 * the log might have consumed all available space in the AG. If
3504 * so, reset the record count to 0 to avoid exposure of an invalid
3505 * record start block.
3506 */
3507 arec->ar_blockcount = cpu_to_be32(agsize -
3508 be32_to_cpu(arec->ar_startblock));
3509 if (!arec->ar_blockcount)
3510 block->bb_numrecs = 0;
3511
3512 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3513
3514 /*
3515 * CNT btree root block
3516 */
3517 buf = libxfs_getbuf(mp->m_ddev_targp,
3518 XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
3519 BTOBB(cfg->blocksize));
3520 buf->b_ops = &xfs_allocbt_buf_ops;
3521 block = XFS_BUF_TO_BLOCK(buf);
3522 memset(block, 0, cfg->blocksize);
3523 libxfs_btree_init_block(mp, buf, XFS_BTNUM_CNT, 0, 1, agno, 0);
3524
3525 arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
3526 arec->ar_startblock = cpu_to_be32(libxfs_prealloc_blocks(mp));
3527 if (is_log_ag) {
3528 xfs_agblock_t start = XFS_FSB_TO_AGBNO(mp, cfg->logstart);
3529
3530 ASSERT(start >= libxfs_prealloc_blocks(mp));
3531 if (start != libxfs_prealloc_blocks(mp)) {
3532 arec->ar_blockcount = cpu_to_be32(start -
3533 libxfs_prealloc_blocks(mp));
3534 nrec = arec + 1;
3535 nrec->ar_startblock = cpu_to_be32(
3536 be32_to_cpu(arec->ar_startblock) +
3537 be32_to_cpu(arec->ar_blockcount));
3538 arec = nrec;
3539 be16_add_cpu(&block->bb_numrecs, 1);
3540 }
3541 be32_add_cpu(&arec->ar_startblock, cfg->logblocks);
3542 }
3543 /*
3544 * Calculate the record block count and check for the case where
3545 * the log might have consumed all available space in the AG. If
3546 * so, reset the record count to 0 to avoid exposure of an invalid
3547 * record start block.
3548 */
3549 arec->ar_blockcount = cpu_to_be32(agsize -
3550 be32_to_cpu(arec->ar_startblock));
3551 if (!arec->ar_blockcount)
3552 block->bb_numrecs = 0;
3553
3554 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3555
3556 /*
3557 * refcount btree root block
3558 */
3559 if (xfs_sb_version_hasreflink(sbp)) {
3560 buf = libxfs_getbuf(mp->m_ddev_targp,
3561 XFS_AGB_TO_DADDR(mp, agno, libxfs_refc_block(mp)),
3562 BTOBB(cfg->blocksize));
3563 buf->b_ops = &xfs_refcountbt_buf_ops;
3564
3565 block = XFS_BUF_TO_BLOCK(buf);
3566 memset(block, 0, cfg->blocksize);
3567 libxfs_btree_init_block(mp, buf, XFS_BTNUM_REFC, 0, 0, agno, 0);
3568 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3569 }
3570
3571 /*
3572 * INO btree root block
3573 */
3574 buf = libxfs_getbuf(mp->m_ddev_targp,
3575 XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
3576 BTOBB(cfg->blocksize));
3577 buf->b_ops = &xfs_inobt_buf_ops;
3578 block = XFS_BUF_TO_BLOCK(buf);
3579 memset(block, 0, cfg->blocksize);
3580 libxfs_btree_init_block(mp, buf, XFS_BTNUM_INO, 0, 0, agno, 0);
3581 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3582
3583 /*
3584 * Free INO btree root block
3585 */
3586 if (xfs_sb_version_hasfinobt(sbp)) {
3587 buf = libxfs_getbuf(mp->m_ddev_targp,
3588 XFS_AGB_TO_DADDR(mp, agno, XFS_FIBT_BLOCK(mp)),
3589 BTOBB(cfg->blocksize));
3590 buf->b_ops = &xfs_inobt_buf_ops;
3591 block = XFS_BUF_TO_BLOCK(buf);
3592 memset(block, 0, cfg->blocksize);
3593 libxfs_btree_init_block(mp, buf, XFS_BTNUM_FINO, 0, 0, agno, 0);
3594 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3595 }
3596
3597 /* RMAP btree root block */
3598 if (xfs_sb_version_hasrmapbt(sbp)) {
3599 struct xfs_rmap_rec *rrec;
3600
3601 buf = libxfs_getbuf(mp->m_ddev_targp,
3602 XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
3603 BTOBB(cfg->blocksize));
3604 buf->b_ops = &xfs_rmapbt_buf_ops;
3605 block = XFS_BUF_TO_BLOCK(buf);
3606 memset(block, 0, cfg->blocksize);
3607
3608 libxfs_btree_init_block(mp, buf, XFS_BTNUM_RMAP, 0, 0, agno, 0);
3609
3610 /*
3611 * mark the AG header regions as static metadata
3612 * The BNO btree block is the first block after the
3613 * headers, so it's location defines the size of region
3614 * the static metadata consumes.
3615 */
3616 rrec = XFS_RMAP_REC_ADDR(block, 1);
3617 rrec->rm_startblock = 0;
3618 rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
3619 rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
3620 rrec->rm_offset = 0;
3621 be16_add_cpu(&block->bb_numrecs, 1);
3622
3623 /* account freespace btree root blocks */
3624 rrec = XFS_RMAP_REC_ADDR(block, 2);
3625 rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
3626 rrec->rm_blockcount = cpu_to_be32(2);
3627 rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
3628 rrec->rm_offset = 0;
3629 be16_add_cpu(&block->bb_numrecs, 1);
3630
3631 /* account inode btree root blocks */
3632 rrec = XFS_RMAP_REC_ADDR(block, 3);
3633 rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
3634 rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
3635 XFS_IBT_BLOCK(mp));
3636 rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
3637 rrec->rm_offset = 0;
3638 be16_add_cpu(&block->bb_numrecs, 1);
3639
3640 /* account for rmap btree root */
3641 rrec = XFS_RMAP_REC_ADDR(block, 4);
3642 rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
3643 rrec->rm_blockcount = cpu_to_be32(1);
3644 rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
3645 rrec->rm_offset = 0;
3646 be16_add_cpu(&block->bb_numrecs, 1);
3647
3648 /* account for refcount btree root */
3649 if (xfs_sb_version_hasreflink(sbp)) {
3650 rrec = XFS_RMAP_REC_ADDR(block, 5);
3651 rrec->rm_startblock = cpu_to_be32(libxfs_refc_block(mp));
3652 rrec->rm_blockcount = cpu_to_be32(1);
3653 rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_REFC);
3654 rrec->rm_offset = 0;
3655 be16_add_cpu(&block->bb_numrecs, 1);
3656 }
3657
3658 /* account for the log space */
3659 if (is_log_ag) {
3660 rrec = XFS_RMAP_REC_ADDR(block,
3661 be16_to_cpu(block->bb_numrecs) + 1);
3662 rrec->rm_startblock = cpu_to_be32(
3663 XFS_FSB_TO_AGBNO(mp, cfg->logstart));
3664 rrec->rm_blockcount = cpu_to_be32(cfg->logblocks);
3665 rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_LOG);
3666 rrec->rm_offset = 0;
3667 be16_add_cpu(&block->bb_numrecs, 1);
3668 }
3669
3670 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3671 }
3672
3673 libxfs_perag_put(pag);
3674 }
3675
3676 static void
3677 initialise_ag_freespace(
3678 struct xfs_mount *mp,
3679 xfs_agnumber_t agno,
3680 int worst_freelist)
3681 {
3682 struct xfs_alloc_arg args;
3683 struct xfs_trans *tp;
3684 int c;
3685
3686 c = -libxfs_trans_alloc_rollable(mp, worst_freelist, &tp);
3687 if (c)
3688 res_failed(c);
3689
3690 memset(&args, 0, sizeof(args));
3691 args.tp = tp;
3692 args.mp = mp;
3693 args.agno = agno;
3694 args.alignment = 1;
3695 args.pag = libxfs_perag_get(mp, agno);
3696
3697 libxfs_alloc_fix_freelist(&args, 0);
3698 libxfs_perag_put(args.pag);
3699 c = -libxfs_trans_commit(tp);
3700 if (c)
3701 res_failed(c);
3702 }
3703
3704 /*
3705 * rewrite several secondary superblocks with the root inode number filled out.
3706 * This can help repair recovery from a trashed primary superblock without
3707 * losing the root inode.
3708 */
3709 static void
3710 rewrite_secondary_superblocks(
3711 struct xfs_mount *mp)
3712 {
3713 struct xfs_buf *buf;
3714
3715 /* rewrite the last superblock */
3716 buf = libxfs_readbuf(mp->m_dev,
3717 XFS_AGB_TO_DADDR(mp, mp->m_sb.sb_agcount - 1,
3718 XFS_SB_DADDR),
3719 XFS_FSS_TO_BB(mp, 1),
3720 LIBXFS_EXIT_ON_FAILURE, &xfs_sb_buf_ops);
3721 XFS_BUF_TO_SBP(buf)->sb_rootino = cpu_to_be64(mp->m_sb.sb_rootino);
3722 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3723
3724 /* and one in the middle for luck if there's enough AGs for that */
3725 if (mp->m_sb.sb_agcount <= 2)
3726 return;
3727
3728 buf = libxfs_readbuf(mp->m_dev,
3729 XFS_AGB_TO_DADDR(mp, (mp->m_sb.sb_agcount - 1) / 2,
3730 XFS_SB_DADDR),
3731 XFS_FSS_TO_BB(mp, 1),
3732 LIBXFS_EXIT_ON_FAILURE, &xfs_sb_buf_ops);
3733 XFS_BUF_TO_SBP(buf)->sb_rootino = cpu_to_be64(mp->m_sb.sb_rootino);
3734 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
3735 }
3736
3737 int
3738 main(
3739 int argc,
3740 char **argv)
3741 {
3742 xfs_agnumber_t agno;
3743 xfs_buf_t *buf;
3744 int c;
3745 char *dfile = NULL;
3746 char *logfile = NULL;
3747 char *rtfile = NULL;
3748 int dry_run = 0;
3749 int discard = 1;
3750 int force_overwrite = 0;
3751 int quiet = 0;
3752 char *protofile = NULL;
3753 char *protostring = NULL;
3754 int worst_freelist = 0;
3755
3756 struct libxfs_xinit xi = {
3757 .isdirect = LIBXFS_DIRECT,
3758 .isreadonly = LIBXFS_EXCLUSIVELY,
3759 };
3760 struct xfs_mount mbuf = {};
3761 struct xfs_mount *mp = &mbuf;
3762 struct xfs_sb *sbp = &mp->m_sb;
3763 struct fs_topology ft = {};
3764 struct cli_params cli = {
3765 .xi = &xi,
3766 .loginternal = 1,
3767 };
3768 struct mkfs_params cfg = {};
3769
3770 /* build time defaults */
3771 struct mkfs_default_params dft = {
3772 .source = _("package build definitions"),
3773 .sectorsize = XFS_MIN_SECTORSIZE,
3774 .blocksize = 1 << XFS_DFL_BLOCKSIZE_LOG,
3775 .sb_feat = {
3776 .log_version = 2,
3777 .attr_version = 2,
3778 .dir_version = 2,
3779 .inode_align = true,
3780 .nci = false,
3781 .lazy_sb_counters = true,
3782 .projid32bit = true,
3783 .crcs_enabled = true,
3784 .dirftype = true,
3785 .finobt = true,
3786 .spinodes = true,
3787 .rmapbt = false,
3788 .reflink = false,
3789 .parent_pointers = false,
3790 .nodalign = false,
3791 .nortalign = false,
3792 },
3793 };
3794
3795 platform_uuid_generate(&cli.uuid);
3796 progname = basename(argv[0]);
3797 setlocale(LC_ALL, "");
3798 bindtextdomain(PACKAGE, LOCALEDIR);
3799 textdomain(PACKAGE);
3800
3801 /*
3802 * TODO: Sourcing defaults from a config file
3803 *
3804 * Before anything else, see if there's a config file with different
3805 * defaults. If a file exists in <package location>, read in the new
3806 * default values and overwrite them in the &dft structure. This way the
3807 * new defaults will apply before we parse the CLI, and the CLI will
3808 * still be able to override them. When more than one source is
3809 * implemented, emit a message to indicate where the defaults being
3810 * used came from.
3811 *
3812 * printf(_("Default configuration sourced from %s\n"), dft.source);
3813 */
3814
3815 /* copy new defaults into CLI parsing structure */
3816 memcpy(&cli.sb_feat, &dft.sb_feat, sizeof(cli.sb_feat));
3817 memcpy(&cli.fsx, &dft.fsx, sizeof(cli.fsx));
3818
3819 while ((c = getopt(argc, argv, "b:d:i:l:L:m:n:KNp:qr:s:CfV")) != EOF) {
3820 switch (c) {
3821 case 'C':
3822 case 'f':
3823 force_overwrite = 1;
3824 break;
3825 case 'b':
3826 case 'd':
3827 case 'i':
3828 case 'l':
3829 case 'm':
3830 case 'n':
3831 case 'r':
3832 case 's':
3833 parse_subopts(c, optarg, &cli);
3834 break;
3835 case 'L':
3836 if (strlen(optarg) > sizeof(sbp->sb_fname))
3837 illegal(optarg, "L");
3838 cfg.label = optarg;
3839 break;
3840 case 'N':
3841 dry_run = 1;
3842 break;
3843 case 'K':
3844 discard = 0;
3845 break;
3846 case 'p':
3847 if (protofile)
3848 respec('p', NULL, 0);
3849 protofile = optarg;
3850 break;
3851 case 'q':
3852 quiet = 1;
3853 break;
3854 case 'V':
3855 printf(_("%s version %s\n"), progname, VERSION);
3856 exit(0);
3857 case '?':
3858 unknown(optopt, "");
3859 }
3860 }
3861 if (argc - optind > 1) {
3862 fprintf(stderr, _("extra arguments\n"));
3863 usage();
3864 } else if (argc - optind == 1) {
3865 dfile = xi.volname = getstr(argv[optind], &dopts, D_NAME);
3866 } else
3867 dfile = xi.dname;
3868
3869 protostring = setup_proto(protofile);
3870
3871 /*
3872 * Extract as much of the valid config as we can from the CLI input
3873 * before opening the libxfs devices.
3874 */
3875 validate_blocksize(&cfg, &cli, &dft);
3876 validate_sectorsize(&cfg, &cli, &dft, &ft, dfile, dry_run,
3877 force_overwrite);
3878
3879 /*
3880 * XXX: we still need to set block size and sector size global variables
3881 * so that getnum/cvtnum works correctly
3882 */
3883 blocksize = cfg.blocksize;
3884 sectorsize = cfg.sectorsize;
3885
3886 validate_log_sectorsize(&cfg, &cli, &dft);
3887 validate_sb_features(&cfg, &cli);
3888
3889 /*
3890 * we've now completed basic validation of the features, sector and
3891 * block sizes, so from this point onwards we use the values found in
3892 * the cfg structure for them, not the command line structure.
3893 */
3894 validate_dirblocksize(&cfg, &cli);
3895 validate_inodesize(&cfg, &cli);
3896
3897 /*
3898 * if the device size was specified convert it to a block count
3899 * now we have a valid block size. These will be set to zero if
3900 * nothing was specified, indicating we should use the full device.
3901 */
3902 cfg.dblocks = calc_dev_size(cli.dsize, &cfg, &dopts, D_SIZE, "data");
3903 cfg.logblocks = calc_dev_size(cli.logsize, &cfg, &lopts, L_SIZE, "log");
3904 cfg.rtblocks = calc_dev_size(cli.rtsize, &cfg, &ropts, R_SIZE, "rt");
3905
3906 validate_rtextsize(&cfg, &cli, &ft);
3907 calc_stripe_factors(&cfg, &cli, &ft);
3908
3909 /*
3910 * Open and validate the device configurations
3911 */
3912 open_devices(&cfg, &xi);
3913 validate_overwrite(dfile, force_overwrite);
3914 validate_datadev(&cfg, &cli);
3915 validate_logdev(&cfg, &cli, &logfile);
3916 validate_rtdev(&cfg, &cli, &rtfile);
3917
3918 /*
3919 * At this point when know exactly what size all the devices are,
3920 * so we can start validating and calculating layout options that are
3921 * dependent on device sizes. Once calculated, make sure everything
3922 * aligns to device geometry correctly.
3923 */
3924 calculate_initial_ag_geometry(&cfg, &cli);
3925 align_ag_geometry(&cfg);
3926
3927 calculate_imaxpct(&cfg, &cli);
3928
3929 /*
3930 * Set up the basic superblock parameters now so that we can use
3931 * the geometry information we've already validated in libxfs
3932 * provided functions to determine on-disk format information.
3933 */
3934 start_superblock_setup(&cfg, mp, sbp);
3935 initialise_mount(&cfg, mp, sbp);
3936
3937 /*
3938 * With the mount set up, we can finally calculate the log size
3939 * constraints and do default size calculations and final validation
3940 */
3941 calculate_log_size(&cfg, &cli, mp);
3942
3943 finish_superblock_setup(&cfg, mp, sbp);
3944
3945 /* Print the intended geometry of the fs. */
3946 if (!quiet || dry_run) {
3947 struct xfs_fsop_geom geo;
3948 int error;
3949
3950 error = -libxfs_fs_geometry(sbp, &geo,
3951 XFS_FS_GEOM_MAX_STRUCT_VER);
3952 if (error) {
3953 fprintf(stderr,
3954 _("%s: failed to generate filesystem geometry\n"),
3955 progname);
3956 exit(1);
3957 }
3958
3959 xfs_report_geom(&geo, dfile, logfile, rtfile);
3960 if (dry_run)
3961 exit(0);
3962 }
3963
3964 /*
3965 * All values have been validated, discard the old device layout.
3966 */
3967 if (discard && !dry_run)
3968 discard_devices(&xi);
3969
3970 /*
3971 * we need the libxfs buffer cache from here on in.
3972 */
3973 libxfs_buftarg_init(mp, xi.ddev, xi.logdev, xi.rtdev);
3974
3975 /*
3976 * Before we mount the filesystem we need to make sure the devices have
3977 * enough of the filesystem structure on them that allows libxfs to
3978 * mount.
3979 */
3980 prepare_devices(&cfg, &xi, mp, sbp, force_overwrite);
3981 mp = libxfs_mount(mp, sbp, xi.ddev, xi.logdev, xi.rtdev, 0);
3982 if (mp == NULL) {
3983 fprintf(stderr, _("%s: filesystem failed to initialize\n"),
3984 progname);
3985 exit(1);
3986 }
3987
3988 /*
3989 * Initialise all the static on disk metadata.
3990 */
3991 for (agno = 0; agno < cfg.agcount; agno++)
3992 initialise_ag_headers(&cfg, mp, sbp, agno, &worst_freelist);
3993
3994 /*
3995 * Initialise the freespace freelists (i.e. AGFLs) in each AG.
3996 */
3997 for (agno = 0; agno < cfg.agcount; agno++)
3998 initialise_ag_freespace(mp, agno, worst_freelist);
3999
4000 /*
4001 * Allocate the root inode and anything else in the proto file.
4002 */
4003 parse_proto(mp, &cli.fsx, &protostring);
4004
4005 /*
4006 * Protect ourselves against possible stupidity
4007 */
4008 if (XFS_INO_TO_AGNO(mp, mp->m_sb.sb_rootino) != 0) {
4009 fprintf(stderr,
4010 _("%s: root inode created in AG %u, not AG 0\n"),
4011 progname, XFS_INO_TO_AGNO(mp, mp->m_sb.sb_rootino));
4012 exit(1);
4013 }
4014
4015 /*
4016 * Re-write multiple secondary superblocks with rootinode field set
4017 */
4018 if (mp->m_sb.sb_agcount > 1)
4019 rewrite_secondary_superblocks(mp);
4020
4021 /*
4022 * Dump all inodes and buffers before marking us all done.
4023 * Need to drop references to inodes we still hold, first.
4024 */
4025 libxfs_rtmount_destroy(mp);
4026 libxfs_bcache_purge();
4027
4028 /*
4029 * Mark the filesystem ok.
4030 */
4031 buf = libxfs_getsb(mp, LIBXFS_EXIT_ON_FAILURE);
4032 (XFS_BUF_TO_SBP(buf))->sb_inprogress = 0;
4033 libxfs_writebuf(buf, LIBXFS_EXIT_ON_FAILURE);
4034
4035 libxfs_umount(mp);
4036 if (xi.rtdev)
4037 libxfs_device_close(xi.rtdev);
4038 if (xi.logdev && xi.logdev != xi.ddev)
4039 libxfs_device_close(xi.logdev);
4040 libxfs_device_close(xi.ddev);
4041 libxfs_destroy();
4042
4043 return 0;
4044 }
Unnamed repository; edit this file 'description' to name the repository.