home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / linux / dlm.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  9.2 KB  |  303 lines
  1. /******************************************************************************
  2. *******************************************************************************
  3. **
  4. **  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
  5. **  Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
  6. **
  7. **  This copyrighted material is made available to anyone wishing to use,
  8. **  modify, copy, or redistribute it subject to the terms and conditions
  9. **  of the GNU General Public License v.2.
  10. **
  11. *******************************************************************************
  12. ******************************************************************************/
  13.  
  14. #ifndef __DLM_DOT_H__
  15. #define __DLM_DOT_H__
  16.  
  17. /*
  18.  * Interface to Distributed Lock Manager (DLM)
  19.  * routines and structures to use DLM lockspaces
  20.  */
  21.  
  22. /*
  23.  * Lock Modes
  24.  */
  25.  
  26. #define DLM_LOCK_IV        -1    /* invalid */
  27. #define DLM_LOCK_NL        0    /* null */
  28. #define DLM_LOCK_CR        1    /* concurrent read */
  29. #define DLM_LOCK_CW        2    /* concurrent write */
  30. #define DLM_LOCK_PR        3    /* protected read */
  31. #define DLM_LOCK_PW        4    /* protected write */
  32. #define DLM_LOCK_EX        5    /* exclusive */
  33.  
  34. /*
  35.  * Maximum size in bytes of a dlm_lock name
  36.  */
  37.  
  38. #define DLM_RESNAME_MAXLEN    64
  39.  
  40. /*
  41.  * Flags to dlm_lock
  42.  *
  43.  * DLM_LKF_NOQUEUE
  44.  *
  45.  * Do not queue the lock request on the wait queue if it cannot be granted
  46.  * immediately.  If the lock cannot be granted because of this flag, DLM will
  47.  * either return -EAGAIN from the dlm_lock call or will return 0 from
  48.  * dlm_lock and -EAGAIN in the lock status block when the AST is executed.
  49.  *
  50.  * DLM_LKF_CANCEL
  51.  *
  52.  * Used to cancel a pending lock request or conversion.  A converting lock is
  53.  * returned to its previously granted mode.
  54.  *
  55.  * DLM_LKF_CONVERT
  56.  *
  57.  * Indicates a lock conversion request.  For conversions the name and namelen
  58.  * are ignored and the lock ID in the LKSB is used to identify the lock.
  59.  *
  60.  * DLM_LKF_VALBLK
  61.  *
  62.  * Requests DLM to return the current contents of the lock value block in the
  63.  * lock status block.  When this flag is set in a lock conversion from PW or EX
  64.  * modes, DLM assigns the value specified in the lock status block to the lock
  65.  * value block of the lock resource.  The LVB is a DLM_LVB_LEN size array
  66.  * containing application-specific information.
  67.  *
  68.  * DLM_LKF_QUECVT
  69.  *
  70.  * Force a conversion request to be queued, even if it is compatible with
  71.  * the granted modes of other locks on the same resource.
  72.  *
  73.  * DLM_LKF_IVVALBLK
  74.  *
  75.  * Invalidate the lock value block.
  76.  *
  77.  * DLM_LKF_CONVDEADLK
  78.  *
  79.  * Allows the dlm to resolve conversion deadlocks internally by demoting the
  80.  * granted mode of a converting lock to NL.  The DLM_SBF_DEMOTED flag is
  81.  * returned for a conversion that's been effected by this.
  82.  *
  83.  * DLM_LKF_PERSISTENT
  84.  *
  85.  * Only relevant to locks originating in userspace.  A persistent lock will not
  86.  * be removed if the process holding the lock exits.
  87.  *
  88.  * DLM_LKF_NODLKWT
  89.  * DLM_LKF_NODLCKBLK
  90.  *
  91.  * net yet implemented
  92.  *
  93.  * DLM_LKF_EXPEDITE
  94.  *
  95.  * Used only with new requests for NL mode locks.  Tells the lock manager
  96.  * to grant the lock, ignoring other locks in convert and wait queues.
  97.  *
  98.  * DLM_LKF_NOQUEUEBAST
  99.  *
  100.  * Send blocking AST's before returning -EAGAIN to the caller.  It is only
  101.  * used along with the NOQUEUE flag.  Blocking AST's are not sent for failed
  102.  * NOQUEUE requests otherwise.
  103.  *
  104.  * DLM_LKF_HEADQUE
  105.  *
  106.  * Add a lock to the head of the convert or wait queue rather than the tail.
  107.  *
  108.  * DLM_LKF_NOORDER
  109.  *
  110.  * Disregard the standard grant order rules and grant a lock as soon as it
  111.  * is compatible with other granted locks.
  112.  *
  113.  * DLM_LKF_ORPHAN
  114.  *
  115.  * not yet implemented
  116.  *
  117.  * DLM_LKF_ALTPR
  118.  *
  119.  * If the requested mode cannot be granted immediately, try to grant the lock
  120.  * in PR mode instead.  If this alternate mode is granted instead of the
  121.  * requested mode, DLM_SBF_ALTMODE is returned in the lksb.
  122.  *
  123.  * DLM_LKF_ALTCW
  124.  *
  125.  * The same as ALTPR, but the alternate mode is CW.
  126.  *
  127.  * DLM_LKF_FORCEUNLOCK
  128.  *
  129.  * Unlock the lock even if it is converting or waiting or has sublocks.
  130.  * Only really for use by the userland device.c code.
  131.  *
  132.  */
  133.  
  134. #define DLM_LKF_NOQUEUE        0x00000001
  135. #define DLM_LKF_CANCEL        0x00000002
  136. #define DLM_LKF_CONVERT        0x00000004
  137. #define DLM_LKF_VALBLK        0x00000008
  138. #define DLM_LKF_QUECVT        0x00000010
  139. #define DLM_LKF_IVVALBLK    0x00000020
  140. #define DLM_LKF_CONVDEADLK    0x00000040
  141. #define DLM_LKF_PERSISTENT    0x00000080
  142. #define DLM_LKF_NODLCKWT    0x00000100
  143. #define DLM_LKF_NODLCKBLK    0x00000200
  144. #define DLM_LKF_EXPEDITE    0x00000400
  145. #define DLM_LKF_NOQUEUEBAST    0x00000800
  146. #define DLM_LKF_HEADQUE        0x00001000
  147. #define DLM_LKF_NOORDER        0x00002000
  148. #define DLM_LKF_ORPHAN        0x00004000
  149. #define DLM_LKF_ALTPR        0x00008000
  150. #define DLM_LKF_ALTCW        0x00010000
  151. #define DLM_LKF_FORCEUNLOCK    0x00020000
  152.  
  153. /*
  154.  * Some return codes that are not in errno.h
  155.  */
  156.  
  157. #define DLM_ECANCEL        0x10001
  158. #define DLM_EUNLOCK        0x10002
  159.  
  160. typedef void dlm_lockspace_t;
  161.  
  162. /*
  163.  * Lock status block
  164.  *
  165.  * Use this structure to specify the contents of the lock value block.  For a
  166.  * conversion request, this structure is used to specify the lock ID of the
  167.  * lock.  DLM writes the status of the lock request and the lock ID assigned
  168.  * to the request in the lock status block.
  169.  *
  170.  * sb_lkid: the returned lock ID.  It is set on new (non-conversion) requests.
  171.  * It is available when dlm_lock returns.
  172.  *
  173.  * sb_lvbptr: saves or returns the contents of the lock's LVB according to rules
  174.  * shown for the DLM_LKF_VALBLK flag.
  175.  *
  176.  * sb_flags: DLM_SBF_DEMOTED is returned if in the process of promoting a lock,
  177.  * it was first demoted to NL to avoid conversion deadlock.
  178.  * DLM_SBF_VALNOTVALID is returned if the resource's LVB is marked invalid.
  179.  *
  180.  * sb_status: the returned status of the lock request set prior to AST
  181.  * execution.  Possible return values:
  182.  *
  183.  * 0 if lock request was successful
  184.  * -EAGAIN if request would block and is flagged DLM_LKF_NOQUEUE
  185.  * -ENOMEM if there is no memory to process request
  186.  * -EINVAL if there are invalid parameters
  187.  * -DLM_EUNLOCK if unlock request was successful
  188.  * -DLM_ECANCEL if a cancel completed successfully
  189.  */
  190.  
  191. #define DLM_SBF_DEMOTED        0x01
  192. #define DLM_SBF_VALNOTVALID    0x02
  193. #define DLM_SBF_ALTMODE        0x04
  194.  
  195. struct dlm_lksb {
  196.     int      sb_status;
  197.     uint32_t sb_lkid;
  198.     char      sb_flags;
  199.     char *     sb_lvbptr;
  200. };
  201.  
  202.  
  203. #ifdef __KERNEL__
  204.  
  205. #define DLM_LSFL_NODIR        0x00000001
  206.  
  207. /*
  208.  * dlm_new_lockspace
  209.  *
  210.  * Starts a lockspace with the given name.  If the named lockspace exists in
  211.  * the cluster, the calling node joins it.
  212.  */
  213.  
  214. int dlm_new_lockspace(char *name, int namelen, dlm_lockspace_t **lockspace,
  215.               uint32_t flags, int lvblen);
  216.  
  217. /*
  218.  * dlm_release_lockspace
  219.  *
  220.  * Stop a lockspace.
  221.  */
  222.  
  223. int dlm_release_lockspace(dlm_lockspace_t *lockspace, int force);
  224.  
  225. /*
  226.  * dlm_lock
  227.  *
  228.  * Make an asyncronous request to acquire or convert a lock on a named
  229.  * resource.
  230.  *
  231.  * lockspace: context for the request
  232.  * mode: the requested mode of the lock (DLM_LOCK_)
  233.  * lksb: lock status block for input and async return values
  234.  * flags: input flags (DLM_LKF_)
  235.  * name: name of the resource to lock, can be binary
  236.  * namelen: the length in bytes of the resource name (MAX_RESNAME_LEN)
  237.  * parent: the lock ID of a parent lock or 0 if none
  238.  * lockast: function DLM executes when it completes processing the request
  239.  * astarg: argument passed to lockast and bast functions
  240.  * bast: function DLM executes when this lock later blocks another request
  241.  *
  242.  * Returns:
  243.  * 0 if request is successfully queued for processing
  244.  * -EINVAL if any input parameters are invalid
  245.  * -EAGAIN if request would block and is flagged DLM_LKF_NOQUEUE
  246.  * -ENOMEM if there is no memory to process request
  247.  * -ENOTCONN if there is a communication error
  248.  *
  249.  * If the call to dlm_lock returns an error then the operation has failed and
  250.  * the AST routine will not be called.  If dlm_lock returns 0 it is still
  251.  * possible that the lock operation will fail. The AST routine will be called
  252.  * when the locking is complete and the status is returned in the lksb.
  253.  *
  254.  * If the AST routines or parameter are passed to a conversion operation then
  255.  * they will overwrite those values that were passed to a previous dlm_lock
  256.  * call.
  257.  *
  258.  * AST routines should not block (at least not for long), but may make
  259.  * any locking calls they please.
  260.  */
  261.  
  262. int dlm_lock(dlm_lockspace_t *lockspace,
  263.          int mode,
  264.          struct dlm_lksb *lksb,
  265.          uint32_t flags,
  266.          void *name,
  267.          unsigned int namelen,
  268.          uint32_t parent_lkid,
  269.          void (*lockast) (void *astarg),
  270.          void *astarg,
  271.          void (*bast) (void *astarg, int mode));
  272.  
  273. /*
  274.  * dlm_unlock
  275.  *
  276.  * Asynchronously release a lock on a resource.  The AST routine is called
  277.  * when the resource is successfully unlocked.
  278.  *
  279.  * lockspace: context for the request
  280.  * lkid: the lock ID as returned in the lksb
  281.  * flags: input flags (DLM_LKF_)
  282.  * lksb: if NULL the lksb parameter passed to last lock request is used
  283.  * astarg: the arg used with the completion ast for the unlock
  284.  *
  285.  * Returns:
  286.  * 0 if request is successfully queued for processing
  287.  * -EINVAL if any input parameters are invalid
  288.  * -ENOTEMPTY if the lock still has sublocks
  289.  * -EBUSY if the lock is waiting for a remote lock operation
  290.  * -ENOTCONN if there is a communication error
  291.  */
  292.  
  293. int dlm_unlock(dlm_lockspace_t *lockspace,
  294.            uint32_t lkid,
  295.            uint32_t flags,
  296.            struct dlm_lksb *lksb,
  297.            void *astarg);
  298.  
  299. #endif                /* __KERNEL__ */
  300.  
  301. #endif                /* __DLM_DOT_H__ */
  302.  
  303.