NAME

       dlm_create_lockspace,  dlm_open_lockspace,  dlm_close_lockspace,  dlm_release_lockspace  -
       manipulate DLM lockspaces

SYNOPSIS

        #include <libdlm.h>

       dlm_lshandle_t dlm_create_lockspace(const char *name, mode_t mode);
       dlm_lshandle_t dlm_new_lockspace(const char *name, mode_t mode,
                                        uint32_t flags);
       dlm_lshandle_t dlm_open_lockspace(const char *name);
       int dlm_close_lockspace(dlm_lshandle_t ls);
       int dlm_release_lockspace(const char *name, dlm_lshandle_t ls,
                                 int force);

DESCRIPTION

       The DLM allows locks to be partitioned into "lockspaces", and these can be manipulated  by
       userspace  calls.  It  is  possible  (though  not  recommended) for an application to have
       multiple lockspaces open at one time.

       Many of the DLM calls work on the "default" lockspace,  which  should  be  fine  for  most
       users.  The  calls with _ls_ in them allow you to isolate your application from all others
       running in the cluster. Remember, lockspaces are a cluster-wide resource, so if you create
       a lockspace called "myls" it will share locks with a lockspace called "myls" on all nodes.
       These calls allow users to create & remove lockspaces, and users to  connect  to  existing
       lockspace to store their locks there.

   dlm_lshandle_t dlm_create_lockspace(const char *name, mode_t mode);
       This  creates a lockspace called <name> and the mode of the file user to access it will be
       <mode> (subject to umask as usual). The lockspace must not already exist on this node,  if
       it  does  -1  will  be returned and errno will be set to EEXIST. If you really want to use
       this lockspace you can then use dlm_open_lockspace() below. The name is the name of a misc
       device that will be created in /dev/misc.
       On  success  a  handle  to  the  lockspace  is  returned,  which  can be used to pass into
       subsequent dlm_ls_lock/unlock calls. Make no assumptions as to the content of this  handle
       as it's content may change in future.
       The caller must have CAP_SYSADMIN privileges to do this operation.

       Return codes: 0 is returned if the call completed successfully. If not, -1 is returned and
       errno is set to one of the following:
       EINVAL          An invalid parameter was passed to the call
       ENOMEM          A (kernel) memory allocation failed
       EEXIST          The lockspace already exists
       EPERM           Process does not have capability to create lockspaces
       ENOSYS          A fatal error occurred initializing the DLM
       Any error returned by the open() system call

   int dlm_new_lockspace(const char *name, mode_t mode, uint32_t flags)
       Performs the same function as dlm_create_lockspace() above, but passes some creation flags
       to the call that affect the lockspace being created.

   int dlm_release_lockspace(const char *name, dlm_lshandle_t ls, int force)
       Deletes  a lockspace. If the lockspace still has active locks then -1 will be returned and
       errno set to EBUSY. Both the lockspace handle /and/ the name must be specified. This  call
       also closes the lockspace and stops the thread associated with the lockspace, if any.
       Note  that  other  nodes  in the cluster may still have locks open on this lockspace. This
       call only removes the lockspace from the current node.  If the force flag is set then  the
       lockspace  will  be  removed  even  if  another  user on this node has active locks in it.
       Existing users will NOT be notified if you do this, so be careful.
       The caller must have CAP_SYSADMIN privileges to do this operation.

       Return codes: 0 is returned if the call completed successfully. If not, -1 is returned and
       errno is set to one of the following:
       EINVAL          An invalid parameter was passed to the call
       EPERM           Process does not have capability to release lockspaces
       EBUSY           The lockspace could not be freed because it still
                       contains locks and force was not set.

   dlm_lshandle_t dlm_open_lockspace(const char *name)
       Opens an already existing lockspace and returns a handle to it.

       Return codes: 0 is returned if the call completed successfully. If not, -1 is returned and
       errno is set to an error returned by the open() system call

   int dlm_close_lockspace(dlm_lshandle_t ls)
       Close the lockspace. Any locks held by  this  process  will  be  freed.  If  a  thread  is
       associated with this lockspace then it will be stopped.

       Return codes: 0 is returned if the call completed successfully. If not, -1 is returned and
       errno is set to one of the following:
       EINVAL         lockspace was not a valid lockspace handle

SEE ALSO

       libdlm(3), dlm_unlock(3), dlm_lock(3),