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