Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/fs/gfs2/ops_fstype.c

  1 /*
  2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
  3  * Copyright (C) 2004-2008 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 version 2.
  8  */
  9 
 10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 11 
 12 #include <linux/sched.h>
 13 #include <linux/slab.h>
 14 #include <linux/spinlock.h>
 15 #include <linux/completion.h>
 16 #include <linux/buffer_head.h>
 17 #include <linux/blkdev.h>
 18 #include <linux/kthread.h>
 19 #include <linux/export.h>
 20 #include <linux/namei.h>
 21 #include <linux/mount.h>
 22 #include <linux/gfs2_ondisk.h>
 23 #include <linux/quotaops.h>
 24 #include <linux/lockdep.h>
 25 #include <linux/module.h>
 26 
 27 #include "gfs2.h"
 28 #include "incore.h"
 29 #include "bmap.h"
 30 #include "glock.h"
 31 #include "glops.h"
 32 #include "inode.h"
 33 #include "recovery.h"
 34 #include "rgrp.h"
 35 #include "super.h"
 36 #include "sys.h"
 37 #include "util.h"
 38 #include "log.h"
 39 #include "quota.h"
 40 #include "dir.h"
 41 #include "meta_io.h"
 42 #include "trace_gfs2.h"
 43 
 44 #define DO 0
 45 #define UNDO 1
 46 
 47 /**
 48  * gfs2_tune_init - Fill a gfs2_tune structure with default values
 49  * @gt: tune
 50  *
 51  */
 52 
 53 static void gfs2_tune_init(struct gfs2_tune *gt)
 54 {
 55         spin_lock_init(&gt->gt_spin);
 56 
 57         gt->gt_quota_warn_period = 10;
 58         gt->gt_quota_scale_num = 1;
 59         gt->gt_quota_scale_den = 1;
 60         gt->gt_new_files_jdata = 0;
 61         gt->gt_max_readahead = 1 << 18;
 62         gt->gt_complain_secs = 10;
 63 }
 64 
 65 static struct gfs2_sbd *init_sbd(struct super_block *sb)
 66 {
 67         struct gfs2_sbd *sdp;
 68         struct address_space *mapping;
 69 
 70         sdp = kzalloc(sizeof(struct gfs2_sbd), GFP_KERNEL);
 71         if (!sdp)
 72                 return NULL;
 73 
 74         sb->s_fs_info = sdp;
 75         sdp->sd_vfs = sb;
 76         sdp->sd_lkstats = alloc_percpu(struct gfs2_pcpu_lkstats);
 77         if (!sdp->sd_lkstats) {
 78                 kfree(sdp);
 79                 return NULL;
 80         }
 81 
 82         set_bit(SDF_NOJOURNALID, &sdp->sd_flags);
 83         gfs2_tune_init(&sdp->sd_tune);
 84 
 85         init_waitqueue_head(&sdp->sd_glock_wait);
 86         atomic_set(&sdp->sd_glock_disposal, 0);
 87         init_completion(&sdp->sd_locking_init);
 88         init_completion(&sdp->sd_wdack);
 89         spin_lock_init(&sdp->sd_statfs_spin);
 90 
 91         spin_lock_init(&sdp->sd_rindex_spin);
 92         sdp->sd_rindex_tree.rb_node = NULL;
 93 
 94         INIT_LIST_HEAD(&sdp->sd_jindex_list);
 95         spin_lock_init(&sdp->sd_jindex_spin);
 96         mutex_init(&sdp->sd_jindex_mutex);
 97 
 98         INIT_LIST_HEAD(&sdp->sd_quota_list);
 99         mutex_init(&sdp->sd_quota_mutex);
100         mutex_init(&sdp->sd_quota_sync_mutex);
101         init_waitqueue_head(&sdp->sd_quota_wait);
102         INIT_LIST_HEAD(&sdp->sd_trunc_list);
103         spin_lock_init(&sdp->sd_trunc_lock);
104         spin_lock_init(&sdp->sd_bitmap_lock);
105 
106         mapping = &sdp->sd_aspace;
107 
108         address_space_init_once(mapping);
109         mapping->a_ops = &gfs2_rgrp_aops;
110         mapping->host = sb->s_bdev->bd_inode;
111         mapping->flags = 0;
112         mapping_set_gfp_mask(mapping, GFP_NOFS);
113         mapping->private_data = NULL;
114         mapping->backing_dev_info = sb->s_bdi;
115         mapping->writeback_index = 0;
116 
117         spin_lock_init(&sdp->sd_log_lock);
118         atomic_set(&sdp->sd_log_pinned, 0);
119         INIT_LIST_HEAD(&sdp->sd_log_le_revoke);
120         INIT_LIST_HEAD(&sdp->sd_log_le_ordered);
121         spin_lock_init(&sdp->sd_ordered_lock);
122 
123         init_waitqueue_head(&sdp->sd_log_waitq);
124         init_waitqueue_head(&sdp->sd_logd_waitq);
125         spin_lock_init(&sdp->sd_ail_lock);
126         INIT_LIST_HEAD(&sdp->sd_ail1_list);
127         INIT_LIST_HEAD(&sdp->sd_ail2_list);
128 
129         init_rwsem(&sdp->sd_log_flush_lock);
130         atomic_set(&sdp->sd_log_in_flight, 0);
131         init_waitqueue_head(&sdp->sd_log_flush_wait);
132 
133         return sdp;
134 }
135 
136 
137 /**
138  * gfs2_check_sb - Check superblock
139  * @sdp: the filesystem
140  * @sb: The superblock
141  * @silent: Don't print a message if the check fails
142  *
143  * Checks the version code of the FS is one that we understand how to
144  * read and that the sizes of the various on-disk structures have not
145  * changed.
146  */
147 
148 static int gfs2_check_sb(struct gfs2_sbd *sdp, int silent)
149 {
150         struct gfs2_sb_host *sb = &sdp->sd_sb;
151 
152         if (sb->sb_magic != GFS2_MAGIC ||
153             sb->sb_type != GFS2_METATYPE_SB) {
154                 if (!silent)
155                         pr_warn("not a GFS2 filesystem\n");
156                 return -EINVAL;
157         }
158 
159         /*  If format numbers match exactly, we're done.  */
160 
161         if (sb->sb_fs_format == GFS2_FORMAT_FS &&
162             sb->sb_multihost_format == GFS2_FORMAT_MULTI)
163                 return 0;
164 
165         fs_warn(sdp, "Unknown on-disk format, unable to mount\n");
166 
167         return -EINVAL;
168 }
169 
170 static void end_bio_io_page(struct bio *bio, int error)
171 {
172         struct page *page = bio->bi_private;
173 
174         if (!error)
175                 SetPageUptodate(page);
176         else
177                 pr_warn("error %d reading superblock\n", error);
178         unlock_page(page);
179 }
180 
181 static void gfs2_sb_in(struct gfs2_sbd *sdp, const void *buf)
182 {
183         struct gfs2_sb_host *sb = &sdp->sd_sb;
184         struct super_block *s = sdp->sd_vfs;
185         const struct gfs2_sb *str = buf;
186 
187         sb->sb_magic = be32_to_cpu(str->sb_header.mh_magic);
188         sb->sb_type = be32_to_cpu(str->sb_header.mh_type);
189         sb->sb_format = be32_to_cpu(str->sb_header.mh_format);
190         sb->sb_fs_format = be32_to_cpu(str->sb_fs_format);
191         sb->sb_multihost_format = be32_to_cpu(str->sb_multihost_format);
192         sb->sb_bsize = be32_to_cpu(str->sb_bsize);
193         sb->sb_bsize_shift = be32_to_cpu(str->sb_bsize_shift);
194         sb->sb_master_dir.no_addr = be64_to_cpu(str->sb_master_dir.no_addr);
195         sb->sb_master_dir.no_formal_ino = be64_to_cpu(str->sb_master_dir.no_formal_ino);
196         sb->sb_root_dir.no_addr = be64_to_cpu(str->sb_root_dir.no_addr);
197         sb->sb_root_dir.no_formal_ino = be64_to_cpu(str->sb_root_dir.no_formal_ino);
198 
199         memcpy(sb->sb_lockproto, str->sb_lockproto, GFS2_LOCKNAME_LEN);
200         memcpy(sb->sb_locktable, str->sb_locktable, GFS2_LOCKNAME_LEN);
201         memcpy(s->s_uuid, str->sb_uuid, 16);
202 }
203 
204 /**
205  * gfs2_read_super - Read the gfs2 super block from disk
206  * @sdp: The GFS2 super block
207  * @sector: The location of the super block
208  * @error: The error code to return
209  *
210  * This uses the bio functions to read the super block from disk
211  * because we want to be 100% sure that we never read cached data.
212  * A super block is read twice only during each GFS2 mount and is
213  * never written to by the filesystem. The first time its read no
214  * locks are held, and the only details which are looked at are those
215  * relating to the locking protocol. Once locking is up and working,
216  * the sb is read again under the lock to establish the location of
217  * the master directory (contains pointers to journals etc) and the
218  * root directory.
219  *
220  * Returns: 0 on success or error
221  */
222 
223 static int gfs2_read_super(struct gfs2_sbd *sdp, sector_t sector, int silent)
224 {
225         struct super_block *sb = sdp->sd_vfs;
226         struct gfs2_sb *p;
227         struct page *page;
228         struct bio *bio;
229 
230         page = alloc_page(GFP_NOFS);
231         if (unlikely(!page))
232                 return -ENOMEM;
233 
234         ClearPageUptodate(page);
235         ClearPageDirty(page);
236         lock_page(page);
237 
238         bio = bio_alloc(GFP_NOFS, 1);
239         bio->bi_iter.bi_sector = sector * (sb->s_blocksize >> 9);
240         bio->bi_bdev = sb->s_bdev;
241         bio_add_page(bio, page, PAGE_SIZE, 0);
242 
243         bio->bi_end_io = end_bio_io_page;
244         bio->bi_private = page;
245         submit_bio(READ_SYNC | REQ_META, bio);
246         wait_on_page_locked(page);
247         bio_put(bio);
248         if (!PageUptodate(page)) {
249                 __free_page(page);
250                 return -EIO;
251         }
252         p = kmap(page);
253         gfs2_sb_in(sdp, p);
254         kunmap(page);
255         __free_page(page);
256         return gfs2_check_sb(sdp, silent);
257 }
258 
259 /**
260  * gfs2_read_sb - Read super block
261  * @sdp: The GFS2 superblock
262  * @silent: Don't print message if mount fails
263  *
264  */
265 
266 static int gfs2_read_sb(struct gfs2_sbd *sdp, int silent)
267 {
268         u32 hash_blocks, ind_blocks, leaf_blocks;
269         u32 tmp_blocks;
270         unsigned int x;
271         int error;
272 
273         error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift, silent);
274         if (error) {
275                 if (!silent)
276                         fs_err(sdp, "can't read superblock\n");
277                 return error;
278         }
279 
280         sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
281                                GFS2_BASIC_BLOCK_SHIFT;
282         sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
283         sdp->sd_diptrs = (sdp->sd_sb.sb_bsize -
284                           sizeof(struct gfs2_dinode)) / sizeof(u64);
285         sdp->sd_inptrs = (sdp->sd_sb.sb_bsize -
286                           sizeof(struct gfs2_meta_header)) / sizeof(u64);
287         sdp->sd_jbsize = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);
288         sdp->sd_hash_bsize = sdp->sd_sb.sb_bsize / 2;
289         sdp->sd_hash_bsize_shift = sdp->sd_sb.sb_bsize_shift - 1;
290         sdp->sd_hash_ptrs = sdp->sd_hash_bsize / sizeof(u64);
291         sdp->sd_qc_per_block = (sdp->sd_sb.sb_bsize -
292                                 sizeof(struct gfs2_meta_header)) /
293                                 sizeof(struct gfs2_quota_change);
294         sdp->sd_blocks_per_bitmap = (sdp->sd_sb.sb_bsize -
295                                      sizeof(struct gfs2_meta_header))
296                 * GFS2_NBBY; /* not the rgrp bitmap, subsequent bitmaps only */
297 
298         /* Compute maximum reservation required to add a entry to a directory */
299 
300         hash_blocks = DIV_ROUND_UP(sizeof(u64) * (1 << GFS2_DIR_MAX_DEPTH),
301                              sdp->sd_jbsize);
302 
303         ind_blocks = 0;
304         for (tmp_blocks = hash_blocks; tmp_blocks > sdp->sd_diptrs;) {
305                 tmp_blocks = DIV_ROUND_UP(tmp_blocks, sdp->sd_inptrs);
306                 ind_blocks += tmp_blocks;
307         }
308 
309         leaf_blocks = 2 + GFS2_DIR_MAX_DEPTH;
310 
311         sdp->sd_max_dirres = hash_blocks + ind_blocks + leaf_blocks;
312 
313         sdp->sd_heightsize[0] = sdp->sd_sb.sb_bsize -
314                                 sizeof(struct gfs2_dinode);
315         sdp->sd_heightsize[1] = sdp->sd_sb.sb_bsize * sdp->sd_diptrs;
316         for (x = 2;; x++) {
317                 u64 space, d;
318                 u32 m;
319 
320                 space = sdp->sd_heightsize[x - 1] * sdp->sd_inptrs;
321                 d = space;
322                 m = do_div(d, sdp->sd_inptrs);
323 
324                 if (d != sdp->sd_heightsize[x - 1] || m)
325                         break;
326                 sdp->sd_heightsize[x] = space;
327         }
328         sdp->sd_max_height = x;
329         sdp->sd_heightsize[x] = ~0;
330         gfs2_assert(sdp, sdp->sd_max_height <= GFS2_MAX_META_HEIGHT);
331 
332         sdp->sd_jheightsize[0] = sdp->sd_sb.sb_bsize -
333                                  sizeof(struct gfs2_dinode);
334         sdp->sd_jheightsize[1] = sdp->sd_jbsize * sdp->sd_diptrs;
335         for (x = 2;; x++) {
336                 u64 space, d;
337                 u32 m;
338 
339                 space = sdp->sd_jheightsize[x - 1] * sdp->sd_inptrs;
340                 d = space;
341                 m = do_div(d, sdp->sd_inptrs);
342 
343                 if (d != sdp->sd_jheightsize[x - 1] || m)
344                         break;
345                 sdp->sd_jheightsize[x] = space;
346         }
347         sdp->sd_max_jheight = x;
348         sdp->sd_jheightsize[x] = ~0;
349         gfs2_assert(sdp, sdp->sd_max_jheight <= GFS2_MAX_META_HEIGHT);
350 
351         return 0;
352 }
353 
354 static int init_names(struct gfs2_sbd *sdp, int silent)
355 {
356         char *proto, *table;
357         int error = 0;
358 
359         proto = sdp->sd_args.ar_lockproto;
360         table = sdp->sd_args.ar_locktable;
361 
362         /*  Try to autodetect  */
363 
364         if (!proto[0] || !table[0]) {
365                 error = gfs2_read_super(sdp, GFS2_SB_ADDR >> sdp->sd_fsb2bb_shift, silent);
366                 if (error)
367                         return error;
368 
369                 if (!proto[0])
370                         proto = sdp->sd_sb.sb_lockproto;
371                 if (!table[0])
372                         table = sdp->sd_sb.sb_locktable;
373         }
374 
375         if (!table[0])
376                 table = sdp->sd_vfs->s_id;
377 
378         strlcpy(sdp->sd_proto_name, proto, GFS2_FSNAME_LEN);
379         strlcpy(sdp->sd_table_name, table, GFS2_FSNAME_LEN);
380 
381         table = sdp->sd_table_name;
382         while ((table = strchr(table, '/')))
383                 *table = '_';
384 
385         return error;
386 }
387 
388 static int init_locking(struct gfs2_sbd *sdp, struct gfs2_holder *mount_gh,
389                         int undo)
390 {
391         int error = 0;
392 
393         if (undo)
394                 goto fail_trans;
395 
396         error = gfs2_glock_nq_num(sdp,
397                                   GFS2_MOUNT_LOCK, &gfs2_nondisk_glops,
398                                   LM_ST_EXCLUSIVE, LM_FLAG_NOEXP | GL_NOCACHE,
399                                   mount_gh);
400         if (error) {
401                 fs_err(sdp, "can't acquire mount glock: %d\n", error);
402                 goto fail;
403         }
404 
405         error = gfs2_glock_nq_num(sdp,
406                                   GFS2_LIVE_LOCK, &gfs2_nondisk_glops,
407                                   LM_ST_SHARED,
408                                   LM_FLAG_NOEXP | GL_EXACT,
409                                   &sdp->sd_live_gh);
410         if (error) {
411                 fs_err(sdp, "can't acquire live glock: %d\n", error);
412                 goto fail_mount;
413         }
414 
415         error = gfs2_glock_get(sdp, GFS2_RENAME_LOCK, &gfs2_nondisk_glops,
416                                CREATE, &sdp->sd_rename_gl);
417         if (error) {
418                 fs_err(sdp, "can't create rename glock: %d\n", error);
419                 goto fail_live;
420         }
421 
422         error = gfs2_glock_get(sdp, GFS2_TRANS_LOCK, &gfs2_trans_glops,
423                                CREATE, &sdp->sd_trans_gl);
424         if (error) {
425                 fs_err(sdp, "can't create transaction glock: %d\n", error);
426                 goto fail_rename;
427         }
428 
429         return 0;
430 
431 fail_trans:
432         gfs2_glock_put(sdp->sd_trans_gl);
433 fail_rename:
434         gfs2_glock_put(sdp->sd_rename_gl);
435 fail_live:
436         gfs2_glock_dq_uninit(&sdp->sd_live_gh);
437 fail_mount:
438         gfs2_glock_dq_uninit(mount_gh);
439 fail:
440         return error;
441 }
442 
443 static int gfs2_lookup_root(struct super_block *sb, struct dentry **dptr,
444                             u64 no_addr, const char *name)
445 {
446         struct gfs2_sbd *sdp = sb->s_fs_info;
447         struct dentry *dentry;
448         struct inode *inode;
449 
450         inode = gfs2_inode_lookup(sb, DT_DIR, no_addr, 0, 0);
451         if (IS_ERR(inode)) {
452                 fs_err(sdp, "can't read in %s inode: %ld\n", name, PTR_ERR(inode));
453                 return PTR_ERR(inode);
454         }
455         dentry = d_make_root(inode);
456         if (!dentry) {
457                 fs_err(sdp, "can't alloc %s dentry\n", name);
458                 return -ENOMEM;
459         }
460         *dptr = dentry;
461         return 0;
462 }
463 
464 static int init_sb(struct gfs2_sbd *sdp, int silent)
465 {
466         struct super_block *sb = sdp->sd_vfs;
467         struct gfs2_holder sb_gh;
468         u64 no_addr;
469         int ret;
470 
471         ret = gfs2_glock_nq_num(sdp, GFS2_SB_LOCK, &gfs2_meta_glops,
472                                 LM_ST_SHARED, 0, &sb_gh);
473         if (ret) {
474                 fs_err(sdp, "can't acquire superblock glock: %d\n", ret);
475                 return ret;
476         }
477 
478         ret = gfs2_read_sb(sdp, silent);
479         if (ret) {
480                 fs_err(sdp, "can't read superblock: %d\n", ret);
481                 goto out;
482         }
483 
484         /* Set up the buffer cache and SB for real */
485         if (sdp->sd_sb.sb_bsize < bdev_logical_block_size(sb->s_bdev)) {
486                 ret = -EINVAL;
487                 fs_err(sdp, "FS block size (%u) is too small for device "
488                        "block size (%u)\n",
489                        sdp->sd_sb.sb_bsize, bdev_logical_block_size(sb->s_bdev));
490                 goto out;
491         }
492         if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
493                 ret = -EINVAL;
494                 fs_err(sdp, "FS block size (%u) is too big for machine "
495                        "page size (%u)\n",
496                        sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE);
497                 goto out;
498         }
499         sb_set_blocksize(sb, sdp->sd_sb.sb_bsize);
500 
501         /* Get the root inode */
502         no_addr = sdp->sd_sb.sb_root_dir.no_addr;
503         ret = gfs2_lookup_root(sb, &sdp->sd_root_dir, no_addr, "root");
504         if (ret)
505                 goto out;
506 
507         /* Get the master inode */
508         no_addr = sdp->sd_sb.sb_master_dir.no_addr;
509         ret = gfs2_lookup_root(sb, &sdp->sd_master_dir, no_addr, "master");
510         if (ret) {
511                 dput(sdp->sd_root_dir);
512                 goto out;
513         }
514         sb->s_root = dget(sdp->sd_args.ar_meta ? sdp->sd_master_dir : sdp->sd_root_dir);
515 out:
516         gfs2_glock_dq_uninit(&sb_gh);
517         return ret;
518 }
519 
520 static void gfs2_others_may_mount(struct gfs2_sbd *sdp)
521 {
522         char *message = "FIRSTMOUNT=Done";
523         char *envp[] = { message, NULL };
524 
525         fs_info(sdp, "first mount done, others may mount\n");
526 
527         if (sdp->sd_lockstruct.ls_ops->lm_first_done)
528                 sdp->sd_lockstruct.ls_ops->lm_first_done(sdp);
529 
530         kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp);
531 }
532 
533 /**
534  * gfs2_jindex_hold - Grab a lock on the jindex
535  * @sdp: The GFS2 superblock
536  * @ji_gh: the holder for the jindex glock
537  *
538  * Returns: errno
539  */
540 
541 static int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
542 {
543         struct gfs2_inode *dip = GFS2_I(sdp->sd_jindex);
544         struct qstr name;
545         char buf[20];
546         struct gfs2_jdesc *jd;
547         int error;
548 
549         name.name = buf;
550 
551         mutex_lock(&sdp->sd_jindex_mutex);
552 
553         for (;;) {
554                 error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, ji_gh);
555                 if (error)
556                         break;
557 
558                 name.len = sprintf(buf, "journal%u", sdp->sd_journals);
559                 name.hash = gfs2_disk_hash(name.name, name.len);
560 
561                 error = gfs2_dir_check(sdp->sd_jindex, &name, NULL);
562                 if (error == -ENOENT) {
563                         error = 0;
564                         break;
565                 }
566 
567                 gfs2_glock_dq_uninit(ji_gh);
568 
569                 if (error)
570                         break;
571 
572                 error = -ENOMEM;
573                 jd = kzalloc(sizeof(struct gfs2_jdesc), GFP_KERNEL);
574                 if (!jd)
575                         break;
576 
577                 INIT_LIST_HEAD(&jd->extent_list);
578                 INIT_LIST_HEAD(&jd->jd_revoke_list);
579 
580                 INIT_WORK(&jd->jd_work, gfs2_recover_func);
581                 jd->jd_inode = gfs2_lookupi(sdp->sd_jindex, &name, 1);
582                 if (!jd->jd_inode || IS_ERR(jd->jd_inode)) {
583                         if (!jd->jd_inode)
584                                 error = -ENOENT;
585                         else
586                                 error = PTR_ERR(jd->jd_inode);
587                         kfree(jd);
588                         break;
589                 }
590 
591                 spin_lock(&sdp->sd_jindex_spin);
592                 jd->jd_jid = sdp->sd_journals++;
593                 list_add_tail(&jd->jd_list, &sdp->sd_jindex_list);
594                 spin_unlock(&sdp->sd_jindex_spin);
595         }
596 
597         mutex_unlock(&sdp->sd_jindex_mutex);
598 
599         return error;
600 }
601 
602 /**
603  * check_journal_clean - Make sure a journal is clean for a spectator mount
604  * @sdp: The GFS2 superblock
605  * @jd: The journal descriptor
606  *
607  * Returns: 0 if the journal is clean or locked, else an error
608  */
609 static int check_journal_clean(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd)
610 {
611         int error;
612         struct gfs2_holder j_gh;
613         struct gfs2_log_header_host head;
614         struct gfs2_inode *ip;
615 
616         ip = GFS2_I(jd->jd_inode);
617         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_NOEXP |
618                                    GL_EXACT | GL_NOCACHE, &j_gh);
619         if (error) {
620                 fs_err(sdp, "Error locking journal for spectator mount.\n");
621                 return -EPERM;
622         }
623         error = gfs2_jdesc_check(jd);
624         if (error) {
625                 fs_err(sdp, "Error checking journal for spectator mount.\n");
626                 goto out_unlock;
627         }
628         error = gfs2_find_jhead(jd, &head);
629         if (error) {
630                 fs_err(sdp, "Error parsing journal for spectator mount.\n");
631                 goto out_unlock;
632         }
633         if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
634                 error = -EPERM;
635                 fs_err(sdp, "jid=%u: Journal is dirty, so the first mounter "
636                        "must not be a spectator.\n", jd->jd_jid);
637         }
638 
639 out_unlock:
640         gfs2_glock_dq_uninit(&j_gh);
641         return error;
642 }
643 
644 static int init_journal(struct gfs2_sbd *sdp, int undo)
645 {
646         struct inode *master = sdp->sd_master_dir->d_inode;
647         struct gfs2_holder ji_gh;
648         struct gfs2_inode *ip;
649         int jindex = 1;
650         int error = 0;
651 
652         if (undo) {
653                 jindex = 0;
654                 goto fail_jinode_gh;
655         }
656 
657         sdp->sd_jindex = gfs2_lookup_simple(master, "jindex");
658         if (IS_ERR(sdp->sd_jindex)) {
659                 fs_err(sdp, "can't lookup journal index: %d\n", error);
660                 return PTR_ERR(sdp->sd_jindex);
661         }
662 
663         /* Load in the journal index special file */
664 
665         error = gfs2_jindex_hold(sdp, &ji_gh);
666         if (error) {
667                 fs_err(sdp, "can't read journal index: %d\n", error);
668                 goto fail;
669         }
670 
671         error = -EUSERS;
672         if (!gfs2_jindex_size(sdp)) {
673                 fs_err(sdp, "no journals!\n");
674                 goto fail_jindex;
675         }
676 
677         if (sdp->sd_args.ar_spectator) {
678                 sdp->sd_jdesc = gfs2_jdesc_find(sdp, 0);
679                 atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
680                 atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
681                 atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
682         } else {
683                 if (sdp->sd_lockstruct.ls_jid >= gfs2_jindex_size(sdp)) {
684                         fs_err(sdp, "can't mount journal #%u\n",
685                                sdp->sd_lockstruct.ls_jid);
686                         fs_err(sdp, "there are only %u journals (0 - %u)\n",
687                                gfs2_jindex_size(sdp),
688                                gfs2_jindex_size(sdp) - 1);
689                         goto fail_jindex;
690                 }
691                 sdp->sd_jdesc = gfs2_jdesc_find(sdp, sdp->sd_lockstruct.ls_jid);
692 
693                 error = gfs2_glock_nq_num(sdp, sdp->sd_lockstruct.ls_jid,
694                                           &gfs2_journal_glops,
695                                           LM_ST_EXCLUSIVE, LM_FLAG_NOEXP,
696                                           &sdp->sd_journal_gh);
697                 if (error) {
698                         fs_err(sdp, "can't acquire journal glock: %d\n", error);
699                         goto fail_jindex;
700                 }
701 
702                 ip = GFS2_I(sdp->sd_jdesc->jd_inode);
703                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED,
704                                            LM_FLAG_NOEXP | GL_EXACT | GL_NOCACHE,
705                                            &sdp->sd_jinode_gh);
706                 if (error) {
707                         fs_err(sdp, "can't acquire journal inode glock: %d\n",
708                                error);
709                         goto fail_journal_gh;
710                 }
711 
712                 error = gfs2_jdesc_check(sdp->sd_jdesc);
713                 if (error) {
714                         fs_err(sdp, "my journal (%u) is bad: %d\n",
715                                sdp->sd_jdesc->jd_jid, error);
716                         goto fail_jinode_gh;
717                 }
718                 atomic_set(&sdp->sd_log_blks_free, sdp->sd_jdesc->jd_blocks);
719                 atomic_set(&sdp->sd_log_thresh1, 2*sdp->sd_jdesc->jd_blocks/5);
720                 atomic_set(&sdp->sd_log_thresh2, 4*sdp->sd_jdesc->jd_blocks/5);
721 
722                 /* Map the extents for this journal's blocks */
723                 gfs2_map_journal_extents(sdp, sdp->sd_jdesc);
724         }
725         trace_gfs2_log_blocks(sdp, atomic_read(&sdp->sd_log_blks_free));
726 
727         if (sdp->sd_lockstruct.ls_first) {
728                 unsigned int x;
729                 for (x = 0; x < sdp->sd_journals; x++) {
730                         struct gfs2_jdesc *jd = gfs2_jdesc_find(sdp, x);
731 
732                         if (sdp->sd_args.ar_spectator) {
733                                 error = check_journal_clean(sdp, jd);
734                                 if (error)
735                                         goto fail_jinode_gh;
736                                 continue;
737                         }
738                         error = gfs2_recover_journal(jd, true);
739                         if (error) {
740                                 fs_err(sdp, "error recovering journal %u: %d\n",
741                                        x, error);
742                                 goto fail_jinode_gh;
743                         }
744                 }
745 
746                 gfs2_others_may_mount(sdp);
747         } else if (!sdp->sd_args.ar_spectator) {
748                 error = gfs2_recover_journal(sdp->sd_jdesc, true);
749                 if (error) {
750                         fs_err(sdp, "error recovering my journal: %d\n", error);
751                         goto fail_jinode_gh;
752                 }
753         }
754 
755         set_bit(SDF_JOURNAL_CHECKED, &sdp->sd_flags);
756         gfs2_glock_dq_uninit(&ji_gh);
757         jindex = 0;
758 
759         return 0;
760 
761 fail_jinode_gh:
762         if (!sdp->sd_args.ar_spectator)
763                 gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
764 fail_journal_gh:
765         if (!sdp->sd_args.ar_spectator)
766                 gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
767 fail_jindex:
768         gfs2_jindex_free(sdp);
769         if (jindex)
770                 gfs2_glock_dq_uninit(&ji_gh);
771 fail:
772         iput(sdp->sd_jindex);
773         return error;
774 }
775 
776 static struct lock_class_key gfs2_quota_imutex_key;
777 
778 static int init_inodes(struct gfs2_sbd *sdp, int undo)
779 {
780         int error = 0;
781         struct inode *master = sdp->sd_master_dir->d_inode;
782 
783         if (undo)
784                 goto fail_qinode;
785 
786         error = init_journal(sdp, undo);
787         if (error)
788                 goto fail;
789 
790         /* Read in the master statfs inode */
791         sdp->sd_statfs_inode = gfs2_lookup_simple(master, "statfs");
792         if (IS_ERR(sdp->sd_statfs_inode)) {
793                 error = PTR_ERR(sdp->sd_statfs_inode);
794                 fs_err(sdp, "can't read in statfs inode: %d\n", error);
795                 goto fail_journal;
796         }
797 
798         /* Read in the resource index inode */
799         sdp->sd_rindex = gfs2_lookup_simple(master, "rindex");
800         if (IS_ERR(sdp->sd_rindex)) {
801                 error = PTR_ERR(sdp->sd_rindex);
802                 fs_err(sdp, "can't get resource index inode: %d\n", error);
803                 goto fail_statfs;
804         }
805         sdp->sd_rindex_uptodate = 0;
806 
807         /* Read in the quota inode */
808         sdp->sd_quota_inode = gfs2_lookup_simple(master, "quota");
809         if (IS_ERR(sdp->sd_quota_inode)) {
810                 error = PTR_ERR(sdp->sd_quota_inode);
811                 fs_err(sdp, "can't get quota file inode: %d\n", error);
812                 goto fail_rindex;
813         }
814         /*
815          * i_mutex on quota files is special. Since this inode is hidden system
816          * file, we are safe to define locking ourselves.
817          */
818         lockdep_set_class(&sdp->sd_quota_inode->i_mutex,
819                           &gfs2_quota_imutex_key);
820 
821         error = gfs2_rindex_update(sdp);
822         if (error)
823                 goto fail_qinode;
824 
825         return 0;
826 
827 fail_qinode:
828         iput(sdp->sd_quota_inode);
829 fail_rindex:
830         gfs2_clear_rgrpd(sdp);
831         iput(sdp->sd_rindex);
832 fail_statfs:
833         iput(sdp->sd_statfs_inode);
834 fail_journal:
835         init_journal(sdp, UNDO);
836 fail:
837         return error;
838 }
839 
840 static int init_per_node(struct gfs2_sbd *sdp, int undo)
841 {
842         struct inode *pn = NULL;
843         char buf[30];
844         int error = 0;
845         struct gfs2_inode *ip;
846         struct inode *master = sdp->sd_master_dir->d_inode;
847 
848         if (sdp->sd_args.ar_spectator)
849                 return 0;
850 
851         if (undo)
852                 goto fail_qc_gh;
853 
854         pn = gfs2_lookup_simple(master, "per_node");
855         if (IS_ERR(pn)) {
856                 error = PTR_ERR(pn);
857                 fs_err(sdp, "can't find per_node directory: %d\n", error);
858                 return error;
859         }
860 
861         sprintf(buf, "statfs_change%u", sdp->sd_jdesc->jd_jid);
862         sdp->sd_sc_inode = gfs2_lookup_simple(pn, buf);
863         if (IS_ERR(sdp->sd_sc_inode)) {
864                 error = PTR_ERR(sdp->sd_sc_inode);
865                 fs_err(sdp, "can't find local \"sc\" file: %d\n", error);
866                 goto fail;
867         }
868 
869         sprintf(buf, "quota_change%u", sdp->sd_jdesc->jd_jid);
870         sdp->sd_qc_inode = gfs2_lookup_simple(pn, buf);
871         if (IS_ERR(sdp->sd_qc_inode)) {
872                 error = PTR_ERR(sdp->sd_qc_inode);
873                 fs_err(sdp, "can't find local \"qc\" file: %d\n", error);
874                 goto fail_ut_i;
875         }
876 
877         iput(pn);
878         pn = NULL;
879 
880         ip = GFS2_I(sdp->sd_sc_inode);
881         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0,
882                                    &sdp->sd_sc_gh);
883         if (error) {
884                 fs_err(sdp, "can't lock local \"sc\" file: %d\n", error);
885                 goto fail_qc_i;
886         }
887 
888         ip = GFS2_I(sdp->sd_qc_inode);
889         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0,
890                                    &sdp->sd_qc_gh);
891         if (error) {
892                 fs_err(sdp, "can't lock local \"qc\" file: %d\n", error);
893                 goto fail_ut_gh;
894         }
895 
896         return 0;
897 
898 fail_qc_gh:
899         gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
900 fail_ut_gh:
901         gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
902 fail_qc_i:
903         iput(sdp->sd_qc_inode);
904 fail_ut_i:
905         iput(sdp->sd_sc_inode);
906 fail:
907         if (pn)
908                 iput(pn);
909         return error;
910 }
911 
912 static const match_table_t nolock_tokens = {
913         { Opt_jid, "jid=%d\n", },
914         { Opt_err, NULL },
915 };
916 
917 static const struct lm_lockops nolock_ops = {
918         .lm_proto_name = "lock_nolock",
919         .lm_put_lock = gfs2_glock_free,
920         .lm_tokens = &nolock_tokens,
921 };
922 
923 /**
924  * gfs2_lm_mount - mount a locking protocol
925  * @sdp: the filesystem
926  * @args: mount arguments
927  * @silent: if 1, don't complain if the FS isn't a GFS2 fs
928  *
929  * Returns: errno
930  */
931 
932 static int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
933 {
934         const struct lm_lockops *lm;
935         struct lm_lockstruct *ls = &sdp->sd_lockstruct;
936         struct gfs2_args *args = &sdp->sd_args;
937         const char *proto = sdp->sd_proto_name;
938         const char *table = sdp->sd_table_name;
939         char *o, *options;
940         int ret;
941 
942         if (!strcmp("lock_nolock", proto)) {
943                 lm = &nolock_ops;
944                 sdp->sd_args.ar_localflocks = 1;
945 #ifdef CONFIG_GFS2_FS_LOCKING_DLM
946         } else if (!strcmp("lock_dlm", proto)) {
947                 lm = &gfs2_dlm_ops;
948 #endif
949         } else {
950                 pr_info("can't find protocol %s\n", proto);
951                 return -ENOENT;
952         }
953 
954         fs_info(sdp, "Trying to join cluster \"%s\", \"%s\"\n", proto, table);
955 
956         ls->ls_ops = lm;
957         ls->ls_first = 1;
958 
959         for (options = args->ar_hostdata; (o = strsep(&options, ":")); ) {
960                 substring_t tmp[MAX_OPT_ARGS];
961                 int token, option;
962 
963                 if (!o || !*o)
964                         continue;
965 
966                 token = match_token(o, *lm->lm_tokens, tmp);
967                 switch (token) {
968                 case Opt_jid:
969                         ret = match_int(&tmp[0], &option);
970                         if (ret || option < 0) 
971                                 goto hostdata_error;
972                         if (test_and_clear_bit(SDF_NOJOURNALID, &sdp->sd_flags))
973                                 ls->ls_jid = option;
974                         break;
975                 case Opt_id:
976                 case Opt_nodir:
977                         /* Obsolete, but left for backward compat purposes */
978                         break;
979                 case Opt_first:
980                         ret = match_int(&tmp[0], &option);
981                         if (ret || (option != 0 && option != 1))
982                                 goto hostdata_error;
983                         ls->ls_first = option;
984                         break;
985                 case Opt_err:
986                 default:
987 hostdata_error:
988                         fs_info(sdp, "unknown hostdata (%s)\n", o);
989                         return -EINVAL;
990                 }
991         }
992 
993         if (lm->lm_mount == NULL) {
994                 fs_info(sdp, "Now mounting FS...\n");
995                 complete_all(&sdp->sd_locking_init);
996                 return 0;
997         }
998         ret = lm->lm_mount(sdp, table);
999         if (ret == 0)
1000                 fs_info(sdp, "Joined cluster. Now mounting FS...\n");
1001         complete_all(&sdp->sd_locking_init);
1002         return ret;
1003 }
1004 
1005 void gfs2_lm_unmount(struct gfs2_sbd *sdp)
1006 {
1007         const struct lm_lockops *lm = sdp->sd_lockstruct.ls_ops;
1008         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)) &&
1009             lm->lm_unmount)
1010                 lm->lm_unmount(sdp);
1011 }
1012 
1013 static int gfs2_journalid_wait(void *word)
1014 {
1015         if (signal_pending(current))
1016                 return -EINTR;
1017         schedule();
1018         return 0;
1019 }
1020 
1021 static int wait_on_journal(struct gfs2_sbd *sdp)
1022 {
1023         if (sdp->sd_lockstruct.ls_ops->lm_mount == NULL)
1024                 return 0;
1025 
1026         return wait_on_bit(&sdp->sd_flags, SDF_NOJOURNALID, gfs2_journalid_wait, TASK_INTERRUPTIBLE);
1027 }
1028 
1029 void gfs2_online_uevent(struct gfs2_sbd *sdp)
1030 {
1031         struct super_block *sb = sdp->sd_vfs;
1032         char ro[20];
1033         char spectator[20];
1034         char *envp[] = { ro, spectator, NULL };
1035         sprintf(ro, "RDONLY=%d", (sb->s_flags & MS_RDONLY) ? 1 : 0);
1036         sprintf(spectator, "SPECTATOR=%d", sdp->sd_args.ar_spectator ? 1 : 0);
1037         kobject_uevent_env(&sdp->sd_kobj, KOBJ_ONLINE, envp);
1038 }
1039 
1040 /**
1041  * fill_super - Read in superblock
1042  * @sb: The VFS superblock
1043  * @data: Mount options
1044  * @silent: Don't complain if it's not a GFS2 filesystem
1045  *
1046  * Returns: errno
1047  */
1048 
1049 static int fill_super(struct super_block *sb, struct gfs2_args *args, int silent)
1050 {
1051         struct gfs2_sbd *sdp;
1052         struct gfs2_holder mount_gh;
1053         int error;
1054 
1055         sdp = init_sbd(sb);
1056         if (!sdp) {
1057                 pr_warn("can't alloc struct gfs2_sbd\n");
1058                 return -ENOMEM;
1059         }
1060         sdp->sd_args = *args;
1061 
1062         if (sdp->sd_args.ar_spectator) {
1063                 sb->s_flags |= MS_RDONLY;
1064                 set_bit(SDF_RORECOVERY, &sdp->sd_flags);
1065         }
1066         if (sdp->sd_args.ar_posix_acl)
1067                 sb->s_flags |= MS_POSIXACL;
1068         if (sdp->sd_args.ar_nobarrier)
1069                 set_bit(SDF_NOBARRIERS, &sdp->sd_flags);
1070 
1071         sb->s_flags |= MS_NOSEC;
1072         sb->s_magic = GFS2_MAGIC;
1073         sb->s_op = &gfs2_super_ops;
1074         sb->s_d_op = &gfs2_dops;
1075         sb->s_export_op = &gfs2_export_ops;
1076         sb->s_xattr = gfs2_xattr_handlers;
1077         sb->s_qcop = &gfs2_quotactl_ops;
1078         sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;
1079         sb->s_time_gran = 1;
1080         sb->s_maxbytes = MAX_LFS_FILESIZE;
1081 
1082         /* Set up the buffer cache and fill in some fake block size values
1083            to allow us to read-in the on-disk superblock. */
1084         sdp->sd_sb.sb_bsize = sb_min_blocksize(sb, GFS2_BASIC_BLOCK);
1085         sdp->sd_sb.sb_bsize_shift = sb->s_blocksize_bits;
1086         sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift -
1087                                GFS2_BASIC_BLOCK_SHIFT;
1088         sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
1089 
1090         sdp->sd_tune.gt_logd_secs = sdp->sd_args.ar_commit;
1091         sdp->sd_tune.gt_quota_quantum = sdp->sd_args.ar_quota_quantum;
1092         if (sdp->sd_args.ar_statfs_quantum) {
1093                 sdp->sd_tune.gt_statfs_slow = 0;
1094                 sdp->sd_tune.gt_statfs_quantum = sdp->sd_args.ar_statfs_quantum;
1095         } else {
1096                 sdp->sd_tune.gt_statfs_slow = 1;
1097                 sdp->sd_tune.gt_statfs_quantum = 30;
1098         }
1099 
1100         error = init_names(sdp, silent);
1101         if (error) {
1102                 /* In this case, we haven't initialized sysfs, so we have to
1103                    manually free the sdp. */
1104                 free_percpu(sdp->sd_lkstats);
1105                 kfree(sdp);
1106                 sb->s_fs_info = NULL;
1107                 return error;
1108         }
1109 
1110         snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s", sdp->sd_table_name);
1111 
1112         error = gfs2_sys_fs_add(sdp);
1113         /*
1114          * If we hit an error here, gfs2_sys_fs_add will have called function
1115          * kobject_put which causes the sysfs usage count to go to zero, which
1116          * causes sysfs to call function gfs2_sbd_release, which frees sdp.
1117          * Subsequent error paths here will call gfs2_sys_fs_del, which also
1118          * kobject_put to free sdp.
1119          */
1120         if (error)
1121                 return error;
1122 
1123         gfs2_create_debugfs_file(sdp);
1124 
1125         error = gfs2_lm_mount(sdp, silent);
1126         if (error)
1127                 goto fail_debug;
1128 
1129         error = init_locking(sdp, &mount_gh, DO);
1130         if (error)
1131                 goto fail_lm;
1132 
1133         error = init_sb(sdp, silent);
1134         if (error)
1135                 goto fail_locking;
1136 
1137         error = wait_on_journal(sdp);
1138         if (error)
1139                 goto fail_sb;
1140 
1141         /*
1142          * If user space has failed to join the cluster or some similar
1143          * failure has occurred, then the journal id will contain a
1144          * negative (error) number. This will then be returned to the
1145          * caller (of the mount syscall). We do this even for spectator
1146          * mounts (which just write a jid of 0 to indicate "ok" even though
1147          * the jid is unused in the spectator case)
1148          */
1149         if (sdp->sd_lockstruct.ls_jid < 0) {
1150                 error = sdp->sd_lockstruct.ls_jid;
1151                 sdp->sd_lockstruct.ls_jid = 0;
1152                 goto fail_sb;
1153         }
1154 
1155         if (sdp->sd_args.ar_spectator)
1156                 snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.s",
1157                          sdp->sd_table_name);
1158         else
1159                 snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.%u",
1160                          sdp->sd_table_name, sdp->sd_lockstruct.ls_jid);
1161 
1162         error = init_inodes(sdp, DO);
1163         if (error)
1164                 goto fail_sb;
1165 
1166         error = init_per_node(sdp, DO);
1167         if (error)
1168                 goto fail_inodes;
1169 
1170         error = gfs2_statfs_init(sdp);
1171         if (error) {
1172                 fs_err(sdp, "can't initialize statfs subsystem: %d\n", error);
1173                 goto fail_per_node;
1174         }
1175 
1176         if (!(sb->s_flags & MS_RDONLY)) {
1177                 error = gfs2_make_fs_rw(sdp);
1178                 if (error) {
1179                         fs_err(sdp, "can't make FS RW: %d\n", error);
1180                         goto fail_per_node;
1181                 }
1182         }
1183 
1184         gfs2_glock_dq_uninit(&mount_gh);
1185         gfs2_online_uevent(sdp);
1186         return 0;
1187 
1188 fail_per_node:
1189         init_per_node(sdp, UNDO);
1190 fail_inodes:
1191         init_inodes(sdp, UNDO);
1192 fail_sb:
1193         if (sdp->sd_root_dir)
1194                 dput(sdp->sd_root_dir);
1195         if (sdp->sd_master_dir)
1196                 dput(sdp->sd_master_dir);
1197         if (sb->s_root)
1198                 dput(sb->s_root);
1199         sb->s_root = NULL;
1200 fail_locking:
1201         init_locking(sdp, &mount_gh, UNDO);
1202 fail_lm:
1203         gfs2_gl_hash_clear(sdp);
1204         gfs2_lm_unmount(sdp);
1205 fail_debug:
1206         gfs2_delete_debugfs_file(sdp);
1207         free_percpu(sdp->sd_lkstats);
1208         /* gfs2_sys_fs_del must be the last thing we do, since it causes
1209          * sysfs to call function gfs2_sbd_release, which frees sdp. */
1210         gfs2_sys_fs_del(sdp);
1211         sb->s_fs_info = NULL;
1212         return error;
1213 }
1214 
1215 static int set_gfs2_super(struct super_block *s, void *data)
1216 {
1217         s->s_bdev = data;
1218         s->s_dev = s->s_bdev->bd_dev;
1219 
1220         /*
1221          * We set the bdi here to the queue backing, file systems can
1222          * overwrite this in ->fill_super()
1223          */
1224         s->s_bdi = &bdev_get_queue(s->s_bdev)->backing_dev_info;
1225         return 0;
1226 }
1227 
1228 static int test_gfs2_super(struct super_block *s, void *ptr)
1229 {
1230         struct block_device *bdev = ptr;
1231         return (bdev == s->s_bdev);
1232 }
1233 
1234 /**
1235  * gfs2_mount - Get the GFS2 superblock
1236  * @fs_type: The GFS2 filesystem type
1237  * @flags: Mount flags
1238  * @dev_name: The name of the device
1239  * @data: The mount arguments
1240  *
1241  * Q. Why not use get_sb_bdev() ?
1242  * A. We need to select one of two root directories to mount, independent
1243  *    of whether this is the initial, or subsequent, mount of this sb
1244  *
1245  * Returns: 0 or -ve on error
1246  */
1247 
1248 static struct dentry *gfs2_mount(struct file_system_type *fs_type, int flags,
1249                        const char *dev_name, void *data)
1250 {
1251         struct block_device *bdev;
1252         struct super_block *s;
1253         fmode_t mode = FMODE_READ | FMODE_EXCL;
1254         int error;
1255         struct gfs2_args args;
1256         struct gfs2_sbd *sdp;
1257 
1258         if (!(flags & MS_RDONLY))
1259                 mode |= FMODE_WRITE;
1260 
1261         bdev = blkdev_get_by_path(dev_name, mode, fs_type);
1262         if (IS_ERR(bdev))
1263                 return ERR_CAST(bdev);
1264 
1265         /*
1266          * once the super is inserted into the list by sget, s_umount
1267          * will protect the lockfs code from trying to start a snapshot
1268          * while we are mounting
1269          */
1270         mutex_lock(&bdev->bd_fsfreeze_mutex);
1271         if (bdev->bd_fsfreeze_count > 0) {
1272                 mutex_unlock(&bdev->bd_fsfreeze_mutex);
1273                 error = -EBUSY;
1274                 goto error_bdev;
1275         }
1276         s = sget(fs_type, test_gfs2_super, set_gfs2_super, flags, bdev);
1277         mutex_unlock(&bdev->bd_fsfreeze_mutex);
1278         error = PTR_ERR(s);
1279         if (IS_ERR(s))
1280                 goto error_bdev;
1281 
1282         if (s->s_root) {
1283                 /*
1284                  * s_umount nests inside bd_mutex during
1285                  * __invalidate_device().  blkdev_put() acquires
1286                  * bd_mutex and can't be called under s_umount.  Drop
1287                  * s_umount temporarily.  This is safe as we're
1288                  * holding an active reference.
1289                  */
1290                 up_write(&s->s_umount);
1291                 blkdev_put(bdev, mode);
1292                 down_write(&s->s_umount);
1293         }
1294 
1295         memset(&args, 0, sizeof(args));
1296         args.ar_quota = GFS2_QUOTA_DEFAULT;
1297         args.ar_data = GFS2_DATA_DEFAULT;
1298         args.ar_commit = 30;
1299         args.ar_statfs_quantum = 30;
1300         args.ar_quota_quantum = 60;
1301         args.ar_errors = GFS2_ERRORS_DEFAULT;
1302 
1303         error = gfs2_mount_args(&args, data);
1304         if (error) {
1305                 pr_warn("can't parse mount arguments\n");
1306                 goto error_super;
1307         }
1308 
1309         if (s->s_root) {
1310                 error = -EBUSY;
1311                 if ((flags ^ s->s_flags) & MS_RDONLY)
1312                         goto error_super;
1313         } else {
1314                 char b[BDEVNAME_SIZE];
1315 
1316                 s->s_mode = mode;
1317                 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1318                 sb_set_blocksize(s, block_size(bdev));
1319                 error = fill_super(s, &args, flags & MS_SILENT ? 1 : 0);
1320                 if (error)
1321                         goto error_super;
1322                 s->s_flags |= MS_ACTIVE;
1323                 bdev->bd_super = s;
1324         }
1325 
1326         sdp = s->s_fs_info;
1327         if (args.ar_meta)
1328                 return dget(sdp->sd_master_dir);
1329         else
1330                 return dget(sdp->sd_root_dir);
1331 
1332 error_super:
1333         deactivate_locked_super(s);
1334         return ERR_PTR(error);
1335 error_bdev:
1336         blkdev_put(bdev, mode);
1337         return ERR_PTR(error);
1338 }
1339 
1340 static int set_meta_super(struct super_block *s, void *ptr)
1341 {
1342         return -EINVAL;
1343 }
1344 
1345 static struct dentry *gfs2_mount_meta(struct file_system_type *fs_type,
1346                         int flags, const char *dev_name, void *data)
1347 {
1348         struct super_block *s;
1349         struct gfs2_sbd *sdp;
1350         struct path path;
1351         int error;
1352 
1353         error = kern_path(dev_name, LOOKUP_FOLLOW, &path);
1354         if (error) {
1355                 pr_warn("path_lookup on %s returned error %d\n",
1356                         dev_name, error);
1357                 return ERR_PTR(error);
1358         }
1359         s = sget(&gfs2_fs_type, test_gfs2_super, set_meta_super, flags,
1360                  path.dentry->d_inode->i_sb->s_bdev);
1361         path_put(&path);
1362         if (IS_ERR(s)) {
1363                 pr_warn("gfs2 mount does not exist\n");
1364                 return ERR_CAST(s);
1365         }
1366         if ((flags ^ s->s_flags) & MS_RDONLY) {
1367                 deactivate_locked_super(s);
1368                 return ERR_PTR(-EBUSY);
1369         }
1370         sdp = s->s_fs_info;
1371         return dget(sdp->sd_master_dir);
1372 }
1373 
1374 static void gfs2_kill_sb(struct super_block *sb)
1375 {
1376         struct gfs2_sbd *sdp = sb->s_fs_info;
1377 
1378         if (sdp == NULL) {
1379                 kill_block_super(sb);
1380                 return;
1381         }
1382 
1383         gfs2_meta_syncfs(sdp);
1384         dput(sdp->sd_root_dir);
1385         dput(sdp->sd_master_dir);
1386         sdp->sd_root_dir = NULL;
1387         sdp->sd_master_dir = NULL;
1388         shrink_dcache_sb(sb);
1389         gfs2_delete_debugfs_file(sdp);
1390         free_percpu(sdp->sd_lkstats);
1391         kill_block_super(sb);
1392 }
1393 
1394 struct file_system_type gfs2_fs_type = {
1395         .name = "gfs2",
1396         .fs_flags = FS_REQUIRES_DEV,
1397         .mount = gfs2_mount,
1398         .kill_sb = gfs2_kill_sb,
1399         .owner = THIS_MODULE,
1400 };
1401 MODULE_ALIAS_FS("gfs2");
1402 
1403 struct file_system_type gfs2meta_fs_type = {
1404         .name = "gfs2meta",
1405         .fs_flags = FS_REQUIRES_DEV,
1406         .mount = gfs2_mount_meta,
1407         .owner = THIS_MODULE,
1408 };
1409 MODULE_ALIAS_FS("gfs2meta");
1410 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us