int open_ocfs2_volume(char *device_name)
{
int open_flags = OCFS2_FLAG_HEARTBEAT_DEV_OK | OCFS2_FLAG_RO;
int ret;
ret = ocfs2_open(device_name, open_flags, 0, 0, &fs);
if (ret < 0) {
fprintf(stderr, "Not a ocfs2 volume!\n");
return ret;
}
ocfs2_sb = OCFS2_RAW_SB(fs->fs_super);
if (!(ocfs2_sb->s_feature_incompat &
OCFS2_FEATURE_INCOMPAT_INLINE_DATA)) {
fprintf(stderr, "Inline-data not supported"
" on this ocfs2 volume\n");
return -1;
}
blocksize = 1 << ocfs2_sb->s_blocksize_bits;
clustersize = 1 << ocfs2_sb->s_clustersize_bits;
max_inline_size = ocfs2_max_inline_data_with_xattr(blocksize, NULL);
return 0;
}
/*
* 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 */
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 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;
}
int open_ocfs2_volume(char *device_name)
{
int open_flags = OCFS2_FLAG_HEARTBEAT_DEV_OK | OCFS2_FLAG_RO;
int ret;
ret = ocfs2_open(device_name, open_flags, 0, 0, &fs);
if (ret < 0) {
fprintf(stderr, "%s is not a ocfs2 volume!\n", device_name);
return ret;
}
ocfs2_sb = OCFS2_RAW_SB(fs->fs_super);
blocksize = 1 << ocfs2_sb->s_blocksize_bits;
clustersize = 1 << ocfs2_sb->s_clustersize_bits;
return 0;
}
static errcode_t open_and_check(o2fsck_state *ost, char *filename,
int open_flags, uint64_t blkno,
uint64_t blksize)
{
errcode_t ret;
ret = ocfs2_open(filename, open_flags, blkno, blksize, &ost->ost_fs);
if (ret) {
com_err(whoami, ret, "while opening \"%s\"", filename);
goto out;
}
ret = check_superblock(ost);
if (ret) {
printf("fsck saw unrecoverable errors in the super block and "
"will not continue.\n");
goto out;
}
out:
return ret;
}
static int
fs_init (Filesystem *self,
PyObject *args,
PyObject *kwargs)
{
errcode_t ret;
char *device;
int flags = OCFS2_FLAG_RO | OCFS2_FLAG_BUFFERED;
unsigned int superblock = 0, blksize = 0;
static char *kwlist[] = { "device", "flags", "superblock", "blocksize",
NULL };
if (!PyArg_ParseTupleAndKeywords(args, kwargs,
"s|iII:ocfs2.Filesystem.__init__", kwlist,
&device, &flags, &superblock, &blksize))
return -1;
self->fs = NULL;
self->device = PyString_FromString (device);
if (self->device == NULL)
return -1;
ret = ocfs2_open (device, flags, superblock, blksize, &self->fs);
if (ret)
{
Py_DECREF (self->device);
self->device = NULL;
PyErr_SetString (ocfs2_error, error_message (ret));
return -1;
}
return 0;
}
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[])
{
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;
}
