git.oblomov.eu Git - linux-2.6/blob - fs/gfs2/lm_interface.h

   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 v.2.
   8  */
   9
  10 #ifndef __LM_INTERFACE_DOT_H__
  11 #define __LM_INTERFACE_DOT_H__
  12
  13 /*
  14  * Opaque handles represent the lock module's lockspace structure, the lock
  15  * module's lock structures, and GFS's file system (superblock) structure.
  16  */
  17
  18 typedef void lm_lockspace_t;
  19 typedef void lm_lock_t;
  20 typedef void lm_fsdata_t;
  21
  22 typedef void (*lm_callback_t) (lm_fsdata_t *fsdata, unsigned int type,
  23                                void *data);
  24
  25 /*
  26  * lm_mount() flags
  27  *
  28  * LM_MFLAG_SPECTATOR
  29  * GFS is asking to join the filesystem's lockspace, but it doesn't want to
  30  * modify the filesystem.  The lock module shouldn't assign a journal to the FS
  31  * mount.  It shouldn't send recovery callbacks to the FS mount.  If the node
  32  * dies or withdraws, all locks can be wiped immediately.
  33  */
  34
  35 #define LM_MFLAG_SPECTATOR      0x00000001
  36
  37 /*
  38  * lm_lockstruct flags
  39  *
  40  * LM_LSFLAG_LOCAL
  41  * The lock_nolock module returns LM_LSFLAG_LOCAL to GFS, indicating that GFS
  42  * can make single-node optimizations.
  43  */
  44
  45 #define LM_LSFLAG_LOCAL         0x00000001
  46
  47 /*
  48  * lm_lockname types
  49  */
  50
  51 #define LM_TYPE_RESERVED        0x00
  52 #define LM_TYPE_NONDISK         0x01
  53 #define LM_TYPE_INODE           0x02
  54 #define LM_TYPE_RGRP            0x03
  55 #define LM_TYPE_META            0x04
  56 #define LM_TYPE_IOPEN           0x05
  57 #define LM_TYPE_FLOCK           0x06
  58 #define LM_TYPE_PLOCK           0x07
  59 #define LM_TYPE_QUOTA           0x08
  60 #define LM_TYPE_JOURNAL         0x09
  61
  62 /*
  63  * lm_lock() states
  64  *
  65  * SHARED is compatible with SHARED, not with DEFERRED or EX.
  66  * DEFERRED is compatible with DEFERRED, not with SHARED or EX.
  67  */
  68
  69 #define LM_ST_UNLOCKED          0
  70 #define LM_ST_EXCLUSIVE         1
  71 #define LM_ST_DEFERRED          2
  72 #define LM_ST_SHARED            3
  73
  74 /*
  75  * lm_lock() flags
  76  *
  77  * LM_FLAG_TRY
  78  * Don't wait to acquire the lock if it can't be granted immediately.
  79  *
  80  * LM_FLAG_TRY_1CB
  81  * Send one blocking callback if TRY is set and the lock is not granted.
  82  *
  83  * LM_FLAG_NOEXP
  84  * GFS sets this flag on lock requests it makes while doing journal recovery.
  85  * These special requests should not be blocked due to the recovery like
  86  * ordinary locks would be.
  87  *
  88  * LM_FLAG_ANY
  89  * A SHARED request may also be granted in DEFERRED, or a DEFERRED request may
  90  * also be granted in SHARED.  The preferred state is whichever is compatible
  91  * with other granted locks, or the specified state if no other locks exist.
  92  *
  93  * LM_FLAG_PRIORITY
  94  * Override fairness considerations.  Suppose a lock is held in a shared state
  95  * and there is a pending request for the deferred state.  A shared lock
  96  * request with the priority flag would be allowed to bypass the deferred
  97  * request and directly join the other shared lock.  A shared lock request
  98  * without the priority flag might be forced to wait until the deferred
  99  * requested had acquired and released the lock.
 100  */
 101
 102 #define LM_FLAG_TRY             0x00000001
 103 #define LM_FLAG_TRY_1CB         0x00000002
 104 #define LM_FLAG_NOEXP           0x00000004
 105 #define LM_FLAG_ANY             0x00000008
 106 #define LM_FLAG_PRIORITY        0x00000010
 107
 108 /*
 109  * lm_lock() and lm_async_cb return flags
 110  *
 111  * LM_OUT_ST_MASK
 112  * Masks the lower two bits of lock state in the returned value.
 113  *
 114  * LM_OUT_CACHEABLE
 115  * The lock hasn't been released so GFS can continue to cache data for it.
 116  *
 117  * LM_OUT_CANCELED
 118  * The lock request was canceled.
 119  *
 120  * LM_OUT_ASYNC
 121  * The result of the request will be returned in an LM_CB_ASYNC callback.
 122  */
 123
 124 #define LM_OUT_ST_MASK          0x00000003
 125 #define LM_OUT_CACHEABLE        0x00000004
 126 #define LM_OUT_CANCELED         0x00000008
 127 #define LM_OUT_ASYNC            0x00000080
 128 #define LM_OUT_ERROR            0x00000100
 129
 130 /*
 131  * lm_callback_t types
 132  *
 133  * LM_CB_NEED_E LM_CB_NEED_D LM_CB_NEED_S
 134  * Blocking callback, a remote node is requesting the given lock in
 135  * EXCLUSIVE, DEFERRED, or SHARED.
 136  *
 137  * LM_CB_NEED_RECOVERY
 138  * The given journal needs to be recovered.
 139  *
 140  * LM_CB_DROPLOCKS
 141  * Reduce the number of cached locks.
 142  *
 143  * LM_CB_ASYNC
 144  * The given lock has been granted.
 145  */
 146
 147 #define LM_CB_NEED_E            257
 148 #define LM_CB_NEED_D            258
 149 #define LM_CB_NEED_S            259
 150 #define LM_CB_NEED_RECOVERY     260
 151 #define LM_CB_DROPLOCKS         261
 152 #define LM_CB_ASYNC             262
 153
 154 /*
 155  * lm_recovery_done() messages
 156  */
 157
 158 #define LM_RD_GAVEUP            308
 159 #define LM_RD_SUCCESS           309
 160
 161
 162 struct lm_lockname {
 163         uint64_t ln_number;
 164         unsigned int ln_type;
 165 };
 166
 167 #define lm_name_equal(name1, name2) \
 168         (((name1)->ln_number == (name2)->ln_number) && \
 169          ((name1)->ln_type == (name2)->ln_type)) \
 170
 171 struct lm_async_cb {
 172         struct lm_lockname lc_name;
 173         int lc_ret;
 174 };
 175
 176 struct lm_lockstruct;
 177
 178 struct lm_lockops {
 179         char lm_proto_name[256];
 180
 181         /*
 182          * Mount/Unmount
 183          */
 184
 185         int (*lm_mount) (char *table_name, char *host_data,
 186                          lm_callback_t cb, lm_fsdata_t *fsdata,
 187                          unsigned int min_lvb_size, int flags,
 188                          struct lm_lockstruct *lockstruct,
 189                          struct kobject *fskobj);
 190
 191         void (*lm_others_may_mount) (lm_lockspace_t *lockspace);
 192
 193         void (*lm_unmount) (lm_lockspace_t *lockspace);
 194
 195         void (*lm_withdraw) (lm_lockspace_t *lockspace);
 196
 197         /*
 198          * Lock oriented operations
 199          */
 200
 201         int (*lm_get_lock) (lm_lockspace_t *lockspace,
 202                             struct lm_lockname *name, lm_lock_t **lockp);
 203
 204         void (*lm_put_lock) (lm_lock_t *lock);
 205
 206         unsigned int (*lm_lock) (lm_lock_t *lock, unsigned int cur_state,
 207                                  unsigned int req_state, unsigned int flags);
 208
 209         unsigned int (*lm_unlock) (lm_lock_t *lock, unsigned int cur_state);
 210
 211         void (*lm_cancel) (lm_lock_t *lock);
 212
 213         int (*lm_hold_lvb) (lm_lock_t *lock, char **lvbp);
 214         void (*lm_unhold_lvb) (lm_lock_t *lock, char *lvb);
 215         void (*lm_sync_lvb) (lm_lock_t *lock, char *lvb);
 216
 217         /*
 218          * Posix Lock oriented operations
 219          */
 220
 221         int (*lm_plock_get) (lm_lockspace_t *lockspace,
 222                              struct lm_lockname *name,
 223                              struct file *file, struct file_lock *fl);
 224
 225         int (*lm_plock) (lm_lockspace_t *lockspace,
 226                          struct lm_lockname *name,
 227                          struct file *file, int cmd, struct file_lock *fl);
 228
 229         int (*lm_punlock) (lm_lockspace_t *lockspace,
 230                            struct lm_lockname *name,
 231                            struct file *file, struct file_lock *fl);
 232
 233         /*
 234          * Client oriented operations
 235          */
 236
 237         void (*lm_recovery_done) (lm_lockspace_t *lockspace, unsigned int jid,
 238                                   unsigned int message);
 239
 240         struct module *lm_owner;
 241 };
 242
 243 /*
 244  * lm_mount() return values
 245  *
 246  * ls_jid - the journal ID this node should use
 247  * ls_first - this node is the first to mount the file system
 248  * ls_lvb_size - size in bytes of lock value blocks
 249  * ls_lockspace - lock module's context for this file system
 250  * ls_ops - lock module's functions
 251  * ls_flags - lock module features
 252  */
 253
 254 struct lm_lockstruct {
 255         unsigned int ls_jid;
 256         unsigned int ls_first;
 257         unsigned int ls_lvb_size;
 258         lm_lockspace_t *ls_lockspace;
 259         struct lm_lockops *ls_ops;
 260         int ls_flags;
 261 };
 262
 263 void __init gfs2_init_lmh(void);
 264
 265 /*
 266  * Lock module bottom interface.  A lock module makes itself available to GFS
 267  * with these functions.
 268  */
 269
 270 int gfs2_register_lockproto(struct lm_lockops *proto);
 271
 272 void gfs2_unregister_lockproto(struct lm_lockops *proto);
 273
 274 /*
 275  * Lock module top interface.  GFS calls these functions when mounting or
 276  * unmounting a file system.
 277  */
 278
 279 int gfs2_mount_lockproto(char *proto_name, char *table_name, char *host_data,
 280                          lm_callback_t cb, lm_fsdata_t *fsdata,
 281                          unsigned int min_lvb_size, int flags,
 282                          struct lm_lockstruct *lockstruct,
 283                          struct kobject *fskobj);
 284
 285 void gfs2_unmount_lockproto(struct lm_lockstruct *lockstruct);
 286
 287 void gfs2_withdraw_lockproto(struct lm_lockstruct *lockstruct);
 288
 289 #endif /* __LM_INTERFACE_DOT_H__ */
 290