fs/gfs2/lock_dlm.c

   1 /*
   2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
   3  * Copyright (C) 2004-2009 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/fs.h>
  11 #include <linux/dlm.h>
  12 #include <linux/types.h>
  13 #include <linux/gfs2_ondisk.h>
  14
  15 #include "incore.h"
  16 #include "glock.h"
  17 #include "util.h"
  18
  19
  20 static void gdlm_ast(void *arg)
  21 {
  22         struct gfs2_glock *gl = arg;
  23         unsigned ret = gl->gl_state;
  24
  25         BUG_ON(gl->gl_lksb.sb_flags & DLM_SBF_DEMOTED);
  26
  27         if (gl->gl_lksb.sb_flags & DLM_SBF_VALNOTVALID)
  28                 memset(gl->gl_lvb, 0, GDLM_LVB_SIZE);
  29
  30         switch (gl->gl_lksb.sb_status) {
  31         case -DLM_EUNLOCK: /* Unlocked, so glock can be freed */
  32                 kmem_cache_free(gfs2_glock_cachep, gl);
  33                 return;
  34         case -DLM_ECANCEL: /* Cancel while getting lock */
  35                 ret |= LM_OUT_CANCELED;
  36                 goto out;
  37         case -EAGAIN: /* Try lock fails */
  38                 goto out;
  39         case -EINVAL: /* Invalid */
  40         case -ENOMEM: /* Out of memory */
  41                 ret |= LM_OUT_ERROR;
  42                 goto out;
  43         case 0: /* Success */
  44                 break;
  45         default: /* Something unexpected */
  46                 BUG();
  47         }
  48
  49         ret = gl->gl_req;
  50         if (gl->gl_lksb.sb_flags & DLM_SBF_ALTMODE) {
  51                 if (gl->gl_req == LM_ST_SHARED)
  52                         ret = LM_ST_DEFERRED;
  53                 else if (gl->gl_req == LM_ST_DEFERRED)
  54                         ret = LM_ST_SHARED;
  55                 else
  56                         BUG();
  57         }
  58
  59         set_bit(GLF_INITIAL, &gl->gl_flags);
  60         gfs2_glock_complete(gl, ret);
  61         return;
  62 out:
  63         if (!test_bit(GLF_INITIAL, &gl->gl_flags))
  64                 gl->gl_lksb.sb_lkid = 0;
  65         gfs2_glock_complete(gl, ret);
  66 }
  67
  68 static void gdlm_bast(void *arg, int mode)
  69 {
  70         struct gfs2_glock *gl = arg;
  71
  72         switch (mode) {
  73         case DLM_LOCK_EX:
  74                 gfs2_glock_cb(gl, LM_ST_UNLOCKED);
  75                 break;
  76         case DLM_LOCK_CW:
  77                 gfs2_glock_cb(gl, LM_ST_DEFERRED);
  78                 break;
  79         case DLM_LOCK_PR:
  80                 gfs2_glock_cb(gl, LM_ST_SHARED);
  81                 break;
  82         default:
  83                 printk(KERN_ERR "unknown bast mode %d", mode);
  84                 BUG();
  85         }
  86 }
  87
  88 /* convert gfs lock-state to dlm lock-mode */
  89
  90 static int make_mode(const unsigned int lmstate)
  91 {
  92         switch (lmstate) {
  93         case LM_ST_UNLOCKED:
  94                 return DLM_LOCK_NL;
  95         case LM_ST_EXCLUSIVE:
  96                 return DLM_LOCK_EX;
  97         case LM_ST_DEFERRED:
  98                 return DLM_LOCK_CW;
  99         case LM_ST_SHARED:
 100                 return DLM_LOCK_PR;
 101         }
 102         printk(KERN_ERR "unknown LM state %d", lmstate);
 103         BUG();
 104         return -1;
 105 }
 106
 107 static u32 make_flags(const u32 lkid, const unsigned int gfs_flags,
 108                       const int req)
 109 {
 110         u32 lkf = 0;
 111
 112         if (gfs_flags & LM_FLAG_TRY)
 113                 lkf |= DLM_LKF_NOQUEUE;
 114
 115         if (gfs_flags & LM_FLAG_TRY_1CB) {
 116                 lkf |= DLM_LKF_NOQUEUE;
 117                 lkf |= DLM_LKF_NOQUEUEBAST;
 118         }
 119
 120         if (gfs_flags & LM_FLAG_PRIORITY) {
 121                 lkf |= DLM_LKF_NOORDER;
 122                 lkf |= DLM_LKF_HEADQUE;
 123         }
 124
 125         if (gfs_flags & LM_FLAG_ANY) {
 126                 if (req == DLM_LOCK_PR)
 127                         lkf |= DLM_LKF_ALTCW;
 128                 else if (req == DLM_LOCK_CW)
 129                         lkf |= DLM_LKF_ALTPR;
 130                 else
 131                         BUG();
 132         }
 133
 134         if (lkid != 0)
 135                 lkf |= DLM_LKF_CONVERT;
 136
 137         lkf |= DLM_LKF_VALBLK;
 138
 139         return lkf;
 140 }
 141
 142 static unsigned int gdlm_lock(struct gfs2_glock *gl,
 143                               unsigned int req_state, unsigned int flags)
 144 {
 145         struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct;
 146         int error;
 147         int req;
 148         u32 lkf;
 149
 150         gl->gl_req = req_state;
 151         req = make_mode(req_state);
 152         lkf = make_flags(gl->gl_lksb.sb_lkid, flags, req);
 153
 154         /*
 155          * Submit the actual lock request.
 156          */
 157
 158         error = dlm_lock(ls->ls_dlm, req, &gl->gl_lksb, lkf, gl->gl_strname,
 159                          GDLM_STRNAME_BYTES - 1, 0, gdlm_ast, gl, gdlm_bast);
 160         if (error == -EAGAIN)
 161                 return 0;
 162         if (error)
 163                 return LM_OUT_ERROR;
 164         return LM_OUT_ASYNC;
 165 }
 166
 167 static void gdlm_put_lock(struct kmem_cache *cachep, void *ptr)
 168 {
 169         struct gfs2_glock *gl = ptr;
 170         struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct;
 171         int error;
 172
 173         if (gl->gl_lksb.sb_lkid == 0) {
 174                 kmem_cache_free(cachep, gl);
 175                 return;
 176         }
 177
 178         error = dlm_unlock(ls->ls_dlm, gl->gl_lksb.sb_lkid, DLM_LKF_VALBLK,
 179                            NULL, gl);
 180         if (error) {
 181                 printk(KERN_ERR "gdlm_unlock %x,%llx err=%d\n",
 182                        gl->gl_name.ln_type,
 183                        (unsigned long long)gl->gl_name.ln_number, error);
 184                 return;
 185         }
 186 }
 187
 188 static void gdlm_cancel(struct gfs2_glock *gl)
 189 {
 190         struct lm_lockstruct *ls = &gl->gl_sbd->sd_lockstruct;
 191         dlm_unlock(ls->ls_dlm, gl->gl_lksb.sb_lkid, DLM_LKF_CANCEL, NULL, gl);
 192 }
 193
 194 static int gdlm_mount(struct gfs2_sbd *sdp, const char *fsname)
 195 {
 196         struct lm_lockstruct *ls = &sdp->sd_lockstruct;
 197         int error;
 198
 199         if (fsname == NULL) {
 200                 fs_info(sdp, "no fsname found\n");
 201                 return -EINVAL;
 202         }
 203
 204         error = dlm_new_lockspace(fsname, strlen(fsname), &ls->ls_dlm,
 205                                   DLM_LSFL_FS | DLM_LSFL_NEWEXCL |
 206                                   (ls->ls_nodir ? DLM_LSFL_NODIR : 0),
 207                                   GDLM_LVB_SIZE);
 208         if (error)
 209                 printk(KERN_ERR "dlm_new_lockspace error %d", error);
 210
 211         return error;
 212 }
 213
 214 static void gdlm_unmount(struct gfs2_sbd *sdp)
 215 {
 216         struct lm_lockstruct *ls = &sdp->sd_lockstruct;
 217
 218         if (ls->ls_dlm) {
 219                 dlm_release_lockspace(ls->ls_dlm, 2);
 220                 ls->ls_dlm = NULL;
 221         }
 222 }
 223
 224 static const match_table_t dlm_tokens = {
 225         { Opt_jid, "jid=%d"},
 226         { Opt_id, "id=%d"},
 227         { Opt_first, "first=%d"},
 228         { Opt_nodir, "nodir=%d"},
 229         { Opt_err, NULL },
 230 };
 231
 232 const struct lm_lockops gfs2_dlm_ops = {
 233         .lm_proto_name = "lock_dlm",
 234         .lm_mount = gdlm_mount,
 235         .lm_unmount = gdlm_unmount,
 236         .lm_put_lock = gdlm_put_lock,
 237         .lm_lock = gdlm_lock,
 238         .lm_cancel = gdlm_cancel,
 239         .lm_tokens = &dlm_tokens,
 240 };
 241