1/*
   2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
   3 *
   4 * Trivial changes by Alan Cox to add the LFS fixes
   5 *
   6 * Trivial Changes:
   7 * Rights granted to Hans Reiser to redistribute under other terms providing
   8 * he accepts all liability including but not limited to patent, fitness
   9 * for purpose, and direct or indirect claims arising from failure to perform.
  10 *
  11 * NO WARRANTY
  12 */
  13
  14#include <linux/module.h>
  15#include <linux/slab.h>
  16#include <linux/vmalloc.h>
  17#include <linux/time.h>
  18#include <asm/uaccess.h>
  19#include <linux/reiserfs_fs.h>
  20#include <linux/reiserfs_acl.h>
  21#include <linux/reiserfs_xattr.h>
  22#include <linux/init.h>
  23#include <linux/blkdev.h>
  24#include <linux/buffer_head.h>
  25#include <linux/exportfs.h>
  26#include <linux/quotaops.h>
  27#include <linux/vfs.h>
  28#include <linux/mount.h>
  29#include <linux/namei.h>
  30#include <linux/crc32.h>
 
  31
  32struct file_system_type reiserfs_fs_type;
  33
  34static const char reiserfs_3_5_magic_string[] = REISERFS_SUPER_MAGIC_STRING;
  35static const char reiserfs_3_6_magic_string[] = REISER2FS_SUPER_MAGIC_STRING;
  36static const char reiserfs_jr_magic_string[] = REISER2FS_JR_SUPER_MAGIC_STRING;
  37
  38int is_reiserfs_3_5(struct reiserfs_super_block *rs)
  39{
  40	return !strncmp(rs->s_v1.s_magic, reiserfs_3_5_magic_string,
  41			strlen(reiserfs_3_5_magic_string));
  42}
  43
  44int is_reiserfs_3_6(struct reiserfs_super_block *rs)
  45{
  46	return !strncmp(rs->s_v1.s_magic, reiserfs_3_6_magic_string,
  47			strlen(reiserfs_3_6_magic_string));
  48}
  49
  50int is_reiserfs_jr(struct reiserfs_super_block *rs)
  51{
  52	return !strncmp(rs->s_v1.s_magic, reiserfs_jr_magic_string,
  53			strlen(reiserfs_jr_magic_string));
  54}
  55
  56static int is_any_reiserfs_magic_string(struct reiserfs_super_block *rs)
  57{
  58	return (is_reiserfs_3_5(rs) || is_reiserfs_3_6(rs) ||
  59		is_reiserfs_jr(rs));
  60}
  61
  62static int reiserfs_remount(struct super_block *s, int *flags, char *data);
  63static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf);
 
  64
  65static int reiserfs_sync_fs(struct super_block *s, int wait)
  66{
  67	struct reiserfs_transaction_handle th;
  68
  69	reiserfs_write_lock(s);
  70	if (!journal_begin(&th, s, 1))
  71		if (!journal_end_sync(&th, s, 1))
  72			reiserfs_flush_old_commits(s);
  73	s->s_dirt = 0;	/* Even if it's not true.
  74			 * We'll loop forever in sync_supers otherwise */
  75	reiserfs_write_unlock(s);
  76	return 0;
  77}
  78
  79static void reiserfs_write_super(struct super_block *s)
  80{
 
 
 
 
 
 
 
 
 
 
  81	reiserfs_sync_fs(s, 1);
  82}
  83
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  84static int reiserfs_freeze(struct super_block *s)
  85{
  86	struct reiserfs_transaction_handle th;
 
 
 
  87	reiserfs_write_lock(s);
  88	if (!(s->s_flags & MS_RDONLY)) {
  89		int err = journal_begin(&th, s, 1);
  90		if (err) {
  91			reiserfs_block_writes(&th);
  92		} else {
  93			reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
  94						     1);
  95			journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
  96			reiserfs_block_writes(&th);
  97			journal_end_sync(&th, s, 1);
  98		}
  99	}
 100	s->s_dirt = 0;
 101	reiserfs_write_unlock(s);
 102	return 0;
 103}
 104
 105static int reiserfs_unfreeze(struct super_block *s)
 106{
 107	reiserfs_allow_writes(s);
 108	return 0;
 109}
 110
 111extern const struct in_core_key MAX_IN_CORE_KEY;
 112
 113/* this is used to delete "save link" when there are no items of a
 114   file it points to. It can either happen if unlink is completed but
 115   "save unlink" removal, or if file has both unlink and truncate
 116   pending and as unlink completes first (because key of "save link"
 117   protecting unlink is bigger that a key lf "save link" which
 118   protects truncate), so there left no items to make truncate
 119   completion on */
 120static int remove_save_link_only(struct super_block *s,
 121				 struct reiserfs_key *key, int oid_free)
 122{
 123	struct reiserfs_transaction_handle th;
 124	int err;
 125
 126	/* we are going to do one balancing */
 127	err = journal_begin(&th, s, JOURNAL_PER_BALANCE_CNT);
 128	if (err)
 129		return err;
 130
 131	reiserfs_delete_solid_item(&th, NULL, key);
 132	if (oid_free)
 133		/* removals are protected by direct items */
 134		reiserfs_release_objectid(&th, le32_to_cpu(key->k_objectid));
 135
 136	return journal_end(&th, s, JOURNAL_PER_BALANCE_CNT);
 137}
 138
 139#ifdef CONFIG_QUOTA
 140static int reiserfs_quota_on_mount(struct super_block *, int);
 141#endif
 142
 143/* look for uncompleted unlinks and truncates and complete them */
 144static int finish_unfinished(struct super_block *s)
 145{
 146	INITIALIZE_PATH(path);
 147	struct cpu_key max_cpu_key, obj_key;
 148	struct reiserfs_key save_link_key, last_inode_key;
 149	int retval = 0;
 150	struct item_head *ih;
 151	struct buffer_head *bh;
 152	int item_pos;
 153	char *item;
 154	int done;
 155	struct inode *inode;
 156	int truncate;
 157#ifdef CONFIG_QUOTA
 158	int i;
 159	int ms_active_set;
 160	int quota_enabled[MAXQUOTAS];
 161#endif
 162
 163	/* compose key to look for "save" links */
 164	max_cpu_key.version = KEY_FORMAT_3_5;
 165	max_cpu_key.on_disk_key.k_dir_id = ~0U;
 166	max_cpu_key.on_disk_key.k_objectid = ~0U;
 167	set_cpu_key_k_offset(&max_cpu_key, ~0U);
 168	max_cpu_key.key_length = 3;
 169
 170	memset(&last_inode_key, 0, sizeof(last_inode_key));
 171
 172#ifdef CONFIG_QUOTA
 173	/* Needed for iput() to work correctly and not trash data */
 174	if (s->s_flags & MS_ACTIVE) {
 175		ms_active_set = 0;
 176	} else {
 177		ms_active_set = 1;
 178		s->s_flags |= MS_ACTIVE;
 179	}
 180	/* Turn on quotas so that they are updated correctly */
 181	for (i = 0; i < MAXQUOTAS; i++) {
 182		quota_enabled[i] = 1;
 183		if (REISERFS_SB(s)->s_qf_names[i]) {
 184			int ret;
 185
 186			if (sb_has_quota_active(s, i)) {
 187				quota_enabled[i] = 0;
 188				continue;
 189			}
 190			ret = reiserfs_quota_on_mount(s, i);
 191			if (ret < 0)
 192				reiserfs_warning(s, "reiserfs-2500",
 193						 "cannot turn on journaled "
 194						 "quota: error %d", ret);
 195		}
 196	}
 197#endif
 198
 199	done = 0;
 200	REISERFS_SB(s)->s_is_unlinked_ok = 1;
 201	while (!retval) {
 202		retval = search_item(s, &max_cpu_key, &path);
 203		if (retval != ITEM_NOT_FOUND) {
 204			reiserfs_error(s, "vs-2140",
 205				       "search_by_key returned %d", retval);
 206			break;
 207		}
 208
 209		bh = get_last_bh(&path);
 210		item_pos = get_item_pos(&path);
 211		if (item_pos != B_NR_ITEMS(bh)) {
 212			reiserfs_warning(s, "vs-2060",
 213					 "wrong position found");
 214			break;
 215		}
 216		item_pos--;
 217		ih = B_N_PITEM_HEAD(bh, item_pos);
 218
 219		if (le32_to_cpu(ih->ih_key.k_dir_id) != MAX_KEY_OBJECTID)
 220			/* there are no "save" links anymore */
 221			break;
 222
 223		save_link_key = ih->ih_key;
 224		if (is_indirect_le_ih(ih))
 225			truncate = 1;
 226		else
 227			truncate = 0;
 228
 229		/* reiserfs_iget needs k_dirid and k_objectid only */
 230		item = B_I_PITEM(bh, ih);
 231		obj_key.on_disk_key.k_dir_id = le32_to_cpu(*(__le32 *) item);
 232		obj_key.on_disk_key.k_objectid =
 233		    le32_to_cpu(ih->ih_key.k_objectid);
 234		obj_key.on_disk_key.k_offset = 0;
 235		obj_key.on_disk_key.k_type = 0;
 236
 237		pathrelse(&path);
 238
 239		inode = reiserfs_iget(s, &obj_key);
 240		if (!inode) {
 241			/* the unlink almost completed, it just did not manage to remove
 242			   "save" link and release objectid */
 243			reiserfs_warning(s, "vs-2180", "iget failed for %K",
 244					 &obj_key);
 245			retval = remove_save_link_only(s, &save_link_key, 1);
 246			continue;
 247		}
 248
 249		if (!truncate && inode->i_nlink) {
 250			/* file is not unlinked */
 251			reiserfs_warning(s, "vs-2185",
 252					 "file %K is not unlinked",
 253					 &obj_key);
 254			retval = remove_save_link_only(s, &save_link_key, 0);
 255			continue;
 256		}
 257		dquot_initialize(inode);
 258
 259		if (truncate && S_ISDIR(inode->i_mode)) {
 260			/* We got a truncate request for a dir which is impossible.
 261			   The only imaginable way is to execute unfinished truncate request
 262			   then boot into old kernel, remove the file and create dir with
 263			   the same key. */
 264			reiserfs_warning(s, "green-2101",
 265					 "impossible truncate on a "
 266					 "directory %k. Please report",
 267					 INODE_PKEY(inode));
 268			retval = remove_save_link_only(s, &save_link_key, 0);
 269			truncate = 0;
 270			iput(inode);
 271			continue;
 272		}
 273
 274		if (truncate) {
 275			REISERFS_I(inode)->i_flags |=
 276			    i_link_saved_truncate_mask;
 277			/* not completed truncate found. New size was committed together
 278			   with "save" link */
 279			reiserfs_info(s, "Truncating %k to %Ld ..",
 280				      INODE_PKEY(inode), inode->i_size);
 281			reiserfs_truncate_file(inode,
 282					       0
 283					       /*don't update modification time */
 284					       );
 285			retval = remove_save_link(inode, truncate);
 286		} else {
 287			REISERFS_I(inode)->i_flags |= i_link_saved_unlink_mask;
 288			/* not completed unlink (rmdir) found */
 289			reiserfs_info(s, "Removing %k..", INODE_PKEY(inode));
 290			if (memcmp(&last_inode_key, INODE_PKEY(inode),
 291					sizeof(last_inode_key))){
 292				last_inode_key = *INODE_PKEY(inode);
 293				/* removal gets completed in iput */
 294				retval = 0;
 295			} else {
 296				reiserfs_warning(s, "super-2189", "Dead loop "
 297						 "in finish_unfinished "
 298						 "detected, just remove "
 299						 "save link\n");
 300				retval = remove_save_link_only(s,
 301							&save_link_key, 0);
 302			}
 303		}
 304
 305		iput(inode);
 306		printk("done\n");
 307		done++;
 308	}
 309	REISERFS_SB(s)->s_is_unlinked_ok = 0;
 310
 311#ifdef CONFIG_QUOTA
 312	/* Turn quotas off */
 313	for (i = 0; i < MAXQUOTAS; i++) {
 314		if (sb_dqopt(s)->files[i] && quota_enabled[i])
 315			dquot_quota_off(s, i);
 316	}
 317	if (ms_active_set)
 318		/* Restore the flag back */
 319		s->s_flags &= ~MS_ACTIVE;
 320#endif
 321	pathrelse(&path);
 322	if (done)
 323		reiserfs_info(s, "There were %d uncompleted unlinks/truncates. "
 324			      "Completed\n", done);
 325	return retval;
 326}
 327
 328/* to protect file being unlinked from getting lost we "safe" link files
 329   being unlinked. This link will be deleted in the same transaction with last
 330   item of file. mounting the filesystem we scan all these links and remove
 331   files which almost got lost */
 332void add_save_link(struct reiserfs_transaction_handle *th,
 333		   struct inode *inode, int truncate)
 334{
 335	INITIALIZE_PATH(path);
 336	int retval;
 337	struct cpu_key key;
 338	struct item_head ih;
 339	__le32 link;
 340
 341	BUG_ON(!th->t_trans_id);
 342
 343	/* file can only get one "save link" of each kind */
 344	RFALSE(truncate &&
 345	       (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask),
 346	       "saved link already exists for truncated inode %lx",
 347	       (long)inode->i_ino);
 348	RFALSE(!truncate &&
 349	       (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask),
 350	       "saved link already exists for unlinked inode %lx",
 351	       (long)inode->i_ino);
 352
 353	/* setup key of "save" link */
 354	key.version = KEY_FORMAT_3_5;
 355	key.on_disk_key.k_dir_id = MAX_KEY_OBJECTID;
 356	key.on_disk_key.k_objectid = inode->i_ino;
 357	if (!truncate) {
 358		/* unlink, rmdir, rename */
 359		set_cpu_key_k_offset(&key, 1 + inode->i_sb->s_blocksize);
 360		set_cpu_key_k_type(&key, TYPE_DIRECT);
 361
 362		/* item head of "safe" link */
 363		make_le_item_head(&ih, &key, key.version,
 364				  1 + inode->i_sb->s_blocksize, TYPE_DIRECT,
 365				  4 /*length */ , 0xffff /*free space */ );
 366	} else {
 367		/* truncate */
 368		if (S_ISDIR(inode->i_mode))
 369			reiserfs_warning(inode->i_sb, "green-2102",
 370					 "Adding a truncate savelink for "
 371					 "a directory %k! Please report",
 372					 INODE_PKEY(inode));
 373		set_cpu_key_k_offset(&key, 1);
 374		set_cpu_key_k_type(&key, TYPE_INDIRECT);
 375
 376		/* item head of "safe" link */
 377		make_le_item_head(&ih, &key, key.version, 1, TYPE_INDIRECT,
 378				  4 /*length */ , 0 /*free space */ );
 379	}
 380	key.key_length = 3;
 381
 382	/* look for its place in the tree */
 383	retval = search_item(inode->i_sb, &key, &path);
 384	if (retval != ITEM_NOT_FOUND) {
 385		if (retval != -ENOSPC)
 386			reiserfs_error(inode->i_sb, "vs-2100",
 387				       "search_by_key (%K) returned %d", &key,
 388				       retval);
 389		pathrelse(&path);
 390		return;
 391	}
 392
 393	/* body of "save" link */
 394	link = INODE_PKEY(inode)->k_dir_id;
 395
 396	/* put "save" link into tree, don't charge quota to anyone */
 397	retval =
 398	    reiserfs_insert_item(th, &path, &key, &ih, NULL, (char *)&link);
 399	if (retval) {
 400		if (retval != -ENOSPC)
 401			reiserfs_error(inode->i_sb, "vs-2120",
 402				       "insert_item returned %d", retval);
 403	} else {
 404		if (truncate)
 405			REISERFS_I(inode)->i_flags |=
 406			    i_link_saved_truncate_mask;
 407		else
 408			REISERFS_I(inode)->i_flags |= i_link_saved_unlink_mask;
 409	}
 410}
 411
 412/* this opens transaction unlike add_save_link */
 413int remove_save_link(struct inode *inode, int truncate)
 414{
 415	struct reiserfs_transaction_handle th;
 416	struct reiserfs_key key;
 417	int err;
 418
 419	/* we are going to do one balancing only */
 420	err = journal_begin(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
 421	if (err)
 422		return err;
 423
 424	/* setup key of "save" link */
 425	key.k_dir_id = cpu_to_le32(MAX_KEY_OBJECTID);
 426	key.k_objectid = INODE_PKEY(inode)->k_objectid;
 427	if (!truncate) {
 428		/* unlink, rmdir, rename */
 429		set_le_key_k_offset(KEY_FORMAT_3_5, &key,
 430				    1 + inode->i_sb->s_blocksize);
 431		set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_DIRECT);
 432	} else {
 433		/* truncate */
 434		set_le_key_k_offset(KEY_FORMAT_3_5, &key, 1);
 435		set_le_key_k_type(KEY_FORMAT_3_5, &key, TYPE_INDIRECT);
 436	}
 437
 438	if ((truncate &&
 439	     (REISERFS_I(inode)->i_flags & i_link_saved_truncate_mask)) ||
 440	    (!truncate &&
 441	     (REISERFS_I(inode)->i_flags & i_link_saved_unlink_mask)))
 442		/* don't take quota bytes from anywhere */
 443		reiserfs_delete_solid_item(&th, NULL, &key);
 444	if (!truncate) {
 445		reiserfs_release_objectid(&th, inode->i_ino);
 446		REISERFS_I(inode)->i_flags &= ~i_link_saved_unlink_mask;
 447	} else
 448		REISERFS_I(inode)->i_flags &= ~i_link_saved_truncate_mask;
 449
 450	return journal_end(&th, inode->i_sb, JOURNAL_PER_BALANCE_CNT);
 451}
 452
 453static void reiserfs_kill_sb(struct super_block *s)
 454{
 455	if (REISERFS_SB(s)) {
 456		if (REISERFS_SB(s)->xattr_root) {
 457			d_invalidate(REISERFS_SB(s)->xattr_root);
 458			dput(REISERFS_SB(s)->xattr_root);
 459			REISERFS_SB(s)->xattr_root = NULL;
 460		}
 461		if (REISERFS_SB(s)->priv_root) {
 462			d_invalidate(REISERFS_SB(s)->priv_root);
 463			dput(REISERFS_SB(s)->priv_root);
 464			REISERFS_SB(s)->priv_root = NULL;
 465		}
 
 
 
 
 466	}
 467
 468	kill_block_super(s);
 469}
 470
 471static void reiserfs_put_super(struct super_block *s)
 472{
 473	struct reiserfs_transaction_handle th;
 474	th.t_trans_id = 0;
 475
 476	dquot_disable(s, -1, DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
 477
 478	reiserfs_write_lock(s);
 479
 480	if (s->s_dirt)
 481		reiserfs_write_super(s);
 482
 483	/* change file system state to current state if it was mounted with read-write permissions */
 484	if (!(s->s_flags & MS_RDONLY)) {
 485		if (!journal_begin(&th, s, 10)) {
 486			reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
 487						     1);
 488			set_sb_umount_state(SB_DISK_SUPER_BLOCK(s),
 489					    REISERFS_SB(s)->s_mount_state);
 490			journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
 491		}
 492	}
 493
 494	/* note, journal_release checks for readonly mount, and can decide not
 495	 ** to do a journal_end
 496	 */
 497	journal_release(&th, s);
 498
 499	reiserfs_free_bitmap_cache(s);
 500
 501	brelse(SB_BUFFER_WITH_SB(s));
 502
 503	print_statistics(s);
 504
 505	if (REISERFS_SB(s)->reserved_blocks != 0) {
 506		reiserfs_warning(s, "green-2005", "reserved blocks left %d",
 507				 REISERFS_SB(s)->reserved_blocks);
 508	}
 509
 510	reiserfs_proc_info_done(s);
 511
 512	reiserfs_write_unlock(s);
 513	mutex_destroy(&REISERFS_SB(s)->lock);
 514	kfree(s->s_fs_info);
 515	s->s_fs_info = NULL;
 516}
 517
 518static struct kmem_cache *reiserfs_inode_cachep;
 519
 520static struct inode *reiserfs_alloc_inode(struct super_block *sb)
 521{
 522	struct reiserfs_inode_info *ei;
 523	ei = (struct reiserfs_inode_info *)
 524	    kmem_cache_alloc(reiserfs_inode_cachep, GFP_KERNEL);
 525	if (!ei)
 526		return NULL;
 527	atomic_set(&ei->openers, 0);
 528	mutex_init(&ei->tailpack);
 529	return &ei->vfs_inode;
 530}
 531
 532static void reiserfs_i_callback(struct rcu_head *head)
 533{
 534	struct inode *inode = container_of(head, struct inode, i_rcu);
 535	INIT_LIST_HEAD(&inode->i_dentry);
 536	kmem_cache_free(reiserfs_inode_cachep, REISERFS_I(inode));
 537}
 538
 539static void reiserfs_destroy_inode(struct inode *inode)
 540{
 541	call_rcu(&inode->i_rcu, reiserfs_i_callback);
 542}
 543
 544static void init_once(void *foo)
 545{
 546	struct reiserfs_inode_info *ei = (struct reiserfs_inode_info *)foo;
 547
 548	INIT_LIST_HEAD(&ei->i_prealloc_list);
 549	inode_init_once(&ei->vfs_inode);
 550}
 551
 552static int init_inodecache(void)
 553{
 554	reiserfs_inode_cachep = kmem_cache_create("reiser_inode_cache",
 555						  sizeof(struct
 556							 reiserfs_inode_info),
 557						  0, (SLAB_RECLAIM_ACCOUNT|
 558							SLAB_MEM_SPREAD),
 559						  init_once);
 560	if (reiserfs_inode_cachep == NULL)
 561		return -ENOMEM;
 562	return 0;
 563}
 564
 565static void destroy_inodecache(void)
 566{
 567	kmem_cache_destroy(reiserfs_inode_cachep);
 568}
 569
 570/* we don't mark inodes dirty, we just log them */
 571static void reiserfs_dirty_inode(struct inode *inode, int flags)
 572{
 573	struct reiserfs_transaction_handle th;
 574
 575	int err = 0;
 576	int lock_depth;
 577
 578	if (inode->i_sb->s_flags & MS_RDONLY) {
 579		reiserfs_warning(inode->i_sb, "clm-6006",
 580				 "writing inode %lu on readonly FS",
 581				 inode->i_ino);
 582		return;
 583	}
 584	lock_depth = reiserfs_write_lock_once(inode->i_sb);
 585
 586	/* this is really only used for atime updates, so they don't have
 587	 ** to be included in O_SYNC or fsync
 588	 */
 589	err = journal_begin(&th, inode->i_sb, 1);
 590	if (err)
 591		goto out;
 592
 593	reiserfs_update_sd(&th, inode);
 594	journal_end(&th, inode->i_sb, 1);
 595
 596out:
 597	reiserfs_write_unlock_once(inode->i_sb, lock_depth);
 598}
 599
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 600#ifdef CONFIG_QUOTA
 601static ssize_t reiserfs_quota_write(struct super_block *, int, const char *,
 602				    size_t, loff_t);
 603static ssize_t reiserfs_quota_read(struct super_block *, int, char *, size_t,
 604				   loff_t);
 605#endif
 606
 607static const struct super_operations reiserfs_sops = {
 608	.alloc_inode = reiserfs_alloc_inode,
 609	.destroy_inode = reiserfs_destroy_inode,
 610	.write_inode = reiserfs_write_inode,
 611	.dirty_inode = reiserfs_dirty_inode,
 612	.evict_inode = reiserfs_evict_inode,
 613	.put_super = reiserfs_put_super,
 614	.write_super = reiserfs_write_super,
 615	.sync_fs = reiserfs_sync_fs,
 616	.freeze_fs = reiserfs_freeze,
 617	.unfreeze_fs = reiserfs_unfreeze,
 618	.statfs = reiserfs_statfs,
 619	.remount_fs = reiserfs_remount,
 620	.show_options = generic_show_options,
 621#ifdef CONFIG_QUOTA
 622	.quota_read = reiserfs_quota_read,
 623	.quota_write = reiserfs_quota_write,
 624#endif
 625};
 626
 627#ifdef CONFIG_QUOTA
 628#define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
 629
 630static int reiserfs_write_dquot(struct dquot *);
 631static int reiserfs_acquire_dquot(struct dquot *);
 632static int reiserfs_release_dquot(struct dquot *);
 633static int reiserfs_mark_dquot_dirty(struct dquot *);
 634static int reiserfs_write_info(struct super_block *, int);
 635static int reiserfs_quota_on(struct super_block *, int, int, struct path *);
 636
 637static const struct dquot_operations reiserfs_quota_operations = {
 638	.write_dquot = reiserfs_write_dquot,
 639	.acquire_dquot = reiserfs_acquire_dquot,
 640	.release_dquot = reiserfs_release_dquot,
 641	.mark_dirty = reiserfs_mark_dquot_dirty,
 642	.write_info = reiserfs_write_info,
 643	.alloc_dquot	= dquot_alloc,
 644	.destroy_dquot	= dquot_destroy,
 645};
 646
 647static const struct quotactl_ops reiserfs_qctl_operations = {
 648	.quota_on = reiserfs_quota_on,
 649	.quota_off = dquot_quota_off,
 650	.quota_sync = dquot_quota_sync,
 651	.get_info = dquot_get_dqinfo,
 652	.set_info = dquot_set_dqinfo,
 653	.get_dqblk = dquot_get_dqblk,
 654	.set_dqblk = dquot_set_dqblk,
 655};
 656#endif
 657
 658static const struct export_operations reiserfs_export_ops = {
 659	.encode_fh = reiserfs_encode_fh,
 660	.fh_to_dentry = reiserfs_fh_to_dentry,
 661	.fh_to_parent = reiserfs_fh_to_parent,
 662	.get_parent = reiserfs_get_parent,
 663};
 664
 665/* this struct is used in reiserfs_getopt () for containing the value for those
 666   mount options that have values rather than being toggles. */
 667typedef struct {
 668	char *value;
 669	int setmask;		/* bitmask which is to set on mount_options bitmask when this
 670				   value is found, 0 is no bits are to be changed. */
 671	int clrmask;		/* bitmask which is to clear on mount_options bitmask when  this
 672				   value is found, 0 is no bits are to be changed. This is
 673				   applied BEFORE setmask */
 674} arg_desc_t;
 675
 676/* Set this bit in arg_required to allow empty arguments */
 677#define REISERFS_OPT_ALLOWEMPTY 31
 678
 679/* this struct is used in reiserfs_getopt() for describing the set of reiserfs
 680   mount options */
 681typedef struct {
 682	char *option_name;
 683	int arg_required;	/* 0 if argument is not required, not 0 otherwise */
 684	const arg_desc_t *values;	/* list of values accepted by an option */
 685	int setmask;		/* bitmask which is to set on mount_options bitmask when this
 686				   value is found, 0 is no bits are to be changed. */
 687	int clrmask;		/* bitmask which is to clear on mount_options bitmask when  this
 688				   value is found, 0 is no bits are to be changed. This is
 689				   applied BEFORE setmask */
 690} opt_desc_t;
 691
 692/* possible values for -o data= */
 693static const arg_desc_t logging_mode[] = {
 694	{"ordered", 1 << REISERFS_DATA_ORDERED,
 695	 (1 << REISERFS_DATA_LOG | 1 << REISERFS_DATA_WRITEBACK)},
 696	{"journal", 1 << REISERFS_DATA_LOG,
 697	 (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_WRITEBACK)},
 698	{"writeback", 1 << REISERFS_DATA_WRITEBACK,
 699	 (1 << REISERFS_DATA_ORDERED | 1 << REISERFS_DATA_LOG)},
 700	{.value = NULL}
 701};
 702
 703/* possible values for -o barrier= */
 704static const arg_desc_t barrier_mode[] = {
 705	{"none", 1 << REISERFS_BARRIER_NONE, 1 << REISERFS_BARRIER_FLUSH},
 706	{"flush", 1 << REISERFS_BARRIER_FLUSH, 1 << REISERFS_BARRIER_NONE},
 707	{.value = NULL}
 708};
 709
 710/* possible values for "-o block-allocator=" and bits which are to be set in
 711   s_mount_opt of reiserfs specific part of in-core super block */
 712static const arg_desc_t balloc[] = {
 713	{"noborder", 1 << REISERFS_NO_BORDER, 0},
 714	{"border", 0, 1 << REISERFS_NO_BORDER},
 715	{"no_unhashed_relocation", 1 << REISERFS_NO_UNHASHED_RELOCATION, 0},
 716	{"hashed_relocation", 1 << REISERFS_HASHED_RELOCATION, 0},
 717	{"test4", 1 << REISERFS_TEST4, 0},
 718	{"notest4", 0, 1 << REISERFS_TEST4},
 719	{NULL, 0, 0}
 720};
 721
 722static const arg_desc_t tails[] = {
 723	{"on", 1 << REISERFS_LARGETAIL, 1 << REISERFS_SMALLTAIL},
 724	{"off", 0, (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)},
 725	{"small", 1 << REISERFS_SMALLTAIL, 1 << REISERFS_LARGETAIL},
 726	{NULL, 0, 0}
 727};
 728
 729static const arg_desc_t error_actions[] = {
 730	{"panic", 1 << REISERFS_ERROR_PANIC,
 731	 (1 << REISERFS_ERROR_RO | 1 << REISERFS_ERROR_CONTINUE)},
 732	{"ro-remount", 1 << REISERFS_ERROR_RO,
 733	 (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_CONTINUE)},
 734#ifdef REISERFS_JOURNAL_ERROR_ALLOWS_NO_LOG
 735	{"continue", 1 << REISERFS_ERROR_CONTINUE,
 736	 (1 << REISERFS_ERROR_PANIC | 1 << REISERFS_ERROR_RO)},
 737#endif
 738	{NULL, 0, 0},
 739};
 740
 741/* proceed only one option from a list *cur - string containing of mount options
 742   opts - array of options which are accepted
 743   opt_arg - if option is found and requires an argument and if it is specifed
 744   in the input - pointer to the argument is stored here
 745   bit_flags - if option requires to set a certain bit - it is set here
 746   return -1 if unknown option is found, opt->arg_required otherwise */
 747static int reiserfs_getopt(struct super_block *s, char **cur, opt_desc_t * opts,
 748			   char **opt_arg, unsigned long *bit_flags)
 749{
 750	char *p;
 751	/* foo=bar,
 752	   ^   ^  ^
 753	   |   |  +-- option_end
 754	   |   +-- arg_start
 755	   +-- option_start
 756	 */
 757	const opt_desc_t *opt;
 758	const arg_desc_t *arg;
 759
 760	p = *cur;
 761
 762	/* assume argument cannot contain commas */
 763	*cur = strchr(p, ',');
 764	if (*cur) {
 765		*(*cur) = '\0';
 766		(*cur)++;
 767	}
 768
 769	if (!strncmp(p, "alloc=", 6)) {
 770		/* Ugly special case, probably we should redo options parser so that
 771		   it can understand several arguments for some options, also so that
 772		   it can fill several bitfields with option values. */
 773		if (reiserfs_parse_alloc_options(s, p + 6)) {
 774			return -1;
 775		} else {
 776			return 0;
 777		}
 778	}
 779
 780	/* for every option in the list */
 781	for (opt = opts; opt->option_name; opt++) {
 782		if (!strncmp(p, opt->option_name, strlen(opt->option_name))) {
 783			if (bit_flags) {
 784				if (opt->clrmask ==
 785				    (1 << REISERFS_UNSUPPORTED_OPT))
 786					reiserfs_warning(s, "super-6500",
 787							 "%s not supported.\n",
 788							 p);
 789				else
 790					*bit_flags &= ~opt->clrmask;
 791				if (opt->setmask ==
 792				    (1 << REISERFS_UNSUPPORTED_OPT))
 793					reiserfs_warning(s, "super-6501",
 794							 "%s not supported.\n",
 795							 p);
 796				else
 797					*bit_flags |= opt->setmask;
 798			}
 799			break;
 800		}
 801	}
 802	if (!opt->option_name) {
 803		reiserfs_warning(s, "super-6502",
 804				 "unknown mount option \"%s\"", p);
 805		return -1;
 806	}
 807
 808	p += strlen(opt->option_name);
 809	switch (*p) {
 810	case '=':
 811		if (!opt->arg_required) {
 812			reiserfs_warning(s, "super-6503",
 813					 "the option \"%s\" does not "
 814					 "require an argument\n",
 815					 opt->option_name);
 816			return -1;
 817		}
 818		break;
 819
 820	case 0:
 821		if (opt->arg_required) {
 822			reiserfs_warning(s, "super-6504",
 823					 "the option \"%s\" requires an "
 824					 "argument\n", opt->option_name);
 825			return -1;
 826		}
 827		break;
 828	default:
 829		reiserfs_warning(s, "super-6505",
 830				 "head of option \"%s\" is only correct\n",
 831				 opt->option_name);
 832		return -1;
 833	}
 834
 835	/* move to the argument, or to next option if argument is not required */
 836	p++;
 837
 838	if (opt->arg_required
 839	    && !(opt->arg_required & (1 << REISERFS_OPT_ALLOWEMPTY))
 840	    && !strlen(p)) {
 841		/* this catches "option=," if not allowed */
 842		reiserfs_warning(s, "super-6506",
 843				 "empty argument for \"%s\"\n",
 844				 opt->option_name);
 845		return -1;
 846	}
 847
 848	if (!opt->values) {
 849		/* *=NULLopt_arg contains pointer to argument */
 850		*opt_arg = p;
 851		return opt->arg_required & ~(1 << REISERFS_OPT_ALLOWEMPTY);
 852	}
 853
 854	/* values possible for this option are listed in opt->values */
 855	for (arg = opt->values; arg->value; arg++) {
 856		if (!strcmp(p, arg->value)) {
 857			if (bit_flags) {
 858				*bit_flags &= ~arg->clrmask;
 859				*bit_flags |= arg->setmask;
 860			}
 861			return opt->arg_required;
 862		}
 863	}
 864
 865	reiserfs_warning(s, "super-6506",
 866			 "bad value \"%s\" for option \"%s\"\n", p,
 867			 opt->option_name);
 868	return -1;
 869}
 870
 871/* returns 0 if something is wrong in option string, 1 - otherwise */
 872static int reiserfs_parse_options(struct super_block *s, char *options,	/* string given via mount's -o */
 873				  unsigned long *mount_options,
 874				  /* after the parsing phase, contains the
 875				     collection of bitflags defining what
 876				     mount options were selected. */
 877				  unsigned long *blocks,	/* strtol-ed from NNN of resize=NNN */
 878				  char **jdev_name,
 879				  unsigned int *commit_max_age,
 880				  char **qf_names,
 881				  unsigned int *qfmt)
 882{
 883	int c;
 884	char *arg = NULL;
 885	char *pos;
 886	opt_desc_t opts[] = {
 887		/* Compatibility stuff, so that -o notail for old setups still work */
 888		{"tails",.arg_required = 't',.values = tails},
 889		{"notail",.clrmask =
 890		 (1 << REISERFS_LARGETAIL) | (1 << REISERFS_SMALLTAIL)},
 891		{"conv",.setmask = 1 << REISERFS_CONVERT},
 892		{"attrs",.setmask = 1 << REISERFS_ATTRS},
 893		{"noattrs",.clrmask = 1 << REISERFS_ATTRS},
 894		{"expose_privroot", .setmask = 1 << REISERFS_EXPOSE_PRIVROOT},
 895#ifdef CONFIG_REISERFS_FS_XATTR
 896		{"user_xattr",.setmask = 1 << REISERFS_XATTRS_USER},
 897		{"nouser_xattr",.clrmask = 1 << REISERFS_XATTRS_USER},
 898#else
 899		{"user_xattr",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
 900		{"nouser_xattr",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
 901#endif
 902#ifdef CONFIG_REISERFS_FS_POSIX_ACL
 903		{"acl",.setmask = 1 << REISERFS_POSIXACL},
 904		{"noacl",.clrmask = 1 << REISERFS_POSIXACL},
 905#else
 906		{"acl",.setmask = 1 << REISERFS_UNSUPPORTED_OPT},
 907		{"noacl",.clrmask = 1 << REISERFS_UNSUPPORTED_OPT},
 908#endif
 909		{.option_name = "nolog"},
 910		{"replayonly",.setmask = 1 << REPLAYONLY},
 911		{"block-allocator",.arg_required = 'a',.values = balloc},
 912		{"data",.arg_required = 'd',.values = logging_mode},
 913		{"barrier",.arg_required = 'b',.values = barrier_mode},
 914		{"resize",.arg_required = 'r',.values = NULL},
 915		{"jdev",.arg_required = 'j',.values = NULL},
 916		{"nolargeio",.arg_required = 'w',.values = NULL},
 917		{"commit",.arg_required = 'c',.values = NULL},
 918		{"usrquota",.setmask = 1 << REISERFS_QUOTA},
 919		{"grpquota",.setmask = 1 << REISERFS_QUOTA},
 920		{"noquota",.clrmask = 1 << REISERFS_QUOTA},
 921		{"errors",.arg_required = 'e',.values = error_actions},
 922		{"usrjquota",.arg_required =
 923		 'u' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
 924		{"grpjquota",.arg_required =
 925		 'g' | (1 << REISERFS_OPT_ALLOWEMPTY),.values = NULL},
 926		{"jqfmt",.arg_required = 'f',.values = NULL},
 927		{.option_name = NULL}
 928	};
 929
 930	*blocks = 0;
 931	if (!options || !*options)
 932		/* use default configuration: create tails, journaling on, no
 933		   conversion to newest format */
 934		return 1;
 935
 936	for (pos = options; pos;) {
 937		c = reiserfs_getopt(s, &pos, opts, &arg, mount_options);
 938		if (c == -1)
 939			/* wrong option is given */
 940			return 0;
 941
 942		if (c == 'r') {
 943			char *p;
 944
 945			p = NULL;
 946			/* "resize=NNN" or "resize=auto" */
 947
 948			if (!strcmp(arg, "auto")) {
 949				/* From JFS code, to auto-get the size. */
 950				*blocks =
 951				    s->s_bdev->bd_inode->i_size >> s->
 952				    s_blocksize_bits;
 953			} else {
 954				*blocks = simple_strtoul(arg, &p, 0);
 955				if (*p != '\0') {
 956					/* NNN does not look like a number */
 957					reiserfs_warning(s, "super-6507",
 958							 "bad value %s for "
 959							 "-oresize\n", arg);
 960					return 0;
 961				}
 962			}
 963		}
 964
 965		if (c == 'c') {
 966			char *p = NULL;
 967			unsigned long val = simple_strtoul(arg, &p, 0);
 968			/* commit=NNN (time in seconds) */
 969			if (*p != '\0' || val >= (unsigned int)-1) {
 970				reiserfs_warning(s, "super-6508",
 971						 "bad value %s for -ocommit\n",
 972						 arg);
 973				return 0;
 974			}
 975			*commit_max_age = (unsigned int)val;
 976		}
 977
 978		if (c == 'w') {
 979			reiserfs_warning(s, "super-6509", "nolargeio option "
 980					 "is no longer supported");
 981			return 0;
 982		}
 983
 984		if (c == 'j') {
 985			if (arg && *arg && jdev_name) {
 986				if (*jdev_name) {	//Hm, already assigned?
 987					reiserfs_warning(s, "super-6510",
 988							 "journal device was "
 989							 "already specified to "
 990							 "be %s", *jdev_name);
 991					return 0;
 992				}
 993				*jdev_name = arg;
 994			}
 995		}
 996#ifdef CONFIG_QUOTA
 997		if (c == 'u' || c == 'g') {
 998			int qtype = c == 'u' ? USRQUOTA : GRPQUOTA;
 999
1000			if (sb_any_quota_loaded(s) &&
1001			    (!*arg != !REISERFS_SB(s)->s_qf_names[qtype])) {
1002				reiserfs_warning(s, "super-6511",
1003						 "cannot change journaled "
1004						 "quota options when quota "
1005						 "turned on.");
1006				return 0;
1007			}
1008			if (*arg) {	/* Some filename specified? */
1009				if (REISERFS_SB(s)->s_qf_names[qtype]
1010				    && strcmp(REISERFS_SB(s)->s_qf_names[qtype],
1011					      arg)) {
1012					reiserfs_warning(s, "super-6512",
1013							 "%s quota file "
1014							 "already specified.",
1015							 QTYPE2NAME(qtype));
1016					return 0;
1017				}
1018				if (strchr(arg, '/')) {
1019					reiserfs_warning(s, "super-6513",
1020							 "quotafile must be "
1021							 "on filesystem root.");
1022					return 0;
1023				}
1024				qf_names[qtype] =
1025				    kmalloc(strlen(arg) + 1, GFP_KERNEL);
1026				if (!qf_names[qtype]) {
1027					reiserfs_warning(s, "reiserfs-2502",
1028							 "not enough memory "
1029							 "for storing "
1030							 "quotafile name.");
1031					return 0;
1032				}
1033				strcpy(qf_names[qtype], arg);
1034				*mount_options |= 1 << REISERFS_QUOTA;
 
 
 
1035			} else {
1036				if (qf_names[qtype] !=
1037				    REISERFS_SB(s)->s_qf_names[qtype])
1038					kfree(qf_names[qtype]);
1039				qf_names[qtype] = NULL;
 
 
 
 
1040			}
1041		}
1042		if (c == 'f') {
1043			if (!strcmp(arg, "vfsold"))
1044				*qfmt = QFMT_VFS_OLD;
1045			else if (!strcmp(arg, "vfsv0"))
1046				*qfmt = QFMT_VFS_V0;
1047			else {
1048				reiserfs_warning(s, "super-6514",
1049						 "unknown quota format "
1050						 "specified.");
1051				return 0;
1052			}
1053			if (sb_any_quota_loaded(s) &&
1054			    *qfmt != REISERFS_SB(s)->s_jquota_fmt) {
1055				reiserfs_warning(s, "super-6515",
1056						 "cannot change journaled "
1057						 "quota options when quota "
1058						 "turned on.");
1059				return 0;
1060			}
1061		}
1062#else
1063		if (c == 'u' || c == 'g' || c == 'f') {
1064			reiserfs_warning(s, "reiserfs-2503", "journaled "
1065					 "quota options not supported.");
1066			return 0;
1067		}
1068#endif
1069	}
1070
1071#ifdef CONFIG_QUOTA
1072	if (!REISERFS_SB(s)->s_jquota_fmt && !*qfmt
1073	    && (qf_names[USRQUOTA] || qf_names[GRPQUOTA])) {
1074		reiserfs_warning(s, "super-6515",
1075				 "journaled quota format not specified.");
1076		return 0;
1077	}
1078	/* This checking is not precise wrt the quota type but for our purposes it is sufficient */
1079	if (!(*mount_options & (1 << REISERFS_QUOTA))
1080	    && sb_any_quota_loaded(s)) {
 
1081		reiserfs_warning(s, "super-6516", "quota options must "
1082				 "be present when quota is turned on.");
1083		return 0;
1084	}
1085#endif
1086
1087	return 1;
1088}
1089
1090static void switch_data_mode(struct super_block *s, unsigned long mode)
1091{
1092	REISERFS_SB(s)->s_mount_opt &= ~((1 << REISERFS_DATA_LOG) |
1093					 (1 << REISERFS_DATA_ORDERED) |
1094					 (1 << REISERFS_DATA_WRITEBACK));
1095	REISERFS_SB(s)->s_mount_opt |= (1 << mode);
1096}
1097
1098static void handle_data_mode(struct super_block *s, unsigned long mount_options)
1099{
1100	if (mount_options & (1 << REISERFS_DATA_LOG)) {
1101		if (!reiserfs_data_log(s)) {
1102			switch_data_mode(s, REISERFS_DATA_LOG);
1103			reiserfs_info(s, "switching to journaled data mode\n");
1104		}
1105	} else if (mount_options & (1 << REISERFS_DATA_ORDERED)) {
1106		if (!reiserfs_data_ordered(s)) {
1107			switch_data_mode(s, REISERFS_DATA_ORDERED);
1108			reiserfs_info(s, "switching to ordered data mode\n");
1109		}
1110	} else if (mount_options & (1 << REISERFS_DATA_WRITEBACK)) {
1111		if (!reiserfs_data_writeback(s)) {
1112			switch_data_mode(s, REISERFS_DATA_WRITEBACK);
1113			reiserfs_info(s, "switching to writeback data mode\n");
1114		}
1115	}
1116}
1117
1118static void handle_barrier_mode(struct super_block *s, unsigned long bits)
1119{
1120	int flush = (1 << REISERFS_BARRIER_FLUSH);
1121	int none = (1 << REISERFS_BARRIER_NONE);
1122	int all_barrier = flush | none;
1123
1124	if (bits & all_barrier) {
1125		REISERFS_SB(s)->s_mount_opt &= ~all_barrier;
1126		if (bits & flush) {
1127			REISERFS_SB(s)->s_mount_opt |= flush;
1128			printk("reiserfs: enabling write barrier flush mode\n");
1129		} else if (bits & none) {
1130			REISERFS_SB(s)->s_mount_opt |= none;
1131			printk("reiserfs: write barriers turned off\n");
1132		}
1133	}
1134}
1135
1136static void handle_attrs(struct super_block *s)
1137{
1138	struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(s);
1139
1140	if (reiserfs_attrs(s)) {
1141		if (old_format_only(s)) {
1142			reiserfs_warning(s, "super-6517", "cannot support "
1143					 "attributes on 3.5.x disk format");
1144			REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
1145			return;
1146		}
1147		if (!(le32_to_cpu(rs->s_flags) & reiserfs_attrs_cleared)) {
1148			reiserfs_warning(s, "super-6518", "cannot support "
1149					 "attributes until flag is set in "
1150					 "super-block");
1151			REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_ATTRS);
1152		}
1153	}
1154}
1155
1156#ifdef CONFIG_QUOTA
1157static void handle_quota_files(struct super_block *s, char **qf_names,
1158			       unsigned int *qfmt)
1159{
1160	int i;
1161
1162	for (i = 0; i < MAXQUOTAS; i++) {
1163		if (qf_names[i] != REISERFS_SB(s)->s_qf_names[i])
1164			kfree(REISERFS_SB(s)->s_qf_names[i]);
1165		REISERFS_SB(s)->s_qf_names[i] = qf_names[i];
1166	}
1167	REISERFS_SB(s)->s_jquota_fmt = *qfmt;
 
1168}
1169#endif
1170
1171static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
1172{
1173	struct reiserfs_super_block *rs;
1174	struct reiserfs_transaction_handle th;
1175	unsigned long blocks;
1176	unsigned long mount_options = REISERFS_SB(s)->s_mount_opt;
1177	unsigned long safe_mask = 0;
1178	unsigned int commit_max_age = (unsigned int)-1;
1179	struct reiserfs_journal *journal = SB_JOURNAL(s);
1180	char *new_opts = kstrdup(arg, GFP_KERNEL);
1181	int err;
1182	char *qf_names[MAXQUOTAS];
1183	unsigned int qfmt = 0;
1184#ifdef CONFIG_QUOTA
1185	int i;
1186#endif
1187
1188	reiserfs_write_lock(s);
1189
1190#ifdef CONFIG_QUOTA
1191	memcpy(qf_names, REISERFS_SB(s)->s_qf_names, sizeof(qf_names));
1192#endif
1193
1194	rs = SB_DISK_SUPER_BLOCK(s);
1195
1196	if (!reiserfs_parse_options
1197	    (s, arg, &mount_options, &blocks, NULL, &commit_max_age,
1198	    qf_names, &qfmt)) {
1199#ifdef CONFIG_QUOTA
1200		for (i = 0; i < MAXQUOTAS; i++)
1201			if (qf_names[i] != REISERFS_SB(s)->s_qf_names[i])
1202				kfree(qf_names[i]);
1203#endif
1204		err = -EINVAL;
1205		goto out_err;
1206	}
1207#ifdef CONFIG_QUOTA
1208	handle_quota_files(s, qf_names, &qfmt);
1209#endif
1210
1211	handle_attrs(s);
1212
1213	/* Add options that are safe here */
1214	safe_mask |= 1 << REISERFS_SMALLTAIL;
1215	safe_mask |= 1 << REISERFS_LARGETAIL;
1216	safe_mask |= 1 << REISERFS_NO_BORDER;
1217	safe_mask |= 1 << REISERFS_NO_UNHASHED_RELOCATION;
1218	safe_mask |= 1 << REISERFS_HASHED_RELOCATION;
1219	safe_mask |= 1 << REISERFS_TEST4;
1220	safe_mask |= 1 << REISERFS_ATTRS;
1221	safe_mask |= 1 << REISERFS_XATTRS_USER;
1222	safe_mask |= 1 << REISERFS_POSIXACL;
1223	safe_mask |= 1 << REISERFS_BARRIER_FLUSH;
1224	safe_mask |= 1 << REISERFS_BARRIER_NONE;
1225	safe_mask |= 1 << REISERFS_ERROR_RO;
1226	safe_mask |= 1 << REISERFS_ERROR_CONTINUE;
1227	safe_mask |= 1 << REISERFS_ERROR_PANIC;
1228	safe_mask |= 1 << REISERFS_QUOTA;
 
1229
1230	/* Update the bitmask, taking care to keep
1231	 * the bits we're not allowed to change here */
1232	REISERFS_SB(s)->s_mount_opt =
1233	    (REISERFS_SB(s)->
1234	     s_mount_opt & ~safe_mask) | (mount_options & safe_mask);
1235
1236	if (commit_max_age != 0 && commit_max_age != (unsigned int)-1) {
1237		journal->j_max_commit_age = commit_max_age;
1238		journal->j_max_trans_age = commit_max_age;
1239	} else if (commit_max_age == 0) {
1240		/* 0 means restore defaults. */
1241		journal->j_max_commit_age = journal->j_default_max_commit_age;
1242		journal->j_max_trans_age = JOURNAL_MAX_TRANS_AGE;
1243	}
1244
1245	if (blocks) {
1246		err = reiserfs_resize(s, blocks);
1247		if (err != 0)
1248			goto out_err;
1249	}
1250
1251	if (*mount_flags & MS_RDONLY) {
1252		reiserfs_xattr_init(s, *mount_flags);
1253		/* remount read-only */
1254		if (s->s_flags & MS_RDONLY)
1255			/* it is read-only already */
1256			goto out_ok;
1257
1258		err = dquot_suspend(s, -1);
1259		if (err < 0)
1260			goto out_err;
1261
1262		/* try to remount file system with read-only permissions */
1263		if (sb_umount_state(rs) == REISERFS_VALID_FS
1264		    || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) {
1265			goto out_ok;
1266		}
1267
1268		err = journal_begin(&th, s, 10);
1269		if (err)
1270			goto out_err;
1271
1272		/* Mounting a rw partition read-only. */
1273		reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1274		set_sb_umount_state(rs, REISERFS_SB(s)->s_mount_state);
1275		journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1276	} else {
1277		/* remount read-write */
1278		if (!(s->s_flags & MS_RDONLY)) {
1279			reiserfs_xattr_init(s, *mount_flags);
1280			goto out_ok;	/* We are read-write already */
1281		}
1282
1283		if (reiserfs_is_journal_aborted(journal)) {
1284			err = journal->j_errno;
1285			goto out_err;
1286		}
1287
1288		handle_data_mode(s, mount_options);
1289		handle_barrier_mode(s, mount_options);
1290		REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1291		s->s_flags &= ~MS_RDONLY;	/* now it is safe to call journal_begin */
1292		err = journal_begin(&th, s, 10);
1293		if (err)
1294			goto out_err;
1295
1296		/* Mount a partition which is read-only, read-write */
1297		reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1298		REISERFS_SB(s)->s_mount_state = sb_umount_state(rs);
1299		s->s_flags &= ~MS_RDONLY;
1300		set_sb_umount_state(rs, REISERFS_ERROR_FS);
1301		if (!old_format_only(s))
1302			set_sb_mnt_count(rs, sb_mnt_count(rs) + 1);
1303		/* mark_buffer_dirty (SB_BUFFER_WITH_SB (s), 1); */
1304		journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1305		REISERFS_SB(s)->s_mount_state = REISERFS_VALID_FS;
1306	}
1307	/* this will force a full flush of all journal lists */
1308	SB_JOURNAL(s)->j_must_wait = 1;
1309	err = journal_end(&th, s, 10);
1310	if (err)
1311		goto out_err;
1312	s->s_dirt = 0;
1313
1314	if (!(*mount_flags & MS_RDONLY)) {
1315		dquot_resume(s, -1);
1316		finish_unfinished(s);
1317		reiserfs_xattr_init(s, *mount_flags);
1318	}
1319
1320out_ok:
1321	replace_mount_options(s, new_opts);
1322	reiserfs_write_unlock(s);
1323	return 0;
1324
1325out_err:
1326	kfree(new_opts);
1327	reiserfs_write_unlock(s);
1328	return err;
1329}
1330
1331static int read_super_block(struct super_block *s, int offset)
1332{
1333	struct buffer_head *bh;
1334	struct reiserfs_super_block *rs;
1335	int fs_blocksize;
1336
1337	bh = sb_bread(s, offset / s->s_blocksize);
1338	if (!bh) {
1339		reiserfs_warning(s, "sh-2006",
1340				 "bread failed (dev %s, block %lu, size %lu)",
1341				 reiserfs_bdevname(s), offset / s->s_blocksize,
1342				 s->s_blocksize);
1343		return 1;
1344	}
1345
1346	rs = (struct reiserfs_super_block *)bh->b_data;
1347	if (!is_any_reiserfs_magic_string(rs)) {
1348		brelse(bh);
1349		return 1;
1350	}
1351	//
1352	// ok, reiserfs signature (old or new) found in at the given offset
1353	//
1354	fs_blocksize = sb_blocksize(rs);
1355	brelse(bh);
1356	sb_set_blocksize(s, fs_blocksize);
1357
1358	bh = sb_bread(s, offset / s->s_blocksize);
1359	if (!bh) {
1360		reiserfs_warning(s, "sh-2007",
1361				 "bread failed (dev %s, block %lu, size %lu)",
1362				 reiserfs_bdevname(s), offset / s->s_blocksize,
1363				 s->s_blocksize);
1364		return 1;
1365	}
1366
1367	rs = (struct reiserfs_super_block *)bh->b_data;
1368	if (sb_blocksize(rs) != s->s_blocksize) {
1369		reiserfs_warning(s, "sh-2011", "can't find a reiserfs "
1370				 "filesystem on (dev %s, block %Lu, size %lu)",
1371				 reiserfs_bdevname(s),
1372				 (unsigned long long)bh->b_blocknr,
1373				 s->s_blocksize);
1374		brelse(bh);
1375		return 1;
1376	}
1377
1378	if (rs->s_v1.s_root_block == cpu_to_le32(-1)) {
1379		brelse(bh);
1380		reiserfs_warning(s, "super-6519", "Unfinished reiserfsck "
1381				 "--rebuild-tree run detected. Please run\n"
1382				 "reiserfsck --rebuild-tree and wait for a "
1383				 "completion. If that fails\n"
1384				 "get newer reiserfsprogs package");
1385		return 1;
1386	}
1387
1388	SB_BUFFER_WITH_SB(s) = bh;
1389	SB_DISK_SUPER_BLOCK(s) = rs;
1390
1391	if (is_reiserfs_jr(rs)) {
1392		/* magic is of non-standard journal filesystem, look at s_version to
1393		   find which format is in use */
1394		if (sb_version(rs) == REISERFS_VERSION_2)
1395			reiserfs_info(s, "found reiserfs format \"3.6\""
1396				      " with non-standard journal\n");
1397		else if (sb_version(rs) == REISERFS_VERSION_1)
1398			reiserfs_info(s, "found reiserfs format \"3.5\""
1399				      " with non-standard journal\n");
1400		else {
1401			reiserfs_warning(s, "sh-2012", "found unknown "
1402					 "format \"%u\" of reiserfs with "
1403					 "non-standard magic", sb_version(rs));
1404			return 1;
1405		}
1406	} else
1407		/* s_version of standard format may contain incorrect information,
1408		   so we just look at the magic string */
1409		reiserfs_info(s,
1410			      "found reiserfs format \"%s\" with standard journal\n",
1411			      is_reiserfs_3_5(rs) ? "3.5" : "3.6");
1412
1413	s->s_op = &reiserfs_sops;
1414	s->s_export_op = &reiserfs_export_ops;
1415#ifdef CONFIG_QUOTA
1416	s->s_qcop = &reiserfs_qctl_operations;
1417	s->dq_op = &reiserfs_quota_operations;
1418#endif
1419
1420	/* new format is limited by the 32 bit wide i_blocks field, want to
1421	 ** be one full block below that.
1422	 */
1423	s->s_maxbytes = (512LL << 32) - s->s_blocksize;
1424	return 0;
1425}
1426
1427/* after journal replay, reread all bitmap and super blocks */
1428static int reread_meta_blocks(struct super_block *s)
1429{
1430	ll_rw_block(READ, 1, &(SB_BUFFER_WITH_SB(s)));
1431	reiserfs_write_unlock(s);
1432	wait_on_buffer(SB_BUFFER_WITH_SB(s));
1433	reiserfs_write_lock(s);
1434	if (!buffer_uptodate(SB_BUFFER_WITH_SB(s))) {
1435		reiserfs_warning(s, "reiserfs-2504", "error reading the super");
1436		return 1;
1437	}
1438
1439	return 0;
1440}
1441
1442/////////////////////////////////////////////////////
1443// hash detection stuff
1444
1445// if root directory is empty - we set default - Yura's - hash and
1446// warn about it
1447// FIXME: we look for only one name in a directory. If tea and yura
1448// bith have the same value - we ask user to send report to the
1449// mailing list
1450static __u32 find_hash_out(struct super_block *s)
1451{
1452	int retval;
1453	struct inode *inode;
1454	struct cpu_key key;
1455	INITIALIZE_PATH(path);
1456	struct reiserfs_dir_entry de;
1457	__u32 hash = DEFAULT_HASH;
1458
1459	inode = s->s_root->d_inode;
1460
1461	do {			// Some serious "goto"-hater was there ;)
1462		u32 teahash, r5hash, yurahash;
1463
1464		make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3);
1465		retval = search_by_entry_key(s, &key, &path, &de);
1466		if (retval == IO_ERROR) {
1467			pathrelse(&path);
1468			return UNSET_HASH;
1469		}
1470		if (retval == NAME_NOT_FOUND)
1471			de.de_entry_num--;
1472		set_de_name_and_namelen(&de);
1473		if (deh_offset(&(de.de_deh[de.de_entry_num])) == DOT_DOT_OFFSET) {
1474			/* allow override in this case */
1475			if (reiserfs_rupasov_hash(s)) {
1476				hash = YURA_HASH;
1477			}
1478			reiserfs_info(s, "FS seems to be empty, autodetect "
1479					 "is using the default hash\n");
1480			break;
1481		}
1482		r5hash = GET_HASH_VALUE(r5_hash(de.de_name, de.de_namelen));
1483		teahash = GET_HASH_VALUE(keyed_hash(de.de_name, de.de_namelen));
1484		yurahash = GET_HASH_VALUE(yura_hash(de.de_name, de.de_namelen));
1485		if (((teahash == r5hash)
1486		     &&
1487		     (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num])))
1488		      == r5hash)) || ((teahash == yurahash)
1489				      && (yurahash ==
1490					  GET_HASH_VALUE(deh_offset
1491							 (&
1492							  (de.
1493							   de_deh[de.
1494								  de_entry_num])))))
1495		    || ((r5hash == yurahash)
1496			&& (yurahash ==
1497			    GET_HASH_VALUE(deh_offset
1498					   (&(de.de_deh[de.de_entry_num])))))) {
1499			reiserfs_warning(s, "reiserfs-2506", "Unable to "
1500					 "automatically detect hash function. "
1501					 "Please mount with -o "
1502					 "hash={tea,rupasov,r5}");
1503			hash = UNSET_HASH;
1504			break;
1505		}
1506		if (GET_HASH_VALUE(deh_offset(&(de.de_deh[de.de_entry_num]))) ==
1507		    yurahash)
1508			hash = YURA_HASH;
1509		else if (GET_HASH_VALUE
1510			 (deh_offset(&(de.de_deh[de.de_entry_num]))) == teahash)
1511			hash = TEA_HASH;
1512		else if (GET_HASH_VALUE
1513			 (deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash)
1514			hash = R5_HASH;
1515		else {
1516			reiserfs_warning(s, "reiserfs-2506",
1517					 "Unrecognised hash function");
1518			hash = UNSET_HASH;
1519		}
1520	} while (0);
1521
1522	pathrelse(&path);
1523	return hash;
1524}
1525
1526// finds out which hash names are sorted with
1527static int what_hash(struct super_block *s)
1528{
1529	__u32 code;
1530
1531	code = sb_hash_function_code(SB_DISK_SUPER_BLOCK(s));
1532
1533	/* reiserfs_hash_detect() == true if any of the hash mount options
1534	 ** were used.  We must check them to make sure the user isn't
1535	 ** using a bad hash value
1536	 */
1537	if (code == UNSET_HASH || reiserfs_hash_detect(s))
1538		code = find_hash_out(s);
1539
1540	if (code != UNSET_HASH && reiserfs_hash_detect(s)) {
1541		/* detection has found the hash, and we must check against the
1542		 ** mount options
1543		 */
1544		if (reiserfs_rupasov_hash(s) && code != YURA_HASH) {
1545			reiserfs_warning(s, "reiserfs-2507",
1546					 "Error, %s hash detected, "
1547					 "unable to force rupasov hash",
1548					 reiserfs_hashname(code));
1549			code = UNSET_HASH;
1550		} else if (reiserfs_tea_hash(s) && code != TEA_HASH) {
1551			reiserfs_warning(s, "reiserfs-2508",
1552					 "Error, %s hash detected, "
1553					 "unable to force tea hash",
1554					 reiserfs_hashname(code));
1555			code = UNSET_HASH;
1556		} else if (reiserfs_r5_hash(s) && code != R5_HASH) {
1557			reiserfs_warning(s, "reiserfs-2509",
1558					 "Error, %s hash detected, "
1559					 "unable to force r5 hash",
1560					 reiserfs_hashname(code));
1561			code = UNSET_HASH;
1562		}
1563	} else {
1564		/* find_hash_out was not called or could not determine the hash */
1565		if (reiserfs_rupasov_hash(s)) {
1566			code = YURA_HASH;
1567		} else if (reiserfs_tea_hash(s)) {
1568			code = TEA_HASH;
1569		} else if (reiserfs_r5_hash(s)) {
1570			code = R5_HASH;
1571		}
1572	}
1573
1574	/* if we are mounted RW, and we have a new valid hash code, update
1575	 ** the super
1576	 */
1577	if (code != UNSET_HASH &&
1578	    !(s->s_flags & MS_RDONLY) &&
1579	    code != sb_hash_function_code(SB_DISK_SUPER_BLOCK(s))) {
1580		set_sb_hash_function_code(SB_DISK_SUPER_BLOCK(s), code);
1581	}
1582	return code;
1583}
1584
1585// return pointer to appropriate function
1586static hashf_t hash_function(struct super_block *s)
1587{
1588	switch (what_hash(s)) {
1589	case TEA_HASH:
1590		reiserfs_info(s, "Using tea hash to sort names\n");
1591		return keyed_hash;
1592	case YURA_HASH:
1593		reiserfs_info(s, "Using rupasov hash to sort names\n");
1594		return yura_hash;
1595	case R5_HASH:
1596		reiserfs_info(s, "Using r5 hash to sort names\n");
1597		return r5_hash;
1598	}
1599	return NULL;
1600}
1601
1602// this is used to set up correct value for old partitions
1603static int function2code(hashf_t func)
1604{
1605	if (func == keyed_hash)
1606		return TEA_HASH;
1607	if (func == yura_hash)
1608		return YURA_HASH;
1609	if (func == r5_hash)
1610		return R5_HASH;
1611
1612	BUG();			// should never happen
1613
1614	return 0;
1615}
1616
1617#define SWARN(silent, s, id, ...)			\
1618	if (!(silent))				\
1619		reiserfs_warning(s, id, __VA_ARGS__)
1620
1621static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
1622{
1623	struct inode *root_inode;
1624	struct reiserfs_transaction_handle th;
1625	int old_format = 0;
1626	unsigned long blocks;
1627	unsigned int commit_max_age = 0;
1628	int jinit_done = 0;
1629	struct reiserfs_iget_args args;
1630	struct reiserfs_super_block *rs;
1631	char *jdev_name;
1632	struct reiserfs_sb_info *sbi;
1633	int errval = -EINVAL;
1634	char *qf_names[MAXQUOTAS] = {};
1635	unsigned int qfmt = 0;
1636
1637	save_mount_options(s, data);
1638
1639	sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
1640	if (!sbi)
1641		return -ENOMEM;
1642	s->s_fs_info = sbi;
1643	/* Set default values for options: non-aggressive tails, RO on errors */
1644	REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_SMALLTAIL);
1645	REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_ERROR_RO);
1646	REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_BARRIER_FLUSH);
1647	/* no preallocation minimum, be smart in
1648	   reiserfs_file_write instead */
1649	REISERFS_SB(s)->s_alloc_options.preallocmin = 0;
1650	/* Preallocate by 16 blocks (17-1) at once */
1651	REISERFS_SB(s)->s_alloc_options.preallocsize = 17;
1652	/* setup default block allocator options */
1653	reiserfs_init_alloc_options(s);
1654
1655	mutex_init(&REISERFS_SB(s)->lock);
1656	REISERFS_SB(s)->lock_depth = -1;
1657
1658	/*
1659	 * This function is called with the bkl, which also was the old
1660	 * locking used here.
1661	 * do_journal_begin() will soon check if we hold the lock (ie: was the
1662	 * bkl). This is likely because do_journal_begin() has several another
1663	 * callers because at this time, it doesn't seem to be necessary to
1664	 * protect against anything.
1665	 * Anyway, let's be conservative and lock for now.
1666	 */
1667	reiserfs_write_lock(s);
1668
1669	jdev_name = NULL;
1670	if (reiserfs_parse_options
1671	    (s, (char *)data, &(sbi->s_mount_opt), &blocks, &jdev_name,
1672	     &commit_max_age, qf_names, &qfmt) == 0) {
1673		goto error;
 
 
 
 
 
 
 
 
1674	}
1675#ifdef CONFIG_QUOTA
1676	handle_quota_files(s, qf_names, &qfmt);
1677#endif
1678
1679	if (blocks) {
1680		SWARN(silent, s, "jmacd-7", "resize option for remount only");
1681		goto error;
1682	}
1683
1684	/* try old format (undistributed bitmap, super block in 8-th 1k block of a device) */
1685	if (!read_super_block(s, REISERFS_OLD_DISK_OFFSET_IN_BYTES))
1686		old_format = 1;
1687	/* try new format (64-th 1k block), which can contain reiserfs super block */
1688	else if (read_super_block(s, REISERFS_DISK_OFFSET_IN_BYTES)) {
1689		SWARN(silent, s, "sh-2021", "can not find reiserfs on %s",
1690		      reiserfs_bdevname(s));
1691		goto error;
1692	}
1693
1694	rs = SB_DISK_SUPER_BLOCK(s);
1695	/* Let's do basic sanity check to verify that underlying device is not
1696	   smaller than the filesystem. If the check fails then abort and scream,
1697	   because bad stuff will happen otherwise. */
1698	if (s->s_bdev && s->s_bdev->bd_inode
1699	    && i_size_read(s->s_bdev->bd_inode) <
1700	    sb_block_count(rs) * sb_blocksize(rs)) {
1701		SWARN(silent, s, "", "Filesystem cannot be "
1702		      "mounted because it is bigger than the device");
1703		SWARN(silent, s, "", "You may need to run fsck "
1704		      "or increase size of your LVM partition");
1705		SWARN(silent, s, "", "Or may be you forgot to "
1706		      "reboot after fdisk when it told you to");
1707		goto error;
1708	}
1709
1710	sbi->s_mount_state = SB_REISERFS_STATE(s);
1711	sbi->s_mount_state = REISERFS_VALID_FS;
1712
1713	if ((errval = reiserfs_init_bitmap_cache(s))) {
1714		SWARN(silent, s, "jmacd-8", "unable to read bitmap");
1715		goto error;
1716	}
 
1717	errval = -EINVAL;
1718#ifdef CONFIG_REISERFS_CHECK
1719	SWARN(silent, s, "", "CONFIG_REISERFS_CHECK is set ON");
1720	SWARN(silent, s, "", "- it is slow mode for debugging.");
1721#endif
1722
1723	/* make data=ordered the default */
1724	if (!reiserfs_data_log(s) && !reiserfs_data_ordered(s) &&
1725	    !reiserfs_data_writeback(s)) {
1726		REISERFS_SB(s)->s_mount_opt |= (1 << REISERFS_DATA_ORDERED);
1727	}
1728
1729	if (reiserfs_data_log(s)) {
1730		reiserfs_info(s, "using journaled data mode\n");
1731	} else if (reiserfs_data_ordered(s)) {
1732		reiserfs_info(s, "using ordered data mode\n");
1733	} else {
1734		reiserfs_info(s, "using writeback data mode\n");
1735	}
1736	if (reiserfs_barrier_flush(s)) {
1737		printk("reiserfs: using flush barriers\n");
1738	}
 
1739	// set_device_ro(s->s_dev, 1) ;
1740	if (journal_init(s, jdev_name, old_format, commit_max_age)) {
1741		SWARN(silent, s, "sh-2022",
1742		      "unable to initialize journal space");
1743		goto error;
1744	} else {
1745		jinit_done = 1;	/* once this is set, journal_release must be called
1746				 ** if we error out of the mount
1747				 */
1748	}
 
1749	if (reread_meta_blocks(s)) {
1750		SWARN(silent, s, "jmacd-9",
1751		      "unable to reread meta blocks after journal init");
1752		goto error;
1753	}
1754
1755	if (replay_only(s))
1756		goto error;
1757
1758	if (bdev_read_only(s->s_bdev) && !(s->s_flags & MS_RDONLY)) {
1759		SWARN(silent, s, "clm-7000",
1760		      "Detected readonly device, marking FS readonly");
1761		s->s_flags |= MS_RDONLY;
1762	}
1763	args.objectid = REISERFS_ROOT_OBJECTID;
1764	args.dirid = REISERFS_ROOT_PARENT_OBJECTID;
1765	root_inode =
1766	    iget5_locked(s, REISERFS_ROOT_OBJECTID, reiserfs_find_actor,
1767			 reiserfs_init_locked_inode, (void *)(&args));
1768	if (!root_inode) {
1769		SWARN(silent, s, "jmacd-10", "get root inode failed");
1770		goto error;
1771	}
1772
 
 
 
 
 
 
 
 
 
 
1773	if (root_inode->i_state & I_NEW) {
1774		reiserfs_read_locked_inode(root_inode, &args);
1775		unlock_new_inode(root_inode);
1776	}
1777
1778	s->s_root = d_alloc_root(root_inode);
1779	if (!s->s_root) {
1780		iput(root_inode);
1781		goto error;
1782	}
1783	// define and initialize hash function
1784	sbi->s_hash_function = hash_function(s);
1785	if (sbi->s_hash_function == NULL) {
1786		dput(s->s_root);
1787		s->s_root = NULL;
1788		goto error;
1789	}
1790
1791	if (is_reiserfs_3_5(rs)
1792	    || (is_reiserfs_jr(rs) && SB_VERSION(s) == REISERFS_VERSION_1))
1793		set_bit(REISERFS_3_5, &(sbi->s_properties));
1794	else if (old_format)
1795		set_bit(REISERFS_OLD_FORMAT, &(sbi->s_properties));
1796	else
1797		set_bit(REISERFS_3_6, &(sbi->s_properties));
1798
1799	if (!(s->s_flags & MS_RDONLY)) {
1800
1801		errval = journal_begin(&th, s, 1);
1802		if (errval) {
1803			dput(s->s_root);
1804			s->s_root = NULL;
1805			goto error;
1806		}
1807		reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
1808
1809		set_sb_umount_state(rs, REISERFS_ERROR_FS);
1810		set_sb_fs_state(rs, 0);
1811
1812		/* Clear out s_bmap_nr if it would wrap. We can handle this
1813		 * case, but older revisions can't. This will cause the
1814		 * file system to fail mount on those older implementations,
1815		 * avoiding corruption. -jeffm */
1816		if (bmap_would_wrap(reiserfs_bmap_count(s)) &&
1817		    sb_bmap_nr(rs) != 0) {
1818			reiserfs_warning(s, "super-2030", "This file system "
1819					"claims to use %u bitmap blocks in "
1820					"its super block, but requires %u. "
1821					"Clearing to zero.", sb_bmap_nr(rs),
1822					reiserfs_bmap_count(s));
1823
1824			set_sb_bmap_nr(rs, 0);
1825		}
1826
1827		if (old_format_only(s)) {
1828			/* filesystem of format 3.5 either with standard or non-standard
1829			   journal */
1830			if (convert_reiserfs(s)) {
1831				/* and -o conv is given */
1832				if (!silent)
1833					reiserfs_info(s,
1834						      "converting 3.5 filesystem to the 3.6 format");
1835
1836				if (is_reiserfs_3_5(rs))
1837					/* put magic string of 3.6 format. 2.2 will not be able to
1838					   mount this filesystem anymore */
1839					memcpy(rs->s_v1.s_magic,
1840					       reiserfs_3_6_magic_string,
1841					       sizeof
1842					       (reiserfs_3_6_magic_string));
1843
1844				set_sb_version(rs, REISERFS_VERSION_2);
1845				reiserfs_convert_objectid_map_v1(s);
1846				set_bit(REISERFS_3_6, &(sbi->s_properties));
1847				clear_bit(REISERFS_3_5, &(sbi->s_properties));
1848			} else if (!silent) {
1849				reiserfs_info(s, "using 3.5.x disk format\n");
1850			}
1851		} else
1852			set_sb_mnt_count(rs, sb_mnt_count(rs) + 1);
1853
1854
1855		journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
1856		errval = journal_end(&th, s, 1);
1857		if (errval) {
1858			dput(s->s_root);
1859			s->s_root = NULL;
1860			goto error;
1861		}
1862
1863		if ((errval = reiserfs_lookup_privroot(s)) ||
1864		    (errval = reiserfs_xattr_init(s, s->s_flags))) {
1865			dput(s->s_root);
1866			s->s_root = NULL;
1867			goto error;
1868		}
1869
1870		/* look for files which were to be removed in previous session */
1871		finish_unfinished(s);
1872	} else {
1873		if (old_format_only(s) && !silent) {
1874			reiserfs_info(s, "using 3.5.x disk format\n");
1875		}
1876
1877		if ((errval = reiserfs_lookup_privroot(s)) ||
1878		    (errval = reiserfs_xattr_init(s, s->s_flags))) {
1879			dput(s->s_root);
1880			s->s_root = NULL;
1881			goto error;
1882		}
1883	}
1884	// mark hash in super block: it could be unset. overwrite should be ok
1885	set_sb_hash_function_code(rs, function2code(sbi->s_hash_function));
1886
1887	handle_attrs(s);
1888
1889	reiserfs_proc_info_init(s);
1890
1891	init_waitqueue_head(&(sbi->s_wait));
1892	spin_lock_init(&sbi->bitmap_lock);
1893
1894	reiserfs_write_unlock(s);
1895
1896	return (0);
1897
1898error:
1899	if (jinit_done) {	/* kill the commit thread, free journal ram */
 
 
 
 
 
1900		journal_release_error(NULL, s);
 
1901	}
1902
1903	reiserfs_write_unlock(s);
1904
1905	reiserfs_free_bitmap_cache(s);
1906	if (SB_BUFFER_WITH_SB(s))
1907		brelse(SB_BUFFER_WITH_SB(s));
1908#ifdef CONFIG_QUOTA
1909	{
1910		int j;
1911		for (j = 0; j < MAXQUOTAS; j++)
1912			kfree(qf_names[j]);
1913	}
1914#endif
1915	kfree(sbi);
1916
1917	s->s_fs_info = NULL;
1918	return errval;
1919}
1920
1921static int reiserfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1922{
1923	struct reiserfs_super_block *rs = SB_DISK_SUPER_BLOCK(dentry->d_sb);
1924
1925	buf->f_namelen = (REISERFS_MAX_NAME(s->s_blocksize));
1926	buf->f_bfree = sb_free_blocks(rs);
1927	buf->f_bavail = buf->f_bfree;
1928	buf->f_blocks = sb_block_count(rs) - sb_bmap_nr(rs) - 1;
1929	buf->f_bsize = dentry->d_sb->s_blocksize;
1930	/* changed to accommodate gcc folks. */
1931	buf->f_type = REISERFS_SUPER_MAGIC;
1932	buf->f_fsid.val[0] = (u32)crc32_le(0, rs->s_uuid, sizeof(rs->s_uuid)/2);
1933	buf->f_fsid.val[1] = (u32)crc32_le(0, rs->s_uuid + sizeof(rs->s_uuid)/2,
1934				sizeof(rs->s_uuid)/2);
1935
1936	return 0;
1937}
1938
1939#ifdef CONFIG_QUOTA
1940static int reiserfs_write_dquot(struct dquot *dquot)
1941{
1942	struct reiserfs_transaction_handle th;
1943	int ret, err;
1944
1945	reiserfs_write_lock(dquot->dq_sb);
1946	ret =
1947	    journal_begin(&th, dquot->dq_sb,
1948			  REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1949	if (ret)
1950		goto out;
1951	ret = dquot_commit(dquot);
1952	err =
1953	    journal_end(&th, dquot->dq_sb,
1954			REISERFS_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
1955	if (!ret && err)
1956		ret = err;
1957      out:
1958	reiserfs_write_unlock(dquot->dq_sb);
1959	return ret;
1960}
1961
1962static int reiserfs_acquire_dquot(struct dquot *dquot)
1963{
1964	struct reiserfs_transaction_handle th;
1965	int ret, err;
1966
1967	reiserfs_write_lock(dquot->dq_sb);
1968	ret =
1969	    journal_begin(&th, dquot->dq_sb,
1970			  REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1971	if (ret)
1972		goto out;
1973	ret = dquot_acquire(dquot);
1974	err =
1975	    journal_end(&th, dquot->dq_sb,
1976			REISERFS_QUOTA_INIT_BLOCKS(dquot->dq_sb));
1977	if (!ret && err)
1978		ret = err;
1979      out:
1980	reiserfs_write_unlock(dquot->dq_sb);
1981	return ret;
1982}
1983
1984static int reiserfs_release_dquot(struct dquot *dquot)
1985{
1986	struct reiserfs_transaction_handle th;
1987	int ret, err;
1988
1989	reiserfs_write_lock(dquot->dq_sb);
1990	ret =
1991	    journal_begin(&th, dquot->dq_sb,
1992			  REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
1993	if (ret) {
1994		/* Release dquot anyway to avoid endless cycle in dqput() */
1995		dquot_release(dquot);
1996		goto out;
1997	}
1998	ret = dquot_release(dquot);
1999	err =
2000	    journal_end(&th, dquot->dq_sb,
2001			REISERFS_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2002	if (!ret && err)
2003		ret = err;
2004      out:
2005	reiserfs_write_unlock(dquot->dq_sb);
2006	return ret;
2007}
2008
2009static int reiserfs_mark_dquot_dirty(struct dquot *dquot)
2010{
2011	/* Are we journaling quotas? */
2012	if (REISERFS_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
2013	    REISERFS_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
2014		dquot_mark_dquot_dirty(dquot);
2015		return reiserfs_write_dquot(dquot);
2016	} else
2017		return dquot_mark_dquot_dirty(dquot);
2018}
2019
2020static int reiserfs_write_info(struct super_block *sb, int type)
2021{
2022	struct reiserfs_transaction_handle th;
2023	int ret, err;
2024
2025	/* Data block + inode block */
2026	reiserfs_write_lock(sb);
2027	ret = journal_begin(&th, sb, 2);
2028	if (ret)
2029		goto out;
2030	ret = dquot_commit_info(sb, type);
2031	err = journal_end(&th, sb, 2);
2032	if (!ret && err)
2033		ret = err;
2034      out:
2035	reiserfs_write_unlock(sb);
2036	return ret;
2037}
2038
2039/*
2040 * Turn on quotas during mount time - we need to find the quota file and such...
2041 */
2042static int reiserfs_quota_on_mount(struct super_block *sb, int type)
2043{
2044	return dquot_quota_on_mount(sb, REISERFS_SB(sb)->s_qf_names[type],
2045					REISERFS_SB(sb)->s_jquota_fmt, type);
2046}
2047
2048/*
2049 * Standard function to be called on quota_on
2050 */
2051static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
2052			     struct path *path)
2053{
2054	int err;
2055	struct inode *inode;
2056	struct reiserfs_transaction_handle th;
 
2057
2058	if (!(REISERFS_SB(sb)->s_mount_opt & (1 << REISERFS_QUOTA)))
2059		return -EINVAL;
2060
2061	/* Quotafile not on the same filesystem? */
2062	if (path->mnt->mnt_sb != sb) {
2063		err = -EXDEV;
2064		goto out;
2065	}
2066	inode = path->dentry->d_inode;
2067	/* We must not pack tails for quota files on reiserfs for quota IO to work */
2068	if (!(REISERFS_I(inode)->i_flags & i_nopack_mask)) {
2069		err = reiserfs_unpack(inode, NULL);
2070		if (err) {
2071			reiserfs_warning(sb, "super-6520",
2072				"Unpacking tail of quota file failed"
2073				" (%d). Cannot turn on quotas.", err);
2074			err = -EINVAL;
2075			goto out;
2076		}
2077		mark_inode_dirty(inode);
2078	}
2079	/* Journaling quota? */
2080	if (REISERFS_SB(sb)->s_qf_names[type]) {
2081		/* Quotafile not of fs root? */
2082		if (path->dentry->d_parent != sb->s_root)
2083			reiserfs_warning(sb, "super-6521",
2084				 "Quota file not on filesystem root. "
2085				 "Journalled quota will not work.");
2086	}
2087
2088	/*
2089	 * When we journal data on quota file, we have to flush journal to see
2090	 * all updates to the file when we bypass pagecache...
2091	 */
2092	if (reiserfs_file_data_log(inode)) {
2093		/* Just start temporary transaction and finish it */
2094		err = journal_begin(&th, sb, 1);
2095		if (err)
2096			goto out;
2097		err = journal_end_sync(&th, sb, 1);
2098		if (err)
2099			goto out;
2100	}
2101	err = dquot_quota_on(sb, type, format_id, path);
2102out:
2103	return err;
2104}
2105
2106/* Read data from quotafile - avoid pagecache and such because we cannot afford
2107 * acquiring the locks... As quota files are never truncated and quota code
2108 * itself serializes the operations (and no one else should touch the files)
2109 * we don't have to be afraid of races */
2110static ssize_t reiserfs_quota_read(struct super_block *sb, int type, char *data,
2111				   size_t len, loff_t off)
2112{
2113	struct inode *inode = sb_dqopt(sb)->files[type];
2114	unsigned long blk = off >> sb->s_blocksize_bits;
2115	int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2116	size_t toread;
2117	struct buffer_head tmp_bh, *bh;
2118	loff_t i_size = i_size_read(inode);
2119
2120	if (off > i_size)
2121		return 0;
2122	if (off + len > i_size)
2123		len = i_size - off;
2124	toread = len;
2125	while (toread > 0) {
2126		tocopy =
2127		    sb->s_blocksize - offset <
2128		    toread ? sb->s_blocksize - offset : toread;
2129		tmp_bh.b_state = 0;
2130		/* Quota files are without tails so we can safely use this function */
2131		reiserfs_write_lock(sb);
2132		err = reiserfs_get_block(inode, blk, &tmp_bh, 0);
2133		reiserfs_write_unlock(sb);
2134		if (err)
2135			return err;
2136		if (!buffer_mapped(&tmp_bh))	/* A hole? */
2137			memset(data, 0, tocopy);
2138		else {
2139			bh = sb_bread(sb, tmp_bh.b_blocknr);
2140			if (!bh)
2141				return -EIO;
2142			memcpy(data, bh->b_data + offset, tocopy);
2143			brelse(bh);
2144		}
2145		offset = 0;
2146		toread -= tocopy;
2147		data += tocopy;
2148		blk++;
2149	}
2150	return len;
2151}
2152
2153/* Write to quotafile (we know the transaction is already started and has
2154 * enough credits) */
2155static ssize_t reiserfs_quota_write(struct super_block *sb, int type,
2156				    const char *data, size_t len, loff_t off)
2157{
2158	struct inode *inode = sb_dqopt(sb)->files[type];
2159	unsigned long blk = off >> sb->s_blocksize_bits;
2160	int err = 0, offset = off & (sb->s_blocksize - 1), tocopy;
2161	int journal_quota = REISERFS_SB(sb)->s_qf_names[type] != NULL;
2162	size_t towrite = len;
2163	struct buffer_head tmp_bh, *bh;
2164
2165	if (!current->journal_info) {
2166		printk(KERN_WARNING "reiserfs: Quota write (off=%Lu, len=%Lu)"
2167			" cancelled because transaction is not started.\n",
2168			(unsigned long long)off, (unsigned long long)len);
2169		return -EIO;
2170	}
2171	mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
2172	while (towrite > 0) {
2173		tocopy = sb->s_blocksize - offset < towrite ?
2174		    sb->s_blocksize - offset : towrite;
2175		tmp_bh.b_state = 0;
2176		err = reiserfs_get_block(inode, blk, &tmp_bh, GET_BLOCK_CREATE);
2177		if (err)
2178			goto out;
2179		if (offset || tocopy != sb->s_blocksize)
2180			bh = sb_bread(sb, tmp_bh.b_blocknr);
2181		else
2182			bh = sb_getblk(sb, tmp_bh.b_blocknr);
2183		if (!bh) {
2184			err = -EIO;
2185			goto out;
2186		}
2187		lock_buffer(bh);
2188		memcpy(bh->b_data + offset, data, tocopy);
2189		flush_dcache_page(bh->b_page);
2190		set_buffer_uptodate(bh);
2191		unlock_buffer(bh);
2192		reiserfs_prepare_for_journal(sb, bh, 1);
2193		journal_mark_dirty(current->journal_info, sb, bh);
2194		if (!journal_quota)
2195			reiserfs_add_ordered_list(inode, bh);
2196		brelse(bh);
2197		offset = 0;
2198		towrite -= tocopy;
2199		data += tocopy;
2200		blk++;
2201	}
2202out:
2203	if (len == towrite) {
2204		mutex_unlock(&inode->i_mutex);
2205		return err;
2206	}
2207	if (inode->i_size < off + len - towrite)
2208		i_size_write(inode, off + len - towrite);
2209	inode->i_version++;
2210	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2211	mark_inode_dirty(inode);
2212	mutex_unlock(&inode->i_mutex);
2213	return len - towrite;
2214}
2215
2216#endif
2217
2218static struct dentry *get_super_block(struct file_system_type *fs_type,
2219			   int flags, const char *dev_name,
2220			   void *data)
2221{
2222	return mount_bdev(fs_type, flags, dev_name, data, reiserfs_fill_super);
2223}
2224
2225static int __init init_reiserfs_fs(void)
2226{
2227	int ret;
2228
2229	if ((ret = init_inodecache())) {
2230		return ret;
2231	}
2232
2233	reiserfs_proc_info_global_init();
2234
2235	ret = register_filesystem(&reiserfs_fs_type);
2236
2237	if (ret == 0) {
2238		return 0;
2239	}
2240
2241	reiserfs_proc_info_global_done();
2242	destroy_inodecache();
2243
2244	return ret;
2245}
2246
2247static void __exit exit_reiserfs_fs(void)
2248{
2249	reiserfs_proc_info_global_done();
2250	unregister_filesystem(&reiserfs_fs_type);
2251	destroy_inodecache();
2252}
2253
2254struct file_system_type reiserfs_fs_type = {
2255	.owner = THIS_MODULE,
2256	.name = "reiserfs",
2257	.mount = get_super_block,
2258	.kill_sb = reiserfs_kill_sb,
2259	.fs_flags = FS_REQUIRES_DEV,
2260};
2261
2262MODULE_DESCRIPTION("ReiserFS journaled filesystem");
2263MODULE_AUTHOR("Hans Reiser <reiser@namesys.com>");
2264MODULE_LICENSE("GPL");
2265
2266module_init(init_reiserfs_fs);
2267module_exit(exit_reiserfs_fs);