2 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 #include <xfs/libxlog.h>
20 #include <sys/resource.h>
28 #include "err_protos.h"
33 #define rounddown(x, y) (((x)/(y))*(y))
35 #define XR_MAX_SECT_SIZE (64 * 1024)
38 * option tables for getsubopt calls
42 * -o: user-supplied override options
44 static char *o_opts
[] = {
57 #define PHASE2_THREADS 6
63 * -c: conversion options
65 static char *c_opts
[] = {
66 #define CONVERT_LAZY_COUNT 0
72 static int bhash_option_used
;
73 static long max_mem_specified
; /* in megabytes */
74 static int phase2_threads
= 32;
80 "Usage: %s [options] device\n"
83 " -f The device is a file\n"
84 " -L Force log zeroing. Do this as a last resort.\n"
85 " -l logdev Specifies the device where the external log resides.\n"
86 " -m maxmem Maximum amount of memory to be used in megabytes.\n"
87 " -n No modify mode, just checks the filesystem for damage.\n"
88 " -P Disables prefetching.\n"
89 " -r rtdev Specifies the device where the realtime section resides.\n"
90 " -v Verbose output.\n"
91 " -c subopts Change filesystem parameters - use xfs_admin.\n"
92 " -o subopts Override default behaviour, refer to man page.\n"
93 " -t interval Reporting interval in minutes.\n"
94 " -d Repair dangerously.\n"
95 " -V Reports version and exits.\n"), progname
);
100 err_string(int err_code
)
102 static char *err_message
[XR_BAD_ERR_CODE
];
106 err_message
[XR_OK
] = _("no error");
107 err_message
[XR_BAD_MAGIC
] = _("bad magic number");
108 err_message
[XR_BAD_BLOCKSIZE
] = _("bad blocksize field");
109 err_message
[XR_BAD_BLOCKLOG
] = _("bad blocksize log field");
110 err_message
[XR_BAD_VERSION
] = _("bad or unsupported version");
111 err_message
[XR_BAD_INPROGRESS
] =
112 _("filesystem mkfs-in-progress bit set");
113 err_message
[XR_BAD_FS_SIZE_DATA
] =
114 _("inconsistent filesystem geometry information");
115 err_message
[XR_BAD_INO_SIZE_DATA
] =
116 _("bad inode size or inconsistent with number of inodes/block"),
117 err_message
[XR_BAD_SECT_SIZE_DATA
] = _("bad sector size");
118 err_message
[XR_AGF_GEO_MISMATCH
] =
119 _("AGF geometry info conflicts with filesystem geometry");
120 err_message
[XR_AGI_GEO_MISMATCH
] =
121 _("AGI geometry info conflicts with filesystem geometry");
122 err_message
[XR_SB_GEO_MISMATCH
] =
123 _("AG superblock geometry info conflicts with filesystem geometry");
124 err_message
[XR_EOF
] = _("attempted to perform I/O beyond EOF");
125 err_message
[XR_BAD_RT_GEO_DATA
] =
126 _("inconsistent filesystem geometry in realtime filesystem component");
127 err_message
[XR_BAD_INO_MAX_PCT
] =
128 _("maximum indicated percentage of inodes > 100%");
129 err_message
[XR_BAD_INO_ALIGN
] =
130 _("inconsistent inode alignment value");
131 err_message
[XR_INSUFF_SEC_SB
] =
132 _("not enough secondary superblocks with matching geometry");
133 err_message
[XR_BAD_SB_UNIT
] =
134 _("bad stripe unit in superblock");
135 err_message
[XR_BAD_SB_WIDTH
] =
136 _("bad stripe width in superblock");
137 err_message
[XR_BAD_SVN
] =
138 _("bad shared version number in superblock");
142 if (err_code
< XR_OK
|| err_code
>= XR_BAD_ERR_CODE
)
143 do_abort(_("bad error code - %d\n"), err_code
);
145 return(err_message
[err_code
]);
149 noval(char opt
, char *tbl
[], int idx
)
151 do_warn(_("-%c %s option cannot have a value\n"), opt
, tbl
[idx
]);
156 respec(char opt
, char *tbl
[], int idx
)
158 do_warn("-%c ", opt
);
160 do_warn("%s ", tbl
[idx
]);
161 do_warn(_("option respecified\n"));
166 unknown(char opt
, char *s
)
168 do_warn(_("unknown option -%c %s\n"), opt
, s
);
173 * sets only the global argument flags and variables
176 process_args(int argc
, char **argv
)
189 full_ino_ex_data
= 0;
197 fs_attributes_allowed
= 1;
198 fs_attributes2_allowed
= 1;
199 fs_inode_nlink_allowed
= 1;
200 fs_quotas_allowed
= 1;
201 fs_aligned_inodes_allowed
= 1;
202 fs_sb_feature_bits_allowed
= 1;
203 fs_has_extflgbit_allowed
= 1;
205 fs_shared_allowed
= 1;
208 report_interval
= PROG_RPT_DEFAULT
;
211 * XXX have to add suboption processing here
212 * attributes, quotas, nlinks, aligned_inos, sb_fbits
214 while ((c
= getopt(argc
, argv
, "c:o:fl:m:r:LnDvVdPt:")) != EOF
) {
224 switch (getsubopt(&p
, (constpp
)o_opts
, &val
)) {
227 noval('o', o_opts
, ASSUME_XFS
);
229 respec('o', o_opts
, ASSUME_XFS
);
234 noval('o', o_opts
, PRE_65_BETA
);
242 _("-o ihash option has been removed and will be ignored\n"));
245 if (max_mem_specified
)
247 _("-o bhash option cannot be used with -m option\n"));
248 libxfs_bhash_size
= (int)strtol(val
, NULL
, 0);
249 bhash_option_used
= 1;
252 ag_stride
= (int)strtol(val
, NULL
, 0);
256 noval('o', o_opts
, FORCE_GEO
);
258 respec('o', o_opts
, FORCE_GEO
);
262 phase2_threads
= (int)strtol(val
, NULL
, 0);
275 switch (getsubopt(&p
, (constpp
)c_opts
, &val
)) {
276 case CONVERT_LAZY_COUNT
:
277 lazy_count
= (int)strtol(val
, NULL
, 0);
278 convert_lazy_count
= 1;
298 if (bhash_option_used
)
299 do_abort(_("-m option cannot be used with "
300 "-o bhash option\n"));
301 max_mem_specified
= strtol(optarg
, NULL
, 0);
316 printf(_("%s version %s\n"), progname
, VERSION
);
322 report_interval
= (int)strtol(optarg
, NULL
, 0);
329 if (argc
- optind
!= 1)
332 if ((fs_name
= argv
[optind
]) == NULL
)
336 void __attribute__((noreturn
))
337 do_error(char const *msg
, ...)
341 fprintf(stderr
, _("\nfatal error -- "));
344 vfprintf(stderr
, msg
, args
);
351 * like do_error, only the error is internal, no system
352 * error so no oserror processing
354 void __attribute__((noreturn
))
355 do_abort(char const *msg
, ...)
360 vfprintf(stderr
, msg
, args
);
367 do_warn(char const *msg
, ...)
374 vfprintf(stderr
, msg
, args
);
381 do_log(char const *msg
, ...)
386 vfprintf(stderr
, msg
, args
);
391 calc_mkfs(xfs_mount_t
*mp
)
393 xfs_agblock_t fino_bno
;
396 do_inoalign
= mp
->m_sinoalign
;
399 * pre-calculate geometry of ag 0. We know what it looks
400 * like because we know what mkfs does -- 3 btree roots,
401 * and some number of blocks to prefill the agfl.
403 bnobt_root
= howmany(4 * mp
->m_sb
.sb_sectsize
, mp
->m_sb
.sb_blocksize
);
404 bcntbt_root
= bnobt_root
+ 1;
405 inobt_root
= bnobt_root
+ 2;
406 fino_bno
= inobt_root
+ XFS_MIN_FREELIST_RAW(1, 1, mp
) + 1;
409 * If the log is allocated in the first allocation group we need to
410 * add the number of blocks used by the log to the above calculation.
412 * This can happens with filesystems that only have a single
413 * allocation group, or very odd geometries created by old mkfs
414 * versions on very small filesystems.
416 if (mp
->m_sb
.sb_logstart
&&
417 XFS_FSB_TO_AGNO(mp
, mp
->m_sb
.sb_logstart
) == 0) {
420 * XXX(hch): verify that sb_logstart makes sense?
422 fino_bno
+= mp
->m_sb
.sb_logblocks
;
426 * ditto the location of the first inode chunks in the fs ('/')
428 if (xfs_sb_version_hasdalign(&mp
->m_sb
) && do_inoalign
) {
429 first_prealloc_ino
= XFS_OFFBNO_TO_AGINO(mp
, roundup(fino_bno
,
430 mp
->m_sb
.sb_unit
), 0);
431 } else if (xfs_sb_version_hasalign(&mp
->m_sb
) &&
432 mp
->m_sb
.sb_inoalignmt
> 1) {
433 first_prealloc_ino
= XFS_OFFBNO_TO_AGINO(mp
,
435 mp
->m_sb
.sb_inoalignmt
),
438 first_prealloc_ino
= XFS_OFFBNO_TO_AGINO(mp
, fino_bno
, 0);
441 ASSERT(XFS_IALLOC_BLOCKS(mp
) > 0);
443 if (XFS_IALLOC_BLOCKS(mp
) > 1)
444 last_prealloc_ino
= first_prealloc_ino
+ XFS_INODES_PER_CHUNK
;
446 last_prealloc_ino
= XFS_OFFBNO_TO_AGINO(mp
, fino_bno
+ 1, 0);
449 * now the first 3 inodes in the system
451 if (mp
->m_sb
.sb_rootino
!= first_prealloc_ino
) {
453 _("sb root inode value %" PRIu64
" %sinconsistent with calculated value %u\n"),
455 (mp
->m_sb
.sb_rootino
== NULLFSINO
? "(NULLFSINO) ":""),
460 _("resetting superblock root inode pointer to %u\n"),
464 _("would reset superblock root inode pointer to %u\n"),
468 * just set the value -- safe since the superblock
469 * doesn't get flushed out if no_modify is set
471 mp
->m_sb
.sb_rootino
= first_prealloc_ino
;
474 if (mp
->m_sb
.sb_rbmino
!= first_prealloc_ino
+ 1) {
476 _("sb realtime bitmap inode %" PRIu64
" %sinconsistent with calculated value %u\n"),
478 (mp
->m_sb
.sb_rbmino
== NULLFSINO
? "(NULLFSINO) ":""),
479 first_prealloc_ino
+ 1);
483 _("resetting superblock realtime bitmap ino pointer to %u\n"),
484 first_prealloc_ino
+ 1);
487 _("would reset superblock realtime bitmap ino pointer to %u\n"),
488 first_prealloc_ino
+ 1);
491 * just set the value -- safe since the superblock
492 * doesn't get flushed out if no_modify is set
494 mp
->m_sb
.sb_rbmino
= first_prealloc_ino
+ 1;
497 if (mp
->m_sb
.sb_rsumino
!= first_prealloc_ino
+ 2) {
499 _("sb realtime summary inode %" PRIu64
" %sinconsistent with calculated value %u\n"),
501 (mp
->m_sb
.sb_rsumino
== NULLFSINO
? "(NULLFSINO) ":""),
502 first_prealloc_ino
+ 2);
506 _("resetting superblock realtime summary ino pointer to %u\n"),
507 first_prealloc_ino
+ 2);
510 _("would reset superblock realtime summary ino pointer to %u\n"),
511 first_prealloc_ino
+ 2);
514 * just set the value -- safe since the superblock
515 * doesn't get flushed out if no_modify is set
517 mp
->m_sb
.sb_rsumino
= first_prealloc_ino
+ 2;
523 main(int argc
, char **argv
)
525 xfs_mount_t
*temp_mp
;
532 progname
= basename(argv
[0]);
533 setlocale(LC_ALL
, "");
534 bindtextdomain(PACKAGE
, LOCALEDIR
);
538 setbuf(stdout
, NULL
);
540 process_args(argc
, argv
);
543 msgbuf
= malloc(DURATION_BUF_SIZE
);
545 timestamp(PHASE_START
, 0, NULL
);
546 timestamp(PHASE_END
, 0, NULL
);
548 /* do phase1 to make sure we have a superblock */
550 timestamp(PHASE_END
, 1, NULL
);
552 if (no_modify
&& primary_sb_modified
) {
553 do_warn(_("Primary superblock would have been modified.\n"
554 "Cannot proceed further in no_modify mode.\n"
559 /* prepare the mount structure */
560 memset(&xfs_m
, 0, sizeof(xfs_mount_t
));
561 libxfs_buftarg_init(&xfs_m
, x
.ddev
, x
.logdev
, x
.rtdev
);
562 sbp
= libxfs_readbuf(xfs_m
.m_ddev_targp
, XFS_SB_DADDR
,
563 1 << (XFS_MAX_SECTORSIZE_LOG
- BBSHIFT
), 0,
565 libxfs_sb_from_disk(&xfs_m
.m_sb
, XFS_BUF_TO_SBP(sbp
));
568 * if the sector size of the filesystem we are trying to repair is
569 * smaller than that of the underlying filesystem (i.e. we are repairing
570 * an image), the we have to turn off direct IO because we cannot do IO
571 * smaller than the host filesystem's sector size.
574 int fd
= libxfs_device_to_fd(x
.ddev
);
575 struct xfs_fsop_geom_v1 geom
= { 0 };
577 if (ioctl(fd
, XFS_IOC_FSGEOMETRY_V1
, &geom
) < 0) {
578 do_warn(_("Cannot get host filesystem geometry.\n"
579 "Repair may fail if there is a sector size mismatch between\n"
580 "the image and the host filesystem.\n"));
581 geom
.sectsize
= BBSIZE
;
584 if (xfs_m
.m_sb
.sb_sectsize
< geom
.sectsize
) {
587 old_flags
= fcntl(fd
, F_GETFL
, 0);
588 if (fcntl(fd
, F_SETFL
, old_flags
& ~O_DIRECT
) < 0) {
590 "Sector size on host filesystem larger than image sector size.\n"
591 "Cannot turn off direct IO, so exiting.\n"));
596 mp
= libxfs_mount(&xfs_m
, &xfs_m
.m_sb
, x
.ddev
, x
.logdev
, x
.rtdev
, 0);
600 _("%s: cannot repair this filesystem. Sorry.\n"),
605 libxfs_purgebuf(sbp
);
608 * set XFS-independent status vars from the mount/sb structure
610 glob_agcount
= mp
->m_sb
.sb_agcount
;
612 chunks_pblock
= mp
->m_sb
.sb_inopblock
/ XFS_INODES_PER_CHUNK
;
613 max_symlink_blocks
= libxfs_symlink_blocks(mp
, MAXPATHLEN
);
614 inodes_per_cluster
= MAX(mp
->m_sb
.sb_inopblock
,
615 XFS_INODE_CLUSTER_SIZE(mp
) >> mp
->m_sb
.sb_inodelog
);
618 thread_count
= (glob_agcount
+ ag_stride
- 1) / ag_stride
;
622 if (ag_stride
&& report_interval
) {
625 do_log(_(" - reporting progress in intervals of %s\n"),
626 duration(report_interval
, msgbuf
));
631 * Adjust libxfs cache sizes based on system memory,
632 * filesystem size and inode count.
634 * We'll set the cache size based on 3/4s the memory minus
635 * space used by the inode AVL tree and block usage map.
637 * Inode AVL tree space is approximately 4 bytes per inode,
638 * block usage map is currently 1 byte for 2 blocks.
640 * We assume most blocks will be inode clusters.
642 * Calculations are done in kilobyte units.
645 if (!bhash_option_used
|| max_mem_specified
) {
646 unsigned long mem_used
;
647 unsigned long max_mem
;
650 libxfs_bcache_purge();
651 cache_destroy(libxfs_bcache
);
653 mem_used
= (mp
->m_sb
.sb_icount
>> (10 - 2)) +
654 (mp
->m_sb
.sb_dblocks
>> (10 + 1)) +
655 50000; /* rough estimate of 50MB overhead */
656 max_mem
= max_mem_specified
? max_mem_specified
* 1024 :
657 libxfs_physmem() * 3 / 4;
659 if (getrlimit(RLIMIT_AS
, &rlim
) != -1 &&
660 rlim
.rlim_cur
!= RLIM_INFINITY
) {
661 rlim
.rlim_cur
= rlim
.rlim_max
;
662 setrlimit(RLIMIT_AS
, &rlim
);
663 /* use approximately 80% of rlimit to avoid overrun */
664 max_mem
= MIN(max_mem
, rlim
.rlim_cur
/ 1280);
666 max_mem
= MIN(max_mem
, (LONG_MAX
>> 10) + 1);
670 _(" - max_mem = %lu, icount = %" PRIu64
", imem = %" PRIu64
", dblock = %" PRIu64
", dmem = %" PRIu64
"\n"),
671 max_mem
, mp
->m_sb
.sb_icount
,
672 mp
->m_sb
.sb_icount
>> (10 - 2),
674 mp
->m_sb
.sb_dblocks
>> (10 + 1));
676 if (max_mem
<= mem_used
) {
678 * Turn off prefetch and minimise libxfs cache if
679 * physical memory is deemed insufficient
681 if (max_mem_specified
) {
683 _("Required memory for repair is greater that the maximum specified\n"
684 "with the -m option. Please increase it to at least %lu.\n"),
688 _("Not enough RAM available for repair to enable prefetching.\n"
689 "This will be _slow_.\n"
690 "You need at least %luMB RAM to run with prefetching enabled.\n"),
691 mem_used
* 1280 / (1024 * 1024));
694 libxfs_bhash_size
= 64;
697 if (max_mem
>= (1 << 30))
699 libxfs_bhash_size
= max_mem
/ (HASH_CACHE_RATIO
*
700 (mp
->m_inode_cluster_size
>> 10));
701 if (libxfs_bhash_size
< 512)
702 libxfs_bhash_size
= 512;
706 do_log(_(" - block cache size set to %d entries\n"),
707 libxfs_bhash_size
* HASH_CACHE_RATIO
);
709 libxfs_bcache
= cache_init(libxfs_bhash_size
,
710 &libxfs_bcache_operations
);
714 * calculate what mkfs would do to this filesystem
719 * initialize block alloc map
725 /* initialize random globals now that we know the fs geometry */
726 inodes_per_block
= mp
->m_sb
.sb_inopblock
;
728 if (parse_sb_version(&mp
->m_sb
)) {
730 _("Found unsupported filesystem features. Exiting now.\n"));
734 /* make sure the per-ag freespace maps are ok so we can mount the fs */
735 phase2(mp
, phase2_threads
);
736 timestamp(PHASE_END
, 2, NULL
);
742 timestamp(PHASE_END
, 3, NULL
);
745 timestamp(PHASE_END
, 4, NULL
);
748 printf(_("No modify flag set, skipping phase 5\n"));
752 timestamp(PHASE_END
, 5, NULL
);
755 * Done with the block usage maps, toss them...
759 if (!bad_ino_btree
) {
761 timestamp(PHASE_END
, 6, NULL
);
764 timestamp(PHASE_END
, 7, NULL
);
767 _("Inode allocation btrees are too corrupted, skipping phases 6 and 7\n"));
770 if (lost_quotas
&& !have_uquotino
&& !have_gquotino
&& !have_pquotino
) {
773 _("Warning: no quota inodes were found. Quotas disabled.\n"));
776 _("Warning: no quota inodes were found. Quotas would be disabled.\n"));
778 } else if (lost_quotas
) {
781 _("Warning: quota inodes were cleared. Quotas disabled.\n"));
784 _("Warning: quota inodes would be cleared. Quotas would be disabled.\n"));
790 _("Warning: user quota information was cleared.\n"
791 "User quotas can not be enforced until limit information is recreated.\n"));
794 _("Warning: user quota information would be cleared.\n"
795 "User quotas could not be enforced until limit information was recreated.\n"));
802 _("Warning: group quota information was cleared.\n"
803 "Group quotas can not be enforced until limit information is recreated.\n"));
806 _("Warning: group quota information would be cleared.\n"
807 "Group quotas could not be enforced until limit information was recreated.\n"));
814 _("Warning: project quota information was cleared.\n"
815 "Project quotas can not be enforced until limit information is recreated.\n"));
818 _("Warning: project quota information would be cleared.\n"
819 "Project quotas could not be enforced until limit information was recreated.\n"));
824 if (ag_stride
&& report_interval
)
829 _("No modify flag set, skipping filesystem flush and exiting.\n"));
839 * Clear the quota flags if they're on.
841 sbp
= libxfs_getsb(mp
, 0);
843 do_error(_("couldn't get superblock\n"));
845 dsb
= XFS_BUF_TO_SBP(sbp
);
847 if (be16_to_cpu(dsb
->sb_qflags
) & XFS_ALL_QUOTA_CHKD
) {
848 do_warn(_("Note - quota info will be regenerated on next "
850 dsb
->sb_qflags
&= cpu_to_be16(~XFS_ALL_QUOTA_CHKD
);
855 _("Note - stripe unit (%d) and width (%d) fields have been reset.\n"
856 "Please set with mount -o sunit=<value>,swidth=<value>\n"),
857 be32_to_cpu(dsb
->sb_unit
), be32_to_cpu(dsb
->sb_width
));
862 libxfs_writebuf(sbp
, 0);
865 * Done, flush all cached buffers and inodes.
867 libxfs_bcache_flush();
871 libxfs_device_close(x
.rtdev
);
872 if (x
.logdev
&& x
.logdev
!= x
.ddev
)
873 libxfs_device_close(x
.logdev
);
874 libxfs_device_close(x
.ddev
);