5899ac33451c46d01c193bf59641cea2fcb26e9a
[linux-2.6.git] / fs / gfs2 / ops_fstype.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License v.2.
8  */
9
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/vmalloc.h>
16 #include <linux/blkdev.h>
17 #include <linux/kthread.h>
18 #include <linux/gfs2_ondisk.h>
19
20 #include "gfs2.h"
21 #include "lm_interface.h"
22 #include "incore.h"
23 #include "daemon.h"
24 #include "glock.h"
25 #include "glops.h"
26 #include "inode.h"
27 #include "lm.h"
28 #include "mount.h"
29 #include "ops_export.h"
30 #include "ops_fstype.h"
31 #include "ops_super.h"
32 #include "recovery.h"
33 #include "rgrp.h"
34 #include "super.h"
35 #include "unlinked.h"
36 #include "sys.h"
37 #include "util.h"
38
39 #define DO 0
40 #define UNDO 1
41
42 extern struct dentry_operations gfs2_dops;
43
44 static struct gfs2_sbd *init_sbd(struct super_block *sb)
45 {
46         struct gfs2_sbd *sdp;
47         unsigned int x;
48
49         sdp = vmalloc(sizeof(struct gfs2_sbd));
50         if (!sdp)
51                 return NULL;
52
53         memset(sdp, 0, sizeof(struct gfs2_sbd));
54
55         sb->s_fs_info = sdp;
56         sdp->sd_vfs = sb;
57
58         gfs2_tune_init(&sdp->sd_tune);
59
60         for (x = 0; x < GFS2_GL_HASH_SIZE; x++) {
61                 sdp->sd_gl_hash[x].hb_lock = RW_LOCK_UNLOCKED;
62                 INIT_LIST_HEAD(&sdp->sd_gl_hash[x].hb_list);
63         }
64         INIT_LIST_HEAD(&sdp->sd_reclaim_list);
65         spin_lock_init(&sdp->sd_reclaim_lock);
66         init_waitqueue_head(&sdp->sd_reclaim_wq);
67         mutex_init(&sdp->sd_invalidate_inodes_mutex);
68
69         mutex_init(&sdp->sd_inum_mutex);
70         spin_lock_init(&sdp->sd_statfs_spin);
71         mutex_init(&sdp->sd_statfs_mutex);
72
73         spin_lock_init(&sdp->sd_rindex_spin);
74         mutex_init(&sdp->sd_rindex_mutex);
75         INIT_LIST_HEAD(&sdp->sd_rindex_list);
76         INIT_LIST_HEAD(&sdp->sd_rindex_mru_list);
77         INIT_LIST_HEAD(&sdp->sd_rindex_recent_list);
78
79         INIT_LIST_HEAD(&sdp->sd_jindex_list);
80         spin_lock_init(&sdp->sd_jindex_spin);
81         mutex_init(&sdp->sd_jindex_mutex);
82
83         INIT_LIST_HEAD(&sdp->sd_unlinked_list);
84         spin_lock_init(&sdp->sd_unlinked_spin);
85         mutex_init(&sdp->sd_unlinked_mutex);
86
87         INIT_LIST_HEAD(&sdp->sd_quota_list);
88         spin_lock_init(&sdp->sd_quota_spin);
89         mutex_init(&sdp->sd_quota_mutex);
90
91         spin_lock_init(&sdp->sd_log_lock);
92
93         INIT_LIST_HEAD(&sdp->sd_log_le_gl);
94         INIT_LIST_HEAD(&sdp->sd_log_le_buf);
95         INIT_LIST_HEAD(&sdp->sd_log_le_revoke);
96         INIT_LIST_HEAD(&sdp->sd_log_le_rg);
97         INIT_LIST_HEAD(&sdp->sd_log_le_databuf);
98
99         mutex_init(&sdp->sd_log_reserve_mutex);
100         INIT_LIST_HEAD(&sdp->sd_ail1_list);
101         INIT_LIST_HEAD(&sdp->sd_ail2_list);
102
103         init_rwsem(&sdp->sd_log_flush_lock);
104         INIT_LIST_HEAD(&sdp->sd_log_flush_list);
105
106         INIT_LIST_HEAD(&sdp->sd_revoke_list);
107
108         mutex_init(&sdp->sd_freeze_lock);
109
110         return sdp;
111 }
112
113 static void init_vfs(struct super_block *sb, unsigned noatime)
114 {
115         struct gfs2_sbd *sdp = sb->s_fs_info;
116
117         sb->s_magic = GFS2_MAGIC;
118         sb->s_op = &gfs2_super_ops;
119         sb->s_export_op = &gfs2_export_ops;
120         sb->s_maxbytes = MAX_LFS_FILESIZE;
121
122         if (sb->s_flags & (MS_NOATIME | MS_NODIRATIME))
123                 set_bit(noatime, &sdp->sd_flags);
124
125         /* Don't let the VFS update atimes.  GFS2 handles this itself. */
126         sb->s_flags |= MS_NOATIME | MS_NODIRATIME;
127 }
128
129 static int init_names(struct gfs2_sbd *sdp, int silent)
130 {
131         struct gfs2_sb *sb = NULL;
132         char *proto, *table;
133         int error = 0;
134
135         proto = sdp->sd_args.ar_lockproto;
136         table = sdp->sd_args.ar_locktable;
137
138         /*  Try to autodetect  */
139
140         if (!proto[0] || !table[0]) {
141                 struct buffer_head *bh;
142                 bh = sb_getblk(sdp->sd_vfs,
143                                GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift);
144                 lock_buffer(bh);
145                 clear_buffer_uptodate(bh);
146                 clear_buffer_dirty(bh);
147                 unlock_buffer(bh);
148                 ll_rw_block(READ, 1, &bh);
149                 wait_on_buffer(bh);
150
151                 if (!buffer_uptodate(bh)) {
152                         brelse(bh);
153                         return -EIO;
154                 }
155
156                 sb = kmalloc(sizeof(struct gfs2_sb), GFP_KERNEL);
157                 if (!sb) {
158                         brelse(bh);
159                         return -ENOMEM;
160                 }
161                 gfs2_sb_in(sb, bh->b_data); 
162                 brelse(bh);
163
164                 error = gfs2_check_sb(sdp, sb, silent);
165                 if (error)
166                         goto out;
167
168                 if (!proto[0])
169                         proto = sb->sb_lockproto;
170                 if (!table[0])
171                         table = sb->sb_locktable;
172         }
173
174         if (!table[0])
175                 table = sdp->sd_vfs->s_id;
176
177         snprintf(sdp->sd_proto_name, GFS2_FSNAME_LEN, "%s", proto);
178         snprintf(sdp->sd_table_name, GFS2_FSNAME_LEN, "%s", table);
179
180  out:
181         kfree(sb);
182
183         return error;
184 }
185
186 static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
187                         int undo)
188 {
189         struct task_struct *p;
190         int error = 0;
191
192         if (undo)
193                 goto fail_trans;
194
195         p = kthread_run(gfs2_scand, sdp, "gfs2_scand");
196         error = IS_ERR(p);
197         if (error) {
198                 fs_err(sdp, "can't start scand thread: %d\n", error);
199                 return error;
200         }
201         sdp->sd_scand_process = p;
202
203         for (sdp->sd_glockd_num = 0;
204              sdp->sd_glockd_num < sdp->sd_args.ar_num_glockd;
205              sdp->sd_glockd_num++) {
206                 p = kthread_run(gfs2_glockd, sdp, "gfs2_glockd");
207                 error = IS_ERR(p);
208                 if (error) {
209                         fs_err(sdp, "can't start glockd thread: %d\n", error);
210                         goto fail;
211                 }
212                 sdp->sd_glockd_process[sdp->sd_glockd_num] = p;
213         }
214
215         error = gfs2_glock_nq_num(sdp,
216                                   GFS2_MOUNT_LOCK, &gfs2_nondisk_glops,
217                                   LM_ST_EXCLUSIVE, LM_FLAG_NOEXP | GL_NOCACHE,
218                                   mount_gh);
219         if (error) {
220                 fs_err(sdp, "can't acquire mount glock: %d\n", error);
221                 goto fail;
222         }
223
224         error = gfs2_glock_nq_num(sdp,
225                                   GFS2_LIVE_LOCK, &gfs2_nondisk_glops,
226                                   LM_ST_SHARED,
227                                   LM_FLAG_NOEXP | GL_EXACT,
228                                   &sdp->sd_live_gh);
229         if (error) {
230                 fs_err(sdp, "can't acquire live glock: %d\n", error);
231                 goto fail_mount;
232         }
233
234         error = gfs2_glock_get(sdp, GFS2_RENAME_LOCK, &gfs2_nondisk_glops,
235                                CREATE, &sdp->sd_rename_gl);
236         if (error) {
237                 fs_err(sdp, "can't create rename glock: %d\n", error);
238                 goto fail_live;
239         }
240
241         error = gfs2_glock_get(sdp, GFS2_TRANS_LOCK, &gfs2_trans_glops,
242                                CREATE, &sdp->sd_trans_gl);
243         if (error) {
244                 fs_err(sdp, "can't create transaction glock: %d\n", error);
245                 goto fail_rename;
246         }
247         set_bit(GLF_STICKY, &sdp->sd_trans_gl->gl_flags);
248
249         return 0;
250
251  fail_trans:
252         gfs2_glock_put(sdp->sd_trans_gl);
253
254  fail_rename:
255         gfs2_glock_put(sdp->sd_rename_gl);
256
257  fail_live:
258         gfs2_glock_dq_uninit(&sdp->sd_live_gh);
259
260  fail_mount:
261         gfs2_glock_dq_uninit(mount_gh);
262
263  fail:
264         while (sdp->sd_glockd_num--)
265                 kthread_stop(sdp->sd_glockd_process[sdp->sd_glockd_num]);
266
267         kthread_stop(sdp->sd_scand_process);
268
269         return error;
270 }
271
272 static struct inode *gfs2_lookup_root(struct gfs2_sbd *sdp,
273                                       const struct gfs2_inum *inum)
274 {
275         int error;
276         struct gfs2_glock *gl;
277         struct gfs2_inode *ip;
278         struct inode *inode;
279
280         error = gfs2_glock_get(sdp, inum->no_addr, &gfs2_inode_glops,
281                                CREATE, &gl);
282         if (!error) {
283                 error = gfs2_inode_get(gl, inum, CREATE, &ip);
284                 if (!error) {
285                         gfs2_inode_min_init(ip, DT_DIR);
286                         inode = gfs2_ip2v(ip);
287                         gfs2_inode_put(ip);
288                         gfs2_glock_put(gl);
289                         return inode;
290                 }
291                 gfs2_glock_put(gl);
292         }
293         return ERR_PTR(error);
294 }
295
296 static int init_sb(struct gfs2_sbd *sdp, int silent, int undo)
297 {
298         struct super_block *sb = sdp->sd_vfs;
299         struct gfs2_holder sb_gh;
300         struct gfs2_inum *inum;
301         struct inode *inode;
302         int error = 0;
303
304         if (undo) {
305                 return 0;
306         }
307         
308         error = gfs2_glock_nq_num(sdp,
309                                  GFS2_SB_LOCK, &gfs2_meta_glops,
310                                  LM_ST_SHARED, 0, &sb_gh);
311         if (error) {
312                 fs_err(sdp, "can't acquire superblock glock: %d\n", error);
313                 return error;
314         }
315
316         error = gfs2_read_sb(sdp, sb_gh.gh_gl, silent);
317         if (error) {
318                 fs_err(sdp, "can't read superblock: %d\n", error);
319                 goto out;
320         }
321
322         /* Set up the buffer cache and SB for real */
323         if (sdp->sd_sb.sb_bsize < bdev_hardsect_size(sb->s_bdev)) {
324                 error = -EINVAL;
325                 fs_err(sdp, "FS block size (%u) is too small for device "
326                        "block size (%u)\n",
327                        sdp->sd_sb.sb_bsize, bdev_hardsect_size(sb->s_bdev));
328                 goto out;
329         }
330         if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
331                 error = -EINVAL;
332                 fs_err(sdp, "FS block size (%u) is too big for machine "
333                        "page size (%u)\n",
334                        sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE);
335                 goto out;
336         }
337
338         /* Get rid of buffers from the original block size */
339         sb_gh.gh_gl->gl_ops->go_inval(sb_gh.gh_gl, DIO_METADATA | DIO_DATA);
340         sb_gh.gh_gl->gl_aspace->i_blkbits = sdp->sd_sb.sb_bsize_shift;
341
342         sb_set_blocksize(sb, sdp->sd_sb.sb_bsize);
343
344         /* Get the root inode */
345         inum = &sdp->sd_sb.sb_root_dir;
346         if (sb->s_type == &gfs2meta_fs_type)
347                 inum = &sdp->sd_sb.sb_master_dir;
348         inode = gfs2_lookup_root(sdp, inum);
349         if (IS_ERR(inode)) {
350                 error = PTR_ERR(inode);
351                 fs_err(sdp, "can't read in root inode: %d\n", error);
352                 goto out;
353         }
354
355         sb->s_root = d_alloc_root(inode);
356         if (!sb->s_root) {
357                 fs_err(sdp, "can't get root dentry\n");
358                 error = -ENOMEM;
359                 iput(inode);
360         }
361         sb->s_root->d_op = &gfs2_dops;
362 out:
363         gfs2_glock_dq_uninit(&sb_gh);
364         return error;
365 }
366
367 static int init_journal(struct gfs2_sbd *sdp, int undo)
368 {
369         struct gfs2_holder ji_gh;
370         struct task_struct *p;
371         struct gfs2_inode *ip;
372         int jindex = 1;
373         int error = 0;
374
375         if (undo) {
376                 jindex = 0;
377                 goto fail_recoverd;
378         }
379
380         sdp->sd_jindex = gfs2_lookup_simple(sdp->sd_master_dir, "jindex");
381         if (IS_ERR(sdp->sd_jindex)) {
382                 fs_err(sdp, "can't lookup journal index: %d\n", error);
383                 return PTR_ERR(sdp->sd_jindex);
384         }
385         ip = sdp->sd_jindex->u.generic_ip;
386         set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
387
388         /* Load in the journal index special file */
389
390         error = gfs2_jindex_hold(sdp, &ji_gh);
391         if (error) {
392                 fs_err(sdp, "can't read journal index: %d\n", error);
393                 goto fail;
394         }
395
396         error = -EINVAL;
397         if (!gfs2_jindex_size(sdp)) {
398                 fs_err(sdp, "no journals!\n");
399                 goto fail_jindex;               
400         }
401
402         if (sdp->sd_args.ar_spectator) {
403                 sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0);
404                 sdp->sd_log_blks_free = sdp->sd_jdesc->jd_blocks;
405         } else {
406                 if (sdp->sd_lockstruct.ls_jid >= gfs2_jindex_size(sdp)) {
407                         fs_err(sdp, "can't mount journal #%u\n",
408                                sdp->sd_lockstruct.ls_jid);
409                         fs_err(sdp, "there are only %u journals (0 - %u)\n",
410                                gfs2_jindex_size(sdp),
411                                gfs2_jindex_size(sdp) - 1);
412                         goto fail_jindex;
413                 }
414                 sdp->sd_jdesc = gfs2_jdesc_find(sdp, sdp->sd_lockstruct.ls_jid);
415
416                 error = gfs2_glock_nq_num(sdp,
417                                           sdp->sd_lockstruct.ls_jid,
418                                           &gfs2_journal_glops,
419                                           LM_ST_EXCLUSIVE, LM_FLAG_NOEXP,
420                                           &sdp->sd_journal_gh);
421                 if (error) {
422                         fs_err(sdp, "can't acquire journal glock: %d\n", error);
423                         goto fail_jindex;
424                 }
425
426                 ip = sdp->sd_jdesc->jd_inode->u.generic_ip;
427                 error = gfs2_glock_nq_init(ip->i_gl,
428                                            LM_ST_SHARED,
429                                            LM_FLAG_NOEXP | GL_EXACT,
430                                            &sdp->sd_jinode_gh);
431                 if (error) {
432                         fs_err(sdp, "can't acquire journal inode glock: %d\n",
433                                error);
434                         goto fail_journal_gh;
435                 }
436
437                 error = gfs2_jdesc_check(sdp->sd_jdesc);
438                 if (error) {
439                         fs_err(sdp, "my journal (%u) is bad: %d\n",
440                                sdp->sd_jdesc->jd_jid, error);
441                         goto fail_jinode_gh;
442                 }
443                 sdp->sd_log_blks_free = sdp->sd_jdesc->jd_blocks;
444         }
445
446         if (sdp->sd_lockstruct.ls_first) {
447                 unsigned int x;
448                 for (x = 0; x < sdp->sd_journals; x++) {
449                         error = gfs2_recover_journal(gfs2_jdesc_find(sdp, x));
450                         if (error) {
451                                 fs_err(sdp, "error recovering journal %u: %d\n",
452                                        x, error);
453                                 goto fail_jinode_gh;
454                         }
455                 }
456
457                 gfs2_lm_others_may_mount(sdp);
458         } else if (!sdp->sd_args.ar_spectator) {
459                 error = gfs2_recover_journal(sdp->sd_jdesc);
460                 if (error) {
461                         fs_err(sdp, "error recovering my journal: %d\n", error);
462                         goto fail_jinode_gh;
463                 }
464         }
465
466         set_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags);
467         gfs2_glock_dq_uninit(&ji_gh);
468         jindex = 0;
469
470         p = kthread_run(gfs2_recoverd, sdp, "gfs2_recoverd");
471         error = IS_ERR(p);
472         if (error) {
473                 fs_err(sdp, "can't start recoverd thread: %d\n", error);
474                 goto fail_jinode_gh;
475         }
476         sdp->sd_recoverd_process = p;
477
478         return 0;
479
480  fail_recoverd:
481         kthread_stop(sdp->sd_recoverd_process);
482
483  fail_jinode_gh:
484         if (!sdp->sd_args.ar_spectator)
485                 gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
486
487  fail_journal_gh:
488         if (!sdp->sd_args.ar_spectator)
489                 gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
490
491  fail_jindex:
492         gfs2_jindex_free(sdp);
493         if (jindex)
494                 gfs2_glock_dq_uninit(&ji_gh);
495
496  fail:
497         iput(sdp->sd_jindex);
498
499         return error;
500 }
501
502
503 static int init_inodes(struct gfs2_sbd *sdp, int undo)
504 {
505         int error = 0;
506         struct gfs2_inode *ip;
507         struct inode *inode;
508
509         if (undo)
510                 goto fail_qinode;
511
512         inode = gfs2_lookup_root(sdp, &sdp->sd_sb.sb_master_dir);
513         if (IS_ERR(inode)) {
514                 error = PTR_ERR(inode);
515                 fs_err(sdp, "can't read in master directory: %d\n", error);
516                 goto fail;
517         }
518         sdp->sd_master_dir = inode;
519
520         error = init_journal(sdp, undo);
521         if (error)
522                 goto fail_master;
523
524         /* Read in the master inode number inode */
525         sdp->sd_inum_inode = gfs2_lookup_simple(sdp->sd_master_dir, "inum");
526         if (IS_ERR(sdp->sd_inum_inode)) {
527                 error = PTR_ERR(sdp->sd_inum_inode);
528                 fs_err(sdp, "can't read in inum inode: %d\n", error);
529                 goto fail_journal;
530         }
531
532
533         /* Read in the master statfs inode */
534         sdp->sd_statfs_inode = gfs2_lookup_simple(sdp->sd_master_dir, "statfs");
535         if (IS_ERR(sdp->sd_statfs_inode)) {
536                 error = PTR_ERR(sdp->sd_statfs_inode);
537                 fs_err(sdp, "can't read in statfs inode: %d\n", error);
538                 goto fail_inum;
539         }
540
541         /* Read in the resource index inode */
542         sdp->sd_rindex = gfs2_lookup_simple(sdp->sd_master_dir, "rindex");
543         if (IS_ERR(sdp->sd_rindex)) {
544                 error = PTR_ERR(sdp->sd_rindex);
545                 fs_err(sdp, "can't get resource index inode: %d\n", error);
546                 goto fail_statfs;
547         }
548         ip = sdp->sd_rindex->u.generic_ip;
549         set_bit(GLF_STICKY, &ip->i_gl->gl_flags);
550         sdp->sd_rindex_vn = ip->i_gl->gl_vn - 1;
551
552         /* Read in the quota inode */
553         sdp->sd_quota_inode = gfs2_lookup_simple(sdp->sd_master_dir, "quota");
554         if (IS_ERR(sdp->sd_quota_inode)) {
555                 error = PTR_ERR(sdp->sd_quota_inode);
556                 fs_err(sdp, "can't get quota file inode: %d\n", error);
557                 goto fail_rindex;
558         }
559         return 0;
560
561 fail_qinode:
562         iput(sdp->sd_quota_inode);
563
564 fail_rindex:
565         gfs2_clear_rgrpd(sdp);
566         iput(sdp->sd_rindex);
567
568 fail_statfs:
569         iput(sdp->sd_statfs_inode);
570
571 fail_inum:
572         iput(sdp->sd_inum_inode);
573 fail_journal:
574         init_journal(sdp, UNDO);
575 fail_master:
576         iput(sdp->sd_master_dir);
577 fail:
578         return error;
579 }
580
581 static int init_per_node(struct gfs2_sbd *sdp, int undo)
582 {
583         struct inode *pn = NULL;
584         char buf[30];
585         int error = 0;
586         struct gfs2_inode *ip;
587
588         if (sdp->sd_args.ar_spectator)
589                 return 0;
590
591         if (undo)
592                 goto fail_qc_gh;
593
594         pn = gfs2_lookup_simple(sdp->sd_master_dir, "per_node");
595         if (IS_ERR(pn)) {
596                 error = PTR_ERR(pn);
597                 fs_err(sdp, "can't find per_node directory: %d\n", error);
598                 return error;
599         }
600
601         sprintf(buf, "inum_range%u", sdp->sd_jdesc->jd_jid);
602         sdp->sd_ir_inode = gfs2_lookup_simple(pn, buf);
603         if (IS_ERR(sdp->sd_ir_inode)) {
604                 error = PTR_ERR(sdp->sd_ir_inode);
605                 fs_err(sdp, "can't find local \"ir\" file: %d\n", error);
606                 goto fail;
607         }
608
609         sprintf(buf, "statfs_change%u", sdp->sd_jdesc->jd_jid);
610         sdp->sd_sc_inode = gfs2_lookup_simple(pn, buf);
611         if (IS_ERR(sdp->sd_sc_inode)) {
612                 error = PTR_ERR(sdp->sd_sc_inode);
613                 fs_err(sdp, "can't find local \"sc\" file: %d\n", error);
614                 goto fail_ir_i;
615         }
616
617         sprintf(buf, "unlinked_tag%u", sdp->sd_jdesc->jd_jid);
618         sdp->sd_ut_inode = gfs2_lookup_simple(pn, buf);
619         if (IS_ERR(sdp->sd_ut_inode)) {
620                 error = PTR_ERR(sdp->sd_ut_inode);
621                 fs_err(sdp, "can't find local \"ut\" file: %d\n", error);
622                 goto fail_sc_i;
623         }
624
625         sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid);
626         sdp->sd_qc_inode = gfs2_lookup_simple(pn, buf);
627         if (IS_ERR(sdp->sd_qc_inode)) {
628                 error = PTR_ERR(sdp->sd_qc_inode);
629                 fs_err(sdp, "can't find local \"qc\" file: %d\n", error);
630                 goto fail_ut_i;
631         }
632
633         iput(pn);
634         pn = NULL;
635
636         ip = sdp->sd_ir_inode->u.generic_ip;
637         error = gfs2_glock_nq_init(ip->i_gl,
638                                    LM_ST_EXCLUSIVE, 0,
639                                    &sdp->sd_ir_gh);
640         if (error) {
641                 fs_err(sdp, "can't lock local \"ir\" file: %d\n", error);
642                 goto fail_qc_i;
643         }
644
645         ip = sdp->sd_sc_inode->u.generic_ip;
646         error = gfs2_glock_nq_init(ip->i_gl,
647                                    LM_ST_EXCLUSIVE, 0,
648                                    &sdp->sd_sc_gh);
649         if (error) {
650                 fs_err(sdp, "can't lock local \"sc\" file: %d\n", error);
651                 goto fail_ir_gh;
652         }
653
654         ip = sdp->sd_ut_inode->u.generic_ip;
655         error = gfs2_glock_nq_init(ip->i_gl,
656                                    LM_ST_EXCLUSIVE, 0,
657                                    &sdp->sd_ut_gh);
658         if (error) {
659                 fs_err(sdp, "can't lock local \"ut\" file: %d\n", error);
660                 goto fail_sc_gh;
661         }
662
663         ip = sdp->sd_qc_inode->u.generic_ip;
664         error = gfs2_glock_nq_init(ip->i_gl,
665                                    LM_ST_EXCLUSIVE, 0,
666                                    &sdp->sd_qc_gh);
667         if (error) {
668                 fs_err(sdp, "can't lock local \"qc\" file: %d\n", error);
669                 goto fail_ut_gh;
670         }
671
672         return 0;
673
674  fail_qc_gh:
675         gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
676
677  fail_ut_gh:
678         gfs2_glock_dq_uninit(&sdp->sd_ut_gh);
679
680  fail_sc_gh:
681         gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
682
683  fail_ir_gh:
684         gfs2_glock_dq_uninit(&sdp->sd_ir_gh);
685
686  fail_qc_i:
687         iput(sdp->sd_qc_inode);
688
689  fail_ut_i:
690         iput(sdp->sd_ut_inode);
691
692  fail_sc_i:
693         iput(sdp->sd_sc_inode);
694
695  fail_ir_i:
696         iput(sdp->sd_ir_inode);
697
698  fail:
699         if (pn)
700                 iput(pn);
701         return error;
702 }
703
704 static int init_threads(struct gfs2_sbd *sdp, int undo)
705 {
706         struct task_struct *p;
707         int error = 0;
708
709         if (undo)
710                 goto fail_inoded;
711
712         sdp->sd_log_flush_time = jiffies;
713         sdp->sd_jindex_refresh_time = jiffies;
714
715         p = kthread_run(gfs2_logd, sdp, "gfs2_logd");
716         error = IS_ERR(p);
717         if (error) {
718                 fs_err(sdp, "can't start logd thread: %d\n", error);
719                 return error;
720         }
721         sdp->sd_logd_process = p;
722
723         sdp->sd_statfs_sync_time = jiffies;
724         sdp->sd_quota_sync_time = jiffies;
725
726         p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad");
727         error = IS_ERR(p);
728         if (error) {
729                 fs_err(sdp, "can't start quotad thread: %d\n", error);
730                 goto fail;
731         }
732         sdp->sd_quotad_process = p;
733
734         p = kthread_run(gfs2_inoded, sdp, "gfs2_inoded");
735         error = IS_ERR(p);
736         if (error) {
737                 fs_err(sdp, "can't start inoded thread: %d\n", error);
738                 goto fail_quotad;
739         }
740         sdp->sd_inoded_process = p;
741
742         return 0;
743
744  fail_inoded:
745         kthread_stop(sdp->sd_inoded_process);
746
747  fail_quotad:
748         kthread_stop(sdp->sd_quotad_process);
749
750  fail:
751         kthread_stop(sdp->sd_logd_process);
752         
753         return error;
754 }
755
756 /**
757  * fill_super - Read in superblock
758  * @sb: The VFS superblock
759  * @data: Mount options
760  * @silent: Don't complain if it's not a GFS2 filesystem
761  *
762  * Returns: errno
763  */
764
765 static int fill_super(struct super_block *sb, void *data, int silent)
766 {
767         struct gfs2_sbd *sdp;
768         struct gfs2_holder mount_gh;
769         int error;
770
771         sdp = init_sbd(sb);
772         if (!sdp) {
773                 printk(KERN_WARNING "GFS2: can't alloc struct gfs2_sbd\n");
774                 return -ENOMEM;
775         }
776
777         error = gfs2_mount_args(sdp, (char *)data, 0);
778         if (error) {
779                 printk(KERN_WARNING "GFS2: can't parse mount arguments\n");
780                 goto fail;
781         }
782
783         init_vfs(sb, SDF_NOATIME);
784
785         /* Set up the buffer cache and fill in some fake block size values
786            to allow us to read-in the on-disk superblock. */
787         sdp->sd_sb.sb_bsize = sb_min_blocksize(sb, GFS2_BASIC_BLOCK);
788         sdp->sd_sb.sb_bsize_shift = sb->s_blocksize_bits;
789         sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
790                                GFS2_BASIC_BLOCK_SHIFT;
791         sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
792
793         error = init_names(sdp, silent);
794         if (error)
795                 goto fail;
796
797         error = gfs2_sys_fs_add(sdp);
798         if (error)
799                 goto fail;
800
801         error = gfs2_lm_mount(sdp, silent);
802         if (error)
803                 goto fail_sys;
804
805         error = init_locking(sdp, &mount_gh, DO);
806         if (error)
807                 goto fail_lm;
808
809         error = init_sb(sdp, silent, DO);
810         if (error)
811                 goto fail_locking;
812
813         error = init_inodes(sdp, DO);
814         if (error)
815                 goto fail_sb;
816
817         error = init_per_node(sdp, DO);
818         if (error)
819                 goto fail_inodes;
820
821         error = gfs2_statfs_init(sdp);
822         if (error) {
823                 fs_err(sdp, "can't initialize statfs subsystem: %d\n", error);
824                 goto fail_per_node;
825         }
826
827         error = init_threads(sdp, DO);
828         if (error)
829                 goto fail_per_node;
830
831         if (!(sb->s_flags & MS_RDONLY)) {
832                 error = gfs2_make_fs_rw(sdp);
833                 if (error) {
834                         fs_err(sdp, "can't make FS RW: %d\n", error);
835                         goto fail_threads;
836                 }
837         }
838
839         gfs2_glock_dq_uninit(&mount_gh);
840
841         return 0;
842
843  fail_threads:
844         init_threads(sdp, UNDO);
845
846  fail_per_node:
847         init_per_node(sdp, UNDO);
848
849  fail_inodes:
850         init_inodes(sdp, UNDO);
851
852  fail_sb:
853         init_sb(sdp, 0, UNDO);
854
855  fail_locking:
856         init_locking(sdp, &mount_gh, UNDO);
857
858  fail_lm:
859         gfs2_gl_hash_clear(sdp, WAIT);
860         gfs2_lm_unmount(sdp);
861         while (invalidate_inodes(sb))
862                 yield();
863
864  fail_sys:
865         gfs2_sys_fs_del(sdp);
866
867  fail:
868         vfree(sdp);
869         sb->s_fs_info = NULL;
870
871         return error;
872 }
873
874 static struct super_block *gfs2_get_sb(struct file_system_type *fs_type,
875                                        int flags, const char *dev_name,
876                                        void *data)
877 {
878         return get_sb_bdev(fs_type, flags, dev_name, data, fill_super);
879 }
880
881 static void gfs2_kill_sb(struct super_block *sb)
882 {
883         kill_block_super(sb);
884 }
885
886 struct file_system_type gfs2_fs_type = {
887         .name = "gfs2",
888         .fs_flags = FS_REQUIRES_DEV,
889         .get_sb = gfs2_get_sb,
890         .kill_sb = gfs2_kill_sb,
891         .owner = THIS_MODULE,
892 };
893
894 struct file_system_type gfs2meta_fs_type = {
895         .name = "gfs2meta",
896         .fs_flags = FS_REQUIRES_DEV,
897         .get_sb = gfs2_get_sb,
898         .kill_sb = gfs2_kill_sb,
899         .owner = THIS_MODULE,
900 };
901