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