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