git.oblomov.eu Git - linux-2.6/blob - fs/gfs2/super.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2007 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 #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/crc32.h>
  16 #include <linux/gfs2_ondisk.h>
  17 #include <linux/bio.h>
  18 #include <linux/lm_interface.h>
  19
  20 #include "gfs2.h"
  21 #include "incore.h"
  22 #include "bmap.h"
  23 #include "dir.h"
  24 #include "glock.h"
  25 #include "glops.h"
  26 #include "inode.h"
  27 #include "log.h"
  28 #include "meta_io.h"
  29 #include "quota.h"
  30 #include "recovery.h"
  31 #include "rgrp.h"
  32 #include "super.h"
  33 #include "trans.h"
  34 #include "util.h"
  35
  36 /**
  37  * gfs2_jindex_free - Clear all the journal index information
  38  * @sdp: The GFS2 superblock
  39  *
  40  */
  41
  42 void gfs2_jindex_free(struct gfs2_sbd *sdp)
  43 {
  44         struct list_head list, *head;
  45         struct gfs2_jdesc *jd;
  46         struct gfs2_journal_extent *jext;
  47
  48         spin_lock(&sdp->sd_jindex_spin);
  49         list_add(&list, &sdp->sd_jindex_list);
  50         list_del_init(&sdp->sd_jindex_list);
  51         sdp->sd_journals = 0;
  52         spin_unlock(&sdp->sd_jindex_spin);
  53
  54         while (!list_empty(&list)) {
  55                 jd = list_entry(list.next, struct gfs2_jdesc, jd_list);
  56                 head = &jd->extent_list;
  57                 while (!list_empty(head)) {
  58                         jext = list_entry(head->next,
  59                                           struct gfs2_journal_extent,
  60                                           extent_list);
  61                         list_del(&jext->extent_list);
  62                         kfree(jext);
  63                 }
  64                 list_del(&jd->jd_list);
  65                 iput(jd->jd_inode);
  66                 kfree(jd);
  67         }
  68 }
  69
  70 static struct gfs2_jdesc *jdesc_find_i(struct list_head *head, unsigned int jid)
  71 {
  72         struct gfs2_jdesc *jd;
  73         int found = 0;
  74
  75         list_for_each_entry(jd, head, jd_list) {
  76                 if (jd->jd_jid == jid) {
  77                         found = 1;
  78                         break;
  79                 }
  80         }
  81
  82         if (!found)
  83                 jd = NULL;
  84
  85         return jd;
  86 }
  87
  88 struct gfs2_jdesc *gfs2_jdesc_find(struct gfs2_sbd *sdp, unsigned int jid)
  89 {
  90         struct gfs2_jdesc *jd;
  91
  92         spin_lock(&sdp->sd_jindex_spin);
  93         jd = jdesc_find_i(&sdp->sd_jindex_list, jid);
  94         spin_unlock(&sdp->sd_jindex_spin);
  95
  96         return jd;
  97 }
  98
  99 int gfs2_jdesc_check(struct gfs2_jdesc *jd)
 100 {
 101         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
 102         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
 103         int ar;
 104         int error;
 105
 106         if (ip->i_disksize < (8 << 20) || ip->i_disksize > (1 << 30) ||
 107             (ip->i_disksize & (sdp->sd_sb.sb_bsize - 1))) {
 108                 gfs2_consist_inode(ip);
 109                 return -EIO;
 110         }
 111         jd->jd_blocks = ip->i_disksize >> sdp->sd_sb.sb_bsize_shift;
 112
 113         error = gfs2_write_alloc_required(ip, 0, ip->i_disksize, &ar);
 114         if (!error && ar) {
 115                 gfs2_consist_inode(ip);
 116                 error = -EIO;
 117         }
 118
 119         return error;
 120 }
 121
 122 /**
 123  * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one
 124  * @sdp: the filesystem
 125  *
 126  * Returns: errno
 127  */
 128
 129 int gfs2_make_fs_rw(struct gfs2_sbd *sdp)
 130 {
 131         struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode);
 132         struct gfs2_glock *j_gl = ip->i_gl;
 133         struct gfs2_holder t_gh;
 134         struct gfs2_log_header_host head;
 135         int error;
 136
 137         error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, 0, &t_gh);
 138         if (error)
 139                 return error;
 140
 141         j_gl->gl_ops->go_inval(j_gl, DIO_METADATA);
 142
 143         error = gfs2_find_jhead(sdp->sd_jdesc, &head);
 144         if (error)
 145                 goto fail;
 146
 147         if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
 148                 gfs2_consist(sdp);
 149                 error = -EIO;
 150                 goto fail;
 151         }
 152
 153         /*  Initialize some head of the log stuff  */
 154         sdp->sd_log_sequence = head.lh_sequence + 1;
 155         gfs2_log_pointers_init(sdp, head.lh_blkno);
 156
 157         error = gfs2_quota_init(sdp);
 158         if (error)
 159                 goto fail;
 160
 161         set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
 162
 163         gfs2_glock_dq_uninit(&t_gh);
 164
 165         return 0;
 166
 167 fail:
 168         t_gh.gh_flags |= GL_NOCACHE;
 169         gfs2_glock_dq_uninit(&t_gh);
 170
 171         return error;
 172 }
 173
 174 static void gfs2_statfs_change_in(struct gfs2_statfs_change_host *sc, const void *buf)
 175 {
 176         const struct gfs2_statfs_change *str = buf;
 177
 178         sc->sc_total = be64_to_cpu(str->sc_total);
 179         sc->sc_free = be64_to_cpu(str->sc_free);
 180         sc->sc_dinodes = be64_to_cpu(str->sc_dinodes);
 181 }
 182
 183 static void gfs2_statfs_change_out(const struct gfs2_statfs_change_host *sc, void *buf)
 184 {
 185         struct gfs2_statfs_change *str = buf;
 186
 187         str->sc_total = cpu_to_be64(sc->sc_total);
 188         str->sc_free = cpu_to_be64(sc->sc_free);
 189         str->sc_dinodes = cpu_to_be64(sc->sc_dinodes);
 190 }
 191
 192 int gfs2_statfs_init(struct gfs2_sbd *sdp)
 193 {
 194         struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
 195         struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
 196         struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
 197         struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
 198         struct buffer_head *m_bh, *l_bh;
 199         struct gfs2_holder gh;
 200         int error;
 201
 202         error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE,
 203                                    &gh);
 204         if (error)
 205                 return error;
 206
 207         error = gfs2_meta_inode_buffer(m_ip, &m_bh);
 208         if (error)
 209                 goto out;
 210
 211         if (sdp->sd_args.ar_spectator) {
 212                 spin_lock(&sdp->sd_statfs_spin);
 213                 gfs2_statfs_change_in(m_sc, m_bh->b_data +
 214                                       sizeof(struct gfs2_dinode));
 215                 spin_unlock(&sdp->sd_statfs_spin);
 216         } else {
 217                 error = gfs2_meta_inode_buffer(l_ip, &l_bh);
 218                 if (error)
 219                         goto out_m_bh;
 220
 221                 spin_lock(&sdp->sd_statfs_spin);
 222                 gfs2_statfs_change_in(m_sc, m_bh->b_data +
 223                                       sizeof(struct gfs2_dinode));
 224                 gfs2_statfs_change_in(l_sc, l_bh->b_data +
 225                                       sizeof(struct gfs2_dinode));
 226                 spin_unlock(&sdp->sd_statfs_spin);
 227
 228                 brelse(l_bh);
 229         }
 230
 231 out_m_bh:
 232         brelse(m_bh);
 233 out:
 234         gfs2_glock_dq_uninit(&gh);
 235         return 0;
 236 }
 237
 238 void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free,
 239                         s64 dinodes)
 240 {
 241         struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
 242         struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
 243         struct buffer_head *l_bh;
 244         int error;
 245
 246         error = gfs2_meta_inode_buffer(l_ip, &l_bh);
 247         if (error)
 248                 return;
 249
 250         gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);
 251
 252         spin_lock(&sdp->sd_statfs_spin);
 253         l_sc->sc_total += total;
 254         l_sc->sc_free += free;
 255         l_sc->sc_dinodes += dinodes;
 256         gfs2_statfs_change_out(l_sc, l_bh->b_data + sizeof(struct gfs2_dinode));
 257         spin_unlock(&sdp->sd_statfs_spin);
 258
 259         brelse(l_bh);
 260 }
 261
 262 int gfs2_statfs_sync(struct gfs2_sbd *sdp)
 263 {
 264         struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode);
 265         struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode);
 266         struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
 267         struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
 268         struct gfs2_holder gh;
 269         struct buffer_head *m_bh, *l_bh;
 270         int error;
 271
 272         error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE,
 273                                    &gh);
 274         if (error)
 275                 return error;
 276
 277         error = gfs2_meta_inode_buffer(m_ip, &m_bh);
 278         if (error)
 279                 goto out;
 280
 281         spin_lock(&sdp->sd_statfs_spin);
 282         gfs2_statfs_change_in(m_sc, m_bh->b_data +
 283                               sizeof(struct gfs2_dinode));
 284         if (!l_sc->sc_total && !l_sc->sc_free && !l_sc->sc_dinodes) {
 285                 spin_unlock(&sdp->sd_statfs_spin);
 286                 goto out_bh;
 287         }
 288         spin_unlock(&sdp->sd_statfs_spin);
 289
 290         error = gfs2_meta_inode_buffer(l_ip, &l_bh);
 291         if (error)
 292                 goto out_bh;
 293
 294         error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0);
 295         if (error)
 296                 goto out_bh2;
 297
 298         gfs2_trans_add_bh(l_ip->i_gl, l_bh, 1);
 299
 300         spin_lock(&sdp->sd_statfs_spin);
 301         m_sc->sc_total += l_sc->sc_total;
 302         m_sc->sc_free += l_sc->sc_free;
 303         m_sc->sc_dinodes += l_sc->sc_dinodes;
 304         memset(l_sc, 0, sizeof(struct gfs2_statfs_change));
 305         memset(l_bh->b_data + sizeof(struct gfs2_dinode),
 306                0, sizeof(struct gfs2_statfs_change));
 307         spin_unlock(&sdp->sd_statfs_spin);
 308
 309         gfs2_trans_add_bh(m_ip->i_gl, m_bh, 1);
 310         gfs2_statfs_change_out(m_sc, m_bh->b_data + sizeof(struct gfs2_dinode));
 311
 312         gfs2_trans_end(sdp);
 313
 314 out_bh2:
 315         brelse(l_bh);
 316 out_bh:
 317         brelse(m_bh);
 318 out:
 319         gfs2_glock_dq_uninit(&gh);
 320         return error;
 321 }
 322
 323 struct lfcc {
 324         struct list_head list;
 325         struct gfs2_holder gh;
 326 };
 327
 328 /**
 329  * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all
 330  *                            journals are clean
 331  * @sdp: the file system
 332  * @state: the state to put the transaction lock into
 333  * @t_gh: the hold on the transaction lock
 334  *
 335  * Returns: errno
 336  */
 337
 338 static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp,
 339                                     struct gfs2_holder *t_gh)
 340 {
 341         struct gfs2_inode *ip;
 342         struct gfs2_holder ji_gh;
 343         struct gfs2_jdesc *jd;
 344         struct lfcc *lfcc;
 345         LIST_HEAD(list);
 346         struct gfs2_log_header_host lh;
 347         int error;
 348
 349         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
 350                 lfcc = kmalloc(sizeof(struct lfcc), GFP_KERNEL);
 351                 if (!lfcc) {
 352                         error = -ENOMEM;
 353                         goto out;
 354                 }
 355                 ip = GFS2_I(jd->jd_inode);
 356                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &lfcc->gh);
 357                 if (error) {
 358                         kfree(lfcc);
 359                         goto out;
 360                 }
 361                 list_add(&lfcc->list, &list);
 362         }
 363
 364         error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_DEFERRED,
 365                                    GL_NOCACHE, t_gh);
 366
 367         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
 368                 error = gfs2_jdesc_check(jd);
 369                 if (error)
 370                         break;
 371                 error = gfs2_find_jhead(jd, &lh);
 372                 if (error)
 373                         break;
 374                 if (!(lh.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) {
 375                         error = -EBUSY;
 376                         break;
 377                 }
 378         }
 379
 380         if (error)
 381                 gfs2_glock_dq_uninit(t_gh);
 382
 383 out:
 384         while (!list_empty(&list)) {
 385                 lfcc = list_entry(list.next, struct lfcc, list);
 386                 list_del(&lfcc->list);
 387                 gfs2_glock_dq_uninit(&lfcc->gh);
 388                 kfree(lfcc);
 389         }
 390         gfs2_glock_dq_uninit(&ji_gh);
 391         return error;
 392 }
 393
 394 /**
 395  * gfs2_freeze_fs - freezes the file system
 396  * @sdp: the file system
 397  *
 398  * This function flushes data and meta data for all machines by
 399  * aquiring the transaction log exclusively.  All journals are
 400  * ensured to be in a clean state as well.
 401  *
 402  * Returns: errno
 403  */
 404
 405 int gfs2_freeze_fs(struct gfs2_sbd *sdp)
 406 {
 407         int error = 0;
 408
 409         mutex_lock(&sdp->sd_freeze_lock);
 410
 411         if (!sdp->sd_freeze_count++) {
 412                 error = gfs2_lock_fs_check_clean(sdp, &sdp->sd_freeze_gh);
 413                 if (error)
 414                         sdp->sd_freeze_count--;
 415         }
 416
 417         mutex_unlock(&sdp->sd_freeze_lock);
 418
 419         return error;
 420 }
 421
 422 /**
 423  * gfs2_unfreeze_fs - unfreezes the file system
 424  * @sdp: the file system
 425  *
 426  * This function allows the file system to proceed by unlocking
 427  * the exclusively held transaction lock.  Other GFS2 nodes are
 428  * now free to acquire the lock shared and go on with their lives.
 429  *
 430  */
 431
 432 void gfs2_unfreeze_fs(struct gfs2_sbd *sdp)
 433 {
 434         mutex_lock(&sdp->sd_freeze_lock);
 435
 436         if (sdp->sd_freeze_count && !--sdp->sd_freeze_count)
 437                 gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);
 438
 439         mutex_unlock(&sdp->sd_freeze_lock);
 440 }
 441