/*
* main()
*
*/
int main(int argc, char **argv)
{
ocfs2_filesys *fs = NULL;
errcode_t ret = 0;
int i;
initialize_ocfs_error_table();
#define INSTALL_SIGNAL(sig) \
do { \
if (signal(sig, handle_signal) == SIG_ERR) { \
fprintf(stderr, "Could not set " #sig "\n");\
goto bail; \
} \
} while (0)
INSTALL_SIGNAL(SIGTERM);
INSTALL_SIGNAL(SIGINT);
memset(corrupt, 0, sizeof(corrupt));
ret = read_options(argc, argv);
if (ret < 0)
goto bail;
print_version();
ret = ocfs2_open(device, OCFS2_FLAG_RW, 0, 0, &fs);
if (ret) {
com_err(progname, ret, "while opening \"%s\"", device);
goto bail;
}
for (i = 0; i < NUM_FSCK_TYPE; ++i) {
if (corrupt[i]) {
if (!prompt_codes[i].pc_func) {
fprintf(stderr, "Unimplemented corrupt code "
"= %s\n", prompt_codes[i].pc_codestr);
continue;
}
fprintf(stdout, "%s: Corrupting %s with code %s (%d)\n",
progname, device, prompt_codes[i].pc_codestr,
prompt_codes[i].pc_codenum);
prompt_codes[i].pc_func(fs, prompt_codes[i].pc_codenum,
slotnum);
}
}
bail:
if (fs) {
ret = ocfs2_close(fs);
if (ret)
com_err(progname, ret, "while closing \"%s\"", device);
}
return ret;
} /* main */
static void
fs_dealloc (Filesystem *self)
{
if (self->fs)
ocfs2_close (self->fs);
Py_XDECREF (self->device);
PyObject_DEL (self);
}
int main (int argc, char **argv)
{
ocfs2_filesys *fs = NULL;
errcode_t ret = 1;
initialize_ocfs_error_table();
#define INSTALL_SIGNAL(sig) \
do { \
if (signal(sig, handle_signal) == SIG_ERR) { \
printf("Could not set " #sig "\n"); \
goto bail; \
} \
} while (0)
INSTALL_SIGNAL(SIGTERM);
INSTALL_SIGNAL(SIGINT);
memset(&options, 0, sizeof(options));
if (read_options(argc, argv)) {
usage(progname);
goto bail;
}
if (!device || !options.ops)
goto bail;
ret = ocfs2_open(device, OCFS2_FLAG_RW, 0, 0, &fs);
if (ret) {
com_err(progname, ret, "while opening \"%s\"", device);
goto bail;
}
srand((unsigned long)fs);
switch (options.ops) {
case CREATE_LOCAL_ALLOC:
ret = create_local_alloc(fs, options.slot);
break;
case CREATE_ORPHAN_FILE:
ret = create_orphan_file(fs, options.slot);
break;
case CREATE_TRUNCATE_LOG:
ret = create_truncate_log(fs, options.slot);
break;
}
bail:
if (fs)
ocfs2_close(fs);
return ret;
}
static errcode_t maybe_replay_journals(o2fsck_state *ost, char *filename,
int open_flags, uint64_t blkno,
uint64_t blksize)
{
int replayed = 0, should = 0, has_dirty = 0;
errcode_t ret = 0;
ret = o2fsck_should_replay_journals(ost->ost_fs, &should, &has_dirty);
if (ret)
goto out;
ost->ost_has_journal_dirty = has_dirty ? 1 : 0;
if (!should)
goto out;
if (!(ost->ost_fs->fs_flags & OCFS2_FLAG_RW)) {
printf("** Skipping journal replay because -n was "
"given. There may be spurious errors that "
"journal replay would fix. **\n");
goto out;
}
printf("%s wasn't cleanly unmounted by all nodes. Attempting to "
"replay the journals for nodes that didn't unmount cleanly\n",
filename);
/* journal replay is careful not to use ost as we only really
* build it up after spraying the journal all over the disk
* and reopening */
ret = o2fsck_replay_journals(ost->ost_fs, &replayed);
if (ret)
goto out;
/* if the journals were replayed we close the fs and start
* over */
if (!replayed)
goto out;
ret = ocfs2_close(ost->ost_fs);
if (ret) {
com_err(whoami, ret, "while closing \"%s\"", filename);
goto out;
}
ret = open_and_check(ost, filename, open_flags, blkno, blksize);
out:
return ret;
}
static errcode_t recover_backup_super(o2fsck_state *ost,
char* device, int sb_num)
{
errcode_t ret;
uint64_t offsets[OCFS2_MAX_BACKUP_SUPERBLOCKS], blksize, sb;
ocfs2_filesys *fs = NULL;
if (sb_num < 1 || sb_num > OCFS2_MAX_BACKUP_SUPERBLOCKS)
return -1;
ocfs2_get_backup_super_offsets(NULL, offsets, ARRAY_SIZE(offsets));
/* iterate all the blocksize to get the right one. */
for (blksize = OCFS2_MIN_BLOCKSIZE;
blksize <= OCFS2_MAX_BLOCKSIZE; blksize <<= 1) {
sb = offsets[sb_num - 1] / blksize;
/* Here we just give the possible value of block num and
* block size to ocfs2_open and this function will check
* them and return '0' if they meet the right one.
*/
ret = ocfs2_open(device, OCFS2_FLAG_RW, sb, blksize, &fs);
if (!ret)
break;
}
if (ret)
goto bail;
/* recover the backup information to superblock. */
if (prompt(ost, PN, PR_RECOVER_BACKUP_SUPERBLOCK,
"Recover superblock information from backup block"
"#%"PRIu64"?", sb)) {
fs->fs_super->i_blkno = OCFS2_SUPER_BLOCK_BLKNO;
ret = ocfs2_write_primary_super(fs);
if (ret)
goto bail;
}
/* no matter whether the user recover the superblock or not above,
* we should return 0 in case the superblock can be opened
* without the recovery.
*/
ret = 0;
bail:
if (fs)
ocfs2_close(fs);
return ret;
}
static void handle_signal(int sig)
{
switch (sig) {
case SIGTERM:
case SIGINT:
printf("\nProcess Interrupted.\n");
if (cluster_locked && _ost.ost_fs->fs_dlm_ctxt) {
ocfs2_release_cluster(_ost.ost_fs);
cluster_locked = 0;
}
if (_ost.ost_fs->fs_dlm_ctxt)
ocfs2_shutdown_dlm(_ost.ost_fs, whoami);
if (_ost.ost_fs)
ocfs2_close(_ost.ost_fs);
exit(1);
}
return ;
}
int main(int argc, char *argv[])
{
errcode_t ret;
uint64_t blkno;
char *filename;
ocfs2_filesys *fs;
struct walk_path wp;
blkno = OCFS2_SUPER_BLOCK_BLKNO;
initialize_ocfs_error_table();
wp.argv0 = argv[0];
wp.quiet = 0;
wp.has_dups = 0;
wp.check_dups = 0;
if (argc < 2) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[1];
if (argc > 2) {
if (!strcmp(argv[2], "-q"))
wp.quiet = 1;
}
ret = ocfs2_open(filename, OCFS2_FLAG_RO, 0, 0, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
wp.fs = fs;
ret = ocfs2_block_bitmap_new(fs, "Inode bitmap", &wp.inode_map);
if (ret) {
com_err(argv[0], ret,
"while creating the inode bitmap");
goto out_close;
}
ret = ocfs2_block_bitmap_new(fs, "Duplicate inode bitmap",
&wp.dup_map);
if (ret) {
com_err(argv[0], ret,
"while creating the duplicate inode bitmap");
goto out_close;
}
ocfs2_bitmap_set(wp.inode_map,
OCFS2_RAW_SB(fs->fs_super)->s_system_dir_blkno,
NULL);
ocfs2_bitmap_set(wp.inode_map,
OCFS2_RAW_SB(fs->fs_super)->s_root_blkno,
NULL);
fprintf(stdout, "Walking system directory...\n");
wp.path = "<system_dir>/";
ret = ocfs2_dir_iterate(fs,
OCFS2_RAW_SB(fs->fs_super)->s_system_dir_blkno,
0, NULL, walk_tree_func, &wp);
if (ret) {
com_err(argv[0], ret,
"while walking sysdm dir inode %"PRIu64" on \"%s\"\n",
blkno, filename);
goto out_close;
}
wp.path = "/";
fprintf(stdout, "Walking root directory...\n");
ret = ocfs2_dir_iterate(fs,
OCFS2_RAW_SB(fs->fs_super)->s_root_blkno,
0, NULL, walk_tree_func, &wp);
if (ret) {
com_err(argv[0], ret,
"while walking root inode %"PRIu64" on \"%s\"\n",
blkno, filename);
goto out_close;
}
if (wp.has_dups) {
fprintf(stdout, "Hardlinks found\n");
wp.check_dups = 1;
fprintf(stdout, "Scanning system directory for dups...\n");
wp.path = "<system_dir>/";
ret = ocfs2_dir_iterate(fs,
OCFS2_RAW_SB(fs->fs_super)->s_system_dir_blkno,
0, NULL, walk_tree_func, &wp);
if (ret) {
com_err(argv[0], ret,
"while dup scanning sysdm dir inode %"PRIu64
" on \"%s\"\n",
blkno, filename);
goto out_close;
}
wp.path = "/";
fprintf(stdout, "Scanning root directory for dups...\n");
ret = ocfs2_dir_iterate(fs,
OCFS2_RAW_SB(fs->fs_super)->s_root_blkno,
0, NULL, walk_tree_func, &wp);
if (ret) {
com_err(argv[0], ret,
"while dup scanning root inode %"PRIu64
" on \"%s\"\n",
blkno, filename);
goto out_close;
}
}
out_close:
ret = ocfs2_close(fs);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return 0;
}
int main(int argc, char *argv[])
{
errcode_t ret;
int c;
uint64_t blkno = 0, new_size = 0;
ocfs2_filesys *fs;
char *device;
initialize_ocfs_error_table();
while ((c = getopt(argc, argv, "i:s:")) != EOF) {
switch (c) {
case 'i':
blkno = read_number(optarg);
if (blkno <= OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid inode block: %s\n",
optarg);
print_usage();
return 1;
}
break;
case 's':
new_size = read_number(optarg);
break;
default:
print_usage();
return 1;
break;
}
}
if (optind >= argc) {
fprintf(stderr, "Missing device name\n");
print_usage();
return 1;
}
device = argv[optind];
if (!blkno || !new_size) {
print_usage();
return 1;
}
ret = ocfs2_open(device, OCFS2_FLAG_RW, 0, 0, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", device);
return ret;
}
ret = ocfs2_truncate(fs, blkno, new_size);
if (ret)
com_err(argv[0], ret, "while truncating inode %"PRIu64, blkno);
ocfs2_close(fs);
return ret;
}
int main(int argc, char **argv)
{
errcode_t ret = 0;
struct mount_options mo;
ocfs2_filesys *fs = NULL;
struct o2cb_cluster_desc cluster;
struct o2cb_region_desc desc;
int clustered = 1;
int group_join = 0;
struct stat statbuf;
const char *spec;
char *opts_string = NULL;
initialize_ocfs_error_table();
initialize_o2dl_error_table();
initialize_o2cb_error_table();
setbuf(stdout, NULL);
setbuf(stderr, NULL);
if (signal(SIGTERM, handle_signal) == SIG_ERR) {
fprintf(stderr, "Could not set SIGTERM\n");
exit(1);
}
if (signal(SIGINT, handle_signal) == SIG_ERR) {
fprintf(stderr, "Could not set SIGINT\n");
exit(1);
}
memset(&mo, 0, sizeof(mo));
read_options (argc, argv, &mo);
ret = process_options(&mo);
if (ret)
goto bail;
ret = ocfs2_open(mo.dev, OCFS2_FLAG_RO, 0, 0, &fs); //O_EXCL?
if (ret) {
com_err(progname, ret, "while opening device %s", mo.dev);
goto bail;
}
clustered = (0 == ocfs2_mount_local(fs));
if (ocfs2_is_hard_readonly(fs) && (clustered ||
!(mo.flags & MS_RDONLY))) {
ret = OCFS2_ET_IO;
com_err(progname, ret,
"while mounting read-only device in %s mode",
(clustered ? "clustered" : "read-write"));
goto bail;
}
if (verbose)
printf("device=%s\n", mo.dev);
ret = o2cb_setup_stack((char *)OCFS2_RAW_SB(fs->fs_super)->s_cluster_info.ci_stack);
if (ret) {
com_err(progname, ret, "while setting up stack\n");
goto bail;
}
if (clustered) {
ret = o2cb_init();
if (ret) {
com_err(progname, ret, "while trying initialize cluster");
goto bail;
}
ret = ocfs2_fill_cluster_desc(fs, &cluster);
if (ret) {
com_err(progname, ret,
"while trying to determine cluster information");
goto bail;
}
ret = ocfs2_fill_heartbeat_desc(fs, &desc);
if (ret) {
com_err(progname, ret,
"while trying to determine heartbeat information");
goto bail;
}
desc.r_persist = 1;
desc.r_service = OCFS2_FS_NAME;
}
ret = add_mount_options(fs, &cluster, &mo.xtra_opts);
if (ret) {
com_err(progname, ret, "while adding mount options");
goto bail;
}
/* validate mount dir */
if (lstat(mo.dir, &statbuf)) {
com_err(progname, 0, "mount directory %s does not exist",
mo.dir);
goto bail;
} else if (stat(mo.dir, &statbuf)) {
com_err(progname, 0, "mount directory %s is a broken symbolic "
"link", mo.dir);
goto bail;
} else if (!S_ISDIR(statbuf.st_mode)) {
com_err(progname, 0, "mount directory %s is not a directory",
mo.dir);
goto bail;
}
block_signals (SIG_BLOCK);
if (clustered && !(mo.flags & MS_REMOUNT)) {
ret = o2cb_begin_group_join(&cluster, &desc);
if (ret) {
block_signals (SIG_UNBLOCK);
com_err(progname, ret,
"while trying to join the group");
goto bail;
}
group_join = 1;
}
spec = canonicalize(mo.dev);
ret = mount(spec, mo.dir, OCFS2_FS_NAME, mo.flags & ~MS_NOSYS,
mo.xtra_opts);
if (ret) {
ret = errno;
if (group_join) {
/* We ignore the return code because the mount
* failure is the important error.
* complete_group_join() will handle cleaning up */
o2cb_complete_group_join(&cluster, &desc, errno);
}
block_signals (SIG_UNBLOCK);
if (ret == -EROFS)
com_err(progname, OCFS2_ET_RO_FILESYS, "while mounting %s "
"on %s, please try fixing this by fsck.ocfs2 and then "
"retry mounting", mo.dev, mo.dir);
else
com_err(progname, OCFS2_ET_INTERNAL_FAILURE,
"while mounting %s on %s. Check 'dmesg' for more "
"information on this error %d.", mo.dev, mo.dir,
(int)ret);
goto bail;
}
if (group_join) {
ret = o2cb_complete_group_join(&cluster, &desc, 0);
if (ret) {
com_err(progname, ret,
"while completing group join (WARNING)");
/*
* XXX: GFS2 allows the mount to continue, so we
* will do the same. I don't know how clean that
* is, but I don't have a better solution.
*/
ret = 0;
}
}
change_local_hb_io_priority(fs, mo.dev);
opts_string = fix_opts_string(((mo.flags & ~MS_NOMTAB) |
(clustered ? MS_NETDEV : 0)),
mo.xtra_opts, NULL);
update_mtab_entry(mo.dev, mo.dir, OCFS2_FS_NAME, opts_string,
mo.flags, 0, 0);
block_signals (SIG_UNBLOCK);
bail:
if (fs)
ocfs2_close(fs);
if (mo.dev)
free(mo.dev);
if (mo.dir)
free(mo.dir);
if (mo.opts)
free(mo.opts);
if (mo.xtra_opts)
free(mo.xtra_opts);
if (mo.type)
free(mo.type);
if (opts_string)
free(opts_string);
return ret ? 1 : 0;
}
int main(int argc, char *argv[])
{
errcode_t ret;
uint64_t blkno;
int c;
char *filename, *buf;
ocfs2_filesys *fs;
struct ocfs2_dinode *di;
struct walk_it wi;
blkno = OCFS2_SUPER_BLOCK_BLKNO;
initialize_ocfs_error_table();
while ((c = getopt(argc, argv, "bei:")) != EOF) {
switch (c) {
case 'i':
blkno = read_number(optarg);
if (blkno <= OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid inode block: %s\n",
optarg);
print_usage();
return 1;
}
break;
default:
print_usage();
return 1;
break;
}
}
if (blkno == OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr, "You must specify an inode block\n");
print_usage();
return 1;
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[optind];
ret = ocfs2_open(filename, OCFS2_FLAG_RO, 0, 0, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret) {
com_err(argv[0], ret,
"while allocating inode buffer");
goto out_close;
}
memset(&wi, 0, sizeof(wi));
ret = ocfs2_read_inode(fs, blkno, buf);
if (ret) {
com_err(argv[0], ret, "while reading inode %"PRIu64, blkno);
goto out_free;
}
di = (struct ocfs2_dinode *)buf;
fprintf(stdout, "OCFS2 inode %"PRIu64" on \"%s\"\n",
blkno, filename);
ret = ocfs2_malloc_block(fs->fs_io, &wi.gd_buf);
if (ret) {
com_err(argv[0], ret,
"while allocating gd buffer");
goto out_free;
}
wi.di = di;
wi.last_chain = -1;
ret = ocfs2_chain_iterate(fs, blkno,
walk_chain_func,
&wi);
if (ret) {
com_err(argv[0], ret,
"while walking extents");
}
out_free:
if (wi.gd_buf)
ocfs2_free(&wi.gd_buf);
ocfs2_free(&buf);
out_close:
ret = ocfs2_close(fs);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return 0;
}
int main(int argc, char *argv[])
{
errcode_t ret;
uint64_t blkno, sys_blkno;
int c;
char *filename, *buf;
const char *bitmap_name = ocfs2_system_inodes[GLOBAL_BITMAP_SYSTEM_INODE].si_name;
ocfs2_filesys *fs;
struct ocfs2_dinode *di;
struct walk_block wb;
blkno = OCFS2_SUPER_BLOCK_BLKNO;
initialize_ocfs_error_table();
while ((c = getopt(argc, argv, "i:")) != EOF) {
switch (c) {
case 'i':
blkno = read_number(optarg);
if (blkno <= OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid inode block: %s\n",
optarg);
print_usage();
return 1;
}
break;
default:
print_usage();
return 1;
break;
}
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[optind];
ret = ocfs2_open(filename, OCFS2_FLAG_RW, 0, 0, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
if (blkno == OCFS2_SUPER_BLOCK_BLKNO) {
sys_blkno = OCFS2_RAW_SB(fs->fs_super)->s_system_dir_blkno;
ret = ocfs2_lookup(fs, sys_blkno, bitmap_name,
strlen(bitmap_name), NULL, &blkno);
if (ret) {
com_err(argv[0], ret,
"while looking up \"%s\"", bitmap_name);
goto out;
}
}
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret) {
com_err(argv[0], ret,
"while allocating inode buffer");
goto out_close;
}
memset(&wb, 0, sizeof(wb));
ret = ocfs2_read_inode(fs, blkno, buf);
if (ret) {
com_err(argv[0], ret, "while reading inode %"PRIu64, blkno);
goto out_free;
}
di = (struct ocfs2_dinode *)buf;
wb.di = di;
ret = ocfs2_malloc_block(fs->fs_io, &wb.buf);
if (ret) {
com_err(argv[0], ret,
"while allocating block buffer");
goto out_free;
}
ret = ocfs2_block_iterate(fs, blkno, 0,
walk_blocks_func,
&wb);
if (ret) {
com_err(argv[0], ret,
"while walking blocks");
goto out_free;
}
di->id1.bitmap1.i_used = wb.used;
ret = ocfs2_write_inode(fs, blkno, buf);
if (ret) {
com_err(argv[0], ret, "while reading inode %"PRIu64, blkno);
goto out_free;
}
out_free:
if (wb.buf)
ocfs2_free(&wb.buf);
ocfs2_free(&buf);
out_close:
ret = ocfs2_close(fs);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return 0;
}
int main(int argc, char *argv[])
{
errcode_t ret;
uint64_t blkno, result_blkno;
int c, len;
char *filename, *lookup_path, *buf;
char *filebuf;
char *p;
char lookup_name[256];
ocfs2_filesys *fs;
blkno = 0;
initialize_ocfs_error_table();
while ((c = getopt(argc, argv, "i:")) != EOF) {
switch (c) {
case 'i':
blkno = read_number(optarg);
if (blkno <= OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid inode block: %s\n",
optarg);
print_usage();
return 1;
}
break;
default:
print_usage();
return 1;
break;
}
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[optind];
optind++;
if (optind >= argc) {
fprintf(stdout, "Missing path to lookup\n");
print_usage();
return 1;
}
lookup_path = argv[optind];
ret = ocfs2_open(filename, OCFS2_FLAG_RO, 0, 0, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret) {
com_err(argv[0], ret,
"while allocating inode buffer");
goto out_close;
}
if (!blkno)
blkno = OCFS2_RAW_SB(fs->fs_super)->s_root_blkno;
for (p = lookup_path; *p == '/'; p++);
lookup_path = p;
for (p = lookup_path; ; p++) {
if (*p && *p != '/')
continue;
memcpy(lookup_name, lookup_path, p - lookup_path);
lookup_name[p - lookup_path] = '\0';
ret = ocfs2_lookup(fs, blkno, lookup_name,
strlen(lookup_name), NULL,
&result_blkno);
if (ret) {
com_err(argv[0], ret,
"while looking up \"%s\" in inode %"PRIu64
" on \"%s\"\n",
lookup_name, blkno, filename);
goto out_free;
}
blkno = result_blkno;
for (; *p == '/'; p++);
lookup_path = p;
if (!*p)
break;
}
if (ocfs2_check_directory(fs, blkno) != OCFS2_ET_NO_DIRECTORY) {
com_err(argv[0], ret, "\"%s\" is not a file", filename);
goto out_free;
}
ret = ocfs2_read_whole_file(fs, blkno, &filebuf, &len);
if (ret) {
com_err(argv[0], ret,
"while reading file \"%s\" -- read %d bytes",
filename, len);
goto out_free_filebuf;
}
if (!len)
fprintf(stderr, "boo!\n");
dump_filebuf(filebuf, len);
out_free_filebuf:
if (len)
ocfs2_free(&filebuf);
out_free:
ocfs2_free(&buf);
out_close:
ret = ocfs2_close(fs);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return 0;
}
int main(int argc, char *argv[])
{
errcode_t ret;
uint64_t blkno, contig, blkoff = 0;
uint16_t ext_flags;
int count = 0;
int c, op = 0;
char *filename;
ocfs2_filesys *fs;
ocfs2_cached_inode *cinode;
blkno = OCFS2_SUPER_BLOCK_BLKNO;
initialize_ocfs_error_table();
while ((c = getopt(argc, argv, "i:b:")) != EOF) {
switch (c) {
case 'i':
blkno = read_number(optarg);
if (blkno <= OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid inode block: %s\n",
optarg);
print_usage();
return 1;
}
break;
case 'b':
if (op) {
fprintf(stderr, "Cannot specify more than one operation\n");
print_usage();
return 1;
}
if (read_b_numbers(optarg,
&blkoff, &count)) {
fprintf(stderr, "Invalid block range: %s\n", optarg);
print_usage();
return 1;
}
op = OP_LOOKUP_BLOCK;
break;
default:
print_usage();
return 1;
break;
}
}
if (!op) {
fprintf(stderr, "Missing operation\n");
print_usage();
return 1;
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[optind];
ret = ocfs2_open(filename, OCFS2_FLAG_RO, 0, 0, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
ret = ocfs2_read_cached_inode(fs, blkno, &cinode);
if (ret) {
com_err(argv[0], ret, "while reading inode %"PRIu64, blkno);
goto out_close;
}
fprintf(stdout, "OCFS2 inode %"PRIu64" on \"%s\" has depth %"PRId16"\n",
blkno, filename,
cinode->ci_inode->id2.i_list.l_tree_depth);
ret = ocfs2_extent_map_get_blocks(cinode,
blkoff,
count,
&blkno,
&contig,
&ext_flags);
if (ret) {
com_err(argv[0], ret,
"looking up block range %"PRIu64":%d", blkoff, count);
goto out_free;
}
fprintf(stdout, "Lookup of block range %"PRIu64":%d returned %"PRIu64":%"PRIu64"\n",
blkoff, count, blkno, contig);
out_free:
ocfs2_free_cached_inode(fs, cinode);
out_close:
ret = ocfs2_close(fs);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return 0;
}
int main(int argc, char *argv[])
{
errcode_t ret;
char *filename;
ocfs2_filesys *fs;
uint64_t ino = 0;
uint32_t new_clusters = 0;
int c;
initialize_ocfs_error_table();
while ((c = getopt(argc, argv, "i:c:")) != EOF) {
switch (c) {
case 'i':
ino = read_number(optarg);
if (ino <= OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid inode block: %s\n",
optarg);
print_usage();
return 1;
}
break;
case 'c':
new_clusters = read_number(optarg);
if (!new_clusters) {
fprintf(stderr,
"Invalid cluster count: %s\n",
optarg);
print_usage();
return 1;
}
break;
default:
print_usage();
return 1;
break;
}
}
if (!ino) {
fprintf(stderr, "You must specify an inode block\n");
print_usage();
return 1;
}
if (!new_clusters) {
fprintf(stderr, "You must specify how many clusters to extend\n");
print_usage();
return 1;
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[optind];
ret = ocfs2_open(filename, OCFS2_FLAG_RW, 0, 0, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
ret = ocfs2_extend_allocation(fs, ino, new_clusters);
if (ret) {
com_err(argv[0], ret,
"while extending inode %"PRIu64, ino);
}
ret = ocfs2_close(fs);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return !!ret;
}
int main(int argc, char **argv)
{
char *filename;
int64_t blkno, blksize;
o2fsck_state *ost = &_ost;
int c, open_flags = OCFS2_FLAG_RW | OCFS2_FLAG_STRICT_COMPAT_CHECK;
int sb_num = 0;
int fsck_mask = FSCK_OK;
int slot_recover_err = 0;
errcode_t ret;
int mount_flags;
int proceed = 1;
memset(ost, 0, sizeof(o2fsck_state));
ost->ost_ask = 1;
ost->ost_dirblocks.db_root = RB_ROOT;
ost->ost_dir_parents = RB_ROOT;
ost->ost_refcount_trees = RB_ROOT;
/* These mean "autodetect" */
blksize = 0;
blkno = 0;
initialize_ocfs_error_table();
initialize_o2dl_error_table();
initialize_o2cb_error_table();
setlinebuf(stderr);
setlinebuf(stdout);
tools_progress_disable();
while ((c = getopt(argc, argv, "b:B:DfFGnupavVytPr:")) != EOF) {
switch (c) {
case 'b':
blkno = read_number(optarg);
if (blkno < OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid blkno: %s\n",
optarg);
fsck_mask |= FSCK_USAGE;
print_usage();
goto out;
}
break;
case 'B':
blksize = read_number(optarg);
if (blksize < OCFS2_MIN_BLOCKSIZE) {
fprintf(stderr,
"Invalid blksize: %s\n",
optarg);
fsck_mask |= FSCK_USAGE;
print_usage();
goto out;
}
break;
case 'D':
ost->ost_compress_dirs = 1;
break;
case 'F':
ost->ost_skip_o2cb = 1;
break;
case 'f':
ost->ost_force = 1;
break;
case 'G':
ost->ost_fix_fs_gen = 1;
break;
case 'n':
open_flags &= ~OCFS2_FLAG_RW;
open_flags |= OCFS2_FLAG_RO;
/* Fall through */
case 'a':
case 'p':
/*
* Like extN, -a maps to -p, which is
* 'preen'. This means only fix things
* that don't require human interaction.
* Unlike extN, this is only journal
* replay for now. To make it smarter,
* ost->ost_answer needs to learn a
* new mode.
*/
ost->ost_ask = 0;
ost->ost_answer = 0;
break;
case 'P':
tools_progress_enable();
break;
case 'y':
ost->ost_ask = 0;
ost->ost_answer = 1;
break;
case 'u':
open_flags |= OCFS2_FLAG_BUFFERED;
break;
case 'v':
verbose = 1;
break;
case 'V':
print_version();
exit(FSCK_USAGE);
break;
case 'r':
sb_num = read_number(optarg);
break;
case 't':
if (ost->ost_show_stats)
ost->ost_show_extended_stats = 1;
ost->ost_show_stats = 1;
break;
default:
fsck_mask |= FSCK_USAGE;
print_usage();
goto out;
break;
}
}
if (!(open_flags & OCFS2_FLAG_RW) && ost->ost_compress_dirs) {
fprintf(stderr, "Compress directories (-D) incompatible with read-only mode\n");
fsck_mask |= FSCK_USAGE;
print_usage();
goto out;
}
if (blksize % OCFS2_MIN_BLOCKSIZE) {
fprintf(stderr, "Invalid blocksize: %"PRId64"\n", blksize);
fsck_mask |= FSCK_USAGE;
print_usage();
goto out;
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
fsck_mask |= FSCK_USAGE;
print_usage();
goto out;
}
filename = argv[optind];
print_version();
ret = ocfs2_check_if_mounted(filename, &mount_flags);
if (ret) {
com_err(whoami, ret, "while determining whether %s is mounted.",
filename);
fsck_mask |= FSCK_ERROR;
goto out;
}
if (mount_flags & (OCFS2_MF_MOUNTED | OCFS2_MF_BUSY)) {
if (!(open_flags & OCFS2_FLAG_RW))
fprintf(stdout, "\nWARNING!!! Running fsck.ocfs2 (read-"
"only) on a mounted filesystem may detect "
"invalid errors.\n\n");
else
fprintf(stdout, "\nWARNING!!! Running fsck.ocfs2 on a "
"mounted filesystem may cause SEVERE "
"filesystem damage.\n\n");
proceed = 0;
}
if (proceed && ost->ost_skip_o2cb) {
fprintf(stdout, "\nWARNING!!! You have disabled the cluster check. "
"Continue only if you\nare absolutely sure that NO "
"node has this filesystem mounted or is\notherwise "
"accessing it. If unsure, do NOT continue.\n\n");
proceed = 0;
}
if (!proceed) {
fprintf(stdout, "Do you really want to continue (y/N): ");
if (toupper(getchar()) != 'Y') {
printf("Aborting operation.\n");
fsck_mask |= FSCK_CANCELED;
goto out;
}
}
if (signal(SIGTERM, handle_signal) == SIG_ERR) {
com_err(whoami, 0, "Could not set SIGTERM");
exit(1);
}
if (signal(SIGINT, handle_signal) == SIG_ERR) {
com_err(whoami, 0, "Could not set SIGINT");
exit(1);
}
/* recover superblock should be called at first. */
if (sb_num) {
ret = recover_backup_super(ost, filename, sb_num);
if (ret) {
com_err(whoami, ret, "recover superblock failed.\n");
fsck_mask |= FSCK_ERROR;
goto out;
}
}
ret = open_and_check(ost, filename, open_flags, blkno, blksize);
if (ret) {
fsck_mask |= FSCK_ERROR;
goto out;
}
if (open_flags & OCFS2_FLAG_RW && !ost->ost_skip_o2cb &&
!ocfs2_mount_local(ost->ost_fs)) {
ret = o2cb_init();
if (ret) {
com_err(whoami, ret, "while initializing the cluster");
goto close;
}
block_signals(SIG_BLOCK);
ret = ocfs2_initialize_dlm(ost->ost_fs, whoami);
if (ret == O2CB_ET_INVALID_STACK_NAME ||
ret == O2CB_ET_INVALID_CLUSTER_NAME ||
ret == O2CB_ET_INVALID_HEARTBEAT_MODE) {
block_signals(SIG_UNBLOCK);
ret = recover_cluster_info(ost);
if (ret) {
com_err(whoami, ret,
"while recovering cluster information");
goto close;
}
block_signals(SIG_BLOCK);
ret = ocfs2_initialize_dlm(ost->ost_fs, whoami);
}
if (ret) {
block_signals(SIG_UNBLOCK);
com_err(whoami, ret, "while initializing the DLM");
goto close;
}
ret = ocfs2_lock_down_cluster(ost->ost_fs);
if (ret) {
block_signals(SIG_UNBLOCK);
com_err(whoami, ret, "while locking down the cluster");
goto close;
}
cluster_locked = 1;
block_signals(SIG_UNBLOCK);
}
printf("Checking OCFS2 filesystem in %s:\n", filename);
printf(" Label: ");
print_label(ost);
printf(" UUID: ");
print_uuid(ost);
printf(" Number of blocks: %"PRIu64"\n", ost->ost_fs->fs_blocks);
printf(" Block size: %u\n", ost->ost_fs->fs_blocksize);
printf(" Number of clusters: %"PRIu32"\n", ost->ost_fs->fs_clusters);
printf(" Cluster size: %u\n", ost->ost_fs->fs_clustersize);
printf(" Number of slots: %u\n\n",
OCFS2_RAW_SB(ost->ost_fs->fs_super)->s_max_slots);
/* Let's get enough of a cache to replay the journals */
o2fsck_init_cache(ost, O2FSCK_CACHE_MODE_JOURNAL);
if (open_flags & OCFS2_FLAG_RW) {
ret = o2fsck_check_journals(ost);
if (ret) {
printf("fsck saw unrecoverable errors in the journal "
"files and will not continue.\n");
goto unlock;
}
}
ret = maybe_replay_journals(ost, filename, open_flags, blkno, blksize);
if (ret) {
printf("fsck encountered unrecoverable errors while "
"replaying the journals and will not continue\n");
fsck_mask |= FSCK_ERROR;
goto unlock;
}
/* Grow the cache */
o2fsck_init_cache(ost, O2FSCK_CACHE_MODE_FULL);
/* allocate all this junk after we've replayed the journal and the
* sb should be stable */
if (o2fsck_state_init(ost->ost_fs, ost)) {
fprintf(stderr, "error allocating run-time state, exiting..\n");
fsck_mask |= FSCK_ERROR;
goto unlock;
}
ret = o2fsck_slot_recovery(ost);
if (ret) {
printf("fsck encountered errors while recovering slot "
"information, check forced.\n");
slot_recover_err = 1;
ost->ost_force = 1;
}
if (fs_is_clean(ost, filename)) {
fsck_mask = FSCK_OK;
goto clear_dirty_flag;
}
#if 0
o2fsck_mark_block_used(ost, 0);
o2fsck_mark_block_used(ost, 1);
o2fsck_mark_block_used(ost, OCFS2_SUPER_BLOCK_BLKNO);
#endif
mark_magical_clusters(ost);
/* XXX we don't use the bad blocks inode, do we? */
/* XXX for now it is assumed that errors returned from a pass
* are fatal. these can be fixed over time. */
ret = o2fsck_pass0(ost);
if (ret) {
com_err(whoami, ret, "while performing pass 0");
goto done;
}
ret = o2fsck_pass1(ost);
if (ret) {
com_err(whoami, ret, "while performing pass 1");
goto done;
}
ret = o2fsck_pass2(ost);
if (ret) {
com_err(whoami, ret, "while performing pass 2");
goto done;
}
ret = o2fsck_pass3(ost);
if (ret) {
com_err(whoami, ret, "while performing pass 3");
goto done;
}
ret = o2fsck_pass4(ost);
if (ret) {
com_err(whoami, ret, "while performing pass 4");
goto done;
}
ret = o2fsck_pass5(ost);
if (ret) {
com_err(whoami, ret, "while performing pass 5");
goto done;
}
done:
if (ret)
fsck_mask |= FSCK_ERROR;
else {
fsck_mask = FSCK_OK;
ost->ost_saw_error = 0;
printf("All passes succeeded.\n\n");
o2fsck_print_resource_track(NULL, ost, &ost->ost_rt,
ost->ost_fs->fs_io);
show_stats(ost);
}
clear_dirty_flag:
if (ost->ost_fs->fs_flags & OCFS2_FLAG_RW) {
ret = write_out_superblock(ost);
if (ret)
com_err(whoami, ret, "while writing back the "
"superblock(s)");
if (fsck_mask == FSCK_OK) {
if (slot_recover_err) {
ret = o2fsck_slot_recovery(ost);
if (ret) {
com_err(whoami, ret, "while doing slot "
"recovery.");
goto unlock;
}
}
ret = o2fsck_clear_journal_flags(ost);
if (ret) {
com_err(whoami, ret, "while clear dirty "
"journal flag.");
goto unlock;
}
ret = ocfs2_format_slot_map(ost->ost_fs);
if (ret)
com_err(whoami, ret, "while format slot "
"map.");
}
}
unlock:
block_signals(SIG_BLOCK);
if (ost->ost_fs->fs_dlm_ctxt)
ocfs2_release_cluster(ost->ost_fs);
cluster_locked = 0;
block_signals(SIG_UNBLOCK);
close:
block_signals(SIG_BLOCK);
if (ost->ost_fs->fs_dlm_ctxt)
ocfs2_shutdown_dlm(ost->ost_fs, whoami);
block_signals(SIG_UNBLOCK);
ret = ocfs2_close(ost->ost_fs);
if (ret) {
com_err(whoami, ret, "while closing file \"%s\"", filename);
/* XXX I wonder about this error.. */
fsck_mask |= FSCK_ERROR;
}
out:
return fsck_mask;
}
int main(int argc, char *argv[])
{
errcode_t ret;
int c;
int64_t blkno, blksize;
char *filename;
ocfs2_filesys *fs;
/* These mean "autodetect" */
blksize = 0;
blkno = 0;
initialize_ocfs_error_table();
while((c = getopt(argc, argv, "s:B:")) != EOF) {
switch (c) {
case 's':
blkno = read_number(optarg);
if (blkno < OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid blkno: %s\n",
optarg);
print_usage();
return 1;
}
break;
case 'B':
blksize = read_number(optarg);
if (blksize < OCFS2_MIN_BLOCKSIZE) {
fprintf(stderr,
"Invalid blksize: %s\n",
optarg);
print_usage();
return 1;
}
break;
default:
print_usage();
return 1;
break;
}
}
if (blksize % OCFS2_MIN_BLOCKSIZE) {
fprintf(stderr, "Invalid blocksize: %"PRId64"\n", blksize);
print_usage();
return 1;
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[optind];
ret = ocfs2_open(filename, OCFS2_FLAG_RO, blkno, blksize, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
fprintf(stdout, "OCFS2 filesystem on \"%s\":\n", filename);
fprintf(stdout,
"\tblocksize = %d\n"
"\tclustersize = %d\n"
"\tclusters = %u\n"
"\tblocks = %"PRIu64"\n"
"\troot_blkno = %"PRIu64"\n"
"\tsystem_dir_blkno = %"PRIu64"\n",
fs->fs_blocksize,
fs->fs_clustersize,
fs->fs_clusters,
fs->fs_blocks,
fs->fs_root_blkno,
fs->fs_sysdir_blkno);
ret = ocfs2_close(fs);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return 0;
}
int main(int argc, char *argv[])
{
errcode_t ret;
uint64_t blkno;
int c;
int walk_blocks = 0, walk_extents = 0;
char *filename, *buf, *eb_buf = NULL;
ocfs2_filesys *fs;
struct ocfs2_dinode *di;
struct walk_it wi;
struct walk_block wb;
blkno = OCFS2_SUPER_BLOCK_BLKNO;
initialize_ocfs_error_table();
while ((c = getopt(argc, argv, "bei:")) != EOF) {
switch (c) {
case 'b':
walk_blocks = 1;
break;
case 'e':
walk_extents = 1;
break;
case 'i':
blkno = read_number(optarg);
if (blkno <= OCFS2_SUPER_BLOCK_BLKNO) {
fprintf(stderr,
"Invalid inode block: %s\n",
optarg);
print_usage();
return 1;
}
break;
default:
print_usage();
return 1;
break;
}
}
if (optind >= argc) {
fprintf(stderr, "Missing filename\n");
print_usage();
return 1;
}
filename = argv[optind];
if (!(walk_blocks + walk_extents)) {
fprintf(stderr,
"No operation specified\n");
print_usage();
return 1;
}
ret = ocfs2_open(filename, OCFS2_FLAG_RO, 0, 0, &fs);
if (ret) {
com_err(argv[0], ret,
"while opening file \"%s\"", filename);
goto out;
}
ret = ocfs2_malloc_block(fs->fs_io, &buf);
if (ret) {
com_err(argv[0], ret,
"while allocating inode buffer");
goto out_close;
}
ret = ocfs2_read_inode(fs, blkno, buf);
if (ret) {
com_err(argv[0], ret, "while reading inode %"PRIu64, blkno);
goto out_free;
}
di = (struct ocfs2_dinode *)buf;
fprintf(stdout, "OCFS2 inode %"PRIu64" on \"%s\" has depth %"PRId16"\n",
blkno, filename, di->id2.i_list.l_tree_depth);
if (walk_extents) {
if (di->id2.i_list.l_tree_depth) {
ret = ocfs2_malloc_blocks(fs->fs_io,
di->id2.i_list.l_tree_depth,
&eb_buf);
if (ret) {
com_err(argv[0], ret,
"while allocating eb buffer");
goto out_free;
}
}
wi.di = di;
ret = ocfs2_extent_iterate(fs, blkno, 0,
eb_buf,
walk_extents_func,
&wi);
if (ret) {
com_err(argv[0], ret,
"while walking extents");
goto out_free;
}
}
if (walk_blocks) {
wb.di = di;
wb.run_first_blkno = wb.run_first_bcount =
wb.run_prev_blkno = 0;
wb.last_block = (wb.di->i_size +
(fs->fs_blocksize - 1)) /
fs->fs_blocksize;
ret = ocfs2_block_iterate(fs, blkno, 0,
walk_blocks_func,
&wb);
if (ret) {
com_err(argv[0], ret,
"while walking blocks");
goto out_free;
}
}
out_free:
if (eb_buf)
ocfs2_free(&eb_buf);
ocfs2_free(&buf);
out_close:
ret = ocfs2_close(fs);
if (ret) {
com_err(argv[0], ret,
"while closing file \"%s\"", filename);
}
out:
return 0;
}