xref: /openbmc/linux/fs/ocfs2/super.c (revision 6c33a6f4)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* -*- mode: c; c-basic-offset: 8; -*-
3  * vim: noexpandtab sw=8 ts=8 sts=0:
4  *
5  * super.c
6  *
7  * load/unload driver, mount/dismount volumes
8  *
9  * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
10  */
11 
12 #include <linux/module.h>
13 #include <linux/fs.h>
14 #include <linux/types.h>
15 #include <linux/slab.h>
16 #include <linux/highmem.h>
17 #include <linux/init.h>
18 #include <linux/random.h>
19 #include <linux/statfs.h>
20 #include <linux/moduleparam.h>
21 #include <linux/blkdev.h>
22 #include <linux/socket.h>
23 #include <linux/inet.h>
24 #include <linux/parser.h>
25 #include <linux/crc32.h>
26 #include <linux/debugfs.h>
27 #include <linux/mount.h>
28 #include <linux/seq_file.h>
29 #include <linux/quotaops.h>
30 #include <linux/cleancache.h>
31 #include <linux/signal.h>
32 
33 #define CREATE_TRACE_POINTS
34 #include "ocfs2_trace.h"
35 
36 #include <cluster/masklog.h>
37 
38 #include "ocfs2.h"
39 
40 /* this should be the only file to include a version 1 header */
41 #include "ocfs1_fs_compat.h"
42 
43 #include "alloc.h"
44 #include "aops.h"
45 #include "blockcheck.h"
46 #include "dlmglue.h"
47 #include "export.h"
48 #include "extent_map.h"
49 #include "heartbeat.h"
50 #include "inode.h"
51 #include "journal.h"
52 #include "localalloc.h"
53 #include "namei.h"
54 #include "slot_map.h"
55 #include "super.h"
56 #include "sysfile.h"
57 #include "uptodate.h"
58 #include "xattr.h"
59 #include "quota.h"
60 #include "refcounttree.h"
61 #include "suballoc.h"
62 
63 #include "buffer_head_io.h"
64 #include "filecheck.h"
65 
66 static struct kmem_cache *ocfs2_inode_cachep;
67 struct kmem_cache *ocfs2_dquot_cachep;
68 struct kmem_cache *ocfs2_qf_chunk_cachep;
69 
70 static struct dentry *ocfs2_debugfs_root;
71 
72 MODULE_AUTHOR("Oracle");
73 MODULE_LICENSE("GPL");
74 MODULE_DESCRIPTION("OCFS2 cluster file system");
75 
76 struct mount_options
77 {
78 	unsigned long	commit_interval;
79 	unsigned long	mount_opt;
80 	unsigned int	atime_quantum;
81 	signed short	slot;
82 	int		localalloc_opt;
83 	unsigned int	resv_level;
84 	int		dir_resv_level;
85 	char		cluster_stack[OCFS2_STACK_LABEL_LEN + 1];
86 };
87 
88 static int ocfs2_parse_options(struct super_block *sb, char *options,
89 			       struct mount_options *mopt,
90 			       int is_remount);
91 static int ocfs2_check_set_options(struct super_block *sb,
92 				   struct mount_options *options);
93 static int ocfs2_show_options(struct seq_file *s, struct dentry *root);
94 static void ocfs2_put_super(struct super_block *sb);
95 static int ocfs2_mount_volume(struct super_block *sb);
96 static int ocfs2_remount(struct super_block *sb, int *flags, char *data);
97 static void ocfs2_dismount_volume(struct super_block *sb, int mnt_err);
98 static int ocfs2_initialize_mem_caches(void);
99 static void ocfs2_free_mem_caches(void);
100 static void ocfs2_delete_osb(struct ocfs2_super *osb);
101 
102 static int ocfs2_statfs(struct dentry *dentry, struct kstatfs *buf);
103 
104 static int ocfs2_sync_fs(struct super_block *sb, int wait);
105 
106 static int ocfs2_init_global_system_inodes(struct ocfs2_super *osb);
107 static int ocfs2_init_local_system_inodes(struct ocfs2_super *osb);
108 static void ocfs2_release_system_inodes(struct ocfs2_super *osb);
109 static int ocfs2_check_volume(struct ocfs2_super *osb);
110 static int ocfs2_verify_volume(struct ocfs2_dinode *di,
111 			       struct buffer_head *bh,
112 			       u32 sectsize,
113 			       struct ocfs2_blockcheck_stats *stats);
114 static int ocfs2_initialize_super(struct super_block *sb,
115 				  struct buffer_head *bh,
116 				  int sector_size,
117 				  struct ocfs2_blockcheck_stats *stats);
118 static int ocfs2_get_sector(struct super_block *sb,
119 			    struct buffer_head **bh,
120 			    int block,
121 			    int sect_size);
122 static struct inode *ocfs2_alloc_inode(struct super_block *sb);
123 static void ocfs2_free_inode(struct inode *inode);
124 static int ocfs2_susp_quotas(struct ocfs2_super *osb, int unsuspend);
125 static int ocfs2_enable_quotas(struct ocfs2_super *osb);
126 static void ocfs2_disable_quotas(struct ocfs2_super *osb);
127 
128 static struct dquot **ocfs2_get_dquots(struct inode *inode)
129 {
130 	return OCFS2_I(inode)->i_dquot;
131 }
132 
133 static const struct super_operations ocfs2_sops = {
134 	.statfs		= ocfs2_statfs,
135 	.alloc_inode	= ocfs2_alloc_inode,
136 	.free_inode	= ocfs2_free_inode,
137 	.drop_inode	= ocfs2_drop_inode,
138 	.evict_inode	= ocfs2_evict_inode,
139 	.sync_fs	= ocfs2_sync_fs,
140 	.put_super	= ocfs2_put_super,
141 	.remount_fs	= ocfs2_remount,
142 	.show_options   = ocfs2_show_options,
143 	.quota_read	= ocfs2_quota_read,
144 	.quota_write	= ocfs2_quota_write,
145 	.get_dquots	= ocfs2_get_dquots,
146 };
147 
148 enum {
149 	Opt_barrier,
150 	Opt_err_panic,
151 	Opt_err_ro,
152 	Opt_intr,
153 	Opt_nointr,
154 	Opt_hb_none,
155 	Opt_hb_local,
156 	Opt_hb_global,
157 	Opt_data_ordered,
158 	Opt_data_writeback,
159 	Opt_atime_quantum,
160 	Opt_slot,
161 	Opt_commit,
162 	Opt_localalloc,
163 	Opt_localflocks,
164 	Opt_stack,
165 	Opt_user_xattr,
166 	Opt_nouser_xattr,
167 	Opt_inode64,
168 	Opt_acl,
169 	Opt_noacl,
170 	Opt_usrquota,
171 	Opt_grpquota,
172 	Opt_coherency_buffered,
173 	Opt_coherency_full,
174 	Opt_resv_level,
175 	Opt_dir_resv_level,
176 	Opt_journal_async_commit,
177 	Opt_err_cont,
178 	Opt_err,
179 };
180 
181 static const match_table_t tokens = {
182 	{Opt_barrier, "barrier=%u"},
183 	{Opt_err_panic, "errors=panic"},
184 	{Opt_err_ro, "errors=remount-ro"},
185 	{Opt_intr, "intr"},
186 	{Opt_nointr, "nointr"},
187 	{Opt_hb_none, OCFS2_HB_NONE},
188 	{Opt_hb_local, OCFS2_HB_LOCAL},
189 	{Opt_hb_global, OCFS2_HB_GLOBAL},
190 	{Opt_data_ordered, "data=ordered"},
191 	{Opt_data_writeback, "data=writeback"},
192 	{Opt_atime_quantum, "atime_quantum=%u"},
193 	{Opt_slot, "preferred_slot=%u"},
194 	{Opt_commit, "commit=%u"},
195 	{Opt_localalloc, "localalloc=%d"},
196 	{Opt_localflocks, "localflocks"},
197 	{Opt_stack, "cluster_stack=%s"},
198 	{Opt_user_xattr, "user_xattr"},
199 	{Opt_nouser_xattr, "nouser_xattr"},
200 	{Opt_inode64, "inode64"},
201 	{Opt_acl, "acl"},
202 	{Opt_noacl, "noacl"},
203 	{Opt_usrquota, "usrquota"},
204 	{Opt_grpquota, "grpquota"},
205 	{Opt_coherency_buffered, "coherency=buffered"},
206 	{Opt_coherency_full, "coherency=full"},
207 	{Opt_resv_level, "resv_level=%u"},
208 	{Opt_dir_resv_level, "dir_resv_level=%u"},
209 	{Opt_journal_async_commit, "journal_async_commit"},
210 	{Opt_err_cont, "errors=continue"},
211 	{Opt_err, NULL}
212 };
213 
214 #ifdef CONFIG_DEBUG_FS
215 static int ocfs2_osb_dump(struct ocfs2_super *osb, char *buf, int len)
216 {
217 	struct ocfs2_cluster_connection *cconn = osb->cconn;
218 	struct ocfs2_recovery_map *rm = osb->recovery_map;
219 	struct ocfs2_orphan_scan *os = &osb->osb_orphan_scan;
220 	int i, out = 0;
221 	unsigned long flags;
222 
223 	out += snprintf(buf + out, len - out,
224 			"%10s => Id: %-s  Uuid: %-s  Gen: 0x%X  Label: %-s\n",
225 			"Device", osb->dev_str, osb->uuid_str,
226 			osb->fs_generation, osb->vol_label);
227 
228 	out += snprintf(buf + out, len - out,
229 			"%10s => State: %d  Flags: 0x%lX\n", "Volume",
230 			atomic_read(&osb->vol_state), osb->osb_flags);
231 
232 	out += snprintf(buf + out, len - out,
233 			"%10s => Block: %lu  Cluster: %d\n", "Sizes",
234 			osb->sb->s_blocksize, osb->s_clustersize);
235 
236 	out += snprintf(buf + out, len - out,
237 			"%10s => Compat: 0x%X  Incompat: 0x%X  "
238 			"ROcompat: 0x%X\n",
239 			"Features", osb->s_feature_compat,
240 			osb->s_feature_incompat, osb->s_feature_ro_compat);
241 
242 	out += snprintf(buf + out, len - out,
243 			"%10s => Opts: 0x%lX  AtimeQuanta: %u\n", "Mount",
244 			osb->s_mount_opt, osb->s_atime_quantum);
245 
246 	if (cconn) {
247 		out += snprintf(buf + out, len - out,
248 				"%10s => Stack: %s  Name: %*s  "
249 				"Version: %d.%d\n", "Cluster",
250 				(*osb->osb_cluster_stack == '\0' ?
251 				 "o2cb" : osb->osb_cluster_stack),
252 				cconn->cc_namelen, cconn->cc_name,
253 				cconn->cc_version.pv_major,
254 				cconn->cc_version.pv_minor);
255 	}
256 
257 	spin_lock_irqsave(&osb->dc_task_lock, flags);
258 	out += snprintf(buf + out, len - out,
259 			"%10s => Pid: %d  Count: %lu  WakeSeq: %lu  "
260 			"WorkSeq: %lu\n", "DownCnvt",
261 			(osb->dc_task ?  task_pid_nr(osb->dc_task) : -1),
262 			osb->blocked_lock_count, osb->dc_wake_sequence,
263 			osb->dc_work_sequence);
264 	spin_unlock_irqrestore(&osb->dc_task_lock, flags);
265 
266 	spin_lock(&osb->osb_lock);
267 	out += snprintf(buf + out, len - out, "%10s => Pid: %d  Nodes:",
268 			"Recovery",
269 			(osb->recovery_thread_task ?
270 			 task_pid_nr(osb->recovery_thread_task) : -1));
271 	if (rm->rm_used == 0)
272 		out += snprintf(buf + out, len - out, " None\n");
273 	else {
274 		for (i = 0; i < rm->rm_used; i++)
275 			out += snprintf(buf + out, len - out, " %d",
276 					rm->rm_entries[i]);
277 		out += snprintf(buf + out, len - out, "\n");
278 	}
279 	spin_unlock(&osb->osb_lock);
280 
281 	out += snprintf(buf + out, len - out,
282 			"%10s => Pid: %d  Interval: %lu\n", "Commit",
283 			(osb->commit_task ? task_pid_nr(osb->commit_task) : -1),
284 			osb->osb_commit_interval);
285 
286 	out += snprintf(buf + out, len - out,
287 			"%10s => State: %d  TxnId: %lu  NumTxns: %d\n",
288 			"Journal", osb->journal->j_state,
289 			osb->journal->j_trans_id,
290 			atomic_read(&osb->journal->j_num_trans));
291 
292 	out += snprintf(buf + out, len - out,
293 			"%10s => GlobalAllocs: %d  LocalAllocs: %d  "
294 			"SubAllocs: %d  LAWinMoves: %d  SAExtends: %d\n",
295 			"Stats",
296 			atomic_read(&osb->alloc_stats.bitmap_data),
297 			atomic_read(&osb->alloc_stats.local_data),
298 			atomic_read(&osb->alloc_stats.bg_allocs),
299 			atomic_read(&osb->alloc_stats.moves),
300 			atomic_read(&osb->alloc_stats.bg_extends));
301 
302 	out += snprintf(buf + out, len - out,
303 			"%10s => State: %u  Descriptor: %llu  Size: %u bits  "
304 			"Default: %u bits\n",
305 			"LocalAlloc", osb->local_alloc_state,
306 			(unsigned long long)osb->la_last_gd,
307 			osb->local_alloc_bits, osb->local_alloc_default_bits);
308 
309 	spin_lock(&osb->osb_lock);
310 	out += snprintf(buf + out, len - out,
311 			"%10s => InodeSlot: %d  StolenInodes: %d, "
312 			"MetaSlot: %d  StolenMeta: %d\n", "Steal",
313 			osb->s_inode_steal_slot,
314 			atomic_read(&osb->s_num_inodes_stolen),
315 			osb->s_meta_steal_slot,
316 			atomic_read(&osb->s_num_meta_stolen));
317 	spin_unlock(&osb->osb_lock);
318 
319 	out += snprintf(buf + out, len - out, "OrphanScan => ");
320 	out += snprintf(buf + out, len - out, "Local: %u  Global: %u ",
321 			os->os_count, os->os_seqno);
322 	out += snprintf(buf + out, len - out, " Last Scan: ");
323 	if (atomic_read(&os->os_state) == ORPHAN_SCAN_INACTIVE)
324 		out += snprintf(buf + out, len - out, "Disabled\n");
325 	else
326 		out += snprintf(buf + out, len - out, "%lu seconds ago\n",
327 				(unsigned long)(ktime_get_seconds() - os->os_scantime));
328 
329 	out += snprintf(buf + out, len - out, "%10s => %3s  %10s\n",
330 			"Slots", "Num", "RecoGen");
331 	for (i = 0; i < osb->max_slots; ++i) {
332 		out += snprintf(buf + out, len - out,
333 				"%10s  %c %3d  %10d\n",
334 				" ",
335 				(i == osb->slot_num ? '*' : ' '),
336 				i, osb->slot_recovery_generations[i]);
337 	}
338 
339 	return out;
340 }
341 
342 static int ocfs2_osb_debug_open(struct inode *inode, struct file *file)
343 {
344 	struct ocfs2_super *osb = inode->i_private;
345 	char *buf = NULL;
346 
347 	buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
348 	if (!buf)
349 		goto bail;
350 
351 	i_size_write(inode, ocfs2_osb_dump(osb, buf, PAGE_SIZE));
352 
353 	file->private_data = buf;
354 
355 	return 0;
356 bail:
357 	return -ENOMEM;
358 }
359 
360 static int ocfs2_debug_release(struct inode *inode, struct file *file)
361 {
362 	kfree(file->private_data);
363 	return 0;
364 }
365 
366 static ssize_t ocfs2_debug_read(struct file *file, char __user *buf,
367 				size_t nbytes, loff_t *ppos)
368 {
369 	return simple_read_from_buffer(buf, nbytes, ppos, file->private_data,
370 				       i_size_read(file->f_mapping->host));
371 }
372 #else
373 static int ocfs2_osb_debug_open(struct inode *inode, struct file *file)
374 {
375 	return 0;
376 }
377 static int ocfs2_debug_release(struct inode *inode, struct file *file)
378 {
379 	return 0;
380 }
381 static ssize_t ocfs2_debug_read(struct file *file, char __user *buf,
382 				size_t nbytes, loff_t *ppos)
383 {
384 	return 0;
385 }
386 #endif	/* CONFIG_DEBUG_FS */
387 
388 static const struct file_operations ocfs2_osb_debug_fops = {
389 	.open =		ocfs2_osb_debug_open,
390 	.release =	ocfs2_debug_release,
391 	.read =		ocfs2_debug_read,
392 	.llseek =	generic_file_llseek,
393 };
394 
395 static int ocfs2_sync_fs(struct super_block *sb, int wait)
396 {
397 	int status;
398 	tid_t target;
399 	struct ocfs2_super *osb = OCFS2_SB(sb);
400 
401 	if (ocfs2_is_hard_readonly(osb))
402 		return -EROFS;
403 
404 	if (wait) {
405 		status = ocfs2_flush_truncate_log(osb);
406 		if (status < 0)
407 			mlog_errno(status);
408 	} else {
409 		ocfs2_schedule_truncate_log_flush(osb, 0);
410 	}
411 
412 	if (jbd2_journal_start_commit(osb->journal->j_journal,
413 				      &target)) {
414 		if (wait)
415 			jbd2_log_wait_commit(osb->journal->j_journal,
416 					     target);
417 	}
418 	return 0;
419 }
420 
421 static int ocfs2_need_system_inode(struct ocfs2_super *osb, int ino)
422 {
423 	if (!OCFS2_HAS_RO_COMPAT_FEATURE(osb->sb, OCFS2_FEATURE_RO_COMPAT_USRQUOTA)
424 	    && (ino == USER_QUOTA_SYSTEM_INODE
425 		|| ino == LOCAL_USER_QUOTA_SYSTEM_INODE))
426 		return 0;
427 	if (!OCFS2_HAS_RO_COMPAT_FEATURE(osb->sb, OCFS2_FEATURE_RO_COMPAT_GRPQUOTA)
428 	    && (ino == GROUP_QUOTA_SYSTEM_INODE
429 		|| ino == LOCAL_GROUP_QUOTA_SYSTEM_INODE))
430 		return 0;
431 	return 1;
432 }
433 
434 static int ocfs2_init_global_system_inodes(struct ocfs2_super *osb)
435 {
436 	struct inode *new = NULL;
437 	int status = 0;
438 	int i;
439 
440 	new = ocfs2_iget(osb, osb->root_blkno, OCFS2_FI_FLAG_SYSFILE, 0);
441 	if (IS_ERR(new)) {
442 		status = PTR_ERR(new);
443 		mlog_errno(status);
444 		goto bail;
445 	}
446 	osb->root_inode = new;
447 
448 	new = ocfs2_iget(osb, osb->system_dir_blkno, OCFS2_FI_FLAG_SYSFILE, 0);
449 	if (IS_ERR(new)) {
450 		status = PTR_ERR(new);
451 		mlog_errno(status);
452 		goto bail;
453 	}
454 	osb->sys_root_inode = new;
455 
456 	for (i = OCFS2_FIRST_ONLINE_SYSTEM_INODE;
457 	     i <= OCFS2_LAST_GLOBAL_SYSTEM_INODE; i++) {
458 		if (!ocfs2_need_system_inode(osb, i))
459 			continue;
460 		new = ocfs2_get_system_file_inode(osb, i, osb->slot_num);
461 		if (!new) {
462 			ocfs2_release_system_inodes(osb);
463 			status = ocfs2_is_soft_readonly(osb) ? -EROFS : -EINVAL;
464 			mlog_errno(status);
465 			mlog(ML_ERROR, "Unable to load system inode %d, "
466 			     "possibly corrupt fs?", i);
467 			goto bail;
468 		}
469 		// the array now has one ref, so drop this one
470 		iput(new);
471 	}
472 
473 bail:
474 	if (status)
475 		mlog_errno(status);
476 	return status;
477 }
478 
479 static int ocfs2_init_local_system_inodes(struct ocfs2_super *osb)
480 {
481 	struct inode *new = NULL;
482 	int status = 0;
483 	int i;
484 
485 	for (i = OCFS2_LAST_GLOBAL_SYSTEM_INODE + 1;
486 	     i < NUM_SYSTEM_INODES;
487 	     i++) {
488 		if (!ocfs2_need_system_inode(osb, i))
489 			continue;
490 		new = ocfs2_get_system_file_inode(osb, i, osb->slot_num);
491 		if (!new) {
492 			ocfs2_release_system_inodes(osb);
493 			status = ocfs2_is_soft_readonly(osb) ? -EROFS : -EINVAL;
494 			mlog(ML_ERROR, "status=%d, sysfile=%d, slot=%d\n",
495 			     status, i, osb->slot_num);
496 			goto bail;
497 		}
498 		/* the array now has one ref, so drop this one */
499 		iput(new);
500 	}
501 
502 bail:
503 	if (status)
504 		mlog_errno(status);
505 	return status;
506 }
507 
508 static void ocfs2_release_system_inodes(struct ocfs2_super *osb)
509 {
510 	int i;
511 	struct inode *inode;
512 
513 	for (i = 0; i < NUM_GLOBAL_SYSTEM_INODES; i++) {
514 		inode = osb->global_system_inodes[i];
515 		if (inode) {
516 			iput(inode);
517 			osb->global_system_inodes[i] = NULL;
518 		}
519 	}
520 
521 	inode = osb->sys_root_inode;
522 	if (inode) {
523 		iput(inode);
524 		osb->sys_root_inode = NULL;
525 	}
526 
527 	inode = osb->root_inode;
528 	if (inode) {
529 		iput(inode);
530 		osb->root_inode = NULL;
531 	}
532 
533 	if (!osb->local_system_inodes)
534 		return;
535 
536 	for (i = 0; i < NUM_LOCAL_SYSTEM_INODES * osb->max_slots; i++) {
537 		if (osb->local_system_inodes[i]) {
538 			iput(osb->local_system_inodes[i]);
539 			osb->local_system_inodes[i] = NULL;
540 		}
541 	}
542 
543 	kfree(osb->local_system_inodes);
544 	osb->local_system_inodes = NULL;
545 }
546 
547 /* We're allocating fs objects, use GFP_NOFS */
548 static struct inode *ocfs2_alloc_inode(struct super_block *sb)
549 {
550 	struct ocfs2_inode_info *oi;
551 
552 	oi = kmem_cache_alloc(ocfs2_inode_cachep, GFP_NOFS);
553 	if (!oi)
554 		return NULL;
555 
556 	oi->i_sync_tid = 0;
557 	oi->i_datasync_tid = 0;
558 	memset(&oi->i_dquot, 0, sizeof(oi->i_dquot));
559 
560 	jbd2_journal_init_jbd_inode(&oi->ip_jinode, &oi->vfs_inode);
561 	return &oi->vfs_inode;
562 }
563 
564 static void ocfs2_free_inode(struct inode *inode)
565 {
566 	kmem_cache_free(ocfs2_inode_cachep, OCFS2_I(inode));
567 }
568 
569 static unsigned long long ocfs2_max_file_offset(unsigned int bbits,
570 						unsigned int cbits)
571 {
572 	unsigned int bytes = 1 << cbits;
573 	unsigned int trim = bytes;
574 	unsigned int bitshift = 32;
575 
576 	/*
577 	 * i_size and all block offsets in ocfs2 are always 64 bits
578 	 * wide. i_clusters is 32 bits, in cluster-sized units. So on
579 	 * 64 bit platforms, cluster size will be the limiting factor.
580 	 */
581 
582 #if BITS_PER_LONG == 32
583 	BUILD_BUG_ON(sizeof(sector_t) != 8);
584 	/*
585 	 * We might be limited by page cache size.
586 	 */
587 	if (bytes > PAGE_SIZE) {
588 		bytes = PAGE_SIZE;
589 		trim = 1;
590 		/*
591 		 * Shift by 31 here so that we don't get larger than
592 		 * MAX_LFS_FILESIZE
593 		 */
594 		bitshift = 31;
595 	}
596 #endif
597 
598 	/*
599 	 * Trim by a whole cluster when we can actually approach the
600 	 * on-disk limits. Otherwise we can overflow i_clusters when
601 	 * an extent start is at the max offset.
602 	 */
603 	return (((unsigned long long)bytes) << bitshift) - trim;
604 }
605 
606 static int ocfs2_remount(struct super_block *sb, int *flags, char *data)
607 {
608 	int incompat_features;
609 	int ret = 0;
610 	struct mount_options parsed_options;
611 	struct ocfs2_super *osb = OCFS2_SB(sb);
612 	u32 tmp;
613 
614 	sync_filesystem(sb);
615 
616 	if (!ocfs2_parse_options(sb, data, &parsed_options, 1) ||
617 	    !ocfs2_check_set_options(sb, &parsed_options)) {
618 		ret = -EINVAL;
619 		goto out;
620 	}
621 
622 	tmp = OCFS2_MOUNT_HB_LOCAL | OCFS2_MOUNT_HB_GLOBAL |
623 		OCFS2_MOUNT_HB_NONE;
624 	if ((osb->s_mount_opt & tmp) != (parsed_options.mount_opt & tmp)) {
625 		ret = -EINVAL;
626 		mlog(ML_ERROR, "Cannot change heartbeat mode on remount\n");
627 		goto out;
628 	}
629 
630 	if ((osb->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) !=
631 	    (parsed_options.mount_opt & OCFS2_MOUNT_DATA_WRITEBACK)) {
632 		ret = -EINVAL;
633 		mlog(ML_ERROR, "Cannot change data mode on remount\n");
634 		goto out;
635 	}
636 
637 	/* Probably don't want this on remount; it might
638 	 * mess with other nodes */
639 	if (!(osb->s_mount_opt & OCFS2_MOUNT_INODE64) &&
640 	    (parsed_options.mount_opt & OCFS2_MOUNT_INODE64)) {
641 		ret = -EINVAL;
642 		mlog(ML_ERROR, "Cannot enable inode64 on remount\n");
643 		goto out;
644 	}
645 
646 	/* We're going to/from readonly mode. */
647 	if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
648 		/* Disable quota accounting before remounting RO */
649 		if (*flags & SB_RDONLY) {
650 			ret = ocfs2_susp_quotas(osb, 0);
651 			if (ret < 0)
652 				goto out;
653 		}
654 		/* Lock here so the check of HARD_RO and the potential
655 		 * setting of SOFT_RO is atomic. */
656 		spin_lock(&osb->osb_lock);
657 		if (osb->osb_flags & OCFS2_OSB_HARD_RO) {
658 			mlog(ML_ERROR, "Remount on readonly device is forbidden.\n");
659 			ret = -EROFS;
660 			goto unlock_osb;
661 		}
662 
663 		if (*flags & SB_RDONLY) {
664 			sb->s_flags |= SB_RDONLY;
665 			osb->osb_flags |= OCFS2_OSB_SOFT_RO;
666 		} else {
667 			if (osb->osb_flags & OCFS2_OSB_ERROR_FS) {
668 				mlog(ML_ERROR, "Cannot remount RDWR "
669 				     "filesystem due to previous errors.\n");
670 				ret = -EROFS;
671 				goto unlock_osb;
672 			}
673 			incompat_features = OCFS2_HAS_RO_COMPAT_FEATURE(sb, ~OCFS2_FEATURE_RO_COMPAT_SUPP);
674 			if (incompat_features) {
675 				mlog(ML_ERROR, "Cannot remount RDWR because "
676 				     "of unsupported optional features "
677 				     "(%x).\n", incompat_features);
678 				ret = -EINVAL;
679 				goto unlock_osb;
680 			}
681 			sb->s_flags &= ~SB_RDONLY;
682 			osb->osb_flags &= ~OCFS2_OSB_SOFT_RO;
683 		}
684 		trace_ocfs2_remount(sb->s_flags, osb->osb_flags, *flags);
685 unlock_osb:
686 		spin_unlock(&osb->osb_lock);
687 		/* Enable quota accounting after remounting RW */
688 		if (!ret && !(*flags & SB_RDONLY)) {
689 			if (sb_any_quota_suspended(sb))
690 				ret = ocfs2_susp_quotas(osb, 1);
691 			else
692 				ret = ocfs2_enable_quotas(osb);
693 			if (ret < 0) {
694 				/* Return back changes... */
695 				spin_lock(&osb->osb_lock);
696 				sb->s_flags |= SB_RDONLY;
697 				osb->osb_flags |= OCFS2_OSB_SOFT_RO;
698 				spin_unlock(&osb->osb_lock);
699 				goto out;
700 			}
701 		}
702 	}
703 
704 	if (!ret) {
705 		/* Only save off the new mount options in case of a successful
706 		 * remount. */
707 		osb->s_mount_opt = parsed_options.mount_opt;
708 		osb->s_atime_quantum = parsed_options.atime_quantum;
709 		osb->preferred_slot = parsed_options.slot;
710 		if (parsed_options.commit_interval)
711 			osb->osb_commit_interval = parsed_options.commit_interval;
712 
713 		if (!ocfs2_is_hard_readonly(osb))
714 			ocfs2_set_journal_params(osb);
715 
716 		sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
717 			((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ?
718 							SB_POSIXACL : 0);
719 	}
720 out:
721 	return ret;
722 }
723 
724 static int ocfs2_sb_probe(struct super_block *sb,
725 			  struct buffer_head **bh,
726 			  int *sector_size,
727 			  struct ocfs2_blockcheck_stats *stats)
728 {
729 	int status, tmpstat;
730 	struct ocfs1_vol_disk_hdr *hdr;
731 	struct ocfs2_dinode *di;
732 	int blksize;
733 
734 	*bh = NULL;
735 
736 	/* may be > 512 */
737 	*sector_size = bdev_logical_block_size(sb->s_bdev);
738 	if (*sector_size > OCFS2_MAX_BLOCKSIZE) {
739 		mlog(ML_ERROR, "Hardware sector size too large: %d (max=%d)\n",
740 		     *sector_size, OCFS2_MAX_BLOCKSIZE);
741 		status = -EINVAL;
742 		goto bail;
743 	}
744 
745 	/* Can this really happen? */
746 	if (*sector_size < OCFS2_MIN_BLOCKSIZE)
747 		*sector_size = OCFS2_MIN_BLOCKSIZE;
748 
749 	/* check block zero for old format */
750 	status = ocfs2_get_sector(sb, bh, 0, *sector_size);
751 	if (status < 0) {
752 		mlog_errno(status);
753 		goto bail;
754 	}
755 	hdr = (struct ocfs1_vol_disk_hdr *) (*bh)->b_data;
756 	if (hdr->major_version == OCFS1_MAJOR_VERSION) {
757 		mlog(ML_ERROR, "incompatible version: %u.%u\n",
758 		     hdr->major_version, hdr->minor_version);
759 		status = -EINVAL;
760 	}
761 	if (memcmp(hdr->signature, OCFS1_VOLUME_SIGNATURE,
762 		   strlen(OCFS1_VOLUME_SIGNATURE)) == 0) {
763 		mlog(ML_ERROR, "incompatible volume signature: %8s\n",
764 		     hdr->signature);
765 		status = -EINVAL;
766 	}
767 	brelse(*bh);
768 	*bh = NULL;
769 	if (status < 0) {
770 		mlog(ML_ERROR, "This is an ocfs v1 filesystem which must be "
771 		     "upgraded before mounting with ocfs v2\n");
772 		goto bail;
773 	}
774 
775 	/*
776 	 * Now check at magic offset for 512, 1024, 2048, 4096
777 	 * blocksizes.  4096 is the maximum blocksize because it is
778 	 * the minimum clustersize.
779 	 */
780 	status = -EINVAL;
781 	for (blksize = *sector_size;
782 	     blksize <= OCFS2_MAX_BLOCKSIZE;
783 	     blksize <<= 1) {
784 		tmpstat = ocfs2_get_sector(sb, bh,
785 					   OCFS2_SUPER_BLOCK_BLKNO,
786 					   blksize);
787 		if (tmpstat < 0) {
788 			status = tmpstat;
789 			mlog_errno(status);
790 			break;
791 		}
792 		di = (struct ocfs2_dinode *) (*bh)->b_data;
793 		memset(stats, 0, sizeof(struct ocfs2_blockcheck_stats));
794 		spin_lock_init(&stats->b_lock);
795 		tmpstat = ocfs2_verify_volume(di, *bh, blksize, stats);
796 		if (tmpstat < 0) {
797 			brelse(*bh);
798 			*bh = NULL;
799 		}
800 		if (tmpstat != -EAGAIN) {
801 			status = tmpstat;
802 			break;
803 		}
804 	}
805 
806 bail:
807 	return status;
808 }
809 
810 static int ocfs2_verify_heartbeat(struct ocfs2_super *osb)
811 {
812 	u32 hb_enabled = OCFS2_MOUNT_HB_LOCAL | OCFS2_MOUNT_HB_GLOBAL;
813 
814 	if (osb->s_mount_opt & hb_enabled) {
815 		if (ocfs2_mount_local(osb)) {
816 			mlog(ML_ERROR, "Cannot heartbeat on a locally "
817 			     "mounted device.\n");
818 			return -EINVAL;
819 		}
820 		if (ocfs2_userspace_stack(osb)) {
821 			mlog(ML_ERROR, "Userspace stack expected, but "
822 			     "o2cb heartbeat arguments passed to mount\n");
823 			return -EINVAL;
824 		}
825 		if (((osb->s_mount_opt & OCFS2_MOUNT_HB_GLOBAL) &&
826 		     !ocfs2_cluster_o2cb_global_heartbeat(osb)) ||
827 		    ((osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) &&
828 		     ocfs2_cluster_o2cb_global_heartbeat(osb))) {
829 			mlog(ML_ERROR, "Mismatching o2cb heartbeat modes\n");
830 			return -EINVAL;
831 		}
832 	}
833 
834 	if (!(osb->s_mount_opt & hb_enabled)) {
835 		if (!ocfs2_mount_local(osb) && !ocfs2_is_hard_readonly(osb) &&
836 		    !ocfs2_userspace_stack(osb)) {
837 			mlog(ML_ERROR, "Heartbeat has to be started to mount "
838 			     "a read-write clustered device.\n");
839 			return -EINVAL;
840 		}
841 	}
842 
843 	return 0;
844 }
845 
846 /*
847  * If we're using a userspace stack, mount should have passed
848  * a name that matches the disk.  If not, mount should not
849  * have passed a stack.
850  */
851 static int ocfs2_verify_userspace_stack(struct ocfs2_super *osb,
852 					struct mount_options *mopt)
853 {
854 	if (!ocfs2_userspace_stack(osb) && mopt->cluster_stack[0]) {
855 		mlog(ML_ERROR,
856 		     "cluster stack passed to mount, but this filesystem "
857 		     "does not support it\n");
858 		return -EINVAL;
859 	}
860 
861 	if (ocfs2_userspace_stack(osb) &&
862 	    strncmp(osb->osb_cluster_stack, mopt->cluster_stack,
863 		    OCFS2_STACK_LABEL_LEN)) {
864 		mlog(ML_ERROR,
865 		     "cluster stack passed to mount (\"%s\") does not "
866 		     "match the filesystem (\"%s\")\n",
867 		     mopt->cluster_stack,
868 		     osb->osb_cluster_stack);
869 		return -EINVAL;
870 	}
871 
872 	return 0;
873 }
874 
875 static int ocfs2_susp_quotas(struct ocfs2_super *osb, int unsuspend)
876 {
877 	int type;
878 	struct super_block *sb = osb->sb;
879 	unsigned int feature[OCFS2_MAXQUOTAS] = {
880 					OCFS2_FEATURE_RO_COMPAT_USRQUOTA,
881 					OCFS2_FEATURE_RO_COMPAT_GRPQUOTA};
882 	int status = 0;
883 
884 	for (type = 0; type < OCFS2_MAXQUOTAS; type++) {
885 		if (!OCFS2_HAS_RO_COMPAT_FEATURE(sb, feature[type]))
886 			continue;
887 		if (unsuspend)
888 			status = dquot_resume(sb, type);
889 		else {
890 			struct ocfs2_mem_dqinfo *oinfo;
891 
892 			/* Cancel periodic syncing before suspending */
893 			oinfo = sb_dqinfo(sb, type)->dqi_priv;
894 			cancel_delayed_work_sync(&oinfo->dqi_sync_work);
895 			status = dquot_suspend(sb, type);
896 		}
897 		if (status < 0)
898 			break;
899 	}
900 	if (status < 0)
901 		mlog(ML_ERROR, "Failed to suspend/unsuspend quotas on "
902 		     "remount (error = %d).\n", status);
903 	return status;
904 }
905 
906 static int ocfs2_enable_quotas(struct ocfs2_super *osb)
907 {
908 	struct inode *inode[OCFS2_MAXQUOTAS] = { NULL, NULL };
909 	struct super_block *sb = osb->sb;
910 	unsigned int feature[OCFS2_MAXQUOTAS] = {
911 					OCFS2_FEATURE_RO_COMPAT_USRQUOTA,
912 					OCFS2_FEATURE_RO_COMPAT_GRPQUOTA};
913 	unsigned int ino[OCFS2_MAXQUOTAS] = {
914 					LOCAL_USER_QUOTA_SYSTEM_INODE,
915 					LOCAL_GROUP_QUOTA_SYSTEM_INODE };
916 	int status;
917 	int type;
918 
919 	sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE | DQUOT_NEGATIVE_USAGE;
920 	for (type = 0; type < OCFS2_MAXQUOTAS; type++) {
921 		if (!OCFS2_HAS_RO_COMPAT_FEATURE(sb, feature[type]))
922 			continue;
923 		inode[type] = ocfs2_get_system_file_inode(osb, ino[type],
924 							osb->slot_num);
925 		if (!inode[type]) {
926 			status = -ENOENT;
927 			goto out_quota_off;
928 		}
929 		status = dquot_load_quota_inode(inode[type], type, QFMT_OCFS2,
930 						DQUOT_USAGE_ENABLED);
931 		if (status < 0)
932 			goto out_quota_off;
933 	}
934 
935 	for (type = 0; type < OCFS2_MAXQUOTAS; type++)
936 		iput(inode[type]);
937 	return 0;
938 out_quota_off:
939 	ocfs2_disable_quotas(osb);
940 	for (type = 0; type < OCFS2_MAXQUOTAS; type++)
941 		iput(inode[type]);
942 	mlog_errno(status);
943 	return status;
944 }
945 
946 static void ocfs2_disable_quotas(struct ocfs2_super *osb)
947 {
948 	int type;
949 	struct inode *inode;
950 	struct super_block *sb = osb->sb;
951 	struct ocfs2_mem_dqinfo *oinfo;
952 
953 	/* We mostly ignore errors in this function because there's not much
954 	 * we can do when we see them */
955 	for (type = 0; type < OCFS2_MAXQUOTAS; type++) {
956 		if (!sb_has_quota_loaded(sb, type))
957 			continue;
958 		oinfo = sb_dqinfo(sb, type)->dqi_priv;
959 		cancel_delayed_work_sync(&oinfo->dqi_sync_work);
960 		inode = igrab(sb->s_dquot.files[type]);
961 		/* Turn off quotas. This will remove all dquot structures from
962 		 * memory and so they will be automatically synced to global
963 		 * quota files */
964 		dquot_disable(sb, type, DQUOT_USAGE_ENABLED |
965 					DQUOT_LIMITS_ENABLED);
966 		if (!inode)
967 			continue;
968 		iput(inode);
969 	}
970 }
971 
972 static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
973 {
974 	struct dentry *root;
975 	int status, sector_size;
976 	struct mount_options parsed_options;
977 	struct inode *inode = NULL;
978 	struct ocfs2_super *osb = NULL;
979 	struct buffer_head *bh = NULL;
980 	char nodestr[12];
981 	struct ocfs2_blockcheck_stats stats;
982 
983 	trace_ocfs2_fill_super(sb, data, silent);
984 
985 	if (!ocfs2_parse_options(sb, data, &parsed_options, 0)) {
986 		status = -EINVAL;
987 		goto read_super_error;
988 	}
989 
990 	/* probe for superblock */
991 	status = ocfs2_sb_probe(sb, &bh, &sector_size, &stats);
992 	if (status < 0) {
993 		mlog(ML_ERROR, "superblock probe failed!\n");
994 		goto read_super_error;
995 	}
996 
997 	status = ocfs2_initialize_super(sb, bh, sector_size, &stats);
998 	osb = OCFS2_SB(sb);
999 	if (status < 0) {
1000 		mlog_errno(status);
1001 		goto read_super_error;
1002 	}
1003 	brelse(bh);
1004 	bh = NULL;
1005 
1006 	if (!ocfs2_check_set_options(sb, &parsed_options)) {
1007 		status = -EINVAL;
1008 		goto read_super_error;
1009 	}
1010 	osb->s_mount_opt = parsed_options.mount_opt;
1011 	osb->s_atime_quantum = parsed_options.atime_quantum;
1012 	osb->preferred_slot = parsed_options.slot;
1013 	osb->osb_commit_interval = parsed_options.commit_interval;
1014 
1015 	ocfs2_la_set_sizes(osb, parsed_options.localalloc_opt);
1016 	osb->osb_resv_level = parsed_options.resv_level;
1017 	osb->osb_dir_resv_level = parsed_options.resv_level;
1018 	if (parsed_options.dir_resv_level == -1)
1019 		osb->osb_dir_resv_level = parsed_options.resv_level;
1020 	else
1021 		osb->osb_dir_resv_level = parsed_options.dir_resv_level;
1022 
1023 	status = ocfs2_verify_userspace_stack(osb, &parsed_options);
1024 	if (status)
1025 		goto read_super_error;
1026 
1027 	sb->s_magic = OCFS2_SUPER_MAGIC;
1028 
1029 	sb->s_flags = (sb->s_flags & ~(SB_POSIXACL | SB_NOSEC)) |
1030 		((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ? SB_POSIXACL : 0);
1031 
1032 	/* Hard readonly mode only if: bdev_read_only, SB_RDONLY,
1033 	 * heartbeat=none */
1034 	if (bdev_read_only(sb->s_bdev)) {
1035 		if (!sb_rdonly(sb)) {
1036 			status = -EACCES;
1037 			mlog(ML_ERROR, "Readonly device detected but readonly "
1038 			     "mount was not specified.\n");
1039 			goto read_super_error;
1040 		}
1041 
1042 		/* You should not be able to start a local heartbeat
1043 		 * on a readonly device. */
1044 		if (osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) {
1045 			status = -EROFS;
1046 			mlog(ML_ERROR, "Local heartbeat specified on readonly "
1047 			     "device.\n");
1048 			goto read_super_error;
1049 		}
1050 
1051 		status = ocfs2_check_journals_nolocks(osb);
1052 		if (status < 0) {
1053 			if (status == -EROFS)
1054 				mlog(ML_ERROR, "Recovery required on readonly "
1055 				     "file system, but write access is "
1056 				     "unavailable.\n");
1057 			else
1058 				mlog_errno(status);
1059 			goto read_super_error;
1060 		}
1061 
1062 		ocfs2_set_ro_flag(osb, 1);
1063 
1064 		printk(KERN_NOTICE "ocfs2: Readonly device (%s) detected. "
1065 		       "Cluster services will not be used for this mount. "
1066 		       "Recovery will be skipped.\n", osb->dev_str);
1067 	}
1068 
1069 	if (!ocfs2_is_hard_readonly(osb)) {
1070 		if (sb_rdonly(sb))
1071 			ocfs2_set_ro_flag(osb, 0);
1072 	}
1073 
1074 	status = ocfs2_verify_heartbeat(osb);
1075 	if (status < 0) {
1076 		mlog_errno(status);
1077 		goto read_super_error;
1078 	}
1079 
1080 	osb->osb_debug_root = debugfs_create_dir(osb->uuid_str,
1081 						 ocfs2_debugfs_root);
1082 
1083 	debugfs_create_file("fs_state", S_IFREG|S_IRUSR, osb->osb_debug_root,
1084 			    osb, &ocfs2_osb_debug_fops);
1085 
1086 	if (ocfs2_meta_ecc(osb))
1087 		ocfs2_blockcheck_stats_debugfs_install( &osb->osb_ecc_stats,
1088 							osb->osb_debug_root);
1089 
1090 	status = ocfs2_mount_volume(sb);
1091 	if (status < 0)
1092 		goto read_super_error;
1093 
1094 	if (osb->root_inode)
1095 		inode = igrab(osb->root_inode);
1096 
1097 	if (!inode) {
1098 		status = -EIO;
1099 		mlog_errno(status);
1100 		goto read_super_error;
1101 	}
1102 
1103 	root = d_make_root(inode);
1104 	if (!root) {
1105 		status = -ENOMEM;
1106 		mlog_errno(status);
1107 		goto read_super_error;
1108 	}
1109 
1110 	sb->s_root = root;
1111 
1112 	ocfs2_complete_mount_recovery(osb);
1113 
1114 	osb->osb_dev_kset = kset_create_and_add(sb->s_id, NULL,
1115 						&ocfs2_kset->kobj);
1116 	if (!osb->osb_dev_kset) {
1117 		status = -ENOMEM;
1118 		mlog(ML_ERROR, "Unable to create device kset %s.\n", sb->s_id);
1119 		goto read_super_error;
1120 	}
1121 
1122 	/* Create filecheck sysfs related directories/files at
1123 	 * /sys/fs/ocfs2/<devname>/filecheck */
1124 	if (ocfs2_filecheck_create_sysfs(osb)) {
1125 		status = -ENOMEM;
1126 		mlog(ML_ERROR, "Unable to create filecheck sysfs directory at "
1127 			"/sys/fs/ocfs2/%s/filecheck.\n", sb->s_id);
1128 		goto read_super_error;
1129 	}
1130 
1131 	if (ocfs2_mount_local(osb))
1132 		snprintf(nodestr, sizeof(nodestr), "local");
1133 	else
1134 		snprintf(nodestr, sizeof(nodestr), "%u", osb->node_num);
1135 
1136 	printk(KERN_INFO "ocfs2: Mounting device (%s) on (node %s, slot %d) "
1137 	       "with %s data mode.\n",
1138 	       osb->dev_str, nodestr, osb->slot_num,
1139 	       osb->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK ? "writeback" :
1140 	       "ordered");
1141 
1142 	atomic_set(&osb->vol_state, VOLUME_MOUNTED);
1143 	wake_up(&osb->osb_mount_event);
1144 
1145 	/* Now we can initialize quotas because we can afford to wait
1146 	 * for cluster locks recovery now. That also means that truncation
1147 	 * log recovery can happen but that waits for proper quota setup */
1148 	if (!sb_rdonly(sb)) {
1149 		status = ocfs2_enable_quotas(osb);
1150 		if (status < 0) {
1151 			/* We have to err-out specially here because
1152 			 * s_root is already set */
1153 			mlog_errno(status);
1154 			atomic_set(&osb->vol_state, VOLUME_DISABLED);
1155 			wake_up(&osb->osb_mount_event);
1156 			return status;
1157 		}
1158 	}
1159 
1160 	ocfs2_complete_quota_recovery(osb);
1161 
1162 	/* Now we wake up again for processes waiting for quotas */
1163 	atomic_set(&osb->vol_state, VOLUME_MOUNTED_QUOTAS);
1164 	wake_up(&osb->osb_mount_event);
1165 
1166 	/* Start this when the mount is almost sure of being successful */
1167 	ocfs2_orphan_scan_start(osb);
1168 
1169 	return status;
1170 
1171 read_super_error:
1172 	brelse(bh);
1173 
1174 	if (status)
1175 		mlog_errno(status);
1176 
1177 	if (osb) {
1178 		atomic_set(&osb->vol_state, VOLUME_DISABLED);
1179 		wake_up(&osb->osb_mount_event);
1180 		ocfs2_dismount_volume(sb, 1);
1181 	}
1182 
1183 	return status;
1184 }
1185 
1186 static struct dentry *ocfs2_mount(struct file_system_type *fs_type,
1187 			int flags,
1188 			const char *dev_name,
1189 			void *data)
1190 {
1191 	return mount_bdev(fs_type, flags, dev_name, data, ocfs2_fill_super);
1192 }
1193 
1194 static struct file_system_type ocfs2_fs_type = {
1195 	.owner          = THIS_MODULE,
1196 	.name           = "ocfs2",
1197 	.mount          = ocfs2_mount,
1198 	.kill_sb        = kill_block_super,
1199 	.fs_flags       = FS_REQUIRES_DEV|FS_RENAME_DOES_D_MOVE,
1200 	.next           = NULL
1201 };
1202 MODULE_ALIAS_FS("ocfs2");
1203 
1204 static int ocfs2_check_set_options(struct super_block *sb,
1205 				   struct mount_options *options)
1206 {
1207 	if (options->mount_opt & OCFS2_MOUNT_USRQUOTA &&
1208 	    !OCFS2_HAS_RO_COMPAT_FEATURE(sb,
1209 					 OCFS2_FEATURE_RO_COMPAT_USRQUOTA)) {
1210 		mlog(ML_ERROR, "User quotas were requested, but this "
1211 		     "filesystem does not have the feature enabled.\n");
1212 		return 0;
1213 	}
1214 	if (options->mount_opt & OCFS2_MOUNT_GRPQUOTA &&
1215 	    !OCFS2_HAS_RO_COMPAT_FEATURE(sb,
1216 					 OCFS2_FEATURE_RO_COMPAT_GRPQUOTA)) {
1217 		mlog(ML_ERROR, "Group quotas were requested, but this "
1218 		     "filesystem does not have the feature enabled.\n");
1219 		return 0;
1220 	}
1221 	if (options->mount_opt & OCFS2_MOUNT_POSIX_ACL &&
1222 	    !OCFS2_HAS_INCOMPAT_FEATURE(sb, OCFS2_FEATURE_INCOMPAT_XATTR)) {
1223 		mlog(ML_ERROR, "ACL support requested but extended attributes "
1224 		     "feature is not enabled\n");
1225 		return 0;
1226 	}
1227 	/* No ACL setting specified? Use XATTR feature... */
1228 	if (!(options->mount_opt & (OCFS2_MOUNT_POSIX_ACL |
1229 				    OCFS2_MOUNT_NO_POSIX_ACL))) {
1230 		if (OCFS2_HAS_INCOMPAT_FEATURE(sb, OCFS2_FEATURE_INCOMPAT_XATTR))
1231 			options->mount_opt |= OCFS2_MOUNT_POSIX_ACL;
1232 		else
1233 			options->mount_opt |= OCFS2_MOUNT_NO_POSIX_ACL;
1234 	}
1235 	return 1;
1236 }
1237 
1238 static int ocfs2_parse_options(struct super_block *sb,
1239 			       char *options,
1240 			       struct mount_options *mopt,
1241 			       int is_remount)
1242 {
1243 	int status, user_stack = 0;
1244 	char *p;
1245 	u32 tmp;
1246 	int token, option;
1247 	substring_t args[MAX_OPT_ARGS];
1248 
1249 	trace_ocfs2_parse_options(is_remount, options ? options : "(none)");
1250 
1251 	mopt->commit_interval = 0;
1252 	mopt->mount_opt = OCFS2_MOUNT_NOINTR;
1253 	mopt->atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM;
1254 	mopt->slot = OCFS2_INVALID_SLOT;
1255 	mopt->localalloc_opt = -1;
1256 	mopt->cluster_stack[0] = '\0';
1257 	mopt->resv_level = OCFS2_DEFAULT_RESV_LEVEL;
1258 	mopt->dir_resv_level = -1;
1259 
1260 	if (!options) {
1261 		status = 1;
1262 		goto bail;
1263 	}
1264 
1265 	while ((p = strsep(&options, ",")) != NULL) {
1266 		if (!*p)
1267 			continue;
1268 
1269 		token = match_token(p, tokens, args);
1270 		switch (token) {
1271 		case Opt_hb_local:
1272 			mopt->mount_opt |= OCFS2_MOUNT_HB_LOCAL;
1273 			break;
1274 		case Opt_hb_none:
1275 			mopt->mount_opt |= OCFS2_MOUNT_HB_NONE;
1276 			break;
1277 		case Opt_hb_global:
1278 			mopt->mount_opt |= OCFS2_MOUNT_HB_GLOBAL;
1279 			break;
1280 		case Opt_barrier:
1281 			if (match_int(&args[0], &option)) {
1282 				status = 0;
1283 				goto bail;
1284 			}
1285 			if (option)
1286 				mopt->mount_opt |= OCFS2_MOUNT_BARRIER;
1287 			else
1288 				mopt->mount_opt &= ~OCFS2_MOUNT_BARRIER;
1289 			break;
1290 		case Opt_intr:
1291 			mopt->mount_opt &= ~OCFS2_MOUNT_NOINTR;
1292 			break;
1293 		case Opt_nointr:
1294 			mopt->mount_opt |= OCFS2_MOUNT_NOINTR;
1295 			break;
1296 		case Opt_err_panic:
1297 			mopt->mount_opt &= ~OCFS2_MOUNT_ERRORS_CONT;
1298 			mopt->mount_opt &= ~OCFS2_MOUNT_ERRORS_ROFS;
1299 			mopt->mount_opt |= OCFS2_MOUNT_ERRORS_PANIC;
1300 			break;
1301 		case Opt_err_ro:
1302 			mopt->mount_opt &= ~OCFS2_MOUNT_ERRORS_CONT;
1303 			mopt->mount_opt &= ~OCFS2_MOUNT_ERRORS_PANIC;
1304 			mopt->mount_opt |= OCFS2_MOUNT_ERRORS_ROFS;
1305 			break;
1306 		case Opt_err_cont:
1307 			mopt->mount_opt &= ~OCFS2_MOUNT_ERRORS_ROFS;
1308 			mopt->mount_opt &= ~OCFS2_MOUNT_ERRORS_PANIC;
1309 			mopt->mount_opt |= OCFS2_MOUNT_ERRORS_CONT;
1310 			break;
1311 		case Opt_data_ordered:
1312 			mopt->mount_opt &= ~OCFS2_MOUNT_DATA_WRITEBACK;
1313 			break;
1314 		case Opt_data_writeback:
1315 			mopt->mount_opt |= OCFS2_MOUNT_DATA_WRITEBACK;
1316 			break;
1317 		case Opt_user_xattr:
1318 			mopt->mount_opt &= ~OCFS2_MOUNT_NOUSERXATTR;
1319 			break;
1320 		case Opt_nouser_xattr:
1321 			mopt->mount_opt |= OCFS2_MOUNT_NOUSERXATTR;
1322 			break;
1323 		case Opt_atime_quantum:
1324 			if (match_int(&args[0], &option)) {
1325 				status = 0;
1326 				goto bail;
1327 			}
1328 			if (option >= 0)
1329 				mopt->atime_quantum = option;
1330 			break;
1331 		case Opt_slot:
1332 			if (match_int(&args[0], &option)) {
1333 				status = 0;
1334 				goto bail;
1335 			}
1336 			if (option)
1337 				mopt->slot = (s16)option;
1338 			break;
1339 		case Opt_commit:
1340 			if (match_int(&args[0], &option)) {
1341 				status = 0;
1342 				goto bail;
1343 			}
1344 			if (option < 0)
1345 				return 0;
1346 			if (option == 0)
1347 				option = JBD2_DEFAULT_MAX_COMMIT_AGE;
1348 			mopt->commit_interval = HZ * option;
1349 			break;
1350 		case Opt_localalloc:
1351 			if (match_int(&args[0], &option)) {
1352 				status = 0;
1353 				goto bail;
1354 			}
1355 			if (option >= 0)
1356 				mopt->localalloc_opt = option;
1357 			break;
1358 		case Opt_localflocks:
1359 			/*
1360 			 * Changing this during remount could race
1361 			 * flock() requests, or "unbalance" existing
1362 			 * ones (e.g., a lock is taken in one mode but
1363 			 * dropped in the other). If users care enough
1364 			 * to flip locking modes during remount, we
1365 			 * could add a "local" flag to individual
1366 			 * flock structures for proper tracking of
1367 			 * state.
1368 			 */
1369 			if (!is_remount)
1370 				mopt->mount_opt |= OCFS2_MOUNT_LOCALFLOCKS;
1371 			break;
1372 		case Opt_stack:
1373 			/* Check both that the option we were passed
1374 			 * is of the right length and that it is a proper
1375 			 * string of the right length.
1376 			 */
1377 			if (((args[0].to - args[0].from) !=
1378 			     OCFS2_STACK_LABEL_LEN) ||
1379 			    (strnlen(args[0].from,
1380 				     OCFS2_STACK_LABEL_LEN) !=
1381 			     OCFS2_STACK_LABEL_LEN)) {
1382 				mlog(ML_ERROR,
1383 				     "Invalid cluster_stack option\n");
1384 				status = 0;
1385 				goto bail;
1386 			}
1387 			memcpy(mopt->cluster_stack, args[0].from,
1388 			       OCFS2_STACK_LABEL_LEN);
1389 			mopt->cluster_stack[OCFS2_STACK_LABEL_LEN] = '\0';
1390 			/*
1391 			 * Open code the memcmp here as we don't have
1392 			 * an osb to pass to
1393 			 * ocfs2_userspace_stack().
1394 			 */
1395 			if (memcmp(mopt->cluster_stack,
1396 				   OCFS2_CLASSIC_CLUSTER_STACK,
1397 				   OCFS2_STACK_LABEL_LEN))
1398 				user_stack = 1;
1399 			break;
1400 		case Opt_inode64:
1401 			mopt->mount_opt |= OCFS2_MOUNT_INODE64;
1402 			break;
1403 		case Opt_usrquota:
1404 			mopt->mount_opt |= OCFS2_MOUNT_USRQUOTA;
1405 			break;
1406 		case Opt_grpquota:
1407 			mopt->mount_opt |= OCFS2_MOUNT_GRPQUOTA;
1408 			break;
1409 		case Opt_coherency_buffered:
1410 			mopt->mount_opt |= OCFS2_MOUNT_COHERENCY_BUFFERED;
1411 			break;
1412 		case Opt_coherency_full:
1413 			mopt->mount_opt &= ~OCFS2_MOUNT_COHERENCY_BUFFERED;
1414 			break;
1415 		case Opt_acl:
1416 			mopt->mount_opt |= OCFS2_MOUNT_POSIX_ACL;
1417 			mopt->mount_opt &= ~OCFS2_MOUNT_NO_POSIX_ACL;
1418 			break;
1419 		case Opt_noacl:
1420 			mopt->mount_opt |= OCFS2_MOUNT_NO_POSIX_ACL;
1421 			mopt->mount_opt &= ~OCFS2_MOUNT_POSIX_ACL;
1422 			break;
1423 		case Opt_resv_level:
1424 			if (is_remount)
1425 				break;
1426 			if (match_int(&args[0], &option)) {
1427 				status = 0;
1428 				goto bail;
1429 			}
1430 			if (option >= OCFS2_MIN_RESV_LEVEL &&
1431 			    option < OCFS2_MAX_RESV_LEVEL)
1432 				mopt->resv_level = option;
1433 			break;
1434 		case Opt_dir_resv_level:
1435 			if (is_remount)
1436 				break;
1437 			if (match_int(&args[0], &option)) {
1438 				status = 0;
1439 				goto bail;
1440 			}
1441 			if (option >= OCFS2_MIN_RESV_LEVEL &&
1442 			    option < OCFS2_MAX_RESV_LEVEL)
1443 				mopt->dir_resv_level = option;
1444 			break;
1445 		case Opt_journal_async_commit:
1446 			mopt->mount_opt |= OCFS2_MOUNT_JOURNAL_ASYNC_COMMIT;
1447 			break;
1448 		default:
1449 			mlog(ML_ERROR,
1450 			     "Unrecognized mount option \"%s\" "
1451 			     "or missing value\n", p);
1452 			status = 0;
1453 			goto bail;
1454 		}
1455 	}
1456 
1457 	if (user_stack == 0) {
1458 		/* Ensure only one heartbeat mode */
1459 		tmp = mopt->mount_opt & (OCFS2_MOUNT_HB_LOCAL |
1460 					 OCFS2_MOUNT_HB_GLOBAL |
1461 					 OCFS2_MOUNT_HB_NONE);
1462 		if (hweight32(tmp) != 1) {
1463 			mlog(ML_ERROR, "Invalid heartbeat mount options\n");
1464 			status = 0;
1465 			goto bail;
1466 		}
1467 	}
1468 
1469 	status = 1;
1470 
1471 bail:
1472 	return status;
1473 }
1474 
1475 static int ocfs2_show_options(struct seq_file *s, struct dentry *root)
1476 {
1477 	struct ocfs2_super *osb = OCFS2_SB(root->d_sb);
1478 	unsigned long opts = osb->s_mount_opt;
1479 	unsigned int local_alloc_megs;
1480 
1481 	if (opts & (OCFS2_MOUNT_HB_LOCAL | OCFS2_MOUNT_HB_GLOBAL)) {
1482 		seq_printf(s, ",_netdev");
1483 		if (opts & OCFS2_MOUNT_HB_LOCAL)
1484 			seq_printf(s, ",%s", OCFS2_HB_LOCAL);
1485 		else
1486 			seq_printf(s, ",%s", OCFS2_HB_GLOBAL);
1487 	} else
1488 		seq_printf(s, ",%s", OCFS2_HB_NONE);
1489 
1490 	if (opts & OCFS2_MOUNT_NOINTR)
1491 		seq_printf(s, ",nointr");
1492 
1493 	if (opts & OCFS2_MOUNT_DATA_WRITEBACK)
1494 		seq_printf(s, ",data=writeback");
1495 	else
1496 		seq_printf(s, ",data=ordered");
1497 
1498 	if (opts & OCFS2_MOUNT_BARRIER)
1499 		seq_printf(s, ",barrier=1");
1500 
1501 	if (opts & OCFS2_MOUNT_ERRORS_PANIC)
1502 		seq_printf(s, ",errors=panic");
1503 	else if (opts & OCFS2_MOUNT_ERRORS_CONT)
1504 		seq_printf(s, ",errors=continue");
1505 	else
1506 		seq_printf(s, ",errors=remount-ro");
1507 
1508 	if (osb->preferred_slot != OCFS2_INVALID_SLOT)
1509 		seq_printf(s, ",preferred_slot=%d", osb->preferred_slot);
1510 
1511 	seq_printf(s, ",atime_quantum=%u", osb->s_atime_quantum);
1512 
1513 	if (osb->osb_commit_interval)
1514 		seq_printf(s, ",commit=%u",
1515 			   (unsigned) (osb->osb_commit_interval / HZ));
1516 
1517 	local_alloc_megs = osb->local_alloc_bits >> (20 - osb->s_clustersize_bits);
1518 	if (local_alloc_megs != ocfs2_la_default_mb(osb))
1519 		seq_printf(s, ",localalloc=%d", local_alloc_megs);
1520 
1521 	if (opts & OCFS2_MOUNT_LOCALFLOCKS)
1522 		seq_printf(s, ",localflocks,");
1523 
1524 	if (osb->osb_cluster_stack[0])
1525 		seq_show_option_n(s, "cluster_stack", osb->osb_cluster_stack,
1526 				  OCFS2_STACK_LABEL_LEN);
1527 	if (opts & OCFS2_MOUNT_USRQUOTA)
1528 		seq_printf(s, ",usrquota");
1529 	if (opts & OCFS2_MOUNT_GRPQUOTA)
1530 		seq_printf(s, ",grpquota");
1531 
1532 	if (opts & OCFS2_MOUNT_COHERENCY_BUFFERED)
1533 		seq_printf(s, ",coherency=buffered");
1534 	else
1535 		seq_printf(s, ",coherency=full");
1536 
1537 	if (opts & OCFS2_MOUNT_NOUSERXATTR)
1538 		seq_printf(s, ",nouser_xattr");
1539 	else
1540 		seq_printf(s, ",user_xattr");
1541 
1542 	if (opts & OCFS2_MOUNT_INODE64)
1543 		seq_printf(s, ",inode64");
1544 
1545 	if (opts & OCFS2_MOUNT_POSIX_ACL)
1546 		seq_printf(s, ",acl");
1547 	else
1548 		seq_printf(s, ",noacl");
1549 
1550 	if (osb->osb_resv_level != OCFS2_DEFAULT_RESV_LEVEL)
1551 		seq_printf(s, ",resv_level=%d", osb->osb_resv_level);
1552 
1553 	if (osb->osb_dir_resv_level != osb->osb_resv_level)
1554 		seq_printf(s, ",dir_resv_level=%d", osb->osb_resv_level);
1555 
1556 	if (opts & OCFS2_MOUNT_JOURNAL_ASYNC_COMMIT)
1557 		seq_printf(s, ",journal_async_commit");
1558 
1559 	return 0;
1560 }
1561 
1562 static int __init ocfs2_init(void)
1563 {
1564 	int status;
1565 
1566 	status = init_ocfs2_uptodate_cache();
1567 	if (status < 0)
1568 		goto out1;
1569 
1570 	status = ocfs2_initialize_mem_caches();
1571 	if (status < 0)
1572 		goto out2;
1573 
1574 	ocfs2_debugfs_root = debugfs_create_dir("ocfs2", NULL);
1575 
1576 	ocfs2_set_locking_protocol();
1577 
1578 	status = register_quota_format(&ocfs2_quota_format);
1579 	if (status < 0)
1580 		goto out3;
1581 	status = register_filesystem(&ocfs2_fs_type);
1582 	if (!status)
1583 		return 0;
1584 
1585 	unregister_quota_format(&ocfs2_quota_format);
1586 out3:
1587 	debugfs_remove(ocfs2_debugfs_root);
1588 	ocfs2_free_mem_caches();
1589 out2:
1590 	exit_ocfs2_uptodate_cache();
1591 out1:
1592 	mlog_errno(status);
1593 	return status;
1594 }
1595 
1596 static void __exit ocfs2_exit(void)
1597 {
1598 	unregister_quota_format(&ocfs2_quota_format);
1599 
1600 	debugfs_remove(ocfs2_debugfs_root);
1601 
1602 	ocfs2_free_mem_caches();
1603 
1604 	unregister_filesystem(&ocfs2_fs_type);
1605 
1606 	exit_ocfs2_uptodate_cache();
1607 }
1608 
1609 static void ocfs2_put_super(struct super_block *sb)
1610 {
1611 	trace_ocfs2_put_super(sb);
1612 
1613 	ocfs2_sync_blockdev(sb);
1614 	ocfs2_dismount_volume(sb, 0);
1615 }
1616 
1617 static int ocfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
1618 {
1619 	struct ocfs2_super *osb;
1620 	u32 numbits, freebits;
1621 	int status;
1622 	struct ocfs2_dinode *bm_lock;
1623 	struct buffer_head *bh = NULL;
1624 	struct inode *inode = NULL;
1625 
1626 	trace_ocfs2_statfs(dentry->d_sb, buf);
1627 
1628 	osb = OCFS2_SB(dentry->d_sb);
1629 
1630 	inode = ocfs2_get_system_file_inode(osb,
1631 					    GLOBAL_BITMAP_SYSTEM_INODE,
1632 					    OCFS2_INVALID_SLOT);
1633 	if (!inode) {
1634 		mlog(ML_ERROR, "failed to get bitmap inode\n");
1635 		status = -EIO;
1636 		goto bail;
1637 	}
1638 
1639 	status = ocfs2_inode_lock(inode, &bh, 0);
1640 	if (status < 0) {
1641 		mlog_errno(status);
1642 		goto bail;
1643 	}
1644 
1645 	bm_lock = (struct ocfs2_dinode *) bh->b_data;
1646 
1647 	numbits = le32_to_cpu(bm_lock->id1.bitmap1.i_total);
1648 	freebits = numbits - le32_to_cpu(bm_lock->id1.bitmap1.i_used);
1649 
1650 	buf->f_type = OCFS2_SUPER_MAGIC;
1651 	buf->f_bsize = dentry->d_sb->s_blocksize;
1652 	buf->f_namelen = OCFS2_MAX_FILENAME_LEN;
1653 	buf->f_blocks = ((sector_t) numbits) *
1654 			(osb->s_clustersize >> osb->sb->s_blocksize_bits);
1655 	buf->f_bfree = ((sector_t) freebits) *
1656 		       (osb->s_clustersize >> osb->sb->s_blocksize_bits);
1657 	buf->f_bavail = buf->f_bfree;
1658 	buf->f_files = numbits;
1659 	buf->f_ffree = freebits;
1660 	buf->f_fsid.val[0] = crc32_le(0, osb->uuid_str, OCFS2_VOL_UUID_LEN)
1661 				& 0xFFFFFFFFUL;
1662 	buf->f_fsid.val[1] = crc32_le(0, osb->uuid_str + OCFS2_VOL_UUID_LEN,
1663 				OCFS2_VOL_UUID_LEN) & 0xFFFFFFFFUL;
1664 
1665 	brelse(bh);
1666 
1667 	ocfs2_inode_unlock(inode, 0);
1668 	status = 0;
1669 bail:
1670 	iput(inode);
1671 
1672 	if (status)
1673 		mlog_errno(status);
1674 
1675 	return status;
1676 }
1677 
1678 static void ocfs2_inode_init_once(void *data)
1679 {
1680 	struct ocfs2_inode_info *oi = data;
1681 
1682 	oi->ip_flags = 0;
1683 	oi->ip_open_count = 0;
1684 	spin_lock_init(&oi->ip_lock);
1685 	ocfs2_extent_map_init(&oi->vfs_inode);
1686 	INIT_LIST_HEAD(&oi->ip_io_markers);
1687 	INIT_LIST_HEAD(&oi->ip_unwritten_list);
1688 	oi->ip_dir_start_lookup = 0;
1689 	init_rwsem(&oi->ip_alloc_sem);
1690 	init_rwsem(&oi->ip_xattr_sem);
1691 	mutex_init(&oi->ip_io_mutex);
1692 
1693 	oi->ip_blkno = 0ULL;
1694 	oi->ip_clusters = 0;
1695 
1696 	ocfs2_resv_init_once(&oi->ip_la_data_resv);
1697 
1698 	ocfs2_lock_res_init_once(&oi->ip_rw_lockres);
1699 	ocfs2_lock_res_init_once(&oi->ip_inode_lockres);
1700 	ocfs2_lock_res_init_once(&oi->ip_open_lockres);
1701 
1702 	ocfs2_metadata_cache_init(INODE_CACHE(&oi->vfs_inode),
1703 				  &ocfs2_inode_caching_ops);
1704 
1705 	inode_init_once(&oi->vfs_inode);
1706 }
1707 
1708 static int ocfs2_initialize_mem_caches(void)
1709 {
1710 	ocfs2_inode_cachep = kmem_cache_create("ocfs2_inode_cache",
1711 				       sizeof(struct ocfs2_inode_info),
1712 				       0,
1713 				       (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
1714 						SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1715 				       ocfs2_inode_init_once);
1716 	ocfs2_dquot_cachep = kmem_cache_create("ocfs2_dquot_cache",
1717 					sizeof(struct ocfs2_dquot),
1718 					0,
1719 					(SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
1720 						SLAB_MEM_SPREAD),
1721 					NULL);
1722 	ocfs2_qf_chunk_cachep = kmem_cache_create("ocfs2_qf_chunk_cache",
1723 					sizeof(struct ocfs2_quota_chunk),
1724 					0,
1725 					(SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD),
1726 					NULL);
1727 	if (!ocfs2_inode_cachep || !ocfs2_dquot_cachep ||
1728 	    !ocfs2_qf_chunk_cachep) {
1729 		kmem_cache_destroy(ocfs2_inode_cachep);
1730 		kmem_cache_destroy(ocfs2_dquot_cachep);
1731 		kmem_cache_destroy(ocfs2_qf_chunk_cachep);
1732 		return -ENOMEM;
1733 	}
1734 
1735 	return 0;
1736 }
1737 
1738 static void ocfs2_free_mem_caches(void)
1739 {
1740 	/*
1741 	 * Make sure all delayed rcu free inodes are flushed before we
1742 	 * destroy cache.
1743 	 */
1744 	rcu_barrier();
1745 	kmem_cache_destroy(ocfs2_inode_cachep);
1746 	ocfs2_inode_cachep = NULL;
1747 
1748 	kmem_cache_destroy(ocfs2_dquot_cachep);
1749 	ocfs2_dquot_cachep = NULL;
1750 
1751 	kmem_cache_destroy(ocfs2_qf_chunk_cachep);
1752 	ocfs2_qf_chunk_cachep = NULL;
1753 }
1754 
1755 static int ocfs2_get_sector(struct super_block *sb,
1756 			    struct buffer_head **bh,
1757 			    int block,
1758 			    int sect_size)
1759 {
1760 	if (!sb_set_blocksize(sb, sect_size)) {
1761 		mlog(ML_ERROR, "unable to set blocksize\n");
1762 		return -EIO;
1763 	}
1764 
1765 	*bh = sb_getblk(sb, block);
1766 	if (!*bh) {
1767 		mlog_errno(-ENOMEM);
1768 		return -ENOMEM;
1769 	}
1770 	lock_buffer(*bh);
1771 	if (!buffer_dirty(*bh))
1772 		clear_buffer_uptodate(*bh);
1773 	unlock_buffer(*bh);
1774 	ll_rw_block(REQ_OP_READ, 0, 1, bh);
1775 	wait_on_buffer(*bh);
1776 	if (!buffer_uptodate(*bh)) {
1777 		mlog_errno(-EIO);
1778 		brelse(*bh);
1779 		*bh = NULL;
1780 		return -EIO;
1781 	}
1782 
1783 	return 0;
1784 }
1785 
1786 static int ocfs2_mount_volume(struct super_block *sb)
1787 {
1788 	int status = 0;
1789 	int unlock_super = 0;
1790 	struct ocfs2_super *osb = OCFS2_SB(sb);
1791 
1792 	if (ocfs2_is_hard_readonly(osb))
1793 		goto leave;
1794 
1795 	mutex_init(&osb->obs_trim_fs_mutex);
1796 
1797 	status = ocfs2_dlm_init(osb);
1798 	if (status < 0) {
1799 		mlog_errno(status);
1800 		if (status == -EBADR && ocfs2_userspace_stack(osb))
1801 			mlog(ML_ERROR, "couldn't mount because cluster name on"
1802 			" disk does not match the running cluster name.\n");
1803 		goto leave;
1804 	}
1805 
1806 	status = ocfs2_super_lock(osb, 1);
1807 	if (status < 0) {
1808 		mlog_errno(status);
1809 		goto leave;
1810 	}
1811 	unlock_super = 1;
1812 
1813 	/* This will load up the node map and add ourselves to it. */
1814 	status = ocfs2_find_slot(osb);
1815 	if (status < 0) {
1816 		mlog_errno(status);
1817 		goto leave;
1818 	}
1819 
1820 	/* load all node-local system inodes */
1821 	status = ocfs2_init_local_system_inodes(osb);
1822 	if (status < 0) {
1823 		mlog_errno(status);
1824 		goto leave;
1825 	}
1826 
1827 	status = ocfs2_check_volume(osb);
1828 	if (status < 0) {
1829 		mlog_errno(status);
1830 		goto leave;
1831 	}
1832 
1833 	status = ocfs2_truncate_log_init(osb);
1834 	if (status < 0)
1835 		mlog_errno(status);
1836 
1837 leave:
1838 	if (unlock_super)
1839 		ocfs2_super_unlock(osb, 1);
1840 
1841 	return status;
1842 }
1843 
1844 static void ocfs2_dismount_volume(struct super_block *sb, int mnt_err)
1845 {
1846 	int tmp, hangup_needed = 0;
1847 	struct ocfs2_super *osb = NULL;
1848 	char nodestr[12];
1849 
1850 	trace_ocfs2_dismount_volume(sb);
1851 
1852 	BUG_ON(!sb);
1853 	osb = OCFS2_SB(sb);
1854 	BUG_ON(!osb);
1855 
1856 	/* Remove file check sysfs related directores/files,
1857 	 * and wait for the pending file check operations */
1858 	ocfs2_filecheck_remove_sysfs(osb);
1859 
1860 	kset_unregister(osb->osb_dev_kset);
1861 
1862 	/* Orphan scan should be stopped as early as possible */
1863 	ocfs2_orphan_scan_stop(osb);
1864 
1865 	ocfs2_disable_quotas(osb);
1866 
1867 	/* All dquots should be freed by now */
1868 	WARN_ON(!llist_empty(&osb->dquot_drop_list));
1869 	/* Wait for worker to be done with the work structure in osb */
1870 	cancel_work_sync(&osb->dquot_drop_work);
1871 
1872 	ocfs2_shutdown_local_alloc(osb);
1873 
1874 	ocfs2_truncate_log_shutdown(osb);
1875 
1876 	/* This will disable recovery and flush any recovery work. */
1877 	ocfs2_recovery_exit(osb);
1878 
1879 	ocfs2_journal_shutdown(osb);
1880 
1881 	ocfs2_sync_blockdev(sb);
1882 
1883 	ocfs2_purge_refcount_trees(osb);
1884 
1885 	/* No cluster connection means we've failed during mount, so skip
1886 	 * all the steps which depended on that to complete. */
1887 	if (osb->cconn) {
1888 		tmp = ocfs2_super_lock(osb, 1);
1889 		if (tmp < 0) {
1890 			mlog_errno(tmp);
1891 			return;
1892 		}
1893 	}
1894 
1895 	if (osb->slot_num != OCFS2_INVALID_SLOT)
1896 		ocfs2_put_slot(osb);
1897 
1898 	if (osb->cconn)
1899 		ocfs2_super_unlock(osb, 1);
1900 
1901 	ocfs2_release_system_inodes(osb);
1902 
1903 	/*
1904 	 * If we're dismounting due to mount error, mount.ocfs2 will clean
1905 	 * up heartbeat.  If we're a local mount, there is no heartbeat.
1906 	 * If we failed before we got a uuid_str yet, we can't stop
1907 	 * heartbeat.  Otherwise, do it.
1908 	 */
1909 	if (!mnt_err && !ocfs2_mount_local(osb) && osb->uuid_str &&
1910 	    !ocfs2_is_hard_readonly(osb))
1911 		hangup_needed = 1;
1912 
1913 	if (osb->cconn)
1914 		ocfs2_dlm_shutdown(osb, hangup_needed);
1915 
1916 	ocfs2_blockcheck_stats_debugfs_remove(&osb->osb_ecc_stats);
1917 	debugfs_remove_recursive(osb->osb_debug_root);
1918 
1919 	if (hangup_needed)
1920 		ocfs2_cluster_hangup(osb->uuid_str, strlen(osb->uuid_str));
1921 
1922 	atomic_set(&osb->vol_state, VOLUME_DISMOUNTED);
1923 
1924 	if (ocfs2_mount_local(osb))
1925 		snprintf(nodestr, sizeof(nodestr), "local");
1926 	else
1927 		snprintf(nodestr, sizeof(nodestr), "%u", osb->node_num);
1928 
1929 	printk(KERN_INFO "ocfs2: Unmounting device (%s) on (node %s)\n",
1930 	       osb->dev_str, nodestr);
1931 
1932 	ocfs2_delete_osb(osb);
1933 	kfree(osb);
1934 	sb->s_dev = 0;
1935 	sb->s_fs_info = NULL;
1936 }
1937 
1938 static int ocfs2_setup_osb_uuid(struct ocfs2_super *osb, const unsigned char *uuid,
1939 				unsigned uuid_bytes)
1940 {
1941 	int i, ret;
1942 	char *ptr;
1943 
1944 	BUG_ON(uuid_bytes != OCFS2_VOL_UUID_LEN);
1945 
1946 	osb->uuid_str = kzalloc(OCFS2_VOL_UUID_LEN * 2 + 1, GFP_KERNEL);
1947 	if (osb->uuid_str == NULL)
1948 		return -ENOMEM;
1949 
1950 	for (i = 0, ptr = osb->uuid_str; i < OCFS2_VOL_UUID_LEN; i++) {
1951 		/* print with null */
1952 		ret = snprintf(ptr, 3, "%02X", uuid[i]);
1953 		if (ret != 2) /* drop super cleans up */
1954 			return -EINVAL;
1955 		/* then only advance past the last char */
1956 		ptr += 2;
1957 	}
1958 
1959 	return 0;
1960 }
1961 
1962 /* Make sure entire volume is addressable by our journal.  Requires
1963    osb_clusters_at_boot to be valid and for the journal to have been
1964    initialized by ocfs2_journal_init(). */
1965 static int ocfs2_journal_addressable(struct ocfs2_super *osb)
1966 {
1967 	int status = 0;
1968 	u64 max_block =
1969 		ocfs2_clusters_to_blocks(osb->sb,
1970 					 osb->osb_clusters_at_boot) - 1;
1971 
1972 	/* 32-bit block number is always OK. */
1973 	if (max_block <= (u32)~0ULL)
1974 		goto out;
1975 
1976 	/* Volume is "huge", so see if our journal is new enough to
1977 	   support it. */
1978 	if (!(OCFS2_HAS_COMPAT_FEATURE(osb->sb,
1979 				       OCFS2_FEATURE_COMPAT_JBD2_SB) &&
1980 	      jbd2_journal_check_used_features(osb->journal->j_journal, 0, 0,
1981 					       JBD2_FEATURE_INCOMPAT_64BIT))) {
1982 		mlog(ML_ERROR, "The journal cannot address the entire volume. "
1983 		     "Enable the 'block64' journal option with tunefs.ocfs2");
1984 		status = -EFBIG;
1985 		goto out;
1986 	}
1987 
1988  out:
1989 	return status;
1990 }
1991 
1992 static int ocfs2_initialize_super(struct super_block *sb,
1993 				  struct buffer_head *bh,
1994 				  int sector_size,
1995 				  struct ocfs2_blockcheck_stats *stats)
1996 {
1997 	int status;
1998 	int i, cbits, bbits;
1999 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data;
2000 	struct inode *inode = NULL;
2001 	struct ocfs2_journal *journal;
2002 	struct ocfs2_super *osb;
2003 	u64 total_blocks;
2004 
2005 	osb = kzalloc(sizeof(struct ocfs2_super), GFP_KERNEL);
2006 	if (!osb) {
2007 		status = -ENOMEM;
2008 		mlog_errno(status);
2009 		goto bail;
2010 	}
2011 
2012 	sb->s_fs_info = osb;
2013 	sb->s_op = &ocfs2_sops;
2014 	sb->s_d_op = &ocfs2_dentry_ops;
2015 	sb->s_export_op = &ocfs2_export_ops;
2016 	sb->s_qcop = &dquot_quotactl_sysfile_ops;
2017 	sb->dq_op = &ocfs2_quota_operations;
2018 	sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP;
2019 	sb->s_xattr = ocfs2_xattr_handlers;
2020 	sb->s_time_gran = 1;
2021 	sb->s_flags |= SB_NOATIME;
2022 	/* this is needed to support O_LARGEFILE */
2023 	cbits = le32_to_cpu(di->id2.i_super.s_clustersize_bits);
2024 	bbits = le32_to_cpu(di->id2.i_super.s_blocksize_bits);
2025 	sb->s_maxbytes = ocfs2_max_file_offset(bbits, cbits);
2026 	memcpy(&sb->s_uuid, di->id2.i_super.s_uuid,
2027 	       sizeof(di->id2.i_super.s_uuid));
2028 
2029 	osb->osb_dx_mask = (1 << (cbits - bbits)) - 1;
2030 
2031 	for (i = 0; i < 3; i++)
2032 		osb->osb_dx_seed[i] = le32_to_cpu(di->id2.i_super.s_dx_seed[i]);
2033 	osb->osb_dx_seed[3] = le32_to_cpu(di->id2.i_super.s_uuid_hash);
2034 
2035 	osb->sb = sb;
2036 	osb->s_sectsize_bits = blksize_bits(sector_size);
2037 	BUG_ON(!osb->s_sectsize_bits);
2038 
2039 	spin_lock_init(&osb->dc_task_lock);
2040 	init_waitqueue_head(&osb->dc_event);
2041 	osb->dc_work_sequence = 0;
2042 	osb->dc_wake_sequence = 0;
2043 	INIT_LIST_HEAD(&osb->blocked_lock_list);
2044 	osb->blocked_lock_count = 0;
2045 	spin_lock_init(&osb->osb_lock);
2046 	spin_lock_init(&osb->osb_xattr_lock);
2047 	ocfs2_init_steal_slots(osb);
2048 
2049 	mutex_init(&osb->system_file_mutex);
2050 
2051 	atomic_set(&osb->alloc_stats.moves, 0);
2052 	atomic_set(&osb->alloc_stats.local_data, 0);
2053 	atomic_set(&osb->alloc_stats.bitmap_data, 0);
2054 	atomic_set(&osb->alloc_stats.bg_allocs, 0);
2055 	atomic_set(&osb->alloc_stats.bg_extends, 0);
2056 
2057 	/* Copy the blockcheck stats from the superblock probe */
2058 	osb->osb_ecc_stats = *stats;
2059 
2060 	ocfs2_init_node_maps(osb);
2061 
2062 	snprintf(osb->dev_str, sizeof(osb->dev_str), "%u,%u",
2063 		 MAJOR(osb->sb->s_dev), MINOR(osb->sb->s_dev));
2064 
2065 	osb->max_slots = le16_to_cpu(di->id2.i_super.s_max_slots);
2066 	if (osb->max_slots > OCFS2_MAX_SLOTS || osb->max_slots == 0) {
2067 		mlog(ML_ERROR, "Invalid number of node slots (%u)\n",
2068 		     osb->max_slots);
2069 		status = -EINVAL;
2070 		goto bail;
2071 	}
2072 
2073 	ocfs2_orphan_scan_init(osb);
2074 
2075 	status = ocfs2_recovery_init(osb);
2076 	if (status) {
2077 		mlog(ML_ERROR, "Unable to initialize recovery state\n");
2078 		mlog_errno(status);
2079 		goto bail;
2080 	}
2081 
2082 	init_waitqueue_head(&osb->checkpoint_event);
2083 
2084 	osb->s_atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM;
2085 
2086 	osb->slot_num = OCFS2_INVALID_SLOT;
2087 
2088 	osb->s_xattr_inline_size = le16_to_cpu(
2089 					di->id2.i_super.s_xattr_inline_size);
2090 
2091 	osb->local_alloc_state = OCFS2_LA_UNUSED;
2092 	osb->local_alloc_bh = NULL;
2093 	INIT_DELAYED_WORK(&osb->la_enable_wq, ocfs2_la_enable_worker);
2094 
2095 	init_waitqueue_head(&osb->osb_mount_event);
2096 
2097 	status = ocfs2_resmap_init(osb, &osb->osb_la_resmap);
2098 	if (status) {
2099 		mlog_errno(status);
2100 		goto bail;
2101 	}
2102 
2103 	osb->vol_label = kmalloc(OCFS2_MAX_VOL_LABEL_LEN, GFP_KERNEL);
2104 	if (!osb->vol_label) {
2105 		mlog(ML_ERROR, "unable to alloc vol label\n");
2106 		status = -ENOMEM;
2107 		goto bail;
2108 	}
2109 
2110 	osb->slot_recovery_generations =
2111 		kcalloc(osb->max_slots, sizeof(*osb->slot_recovery_generations),
2112 			GFP_KERNEL);
2113 	if (!osb->slot_recovery_generations) {
2114 		status = -ENOMEM;
2115 		mlog_errno(status);
2116 		goto bail;
2117 	}
2118 
2119 	init_waitqueue_head(&osb->osb_wipe_event);
2120 	osb->osb_orphan_wipes = kcalloc(osb->max_slots,
2121 					sizeof(*osb->osb_orphan_wipes),
2122 					GFP_KERNEL);
2123 	if (!osb->osb_orphan_wipes) {
2124 		status = -ENOMEM;
2125 		mlog_errno(status);
2126 		goto bail;
2127 	}
2128 
2129 	osb->osb_rf_lock_tree = RB_ROOT;
2130 
2131 	osb->s_feature_compat =
2132 		le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_compat);
2133 	osb->s_feature_ro_compat =
2134 		le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_ro_compat);
2135 	osb->s_feature_incompat =
2136 		le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_incompat);
2137 
2138 	if ((i = OCFS2_HAS_INCOMPAT_FEATURE(osb->sb, ~OCFS2_FEATURE_INCOMPAT_SUPP))) {
2139 		mlog(ML_ERROR, "couldn't mount because of unsupported "
2140 		     "optional features (%x).\n", i);
2141 		status = -EINVAL;
2142 		goto bail;
2143 	}
2144 	if (!sb_rdonly(osb->sb) && (i = OCFS2_HAS_RO_COMPAT_FEATURE(osb->sb, ~OCFS2_FEATURE_RO_COMPAT_SUPP))) {
2145 		mlog(ML_ERROR, "couldn't mount RDWR because of "
2146 		     "unsupported optional features (%x).\n", i);
2147 		status = -EINVAL;
2148 		goto bail;
2149 	}
2150 
2151 	if (ocfs2_clusterinfo_valid(osb)) {
2152 		osb->osb_stackflags =
2153 			OCFS2_RAW_SB(di)->s_cluster_info.ci_stackflags;
2154 		strlcpy(osb->osb_cluster_stack,
2155 		       OCFS2_RAW_SB(di)->s_cluster_info.ci_stack,
2156 		       OCFS2_STACK_LABEL_LEN + 1);
2157 		if (strlen(osb->osb_cluster_stack) != OCFS2_STACK_LABEL_LEN) {
2158 			mlog(ML_ERROR,
2159 			     "couldn't mount because of an invalid "
2160 			     "cluster stack label (%s) \n",
2161 			     osb->osb_cluster_stack);
2162 			status = -EINVAL;
2163 			goto bail;
2164 		}
2165 		strlcpy(osb->osb_cluster_name,
2166 			OCFS2_RAW_SB(di)->s_cluster_info.ci_cluster,
2167 			OCFS2_CLUSTER_NAME_LEN + 1);
2168 	} else {
2169 		/* The empty string is identical with classic tools that
2170 		 * don't know about s_cluster_info. */
2171 		osb->osb_cluster_stack[0] = '\0';
2172 	}
2173 
2174 	get_random_bytes(&osb->s_next_generation, sizeof(u32));
2175 
2176 	/* FIXME
2177 	 * This should be done in ocfs2_journal_init(), but unknown
2178 	 * ordering issues will cause the filesystem to crash.
2179 	 * If anyone wants to figure out what part of the code
2180 	 * refers to osb->journal before ocfs2_journal_init() is run,
2181 	 * be my guest.
2182 	 */
2183 	/* initialize our journal structure */
2184 
2185 	journal = kzalloc(sizeof(struct ocfs2_journal), GFP_KERNEL);
2186 	if (!journal) {
2187 		mlog(ML_ERROR, "unable to alloc journal\n");
2188 		status = -ENOMEM;
2189 		goto bail;
2190 	}
2191 	osb->journal = journal;
2192 	journal->j_osb = osb;
2193 
2194 	atomic_set(&journal->j_num_trans, 0);
2195 	init_rwsem(&journal->j_trans_barrier);
2196 	init_waitqueue_head(&journal->j_checkpointed);
2197 	spin_lock_init(&journal->j_lock);
2198 	journal->j_trans_id = (unsigned long) 1;
2199 	INIT_LIST_HEAD(&journal->j_la_cleanups);
2200 	INIT_WORK(&journal->j_recovery_work, ocfs2_complete_recovery);
2201 	journal->j_state = OCFS2_JOURNAL_FREE;
2202 
2203 	INIT_WORK(&osb->dquot_drop_work, ocfs2_drop_dquot_refs);
2204 	init_llist_head(&osb->dquot_drop_list);
2205 
2206 	/* get some pseudo constants for clustersize bits */
2207 	osb->s_clustersize_bits =
2208 		le32_to_cpu(di->id2.i_super.s_clustersize_bits);
2209 	osb->s_clustersize = 1 << osb->s_clustersize_bits;
2210 
2211 	if (osb->s_clustersize < OCFS2_MIN_CLUSTERSIZE ||
2212 	    osb->s_clustersize > OCFS2_MAX_CLUSTERSIZE) {
2213 		mlog(ML_ERROR, "Volume has invalid cluster size (%d)\n",
2214 		     osb->s_clustersize);
2215 		status = -EINVAL;
2216 		goto bail;
2217 	}
2218 
2219 	total_blocks = ocfs2_clusters_to_blocks(osb->sb,
2220 						le32_to_cpu(di->i_clusters));
2221 
2222 	status = generic_check_addressable(osb->sb->s_blocksize_bits,
2223 					   total_blocks);
2224 	if (status) {
2225 		mlog(ML_ERROR, "Volume too large "
2226 		     "to mount safely on this system");
2227 		status = -EFBIG;
2228 		goto bail;
2229 	}
2230 
2231 	if (ocfs2_setup_osb_uuid(osb, di->id2.i_super.s_uuid,
2232 				 sizeof(di->id2.i_super.s_uuid))) {
2233 		mlog(ML_ERROR, "Out of memory trying to setup our uuid.\n");
2234 		status = -ENOMEM;
2235 		goto bail;
2236 	}
2237 
2238 	strlcpy(osb->vol_label, di->id2.i_super.s_label,
2239 		OCFS2_MAX_VOL_LABEL_LEN);
2240 	osb->root_blkno = le64_to_cpu(di->id2.i_super.s_root_blkno);
2241 	osb->system_dir_blkno = le64_to_cpu(di->id2.i_super.s_system_dir_blkno);
2242 	osb->first_cluster_group_blkno =
2243 		le64_to_cpu(di->id2.i_super.s_first_cluster_group);
2244 	osb->fs_generation = le32_to_cpu(di->i_fs_generation);
2245 	osb->uuid_hash = le32_to_cpu(di->id2.i_super.s_uuid_hash);
2246 	trace_ocfs2_initialize_super(osb->vol_label, osb->uuid_str,
2247 				     (unsigned long long)osb->root_blkno,
2248 				     (unsigned long long)osb->system_dir_blkno,
2249 				     osb->s_clustersize_bits);
2250 
2251 	osb->osb_dlm_debug = ocfs2_new_dlm_debug();
2252 	if (!osb->osb_dlm_debug) {
2253 		status = -ENOMEM;
2254 		mlog_errno(status);
2255 		goto bail;
2256 	}
2257 
2258 	atomic_set(&osb->vol_state, VOLUME_INIT);
2259 
2260 	/* load root, system_dir, and all global system inodes */
2261 	status = ocfs2_init_global_system_inodes(osb);
2262 	if (status < 0) {
2263 		mlog_errno(status);
2264 		goto bail;
2265 	}
2266 
2267 	/*
2268 	 * global bitmap
2269 	 */
2270 	inode = ocfs2_get_system_file_inode(osb, GLOBAL_BITMAP_SYSTEM_INODE,
2271 					    OCFS2_INVALID_SLOT);
2272 	if (!inode) {
2273 		status = -EINVAL;
2274 		mlog_errno(status);
2275 		goto bail;
2276 	}
2277 
2278 	osb->bitmap_blkno = OCFS2_I(inode)->ip_blkno;
2279 	osb->osb_clusters_at_boot = OCFS2_I(inode)->ip_clusters;
2280 	iput(inode);
2281 
2282 	osb->bitmap_cpg = ocfs2_group_bitmap_size(sb, 0,
2283 				 osb->s_feature_incompat) * 8;
2284 
2285 	status = ocfs2_init_slot_info(osb);
2286 	if (status < 0) {
2287 		mlog_errno(status);
2288 		goto bail;
2289 	}
2290 	cleancache_init_shared_fs(sb);
2291 
2292 	osb->ocfs2_wq = alloc_ordered_workqueue("ocfs2_wq", WQ_MEM_RECLAIM);
2293 	if (!osb->ocfs2_wq) {
2294 		status = -ENOMEM;
2295 		mlog_errno(status);
2296 	}
2297 
2298 bail:
2299 	return status;
2300 }
2301 
2302 /*
2303  * will return: -EAGAIN if it is ok to keep searching for superblocks
2304  *              -EINVAL if there is a bad superblock
2305  *              0 on success
2306  */
2307 static int ocfs2_verify_volume(struct ocfs2_dinode *di,
2308 			       struct buffer_head *bh,
2309 			       u32 blksz,
2310 			       struct ocfs2_blockcheck_stats *stats)
2311 {
2312 	int status = -EAGAIN;
2313 
2314 	if (memcmp(di->i_signature, OCFS2_SUPER_BLOCK_SIGNATURE,
2315 		   strlen(OCFS2_SUPER_BLOCK_SIGNATURE)) == 0) {
2316 		/* We have to do a raw check of the feature here */
2317 		if (le32_to_cpu(di->id2.i_super.s_feature_incompat) &
2318 		    OCFS2_FEATURE_INCOMPAT_META_ECC) {
2319 			status = ocfs2_block_check_validate(bh->b_data,
2320 							    bh->b_size,
2321 							    &di->i_check,
2322 							    stats);
2323 			if (status)
2324 				goto out;
2325 		}
2326 		status = -EINVAL;
2327 		if ((1 << le32_to_cpu(di->id2.i_super.s_blocksize_bits)) != blksz) {
2328 			mlog(ML_ERROR, "found superblock with incorrect block "
2329 			     "size: found %u, should be %u\n",
2330 			     1 << le32_to_cpu(di->id2.i_super.s_blocksize_bits),
2331 			       blksz);
2332 		} else if (le16_to_cpu(di->id2.i_super.s_major_rev_level) !=
2333 			   OCFS2_MAJOR_REV_LEVEL ||
2334 			   le16_to_cpu(di->id2.i_super.s_minor_rev_level) !=
2335 			   OCFS2_MINOR_REV_LEVEL) {
2336 			mlog(ML_ERROR, "found superblock with bad version: "
2337 			     "found %u.%u, should be %u.%u\n",
2338 			     le16_to_cpu(di->id2.i_super.s_major_rev_level),
2339 			     le16_to_cpu(di->id2.i_super.s_minor_rev_level),
2340 			     OCFS2_MAJOR_REV_LEVEL,
2341 			     OCFS2_MINOR_REV_LEVEL);
2342 		} else if (bh->b_blocknr != le64_to_cpu(di->i_blkno)) {
2343 			mlog(ML_ERROR, "bad block number on superblock: "
2344 			     "found %llu, should be %llu\n",
2345 			     (unsigned long long)le64_to_cpu(di->i_blkno),
2346 			     (unsigned long long)bh->b_blocknr);
2347 		} else if (le32_to_cpu(di->id2.i_super.s_clustersize_bits) < 12 ||
2348 			    le32_to_cpu(di->id2.i_super.s_clustersize_bits) > 20) {
2349 			mlog(ML_ERROR, "bad cluster size found: %u\n",
2350 			     1 << le32_to_cpu(di->id2.i_super.s_clustersize_bits));
2351 		} else if (!le64_to_cpu(di->id2.i_super.s_root_blkno)) {
2352 			mlog(ML_ERROR, "bad root_blkno: 0\n");
2353 		} else if (!le64_to_cpu(di->id2.i_super.s_system_dir_blkno)) {
2354 			mlog(ML_ERROR, "bad system_dir_blkno: 0\n");
2355 		} else if (le16_to_cpu(di->id2.i_super.s_max_slots) > OCFS2_MAX_SLOTS) {
2356 			mlog(ML_ERROR,
2357 			     "Superblock slots found greater than file system "
2358 			     "maximum: found %u, max %u\n",
2359 			     le16_to_cpu(di->id2.i_super.s_max_slots),
2360 			     OCFS2_MAX_SLOTS);
2361 		} else {
2362 			/* found it! */
2363 			status = 0;
2364 		}
2365 	}
2366 
2367 out:
2368 	if (status && status != -EAGAIN)
2369 		mlog_errno(status);
2370 	return status;
2371 }
2372 
2373 static int ocfs2_check_volume(struct ocfs2_super *osb)
2374 {
2375 	int status;
2376 	int dirty;
2377 	int local;
2378 	struct ocfs2_dinode *local_alloc = NULL; /* only used if we
2379 						  * recover
2380 						  * ourselves. */
2381 
2382 	/* Init our journal object. */
2383 	status = ocfs2_journal_init(osb->journal, &dirty);
2384 	if (status < 0) {
2385 		mlog(ML_ERROR, "Could not initialize journal!\n");
2386 		goto finally;
2387 	}
2388 
2389 	/* Now that journal has been initialized, check to make sure
2390 	   entire volume is addressable. */
2391 	status = ocfs2_journal_addressable(osb);
2392 	if (status)
2393 		goto finally;
2394 
2395 	/* If the journal was unmounted cleanly then we don't want to
2396 	 * recover anything. Otherwise, journal_load will do that
2397 	 * dirty work for us :) */
2398 	if (!dirty) {
2399 		status = ocfs2_journal_wipe(osb->journal, 0);
2400 		if (status < 0) {
2401 			mlog_errno(status);
2402 			goto finally;
2403 		}
2404 	} else {
2405 		printk(KERN_NOTICE "ocfs2: File system on device (%s) was not "
2406 		       "unmounted cleanly, recovering it.\n", osb->dev_str);
2407 	}
2408 
2409 	local = ocfs2_mount_local(osb);
2410 
2411 	/* will play back anything left in the journal. */
2412 	status = ocfs2_journal_load(osb->journal, local, dirty);
2413 	if (status < 0) {
2414 		mlog(ML_ERROR, "ocfs2 journal load failed! %d\n", status);
2415 		goto finally;
2416 	}
2417 
2418 	if (osb->s_mount_opt & OCFS2_MOUNT_JOURNAL_ASYNC_COMMIT)
2419 		jbd2_journal_set_features(osb->journal->j_journal,
2420 				JBD2_FEATURE_COMPAT_CHECKSUM, 0,
2421 				JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2422 	else
2423 		jbd2_journal_clear_features(osb->journal->j_journal,
2424 				JBD2_FEATURE_COMPAT_CHECKSUM, 0,
2425 				JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2426 
2427 	if (dirty) {
2428 		/* recover my local alloc if we didn't unmount cleanly. */
2429 		status = ocfs2_begin_local_alloc_recovery(osb,
2430 							  osb->slot_num,
2431 							  &local_alloc);
2432 		if (status < 0) {
2433 			mlog_errno(status);
2434 			goto finally;
2435 		}
2436 		/* we complete the recovery process after we've marked
2437 		 * ourselves as mounted. */
2438 	}
2439 
2440 	status = ocfs2_load_local_alloc(osb);
2441 	if (status < 0) {
2442 		mlog_errno(status);
2443 		goto finally;
2444 	}
2445 
2446 	if (dirty) {
2447 		/* Recovery will be completed after we've mounted the
2448 		 * rest of the volume. */
2449 		osb->local_alloc_copy = local_alloc;
2450 		local_alloc = NULL;
2451 	}
2452 
2453 	/* go through each journal, trylock it and if you get the
2454 	 * lock, and it's marked as dirty, set the bit in the recover
2455 	 * map and launch a recovery thread for it. */
2456 	status = ocfs2_mark_dead_nodes(osb);
2457 	if (status < 0) {
2458 		mlog_errno(status);
2459 		goto finally;
2460 	}
2461 
2462 	status = ocfs2_compute_replay_slots(osb);
2463 	if (status < 0)
2464 		mlog_errno(status);
2465 
2466 finally:
2467 	kfree(local_alloc);
2468 
2469 	if (status)
2470 		mlog_errno(status);
2471 	return status;
2472 }
2473 
2474 /*
2475  * The routine gets called from dismount or close whenever a dismount on
2476  * volume is requested and the osb open count becomes 1.
2477  * It will remove the osb from the global list and also free up all the
2478  * initialized resources and fileobject.
2479  */
2480 static void ocfs2_delete_osb(struct ocfs2_super *osb)
2481 {
2482 	/* This function assumes that the caller has the main osb resource */
2483 
2484 	/* ocfs2_initializer_super have already created this workqueue */
2485 	if (osb->ocfs2_wq)
2486 		destroy_workqueue(osb->ocfs2_wq);
2487 
2488 	ocfs2_free_slot_info(osb);
2489 
2490 	kfree(osb->osb_orphan_wipes);
2491 	kfree(osb->slot_recovery_generations);
2492 	/* FIXME
2493 	 * This belongs in journal shutdown, but because we have to
2494 	 * allocate osb->journal at the start of ocfs2_initialize_osb(),
2495 	 * we free it here.
2496 	 */
2497 	kfree(osb->journal);
2498 	kfree(osb->local_alloc_copy);
2499 	kfree(osb->uuid_str);
2500 	kfree(osb->vol_label);
2501 	ocfs2_put_dlm_debug(osb->osb_dlm_debug);
2502 	memset(osb, 0, sizeof(struct ocfs2_super));
2503 }
2504 
2505 /* Depending on the mount option passed, perform one of the following:
2506  * Put OCFS2 into a readonly state (default)
2507  * Return EIO so that only the process errs
2508  * Fix the error as if fsck.ocfs2 -y
2509  * panic
2510  */
2511 static int ocfs2_handle_error(struct super_block *sb)
2512 {
2513 	struct ocfs2_super *osb = OCFS2_SB(sb);
2514 	int rv = 0;
2515 
2516 	ocfs2_set_osb_flag(osb, OCFS2_OSB_ERROR_FS);
2517 	pr_crit("On-disk corruption discovered. "
2518 		"Please run fsck.ocfs2 once the filesystem is unmounted.\n");
2519 
2520 	if (osb->s_mount_opt & OCFS2_MOUNT_ERRORS_PANIC) {
2521 		panic("OCFS2: (device %s): panic forced after error\n",
2522 		      sb->s_id);
2523 	} else if (osb->s_mount_opt & OCFS2_MOUNT_ERRORS_CONT) {
2524 		pr_crit("OCFS2: Returning error to the calling process.\n");
2525 		rv = -EIO;
2526 	} else { /* default option */
2527 		rv = -EROFS;
2528 		if (sb_rdonly(sb) && (ocfs2_is_soft_readonly(osb) || ocfs2_is_hard_readonly(osb)))
2529 			return rv;
2530 
2531 		pr_crit("OCFS2: File system is now read-only.\n");
2532 		sb->s_flags |= SB_RDONLY;
2533 		ocfs2_set_ro_flag(osb, 0);
2534 	}
2535 
2536 	return rv;
2537 }
2538 
2539 int __ocfs2_error(struct super_block *sb, const char *function,
2540 		  const char *fmt, ...)
2541 {
2542 	struct va_format vaf;
2543 	va_list args;
2544 
2545 	va_start(args, fmt);
2546 	vaf.fmt = fmt;
2547 	vaf.va = &args;
2548 
2549 	/* Not using mlog here because we want to show the actual
2550 	 * function the error came from. */
2551 	printk(KERN_CRIT "OCFS2: ERROR (device %s): %s: %pV",
2552 	       sb->s_id, function, &vaf);
2553 
2554 	va_end(args);
2555 
2556 	return ocfs2_handle_error(sb);
2557 }
2558 
2559 /* Handle critical errors. This is intentionally more drastic than
2560  * ocfs2_handle_error, so we only use for things like journal errors,
2561  * etc. */
2562 void __ocfs2_abort(struct super_block *sb, const char *function,
2563 		   const char *fmt, ...)
2564 {
2565 	struct va_format vaf;
2566 	va_list args;
2567 
2568 	va_start(args, fmt);
2569 
2570 	vaf.fmt = fmt;
2571 	vaf.va = &args;
2572 
2573 	printk(KERN_CRIT "OCFS2: abort (device %s): %s: %pV",
2574 	       sb->s_id, function, &vaf);
2575 
2576 	va_end(args);
2577 
2578 	/* We don't have the cluster support yet to go straight to
2579 	 * hard readonly in here. Until then, we want to keep
2580 	 * ocfs2_abort() so that we can at least mark critical
2581 	 * errors.
2582 	 *
2583 	 * TODO: This should abort the journal and alert other nodes
2584 	 * that our slot needs recovery. */
2585 
2586 	/* Force a panic(). This stinks, but it's better than letting
2587 	 * things continue without having a proper hard readonly
2588 	 * here. */
2589 	if (!ocfs2_mount_local(OCFS2_SB(sb)))
2590 		OCFS2_SB(sb)->s_mount_opt |= OCFS2_MOUNT_ERRORS_PANIC;
2591 	ocfs2_handle_error(sb);
2592 }
2593 
2594 /*
2595  * Void signal blockers, because in-kernel sigprocmask() only fails
2596  * when SIG_* is wrong.
2597  */
2598 void ocfs2_block_signals(sigset_t *oldset)
2599 {
2600 	int rc;
2601 	sigset_t blocked;
2602 
2603 	sigfillset(&blocked);
2604 	rc = sigprocmask(SIG_BLOCK, &blocked, oldset);
2605 	BUG_ON(rc);
2606 }
2607 
2608 void ocfs2_unblock_signals(sigset_t *oldset)
2609 {
2610 	int rc = sigprocmask(SIG_SETMASK, oldset, NULL);
2611 	BUG_ON(rc);
2612 }
2613 
2614 module_init(ocfs2_init);
2615 module_exit(ocfs2_exit);
2616