// finds out which hash names are sorted with
static int what_hash (struct super_block * s)
{
__u32 code;
code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));
/* reiserfs_hash_detect() == true if any of the hash mount options
** were used. We must check them to make sure the user isn't
** using a bad hash value
*/
if (code == UNSET_HASH || reiserfs_hash_detect(s))
code = find_hash_out (s);
if (code != UNSET_HASH && reiserfs_hash_detect(s)) {
/* detection has found the hash, and we must check against the
** mount options
*/
if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {
printk("REISERFS: Error, %s hash detected, "
"unable to force rupasov hash\n", reiserfs_hashname(code)) ;
code = UNSET_HASH ;
} else if (reiserfs_tea_hash(s) && code != TEA_HASH) {
printk("REISERFS: Error, %s hash detected, "
"unable to force tea hash\n", reiserfs_hashname(code)) ;
code = UNSET_HASH ;
} else if (reiserfs_r5_hash(s) && code != R5_HASH) {
printk("REISERFS: Error, %s hash detected, "
"unable to force r5 hash\n", reiserfs_hashname(code)) ;
code = UNSET_HASH ;
}
} else {
/* find_hash_out was not called or could not determine the hash */
if (reiserfs_rupasov_hash(s)) {
code = YURA_HASH ;
} else if (reiserfs_tea_hash(s)) {
code = TEA_HASH ;
} else if (reiserfs_r5_hash(s)) {
code = R5_HASH ;
}
}
/* if we are mounted RW, and we have a new valid hash code, update
** the super
*/
if (code != UNSET_HASH &&
!(s->s_flags & MS_RDONLY) &&
code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {
set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);
}
return code;
}
//
// a portion of this function, particularly the VFS interface portion,
// was derived from minix or ext2's analog and evolved as the
// prototype did. You should be able to tell which portion by looking
// at the ext2 code and comparing. It's subfunctions contain no code
// used as a template unless they are so labeled.
//
static struct super_block * reiserfs_read_super (struct super_block * s, void * data, int silent)
{
int size;
struct inode *root_inode;
kdev_t dev = s->s_dev;
int j;
extern int *blksize_size[];
struct reiserfs_transaction_handle th ;
int old_format = 0;
unsigned long blocks;
int jinit_done = 0 ;
struct reiserfs_iget4_args args ;
int old_magic;
struct reiserfs_super_block * rs;
memset (&s->u.reiserfs_sb, 0, sizeof (struct reiserfs_sb_info));
if (parse_options ((char *) data, &(s->u.reiserfs_sb.s_mount_opt), &blocks) == 0) {
return NULL;
}
if (blocks) {
printk("reserfs: resize option for remount only\n");
return NULL;
}
if (blksize_size[MAJOR(dev)] && blksize_size[MAJOR(dev)][MINOR(dev)] != 0) {
/* as blocksize is set for partition we use it */
size = blksize_size[MAJOR(dev)][MINOR(dev)];
} else {
size = BLOCK_SIZE;
set_blocksize (s->s_dev, BLOCK_SIZE);
}
/* read block (64-th 1k block), which can contain reiserfs super block */
if (read_super_block (s, size, REISERFS_DISK_OFFSET_IN_BYTES)) {
// try old format (undistributed bitmap, super block in 8-th 1k block of a device)
if (read_super_block (s, size, REISERFS_OLD_DISK_OFFSET_IN_BYTES))
goto error;
else
old_format = 1;
}
rs = SB_DISK_SUPER_BLOCK (s);
s->u.reiserfs_sb.s_mount_state = SB_REISERFS_STATE(s);
s->u.reiserfs_sb.s_mount_state = REISERFS_VALID_FS ;
if (old_format ? read_old_bitmaps(s) : read_bitmaps(s)) {
printk ("reiserfs_read_super: unable to read bitmap\n");
goto error;
}
#ifdef CONFIG_REISERFS_CHECK
printk("reiserfs:warning: CONFIG_REISERFS_CHECK is set ON\n");
printk("reiserfs:warning: - it is slow mode for debugging.\n");
#endif
// set_device_ro(s->s_dev, 1) ;
if (journal_init(s)) {
printk("reiserfs_read_super: unable to initialize journal space\n") ;
goto error ;
} else {
jinit_done = 1 ; /* once this is set, journal_release must be called
** if we error out of the mount
*/
}
if (reread_meta_blocks(s)) {
printk("reiserfs_read_super: unable to reread meta blocks after journal init\n") ;
goto error ;
}
if (replay_only (s))
goto error;
if (is_read_only(s->s_dev) && !(s->s_flags & MS_RDONLY)) {
printk("clm-7000: Detected readonly device, marking FS readonly\n") ;
s->s_flags |= MS_RDONLY ;
}
args.objectid = REISERFS_ROOT_PARENT_OBJECTID ;
root_inode = iget4 (s, REISERFS_ROOT_OBJECTID, 0, (void *)(&args));
if (!root_inode) {
printk ("reiserfs_read_super: get root inode failed\n");
goto error;
}
s->s_root = d_alloc_root(root_inode);
if (!s->s_root) {
iput(root_inode);
goto error;
}
// define and initialize hash function
s->u.reiserfs_sb.s_hash_function = hash_function (s);
if (s->u.reiserfs_sb.s_hash_function == NULL) {
dput(s->s_root) ;
s->s_root = NULL ;
goto error ;
}
rs = SB_DISK_SUPER_BLOCK (s);
old_magic = strncmp (rs->s_magic, REISER2FS_SUPER_MAGIC_STRING,
strlen ( REISER2FS_SUPER_MAGIC_STRING));
if (!old_magic)
set_bit(REISERFS_3_6, &(s->u.reiserfs_sb.s_properties));
else
set_bit(REISERFS_3_5, &(s->u.reiserfs_sb.s_properties));
if (!(s->s_flags & MS_RDONLY)) {
journal_begin(&th, s, 1) ;
reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1) ;
set_sb_state( rs, REISERFS_ERROR_FS );
if ( old_magic ) {
// filesystem created under 3.5.x found
if (convert_reiserfs (s)) {
reiserfs_warning("reiserfs: converting 3.5.x filesystem to the new format\n") ;
// after this 3.5.x will not be able to mount this partition
memcpy (rs->s_magic, REISER2FS_SUPER_MAGIC_STRING,
sizeof (REISER2FS_SUPER_MAGIC_STRING));
reiserfs_convert_objectid_map_v1(s) ;
set_bit(REISERFS_3_6, &(s->u.reiserfs_sb.s_properties));
clear_bit(REISERFS_3_5, &(s->u.reiserfs_sb.s_properties));
} else {
reiserfs_warning("reiserfs: using 3.5.x disk format\n") ;
}
}
journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB (s));
journal_end(&th, s, 1) ;
/* look for files which were to be removed in previous session */
finish_unfinished (s);
s->s_dirt = 0;
} else {
if ( old_magic ) {
reiserfs_warning("reiserfs: using 3.5.x disk format\n") ;
}
}
// mark hash in super block: it could be unset. overwrite should be ok
set_sb_hash_function_code( rs, function2code(s->u.reiserfs_sb.s_hash_function ) );
handle_attrs( s );
reiserfs_proc_info_init( s );
reiserfs_proc_register( s, "version", reiserfs_version_in_proc );
reiserfs_proc_register( s, "super", reiserfs_super_in_proc );
reiserfs_proc_register( s, "per-level", reiserfs_per_level_in_proc );
reiserfs_proc_register( s, "bitmap", reiserfs_bitmap_in_proc );
reiserfs_proc_register( s, "on-disk-super", reiserfs_on_disk_super_in_proc );
reiserfs_proc_register( s, "oidmap", reiserfs_oidmap_in_proc );
reiserfs_proc_register( s, "journal", reiserfs_journal_in_proc );
init_waitqueue_head (&(s->u.reiserfs_sb.s_wait));
printk("%s\n", reiserfs_get_version_string()) ;
return s;
error:
if (jinit_done) { /* kill the commit thread, free journal ram */
journal_release_error(NULL, s) ;
}
if (SB_DISK_SUPER_BLOCK (s)) {
for (j = 0; j < SB_BMAP_NR (s); j ++) {
if (SB_AP_BITMAP (s))
brelse (SB_AP_BITMAP (s)[j]);
}
if (SB_AP_BITMAP (s))
reiserfs_kfree (SB_AP_BITMAP (s), sizeof (struct buffer_head *) * SB_BMAP_NR (s), s);
}
if (SB_BUFFER_WITH_SB (s))
brelse(SB_BUFFER_WITH_SB (s));
return NULL;
}
/* Finds out which hash names are sorted with */
static int
what_hash(struct reiserfs_mount *rmp)
{
uint32_t code;
struct reiserfs_sb_info *sbi = rmp->rm_reiserfs;
find_hash_out(rmp);
code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(sbi));
/*
* reiserfs_hash_detect() == true if any of the hash mount options
* were used. We must check them to make sure the user isn't using a
* bad hash value
*/
if (code == UNSET_HASH || reiserfs_hash_detect(sbi))
code = find_hash_out(rmp);
if (code != UNSET_HASH && reiserfs_hash_detect(sbi)) {
/*
* Detection has found the hash, and we must check against
* the mount options
*/
if (reiserfs_rupasov_hash(sbi) && code != YURA_HASH) {
reiserfs_log(LOG_ERR, "error, %s hash detected, "
"unable to force rupasov hash",
reiserfs_hashname(code));
code = UNSET_HASH;
} else if (reiserfs_tea_hash(sbi) && code != TEA_HASH) {
reiserfs_log(LOG_ERR, "error, %s hash detected, "
"unable to force tea hash",
reiserfs_hashname(code));
code = UNSET_HASH;
} else if (reiserfs_r5_hash(sbi) && code != R5_HASH) {
reiserfs_log(LOG_ERR, "error, %s hash detected, "
"unable to force r5 hash",
reiserfs_hashname(code));
code = UNSET_HASH;
}
} else {
/*
* Find_hash_out was not called or could not determine
* the hash
*/
if (reiserfs_rupasov_hash(sbi)) {
code = YURA_HASH;
} else if (reiserfs_tea_hash(sbi)) {
code = TEA_HASH;
} else if (reiserfs_r5_hash(sbi)) {
code = R5_HASH;
}
}
/* TODO Not supported yet */
#if 0
/* If we are mounted RW, and we have a new valid hash code, update
* the super */
if (code != UNSET_HASH &&
!(s->s_flags & MS_RDONLY) &&
code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {
set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);
}
#endif
return (code);
}
