David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. |
Steven Whitehouse | 3a8a9a1 | 2006-05-18 15:09:15 -0400 | [diff] [blame] | 3 | * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 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 |
Steven Whitehouse | e9fc2aa | 2006-09-01 11:05:15 -0400 | [diff] [blame] | 7 | * of the GNU General Public License version 2. |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 8 | */ |
| 9 | |
| 10 | #ifndef __GLOCK_DOT_H__ |
| 11 | #define __GLOCK_DOT_H__ |
| 12 | |
Alexey Dobriyan | e8edc6e | 2007-05-21 01:22:52 +0400 | [diff] [blame] | 13 | #include <linux/sched.h> |
Steven Whitehouse | f057f6c | 2009-01-12 10:43:39 +0000 | [diff] [blame] | 14 | #include <linux/parser.h> |
Steven Whitehouse | f2f7ba5 | 2006-09-05 10:39:21 -0400 | [diff] [blame] | 15 | #include "incore.h" |
| 16 | |
Steven Whitehouse | f057f6c | 2009-01-12 10:43:39 +0000 | [diff] [blame] | 17 | /* Options for hostdata parser */ |
| 18 | |
| 19 | enum { |
| 20 | Opt_jid, |
| 21 | Opt_id, |
| 22 | Opt_first, |
| 23 | Opt_nodir, |
| 24 | Opt_err, |
| 25 | }; |
| 26 | |
| 27 | /* |
| 28 | * lm_lockname types |
| 29 | */ |
| 30 | |
| 31 | #define LM_TYPE_RESERVED 0x00 |
| 32 | #define LM_TYPE_NONDISK 0x01 |
| 33 | #define LM_TYPE_INODE 0x02 |
| 34 | #define LM_TYPE_RGRP 0x03 |
| 35 | #define LM_TYPE_META 0x04 |
| 36 | #define LM_TYPE_IOPEN 0x05 |
| 37 | #define LM_TYPE_FLOCK 0x06 |
| 38 | #define LM_TYPE_PLOCK 0x07 |
| 39 | #define LM_TYPE_QUOTA 0x08 |
| 40 | #define LM_TYPE_JOURNAL 0x09 |
| 41 | |
| 42 | /* |
| 43 | * lm_lock() states |
| 44 | * |
| 45 | * SHARED is compatible with SHARED, not with DEFERRED or EX. |
| 46 | * DEFERRED is compatible with DEFERRED, not with SHARED or EX. |
| 47 | */ |
| 48 | |
| 49 | #define LM_ST_UNLOCKED 0 |
| 50 | #define LM_ST_EXCLUSIVE 1 |
| 51 | #define LM_ST_DEFERRED 2 |
| 52 | #define LM_ST_SHARED 3 |
| 53 | |
| 54 | /* |
| 55 | * lm_lock() flags |
| 56 | * |
| 57 | * LM_FLAG_TRY |
| 58 | * Don't wait to acquire the lock if it can't be granted immediately. |
| 59 | * |
| 60 | * LM_FLAG_TRY_1CB |
| 61 | * Send one blocking callback if TRY is set and the lock is not granted. |
| 62 | * |
| 63 | * LM_FLAG_NOEXP |
| 64 | * GFS sets this flag on lock requests it makes while doing journal recovery. |
| 65 | * These special requests should not be blocked due to the recovery like |
| 66 | * ordinary locks would be. |
| 67 | * |
| 68 | * LM_FLAG_ANY |
| 69 | * A SHARED request may also be granted in DEFERRED, or a DEFERRED request may |
| 70 | * also be granted in SHARED. The preferred state is whichever is compatible |
| 71 | * with other granted locks, or the specified state if no other locks exist. |
| 72 | * |
| 73 | * LM_FLAG_PRIORITY |
| 74 | * Override fairness considerations. Suppose a lock is held in a shared state |
| 75 | * and there is a pending request for the deferred state. A shared lock |
| 76 | * request with the priority flag would be allowed to bypass the deferred |
| 77 | * request and directly join the other shared lock. A shared lock request |
| 78 | * without the priority flag might be forced to wait until the deferred |
| 79 | * requested had acquired and released the lock. |
| 80 | */ |
| 81 | |
Bob Peterson | b58bf40 | 2015-07-24 09:45:43 -0500 | [diff] [blame^] | 82 | #define LM_FLAG_TRY 0x0001 |
| 83 | #define LM_FLAG_TRY_1CB 0x0002 |
| 84 | #define LM_FLAG_NOEXP 0x0004 |
| 85 | #define LM_FLAG_ANY 0x0008 |
| 86 | #define LM_FLAG_PRIORITY 0x0010 |
| 87 | #define GL_ASYNC 0x0040 |
| 88 | #define GL_EXACT 0x0080 |
| 89 | #define GL_SKIP 0x0100 |
| 90 | #define GL_NOCACHE 0x0400 |
Steven Whitehouse | f057f6c | 2009-01-12 10:43:39 +0000 | [diff] [blame] | 91 | |
| 92 | /* |
Steven Whitehouse | 921169c | 2010-11-29 12:50:38 +0000 | [diff] [blame] | 93 | * lm_async_cb return flags |
Steven Whitehouse | f057f6c | 2009-01-12 10:43:39 +0000 | [diff] [blame] | 94 | * |
| 95 | * LM_OUT_ST_MASK |
| 96 | * Masks the lower two bits of lock state in the returned value. |
| 97 | * |
| 98 | * LM_OUT_CANCELED |
| 99 | * The lock request was canceled. |
| 100 | * |
Steven Whitehouse | f057f6c | 2009-01-12 10:43:39 +0000 | [diff] [blame] | 101 | */ |
| 102 | |
| 103 | #define LM_OUT_ST_MASK 0x00000003 |
| 104 | #define LM_OUT_CANCELED 0x00000008 |
Steven Whitehouse | 921169c | 2010-11-29 12:50:38 +0000 | [diff] [blame] | 105 | #define LM_OUT_ERROR 0x00000004 |
Steven Whitehouse | f057f6c | 2009-01-12 10:43:39 +0000 | [diff] [blame] | 106 | |
| 107 | /* |
| 108 | * lm_recovery_done() messages |
| 109 | */ |
| 110 | |
| 111 | #define LM_RD_GAVEUP 308 |
| 112 | #define LM_RD_SUCCESS 309 |
| 113 | |
| 114 | #define GLR_TRYFAILED 13 |
| 115 | |
Bob Peterson | 7cf8dcd | 2011-06-15 11:41:48 -0400 | [diff] [blame] | 116 | #define GL_GLOCK_MAX_HOLD (long)(HZ / 5) |
| 117 | #define GL_GLOCK_DFT_HOLD (long)(HZ / 5) |
| 118 | #define GL_GLOCK_MIN_HOLD (long)(10) |
| 119 | #define GL_GLOCK_HOLD_INCR (long)(HZ / 20) |
| 120 | #define GL_GLOCK_HOLD_DECR (long)(HZ / 40) |
| 121 | |
Steven Whitehouse | f057f6c | 2009-01-12 10:43:39 +0000 | [diff] [blame] | 122 | struct lm_lockops { |
| 123 | const char *lm_proto_name; |
David Teigland | e0c2a9a | 2012-01-09 17:18:05 -0500 | [diff] [blame] | 124 | int (*lm_mount) (struct gfs2_sbd *sdp, const char *table); |
| 125 | void (*lm_first_done) (struct gfs2_sbd *sdp); |
| 126 | void (*lm_recovery_result) (struct gfs2_sbd *sdp, unsigned int jid, |
| 127 | unsigned int result); |
| 128 | void (*lm_unmount) (struct gfs2_sbd *sdp); |
Steven Whitehouse | f057f6c | 2009-01-12 10:43:39 +0000 | [diff] [blame] | 129 | void (*lm_withdraw) (struct gfs2_sbd *sdp); |
Steven Whitehouse | bc015cb | 2011-01-19 09:30:01 +0000 | [diff] [blame] | 130 | void (*lm_put_lock) (struct gfs2_glock *gl); |
Steven Whitehouse | 921169c | 2010-11-29 12:50:38 +0000 | [diff] [blame] | 131 | int (*lm_lock) (struct gfs2_glock *gl, unsigned int req_state, |
| 132 | unsigned int flags); |
Steven Whitehouse | f057f6c | 2009-01-12 10:43:39 +0000 | [diff] [blame] | 133 | void (*lm_cancel) (struct gfs2_glock *gl); |
| 134 | const match_table_t *lm_tokens; |
| 135 | }; |
| 136 | |
Benjamin Marzinski | b94a170 | 2009-07-23 18:52:34 -0500 | [diff] [blame] | 137 | extern struct workqueue_struct *gfs2_delete_workqueue; |
Steven Whitehouse | 7afd88d | 2008-02-22 16:07:18 +0000 | [diff] [blame] | 138 | static inline struct gfs2_holder *gfs2_glock_is_locked_by_me(struct gfs2_glock *gl) |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 139 | { |
| 140 | struct gfs2_holder *gh; |
Pavel Emelyanov | b1e058d | 2008-02-07 00:13:19 -0800 | [diff] [blame] | 141 | struct pid *pid; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 142 | |
| 143 | /* Look in glock's list of holders for one with current task as owner */ |
Andreas Gruenbacher | f3dd164 | 2015-10-29 10:58:09 -0500 | [diff] [blame] | 144 | spin_lock(&gl->gl_lockref.lock); |
Pavel Emelyanov | b1e058d | 2008-02-07 00:13:19 -0800 | [diff] [blame] | 145 | pid = task_pid(current); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 146 | list_for_each_entry(gh, &gl->gl_holders, gh_list) { |
Steven Whitehouse | 6802e34 | 2008-05-21 17:03:22 +0100 | [diff] [blame] | 147 | if (!test_bit(HIF_HOLDER, &gh->gh_iflags)) |
| 148 | break; |
Steven Whitehouse | 7afd88d | 2008-02-22 16:07:18 +0000 | [diff] [blame] | 149 | if (gh->gh_owner_pid == pid) |
| 150 | goto out; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 151 | } |
Steven Whitehouse | 7afd88d | 2008-02-22 16:07:18 +0000 | [diff] [blame] | 152 | gh = NULL; |
| 153 | out: |
Andreas Gruenbacher | f3dd164 | 2015-10-29 10:58:09 -0500 | [diff] [blame] | 154 | spin_unlock(&gl->gl_lockref.lock); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 155 | |
Steven Whitehouse | 7afd88d | 2008-02-22 16:07:18 +0000 | [diff] [blame] | 156 | return gh; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 157 | } |
| 158 | |
| 159 | static inline int gfs2_glock_is_held_excl(struct gfs2_glock *gl) |
| 160 | { |
Steven Whitehouse | 5029996 | 2006-09-04 09:49:55 -0400 | [diff] [blame] | 161 | return gl->gl_state == LM_ST_EXCLUSIVE; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 162 | } |
| 163 | |
| 164 | static inline int gfs2_glock_is_held_dfrd(struct gfs2_glock *gl) |
| 165 | { |
Steven Whitehouse | 5029996 | 2006-09-04 09:49:55 -0400 | [diff] [blame] | 166 | return gl->gl_state == LM_ST_DEFERRED; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 167 | } |
| 168 | |
| 169 | static inline int gfs2_glock_is_held_shrd(struct gfs2_glock *gl) |
| 170 | { |
Steven Whitehouse | 5029996 | 2006-09-04 09:49:55 -0400 | [diff] [blame] | 171 | return gl->gl_state == LM_ST_SHARED; |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 172 | } |
| 173 | |
Steven Whitehouse | 009d851 | 2009-12-08 12:12:13 +0000 | [diff] [blame] | 174 | static inline struct address_space *gfs2_glock2aspace(struct gfs2_glock *gl) |
| 175 | { |
| 176 | if (gl->gl_ops->go_flags & GLOF_ASPACE) |
| 177 | return (struct address_space *)(gl + 1); |
| 178 | return NULL; |
| 179 | } |
| 180 | |
Steven Whitehouse | 8eae1ca | 2012-10-15 10:57:02 +0100 | [diff] [blame] | 181 | extern int gfs2_glock_get(struct gfs2_sbd *sdp, u64 number, |
| 182 | const struct gfs2_glock_operations *glops, |
| 183 | int create, struct gfs2_glock **glp); |
Steven Whitehouse | 8eae1ca | 2012-10-15 10:57:02 +0100 | [diff] [blame] | 184 | extern void gfs2_glock_put(struct gfs2_glock *gl); |
| 185 | extern void gfs2_holder_init(struct gfs2_glock *gl, unsigned int state, |
Bob Peterson | b58bf40 | 2015-07-24 09:45:43 -0500 | [diff] [blame^] | 186 | u16 flags, struct gfs2_holder *gh); |
| 187 | extern void gfs2_holder_reinit(unsigned int state, u16 flags, |
Steven Whitehouse | 8eae1ca | 2012-10-15 10:57:02 +0100 | [diff] [blame] | 188 | struct gfs2_holder *gh); |
| 189 | extern void gfs2_holder_uninit(struct gfs2_holder *gh); |
| 190 | extern int gfs2_glock_nq(struct gfs2_holder *gh); |
| 191 | extern int gfs2_glock_poll(struct gfs2_holder *gh); |
| 192 | extern int gfs2_glock_wait(struct gfs2_holder *gh); |
| 193 | extern void gfs2_glock_dq(struct gfs2_holder *gh); |
| 194 | extern void gfs2_glock_dq_wait(struct gfs2_holder *gh); |
| 195 | extern void gfs2_glock_dq_uninit(struct gfs2_holder *gh); |
| 196 | extern int gfs2_glock_nq_num(struct gfs2_sbd *sdp, u64 number, |
| 197 | const struct gfs2_glock_operations *glops, |
Bob Peterson | b58bf40 | 2015-07-24 09:45:43 -0500 | [diff] [blame^] | 198 | unsigned int state, u16 flags, |
Steven Whitehouse | 8eae1ca | 2012-10-15 10:57:02 +0100 | [diff] [blame] | 199 | struct gfs2_holder *gh); |
| 200 | extern int gfs2_glock_nq_m(unsigned int num_gh, struct gfs2_holder *ghs); |
| 201 | extern void gfs2_glock_dq_m(unsigned int num_gh, struct gfs2_holder *ghs); |
Steven Whitehouse | ac3beb6 | 2014-01-16 10:31:13 +0000 | [diff] [blame] | 202 | extern void gfs2_dump_glock(struct seq_file *seq, const struct gfs2_glock *gl); |
Steven Whitehouse | 8eae1ca | 2012-10-15 10:57:02 +0100 | [diff] [blame] | 203 | #define GLOCK_BUG_ON(gl,x) do { if (unlikely(x)) { gfs2_dump_glock(NULL, gl); BUG(); } } while(0) |
| 204 | extern __printf(2, 3) |
Steven Whitehouse | 6802e34 | 2008-05-21 17:03:22 +0100 | [diff] [blame] | 205 | void gfs2_print_dbg(struct seq_file *seq, const char *fmt, ...); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 206 | |
Steven Whitehouse | d0dc80d | 2006-03-29 14:36:49 -0500 | [diff] [blame] | 207 | /** |
Andrea Gelmini | 33027af | 2010-10-16 15:19:22 +0200 | [diff] [blame] | 208 | * gfs2_glock_nq_init - initialize a holder and enqueue it on a glock |
Steven Whitehouse | d0dc80d | 2006-03-29 14:36:49 -0500 | [diff] [blame] | 209 | * @gl: the glock |
| 210 | * @state: the state we're requesting |
| 211 | * @flags: the modifier flags |
| 212 | * @gh: the holder structure |
| 213 | * |
| 214 | * Returns: 0, GLR_*, or errno |
| 215 | */ |
| 216 | |
| 217 | static inline int gfs2_glock_nq_init(struct gfs2_glock *gl, |
Bob Peterson | b58bf40 | 2015-07-24 09:45:43 -0500 | [diff] [blame^] | 218 | unsigned int state, u16 flags, |
Steven Whitehouse | d0dc80d | 2006-03-29 14:36:49 -0500 | [diff] [blame] | 219 | struct gfs2_holder *gh) |
| 220 | { |
| 221 | int error; |
| 222 | |
| 223 | gfs2_holder_init(gl, state, flags, gh); |
| 224 | |
| 225 | error = gfs2_glock_nq(gh); |
| 226 | if (error) |
| 227 | gfs2_holder_uninit(gh); |
| 228 | |
| 229 | return error; |
| 230 | } |
| 231 | |
Steven Whitehouse | bc015cb | 2011-01-19 09:30:01 +0000 | [diff] [blame] | 232 | extern void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state); |
| 233 | extern void gfs2_glock_complete(struct gfs2_glock *gl, int ret); |
Steven Whitehouse | bc015cb | 2011-01-19 09:30:01 +0000 | [diff] [blame] | 234 | extern void gfs2_gl_hash_clear(struct gfs2_sbd *sdp); |
| 235 | extern void gfs2_glock_finish_truncate(struct gfs2_inode *ip); |
| 236 | extern void gfs2_glock_thaw(struct gfs2_sbd *sdp); |
Steven Whitehouse | 29687a2 | 2011-03-30 16:33:25 +0100 | [diff] [blame] | 237 | extern void gfs2_glock_add_to_lru(struct gfs2_glock *gl); |
Steven Whitehouse | fc0e38d | 2011-03-09 10:58:04 +0000 | [diff] [blame] | 238 | extern void gfs2_glock_free(struct gfs2_glock *gl); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 239 | |
Steven Whitehouse | bc015cb | 2011-01-19 09:30:01 +0000 | [diff] [blame] | 240 | extern int __init gfs2_glock_init(void); |
| 241 | extern void gfs2_glock_exit(void); |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 242 | |
Steven Whitehouse | bc015cb | 2011-01-19 09:30:01 +0000 | [diff] [blame] | 243 | extern int gfs2_create_debugfs_file(struct gfs2_sbd *sdp); |
| 244 | extern void gfs2_delete_debugfs_file(struct gfs2_sbd *sdp); |
| 245 | extern int gfs2_register_debugfs(void); |
| 246 | extern void gfs2_unregister_debugfs(void); |
Steven Whitehouse | 85d1da6 | 2006-09-07 14:40:21 -0400 | [diff] [blame] | 247 | |
Steven Whitehouse | f057f6c | 2009-01-12 10:43:39 +0000 | [diff] [blame] | 248 | extern const struct lm_lockops gfs2_dlm_ops; |
| 249 | |
David Teigland | b3b94fa | 2006-01-16 16:50:04 +0000 | [diff] [blame] | 250 | #endif /* __GLOCK_DOT_H__ */ |