fs/gfs2/lm.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2006 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/delay.h>
  16 #include <linux/gfs2_ondisk.h>
  17
  18 #include "gfs2.h"
  19 #include "lm_interface.h"
  20 #include "incore.h"
  21 #include "glock.h"
  22 #include "lm.h"
  23 #include "super.h"
  24 #include "util.h"
  25 #include "lvb.h"
  26
  27 /**
  28  * gfs2_lm_mount - mount a locking protocol
  29  * @sdp: the filesystem
  30  * @args: mount arguements
  31  * @silent: if 1, don't complain if the FS isn't a GFS2 fs
  32  *
  33  * Returns: errno
  34  */
  35
  36 int gfs2_lm_mount(struct gfs2_sbd *sdp, int silent)
  37 {
  38         char *proto = sdp->sd_proto_name;
  39         char *table = sdp->sd_table_name;
  40         int flags = 0;
  41         int error;
  42
  43         if (sdp->sd_args.ar_spectator)
  44                 flags |= LM_MFLAG_SPECTATOR;
  45
  46         fs_info(sdp, "Trying to join cluster \"%s\", \"%s\"\n", proto, table);
  47
  48         error = gfs2_mount_lockproto(proto, table, sdp->sd_args.ar_hostdata,
  49                                      gfs2_glock_cb, sdp,
  50                                      GFS2_MIN_LVB_SIZE, flags,
  51                                      &sdp->sd_lockstruct, &sdp->sd_kobj);
  52         if (error) {
  53                 fs_info(sdp, "can't mount proto=%s, table=%s, hostdata=%s\n",
  54                         proto, table, sdp->sd_args.ar_hostdata);
  55                 goto out;
  56         }
  57
  58         if (gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_lockspace) ||
  59             gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_ops) ||
  60             gfs2_assert_warn(sdp, sdp->sd_lockstruct.ls_lvb_size >=
  61                                   GFS2_MIN_LVB_SIZE)) {
  62                 gfs2_unmount_lockproto(&sdp->sd_lockstruct);
  63                 goto out;
  64         }
  65
  66         if (sdp->sd_args.ar_spectator)
  67                 snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.s", table);
  68         else
  69                 snprintf(sdp->sd_fsname, GFS2_FSNAME_LEN, "%s.%u", table,
  70                          sdp->sd_lockstruct.ls_jid);
  71
  72         fs_info(sdp, "Joined cluster. Now mounting FS...\n");
  73
  74         if ((sdp->sd_lockstruct.ls_flags & LM_LSFLAG_LOCAL) &&
  75             !sdp->sd_args.ar_ignore_local_fs) {
  76                 sdp->sd_args.ar_localflocks = 1;
  77                 sdp->sd_args.ar_localcaching = 1;
  78         }
  79
  80  out:
  81         return error;
  82 }
  83
  84 void gfs2_lm_others_may_mount(struct gfs2_sbd *sdp)
  85 {
  86         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
  87                 sdp->sd_lockstruct.ls_ops->lm_others_may_mount(
  88                                         sdp->sd_lockstruct.ls_lockspace);
  89 }
  90
  91 void gfs2_lm_unmount(struct gfs2_sbd *sdp)
  92 {
  93         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
  94                 gfs2_unmount_lockproto(&sdp->sd_lockstruct);
  95 }
  96
  97 int gfs2_lm_withdraw(struct gfs2_sbd *sdp, char *fmt, ...)
  98 {
  99         va_list args;
 100
 101         if (test_and_set_bit(SDF_SHUTDOWN, &sdp->sd_flags))
 102                 return 0;
 103
 104         va_start(args, fmt);
 105         vprintk(fmt, args);
 106         va_end(args);
 107
 108         fs_err(sdp, "about to withdraw from the cluster\n");
 109         BUG_ON(sdp->sd_args.ar_debug);
 110
 111
 112         fs_err(sdp, "waiting for outstanding I/O\n");
 113
 114         /* FIXME: suspend dm device so oustanding bio's complete
 115            and all further io requests fail */
 116
 117         fs_err(sdp, "telling LM to withdraw\n");
 118         gfs2_withdraw_lockproto(&sdp->sd_lockstruct);
 119         fs_err(sdp, "withdrawn\n");
 120         dump_stack();
 121
 122         return -1;
 123 }
 124
 125 int gfs2_lm_get_lock(struct gfs2_sbd *sdp, struct lm_lockname *name,
 126                      lm_lock_t **lockp)
 127 {
 128         int error;
 129         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 130                 error = -EIO;
 131         else
 132                 error = sdp->sd_lockstruct.ls_ops->lm_get_lock(
 133                                 sdp->sd_lockstruct.ls_lockspace, name, lockp);
 134         return error;
 135 }
 136
 137 void gfs2_lm_put_lock(struct gfs2_sbd *sdp, lm_lock_t *lock)
 138 {
 139         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 140                 sdp->sd_lockstruct.ls_ops->lm_put_lock(lock);
 141 }
 142
 143 unsigned int gfs2_lm_lock(struct gfs2_sbd *sdp, lm_lock_t *lock,
 144                           unsigned int cur_state, unsigned int req_state,
 145                           unsigned int flags)
 146 {
 147         int ret;
 148         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 149                 ret = 0;
 150         else
 151                 ret = sdp->sd_lockstruct.ls_ops->lm_lock(lock,
 152                                                          cur_state,
 153                                                          req_state, flags);
 154         return ret;
 155 }
 156
 157 unsigned int gfs2_lm_unlock(struct gfs2_sbd *sdp, lm_lock_t *lock,
 158                             unsigned int cur_state)
 159 {
 160         int ret;
 161         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 162                 ret = 0;
 163         else
 164                 ret =  sdp->sd_lockstruct.ls_ops->lm_unlock(lock, cur_state);
 165         return ret;
 166 }
 167
 168 void gfs2_lm_cancel(struct gfs2_sbd *sdp, lm_lock_t *lock)
 169 {
 170         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 171                 sdp->sd_lockstruct.ls_ops->lm_cancel(lock);
 172 }
 173
 174 int gfs2_lm_hold_lvb(struct gfs2_sbd *sdp, lm_lock_t *lock, char **lvbp)
 175 {
 176         int error;
 177         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 178                 error = -EIO;
 179         else
 180                 error = sdp->sd_lockstruct.ls_ops->lm_hold_lvb(lock, lvbp);
 181         return error;
 182 }
 183
 184 void gfs2_lm_unhold_lvb(struct gfs2_sbd *sdp, lm_lock_t *lock, char *lvb)
 185 {
 186         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 187                 sdp->sd_lockstruct.ls_ops->lm_unhold_lvb(lock, lvb);
 188 }
 189
 190 #if 0
 191 void gfs2_lm_sync_lvb(struct gfs2_sbd *sdp, lm_lock_t *lock, char *lvb)
 192 {
 193         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 194                 sdp->sd_lockstruct.ls_ops->lm_sync_lvb(lock, lvb);
 195 }
 196 #endif  /*  0  */
 197
 198 int gfs2_lm_plock_get(struct gfs2_sbd *sdp, struct lm_lockname *name,
 199                       struct file *file, struct file_lock *fl)
 200 {
 201         int error;
 202         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 203                 error = -EIO;
 204         else
 205                 error = sdp->sd_lockstruct.ls_ops->lm_plock_get(
 206                         sdp->sd_lockstruct.ls_lockspace,
 207                         name, file, fl);
 208         return error;
 209 }
 210
 211 int gfs2_lm_plock(struct gfs2_sbd *sdp, struct lm_lockname *name,
 212                   struct file *file, int cmd, struct file_lock *fl)
 213 {
 214         int error;
 215         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 216                 error = -EIO;
 217         else
 218                 error = sdp->sd_lockstruct.ls_ops->lm_plock(
 219                         sdp->sd_lockstruct.ls_lockspace,
 220                         name, file, cmd, fl);
 221         return error;
 222 }
 223
 224 int gfs2_lm_punlock(struct gfs2_sbd *sdp, struct lm_lockname *name,
 225                     struct file *file, struct file_lock *fl)
 226 {
 227         int error;
 228         if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 229                 error = -EIO;
 230         else
 231                 error = sdp->sd_lockstruct.ls_ops->lm_punlock(
 232                         sdp->sd_lockstruct.ls_lockspace,
 233                         name, file, fl);
 234         return error;
 235 }
 236
 237 void gfs2_lm_recovery_done(struct gfs2_sbd *sdp, unsigned int jid,
 238                            unsigned int message)
 239 {
 240         if (likely(!test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
 241                 sdp->sd_lockstruct.ls_ops->lm_recovery_done(
 242                         sdp->sd_lockstruct.ls_lockspace, jid, message);
 243 }
 244