xref: /openbmc/linux/fs/ocfs2/super.c (revision 545e4006)
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * super.c
5  *
6  * load/unload driver, mount/dismount volumes
7  *
8  * Copyright (C) 2002, 2004 Oracle.  All rights reserved.
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public
21  * License along with this program; if not, write to the
22  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23  * Boston, MA 021110-1307, USA.
24  */
25 
26 #include <linux/module.h>
27 #include <linux/fs.h>
28 #include <linux/types.h>
29 #include <linux/slab.h>
30 #include <linux/highmem.h>
31 #include <linux/utsname.h>
32 #include <linux/init.h>
33 #include <linux/random.h>
34 #include <linux/statfs.h>
35 #include <linux/moduleparam.h>
36 #include <linux/blkdev.h>
37 #include <linux/socket.h>
38 #include <linux/inet.h>
39 #include <linux/parser.h>
40 #include <linux/crc32.h>
41 #include <linux/debugfs.h>
42 #include <linux/mount.h>
43 #include <linux/seq_file.h>
44 
45 #define MLOG_MASK_PREFIX ML_SUPER
46 #include <cluster/masklog.h>
47 
48 #include "ocfs2.h"
49 
50 /* this should be the only file to include a version 1 header */
51 #include "ocfs1_fs_compat.h"
52 
53 #include "alloc.h"
54 #include "dlmglue.h"
55 #include "export.h"
56 #include "extent_map.h"
57 #include "heartbeat.h"
58 #include "inode.h"
59 #include "journal.h"
60 #include "localalloc.h"
61 #include "namei.h"
62 #include "slot_map.h"
63 #include "super.h"
64 #include "sysfile.h"
65 #include "uptodate.h"
66 #include "ver.h"
67 
68 #include "buffer_head_io.h"
69 
70 static struct kmem_cache *ocfs2_inode_cachep = NULL;
71 
72 /* OCFS2 needs to schedule several differnt types of work which
73  * require cluster locking, disk I/O, recovery waits, etc. Since these
74  * types of work tend to be heavy we avoid using the kernel events
75  * workqueue and schedule on our own. */
76 struct workqueue_struct *ocfs2_wq = NULL;
77 
78 static struct dentry *ocfs2_debugfs_root = NULL;
79 
80 MODULE_AUTHOR("Oracle");
81 MODULE_LICENSE("GPL");
82 
83 struct mount_options
84 {
85 	unsigned long	commit_interval;
86 	unsigned long	mount_opt;
87 	unsigned int	atime_quantum;
88 	signed short	slot;
89 	unsigned int	localalloc_opt;
90 	char		cluster_stack[OCFS2_STACK_LABEL_LEN + 1];
91 };
92 
93 static int ocfs2_parse_options(struct super_block *sb, char *options,
94 			       struct mount_options *mopt,
95 			       int is_remount);
96 static int ocfs2_show_options(struct seq_file *s, struct vfsmount *mnt);
97 static void ocfs2_put_super(struct super_block *sb);
98 static int ocfs2_mount_volume(struct super_block *sb);
99 static int ocfs2_remount(struct super_block *sb, int *flags, char *data);
100 static void ocfs2_dismount_volume(struct super_block *sb, int mnt_err);
101 static int ocfs2_initialize_mem_caches(void);
102 static void ocfs2_free_mem_caches(void);
103 static void ocfs2_delete_osb(struct ocfs2_super *osb);
104 
105 static int ocfs2_statfs(struct dentry *dentry, struct kstatfs *buf);
106 
107 static int ocfs2_sync_fs(struct super_block *sb, int wait);
108 
109 static int ocfs2_init_global_system_inodes(struct ocfs2_super *osb);
110 static int ocfs2_init_local_system_inodes(struct ocfs2_super *osb);
111 static void ocfs2_release_system_inodes(struct ocfs2_super *osb);
112 static int ocfs2_check_volume(struct ocfs2_super *osb);
113 static int ocfs2_verify_volume(struct ocfs2_dinode *di,
114 			       struct buffer_head *bh,
115 			       u32 sectsize);
116 static int ocfs2_initialize_super(struct super_block *sb,
117 				  struct buffer_head *bh,
118 				  int sector_size);
119 static int ocfs2_get_sector(struct super_block *sb,
120 			    struct buffer_head **bh,
121 			    int block,
122 			    int sect_size);
123 static void ocfs2_write_super(struct super_block *sb);
124 static struct inode *ocfs2_alloc_inode(struct super_block *sb);
125 static void ocfs2_destroy_inode(struct inode *inode);
126 
127 static const struct super_operations ocfs2_sops = {
128 	.statfs		= ocfs2_statfs,
129 	.alloc_inode	= ocfs2_alloc_inode,
130 	.destroy_inode	= ocfs2_destroy_inode,
131 	.drop_inode	= ocfs2_drop_inode,
132 	.clear_inode	= ocfs2_clear_inode,
133 	.delete_inode	= ocfs2_delete_inode,
134 	.sync_fs	= ocfs2_sync_fs,
135 	.write_super	= ocfs2_write_super,
136 	.put_super	= ocfs2_put_super,
137 	.remount_fs	= ocfs2_remount,
138 	.show_options   = ocfs2_show_options,
139 };
140 
141 enum {
142 	Opt_barrier,
143 	Opt_err_panic,
144 	Opt_err_ro,
145 	Opt_intr,
146 	Opt_nointr,
147 	Opt_hb_none,
148 	Opt_hb_local,
149 	Opt_data_ordered,
150 	Opt_data_writeback,
151 	Opt_atime_quantum,
152 	Opt_slot,
153 	Opt_commit,
154 	Opt_localalloc,
155 	Opt_localflocks,
156 	Opt_stack,
157 	Opt_err,
158 };
159 
160 static match_table_t tokens = {
161 	{Opt_barrier, "barrier=%u"},
162 	{Opt_err_panic, "errors=panic"},
163 	{Opt_err_ro, "errors=remount-ro"},
164 	{Opt_intr, "intr"},
165 	{Opt_nointr, "nointr"},
166 	{Opt_hb_none, OCFS2_HB_NONE},
167 	{Opt_hb_local, OCFS2_HB_LOCAL},
168 	{Opt_data_ordered, "data=ordered"},
169 	{Opt_data_writeback, "data=writeback"},
170 	{Opt_atime_quantum, "atime_quantum=%u"},
171 	{Opt_slot, "preferred_slot=%u"},
172 	{Opt_commit, "commit=%u"},
173 	{Opt_localalloc, "localalloc=%d"},
174 	{Opt_localflocks, "localflocks"},
175 	{Opt_stack, "cluster_stack=%s"},
176 	{Opt_err, NULL}
177 };
178 
179 /*
180  * write_super and sync_fs ripped right out of ext3.
181  */
182 static void ocfs2_write_super(struct super_block *sb)
183 {
184 	if (mutex_trylock(&sb->s_lock) != 0)
185 		BUG();
186 	sb->s_dirt = 0;
187 }
188 
189 static int ocfs2_sync_fs(struct super_block *sb, int wait)
190 {
191 	int status;
192 	tid_t target;
193 	struct ocfs2_super *osb = OCFS2_SB(sb);
194 
195 	sb->s_dirt = 0;
196 
197 	if (ocfs2_is_hard_readonly(osb))
198 		return -EROFS;
199 
200 	if (wait) {
201 		status = ocfs2_flush_truncate_log(osb);
202 		if (status < 0)
203 			mlog_errno(status);
204 	} else {
205 		ocfs2_schedule_truncate_log_flush(osb, 0);
206 	}
207 
208 	if (journal_start_commit(OCFS2_SB(sb)->journal->j_journal, &target)) {
209 		if (wait)
210 			log_wait_commit(OCFS2_SB(sb)->journal->j_journal,
211 					target);
212 	}
213 	return 0;
214 }
215 
216 static int ocfs2_init_global_system_inodes(struct ocfs2_super *osb)
217 {
218 	struct inode *new = NULL;
219 	int status = 0;
220 	int i;
221 
222 	mlog_entry_void();
223 
224 	new = ocfs2_iget(osb, osb->root_blkno, OCFS2_FI_FLAG_SYSFILE, 0);
225 	if (IS_ERR(new)) {
226 		status = PTR_ERR(new);
227 		mlog_errno(status);
228 		goto bail;
229 	}
230 	osb->root_inode = new;
231 
232 	new = ocfs2_iget(osb, osb->system_dir_blkno, OCFS2_FI_FLAG_SYSFILE, 0);
233 	if (IS_ERR(new)) {
234 		status = PTR_ERR(new);
235 		mlog_errno(status);
236 		goto bail;
237 	}
238 	osb->sys_root_inode = new;
239 
240 	for (i = OCFS2_FIRST_ONLINE_SYSTEM_INODE;
241 	     i <= OCFS2_LAST_GLOBAL_SYSTEM_INODE; i++) {
242 		new = ocfs2_get_system_file_inode(osb, i, osb->slot_num);
243 		if (!new) {
244 			ocfs2_release_system_inodes(osb);
245 			status = -EINVAL;
246 			mlog_errno(status);
247 			/* FIXME: Should ERROR_RO_FS */
248 			mlog(ML_ERROR, "Unable to load system inode %d, "
249 			     "possibly corrupt fs?", i);
250 			goto bail;
251 		}
252 		// the array now has one ref, so drop this one
253 		iput(new);
254 	}
255 
256 bail:
257 	mlog_exit(status);
258 	return status;
259 }
260 
261 static int ocfs2_init_local_system_inodes(struct ocfs2_super *osb)
262 {
263 	struct inode *new = NULL;
264 	int status = 0;
265 	int i;
266 
267 	mlog_entry_void();
268 
269 	for (i = OCFS2_LAST_GLOBAL_SYSTEM_INODE + 1;
270 	     i < NUM_SYSTEM_INODES;
271 	     i++) {
272 		new = ocfs2_get_system_file_inode(osb, i, osb->slot_num);
273 		if (!new) {
274 			ocfs2_release_system_inodes(osb);
275 			status = -EINVAL;
276 			mlog(ML_ERROR, "status=%d, sysfile=%d, slot=%d\n",
277 			     status, i, osb->slot_num);
278 			goto bail;
279 		}
280 		/* the array now has one ref, so drop this one */
281 		iput(new);
282 	}
283 
284 bail:
285 	mlog_exit(status);
286 	return status;
287 }
288 
289 static void ocfs2_release_system_inodes(struct ocfs2_super *osb)
290 {
291 	int i;
292 	struct inode *inode;
293 
294 	mlog_entry_void();
295 
296 	for (i = 0; i < NUM_SYSTEM_INODES; i++) {
297 		inode = osb->system_inodes[i];
298 		if (inode) {
299 			iput(inode);
300 			osb->system_inodes[i] = NULL;
301 		}
302 	}
303 
304 	inode = osb->sys_root_inode;
305 	if (inode) {
306 		iput(inode);
307 		osb->sys_root_inode = NULL;
308 	}
309 
310 	inode = osb->root_inode;
311 	if (inode) {
312 		iput(inode);
313 		osb->root_inode = NULL;
314 	}
315 
316 	mlog_exit(0);
317 }
318 
319 /* We're allocating fs objects, use GFP_NOFS */
320 static struct inode *ocfs2_alloc_inode(struct super_block *sb)
321 {
322 	struct ocfs2_inode_info *oi;
323 
324 	oi = kmem_cache_alloc(ocfs2_inode_cachep, GFP_NOFS);
325 	if (!oi)
326 		return NULL;
327 
328 	return &oi->vfs_inode;
329 }
330 
331 static void ocfs2_destroy_inode(struct inode *inode)
332 {
333 	kmem_cache_free(ocfs2_inode_cachep, OCFS2_I(inode));
334 }
335 
336 static unsigned long long ocfs2_max_file_offset(unsigned int bbits,
337 						unsigned int cbits)
338 {
339 	unsigned int bytes = 1 << cbits;
340 	unsigned int trim = bytes;
341 	unsigned int bitshift = 32;
342 
343 	/*
344 	 * i_size and all block offsets in ocfs2 are always 64 bits
345 	 * wide. i_clusters is 32 bits, in cluster-sized units. So on
346 	 * 64 bit platforms, cluster size will be the limiting factor.
347 	 */
348 
349 #if BITS_PER_LONG == 32
350 # if defined(CONFIG_LBD)
351 	BUILD_BUG_ON(sizeof(sector_t) != 8);
352 	/*
353 	 * We might be limited by page cache size.
354 	 */
355 	if (bytes > PAGE_CACHE_SIZE) {
356 		bytes = PAGE_CACHE_SIZE;
357 		trim = 1;
358 		/*
359 		 * Shift by 31 here so that we don't get larger than
360 		 * MAX_LFS_FILESIZE
361 		 */
362 		bitshift = 31;
363 	}
364 # else
365 	/*
366 	 * We are limited by the size of sector_t. Use block size, as
367 	 * that's what we expose to the VFS.
368 	 */
369 	bytes = 1 << bbits;
370 	trim = 1;
371 	bitshift = 31;
372 # endif
373 #endif
374 
375 	/*
376 	 * Trim by a whole cluster when we can actually approach the
377 	 * on-disk limits. Otherwise we can overflow i_clusters when
378 	 * an extent start is at the max offset.
379 	 */
380 	return (((unsigned long long)bytes) << bitshift) - trim;
381 }
382 
383 static int ocfs2_remount(struct super_block *sb, int *flags, char *data)
384 {
385 	int incompat_features;
386 	int ret = 0;
387 	struct mount_options parsed_options;
388 	struct ocfs2_super *osb = OCFS2_SB(sb);
389 
390 	if (!ocfs2_parse_options(sb, data, &parsed_options, 1)) {
391 		ret = -EINVAL;
392 		goto out;
393 	}
394 
395 	if ((osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) !=
396 	    (parsed_options.mount_opt & OCFS2_MOUNT_HB_LOCAL)) {
397 		ret = -EINVAL;
398 		mlog(ML_ERROR, "Cannot change heartbeat mode on remount\n");
399 		goto out;
400 	}
401 
402 	if ((osb->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK) !=
403 	    (parsed_options.mount_opt & OCFS2_MOUNT_DATA_WRITEBACK)) {
404 		ret = -EINVAL;
405 		mlog(ML_ERROR, "Cannot change data mode on remount\n");
406 		goto out;
407 	}
408 
409 	/* We're going to/from readonly mode. */
410 	if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY)) {
411 		/* Lock here so the check of HARD_RO and the potential
412 		 * setting of SOFT_RO is atomic. */
413 		spin_lock(&osb->osb_lock);
414 		if (osb->osb_flags & OCFS2_OSB_HARD_RO) {
415 			mlog(ML_ERROR, "Remount on readonly device is forbidden.\n");
416 			ret = -EROFS;
417 			goto unlock_osb;
418 		}
419 
420 		if (*flags & MS_RDONLY) {
421 			mlog(0, "Going to ro mode.\n");
422 			sb->s_flags |= MS_RDONLY;
423 			osb->osb_flags |= OCFS2_OSB_SOFT_RO;
424 		} else {
425 			mlog(0, "Making ro filesystem writeable.\n");
426 
427 			if (osb->osb_flags & OCFS2_OSB_ERROR_FS) {
428 				mlog(ML_ERROR, "Cannot remount RDWR "
429 				     "filesystem due to previous errors.\n");
430 				ret = -EROFS;
431 				goto unlock_osb;
432 			}
433 			incompat_features = OCFS2_HAS_RO_COMPAT_FEATURE(sb, ~OCFS2_FEATURE_RO_COMPAT_SUPP);
434 			if (incompat_features) {
435 				mlog(ML_ERROR, "Cannot remount RDWR because "
436 				     "of unsupported optional features "
437 				     "(%x).\n", incompat_features);
438 				ret = -EINVAL;
439 				goto unlock_osb;
440 			}
441 			sb->s_flags &= ~MS_RDONLY;
442 			osb->osb_flags &= ~OCFS2_OSB_SOFT_RO;
443 		}
444 unlock_osb:
445 		spin_unlock(&osb->osb_lock);
446 	}
447 
448 	if (!ret) {
449 		/* Only save off the new mount options in case of a successful
450 		 * remount. */
451 		osb->s_mount_opt = parsed_options.mount_opt;
452 		osb->s_atime_quantum = parsed_options.atime_quantum;
453 		osb->preferred_slot = parsed_options.slot;
454 		if (parsed_options.commit_interval)
455 			osb->osb_commit_interval = parsed_options.commit_interval;
456 
457 		if (!ocfs2_is_hard_readonly(osb))
458 			ocfs2_set_journal_params(osb);
459 	}
460 out:
461 	return ret;
462 }
463 
464 static int ocfs2_sb_probe(struct super_block *sb,
465 			  struct buffer_head **bh,
466 			  int *sector_size)
467 {
468 	int status, tmpstat;
469 	struct ocfs1_vol_disk_hdr *hdr;
470 	struct ocfs2_dinode *di;
471 	int blksize;
472 
473 	*bh = NULL;
474 
475 	/* may be > 512 */
476 	*sector_size = bdev_hardsect_size(sb->s_bdev);
477 	if (*sector_size > OCFS2_MAX_BLOCKSIZE) {
478 		mlog(ML_ERROR, "Hardware sector size too large: %d (max=%d)\n",
479 		     *sector_size, OCFS2_MAX_BLOCKSIZE);
480 		status = -EINVAL;
481 		goto bail;
482 	}
483 
484 	/* Can this really happen? */
485 	if (*sector_size < OCFS2_MIN_BLOCKSIZE)
486 		*sector_size = OCFS2_MIN_BLOCKSIZE;
487 
488 	/* check block zero for old format */
489 	status = ocfs2_get_sector(sb, bh, 0, *sector_size);
490 	if (status < 0) {
491 		mlog_errno(status);
492 		goto bail;
493 	}
494 	hdr = (struct ocfs1_vol_disk_hdr *) (*bh)->b_data;
495 	if (hdr->major_version == OCFS1_MAJOR_VERSION) {
496 		mlog(ML_ERROR, "incompatible version: %u.%u\n",
497 		     hdr->major_version, hdr->minor_version);
498 		status = -EINVAL;
499 	}
500 	if (memcmp(hdr->signature, OCFS1_VOLUME_SIGNATURE,
501 		   strlen(OCFS1_VOLUME_SIGNATURE)) == 0) {
502 		mlog(ML_ERROR, "incompatible volume signature: %8s\n",
503 		     hdr->signature);
504 		status = -EINVAL;
505 	}
506 	brelse(*bh);
507 	*bh = NULL;
508 	if (status < 0) {
509 		mlog(ML_ERROR, "This is an ocfs v1 filesystem which must be "
510 		     "upgraded before mounting with ocfs v2\n");
511 		goto bail;
512 	}
513 
514 	/*
515 	 * Now check at magic offset for 512, 1024, 2048, 4096
516 	 * blocksizes.  4096 is the maximum blocksize because it is
517 	 * the minimum clustersize.
518 	 */
519 	status = -EINVAL;
520 	for (blksize = *sector_size;
521 	     blksize <= OCFS2_MAX_BLOCKSIZE;
522 	     blksize <<= 1) {
523 		tmpstat = ocfs2_get_sector(sb, bh,
524 					   OCFS2_SUPER_BLOCK_BLKNO,
525 					   blksize);
526 		if (tmpstat < 0) {
527 			status = tmpstat;
528 			mlog_errno(status);
529 			goto bail;
530 		}
531 		di = (struct ocfs2_dinode *) (*bh)->b_data;
532 		status = ocfs2_verify_volume(di, *bh, blksize);
533 		if (status >= 0)
534 			goto bail;
535 		brelse(*bh);
536 		*bh = NULL;
537 		if (status != -EAGAIN)
538 			break;
539 	}
540 
541 bail:
542 	return status;
543 }
544 
545 static int ocfs2_verify_heartbeat(struct ocfs2_super *osb)
546 {
547 	if (ocfs2_mount_local(osb)) {
548 		if (osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) {
549 			mlog(ML_ERROR, "Cannot heartbeat on a locally "
550 			     "mounted device.\n");
551 			return -EINVAL;
552 		}
553 	}
554 
555 	if (ocfs2_userspace_stack(osb)) {
556 		if (osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) {
557 			mlog(ML_ERROR, "Userspace stack expected, but "
558 			     "o2cb heartbeat arguments passed to mount\n");
559 			return -EINVAL;
560 		}
561 	}
562 
563 	if (!(osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL)) {
564 		if (!ocfs2_mount_local(osb) && !ocfs2_is_hard_readonly(osb) &&
565 		    !ocfs2_userspace_stack(osb)) {
566 			mlog(ML_ERROR, "Heartbeat has to be started to mount "
567 			     "a read-write clustered device.\n");
568 			return -EINVAL;
569 		}
570 	}
571 
572 	return 0;
573 }
574 
575 /*
576  * If we're using a userspace stack, mount should have passed
577  * a name that matches the disk.  If not, mount should not
578  * have passed a stack.
579  */
580 static int ocfs2_verify_userspace_stack(struct ocfs2_super *osb,
581 					struct mount_options *mopt)
582 {
583 	if (!ocfs2_userspace_stack(osb) && mopt->cluster_stack[0]) {
584 		mlog(ML_ERROR,
585 		     "cluster stack passed to mount, but this filesystem "
586 		     "does not support it\n");
587 		return -EINVAL;
588 	}
589 
590 	if (ocfs2_userspace_stack(osb) &&
591 	    strncmp(osb->osb_cluster_stack, mopt->cluster_stack,
592 		    OCFS2_STACK_LABEL_LEN)) {
593 		mlog(ML_ERROR,
594 		     "cluster stack passed to mount (\"%s\") does not "
595 		     "match the filesystem (\"%s\")\n",
596 		     mopt->cluster_stack,
597 		     osb->osb_cluster_stack);
598 		return -EINVAL;
599 	}
600 
601 	return 0;
602 }
603 
604 static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
605 {
606 	struct dentry *root;
607 	int status, sector_size;
608 	struct mount_options parsed_options;
609 	struct inode *inode = NULL;
610 	struct ocfs2_super *osb = NULL;
611 	struct buffer_head *bh = NULL;
612 	char nodestr[8];
613 
614 	mlog_entry("%p, %p, %i", sb, data, silent);
615 
616 	if (!ocfs2_parse_options(sb, data, &parsed_options, 0)) {
617 		status = -EINVAL;
618 		goto read_super_error;
619 	}
620 
621 	/* probe for superblock */
622 	status = ocfs2_sb_probe(sb, &bh, &sector_size);
623 	if (status < 0) {
624 		mlog(ML_ERROR, "superblock probe failed!\n");
625 		goto read_super_error;
626 	}
627 
628 	status = ocfs2_initialize_super(sb, bh, sector_size);
629 	osb = OCFS2_SB(sb);
630 	if (status < 0) {
631 		mlog_errno(status);
632 		goto read_super_error;
633 	}
634 	brelse(bh);
635 	bh = NULL;
636 	osb->s_mount_opt = parsed_options.mount_opt;
637 	osb->s_atime_quantum = parsed_options.atime_quantum;
638 	osb->preferred_slot = parsed_options.slot;
639 	osb->osb_commit_interval = parsed_options.commit_interval;
640 	osb->local_alloc_size = parsed_options.localalloc_opt;
641 
642 	status = ocfs2_verify_userspace_stack(osb, &parsed_options);
643 	if (status)
644 		goto read_super_error;
645 
646 	sb->s_magic = OCFS2_SUPER_MAGIC;
647 
648 	/* Hard readonly mode only if: bdev_read_only, MS_RDONLY,
649 	 * heartbeat=none */
650 	if (bdev_read_only(sb->s_bdev)) {
651 		if (!(sb->s_flags & MS_RDONLY)) {
652 			status = -EACCES;
653 			mlog(ML_ERROR, "Readonly device detected but readonly "
654 			     "mount was not specified.\n");
655 			goto read_super_error;
656 		}
657 
658 		/* You should not be able to start a local heartbeat
659 		 * on a readonly device. */
660 		if (osb->s_mount_opt & OCFS2_MOUNT_HB_LOCAL) {
661 			status = -EROFS;
662 			mlog(ML_ERROR, "Local heartbeat specified on readonly "
663 			     "device.\n");
664 			goto read_super_error;
665 		}
666 
667 		status = ocfs2_check_journals_nolocks(osb);
668 		if (status < 0) {
669 			if (status == -EROFS)
670 				mlog(ML_ERROR, "Recovery required on readonly "
671 				     "file system, but write access is "
672 				     "unavailable.\n");
673 			else
674 				mlog_errno(status);
675 			goto read_super_error;
676 		}
677 
678 		ocfs2_set_ro_flag(osb, 1);
679 
680 		printk(KERN_NOTICE "Readonly device detected. No cluster "
681 		       "services will be utilized for this mount. Recovery "
682 		       "will be skipped.\n");
683 	}
684 
685 	if (!ocfs2_is_hard_readonly(osb)) {
686 		if (sb->s_flags & MS_RDONLY)
687 			ocfs2_set_ro_flag(osb, 0);
688 	}
689 
690 	status = ocfs2_verify_heartbeat(osb);
691 	if (status < 0) {
692 		mlog_errno(status);
693 		goto read_super_error;
694 	}
695 
696 	osb->osb_debug_root = debugfs_create_dir(osb->uuid_str,
697 						 ocfs2_debugfs_root);
698 	if (!osb->osb_debug_root) {
699 		status = -EINVAL;
700 		mlog(ML_ERROR, "Unable to create per-mount debugfs root.\n");
701 		goto read_super_error;
702 	}
703 
704 	status = ocfs2_mount_volume(sb);
705 	if (osb->root_inode)
706 		inode = igrab(osb->root_inode);
707 
708 	if (status < 0)
709 		goto read_super_error;
710 
711 	if (!inode) {
712 		status = -EIO;
713 		mlog_errno(status);
714 		goto read_super_error;
715 	}
716 
717 	root = d_alloc_root(inode);
718 	if (!root) {
719 		status = -ENOMEM;
720 		mlog_errno(status);
721 		goto read_super_error;
722 	}
723 
724 	sb->s_root = root;
725 
726 	ocfs2_complete_mount_recovery(osb);
727 
728 	if (ocfs2_mount_local(osb))
729 		snprintf(nodestr, sizeof(nodestr), "local");
730 	else
731 		snprintf(nodestr, sizeof(nodestr), "%u", osb->node_num);
732 
733 	printk(KERN_INFO "ocfs2: Mounting device (%s) on (node %s, slot %d) "
734 	       "with %s data mode.\n",
735 	       osb->dev_str, nodestr, osb->slot_num,
736 	       osb->s_mount_opt & OCFS2_MOUNT_DATA_WRITEBACK ? "writeback" :
737 	       "ordered");
738 
739 	atomic_set(&osb->vol_state, VOLUME_MOUNTED);
740 	wake_up(&osb->osb_mount_event);
741 
742 	mlog_exit(status);
743 	return status;
744 
745 read_super_error:
746 	if (bh != NULL)
747 		brelse(bh);
748 
749 	if (inode)
750 		iput(inode);
751 
752 	if (osb) {
753 		atomic_set(&osb->vol_state, VOLUME_DISABLED);
754 		wake_up(&osb->osb_mount_event);
755 		ocfs2_dismount_volume(sb, 1);
756 	}
757 
758 	mlog_exit(status);
759 	return status;
760 }
761 
762 static int ocfs2_get_sb(struct file_system_type *fs_type,
763 			int flags,
764 			const char *dev_name,
765 			void *data,
766 			struct vfsmount *mnt)
767 {
768 	return get_sb_bdev(fs_type, flags, dev_name, data, ocfs2_fill_super,
769 			   mnt);
770 }
771 
772 static struct file_system_type ocfs2_fs_type = {
773 	.owner          = THIS_MODULE,
774 	.name           = "ocfs2",
775 	.get_sb         = ocfs2_get_sb, /* is this called when we mount
776 					* the fs? */
777 	.kill_sb        = kill_block_super, /* set to the generic one
778 					     * right now, but do we
779 					     * need to change that? */
780 	.fs_flags       = FS_REQUIRES_DEV|FS_RENAME_DOES_D_MOVE,
781 	.next           = NULL
782 };
783 
784 static int ocfs2_parse_options(struct super_block *sb,
785 			       char *options,
786 			       struct mount_options *mopt,
787 			       int is_remount)
788 {
789 	int status;
790 	char *p;
791 
792 	mlog_entry("remount: %d, options: \"%s\"\n", is_remount,
793 		   options ? options : "(none)");
794 
795 	mopt->commit_interval = 0;
796 	mopt->mount_opt = 0;
797 	mopt->atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM;
798 	mopt->slot = OCFS2_INVALID_SLOT;
799 	mopt->localalloc_opt = OCFS2_DEFAULT_LOCAL_ALLOC_SIZE;
800 	mopt->cluster_stack[0] = '\0';
801 
802 	if (!options) {
803 		status = 1;
804 		goto bail;
805 	}
806 
807 	while ((p = strsep(&options, ",")) != NULL) {
808 		int token, option;
809 		substring_t args[MAX_OPT_ARGS];
810 
811 		if (!*p)
812 			continue;
813 
814 		token = match_token(p, tokens, args);
815 		switch (token) {
816 		case Opt_hb_local:
817 			mopt->mount_opt |= OCFS2_MOUNT_HB_LOCAL;
818 			break;
819 		case Opt_hb_none:
820 			mopt->mount_opt &= ~OCFS2_MOUNT_HB_LOCAL;
821 			break;
822 		case Opt_barrier:
823 			if (match_int(&args[0], &option)) {
824 				status = 0;
825 				goto bail;
826 			}
827 			if (option)
828 				mopt->mount_opt |= OCFS2_MOUNT_BARRIER;
829 			else
830 				mopt->mount_opt &= ~OCFS2_MOUNT_BARRIER;
831 			break;
832 		case Opt_intr:
833 			mopt->mount_opt &= ~OCFS2_MOUNT_NOINTR;
834 			break;
835 		case Opt_nointr:
836 			mopt->mount_opt |= OCFS2_MOUNT_NOINTR;
837 			break;
838 		case Opt_err_panic:
839 			mopt->mount_opt |= OCFS2_MOUNT_ERRORS_PANIC;
840 			break;
841 		case Opt_err_ro:
842 			mopt->mount_opt &= ~OCFS2_MOUNT_ERRORS_PANIC;
843 			break;
844 		case Opt_data_ordered:
845 			mopt->mount_opt &= ~OCFS2_MOUNT_DATA_WRITEBACK;
846 			break;
847 		case Opt_data_writeback:
848 			mopt->mount_opt |= OCFS2_MOUNT_DATA_WRITEBACK;
849 			break;
850 		case Opt_atime_quantum:
851 			if (match_int(&args[0], &option)) {
852 				status = 0;
853 				goto bail;
854 			}
855 			if (option >= 0)
856 				mopt->atime_quantum = option;
857 			break;
858 		case Opt_slot:
859 			option = 0;
860 			if (match_int(&args[0], &option)) {
861 				status = 0;
862 				goto bail;
863 			}
864 			if (option)
865 				mopt->slot = (s16)option;
866 			break;
867 		case Opt_commit:
868 			option = 0;
869 			if (match_int(&args[0], &option)) {
870 				status = 0;
871 				goto bail;
872 			}
873 			if (option < 0)
874 				return 0;
875 			if (option == 0)
876 				option = JBD_DEFAULT_MAX_COMMIT_AGE;
877 			mopt->commit_interval = HZ * option;
878 			break;
879 		case Opt_localalloc:
880 			option = 0;
881 			if (match_int(&args[0], &option)) {
882 				status = 0;
883 				goto bail;
884 			}
885 			if (option >= 0 && (option <= ocfs2_local_alloc_size(sb) * 8))
886 				mopt->localalloc_opt = option;
887 			break;
888 		case Opt_localflocks:
889 			/*
890 			 * Changing this during remount could race
891 			 * flock() requests, or "unbalance" existing
892 			 * ones (e.g., a lock is taken in one mode but
893 			 * dropped in the other). If users care enough
894 			 * to flip locking modes during remount, we
895 			 * could add a "local" flag to individual
896 			 * flock structures for proper tracking of
897 			 * state.
898 			 */
899 			if (!is_remount)
900 				mopt->mount_opt |= OCFS2_MOUNT_LOCALFLOCKS;
901 			break;
902 		case Opt_stack:
903 			/* Check both that the option we were passed
904 			 * is of the right length and that it is a proper
905 			 * string of the right length.
906 			 */
907 			if (((args[0].to - args[0].from) !=
908 			     OCFS2_STACK_LABEL_LEN) ||
909 			    (strnlen(args[0].from,
910 				     OCFS2_STACK_LABEL_LEN) !=
911 			     OCFS2_STACK_LABEL_LEN)) {
912 				mlog(ML_ERROR,
913 				     "Invalid cluster_stack option\n");
914 				status = 0;
915 				goto bail;
916 			}
917 			memcpy(mopt->cluster_stack, args[0].from,
918 			       OCFS2_STACK_LABEL_LEN);
919 			mopt->cluster_stack[OCFS2_STACK_LABEL_LEN] = '\0';
920 			break;
921 		default:
922 			mlog(ML_ERROR,
923 			     "Unrecognized mount option \"%s\" "
924 			     "or missing value\n", p);
925 			status = 0;
926 			goto bail;
927 		}
928 	}
929 
930 	status = 1;
931 
932 bail:
933 	mlog_exit(status);
934 	return status;
935 }
936 
937 static int ocfs2_show_options(struct seq_file *s, struct vfsmount *mnt)
938 {
939 	struct ocfs2_super *osb = OCFS2_SB(mnt->mnt_sb);
940 	unsigned long opts = osb->s_mount_opt;
941 
942 	if (opts & OCFS2_MOUNT_HB_LOCAL)
943 		seq_printf(s, ",_netdev,heartbeat=local");
944 	else
945 		seq_printf(s, ",heartbeat=none");
946 
947 	if (opts & OCFS2_MOUNT_NOINTR)
948 		seq_printf(s, ",nointr");
949 
950 	if (opts & OCFS2_MOUNT_DATA_WRITEBACK)
951 		seq_printf(s, ",data=writeback");
952 	else
953 		seq_printf(s, ",data=ordered");
954 
955 	if (opts & OCFS2_MOUNT_BARRIER)
956 		seq_printf(s, ",barrier=1");
957 
958 	if (opts & OCFS2_MOUNT_ERRORS_PANIC)
959 		seq_printf(s, ",errors=panic");
960 	else
961 		seq_printf(s, ",errors=remount-ro");
962 
963 	if (osb->preferred_slot != OCFS2_INVALID_SLOT)
964 		seq_printf(s, ",preferred_slot=%d", osb->preferred_slot);
965 
966 	if (osb->s_atime_quantum != OCFS2_DEFAULT_ATIME_QUANTUM)
967 		seq_printf(s, ",atime_quantum=%u", osb->s_atime_quantum);
968 
969 	if (osb->osb_commit_interval)
970 		seq_printf(s, ",commit=%u",
971 			   (unsigned) (osb->osb_commit_interval / HZ));
972 
973 	if (osb->local_alloc_size != OCFS2_DEFAULT_LOCAL_ALLOC_SIZE)
974 		seq_printf(s, ",localalloc=%d", osb->local_alloc_size);
975 
976 	if (opts & OCFS2_MOUNT_LOCALFLOCKS)
977 		seq_printf(s, ",localflocks,");
978 
979 	if (osb->osb_cluster_stack[0])
980 		seq_printf(s, ",cluster_stack=%.*s", OCFS2_STACK_LABEL_LEN,
981 			   osb->osb_cluster_stack);
982 
983 	return 0;
984 }
985 
986 static int __init ocfs2_init(void)
987 {
988 	int status;
989 
990 	mlog_entry_void();
991 
992 	ocfs2_print_version();
993 
994 	status = init_ocfs2_uptodate_cache();
995 	if (status < 0) {
996 		mlog_errno(status);
997 		goto leave;
998 	}
999 
1000 	status = ocfs2_initialize_mem_caches();
1001 	if (status < 0) {
1002 		mlog_errno(status);
1003 		goto leave;
1004 	}
1005 
1006 	ocfs2_wq = create_singlethread_workqueue("ocfs2_wq");
1007 	if (!ocfs2_wq) {
1008 		status = -ENOMEM;
1009 		goto leave;
1010 	}
1011 
1012 	ocfs2_debugfs_root = debugfs_create_dir("ocfs2", NULL);
1013 	if (!ocfs2_debugfs_root) {
1014 		status = -EFAULT;
1015 		mlog(ML_ERROR, "Unable to create ocfs2 debugfs root.\n");
1016 	}
1017 
1018 	ocfs2_set_locking_protocol();
1019 
1020 leave:
1021 	if (status < 0) {
1022 		ocfs2_free_mem_caches();
1023 		exit_ocfs2_uptodate_cache();
1024 	}
1025 
1026 	mlog_exit(status);
1027 
1028 	if (status >= 0) {
1029 		return register_filesystem(&ocfs2_fs_type);
1030 	} else
1031 		return -1;
1032 }
1033 
1034 static void __exit ocfs2_exit(void)
1035 {
1036 	mlog_entry_void();
1037 
1038 	if (ocfs2_wq) {
1039 		flush_workqueue(ocfs2_wq);
1040 		destroy_workqueue(ocfs2_wq);
1041 	}
1042 
1043 	debugfs_remove(ocfs2_debugfs_root);
1044 
1045 	ocfs2_free_mem_caches();
1046 
1047 	unregister_filesystem(&ocfs2_fs_type);
1048 
1049 	exit_ocfs2_uptodate_cache();
1050 
1051 	mlog_exit_void();
1052 }
1053 
1054 static void ocfs2_put_super(struct super_block *sb)
1055 {
1056 	mlog_entry("(0x%p)\n", sb);
1057 
1058 	ocfs2_sync_blockdev(sb);
1059 	ocfs2_dismount_volume(sb, 0);
1060 
1061 	mlog_exit_void();
1062 }
1063 
1064 static int ocfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
1065 {
1066 	struct ocfs2_super *osb;
1067 	u32 numbits, freebits;
1068 	int status;
1069 	struct ocfs2_dinode *bm_lock;
1070 	struct buffer_head *bh = NULL;
1071 	struct inode *inode = NULL;
1072 
1073 	mlog_entry("(%p, %p)\n", dentry->d_sb, buf);
1074 
1075 	osb = OCFS2_SB(dentry->d_sb);
1076 
1077 	inode = ocfs2_get_system_file_inode(osb,
1078 					    GLOBAL_BITMAP_SYSTEM_INODE,
1079 					    OCFS2_INVALID_SLOT);
1080 	if (!inode) {
1081 		mlog(ML_ERROR, "failed to get bitmap inode\n");
1082 		status = -EIO;
1083 		goto bail;
1084 	}
1085 
1086 	status = ocfs2_inode_lock(inode, &bh, 0);
1087 	if (status < 0) {
1088 		mlog_errno(status);
1089 		goto bail;
1090 	}
1091 
1092 	bm_lock = (struct ocfs2_dinode *) bh->b_data;
1093 
1094 	numbits = le32_to_cpu(bm_lock->id1.bitmap1.i_total);
1095 	freebits = numbits - le32_to_cpu(bm_lock->id1.bitmap1.i_used);
1096 
1097 	buf->f_type = OCFS2_SUPER_MAGIC;
1098 	buf->f_bsize = dentry->d_sb->s_blocksize;
1099 	buf->f_namelen = OCFS2_MAX_FILENAME_LEN;
1100 	buf->f_blocks = ((sector_t) numbits) *
1101 			(osb->s_clustersize >> osb->sb->s_blocksize_bits);
1102 	buf->f_bfree = ((sector_t) freebits) *
1103 		       (osb->s_clustersize >> osb->sb->s_blocksize_bits);
1104 	buf->f_bavail = buf->f_bfree;
1105 	buf->f_files = numbits;
1106 	buf->f_ffree = freebits;
1107 
1108 	brelse(bh);
1109 
1110 	ocfs2_inode_unlock(inode, 0);
1111 	status = 0;
1112 bail:
1113 	if (inode)
1114 		iput(inode);
1115 
1116 	mlog_exit(status);
1117 
1118 	return status;
1119 }
1120 
1121 static void ocfs2_inode_init_once(struct kmem_cache *cachep, void *data)
1122 {
1123 	struct ocfs2_inode_info *oi = data;
1124 
1125 	oi->ip_flags = 0;
1126 	oi->ip_open_count = 0;
1127 	spin_lock_init(&oi->ip_lock);
1128 	ocfs2_extent_map_init(&oi->vfs_inode);
1129 	INIT_LIST_HEAD(&oi->ip_io_markers);
1130 	oi->ip_created_trans = 0;
1131 	oi->ip_last_trans = 0;
1132 	oi->ip_dir_start_lookup = 0;
1133 
1134 	init_rwsem(&oi->ip_alloc_sem);
1135 	mutex_init(&oi->ip_io_mutex);
1136 
1137 	oi->ip_blkno = 0ULL;
1138 	oi->ip_clusters = 0;
1139 
1140 	ocfs2_lock_res_init_once(&oi->ip_rw_lockres);
1141 	ocfs2_lock_res_init_once(&oi->ip_inode_lockres);
1142 	ocfs2_lock_res_init_once(&oi->ip_open_lockres);
1143 
1144 	ocfs2_metadata_cache_init(&oi->vfs_inode);
1145 
1146 	inode_init_once(&oi->vfs_inode);
1147 }
1148 
1149 static int ocfs2_initialize_mem_caches(void)
1150 {
1151 	ocfs2_inode_cachep = kmem_cache_create("ocfs2_inode_cache",
1152 				       sizeof(struct ocfs2_inode_info),
1153 				       0,
1154 				       (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
1155 						SLAB_MEM_SPREAD),
1156 				       ocfs2_inode_init_once);
1157 	if (!ocfs2_inode_cachep)
1158 		return -ENOMEM;
1159 
1160 	return 0;
1161 }
1162 
1163 static void ocfs2_free_mem_caches(void)
1164 {
1165 	if (ocfs2_inode_cachep)
1166 		kmem_cache_destroy(ocfs2_inode_cachep);
1167 
1168 	ocfs2_inode_cachep = NULL;
1169 }
1170 
1171 static int ocfs2_get_sector(struct super_block *sb,
1172 			    struct buffer_head **bh,
1173 			    int block,
1174 			    int sect_size)
1175 {
1176 	if (!sb_set_blocksize(sb, sect_size)) {
1177 		mlog(ML_ERROR, "unable to set blocksize\n");
1178 		return -EIO;
1179 	}
1180 
1181 	*bh = sb_getblk(sb, block);
1182 	if (!*bh) {
1183 		mlog_errno(-EIO);
1184 		return -EIO;
1185 	}
1186 	lock_buffer(*bh);
1187 	if (!buffer_dirty(*bh))
1188 		clear_buffer_uptodate(*bh);
1189 	unlock_buffer(*bh);
1190 	ll_rw_block(READ, 1, bh);
1191 	wait_on_buffer(*bh);
1192 	return 0;
1193 }
1194 
1195 static int ocfs2_mount_volume(struct super_block *sb)
1196 {
1197 	int status = 0;
1198 	int unlock_super = 0;
1199 	struct ocfs2_super *osb = OCFS2_SB(sb);
1200 
1201 	mlog_entry_void();
1202 
1203 	if (ocfs2_is_hard_readonly(osb))
1204 		goto leave;
1205 
1206 	status = ocfs2_dlm_init(osb);
1207 	if (status < 0) {
1208 		mlog_errno(status);
1209 		goto leave;
1210 	}
1211 
1212 	status = ocfs2_super_lock(osb, 1);
1213 	if (status < 0) {
1214 		mlog_errno(status);
1215 		goto leave;
1216 	}
1217 	unlock_super = 1;
1218 
1219 	/* This will load up the node map and add ourselves to it. */
1220 	status = ocfs2_find_slot(osb);
1221 	if (status < 0) {
1222 		mlog_errno(status);
1223 		goto leave;
1224 	}
1225 
1226 	/* load all node-local system inodes */
1227 	status = ocfs2_init_local_system_inodes(osb);
1228 	if (status < 0) {
1229 		mlog_errno(status);
1230 		goto leave;
1231 	}
1232 
1233 	status = ocfs2_check_volume(osb);
1234 	if (status < 0) {
1235 		mlog_errno(status);
1236 		goto leave;
1237 	}
1238 
1239 	status = ocfs2_truncate_log_init(osb);
1240 	if (status < 0) {
1241 		mlog_errno(status);
1242 		goto leave;
1243 	}
1244 
1245 	if (ocfs2_mount_local(osb))
1246 		goto leave;
1247 
1248 leave:
1249 	if (unlock_super)
1250 		ocfs2_super_unlock(osb, 1);
1251 
1252 	mlog_exit(status);
1253 	return status;
1254 }
1255 
1256 static void ocfs2_dismount_volume(struct super_block *sb, int mnt_err)
1257 {
1258 	int tmp, hangup_needed = 0;
1259 	struct ocfs2_super *osb = NULL;
1260 	char nodestr[8];
1261 
1262 	mlog_entry("(0x%p)\n", sb);
1263 
1264 	BUG_ON(!sb);
1265 	osb = OCFS2_SB(sb);
1266 	BUG_ON(!osb);
1267 
1268 	ocfs2_shutdown_local_alloc(osb);
1269 
1270 	ocfs2_truncate_log_shutdown(osb);
1271 
1272 	/* This will disable recovery and flush any recovery work. */
1273 	ocfs2_recovery_exit(osb);
1274 
1275 	ocfs2_journal_shutdown(osb);
1276 
1277 	ocfs2_sync_blockdev(sb);
1278 
1279 	/* No cluster connection means we've failed during mount, so skip
1280 	 * all the steps which depended on that to complete. */
1281 	if (osb->cconn) {
1282 		tmp = ocfs2_super_lock(osb, 1);
1283 		if (tmp < 0) {
1284 			mlog_errno(tmp);
1285 			return;
1286 		}
1287 	}
1288 
1289 	if (osb->slot_num != OCFS2_INVALID_SLOT)
1290 		ocfs2_put_slot(osb);
1291 
1292 	if (osb->cconn)
1293 		ocfs2_super_unlock(osb, 1);
1294 
1295 	ocfs2_release_system_inodes(osb);
1296 
1297 	/*
1298 	 * If we're dismounting due to mount error, mount.ocfs2 will clean
1299 	 * up heartbeat.  If we're a local mount, there is no heartbeat.
1300 	 * If we failed before we got a uuid_str yet, we can't stop
1301 	 * heartbeat.  Otherwise, do it.
1302 	 */
1303 	if (!mnt_err && !ocfs2_mount_local(osb) && osb->uuid_str)
1304 		hangup_needed = 1;
1305 
1306 	if (osb->cconn)
1307 		ocfs2_dlm_shutdown(osb, hangup_needed);
1308 
1309 	debugfs_remove(osb->osb_debug_root);
1310 
1311 	if (hangup_needed)
1312 		ocfs2_cluster_hangup(osb->uuid_str, strlen(osb->uuid_str));
1313 
1314 	atomic_set(&osb->vol_state, VOLUME_DISMOUNTED);
1315 
1316 	if (ocfs2_mount_local(osb))
1317 		snprintf(nodestr, sizeof(nodestr), "local");
1318 	else
1319 		snprintf(nodestr, sizeof(nodestr), "%u", osb->node_num);
1320 
1321 	printk(KERN_INFO "ocfs2: Unmounting device (%s) on (node %s)\n",
1322 	       osb->dev_str, nodestr);
1323 
1324 	ocfs2_delete_osb(osb);
1325 	kfree(osb);
1326 	sb->s_dev = 0;
1327 	sb->s_fs_info = NULL;
1328 }
1329 
1330 static int ocfs2_setup_osb_uuid(struct ocfs2_super *osb, const unsigned char *uuid,
1331 				unsigned uuid_bytes)
1332 {
1333 	int i, ret;
1334 	char *ptr;
1335 
1336 	BUG_ON(uuid_bytes != OCFS2_VOL_UUID_LEN);
1337 
1338 	osb->uuid_str = kzalloc(OCFS2_VOL_UUID_LEN * 2 + 1, GFP_KERNEL);
1339 	if (osb->uuid_str == NULL)
1340 		return -ENOMEM;
1341 
1342 	for (i = 0, ptr = osb->uuid_str; i < OCFS2_VOL_UUID_LEN; i++) {
1343 		/* print with null */
1344 		ret = snprintf(ptr, 3, "%02X", uuid[i]);
1345 		if (ret != 2) /* drop super cleans up */
1346 			return -EINVAL;
1347 		/* then only advance past the last char */
1348 		ptr += 2;
1349 	}
1350 
1351 	return 0;
1352 }
1353 
1354 static int ocfs2_initialize_super(struct super_block *sb,
1355 				  struct buffer_head *bh,
1356 				  int sector_size)
1357 {
1358 	int status;
1359 	int i, cbits, bbits;
1360 	struct ocfs2_dinode *di = (struct ocfs2_dinode *)bh->b_data;
1361 	struct inode *inode = NULL;
1362 	struct ocfs2_journal *journal;
1363 	__le32 uuid_net_key;
1364 	struct ocfs2_super *osb;
1365 
1366 	mlog_entry_void();
1367 
1368 	osb = kzalloc(sizeof(struct ocfs2_super), GFP_KERNEL);
1369 	if (!osb) {
1370 		status = -ENOMEM;
1371 		mlog_errno(status);
1372 		goto bail;
1373 	}
1374 
1375 	sb->s_fs_info = osb;
1376 	sb->s_op = &ocfs2_sops;
1377 	sb->s_export_op = &ocfs2_export_ops;
1378 	sb->s_time_gran = 1;
1379 	sb->s_flags |= MS_NOATIME;
1380 	/* this is needed to support O_LARGEFILE */
1381 	cbits = le32_to_cpu(di->id2.i_super.s_clustersize_bits);
1382 	bbits = le32_to_cpu(di->id2.i_super.s_blocksize_bits);
1383 	sb->s_maxbytes = ocfs2_max_file_offset(bbits, cbits);
1384 
1385 	osb->sb = sb;
1386 	/* Save off for ocfs2_rw_direct */
1387 	osb->s_sectsize_bits = blksize_bits(sector_size);
1388 	BUG_ON(!osb->s_sectsize_bits);
1389 
1390 	spin_lock_init(&osb->dc_task_lock);
1391 	init_waitqueue_head(&osb->dc_event);
1392 	osb->dc_work_sequence = 0;
1393 	osb->dc_wake_sequence = 0;
1394 	INIT_LIST_HEAD(&osb->blocked_lock_list);
1395 	osb->blocked_lock_count = 0;
1396 	spin_lock_init(&osb->osb_lock);
1397 	ocfs2_init_inode_steal_slot(osb);
1398 
1399 	atomic_set(&osb->alloc_stats.moves, 0);
1400 	atomic_set(&osb->alloc_stats.local_data, 0);
1401 	atomic_set(&osb->alloc_stats.bitmap_data, 0);
1402 	atomic_set(&osb->alloc_stats.bg_allocs, 0);
1403 	atomic_set(&osb->alloc_stats.bg_extends, 0);
1404 
1405 	ocfs2_init_node_maps(osb);
1406 
1407 	snprintf(osb->dev_str, sizeof(osb->dev_str), "%u,%u",
1408 		 MAJOR(osb->sb->s_dev), MINOR(osb->sb->s_dev));
1409 
1410 	status = ocfs2_recovery_init(osb);
1411 	if (status) {
1412 		mlog(ML_ERROR, "Unable to initialize recovery state\n");
1413 		mlog_errno(status);
1414 		goto bail;
1415 	}
1416 
1417 	init_waitqueue_head(&osb->checkpoint_event);
1418 	atomic_set(&osb->needs_checkpoint, 0);
1419 
1420 	osb->s_atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM;
1421 
1422 	osb->slot_num = OCFS2_INVALID_SLOT;
1423 
1424 	osb->local_alloc_state = OCFS2_LA_UNUSED;
1425 	osb->local_alloc_bh = NULL;
1426 
1427 	init_waitqueue_head(&osb->osb_mount_event);
1428 
1429 	osb->vol_label = kmalloc(OCFS2_MAX_VOL_LABEL_LEN, GFP_KERNEL);
1430 	if (!osb->vol_label) {
1431 		mlog(ML_ERROR, "unable to alloc vol label\n");
1432 		status = -ENOMEM;
1433 		goto bail;
1434 	}
1435 
1436 	osb->max_slots = le16_to_cpu(di->id2.i_super.s_max_slots);
1437 	if (osb->max_slots > OCFS2_MAX_SLOTS || osb->max_slots == 0) {
1438 		mlog(ML_ERROR, "Invalid number of node slots (%u)\n",
1439 		     osb->max_slots);
1440 		status = -EINVAL;
1441 		goto bail;
1442 	}
1443 	mlog(0, "max_slots for this device: %u\n", osb->max_slots);
1444 
1445 	init_waitqueue_head(&osb->osb_wipe_event);
1446 	osb->osb_orphan_wipes = kcalloc(osb->max_slots,
1447 					sizeof(*osb->osb_orphan_wipes),
1448 					GFP_KERNEL);
1449 	if (!osb->osb_orphan_wipes) {
1450 		status = -ENOMEM;
1451 		mlog_errno(status);
1452 		goto bail;
1453 	}
1454 
1455 	osb->s_feature_compat =
1456 		le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_compat);
1457 	osb->s_feature_ro_compat =
1458 		le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_ro_compat);
1459 	osb->s_feature_incompat =
1460 		le32_to_cpu(OCFS2_RAW_SB(di)->s_feature_incompat);
1461 
1462 	if ((i = OCFS2_HAS_INCOMPAT_FEATURE(osb->sb, ~OCFS2_FEATURE_INCOMPAT_SUPP))) {
1463 		mlog(ML_ERROR, "couldn't mount because of unsupported "
1464 		     "optional features (%x).\n", i);
1465 		status = -EINVAL;
1466 		goto bail;
1467 	}
1468 	if (!(osb->sb->s_flags & MS_RDONLY) &&
1469 	    (i = OCFS2_HAS_RO_COMPAT_FEATURE(osb->sb, ~OCFS2_FEATURE_RO_COMPAT_SUPP))) {
1470 		mlog(ML_ERROR, "couldn't mount RDWR because of "
1471 		     "unsupported optional features (%x).\n", i);
1472 		status = -EINVAL;
1473 		goto bail;
1474 	}
1475 
1476 	if (ocfs2_userspace_stack(osb)) {
1477 		memcpy(osb->osb_cluster_stack,
1478 		       OCFS2_RAW_SB(di)->s_cluster_info.ci_stack,
1479 		       OCFS2_STACK_LABEL_LEN);
1480 		osb->osb_cluster_stack[OCFS2_STACK_LABEL_LEN] = '\0';
1481 		if (strlen(osb->osb_cluster_stack) != OCFS2_STACK_LABEL_LEN) {
1482 			mlog(ML_ERROR,
1483 			     "couldn't mount because of an invalid "
1484 			     "cluster stack label (%s) \n",
1485 			     osb->osb_cluster_stack);
1486 			status = -EINVAL;
1487 			goto bail;
1488 		}
1489 	} else {
1490 		/* The empty string is identical with classic tools that
1491 		 * don't know about s_cluster_info. */
1492 		osb->osb_cluster_stack[0] = '\0';
1493 	}
1494 
1495 	get_random_bytes(&osb->s_next_generation, sizeof(u32));
1496 
1497 	/* FIXME
1498 	 * This should be done in ocfs2_journal_init(), but unknown
1499 	 * ordering issues will cause the filesystem to crash.
1500 	 * If anyone wants to figure out what part of the code
1501 	 * refers to osb->journal before ocfs2_journal_init() is run,
1502 	 * be my guest.
1503 	 */
1504 	/* initialize our journal structure */
1505 
1506 	journal = kzalloc(sizeof(struct ocfs2_journal), GFP_KERNEL);
1507 	if (!journal) {
1508 		mlog(ML_ERROR, "unable to alloc journal\n");
1509 		status = -ENOMEM;
1510 		goto bail;
1511 	}
1512 	osb->journal = journal;
1513 	journal->j_osb = osb;
1514 
1515 	atomic_set(&journal->j_num_trans, 0);
1516 	init_rwsem(&journal->j_trans_barrier);
1517 	init_waitqueue_head(&journal->j_checkpointed);
1518 	spin_lock_init(&journal->j_lock);
1519 	journal->j_trans_id = (unsigned long) 1;
1520 	INIT_LIST_HEAD(&journal->j_la_cleanups);
1521 	INIT_WORK(&journal->j_recovery_work, ocfs2_complete_recovery);
1522 	journal->j_state = OCFS2_JOURNAL_FREE;
1523 
1524 	/* get some pseudo constants for clustersize bits */
1525 	osb->s_clustersize_bits =
1526 		le32_to_cpu(di->id2.i_super.s_clustersize_bits);
1527 	osb->s_clustersize = 1 << osb->s_clustersize_bits;
1528 	mlog(0, "clusterbits=%d\n", osb->s_clustersize_bits);
1529 
1530 	if (osb->s_clustersize < OCFS2_MIN_CLUSTERSIZE ||
1531 	    osb->s_clustersize > OCFS2_MAX_CLUSTERSIZE) {
1532 		mlog(ML_ERROR, "Volume has invalid cluster size (%d)\n",
1533 		     osb->s_clustersize);
1534 		status = -EINVAL;
1535 		goto bail;
1536 	}
1537 
1538 	if (ocfs2_clusters_to_blocks(osb->sb, le32_to_cpu(di->i_clusters) - 1)
1539 	    > (u32)~0UL) {
1540 		mlog(ML_ERROR, "Volume might try to write to blocks beyond "
1541 		     "what jbd can address in 32 bits.\n");
1542 		status = -EINVAL;
1543 		goto bail;
1544 	}
1545 
1546 	if (ocfs2_setup_osb_uuid(osb, di->id2.i_super.s_uuid,
1547 				 sizeof(di->id2.i_super.s_uuid))) {
1548 		mlog(ML_ERROR, "Out of memory trying to setup our uuid.\n");
1549 		status = -ENOMEM;
1550 		goto bail;
1551 	}
1552 
1553 	memcpy(&uuid_net_key, di->id2.i_super.s_uuid, sizeof(uuid_net_key));
1554 
1555 	strncpy(osb->vol_label, di->id2.i_super.s_label, 63);
1556 	osb->vol_label[63] = '\0';
1557 	osb->root_blkno = le64_to_cpu(di->id2.i_super.s_root_blkno);
1558 	osb->system_dir_blkno = le64_to_cpu(di->id2.i_super.s_system_dir_blkno);
1559 	osb->first_cluster_group_blkno =
1560 		le64_to_cpu(di->id2.i_super.s_first_cluster_group);
1561 	osb->fs_generation = le32_to_cpu(di->i_fs_generation);
1562 	mlog(0, "vol_label: %s\n", osb->vol_label);
1563 	mlog(0, "uuid: %s\n", osb->uuid_str);
1564 	mlog(0, "root_blkno=%llu, system_dir_blkno=%llu\n",
1565 	     (unsigned long long)osb->root_blkno,
1566 	     (unsigned long long)osb->system_dir_blkno);
1567 
1568 	osb->osb_dlm_debug = ocfs2_new_dlm_debug();
1569 	if (!osb->osb_dlm_debug) {
1570 		status = -ENOMEM;
1571 		mlog_errno(status);
1572 		goto bail;
1573 	}
1574 
1575 	atomic_set(&osb->vol_state, VOLUME_INIT);
1576 
1577 	/* load root, system_dir, and all global system inodes */
1578 	status = ocfs2_init_global_system_inodes(osb);
1579 	if (status < 0) {
1580 		mlog_errno(status);
1581 		goto bail;
1582 	}
1583 
1584 	/*
1585 	 * global bitmap
1586 	 */
1587 	inode = ocfs2_get_system_file_inode(osb, GLOBAL_BITMAP_SYSTEM_INODE,
1588 					    OCFS2_INVALID_SLOT);
1589 	if (!inode) {
1590 		status = -EINVAL;
1591 		mlog_errno(status);
1592 		goto bail;
1593 	}
1594 
1595 	osb->bitmap_blkno = OCFS2_I(inode)->ip_blkno;
1596 	iput(inode);
1597 
1598 	osb->bitmap_cpg = ocfs2_group_bitmap_size(sb) * 8;
1599 
1600 	status = ocfs2_init_slot_info(osb);
1601 	if (status < 0) {
1602 		mlog_errno(status);
1603 		goto bail;
1604 	}
1605 
1606 bail:
1607 	mlog_exit(status);
1608 	return status;
1609 }
1610 
1611 /*
1612  * will return: -EAGAIN if it is ok to keep searching for superblocks
1613  *              -EINVAL if there is a bad superblock
1614  *              0 on success
1615  */
1616 static int ocfs2_verify_volume(struct ocfs2_dinode *di,
1617 			       struct buffer_head *bh,
1618 			       u32 blksz)
1619 {
1620 	int status = -EAGAIN;
1621 
1622 	mlog_entry_void();
1623 
1624 	if (memcmp(di->i_signature, OCFS2_SUPER_BLOCK_SIGNATURE,
1625 		   strlen(OCFS2_SUPER_BLOCK_SIGNATURE)) == 0) {
1626 		status = -EINVAL;
1627 		if ((1 << le32_to_cpu(di->id2.i_super.s_blocksize_bits)) != blksz) {
1628 			mlog(ML_ERROR, "found superblock with incorrect block "
1629 			     "size: found %u, should be %u\n",
1630 			     1 << le32_to_cpu(di->id2.i_super.s_blocksize_bits),
1631 			       blksz);
1632 		} else if (le16_to_cpu(di->id2.i_super.s_major_rev_level) !=
1633 			   OCFS2_MAJOR_REV_LEVEL ||
1634 			   le16_to_cpu(di->id2.i_super.s_minor_rev_level) !=
1635 			   OCFS2_MINOR_REV_LEVEL) {
1636 			mlog(ML_ERROR, "found superblock with bad version: "
1637 			     "found %u.%u, should be %u.%u\n",
1638 			     le16_to_cpu(di->id2.i_super.s_major_rev_level),
1639 			     le16_to_cpu(di->id2.i_super.s_minor_rev_level),
1640 			     OCFS2_MAJOR_REV_LEVEL,
1641 			     OCFS2_MINOR_REV_LEVEL);
1642 		} else if (bh->b_blocknr != le64_to_cpu(di->i_blkno)) {
1643 			mlog(ML_ERROR, "bad block number on superblock: "
1644 			     "found %llu, should be %llu\n",
1645 			     (unsigned long long)le64_to_cpu(di->i_blkno),
1646 			     (unsigned long long)bh->b_blocknr);
1647 		} else if (le32_to_cpu(di->id2.i_super.s_clustersize_bits) < 12 ||
1648 			    le32_to_cpu(di->id2.i_super.s_clustersize_bits) > 20) {
1649 			mlog(ML_ERROR, "bad cluster size found: %u\n",
1650 			     1 << le32_to_cpu(di->id2.i_super.s_clustersize_bits));
1651 		} else if (!le64_to_cpu(di->id2.i_super.s_root_blkno)) {
1652 			mlog(ML_ERROR, "bad root_blkno: 0\n");
1653 		} else if (!le64_to_cpu(di->id2.i_super.s_system_dir_blkno)) {
1654 			mlog(ML_ERROR, "bad system_dir_blkno: 0\n");
1655 		} else if (le16_to_cpu(di->id2.i_super.s_max_slots) > OCFS2_MAX_SLOTS) {
1656 			mlog(ML_ERROR,
1657 			     "Superblock slots found greater than file system "
1658 			     "maximum: found %u, max %u\n",
1659 			     le16_to_cpu(di->id2.i_super.s_max_slots),
1660 			     OCFS2_MAX_SLOTS);
1661 		} else {
1662 			/* found it! */
1663 			status = 0;
1664 		}
1665 	}
1666 
1667 	mlog_exit(status);
1668 	return status;
1669 }
1670 
1671 static int ocfs2_check_volume(struct ocfs2_super *osb)
1672 {
1673 	int status;
1674 	int dirty;
1675 	int local;
1676 	struct ocfs2_dinode *local_alloc = NULL; /* only used if we
1677 						  * recover
1678 						  * ourselves. */
1679 
1680 	mlog_entry_void();
1681 
1682 	/* Init our journal object. */
1683 	status = ocfs2_journal_init(osb->journal, &dirty);
1684 	if (status < 0) {
1685 		mlog(ML_ERROR, "Could not initialize journal!\n");
1686 		goto finally;
1687 	}
1688 
1689 	/* If the journal was unmounted cleanly then we don't want to
1690 	 * recover anything. Otherwise, journal_load will do that
1691 	 * dirty work for us :) */
1692 	if (!dirty) {
1693 		status = ocfs2_journal_wipe(osb->journal, 0);
1694 		if (status < 0) {
1695 			mlog_errno(status);
1696 			goto finally;
1697 		}
1698 	} else {
1699 		mlog(ML_NOTICE, "File system was not unmounted cleanly, "
1700 		     "recovering volume.\n");
1701 	}
1702 
1703 	local = ocfs2_mount_local(osb);
1704 
1705 	/* will play back anything left in the journal. */
1706 	status = ocfs2_journal_load(osb->journal, local);
1707 	if (status < 0) {
1708 		mlog(ML_ERROR, "ocfs2 journal load failed! %d\n", status);
1709 		goto finally;
1710 	}
1711 
1712 	if (dirty) {
1713 		/* recover my local alloc if we didn't unmount cleanly. */
1714 		status = ocfs2_begin_local_alloc_recovery(osb,
1715 							  osb->slot_num,
1716 							  &local_alloc);
1717 		if (status < 0) {
1718 			mlog_errno(status);
1719 			goto finally;
1720 		}
1721 		/* we complete the recovery process after we've marked
1722 		 * ourselves as mounted. */
1723 	}
1724 
1725 	mlog(0, "Journal loaded.\n");
1726 
1727 	status = ocfs2_load_local_alloc(osb);
1728 	if (status < 0) {
1729 		mlog_errno(status);
1730 		goto finally;
1731 	}
1732 
1733 	if (dirty) {
1734 		/* Recovery will be completed after we've mounted the
1735 		 * rest of the volume. */
1736 		osb->dirty = 1;
1737 		osb->local_alloc_copy = local_alloc;
1738 		local_alloc = NULL;
1739 	}
1740 
1741 	/* go through each journal, trylock it and if you get the
1742 	 * lock, and it's marked as dirty, set the bit in the recover
1743 	 * map and launch a recovery thread for it. */
1744 	status = ocfs2_mark_dead_nodes(osb);
1745 	if (status < 0)
1746 		mlog_errno(status);
1747 
1748 finally:
1749 	if (local_alloc)
1750 		kfree(local_alloc);
1751 
1752 	mlog_exit(status);
1753 	return status;
1754 }
1755 
1756 /*
1757  * The routine gets called from dismount or close whenever a dismount on
1758  * volume is requested and the osb open count becomes 1.
1759  * It will remove the osb from the global list and also free up all the
1760  * initialized resources and fileobject.
1761  */
1762 static void ocfs2_delete_osb(struct ocfs2_super *osb)
1763 {
1764 	mlog_entry_void();
1765 
1766 	/* This function assumes that the caller has the main osb resource */
1767 
1768 	ocfs2_free_slot_info(osb);
1769 
1770 	kfree(osb->osb_orphan_wipes);
1771 	/* FIXME
1772 	 * This belongs in journal shutdown, but because we have to
1773 	 * allocate osb->journal at the start of ocfs2_initalize_osb(),
1774 	 * we free it here.
1775 	 */
1776 	kfree(osb->journal);
1777 	if (osb->local_alloc_copy)
1778 		kfree(osb->local_alloc_copy);
1779 	kfree(osb->uuid_str);
1780 	ocfs2_put_dlm_debug(osb->osb_dlm_debug);
1781 	memset(osb, 0, sizeof(struct ocfs2_super));
1782 
1783 	mlog_exit_void();
1784 }
1785 
1786 /* Put OCFS2 into a readonly state, or (if the user specifies it),
1787  * panic(). We do not support continue-on-error operation. */
1788 static void ocfs2_handle_error(struct super_block *sb)
1789 {
1790 	struct ocfs2_super *osb = OCFS2_SB(sb);
1791 
1792 	if (osb->s_mount_opt & OCFS2_MOUNT_ERRORS_PANIC)
1793 		panic("OCFS2: (device %s): panic forced after error\n",
1794 		      sb->s_id);
1795 
1796 	ocfs2_set_osb_flag(osb, OCFS2_OSB_ERROR_FS);
1797 
1798 	if (sb->s_flags & MS_RDONLY &&
1799 	    (ocfs2_is_soft_readonly(osb) ||
1800 	     ocfs2_is_hard_readonly(osb)))
1801 		return;
1802 
1803 	printk(KERN_CRIT "File system is now read-only due to the potential "
1804 	       "of on-disk corruption. Please run fsck.ocfs2 once the file "
1805 	       "system is unmounted.\n");
1806 	sb->s_flags |= MS_RDONLY;
1807 	ocfs2_set_ro_flag(osb, 0);
1808 }
1809 
1810 static char error_buf[1024];
1811 
1812 void __ocfs2_error(struct super_block *sb,
1813 		   const char *function,
1814 		   const char *fmt, ...)
1815 {
1816 	va_list args;
1817 
1818 	va_start(args, fmt);
1819 	vsnprintf(error_buf, sizeof(error_buf), fmt, args);
1820 	va_end(args);
1821 
1822 	/* Not using mlog here because we want to show the actual
1823 	 * function the error came from. */
1824 	printk(KERN_CRIT "OCFS2: ERROR (device %s): %s: %s\n",
1825 	       sb->s_id, function, error_buf);
1826 
1827 	ocfs2_handle_error(sb);
1828 }
1829 
1830 /* Handle critical errors. This is intentionally more drastic than
1831  * ocfs2_handle_error, so we only use for things like journal errors,
1832  * etc. */
1833 void __ocfs2_abort(struct super_block* sb,
1834 		   const char *function,
1835 		   const char *fmt, ...)
1836 {
1837 	va_list args;
1838 
1839 	va_start(args, fmt);
1840 	vsnprintf(error_buf, sizeof(error_buf), fmt, args);
1841 	va_end(args);
1842 
1843 	printk(KERN_CRIT "OCFS2: abort (device %s): %s: %s\n",
1844 	       sb->s_id, function, error_buf);
1845 
1846 	/* We don't have the cluster support yet to go straight to
1847 	 * hard readonly in here. Until then, we want to keep
1848 	 * ocfs2_abort() so that we can at least mark critical
1849 	 * errors.
1850 	 *
1851 	 * TODO: This should abort the journal and alert other nodes
1852 	 * that our slot needs recovery. */
1853 
1854 	/* Force a panic(). This stinks, but it's better than letting
1855 	 * things continue without having a proper hard readonly
1856 	 * here. */
1857 	OCFS2_SB(sb)->s_mount_opt |= OCFS2_MOUNT_ERRORS_PANIC;
1858 	ocfs2_handle_error(sb);
1859 }
1860 
1861 module_init(ocfs2_init);
1862 module_exit(ocfs2_exit);
1863