7 files changed, 1151 insertions, 0 deletions

diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 7d564b6fc98f..ea005c0a79fd 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -46,6 +46,7 @@ header-y += coff.h
 header-y += comstats.h
 header-y += consolemap.h
 header-y += cycx_cfm.h
+header-y += dlm_device.h
 header-y += dm-ioctl.h
 header-y += dn.h
 header-y += dqblk_v1.h
@@ -104,6 +105,7 @@ header-y += ixjuser.h
 header-y += jffs2.h
 header-y += keyctl.h
 header-y += limits.h
+header-y += lock_dlm_plock.h
 header-y += magic.h
 header-y += major.h
 header-y += matroxfb.h
@@ -192,6 +194,7 @@ unifdef-y += cyclades.h
 unifdef-y += dccp.h
 unifdef-y += dirent.h
 unifdef-y += divert.h
+unifdef-y += dlm.h
 unifdef-y += elfcore.h
 unifdef-y += errno.h
 unifdef-y += errqueue.h
@@ -208,6 +211,7 @@ unifdef-y += ftape.h
 unifdef-y += gameport.h
 unifdef-y += generic_serial.h
 unifdef-y += genhd.h
+unifdef-y += gfs2_ondisk.h
 unifdef-y += hayesesp.h
 unifdef-y += hdlcdrv.h
 unifdef-y += hdlc.h
diff --git a/include/linux/dlm.h b/include/linux/dlm.h
new file mode 100644
index 000000000000..1b1dcb9a40bb
--- /dev/null
+++ b/include/linux/dlm.h
@@ -0,0 +1,302 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+#ifndef __DLM_DOT_H__
+#define __DLM_DOT_H__
+
+/*
+ * Interface to Distributed Lock Manager (DLM)
+ * routines and structures to use DLM lockspaces
+ */
+
+/*
+ * Lock Modes
+ */
+
+#define DLM_LOCK_IV             -1      /* invalid */
+#define DLM_LOCK_NL             0       /* null */
+#define DLM_LOCK_CR             1       /* concurrent read */
+#define DLM_LOCK_CW             2       /* concurrent write */
+#define DLM_LOCK_PR             3       /* protected read */
+#define DLM_LOCK_PW             4       /* protected write */
+#define DLM_LOCK_EX             5       /* exclusive */
+
+/*
+ * Maximum size in bytes of a dlm_lock name
+ */
+
+#define DLM_RESNAME_MAXLEN      64
+
+/*
+ * Flags to dlm_lock
+ *
+ * DLM_LKF_NOQUEUE
+ *
+ * Do not queue the lock request on the wait queue if it cannot be granted
+ * immediately.  If the lock cannot be granted because of this flag, DLM will
+ * either return -EAGAIN from the dlm_lock call or will return 0 from
+ * dlm_lock and -EAGAIN in the lock status block when the AST is executed.
+ *
+ * DLM_LKF_CANCEL
+ *
+ * Used to cancel a pending lock request or conversion.  A converting lock is
+ * returned to its previously granted mode.
+ *
+ * DLM_LKF_CONVERT
+ *
+ * Indicates a lock conversion request.  For conversions the name and namelen
+ * are ignored and the lock ID in the LKSB is used to identify the lock.
+ *
+ * DLM_LKF_VALBLK
+ *
+ * Requests DLM to return the current contents of the lock value block in the
+ * lock status block.  When this flag is set in a lock conversion from PW or EX
+ * modes, DLM assigns the value specified in the lock status block to the lock
+ * value block of the lock resource.  The LVB is a DLM_LVB_LEN size array
+ * containing application-specific information.
+ *
+ * DLM_LKF_QUECVT
+ *
+ * Force a conversion request to be queued, even if it is compatible with
+ * the granted modes of other locks on the same resource.
+ *
+ * DLM_LKF_IVVALBLK
+ *
+ * Invalidate the lock value block.
+ *
+ * DLM_LKF_CONVDEADLK
+ *
+ * Allows the dlm to resolve conversion deadlocks internally by demoting the
+ * granted mode of a converting lock to NL.  The DLM_SBF_DEMOTED flag is
+ * returned for a conversion that's been effected by this.
+ *
+ * DLM_LKF_PERSISTENT
+ *
+ * Only relevant to locks originating in userspace.  A persistent lock will not
+ * be removed if the process holding the lock exits.
+ *
+ * DLM_LKF_NODLKWT
+ * DLM_LKF_NODLCKBLK
+ *
+ * net yet implemented
+ *
+ * DLM_LKF_EXPEDITE
+ *
+ * Used only with new requests for NL mode locks.  Tells the lock manager
+ * to grant the lock, ignoring other locks in convert and wait queues.
+ *
+ * DLM_LKF_NOQUEUEBAST
+ *
+ * Send blocking AST's before returning -EAGAIN to the caller.  It is only
+ * used along with the NOQUEUE flag.  Blocking AST's are not sent for failed
+ * NOQUEUE requests otherwise.
+ *
+ * DLM_LKF_HEADQUE
+ *
+ * Add a lock to the head of the convert or wait queue rather than the tail.
+ *
+ * DLM_LKF_NOORDER
+ *
+ * Disregard the standard grant order rules and grant a lock as soon as it
+ * is compatible with other granted locks.
+ *
+ * DLM_LKF_ORPHAN
+ *
+ * not yet implemented
+ *
+ * DLM_LKF_ALTPR
+ *
+ * If the requested mode cannot be granted immediately, try to grant the lock
+ * in PR mode instead.  If this alternate mode is granted instead of the
+ * requested mode, DLM_SBF_ALTMODE is returned in the lksb.
+ *
+ * DLM_LKF_ALTCW
+ *
+ * The same as ALTPR, but the alternate mode is CW.
+ *
+ * DLM_LKF_FORCEUNLOCK
+ *
+ * Unlock the lock even if it is converting or waiting or has sublocks.
+ * Only really for use by the userland device.c code.
+ *
+ */
+
+#define DLM_LKF_NOQUEUE         0x00000001
+#define DLM_LKF_CANCEL          0x00000002
+#define DLM_LKF_CONVERT         0x00000004
+#define DLM_LKF_VALBLK          0x00000008
+#define DLM_LKF_QUECVT          0x00000010
+#define DLM_LKF_IVVALBLK        0x00000020
+#define DLM_LKF_CONVDEADLK      0x00000040
+#define DLM_LKF_PERSISTENT      0x00000080
+#define DLM_LKF_NODLCKWT        0x00000100
+#define DLM_LKF_NODLCKBLK       0x00000200
+#define DLM_LKF_EXPEDITE        0x00000400
+#define DLM_LKF_NOQUEUEBAST     0x00000800
+#define DLM_LKF_HEADQUE         0x00001000
+#define DLM_LKF_NOORDER         0x00002000
+#define DLM_LKF_ORPHAN          0x00004000
+#define DLM_LKF_ALTPR           0x00008000
+#define DLM_LKF_ALTCW           0x00010000
+#define DLM_LKF_FORCEUNLOCK     0x00020000
+
+/*
+ * Some return codes that are not in errno.h
+ */
+
+#define DLM_ECANCEL             0x10001
+#define DLM_EUNLOCK             0x10002
+
+typedef void dlm_lockspace_t;
+
+/*
+ * Lock status block
+ *
+ * Use this structure to specify the contents of the lock value block.  For a
+ * conversion request, this structure is used to specify the lock ID of the
+ * lock.  DLM writes the status of the lock request and the lock ID assigned
+ * to the request in the lock status block.
+ *
+ * sb_lkid: the returned lock ID.  It is set on new (non-conversion) requests.
+ * It is available when dlm_lock returns.
+ *
+ * sb_lvbptr: saves or returns the contents of the lock's LVB according to rules
+ * shown for the DLM_LKF_VALBLK flag.
+ *
+ * sb_flags: DLM_SBF_DEMOTED is returned if in the process of promoting a lock,
+ * it was first demoted to NL to avoid conversion deadlock.
+ * DLM_SBF_VALNOTVALID is returned if the resource's LVB is marked invalid.
+ *
+ * sb_status: the returned status of the lock request set prior to AST
+ * execution.  Possible return values:
+ *
+ * 0 if lock request was successful
+ * -EAGAIN if request would block and is flagged DLM_LKF_NOQUEUE
+ * -ENOMEM if there is no memory to process request
+ * -EINVAL if there are invalid parameters
+ * -DLM_EUNLOCK if unlock request was successful
+ * -DLM_ECANCEL if a cancel completed successfully
+ */
+
+#define DLM_SBF_DEMOTED         0x01
+#define DLM_SBF_VALNOTVALID     0x02
+#define DLM_SBF_ALTMODE         0x04
+
+struct dlm_lksb {
+        int      sb_status;
+        uint32_t sb_lkid;
+        char     sb_flags;
+        char *   sb_lvbptr;
+};
+
+
+#ifdef __KERNEL__
+
+#define DLM_LSFL_NODIR          0x00000001
+
+/*
+ * dlm_new_lockspace
+ *
+ * Starts a lockspace with the given name.  If the named lockspace exists in
+ * the cluster, the calling node joins it.
+ */
+
+int dlm_new_lockspace(char *name, int namelen, dlm_lockspace_t **lockspace,
+                      uint32_t flags, int lvblen);
+
+/*
+ * dlm_release_lockspace
+ *
+ * Stop a lockspace.
+ */
+
+int dlm_release_lockspace(dlm_lockspace_t *lockspace, int force);
+
+/*
+ * dlm_lock
+ *
+ * Make an asyncronous request to acquire or convert a lock on a named
+ * resource.
+ *
+ * lockspace: context for the request
+ * mode: the requested mode of the lock (DLM_LOCK_)
+ * lksb: lock status block for input and async return values
+ * flags: input flags (DLM_LKF_)
+ * name: name of the resource to lock, can be binary
+ * namelen: the length in bytes of the resource name (MAX_RESNAME_LEN)
+ * parent: the lock ID of a parent lock or 0 if none
+ * lockast: function DLM executes when it completes processing the request
+ * astarg: argument passed to lockast and bast functions
+ * bast: function DLM executes when this lock later blocks another request
+ *
+ * Returns:
+ * 0 if request is successfully queued for processing
+ * -EINVAL if any input parameters are invalid
+ * -EAGAIN if request would block and is flagged DLM_LKF_NOQUEUE
+ * -ENOMEM if there is no memory to process request
+ * -ENOTCONN if there is a communication error
+ *
+ * If the call to dlm_lock returns an error then the operation has failed and
+ * the AST routine will not be called.  If dlm_lock returns 0 it is still
+ * possible that the lock operation will fail. The AST routine will be called
+ * when the locking is complete and the status is returned in the lksb.
+ *
+ * If the AST routines or parameter are passed to a conversion operation then
+ * they will overwrite those values that were passed to a previous dlm_lock
+ * call.
+ *
+ * AST routines should not block (at least not for long), but may make
+ * any locking calls they please.
+ */
+
+int dlm_lock(dlm_lockspace_t *lockspace,
+             int mode,
+             struct dlm_lksb *lksb,
+             uint32_t flags,
+             void *name,
+             unsigned int namelen,
+             uint32_t parent_lkid,
+             void (*lockast) (void *astarg),
+             void *astarg,
+             void (*bast) (void *astarg, int mode));
+
+/*
+ * dlm_unlock
+ *
+ * Asynchronously release a lock on a resource.  The AST routine is called
+ * when the resource is successfully unlocked.
+ *
+ * lockspace: context for the request
+ * lkid: the lock ID as returned in the lksb
+ * flags: input flags (DLM_LKF_)
+ * lksb: if NULL the lksb parameter passed to last lock request is used
+ * astarg: the arg used with the completion ast for the unlock
+ *
+ * Returns:
+ * 0 if request is successfully queued for processing
+ * -EINVAL if any input parameters are invalid
+ * -ENOTEMPTY if the lock still has sublocks
+ * -EBUSY if the lock is waiting for a remote lock operation
+ * -ENOTCONN if there is a communication error
+ */
+
+int dlm_unlock(dlm_lockspace_t *lockspace,
+               uint32_t lkid,
+               uint32_t flags,
+               struct dlm_lksb *lksb,
+               void *astarg);
+
+#endif                          /* __KERNEL__ */
+
+#endif                          /* __DLM_DOT_H__ */
+
diff --git a/include/linux/dlm_device.h b/include/linux/dlm_device.h
new file mode 100644
index 000000000000..2a2dd189b9fd
--- /dev/null
+++ b/include/linux/dlm_device.h
@@ -0,0 +1,86 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+
+/* This is the device interface for dlm, most users will use a library
+ * interface.
+ */
+
+#define DLM_USER_LVB_LEN        32
+
+/* Version of the device interface */
+#define DLM_DEVICE_VERSION_MAJOR 5
+#define DLM_DEVICE_VERSION_MINOR 0
+#define DLM_DEVICE_VERSION_PATCH 0
+
+/* struct passed to the lock write */
+struct dlm_lock_params {
+        __u8 mode;
+        __u8 namelen;
+        __u16 flags;
+        __u32 lkid;
+        __u32 parent;
+        void __user *castparam;
+        void __user *castaddr;
+        void __user *bastparam;
+        void __user *bastaddr;
+        struct dlm_lksb __user *lksb;
+        char lvb[DLM_USER_LVB_LEN];
+        char name[0];
+};
+
+struct dlm_lspace_params {
+        __u32 flags;
+        __u32 minor;
+        char name[0];
+};
+
+struct dlm_write_request {
+        __u32 version[3];
+        __u8 cmd;
+        __u8 is64bit;
+        __u8 unused[2];
+
+        union  {
+                struct dlm_lock_params   lock;
+                struct dlm_lspace_params lspace;
+        } i;
+};
+
+/* struct read from the "device" fd,
+   consists mainly of userspace pointers for the library to use */
+struct dlm_lock_result {
+        __u32 length;
+        void __user * user_astaddr;
+        void __user * user_astparam;
+        struct dlm_lksb __user * user_lksb;
+        struct dlm_lksb lksb;
+        __u8 bast_mode;
+        __u8 unused[3];
+        /* Offsets may be zero if no data is present */
+        __u32 lvb_offset;
+};
+
+/* Commands passed to the device */
+#define DLM_USER_LOCK         1
+#define DLM_USER_UNLOCK       2
+#define DLM_USER_QUERY        3
+#define DLM_USER_CREATE_LOCKSPACE  4
+#define DLM_USER_REMOVE_LOCKSPACE  5
+
+/* Arbitrary length restriction */
+#define MAX_LS_NAME_LEN 64
+
+/* Lockspace flags */
+#define DLM_USER_LSFLG_AUTOFREE   1
+#define DLM_USER_LSFLG_FORCEFREE  2
+
diff --git a/include/linux/fs.h b/include/linux/fs.h
index f53bf4ff1955..34406ed467c3 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -250,6 +250,8 @@ extern int dir_notify_enable;
 #define FS_NOTAIL_FL                    0x00008000 /* file tail should not be merged */
 #define FS_DIRSYNC_FL                   0x00010000 /* dirsync behaviour (directories only) */
 #define FS_TOPDIR_FL                    0x00020000 /* Top of directory hierarchies*/
+#define FS_EXTENT_FL                    0x00080000 /* Extents */
+#define FS_DIRECTIO_FL                  0x00100000 /* Use direct i/o */
 #define FS_RESERVED_FL                  0x80000000 /* reserved for ext2 lib */
 
 #define FS_FL_USER_VISIBLE              0x0003DFFF /* User visible flags */
diff --git a/include/linux/gfs2_ondisk.h b/include/linux/gfs2_ondisk.h
new file mode 100644
index 000000000000..a7ae7c177cac
--- /dev/null
+++ b/include/linux/gfs2_ondisk.h
@@ -0,0 +1,443 @@
+/*
+ * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
+ * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ */
+
+#ifndef __GFS2_ONDISK_DOT_H__
+#define __GFS2_ONDISK_DOT_H__
+
+#define GFS2_MAGIC              0x01161970
+#define GFS2_BASIC_BLOCK        512
+#define GFS2_BASIC_BLOCK_SHIFT  9
+
+/* Lock numbers of the LM_TYPE_NONDISK type */
+
+#define GFS2_MOUNT_LOCK         0
+#define GFS2_LIVE_LOCK          1
+#define GFS2_TRANS_LOCK         2
+#define GFS2_RENAME_LOCK        3
+
+/* Format numbers for various metadata types */
+
+#define GFS2_FORMAT_NONE        0
+#define GFS2_FORMAT_SB          100
+#define GFS2_FORMAT_RG          200
+#define GFS2_FORMAT_RB          300
+#define GFS2_FORMAT_DI          400
+#define GFS2_FORMAT_IN          500
+#define GFS2_FORMAT_LF          600
+#define GFS2_FORMAT_JD          700
+#define GFS2_FORMAT_LH          800
+#define GFS2_FORMAT_LD          900
+#define GFS2_FORMAT_LB          1000
+#define GFS2_FORMAT_EA          1600
+#define GFS2_FORMAT_ED          1700
+#define GFS2_FORMAT_QC          1400
+/* These are format numbers for entities contained in files */
+#define GFS2_FORMAT_RI          1100
+#define GFS2_FORMAT_DE          1200
+#define GFS2_FORMAT_QU          1500
+/* These are part of the superblock */
+#define GFS2_FORMAT_FS          1801
+#define GFS2_FORMAT_MULTI       1900
+
+/*
+ * An on-disk inode number
+ */
+
+struct gfs2_inum {
+        __be64 no_formal_ino;
+        __be64 no_addr;
+};
+
+static inline int gfs2_inum_equal(const struct gfs2_inum *ino1,
+                                  const struct gfs2_inum *ino2)
+{
+        return ino1->no_formal_ino == ino2->no_formal_ino &&
+               ino1->no_addr == ino2->no_addr;
+}
+
+/*
+ * Generic metadata head structure
+ * Every inplace buffer logged in the journal must start with this.
+ */
+
+#define GFS2_METATYPE_NONE      0
+#define GFS2_METATYPE_SB        1
+#define GFS2_METATYPE_RG        2
+#define GFS2_METATYPE_RB        3
+#define GFS2_METATYPE_DI        4
+#define GFS2_METATYPE_IN        5
+#define GFS2_METATYPE_LF        6
+#define GFS2_METATYPE_JD        7
+#define GFS2_METATYPE_LH        8
+#define GFS2_METATYPE_LD        9
+#define GFS2_METATYPE_LB        12
+#define GFS2_METATYPE_EA        10
+#define GFS2_METATYPE_ED        11
+#define GFS2_METATYPE_QC        14
+
+struct gfs2_meta_header {
+        __be32 mh_magic;
+        __be32 mh_type;
+        __be64 __pad0;          /* Was generation number in gfs1 */
+        __be32 mh_format;
+        __be32 __pad1;          /* Was incarnation number in gfs1 */
+};
+
+/*
+ * super-block structure
+ *
+ * It's probably good if SIZEOF_SB <= GFS2_BASIC_BLOCK (512 bytes)
+ *
+ * Order is important, need to be able to read old superblocks to do on-disk
+ * version upgrades.
+ */
+
+/* Address of superblock in GFS2 basic blocks */
+#define GFS2_SB_ADDR            128
+
+/* The lock number for the superblock (must be zero) */
+#define GFS2_SB_LOCK            0
+
+/* Requirement:  GFS2_LOCKNAME_LEN % 8 == 0
+   Includes: the fencing zero at the end */
+#define GFS2_LOCKNAME_LEN       64
+
+struct gfs2_sb {
+        struct gfs2_meta_header sb_header;
+
+        __be32 sb_fs_format;
+        __be32 sb_multihost_format;
+        __u32  __pad0;  /* Was superblock flags in gfs1 */
+
+        __be32 sb_bsize;
+        __be32 sb_bsize_shift;
+        __u32 __pad1;   /* Was journal segment size in gfs1 */
+
+        struct gfs2_inum sb_master_dir; /* Was jindex dinode in gfs1 */
+        struct gfs2_inum __pad2; /* Was rindex dinode in gfs1 */
+        struct gfs2_inum sb_root_dir;
+
+        char sb_lockproto[GFS2_LOCKNAME_LEN];
+        char sb_locktable[GFS2_LOCKNAME_LEN];
+        /* In gfs1, quota and license dinodes followed */
+};
+
+/*
+ * resource index structure
+ */
+
+struct gfs2_rindex {
+        __be64 ri_addr; /* grp block disk address */
+        __be32 ri_length;       /* length of rgrp header in fs blocks */
+        __u32 __pad;
+
+        __be64 ri_data0;        /* first data location */
+        __be32 ri_data; /* num of data blocks in rgrp */
+
+        __be32 ri_bitbytes;     /* number of bytes in data bitmaps */
+
+        __u8 ri_reserved[64];
+};
+
+/*
+ * resource group header structure
+ */
+
+/* Number of blocks per byte in rgrp */
+#define GFS2_NBBY               4
+#define GFS2_BIT_SIZE           2
+#define GFS2_BIT_MASK           0x00000003
+
+#define GFS2_BLKST_FREE         0
+#define GFS2_BLKST_USED         1
+#define GFS2_BLKST_UNLINKED     2
+#define GFS2_BLKST_DINODE       3
+
+#define GFS2_RGF_JOURNAL        0x00000001
+#define GFS2_RGF_METAONLY       0x00000002
+#define GFS2_RGF_DATAONLY       0x00000004
+#define GFS2_RGF_NOALLOC        0x00000008
+
+struct gfs2_rgrp {
+        struct gfs2_meta_header rg_header;
+
+        __be32 rg_flags;
+        __be32 rg_free;
+        __be32 rg_dinodes;
+        __be32 __pad;
+        __be64 rg_igeneration;
+
+        __u8 rg_reserved[80]; /* Several fields from gfs1 now reserved */
+};
+
+/*
+ * quota structure
+ */
+
+struct gfs2_quota {
+        __be64 qu_limit;
+        __be64 qu_warn;
+        __be64 qu_value;
+        __u8 qu_reserved[64];
+};
+
+/*
+ * dinode structure
+ */
+
+#define GFS2_MAX_META_HEIGHT    10
+#define GFS2_DIR_MAX_DEPTH      17
+
+#define DT2IF(dt) (((dt) << 12) & S_IFMT)
+#define IF2DT(sif) (((sif) & S_IFMT) >> 12)
+
+enum {
+        gfs2fl_Jdata            = 0,
+        gfs2fl_ExHash           = 1,
+        gfs2fl_Unused           = 2,
+        gfs2fl_EaIndirect       = 3,
+        gfs2fl_Directio         = 4,
+        gfs2fl_Immutable        = 5,
+        gfs2fl_AppendOnly       = 6,
+        gfs2fl_NoAtime          = 7,
+        gfs2fl_Sync             = 8,
+        gfs2fl_System           = 9,
+        gfs2fl_TruncInProg      = 29,
+        gfs2fl_InheritDirectio  = 30,
+        gfs2fl_InheritJdata     = 31,
+};
+
+/* Dinode flags */
+#define GFS2_DIF_JDATA                  0x00000001
+#define GFS2_DIF_EXHASH                 0x00000002
+#define GFS2_DIF_UNUSED                 0x00000004  /* only in gfs1 */
+#define GFS2_DIF_EA_INDIRECT            0x00000008
+#define GFS2_DIF_DIRECTIO               0x00000010
+#define GFS2_DIF_IMMUTABLE              0x00000020
+#define GFS2_DIF_APPENDONLY             0x00000040
+#define GFS2_DIF_NOATIME                0x00000080
+#define GFS2_DIF_SYNC                   0x00000100
+#define GFS2_DIF_SYSTEM                 0x00000200 /* New in gfs2 */
+#define GFS2_DIF_TRUNC_IN_PROG          0x20000000 /* New in gfs2 */
+#define GFS2_DIF_INHERIT_DIRECTIO       0x40000000
+#define GFS2_DIF_INHERIT_JDATA          0x80000000
+
+struct gfs2_dinode {
+        struct gfs2_meta_header di_header;
+
+        struct gfs2_inum di_num;
+
+        __be32 di_mode; /* mode of file */
+        __be32 di_uid;  /* owner's user id */
+        __be32 di_gid;  /* owner's group id */
+        __be32 di_nlink;        /* number of links to this file */
+        __be64 di_size; /* number of bytes in file */
+        __be64 di_blocks;       /* number of blocks in file */
+        __be64 di_atime;        /* time last accessed */
+        __be64 di_mtime;        /* time last modified */
+        __be64 di_ctime;        /* time last changed */
+        __be32 di_major;        /* device major number */
+        __be32 di_minor;        /* device minor number */
+
+        /* This section varies from gfs1. Padding added to align with
+         * remainder of dinode
+         */
+        __be64 di_goal_meta;    /* rgrp to alloc from next */
+        __be64 di_goal_data;    /* data block goal */
+        __be64 di_generation;   /* generation number for NFS */
+
+        __be32 di_flags;        /* GFS2_DIF_... */
+        __be32 di_payload_format;  /* GFS2_FORMAT_... */
+        __u16 __pad1;   /* Was ditype in gfs1 */
+        __be16 di_height;       /* height of metadata */
+        __u32 __pad2;   /* Unused incarnation number from gfs1 */
+
+        /* These only apply to directories  */
+        __u16 __pad3;   /* Padding */
+        __be16 di_depth;        /* Number of bits in the table */
+        __be32 di_entries;      /* The number of entries in the directory */
+
+        struct gfs2_inum __pad4; /* Unused even in current gfs1 */
+
+        __be64 di_eattr;        /* extended attribute block number */
+
+        __u8 di_reserved[56];
+};
+
+/*
+ * directory structure - many of these per directory file
+ */
+
+#define GFS2_FNAMESIZE          255
+#define GFS2_DIRENT_SIZE(name_len) ((sizeof(struct gfs2_dirent) + (name_len) + 7) & ~7)
+
+struct gfs2_dirent {
+        struct gfs2_inum de_inum;
+        __be32 de_hash;
+        __be16 de_rec_len;
+        __be16 de_name_len;
+        __be16 de_type;
+        __u8 __pad[14];
+};
+
+/*
+ * Header of leaf directory nodes
+ */
+
+struct gfs2_leaf {
+        struct gfs2_meta_header lf_header;
+
+        __be16 lf_depth;                /* Depth of leaf */
+        __be16 lf_entries;              /* Number of dirents in leaf */
+        __be32 lf_dirent_format;        /* Format of the dirents */
+        __be64 lf_next;                 /* Next leaf, if overflow */
+
+        __u8 lf_reserved[64];
+};
+
+/*
+ * Extended attribute header format
+ */
+
+#define GFS2_EA_MAX_NAME_LEN    255
+#define GFS2_EA_MAX_DATA_LEN    65536
+
+#define GFS2_EATYPE_UNUSED      0
+#define GFS2_EATYPE_USR         1
+#define GFS2_EATYPE_SYS         2
+#define GFS2_EATYPE_SECURITY    3
+
+#define GFS2_EATYPE_LAST        3
+#define GFS2_EATYPE_VALID(x)    ((x) <= GFS2_EATYPE_LAST)
+
+#define GFS2_EAFLAG_LAST        0x01    /* last ea in block */
+
+struct gfs2_ea_header {
+        __be32 ea_rec_len;
+        __be32 ea_data_len;
+        __u8 ea_name_len;       /* no NULL pointer after the string */
+        __u8 ea_type;           /* GFS2_EATYPE_... */
+        __u8 ea_flags;          /* GFS2_EAFLAG_... */
+        __u8 ea_num_ptrs;
+        __u32 __pad;
+};
+
+/*
+ * Log header structure
+ */
+
+#define GFS2_LOG_HEAD_UNMOUNT   0x00000001      /* log is clean */
+
+struct gfs2_log_header {
+        struct gfs2_meta_header lh_header;
+
+        __be64 lh_sequence;     /* Sequence number of this transaction */
+        __be32 lh_flags;        /* GFS2_LOG_HEAD_... */
+        __be32 lh_tail;         /* Block number of log tail */
+        __be32 lh_blkno;
+        __be32 lh_hash;
+};
+
+/*
+ * Log type descriptor
+ */
+
+#define GFS2_LOG_DESC_METADATA  300
+/* ld_data1 is the number of metadata blocks in the descriptor.
+   ld_data2 is unused. */
+
+#define GFS2_LOG_DESC_REVOKE    301
+/* ld_data1 is the number of revoke blocks in the descriptor.
+   ld_data2 is unused. */
+
+#define GFS2_LOG_DESC_JDATA     302
+/* ld_data1 is the number of data blocks in the descriptor.
+   ld_data2 is unused. */
+
+struct gfs2_log_descriptor {
+        struct gfs2_meta_header ld_header;
+
+        __be32 ld_type;         /* GFS2_LOG_DESC_... */
+        __be32 ld_length;       /* Number of buffers in this chunk */
+        __be32 ld_data1;        /* descriptor-specific field */
+        __be32 ld_data2;        /* descriptor-specific field */
+
+        __u8 ld_reserved[32];
+};
+
+/*
+ * Inum Range
+ * Describe a range of formal inode numbers allocated to
+ * one machine to assign to inodes.
+ */
+
+#define GFS2_INUM_QUANTUM       1048576
+
+struct gfs2_inum_range {
+        __be64 ir_start;
+        __be64 ir_length;
+};
+
+/*
+ * Statfs change
+ * Describes an change to the pool of free and allocated
+ * blocks.
+ */
+
+struct gfs2_statfs_change {
+        __be64 sc_total;
+        __be64 sc_free;
+        __be64 sc_dinodes;
+};
+
+/*
+ * Quota change
+ * Describes an allocation change for a particular
+ * user or group.
+ */
+
+#define GFS2_QCF_USER           0x00000001
+
+struct gfs2_quota_change {
+        __be64 qc_change;
+        __be32 qc_flags;        /* GFS2_QCF_... */
+        __be32 qc_id;
+};
+
+#ifdef __KERNEL__
+/* Translation functions */
+
+extern void gfs2_inum_in(struct gfs2_inum *no, const void *buf);
+extern void gfs2_inum_out(const struct gfs2_inum *no, void *buf);
+extern void gfs2_sb_in(struct gfs2_sb *sb, const void *buf);
+extern void gfs2_rindex_in(struct gfs2_rindex *ri, const void *buf);
+extern void gfs2_rindex_out(const struct gfs2_rindex *ri, void *buf);
+extern void gfs2_rgrp_in(struct gfs2_rgrp *rg, const void *buf);
+extern void gfs2_rgrp_out(const struct gfs2_rgrp *rg, void *buf);
+extern void gfs2_quota_in(struct gfs2_quota *qu, const void *buf);
+extern void gfs2_quota_out(const struct gfs2_quota *qu, void *buf);
+extern void gfs2_dinode_in(struct gfs2_dinode *di, const void *buf);
+extern void gfs2_dinode_out(const struct gfs2_dinode *di, void *buf);
+extern void gfs2_ea_header_in(struct gfs2_ea_header *ea, const void *buf);
+extern void gfs2_ea_header_out(const struct gfs2_ea_header *ea, void *buf);
+extern void gfs2_log_header_in(struct gfs2_log_header *lh, const void *buf);
+extern void gfs2_inum_range_in(struct gfs2_inum_range *ir, const void *buf);
+extern void gfs2_inum_range_out(const struct gfs2_inum_range *ir, void *buf);
+extern void gfs2_statfs_change_in(struct gfs2_statfs_change *sc, const void *buf);
+extern void gfs2_statfs_change_out(const struct gfs2_statfs_change *sc, void *buf);
+extern void gfs2_quota_change_in(struct gfs2_quota_change *qc, const void *buf);
+
+/* Printing functions */
+
+extern void gfs2_rindex_print(const struct gfs2_rindex *ri);
+extern void gfs2_dinode_print(const struct gfs2_dinode *di);
+
+#endif /* __KERNEL__ */
+
+#endif /* __GFS2_ONDISK_DOT_H__ */
diff --git a/include/linux/lm_interface.h b/include/linux/lm_interface.h
new file mode 100644
index 000000000000..1418fdc9ac02
--- /dev/null
+++ b/include/linux/lm_interface.h
@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
+ * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License version 2.
+ */
+
+#ifndef __LM_INTERFACE_DOT_H__
+#define __LM_INTERFACE_DOT_H__
+
+
+typedef void (*lm_callback_t) (void *ptr, unsigned int type, void *data);
+
+/*
+ * lm_mount() flags
+ *
+ * LM_MFLAG_SPECTATOR
+ * GFS is asking to join the filesystem's lockspace, but it doesn't want to
+ * modify the filesystem.  The lock module shouldn't assign a journal to the FS
+ * mount.  It shouldn't send recovery callbacks to the FS mount.  If the node
+ * dies or withdraws, all locks can be wiped immediately.
+ */
+
+#define LM_MFLAG_SPECTATOR      0x00000001
+
+/*
+ * lm_lockstruct flags
+ *
+ * LM_LSFLAG_LOCAL
+ * The lock_nolock module returns LM_LSFLAG_LOCAL to GFS, indicating that GFS
+ * can make single-node optimizations.
+ */
+
+#define LM_LSFLAG_LOCAL         0x00000001
+
+/*
+ * lm_lockname types
+ */
+
+#define LM_TYPE_RESERVED        0x00
+#define LM_TYPE_NONDISK         0x01
+#define LM_TYPE_INODE           0x02
+#define LM_TYPE_RGRP            0x03
+#define LM_TYPE_META            0x04
+#define LM_TYPE_IOPEN           0x05
+#define LM_TYPE_FLOCK           0x06
+#define LM_TYPE_PLOCK           0x07
+#define LM_TYPE_QUOTA           0x08
+#define LM_TYPE_JOURNAL         0x09
+
+/*
+ * lm_lock() states
+ *
+ * SHARED is compatible with SHARED, not with DEFERRED or EX.
+ * DEFERRED is compatible with DEFERRED, not with SHARED or EX.
+ */
+
+#define LM_ST_UNLOCKED          0
+#define LM_ST_EXCLUSIVE         1
+#define LM_ST_DEFERRED          2
+#define LM_ST_SHARED            3
+
+/*
+ * lm_lock() flags
+ *
+ * LM_FLAG_TRY
+ * Don't wait to acquire the lock if it can't be granted immediately.
+ *
+ * LM_FLAG_TRY_1CB
+ * Send one blocking callback if TRY is set and the lock is not granted.
+ *
+ * LM_FLAG_NOEXP
+ * GFS sets this flag on lock requests it makes while doing journal recovery.
+ * These special requests should not be blocked due to the recovery like
+ * ordinary locks would be.
+ *
+ * LM_FLAG_ANY
+ * A SHARED request may also be granted in DEFERRED, or a DEFERRED request may
+ * also be granted in SHARED.  The preferred state is whichever is compatible
+ * with other granted locks, or the specified state if no other locks exist.
+ *
+ * LM_FLAG_PRIORITY
+ * Override fairness considerations.  Suppose a lock is held in a shared state
+ * and there is a pending request for the deferred state.  A shared lock
+ * request with the priority flag would be allowed to bypass the deferred
+ * request and directly join the other shared lock.  A shared lock request
+ * without the priority flag might be forced to wait until the deferred
+ * requested had acquired and released the lock.
+ */
+
+#define LM_FLAG_TRY             0x00000001
+#define LM_FLAG_TRY_1CB         0x00000002
+#define LM_FLAG_NOEXP           0x00000004
+#define LM_FLAG_ANY             0x00000008
+#define LM_FLAG_PRIORITY        0x00000010
+
+/*
+ * lm_lock() and lm_async_cb return flags
+ *
+ * LM_OUT_ST_MASK
+ * Masks the lower two bits of lock state in the returned value.
+ *
+ * LM_OUT_CACHEABLE
+ * The lock hasn't been released so GFS can continue to cache data for it.
+ *
+ * LM_OUT_CANCELED
+ * The lock request was canceled.
+ *
+ * LM_OUT_ASYNC
+ * The result of the request will be returned in an LM_CB_ASYNC callback.
+ */
+
+#define LM_OUT_ST_MASK          0x00000003
+#define LM_OUT_CACHEABLE        0x00000004
+#define LM_OUT_CANCELED         0x00000008
+#define LM_OUT_ASYNC            0x00000080
+#define LM_OUT_ERROR            0x00000100
+
+/*
+ * lm_callback_t types
+ *
+ * LM_CB_NEED_E LM_CB_NEED_D LM_CB_NEED_S
+ * Blocking callback, a remote node is requesting the given lock in
+ * EXCLUSIVE, DEFERRED, or SHARED.
+ *
+ * LM_CB_NEED_RECOVERY
+ * The given journal needs to be recovered.
+ *
+ * LM_CB_DROPLOCKS
+ * Reduce the number of cached locks.
+ *
+ * LM_CB_ASYNC
+ * The given lock has been granted.
+ */
+
+#define LM_CB_NEED_E            257
+#define LM_CB_NEED_D            258
+#define LM_CB_NEED_S            259
+#define LM_CB_NEED_RECOVERY     260
+#define LM_CB_DROPLOCKS         261
+#define LM_CB_ASYNC             262
+
+/*
+ * lm_recovery_done() messages
+ */
+
+#define LM_RD_GAVEUP            308
+#define LM_RD_SUCCESS           309
+
+
+struct lm_lockname {
+        u64 ln_number;
+        unsigned int ln_type;
+};
+
+#define lm_name_equal(name1, name2) \
+        (((name1)->ln_number == (name2)->ln_number) && \
+         ((name1)->ln_type == (name2)->ln_type)) \
+
+struct lm_async_cb {
+        struct lm_lockname lc_name;
+        int lc_ret;
+};
+
+struct lm_lockstruct;
+
+struct lm_lockops {
+        const char *lm_proto_name;
+
+        /*
+         * Mount/Unmount
+         */
+
+        int (*lm_mount) (char *table_name, char *host_data,
+                         lm_callback_t cb, void *cb_data,
+                         unsigned int min_lvb_size, int flags,
+                         struct lm_lockstruct *lockstruct,
+                         struct kobject *fskobj);
+
+        void (*lm_others_may_mount) (void *lockspace);
+
+        void (*lm_unmount) (void *lockspace);
+
+        void (*lm_withdraw) (void *lockspace);
+
+        /*
+         * Lock oriented operations
+         */
+
+        int (*lm_get_lock) (void *lockspace, struct lm_lockname *name, void **lockp);
+
+        void (*lm_put_lock) (void *lock);
+
+        unsigned int (*lm_lock) (void *lock, unsigned int cur_state,
+                                 unsigned int req_state, unsigned int flags);
+
+        unsigned int (*lm_unlock) (void *lock, unsigned int cur_state);
+
+        void (*lm_cancel) (void *lock);
+
+        int (*lm_hold_lvb) (void *lock, char **lvbp);
+        void (*lm_unhold_lvb) (void *lock, char *lvb);
+
+        /*
+         * Posix Lock oriented operations
+         */
+
+        int (*lm_plock_get) (void *lockspace, struct lm_lockname *name,
+                             struct file *file, struct file_lock *fl);
+
+        int (*lm_plock) (void *lockspace, struct lm_lockname *name,
+                         struct file *file, int cmd, struct file_lock *fl);
+
+        int (*lm_punlock) (void *lockspace, struct lm_lockname *name,
+                           struct file *file, struct file_lock *fl);
+
+        /*
+         * Client oriented operations
+         */
+
+        void (*lm_recovery_done) (void *lockspace, unsigned int jid,
+                                  unsigned int message);
+
+        struct module *lm_owner;
+};
+
+/*
+ * lm_mount() return values
+ *
+ * ls_jid - the journal ID this node should use
+ * ls_first - this node is the first to mount the file system
+ * ls_lvb_size - size in bytes of lock value blocks
+ * ls_lockspace - lock module's context for this file system
+ * ls_ops - lock module's functions
+ * ls_flags - lock module features
+ */
+
+struct lm_lockstruct {
+        unsigned int ls_jid;
+        unsigned int ls_first;
+        unsigned int ls_lvb_size;
+        void *ls_lockspace;
+        const struct lm_lockops *ls_ops;
+        int ls_flags;
+};
+
+/*
+ * Lock module bottom interface.  A lock module makes itself available to GFS
+ * with these functions.
+ */
+
+int gfs2_register_lockproto(const struct lm_lockops *proto);
+void gfs2_unregister_lockproto(const struct lm_lockops *proto);
+
+/*
+ * Lock module top interface.  GFS calls these functions when mounting or
+ * unmounting a file system.
+ */
+
+int gfs2_mount_lockproto(char *proto_name, char *table_name, char *host_data,
+                         lm_callback_t cb, void *cb_data,
+                         unsigned int min_lvb_size, int flags,
+                         struct lm_lockstruct *lockstruct,
+                         struct kobject *fskobj);
+
+void gfs2_unmount_lockproto(struct lm_lockstruct *lockstruct);
+
+void gfs2_withdraw_lockproto(struct lm_lockstruct *lockstruct);
+
+#endif /* __LM_INTERFACE_DOT_H__ */
+
diff --git a/include/linux/lock_dlm_plock.h b/include/linux/lock_dlm_plock.h
new file mode 100644
index 000000000000..fc3415113973
--- /dev/null
+++ b/include/linux/lock_dlm_plock.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2005 Red Hat, Inc.  All rights reserved.
+ *
+ * This copyrighted material is made available to anyone wishing to use,
+ * modify, copy, or redistribute it subject to the terms and conditions
+ * of the GNU General Public License v.2.
+ */
+
+#ifndef __LOCK_DLM_PLOCK_DOT_H__
+#define __LOCK_DLM_PLOCK_DOT_H__
+
+#define GDLM_PLOCK_MISC_NAME            "lock_dlm_plock"
+
+#define GDLM_PLOCK_VERSION_MAJOR        1
+#define GDLM_PLOCK_VERSION_MINOR        1
+#define GDLM_PLOCK_VERSION_PATCH        0
+
+enum {
+        GDLM_PLOCK_OP_LOCK = 1,
+        GDLM_PLOCK_OP_UNLOCK,
+        GDLM_PLOCK_OP_GET,
+};
+
+struct gdlm_plock_info {
+        __u32 version[3];
+        __u8 optype;
+        __u8 ex;
+        __u8 wait;
+        __u8 pad;
+        __u32 pid;
+        __s32 nodeid;
+        __s32 rv;
+        __u32 fsid;
+        __u64 number;
+        __u64 start;
+        __u64 end;
+        __u64 owner;
+};
+
+#endif
+