[PATCHES] Add gpfs.h to always build vfs_gpfs module
Christof Schmitt
cs at samba.org
Sat Jan 12 03:46:39 UTC 2019
Compiling the vfs_gfs module only requires the gpfs.h header file that
is available under a license allowing the distribution of the file. The
attached patches add that header file to third_party and use it by
default on Linux. My goal here is to always build the gpfs code in
autobuild, so that any build breakage (e.g. from vfs changes) is detected
early.
Christof
-------------- next part --------------
From 1f562d1154b8d14269ad6a3ca7af7539b5ad3553 Mon Sep 17 00:00:00 2001
From: Christof Schmitt <cs at samba.org>
Date: Fri, 11 Jan 2019 15:02:03 -0700
Subject: [PATCH 1/3] wscript: Make non_posix_acls a subsystem
This fixes a build error when building vfs_gpfs as static module:
ERROR: circular library dependency between smbd_base and non_posix_acls
Signed-off-by: Christof Schmitt <cs at samba.org>
---
source3/modules/wscript_build | 5 ++---
1 file changed, 2 insertions(+), 3 deletions(-)
diff --git a/source3/modules/wscript_build b/source3/modules/wscript_build
index db083f50646..ef1d476ef6a 100644
--- a/source3/modules/wscript_build
+++ b/source3/modules/wscript_build
@@ -12,10 +12,9 @@ bld.SAMBA3_SUBSYSTEM('POSIXACL_XATTR',
enabled=(bld.SAMBA3_IS_ENABLED_MODULE('vfs_ceph') or bld.SAMBA3_IS_ENABLED_MODULE('vfs_glusterfs')),
deps='acl attr')
-bld.SAMBA3_LIBRARY('non_posix_acls',
+bld.SAMBA3_SUBSYSTEM('non_posix_acls',
source='non_posix_acls.c',
- deps='samba-util vfs',
- private_library=True)
+ deps='samba-util vfs')
bld.SAMBA3_SUBSYSTEM('VFS_VIRUSFILTER_UTILS',
source='vfs_virusfilter_utils.c',
--
2.17.0
From cd86dc6b56ab6155d2d8dc415877abc6e96d4017 Mon Sep 17 00:00:00 2001
From: Christof Schmitt <cs at samba.org>
Date: Tue, 19 Dec 2017 15:11:43 -0700
Subject: [PATCH 2/3] third_party: Add gpfs.h header file
This is the only requirement for building the vfs_gpfs module; the
corresponding library is opened through dlopen at runtime. The intent
here is to always build the vfs_gpfs module to easily detect breakage
e.g. due to vfs interface changes.
Signed-off-by: Christof Schmitt <cs at samba.org>
---
third_party/gpfs/gpfs.h | 4042 +++++++++++++++++++++++++++++++++++++++
1 file changed, 4042 insertions(+)
create mode 100644 third_party/gpfs/gpfs.h
diff --git a/third_party/gpfs/gpfs.h b/third_party/gpfs/gpfs.h
new file mode 100644
index 00000000000..acafe12c2e7
--- /dev/null
+++ b/third_party/gpfs/gpfs.h
@@ -0,0 +1,4042 @@
+/* */
+/* Copyright (C) 2001 International Business Machines */
+/* All rights reserved. */
+/* */
+/* This file is part of the GPFS user library. */
+/* */
+/* Redistribution and use in source and binary forms, with or without */
+/* modification, are permitted provided that the following conditions */
+/* are met: */
+/* */
+/* 1. Redistributions of source code must retain the above copyright notice, */
+/* this list of conditions and the following disclaimer. */
+/* 2. Redistributions in binary form must reproduce the above copyright */
+/* notice, this list of conditions and the following disclaimer in the */
+/* documentation and/or other materials provided with the distribution. */
+/* 3. The name of the author may not be used to endorse or promote products */
+/* derived from this software without specific prior written */
+/* permission. */
+/* */
+/* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR */
+/* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES */
+/* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. */
+/* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */
+/* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, */
+/* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; */
+/* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, */
+/* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR */
+/* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF */
+/* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
+/* */
+/* @(#)42 1.1.12.3 src/avs/fs/mmfs/ts/util/gpfs.h, mmfs, avs_rttn423, rttn423s001a 4/10/17 10:46:33 */
+/*
+ * Library calls for GPFS interfaces
+ */
+#ifndef H_GPFS
+#define H_GPFS
+
+#include <stddef.h>
+
+/* Define GPFS_64BIT_INODES to map the default interface definitions
+ to 64-bit interfaces. Without this define, the 32-bit interface
+ is the default. Both interfaces are always present, but the
+ define sets the default. The actual mapping can be found near the
+ end of this header. */
+/* #define GPFS_64BIT_INODES 1 */
+
+#define NFS_IP_SIZE 32
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(WIN32) && defined(GPFSDLL)
+
+ /* The following errno values either are missing from Windows errno.h or
+ have a conflicting value. Other errno values (e.g. EPERM) are okay. */
+ #define GPFS_EALREADY 37 /* Operation already in progress */
+ #define GPFS_EOPNOTSUPP 45 /* Operation not supported */
+ #define GPFS_EDQUOT 69 /* Disk quota exceeded */
+ #define GPFS_ESTALE 9 /* No file system (mapped to EBADF) */
+ #define GPFS_EFORMAT 19 /* Unformatted media (mapped to ENODEV) */
+
+ /* specify the library calling convention */
+ #define GPFS_API __stdcall
+
+ /* On Windows, this is a HANDLE as returned by CreateFile() */
+ typedef void* gpfs_file_t;
+
+#else /* not gpfs.dll on Windows */
+
+ #define GPFS_API
+ /* On UNIX systems, this is a file descriptor as returned by open() */
+ typedef int gpfs_file_t;
+
+#endif
+
+
+typedef unsigned int gpfs_uid_t;
+typedef long long gpfs_off64_t;
+typedef unsigned long long gpfs_uid64_t;
+
+typedef struct gpfs_timestruc
+{
+ unsigned int tv_sec;
+ unsigned int tv_nsec;
+} gpfs_timestruc_t;
+
+typedef struct gpfs_timestruc64
+{
+ long long tv_sec;
+ unsigned int tv_nsec;
+} gpfs_timestruc64_t;
+
+#define GPFS_SLITE_SIZE_BIT 0x00000001
+#define GPFS_SLITE_BLKSIZE_BIT 0x00000002
+#define GPFS_SLITE_BLOCKS_BIT 0x00000004
+#define GPFS_SLITE_ATIME_BIT 0x00000010
+#define GPFS_SLITE_MTIME_BIT 0x00000020
+#define GPFS_SLITE_CTIME_BIT 0x00000040
+#define GPFS_SLITE_EXACT_BITS 0x00000077
+
+/* Returns "1" if the attribute is requested to be accurate.
+ (On output, indicates the value returned in statbufP is accurate). */
+#define GPFS_SLITE(m) (0 == (m))
+#define GPFS_SLITE_SIZET(m) (0 != ((m) & GPFS_SLITE_SIZE_BIT))
+#define GPFS_SLITE_BLKSIZE(m) (0 != ((m) & GPFS_SLITE_BLKSIZE_BIT))
+#define GPFS_SLITE_BLOCKS(m) (0 != ((m) & GPFS_SLITE_BLOCKS_BIT))
+#define GPFS_SLITE_ATIME(m) (0 != ((m) & GPFS_SLITE_ATIME_BIT))
+#define GPFS_SLITE_MTIME(m) (0 != ((m) & GPFS_SLITE_MTIME_BIT))
+#define GPFS_SLITE_CTIME(m) (0 != ((m) & GPFS_SLITE_CTIME_BIT))
+#define GPFS_SLITE_EXACT(m) (GPFS_SLITE_EXACT_BITS == (m))
+
+/* Sets the litemask bit indicating that the attribute should be accurate */
+#define GPFS_S_SLITE(m) (m) = 0
+#define GPFS_S_SLITE_SIZET(m) (m) |= GPFS_SLITE_SIZE_BIT
+#define GPFS_S_SLITE_BLKSIZE(m) (m) |= GPFS_SLITE_BLKSIZE_BIT
+#define GPFS_S_SLITE_BLOCKS(m) (m) |= GPFS_SLITE_BLOCKS_BIT
+#define GPFS_S_SLITE_ATIME(m) (m) |= GPFS_SLITE_ATIME_BIT
+#define GPFS_S_SLITE_MTIME(m) (m) |= GPFS_SLITE_MTIME_BIT
+#define GPFS_S_SLITE_CTIME(m) (m) |= GPFS_SLITE_CTIME_BIT
+#define GPFS_S_SLITE_EXACT(m) (m) |= GPFS_SLITE_EXACT_BITS
+
+#define GPFS_STATLITE 0
+#define GPFS_NOFOLLOW 1
+
+/* Mapping of buffer for gpfs_getacl, gpfs_putacl. */
+typedef struct gpfs_opaque_acl
+{
+ int acl_buffer_len; /* INPUT: Total size of buffer (including this field).
+ OUTPUT: Actual size of the ACL information. */
+ unsigned short acl_version; /* INPUT: Set to zero.
+ OUTPUT: Current version of the returned ACL. */
+ unsigned char acl_type; /* INPUT: Type of ACL: access (1) or default (2). */
+ char acl_var_data[1]; /* OUTPUT: Remainder of the ACL information. */
+} gpfs_opaque_acl_t;
+
+/* ACL types (acl_type field in gpfs_opaque_acl_t or gpfs_acl_t) */
+#define GPFS_ACL_TYPE_ACCESS 1
+#define GPFS_ACL_TYPE_DEFAULT 2
+#define GPFS_ACL_TYPE_NFS4 3
+
+/* gpfs_getacl, gpfs_putacl flag indicating structures instead of the
+ opaque style data normally used. */
+#define GPFS_GETACL_STRUCT 0x00000020
+#define GPFS_PUTACL_STRUCT 0x00000020
+
+/* gpfs_getacl, gpfs_putacl flag indicating smbd is the caller */
+#define GPFS_ACL_SAMBA 0x00000040
+
+/* Defined values for gpfs_aclVersion_t */
+#define GPFS_ACL_VERSION_POSIX 1
+#define GPFS_ACL_VERSION_NFS4F 3 /* GPFS_ACL_VERSION_NFS4 plus V4FLAGS */
+#define GPFS_ACL_VERSION_NFS4 4
+
+/* Values for gpfs_aclLevel_t */
+#define GPFS_ACL_LEVEL_BASE 0 /* compatible with all acl_version values */
+#define GPFS_ACL_LEVEL_V4FLAGS 1 /* requires GPFS_ACL_VERSION_NFS4 */
+
+/* Values for gpfs_aceType_t (ACL_VERSION_POSIX) */
+#define GPFS_ACL_USER_OBJ 1
+#define GPFS_ACL_GROUP_OBJ 2
+#define GPFS_ACL_OTHER 3
+#define GPFS_ACL_MASK 4
+#define GPFS_ACL_USER 5
+#define GPFS_ACL_GROUP 6
+
+/* Values for gpfs_acePerm_t (ACL_VERSION_POSIX) */
+#define ACL_PERM_EXECUTE 001
+#define ACL_PERM_WRITE 002
+#define ACL_PERM_READ 004
+#define ACL_PERM_CONTROL 010
+
+/* Values for gpfs_aceType_t (ACL_VERSION_NFS4) */
+#define ACE4_TYPE_ALLOW 0
+#define ACE4_TYPE_DENY 1
+#define ACE4_TYPE_AUDIT 2
+#define ACE4_TYPE_ALARM 3
+
+/* Values for gpfs_aceFlags_t (ACL_VERSION_NFS4) */
+#define ACE4_FLAG_FILE_INHERIT 0x00000001
+#define ACE4_FLAG_DIR_INHERIT 0x00000002
+#define ACE4_FLAG_NO_PROPAGATE 0x00000004
+#define ACE4_FLAG_INHERIT_ONLY 0x00000008
+#define ACE4_FLAG_SUCCESSFUL 0x00000010
+#define ACE4_FLAG_FAILED 0x00000020
+#define ACE4_FLAG_GROUP_ID 0x00000040
+#define ACE4_FLAG_INHERITED 0x00000080
+
+/* GPFS-defined flags. Placed in a separate ACL field to avoid
+ ever running into newly defined NFSv4 flags. */
+#define ACE4_IFLAG_SPECIAL_ID 0x80000000
+
+/* Values for gpfs_aceMask_t (ACL_VERSION_NFS4) */
+#define ACE4_MASK_READ 0x00000001
+#define ACE4_MASK_LIST_DIR 0x00000001
+#define ACE4_MASK_WRITE 0x00000002
+#define ACE4_MASK_ADD_FILE 0x00000002
+#define ACE4_MASK_APPEND 0x00000004
+#define ACE4_MASK_ADD_SUBDIR 0x00000004
+#define ACE4_MASK_READ_NAMED 0x00000008
+#define ACE4_MASK_WRITE_NAMED 0x00000010
+#define ACE4_MASK_EXECUTE 0x00000020
+
+/* The rfc doesn't provide a mask equivalent to "search" ("x" on a
+ * directory in posix), but it also doesn't say that its EXECUTE
+ * is to have this dual use (even though it does so for other dual
+ * use permissions such as read/list. Going to make the assumption
+ * here that the EXECUTE bit has this dual meaning... otherwise
+ * we're left with no control over search.
+ */
+#define ACE4_MASK_SEARCH 0x00000020
+
+#define ACE4_MASK_DELETE_CHILD 0x00000040
+#define ACE4_MASK_READ_ATTR 0x00000080
+#define ACE4_MASK_WRITE_ATTR 0x00000100
+#define ACE4_MASK_DELETE 0x00010000
+#define ACE4_MASK_READ_ACL 0x00020000
+#define ACE4_MASK_WRITE_ACL 0x00040000
+#define ACE4_MASK_WRITE_OWNER 0x00080000
+#define ACE4_MASK_SYNCHRONIZE 0x00100000
+#define ACE4_MASK_ALL 0x001f01ff
+
+/* Values for gpfs_uid_t (ACL_VERSION_NFS4) */
+#define ACE4_SPECIAL_OWNER 1
+#define ACE4_SPECIAL_GROUP 2
+#define ACE4_SPECIAL_EVERYONE 3
+
+/* per-ACL flags imported from a Windows security descriptor object */
+#define ACL4_FLAG_OWNER_DEFAULTED 0x00000100
+#define ACL4_FLAG_GROUP_DEFAULTED 0x00000200
+#define ACL4_FLAG_DACL_PRESENT 0x00000400
+#define ACL4_FLAG_DACL_DEFAULTED 0x00000800
+#define ACL4_FLAG_SACL_PRESENT 0x00001000
+#define ACL4_FLAG_SACL_DEFAULTED 0x00002000
+#define ACL4_FLAG_DACL_UNTRUSTED 0x00004000
+#define ACL4_FLAG_SERVER_SECURITY 0x00008000
+#define ACL4_FLAG_DACL_AUTO_INHERIT_REQ 0x00010000
+#define ACL4_FLAG_SACL_AUTO_INHERIT_REQ 0x00020000
+#define ACL4_FLAG_DACL_AUTO_INHERITED 0x00040000
+#define ACL4_FLAG_SACL_AUTO_INHERITED 0x00080000
+#define ACL4_FLAG_DACL_PROTECTED 0x00100000
+#define ACL4_FLAG_SACL_PROTECTED 0x00200000
+#define ACL4_FLAG_RM_CONTROL_VALID 0x00400000
+#define ACL4_FLAG_NULL_DACL 0x00800000
+#define ACL4_FLAG_NULL_SACL 0x01000000
+#define ACL4_FLAG_VALID_FLAGS 0x01ffff00
+
+
+/* Externalized ACL defintions */
+typedef unsigned int gpfs_aclType_t;
+typedef unsigned int gpfs_aclLen_t;
+typedef unsigned int gpfs_aclLevel_t;
+typedef unsigned int gpfs_aclVersion_t;
+typedef unsigned int gpfs_aclCount_t;
+typedef unsigned int gpfs_aclFlag_t;
+
+typedef unsigned int gpfs_aceType_t;
+typedef unsigned int gpfs_aceFlags_t;
+typedef unsigned int gpfs_acePerm_t;
+typedef unsigned int gpfs_aceMask_t;
+
+/* A POSIX ACL Entry */
+typedef struct gpfs_ace_v1
+{
+ gpfs_aceType_t ace_type; /* POSIX ACE type */
+ gpfs_uid_t ace_who; /* uid/gid */
+ gpfs_acePerm_t ace_perm; /* POSIX permissions */
+} gpfs_ace_v1_t;
+
+/* An NFSv4 ACL Entry */
+typedef struct gpfs_ace_v4
+{
+ gpfs_aceType_t aceType; /* Allow or Deny */
+ gpfs_aceFlags_t aceFlags; /* Inherit specifications, etc. */
+ gpfs_aceFlags_t aceIFlags; /* GPFS Internal flags */
+ gpfs_aceMask_t aceMask; /* NFSv4 mask specification */
+ gpfs_uid_t aceWho; /* User/Group identification */
+} gpfs_ace_v4_t;
+
+/* when GPFS_ACL_VERSION_NFS4, and GPFS_ACL_LEVEL_V4FLAGS */
+typedef struct v4Level1_ext /* ACL extension */
+{
+ gpfs_aclFlag_t acl_flags; /* per-ACL flags */
+ gpfs_ace_v4_t ace_v4[1];
+} v4Level1_t;
+
+/* The GPFS ACL */
+typedef struct gpfs_acl
+{
+ gpfs_aclLen_t acl_len; /* Total length of this ACL in bytes */
+ gpfs_aclLevel_t acl_level; /* Reserved (must be zero) */
+ gpfs_aclVersion_t acl_version; /* POSIX or NFS4 ACL */
+ gpfs_aclType_t acl_type; /* Access, Default, or NFS4 */
+ gpfs_aclCount_t acl_nace; /* Number of Entries that follow */
+ union
+ {
+ gpfs_ace_v1_t ace_v1[1]; /* when GPFS_ACL_VERSION_POSIX */
+ gpfs_ace_v4_t ace_v4[1]; /* when GPFS_ACL_VERSION_NFS4 */
+ v4Level1_t v4Level1; /* when GPFS_ACL_LEVEL_V4FLAGS */
+ };
+} gpfs_acl_t;
+
+
+/* NAME: gpfs_getacl()
+ *
+ * FUNCTION: Retrieves the ACL information for a file.
+ *
+ * The aclP parameter must point to a buffer mapped by either:
+ * - gpfs_opaque_acl_t (when flags are zero). In this case,
+ * the opaque data that is intended to be used by a backup
+ * program (restoreed by passing this data back on a subsequent
+ * call to gpfs_putacl).
+ * - gpfs_acl_t (when GPFS_GETACL_STRUCT is specified). In this
+ * case, the data can be interpreted by the calling application
+ * (and may be modified and applied to the file by passing it
+ * to gpfs_putacl...along with the GPFS_PUTACL_STRUCT flag).
+ *
+ * On input, the first four bytes of the buffer must contain its
+ * total size.
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * ENOSPC buffer too small to return the entire ACL.
+ * Needed size is returned in the first four
+ * bytes of the buffer pointed to by aclP.
+ * EINVAL Invalid arguments
+ * ENOTDIR Not on directory
+ * ENOMEM Out of memory
+ */
+int GPFS_API
+gpfs_getacl(const char *pathname,
+ int flags,
+ void *acl);
+
+
+/* NAME: gpfs_putacl()
+ *
+ * FUNCTION: Sets the ACL information for a file.
+ * The buffer passed in should contain the ACL data
+ * that was obtained by a previous call to gpfs_getacl.
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL Invalid arguments
+ * ENOTDIR Not on directory
+ * ENOMEM Out of memory
+ * EPERM Caller does not hold appropriate privilege
+ */
+int GPFS_API
+gpfs_putacl(const char *pathname,
+ int flags,
+ void *acl);
+
+
+/* NAME: gpfs_prealloc()
+ *
+ * FUNCTION: Preallocate disk storage for a file or directory, starting
+ * at the specified startOffset and covering at least the number
+ * of bytes requested by bytesToPrealloc. Allocations are rounded
+ * to block boundaries (block size can be found in st_blksize
+ * returned by fstat()), or possibly larger sizes. For files, the
+ * file descriptor must be open for write, but any existing data
+ * already present will not be modified. Reading the preallocated
+ * blocks will return zeros. For directories, the file descriptor
+ * may be open for read but the caller must have write permission,
+ * and existing entries are unaffected; startOffset must be zero.
+ *
+ * This function implements the behavior of mmchattr when invoked
+ * with --compact[=minimumEntries]. The minimumEntries value
+ * specifies both the lower bound on automatic compaction and the
+ * desired size for pre-allocation. It defaults to zero, meaning
+ * no pre-allocation and compact the directory as much as
+ * possible. The mapping between minimumEntries and the
+ * bytesToPrealloc is given by GPFS_PREALLOC_DIR_SLOT_SIZE, see
+ * below.
+ *
+ * Directory compaction (zero bytesToPrealloc) requires a file
+ * system supporting V2 directories (format version 1400, v4.1).
+ * Directories created before upgrading the file system to version
+ * 4.1, are upgraded from V1 to V2 by this operation even if no
+ * other change is made. Since v4.2.2, bytesToPrealloc may be
+ * nonzero effecting pre-allocation by setting a minimum
+ * compaction size. Prior to v4.2.2 the minimum size of any
+ * directory is zero.
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOSYS No prealloc service available
+ * EBADF Bad file descriptor
+ * EINVAL Not a GPFS file
+ * EINVAL Not a regular file or directory
+ * EINVAL Directory pre-allocation not supported
+ * EINVAL startOffset or bytesToPrealloc < 0
+ * EACCES File not opened for writing
+ * EACCES Caller does not have write access to directory.
+ * EDQUOT Quota exceeded
+ * ENOSPC Not enough space on disk
+ * EPERM File is in a snapshot
+ */
+int GPFS_API
+gpfs_prealloc(gpfs_file_t fileDesc,
+ gpfs_off64_t startOffset,
+ gpfs_off64_t bytesToPrealloc);
+
+/* Directory entries are nominally (assuming compact names of 19 bytes or less)
+ 32 bytes in size. This conversion factor is used in mapping between a
+ number of entries (for mmchattr) and a size when calling gpfs_prealloc. */
+#define GPFS_PREALLOC_DIR_SLOT_SIZE 32 /* for size => bytes per entry */
+
+
+typedef struct gpfs_winattr
+{
+ gpfs_timestruc_t creationTime;
+ unsigned int winAttrs; /* values as defined below */
+} gpfs_winattr_t;
+
+/* winAttrs values */
+#define GPFS_WINATTR_ARCHIVE 0x0001
+#define GPFS_WINATTR_COMPRESSED 0x0002
+#define GPFS_WINATTR_DEVICE 0x0004
+#define GPFS_WINATTR_DIRECTORY 0x0008
+#define GPFS_WINATTR_ENCRYPTED 0x0010
+#define GPFS_WINATTR_HIDDEN 0x0020
+#define GPFS_WINATTR_NORMAL 0x0040
+#define GPFS_WINATTR_NOT_CONTENT_INDEXED 0x0080
+#define GPFS_WINATTR_OFFLINE 0x0100
+#define GPFS_WINATTR_READONLY 0x0200
+#define GPFS_WINATTR_REPARSE_POINT 0x0400
+#define GPFS_WINATTR_SPARSE_FILE 0x0800
+#define GPFS_WINATTR_SYSTEM 0x1000
+#define GPFS_WINATTR_TEMPORARY 0x2000
+#define GPFS_WINATTR_HAS_STREAMS 0x4000
+
+
+/* NAME: gpfs_get_winattrs()
+ * gpfs_get_winattrs_path()
+ *
+ * FUNCTION: Returns gpfs_winattr_t attributes
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOENT file not found
+ * EBADF Bad file handle, not a GPFS file
+ * ENOMEM Memory allocation failed
+ * EACCESS Permission denied
+ * EFAULT Bad address provided
+ * EINVAL Not a regular file
+ * ENOSYS function not available
+ */
+int GPFS_API
+gpfs_get_winattrs(gpfs_file_t fileDesc, gpfs_winattr_t *attrP);
+
+int GPFS_API
+gpfs_get_winattrs_path(const char *pathname, gpfs_winattr_t *attrP);
+
+
+/* NAME: gpfs_set_winattrs()
+ * gpfs_set_winattrs_path()
+ *
+ * FUNCTION: Sets gpfs_winattr_t attributes (as specified by
+ * the flags).
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOENT file not found
+ * EBADF Bad file handle, not a GPFS file
+ * ENOMEM Memory allocation failed
+ * EACCESS Permission denied
+ * EFAULT Bad address provided
+ * EINVAL Not a regular file
+ * ENOSYS function not available
+ */
+int GPFS_API
+gpfs_set_winattrs(gpfs_file_t fileDesc, int flags, gpfs_winattr_t *attrP);
+
+int GPFS_API
+gpfs_set_winattrs_path(const char *pathname, int flags, gpfs_winattr_t *attrP);
+
+/* gpfs_set_winattr flag values */
+#define GPFS_WINATTR_SET_CREATION_TIME 0x08
+#define GPFS_WINATTR_SET_ATTRS 0x10
+
+/*
+ * NAME: gpfs_set_times(), gpfs_set_times_path()
+ *
+ * FUNCTION: Sets file access time, modified time, change time,
+ * and/or creation time (as specified by the flags).
+ *
+ * Input: flagsfileDesc : file descriptor of the object to set
+ * pathname : path to a file or directory
+ * flag : define time value to set
+ * GPFS_SET_ATIME - set access time
+ * GPFS_SET_MTIME - set mod. time
+ * GPFS_SET_CTIME - set change time
+ * GPFS_SET_CREATION_TIME - set creation time
+ * GPFS_SET_TIME_NO_FOLLOW - don't follow links
+ * times : array to times
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * EBADF Not a GPFS File
+ * EINVAL invalid argument
+ * EACCES Permission denied
+ * EROFS Filesystem is read only
+ * ENOENT No such file or directory
+ */
+typedef gpfs_timestruc_t gpfs_times_vector_t[4];
+
+int GPFS_API
+gpfs_set_times(gpfs_file_t fileDesc, int flags, gpfs_times_vector_t times);
+
+int GPFS_API
+gpfs_set_times_path(char *pathname, int flags, gpfs_times_vector_t times);
+
+/* gpfs_set_times flag values */
+#define GPFS_SET_ATIME 0x01
+#define GPFS_SET_MTIME 0x02
+#define GPFS_SET_CTIME 0x04
+#define GPFS_SET_CREATION_TIME 0x08
+#define GPFS_SET_TIME_NO_FOLLOW 0x10
+
+
+/* NAME: gpfs_set_share()
+ *
+ * FUNCTION: Acquire shares
+ *
+ * Input: fileDesc : file descriptor
+ * allow : share type being requested
+ * GPFS_SHARE_NONE, GPFS_SHARE_READ,
+ * GPFS_SHARE_WRITE, GPFS_SHARE_BOTH
+ * deny : share type to deny to others
+ * GPFS_DENY_NONE, GPFS_DENY_READ,
+ * GPFS_DENY_WRITE, GPFS_DENY_BOTH
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: EBADF Bad file handle
+ * EINVAL Bad argument given
+ * EFAULT Bad address provided
+ * ENOMEM Memory allocation failed
+ * EACCES share mode not available
+ * ENOSYS function not available
+ */
+
+/* allow/deny specifications */
+#define GPFS_SHARE_NONE 0
+#define GPFS_SHARE_READ 1
+#define GPFS_SHARE_WRITE 2
+#define GPFS_SHARE_BOTH 3
+#define GPFS_SHARE_ALL 3
+#define GPFS_DENY_NONE 0
+#define GPFS_DENY_READ 1
+#define GPFS_DENY_WRITE 2
+#define GPFS_DENY_BOTH 3
+#define GPFS_DENY_DELETE 4
+#define GPFS_DENY_ALL 7
+
+int GPFS_API
+gpfs_set_share(gpfs_file_t fileDesc,
+ unsigned int share,
+ unsigned int deny);
+
+
+/* NAME: gpfs_set_lease()
+ *
+ * FUNCTION: Acquire leases for Samba
+ *
+ * Input: fileDesc : file descriptor
+ * leaseType : lease type being requested
+ * GPFS_LEASE_NONE GPFS_LEASE_READ,
+ * GPFS_LEASE_WRITE
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: EBADF Bad file handle
+ * EINVAL Bad argument given
+ * EFAULT Bad address provided
+ * ENOMEM Memory allocation failed
+ * EAGAIN lease not available
+ * EACCES permission denied
+ * EOPNOTSUPP unsupported leaseType
+ * ESTALE unmounted file system
+ * ENOSYS function not available
+ */
+
+/* leaseType specifications */
+#define GPFS_LEASE_NONE 0
+#define GPFS_LEASE_READ 1
+#define GPFS_LEASE_WRITE 2
+
+int GPFS_API
+gpfs_set_lease(gpfs_file_t fileDesc,
+ unsigned int leaseType);
+
+
+/* NAME: gpfs_get_lease()
+ *
+ * FUNCTION: Returns the type of lease currently held
+ *
+ * Returns: GPFS_LEASE_READ
+ * GPFS_LEASE_WRITE
+ * GPFS_LEASE_NONE
+ *
+ * Returns: >= 0 Success
+ * -1 Failure
+ *
+ * Errno: EINVAL
+ */
+int GPFS_API
+gpfs_get_lease(gpfs_file_t fileDesc);
+
+
+ /* NAME: gpfs_get_realfilename(), gpfs_get_realfilename_path()
+ *
+ * FUNCTION: Interface to get real name of a file.
+ *
+ * INPUT: File descriptor, pathname, buffer, bufferlength
+ * OUTPUT: Real file name stored in file system
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: EBADF Bad file handle
+ * EINVAL Not a regular file
+ * EFAULT Bad address provided
+ * ENOSPC buffer too small to return the real file name.
+ * Needed size is returned in buflen parameter.
+ * ENOENT File does not exist
+ * ENOMEM Memory allocation failed
+ * EACCESS Permission denied
+ * ENOSYS function not available
+ */
+int GPFS_API
+gpfs_get_realfilename(gpfs_file_t fileDesc,
+ char *fileNameP,
+ int *buflen);
+
+int GPFS_API
+gpfs_get_realfilename_path(const char *pathname,
+ char *fileNameP,
+ int *buflen);
+
+ /* NAME: gpfs_ftruncate()
+ *
+ * FUNCTION: Interface to truncate a file.
+ *
+ * INPUT: File descriptor
+ * length
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * EBADF Bad file handle
+ * EBADF Not a GPFS file
+ * EINVAL Not a regular file
+ * ENOENT File does not exist
+ * ENOMEM Memory allocation failed
+ * EINVAL length < 0
+ * EACCESS Permission denied
+ */
+int GPFS_API
+gpfs_ftruncate(gpfs_file_t fileDesc, gpfs_off64_t length);
+
+#define GPFS_WIN_CIFS_REGISTERED 0x02000000
+typedef struct cifsThreadData_t
+{
+ unsigned int dataLength; /* Total buffer length */
+ unsigned int share; /* gpfs_set_share declaration */
+ unsigned int deny; /* gpfs_set_share specification */
+ unsigned int lease; /* gpfs_set_lease lease type */
+ unsigned int secInfoFlags; /* Future use. Must be zero */
+ gpfs_uid_t sdUID; /* Owning user */
+ gpfs_uid_t sdGID; /* Owning group */
+ int shareLocked_fd; /* file descriptor with share locks */
+ unsigned int aclLength ; /* Length of the following ACL */
+ gpfs_acl_t acl; /* The initial ACL for create/mkdir */
+} cifsThreadData_t;
+
+ /* NAME: gpfs_register_cifs_export()
+ *
+ * FUNCTION: Register a CIFS export process.
+ *
+ * INPUT: implicit use of the process ids
+ *
+ * Returns: 0 Successful
+ * ENOSYS function not available
+ * EACCES cannot establish credentials
+ * ENOMEM temporary shortage of memory
+ * EINVAL prior process/thread registrations exist
+ * EBADF unable to allocate a file descriptor
+ */
+int GPFS_API
+gpfs_register_cifs_export(void);
+
+ /* NAME: gpfs_unregister_cifs_export()
+ *
+ * FUNCTION: remove a registration for a CIFS export
+ *
+ * INPUT: implicit use of the process ids
+ *
+ * Returns: 0 Successful
+ * ENOSYS function not available
+ * EACCES cannot establish credentials
+ * ENOMEM temporary shortage of memory
+ */
+int GPFS_API
+gpfs_unregister_cifs_export(void);
+
+ /* NAME: gpfs_register_cifs_buffer()
+ *
+ * FUNCTION: Register a CIFS thread/buffer combination
+ *
+ * INPUT: implicit use of the process and thread ids
+ * Address of a cifsThreadData_t structure that will include
+ * a GPFS ACL (GPFS_ACL_VERSION_NFS4/GPFS_ACL_LEVEL_V4FLAGS)
+ * that can be applied at file/dir creation.
+ *
+ * Returns: 0 Successful
+ * ENOSYS function not available
+ * EACCES cannot establish credentials
+ * ENOMEM unable to allocate required memory
+ * EINVAL no associated process registrion exists
+ * bad dataLength in buffer.
+ */
+int GPFS_API
+gpfs_register_cifs_buffer(cifsThreadData_t *bufP);
+
+ /* NAME: gpfs_unregister_cifs_buffer()
+ *
+ * FUNCTION: remove a CIFS thread/buffer registration
+ *
+ * INPUT: implicit use of the process and thread ids
+ *
+ * Returns: 0 Successful
+ * ENOSYS function not available
+ * EACCES cannot establish credentials
+ * ENOMEM unable to allocate required memory
+ * EINVAL no associated process registrion exists
+ */
+int GPFS_API
+gpfs_unregister_cifs_buffer(void);
+
+/* NAME: gpfs_lib_init()
+ *
+ * FUNCTION: Open GPFS main module device file
+ *
+ * INPUT: Flags
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ */
+int GPFS_API
+gpfs_lib_init(int flags);
+
+/* NAME: gpfs_lib_term()
+ *
+ * FUNCTION: Close GPFS main module device file
+ *
+ * INPUT: Flags
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ */
+int GPFS_API
+gpfs_lib_term(int flags);
+
+/* Define maximum length of the name for a GPFS named object, such
+ as a snapshot, storage pool or fileset. The name is a null-terminated
+ character string, which is not include in the max length */
+#define GPFS_MAXNAMLEN 255
+
+/* Define maximum length of the path to a GPFS named object
+ such as a snapshot or fileset. If the absolute path name exceeds
+ this limit, then use a relative path name. The path is a null-terminated
+ character string, which is not included in the max length */
+#define GPFS_MAXPATHLEN 1023
+
+/* ASCII code for "GPFS" in the struct statfs f_type field */
+#define GPFS_SUPER_MAGIC 0x47504653
+
+/* GPFS inode attributes
+ gpfs_uid_t - defined above
+ gpfs_uid64_t - defined above
+ gpfs_off64_t - defined above
+
+ gpfs_mode_t may include gpfs specific values including 0x02000000
+ To have a gpfs_mode_t be equivalent to a mode_t mask that value out.
+ */
+typedef unsigned int gpfs_mode_t;
+typedef unsigned int gpfs_gid_t;
+typedef unsigned long long gpfs_gid64_t;
+typedef unsigned int gpfs_ino_t;
+typedef unsigned long long gpfs_ino64_t;
+typedef unsigned int gpfs_gen_t;
+typedef unsigned long long gpfs_gen64_t;
+typedef unsigned int gpfs_dev_t;
+typedef unsigned int gpfs_mask_t;
+typedef unsigned int gpfs_pool_t;
+typedef unsigned int gpfs_snapid_t;
+typedef unsigned long long gpfs_snapid64_t;
+typedef unsigned long long gpfs_fsid64_t[2];
+typedef short gpfs_nlink_t;
+typedef long long gpfs_nlink64_t;
+
+
+#if defined(WIN32) || defined(_MS_SUA_)
+ typedef struct gpfs_stat64
+ {
+ gpfs_dev_t st_dev; /* id of device containing file */
+ gpfs_ino64_t st_ino; /* file inode number */
+ gpfs_mode_t st_mode; /* access mode */
+ gpfs_nlink64_t st_nlink; /* number of links */
+ unsigned int st_flags; /* flag word */
+ gpfs_uid64_t st_uid; /* owner uid */
+ gpfs_gid64_t st_gid; /* owner gid */
+ gpfs_dev_t st_rdev; /* device id (if special file) */
+ gpfs_off64_t st_size; /* file size in bytes */
+ gpfs_timestruc64_t st_atime; /* time of last access */
+ gpfs_timestruc64_t st_mtime; /* time of last data modification */
+ gpfs_timestruc64_t st_ctime; /* time of last status change */
+ int st_blksize; /* preferred block size for io */
+ gpfs_off64_t st_blocks; /* 512 byte blocks of disk held by file */
+ long long st_fsid; /* file system id */
+ unsigned int st_type; /* file type */
+ gpfs_gen64_t st_gen; /* inode generation number */
+ gpfs_timestruc64_t st_createtime; /* time of creation */
+ unsigned int st_attrs; /* Windows flags */
+ } gpfs_stat64_t;
+#else
+ typedef struct stat64 gpfs_stat64_t;
+#endif
+
+#if defined(WIN32) || defined(_MS_SUA_)
+ typedef struct gpfs_statfs64
+ {
+ gpfs_off64_t f_blocks; /* total data blocks in file system */
+ gpfs_off64_t f_bfree; /* free block in fs */
+ gpfs_off64_t f_bavail; /* free blocks avail to non-superuser */
+ int f_bsize; /* optimal file system block size */
+ gpfs_ino64_t f_files; /* total file nodes in file system */
+ gpfs_ino64_t f_ffree; /* free file nodes in fs */
+ gpfs_fsid64_t f_fsid; /* file system id */
+ int f_fsize; /* fundamental file system block size */
+ int f_sector_size; /* logical disk sector size */
+ char f_fname[32]; /* file system name (usually mount pt.) */
+ char f_fpack[32]; /* file system pack name */
+ int f_name_max; /* maximum component name length for posix */
+ } gpfs_statfs64_t;
+#else
+ typedef struct statfs64 gpfs_statfs64_t;
+#endif
+
+/* Declarations for backwards compatibility. */
+typedef gpfs_stat64_t stat64_t;
+typedef gpfs_statfs64_t statfs64_t;
+
+
+/* Define a version number for the directory entry data to allow
+ future changes in this structure. Careful callers should also use
+ the d_reclen field for the size of the structure rather than sizeof,
+ to allow some degree of forward compatibility */
+#define GPFS_D_VERSION 1
+
+typedef struct gpfs_direntx
+{
+ int d_version; /* this struct's version */
+ unsigned short d_reclen; /* actual size of this struct including
+ null terminated variable length d_name */
+ unsigned short d_type; /* Types are defined below */
+ gpfs_ino_t d_ino; /* File inode number */
+ gpfs_gen_t d_gen; /* Generation number for the inode */
+ char d_name[256]; /* null terminated variable length name */
+} gpfs_direntx_t;
+
+
+#define GPFS_D64_VERSION 2
+
+typedef struct gpfs_direntx64
+{
+ int d_version; /* this struct's version */
+ unsigned short d_reclen; /* actual size of this struct including
+ null terminated variable length d_name */
+ unsigned short d_type; /* Types are defined below */
+ gpfs_ino64_t d_ino; /* File inode number */
+ gpfs_gen64_t d_gen; /* Generation number for the inode */
+ unsigned int d_flags; /* Flags are defined below */
+ char d_name[1028]; /* null terminated variable length name */
+ /* (1020+null+7 byte pad to double word) */
+ /* to handle up to 255 UTF-8 chars */
+} gpfs_direntx64_t;
+
+/* File types for d_type field in gpfs_direntx_t */
+#define GPFS_DE_OTHER 0
+#define GPFS_DE_FIFO 1
+#define GPFS_DE_CHR 2
+#define GPFS_DE_DIR 4
+#define GPFS_DE_BLK 6
+#define GPFS_DE_REG 8
+#define GPFS_DE_LNK 10
+#define GPFS_DE_SOCK 12
+#define GPFS_DE_DEL 16
+
+/* Define flags for gpfs_direntx64_t */
+#define GPFS_DEFLAG_NONE 0x0000 /* Default value, no flags set */
+#define GPFS_DEFLAG_JUNCTION 0x0001 /* DirEnt is a fileset junction */
+#define GPFS_DEFLAG_IJUNCTION 0x0002 /* DirEnt is a inode space junction */
+#define GPFS_DEFLAG_ORPHAN 0x0004 /* DirEnt is an orphan (pcache) */
+#define GPFS_DEFLAG_CLONE 0x0008 /* DirEnt is a clone child */
+
+/* Define a version number for the iattr data to allow future changes
+ in this structure. Careful callers should also use the ia_reclen field
+ for the size of the structure rather than sizeof, to allow some degree
+ of forward compatibility */
+#define GPFS_IA_VERSION 1
+#define GPFS_IA64_VERSION 3 /* ver 3 adds ia_repl_xxxx bytes instead of ia_pad2 */
+#define GPFS_IA64_RESERVED 4
+#define GPFS_IA64_UNUSED 8
+
+typedef struct gpfs_iattr
+{
+ int ia_version; /* this struct version */
+ int ia_reclen; /* sizeof this structure */
+ int ia_checksum; /* validity check on iattr struct */
+ gpfs_mode_t ia_mode; /* access mode; see gpfs_mode_t comment */
+ gpfs_uid_t ia_uid; /* owner uid */
+ gpfs_gid_t ia_gid; /* owner gid */
+ gpfs_ino_t ia_inode; /* file inode number */
+ gpfs_gen_t ia_gen; /* inode generation number */
+ gpfs_nlink_t ia_nlink; /* number of links */
+ short ia_flags; /* Flags (defined below) */
+ int ia_blocksize; /* preferred block size for io */
+ gpfs_mask_t ia_mask; /* Initial attribute mask (not used) */
+ unsigned int ia_pad1; /* reserved space */
+ gpfs_off64_t ia_size; /* file size in bytes */
+ gpfs_off64_t ia_blocks; /* 512 byte blocks of disk held by file */
+ gpfs_timestruc_t ia_atime; /* time of last access */
+ gpfs_timestruc_t ia_mtime; /* time of last data modification */
+ gpfs_timestruc_t ia_ctime; /* time of last status change */
+ gpfs_dev_t ia_rdev; /* id of device */
+ unsigned int ia_xperm; /* extended attributes (defined below) */
+ unsigned int ia_modsnapid; /* snapshot id of last modification */
+ unsigned int ia_filesetid; /* fileset ID */
+ unsigned int ia_datapoolid; /* storage pool ID for data */
+ unsigned int ia_pad2; /* reserved space */
+} gpfs_iattr_t;
+
+
+typedef struct gpfs_iattr64
+{
+ int ia_version; /* this struct version */
+ int ia_reclen; /* sizeof this structure */
+ int ia_checksum; /* validity check on iattr struct */
+ gpfs_mode_t ia_mode; /* access mode; see gpfs_mode_t comment */
+ gpfs_uid64_t ia_uid; /* owner uid */
+ gpfs_gid64_t ia_gid; /* owner gid */
+ gpfs_ino64_t ia_inode; /* file inode number */
+ gpfs_gen64_t ia_gen; /* inode generation number */
+ gpfs_nlink64_t ia_nlink; /* number of links */
+ gpfs_off64_t ia_size; /* file size in bytes */
+ gpfs_off64_t ia_blocks; /* 512 byte blocks of disk held by file */
+ gpfs_timestruc64_t ia_atime; /* time of last access */
+ unsigned int ia_winflags; /* windows flags (defined below) */
+ unsigned int ia_pad1; /* reserved space */
+ gpfs_timestruc64_t ia_mtime; /* time of last data modification */
+ unsigned int ia_flags; /* flags (defined below) */
+ /* next four bytes were ia_pad2 */
+ unsigned char ia_repl_data; /* data replication factor */
+ unsigned char ia_repl_data_max; /* data replication max factor */
+ unsigned char ia_repl_meta; /* meta data replication factor */
+ unsigned char ia_repl_meta_max; /* meta data replication max factor */
+ gpfs_timestruc64_t ia_ctime; /* time of last status change */
+ int ia_blocksize; /* preferred block size for io */
+ unsigned int ia_pad3; /* reserved space */
+ gpfs_timestruc64_t ia_createtime; /* creation time */
+ gpfs_mask_t ia_mask; /* initial attribute mask (not used) */
+ int ia_pad4; /* reserved space */
+ unsigned int ia_reserved[GPFS_IA64_RESERVED]; /* reserved space */
+ unsigned int ia_xperm; /* extended attributes (defined below) */
+ gpfs_dev_t ia_dev; /* id of device containing file */
+ gpfs_dev_t ia_rdev; /* device id (if special file) */
+ unsigned int ia_pcacheflags; /* pcache inode bits */
+ gpfs_snapid64_t ia_modsnapid; /* snapshot id of last modification */
+ unsigned int ia_filesetid; /* fileset ID */
+ unsigned int ia_datapoolid; /* storage pool ID for data */
+ gpfs_ino64_t ia_inode_space_mask; /* inode space mask of this file system */
+ /* This value is saved in the iattr structure
+ during backup and used during restore */
+ gpfs_off64_t ia_dirminsize; /* dir pre-allocation size in bytes */
+ unsigned int ia_unused[GPFS_IA64_UNUSED]; /* reserved space */
+} gpfs_iattr64_t;
+
+/* Define flags for inode attributes */
+#define GPFS_IAFLAG_SNAPDIR 0x0001 /* (obsolete) */
+#define GPFS_IAFLAG_USRQUOTA 0x0002 /* inode is a user quota file */
+#define GPFS_IAFLAG_GRPQUOTA 0x0004 /* inode is a group quota file */
+#define GPFS_IAFLAG_ERROR 0x0008 /* error reading inode */
+/* Define flags for inode replication attributes */
+#define GPFS_IAFLAG_FILESET_ROOT 0x0010 /* root dir of a fileset */
+#define GPFS_IAFLAG_NO_SNAP_RESTORE 0x0020 /* don't restore from snapshots */
+#define GPFS_IAFLAG_FILESETQUOTA 0x0040 /* inode is a fileset quota file */
+#define GPFS_IAFLAG_COMANAGED 0x0080 /* file data is co-managed */
+#define GPFS_IAFLAG_ILLPLACED 0x0100 /* may not be properly placed */
+#define GPFS_IAFLAG_REPLMETA 0x0200 /* metadata replication set */
+#define GPFS_IAFLAG_REPLDATA 0x0400 /* data replication set */
+#define GPFS_IAFLAG_EXPOSED 0x0800 /* may have data on suspended disks */
+#define GPFS_IAFLAG_ILLREPLICATED 0x1000 /* may not be properly replicated */
+#define GPFS_IAFLAG_UNBALANCED 0x2000 /* may not be properly balanced */
+#define GPFS_IAFLAG_DATAUPDATEMISS 0x4000 /* has stale data blocks on
+ unavailable disk */
+#define GPFS_IAFLAG_METAUPDATEMISS 0x8000 /* has stale metadata on
+ unavailable disk */
+
+#define GPFS_IAFLAG_IMMUTABLE 0x00010000 /* Immutability */
+#define GPFS_IAFLAG_INDEFRETENT 0x00020000 /* Indefinite retention */
+#define GPFS_IAFLAG_SECUREDELETE 0x00040000 /* Secure deletion */
+
+#define GPFS_IAFLAG_TRUNCMANAGED 0x00080000 /* dmapi truncate event enabled */
+#define GPFS_IAFLAG_READMANAGED 0x00100000 /* dmapi read event enabled */
+#define GPFS_IAFLAG_WRITEMANAGED 0x00200000 /* dmapi write event enabled */
+
+#define GPFS_IAFLAG_APPENDONLY 0x00400000 /* AppendOnly only */
+#define GPFS_IAFLAG_DELETED 0x00800000 /* inode has been deleted */
+#ifdef ZIP
+#define GPFS_IAFLAG_ILLCOMPRESSED 0x01000000 /* may not be properly compressed */
+#endif
+#define GPFS_IAFLAG_FPOILLPLACED 0x02000000 /* may not be properly placed per
+ FPO attributes (bgf, wad, wadfg) */
+
+/* Define flags for window's attributes */
+#define GPFS_IWINFLAG_ARCHIVE 0x0001 /* Archive */
+#define GPFS_IWINFLAG_HIDDEN 0x0002 /* Hidden */
+#define GPFS_IWINFLAG_NOTINDEXED 0x0004 /* Not content indexed */
+#define GPFS_IWINFLAG_OFFLINE 0x0008 /* Off-line */
+#define GPFS_IWINFLAG_READONLY 0x0010 /* Read-only */
+#define GPFS_IWINFLAG_REPARSE 0x0020 /* Reparse point */
+#define GPFS_IWINFLAG_SYSTEM 0x0040 /* System */
+#define GPFS_IWINFLAG_TEMPORARY 0x0080 /* Temporary */
+#define GPFS_IWINFLAG_COMPRESSED 0x0100 /* Compressed */
+#define GPFS_IWINFLAG_ENCRYPTED 0x0200 /* Encrypted */
+#define GPFS_IWINFLAG_SPARSE 0x0400 /* Sparse file */
+#define GPFS_IWINFLAG_HASSTREAMS 0x0800 /* Has streams */
+
+/* Define flags for extended attributes */
+#define GPFS_IAXPERM_ACL 0x0001 /* file has acls */
+#define GPFS_IAXPERM_XATTR 0x0002 /* file has extended attributes */
+#define GPFS_IAXPERM_DMATTR 0x0004 /* file has dm attributes */
+#define GPFS_IAXPERM_DOSATTR 0x0008 /* file has non-default dos attrs */
+#define GPFS_IAXPERM_RPATTR 0x0010 /* file has restore policy attrs */
+
+/* Define flags for pcache bits defined in the inode */
+#define GPFS_ICAFLAG_CACHED 0x0001 /* "cached complete" */
+#define GPFS_ICAFLAG_CREATE 0x0002 /* "created" */
+#define GPFS_ICAFLAG_DIRTY 0x0004 /* "data dirty" */
+#define GPFS_ICAFLAG_LINK 0x0008 /* "hard linked" */
+#define GPFS_ICAFLAG_SETATTR 0x0010 /* "attr changed" */
+#define GPFS_ICAFLAG_LOCAL 0x0020 /* "local" */
+#define GPFS_ICAFLAG_APPEND 0x0040 /* "append" */
+#define GPFS_ICAFLAG_STATE 0x0080 /* "has remote state" */
+
+/* Define pointers to interface types */
+typedef struct gpfs_fssnap_handle gpfs_fssnap_handle_t;
+typedef struct gpfs_iscan gpfs_iscan_t;
+typedef struct gpfs_ifile gpfs_ifile_t;
+typedef struct gpfs_restore gpfs_restore_t;
+
+typedef struct gpfs_fssnap_id
+{
+ char opaque[48];
+} gpfs_fssnap_id_t;
+
+
+/* Define extended return codes for gpfs backup & restore
+ calls without an explicit return code will return the value in errno */
+#define GPFS_NEW_ERRNO_BASE 185
+#define GPFS_E_INVAL_INUM (GPFS_NEW_ERRNO_BASE+0) /* invalid inode number */
+
+#define GPFS_ERRNO_BASE 190
+#define GPFS_E_INVAL_FSSNAPID (GPFS_ERRNO_BASE+0) /* invalid fssnap id */
+#define GPFS_E_INVAL_ISCAN (GPFS_ERRNO_BASE+1) /* invalid iscan pointer */
+#define GPFS_E_INVAL_IFILE (GPFS_ERRNO_BASE+2) /* invalid ifile pointer */
+#define GPFS_E_INVAL_IATTR (GPFS_ERRNO_BASE+3) /* invalid iattr structure */
+#define GPFS_E_INVAL_RESTORE (GPFS_ERRNO_BASE+4) /* invalid restore pointer */
+#define GPFS_E_INVAL_FSSNAPHANDLE (GPFS_ERRNO_BASE+5) /* invalid fssnap handle */
+#define GPFS_E_INVAL_SNAPNAME (GPFS_ERRNO_BASE+6) /* invalid snapshot name */
+#define GPFS_E_FS_NOT_RESTORABLE (GPFS_ERRNO_BASE+7) /* FS is not clean */
+#define GPFS_E_RESTORE_NOT_ENABLED (GPFS_ERRNO_BASE+8) /* Restore was not enabled */
+#define GPFS_E_RESTORE_STARTED (GPFS_ERRNO_BASE+9) /* Restore is running */
+#define GPFS_E_INVAL_XATTR (GPFS_ERRNO_BASE+10) /* invalid extended
+ attribute pointer */
+
+/* Define flags parameter for get/put file attributes.
+ Used by gpfs_fgetattr, gpfs_fputattr, gpfs_fputattrwithpath
+ gpfs_igetattrsx, gpfs_iputattrsx
+ and gpfs_lwe_getattrs, gpfs_lwe_putattrs
+*/
+#define GPFS_ATTRFLAG_DEFAULT 0x0000 /* default behavior */
+#define GPFS_ATTRFLAG_NO_PLACEMENT 0x0001 /* exclude file placement attributes */
+#define GPFS_ATTRFLAG_IGNORE_POOL 0x0002 /* saved poolid is not valid */
+#define GPFS_ATTRFLAG_USE_POLICY 0x0004 /* use restore policy rules to
+ determine poolid */
+#define GPFS_ATTRFLAG_INCL_DMAPI 0x0008 /* Include dmapi attributes */
+#define GPFS_ATTRFLAG_FINALIZE_ATTRS 0x0010 /* Finalize immutability attributes */
+#define GPFS_ATTRFLAG_SKIP_IMMUTABLE 0x0020 /* Skip immutable attributes */
+#define GPFS_ATTRFLAG_INCL_ENCR 0x0040 /* Include encryption attributes */
+#define GPFS_ATTRFLAG_SKIP_CLONE 0x0080 /* Skip clone attributes */
+#define GPFS_ATTRFLAG_MODIFY_CLONEPARENT 0x0100 /* Allow modification on clone parent */
+#ifdef ZIP
+#define GPFS_ATTRFLAG_NO_COMPRESSED 0x0200 /* exclude "compressed" attribute */
+#endif
+
+/* Define structure used by gpfs_statfspool */
+typedef struct gpfs_statfspool_s
+{
+ gpfs_off64_t f_blocks; /* total data blocks in pool */
+ gpfs_off64_t f_bfree; /* free blocks in pool */
+ gpfs_off64_t f_bavail; /* free blocks avail to non-superuser */
+ gpfs_off64_t f_mblocks; /* total metadata blocks in pool */
+ gpfs_off64_t f_mfree; /* free blocks avail for system metadata */
+ int f_bsize; /* optimal storage pool block size */
+ int f_files; /* total file nodes assigned to pool */
+ gpfs_pool_t f_poolid; /* storage pool id */
+ int f_fsize; /* fundamental file system block size */
+ unsigned int f_usage; /* data and/or metadata stored in pool */
+ int f_replica; /* replica */
+ int f_bgf; /* block group factor */
+ int f_wad; /* write affinity depth */
+ int f_allowWriteAffinity; /* allow write affinity depth. 1 means yes */
+ int f_reserved[3];/* Current unused and set to zero */
+} gpfs_statfspool_t;
+
+#define STATFSPOOL_USAGE_DATA 0x0001 /* Pool stores user data */
+#define STATFSPOOL_USAGE_METADATA 0x0002 /* Pool stores system metadata */
+
+
+/* NAME: gpfs_fstat(), gpfs_stat()
+ *
+ * FUNCTION: Get exact stat information for a file descriptor (or filename).
+ * Forces all other nodes to flush dirty data and metadata to disk.
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS The gpfs_fstat() (or) gpfs_stat() subroutine is not supported
+ * under the current file system format
+ * EBADF The file descriptor is not valid.
+ * EINVAL The file descriptor does not refer to a GPFS file or a
+ * regular file.
+ * ESTALE The cached file system information was not valid.
+ */
+int GPFS_API
+gpfs_fstat(gpfs_file_t fileDesc,
+ gpfs_stat64_t *buffer);
+
+int GPFS_API
+gpfs_stat(const char *pathname, /* File pathname */
+ gpfs_stat64_t *buffer);
+
+/* NAME: gpfs_fstat_x(), gpfs_stat_x()
+ *
+ * FUNCTION: Returns extended stat() information with specified accuracy
+ * for a file descriptor (or filename)
+ *
+ * Input: fileDesc : file descriptor or handle
+ * pathname : path to a file or directory
+ * iattrBufLen : length of iattr buffer
+ *
+ * In/Out: st_litemaskP: bitmask specification of required accuracy
+ * iattr : buffer for returned stat information
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * ENOENT invalid pathname
+ * EBADF Bad file desc
+ * EINVAL Not a GPFS file
+ * ESTALE cached fs information was invalid
+ */
+int GPFS_API
+gpfs_fstat_x(gpfs_file_t fileDesc,
+ unsigned int *st_litemaskP,
+ gpfs_iattr64_t *iattr,
+ size_t iattrBufLen);
+
+int GPFS_API
+gpfs_stat_x(const char *pathname, /* File pathname */
+ unsigned int *st_litemaskP,
+ gpfs_iattr64_t *iattr,
+ size_t iattrBufLen);
+
+/* NAME: gpfs_statfs64()
+ *
+ * FUNCTION: Get information about the file system.
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * EBADF Bad file desc
+ * EINVAL Not a GPFS file
+ * ESTALE cached fs information was invalid
+ */
+int GPFS_API
+gpfs_statfs64(const char *pathname, /* File pathname */
+ gpfs_statfs64_t *buffer);
+
+/* NAME: gpfs_statlite()
+ * gpfs_lstatlite() - do not follow a symlink at the end of the path
+ *
+ * FUNCTION: Returns stat() information with specified accuracy
+ *
+ * Input: pathname : path to a file or directory
+ *
+ * In/Out: st_litemaskP: bitmask specification of required accuracy
+ * statbufP : buffer for returned stat information
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: Specific error indication
+ * EINVAL
+ *
+ */
+int GPFS_API
+gpfs_statlite(const char *pathname,
+ unsigned int *st_litemaskP,
+ gpfs_stat64_t *statbufP);
+
+int GPFS_API
+gpfs_lstatlite(const char *pathname,
+ unsigned int *st_litemaskP,
+ gpfs_stat64_t *statbufP);
+
+
+/* NAME: gpfs_fgetattrs()
+ *
+ * FUNCTION: Retrieves all extended file attributes in opaque format.
+ * This function together with gpfs_fputattrs is intended for
+ * use by a backup program to save (gpfs_fgetattrs) and
+ * restore (gpfs_fputattrs) all extended file attributes
+ * (ACLs, user attributes, ...) in one call.
+ *
+ * NOTE: This call does not return extended attributes used for
+ * the Data Storage Management (XDSM) API (aka DMAPI).
+ *
+ * Input: flags Define behavior of get attributes
+ * GPFS_ATTRFLAG_NO_PLACEMENT - file attributes for placement
+ * are not saved, neither is the current storage pool.
+ * GPFS_ATTRFLAG_IGNORE_POOL - file attributes for placement
+ * are saved, but the current storage pool is not.
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL Not a GPFS file
+ * EINVAL invalid flags provided
+ * ENOSPC buffer too small to return all attributes
+ * *attrSizeP will be set to the size necessary
+ */
+int GPFS_API
+gpfs_fgetattrs(gpfs_file_t fileDesc,
+ int flags,
+ void *bufferP,
+ int bufferSize,
+ int *attrSizeP);
+
+
+/* NAME: gpfs_fputattrs()
+ *
+ * FUNCTION: Sets all extended file attributes of a file
+ * and sets the file's storage pool and data replication
+ * to the values saved in the extended attributes.
+ *
+ * If the saved storage pool is not valid or if the IGNORE_POOL
+ * flag is set, then it will select the storage pool by matching
+ * a PLACEMENT rule using the saved file attributes.
+ * If it fails to match a placement rule or if there are
+ * no placement rules installed it will assign the file
+ * to the "system" storage pool.
+ *
+ * The buffer passed in should contain extended attribute data
+ * that was obtained by a previous call to gpfs_fgetattrs.
+ *
+ * Input: flags Define behavior of put attributes
+ * GPFS_ATTRFLAG_NO_PLACEMENT - file attributes are restored
+ * but the storage pool and data replication are unchanged
+ * GPFS_ATTRFLAG_IGNORE_POOL - file attributes are restored
+ * but the storage pool and data replication are selected
+ * by matching the saved attributes to a placement rule
+ * instead of restoring the saved storage pool.
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL Not a GPFS file
+ * EINVAL the buffer does not contain valid attribute data
+ * EINVAL invalid flags provided
+ */
+int GPFS_API
+gpfs_fputattrs(gpfs_file_t fileDesc,
+ int flags,
+ void *bufferP);
+
+
+/* NAME: gpfs_fputattrswithpathname()
+ *
+ * FUNCTION: Sets all extended file attributes of a file and invokes
+ * the policy engine to match a RESTORE rule using the file's
+ * attributes saved in the extended attributes to set the
+ * file's storage pool and data replication. The caller should
+ * include the full path to the file, including the file name,
+ * to allow rule selection based on file name or path.
+ *
+ * If the file fails to match a RESTORE rule, or if there are
+ * no RESTORE rules installed, then the storage pool and data
+ * replication are selected as when calling gpfs_fputattrs().
+ *
+ * The buffer passed in should contain extended attribute data
+ * that was obtained by a previous call to gpfs_fgetattrs.
+ *
+ * pathName is a UTF-8 encoded string. On Windows, applications
+ * can convert UTF-16 ("Unicode") to UTF-8 using the platforms
+ * WideCharToMultiByte function.
+ *
+ *
+ * Input: flags Define behavior of put attributes
+ * GPFS_ATTRFLAG_NO_PLACEMENT - file attributes are restored
+ * but the storage pool and data replication are unchanged
+ * GPFS_ATTRFLAG_IGNORE_POOL - file attributes are restored
+ * but if the file fails to match a RESTORE rule, it
+ * ignore the saved storage pool and select a pool
+ * by matching the saved attributes to a PLACEMENT rule.
+ * GPFS_ATTRFLAG_SKIP_IMMUTABLE - Skip immutable/appendOnly flags
+ * before restoring file data. Then use GPFS_ATTRFLAG_FINALIZE_ATTRS
+ * to restore immutable/appendOnly flags after data is restored.
+ * GPFS_ATTRFLAG_FINALIZE_ATTRS - file attributes that are restored
+ * after data is retored. If file is immutable/appendOnly
+ * call without this flag before restoring data
+ * then call with this flag after restoring data
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL Not a GPFS file
+ * EINVAL the buffer does not contain valid attribute data
+ * ENOENT invalid pathname
+ * EINVAL invalid flags provided
+ */
+int GPFS_API
+gpfs_fputattrswithpathname(gpfs_file_t fileDesc,
+ int flags,
+ void *bufferP,
+ const char *pathName);
+
+
+/* NAME: gpfs_get_fssnaphandle_by_path()
+ *
+ * FUNCTION: Get a volatile handle to uniquely identify a file system
+ * and snapshot by the path to the file system and snapshot
+ *
+ * Input: pathName: path to a file or directory in a gpfs file system
+ * or to one of its snapshots
+ *
+ * Returns: pointer to gpfs_fssnap_handle_t (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL Not a GPFS file
+ * ENOENT invalid pathname
+ * see system calls open(), fstatfs(), and malloc() ERRORS
+ */
+gpfs_fssnap_handle_t * GPFS_API
+gpfs_get_fssnaphandle_by_path(const char *pathName);
+
+
+/* NAME: gpfs_get_fssnaphandle_by_name()
+ *
+ * FUNCTION: Get a volatile handle to uniquely identify a file system
+ * and snapshot by the file system name and snapshot name.
+ *
+ * Input: fsName: unique name for gpfs file system (may be specified
+ * as fsName or /dev/fsName)
+ * snapName: name for snapshot within that file system
+ * or NULL to access the active file system rather
+ * than a snapshot within the file system.
+ *
+ * Returns: pointer to gpfs_fssnap_handle_t (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * ENOENT invalid file system name
+ * GPFS_E_INVAL_SNAPNAME invalid snapshot name
+ * see system calls open(), fstatfs(), and malloc() ERRORS
+ */
+gpfs_fssnap_handle_t * GPFS_API
+gpfs_get_fssnaphandle_by_name(const char *fsName,
+ const char *snapName);
+
+
+/* NAME: gpfs_get_fssnaphandle_by_fssnapid()
+ *
+ * FUNCTION: Get a volatile handle to uniquely identify a file system
+ * and snapshot by a fssnapId created from a previous handle.
+ *
+ * Input: fssnapId: unique id for a file system and snapshot
+ *
+ * Returns: pointer to gpfs_fssnap_handle_t (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * GPFS_E_INVAL_FSSNAPID invalid snapshot id
+ * see system calls open(), fstatfs(), and malloc() ERRORS
+ */
+gpfs_fssnap_handle_t * GPFS_API
+gpfs_get_fssnaphandle_by_fssnapid(const gpfs_fssnap_id_t *fssnapId);
+
+/* NAME: gpfs_get_fset_snaphandle_by_path()
+ *
+ * FUNCTION: Get a volatile handle to uniquely identify an inode space within a
+ * filesyetsm and snapshot by the path to the file system and snapshot.
+ *
+ * Input: pathName: path to a file or directory in a gpfs file system
+ * or to one of its snapshots
+ *
+ * Returns: pointer to gpfs_fssnap_handle_t (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL Not a GPFS file
+ * ENOENT invalid pathname
+ * see system calls open(), fstatfs(), and malloc() ERRORS
+ */
+gpfs_fssnap_handle_t * GPFS_API
+gpfs_get_fset_snaphandle_by_path(const char *pathName);
+
+/* NAME: gpfs_get_fset_snaphandle_by_name()
+ *
+ * FUNCTION: Get a volatile handle to uniquely identify an inode space within a
+ * file system and snapshot by the independent fileset name, file system
+ * name and snapshot name.
+ *
+ * Input: fsName: unique name for gpfs file system (may be specified
+ * as fsName or /dev/fsName)
+ * fsetName name of the independent fileset that owns the inode space
+ * snapName: name for snapshot within that file system
+ * or NULL to access the active file system rather
+ * than a snapshot within the file system.
+ *
+ * Returns: pointer to gpfs_fssnap_handle_t (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * ENOENT invalid file system name
+ * GPFS_E_INVAL_FSETNAME invalid fset nsmae
+ * GPFS_E_INVAL_SNAPNAME invalid snapshot name
+ * see system calls open(), fstatfs(), and malloc() ERRORS
+ */
+gpfs_fssnap_handle_t * GPFS_API
+gpfs_get_fset_snaphandle_by_name(const char *fsName,
+ const char *fsetName,
+ const char *snapName);
+
+/* NAME: gpfs_get_fset_snaphandle_by_fset_snapid()
+ *
+ * FUNCTION: Get a volatile handle to uniquely identify a file system
+ * and snapshot by a fssnapId created from a previous handle.
+ *
+ * Input: fssnapId: unique id for a file system and snapshot
+ *
+ * Returns: pointer to gpfs_fssnap_handle_t (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * GPFS_E_INVAL_FSSNAPID invalid snapshot id
+ * see system calls open(), fstatfs(), and malloc() ERRORS
+ */
+gpfs_fssnap_handle_t * GPFS_API
+gpfs_get_fset_snaphandle_by_fset_snapid(const gpfs_fssnap_id_t *fsetsnapId);
+
+/* NAME: gpfs_get_pathname_from_fssnaphandle()
+ *
+ * FUNCTION: Get the mountpoint and path to a file system
+ * and snapshot identified by a fssnapHandle
+ *
+ * Input: fssnapHandle: ptr to file system & snapshot handle
+ *
+ * Returns: ptr to path name to the file system (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * GPFS_E_INVAL_FSSNAPHANDLE invalid fssnapHandle
+ */
+const char * GPFS_API
+gpfs_get_pathname_from_fssnaphandle(gpfs_fssnap_handle_t *fssnapHandle);
+
+
+/* NAME: gpfs_get_fsname_from_fssnaphandle()
+ *
+ * FUNCTION: Get the unique name for the file system
+ * identified by a fssnapHandle
+ *
+ * Input: fssnapHandle: ptr to file system & snapshot handle
+ *
+ * Returns: ptr to name of the file system (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * GPFS_E_INVAL_FSSNAPHANDLE invalid fssnapHandle
+ */
+const char * GPFS_API
+gpfs_get_fsname_from_fssnaphandle(gpfs_fssnap_handle_t *fssnapHandle);
+
+
+/* NAME: gpfs_get_snapname_from_fssnaphandle()
+ *
+ * FUNCTION: Get the name for the snapshot
+ * uniquely identified by a fssnapHandle
+ *
+ * Input: fssnapHandle: ptr to file system & snapshot handle
+ *
+ * Returns: ptr to name assigned to the snapshot (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * GPFS_E_INVAL_FSSNAPHANDLE invalid fssnaphandle
+ * GPFS_E_INVAL_SNAPNAME snapshot has been deleted
+ *
+ * Notes: If the snapshot has been deleted from the file system
+ * the snapId may still be valid, but the call will fail
+ * with errno set to GPFS_E_INVAL_SNAPNAME.
+ */
+const char * GPFS_API
+gpfs_get_snapname_from_fssnaphandle(gpfs_fssnap_handle_t *fssnapHandle);
+
+
+/* NAME: gpfs_get_snapid_from_fssnaphandle()
+ *
+ * FUNCTION: Get the numeric id for the snapshot identified
+ * by a fssnapHandle. The snapshots define an ordered
+ * sequence of changes to each file. The file's iattr
+ * structure defines the snapshot id in which the file
+ * was last modified (ia_modsnapid). This numeric value
+ * can be compared to the numeric snapid from a fssnaphandle
+ * to determine if the file changed before or after the
+ * snapshot identified by the fssnaphandle.
+ *
+ * Input: fssnapHandle: ptr to file system & snapshot handle
+ *
+ * Returns: Numeric id for the snapshot referred to by the fssnaphandle
+ * 0 if the fssnaphandle does not refer to a snapshot
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * GPFS_E_INVAL_FSSNAPHANDLE invalid fssnaphandle
+ *
+ * Notes: The snapshot need not be on-line to determine the
+ * snapshot's numeric id.
+ */
+gpfs_snapid_t GPFS_API
+gpfs_get_snapid_from_fssnaphandle(gpfs_fssnap_handle_t *fssnapHandle);
+
+gpfs_snapid64_t GPFS_API
+gpfs_get_snapid_from_fssnaphandle64(gpfs_fssnap_handle_t *fssnapHandle);
+
+
+/* NAME: gpfs_get_fssnapid_from_fssnaphandle()
+ *
+ * FUNCTION: Get a unique, non-volatile file system and snapshot id
+ * for the file system and snapshot identified by a
+ * volatile fssnap handle.
+ *
+ * Input: fssnapHandle: ptr to file system & snapshot handle
+ * fssnapId: returned fssnapId uniquely identifying the
+ * file system and snapshot being scanned
+ *
+ * Returns: 0 and fssnapId is set with id (Successful)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: GPFS_E_INVAL_FSSNAPHANDLE invalid fssnaphandle
+ * EINVAL null ptr given for returned fssnapId
+ * EFAULT size mismatch for fssnapId
+ */
+int GPFS_API
+gpfs_get_fssnapid_from_fssnaphandle(gpfs_fssnap_handle_t *fssnapHandle,
+ gpfs_fssnap_id_t *fssnapId);
+
+
+/* NAME: gpfs_get_restore_fssnapid_from_fssnaphandle()
+ *
+ * FUNCTION: Get the unique, non-volatile file system and snapshot id
+ * used for the last complete restore of a mirrored file
+ * system. The file system must been a previous restore
+ * target and ready for additional incremental restore.
+ *
+ * Input: fssnapHandle: ptr to file system & snapshot handle
+ * fssnapId: returned fssnapId uniquely identifying the
+ * last complete restored file system.
+ *
+ * Returns: 0 and fssnapId is set with id (Successful)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: GPFS_E_INVAL_FSSNAPHANDLE invalid fssnaphandle
+ * EINVAL null ptr given for returned fssnapId
+ * EFAULT size mismatch for fssnapId
+ * EPERM caller must have superuser privilege
+ * ENOMEM unable to allocate memory for request
+ * GPFS_E_FS_NOT_RESTORABLE fs is not clean for restore
+ */
+int GPFS_API
+gpfs_get_restore_fssnapid_from_fssnaphandle(gpfs_fssnap_handle_t *fssnapHandle,
+ gpfs_fssnap_id_t *fssnapId);
+
+/* NAME: gpfs_free_fssnaphandle()
+ *
+ * FUNCTION: Free a fssnapHandle
+ *
+ * Input: fssnapHandle: ptr to file system & snapshot handle
+ *
+ * Returns: void
+ *
+ * Errno: None
+ */
+void GPFS_API
+gpfs_free_fssnaphandle(gpfs_fssnap_handle_t *fssnapHandle);
+
+/* NAME: gpfs_get_snapdirname()
+ *
+ * FUNCTION: Get the name of the directory containing snapshots.
+ *
+ * Input: fssnapHandle: handle for the file system
+ * snapdirName: buffer into which the name of the snapshot
+ * directory will be copied
+ * bufLen: the size of the provided buffer
+ *
+ * Returns: 0 (Successful)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOMEM unable to allocate memory for request
+ * GPFS_E_INVAL_FSSNAPHANDLE fssnapHandle is invalid
+ * E2BIG buffer too small to return the snapshot directory name
+ */
+int GPFS_API
+gpfs_get_snapdirname(gpfs_fssnap_handle_t *fssnapHandle,
+ char *snapdirName,
+ int bufLen);
+
+
+/* NAME: gpfs_open_inodescan()
+ *
+ * FUNCTION: Open inode file for inode scan.
+ *
+ * Input: fssnapHandle: handle for file system and snapshot
+ * to be scanned
+ * prev_fssnapId:
+ * if NULL, all inodes of existing file will be returned;
+ * if non-null, only returns inodes of files that have changed
+ * since the specified previous snapshot;
+ * if specifies the same snapshot as the one referred by
+ * fssnapHandle, only the snapshot inodes that have been
+ * copied into this snap inode file are returned;
+ * maxIno: if non-null, returns the maximum inode number
+ * available in the inode file being scanned.
+ *
+ * Returns: pointer to gpfs_iscan_t (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL bad parameters
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOMEM unable to allocate memory for request
+ * GPFS_E_INVAL_FSSNAPHANDLE fssnapHandle is invalid
+ * GPFS_E_INVAL_FSSNAPID prev_fssnapId is invalid
+ * EDOM prev_fssnapId is from a different fs
+ * ERANGE prev_fssnapId is more recent than snapId
+ * being scanned
+ * see system calls dup() and malloc() ERRORS
+ */
+gpfs_iscan_t * GPFS_API
+gpfs_open_inodescan(gpfs_fssnap_handle_t *fssnapHandle,
+ const gpfs_fssnap_id_t *prev_fssnapId,
+ gpfs_ino_t *maxIno);
+
+gpfs_iscan_t * GPFS_API
+gpfs_open_inodescan64(gpfs_fssnap_handle_t *fssnapHandle,
+ const gpfs_fssnap_id_t *prev_fssnapId,
+ gpfs_ino64_t *maxIno);
+
+
+/* NAME: gpfs_open_inodescan_with_xattrs()
+ *
+ * FUNCTION: Open inode file and extended attributes for an inode scan
+ *
+ * Input: fssnapHandle: handle for file system and snapshot
+ * to be scanned
+ * prev_fssnapId: if NULL, all inodes of existing file will
+ * be returned; if non-null, only returns inodes of files
+ * that have changed since the specified previous snapshot;
+ * if specifies the same snapshot as the one referred by
+ * fssnapHandle, only the snapshot inodes that have been
+ * copied into this snap inode file are returned;
+ * nxAttrs: count of extended attributes to be returned.
+ * if nxAttrs is set to 0, call returns no extended
+ * attributes, like gpfs_open_inodescan.
+ * if nxAttrs is set to -1, call returns all extended attributes
+ * xAttrList: pointer to array of pointers to names of extended
+ * attribute to be returned. nxAttrList may be null if nxAttrs
+ * is set to 0 or -1.
+ * maxIno: if non-null, returns the maximum inode number
+ * available in the inode file being scanned.
+ *
+ * Returns: pointer to gpfs_iscan_t (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL bad parameters
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOMEM unable to allocate memory for request
+ * GPFS_E_INVAL_FSSNAPHANDLE fssnapHandle is invalid
+ * GPFS_E_INVAL_FSSNAPID prev_fssnapId is invalid
+ * EDOM prev_fssnapId is from a different fs
+ * ERANGE prev_fssnapId is more recent than snapId
+ * being scanned
+ * see system calls dup() and malloc() ERRORS
+ */
+gpfs_iscan_t * GPFS_API
+gpfs_open_inodescan_with_xattrs(gpfs_fssnap_handle_t *fssnapHandle,
+ const gpfs_fssnap_id_t *prev_fssnapId,
+ int nxAttrs,
+ const char *xattrsList[],
+ gpfs_ino_t *maxIno);
+
+gpfs_iscan_t * GPFS_API
+gpfs_open_inodescan_with_xattrs64(gpfs_fssnap_handle_t *fssnapHandle,
+ const gpfs_fssnap_id_t *prev_fssnapId,
+ int nxAttrs,
+ const char *xattrList[],
+ gpfs_ino64_t *maxIno);
+
+
+/* NAME: gpfs_next_inode()
+ *
+ * FUNCTION: Get next inode from inode scan. Scan terminates before
+ * the last inode specified or the last inode in the
+ * inode file being scanned.
+ *
+ * If the inode scan was opened to expressly look for inodes
+ * in a snapshot, and not dittos, gets the next inode skipping
+ * holes, if any.
+ *
+ * Input: iscan: ptr to inode scan descriptor
+ * termIno: scan terminates before this inode number
+ * caller may specify maxIno from gpfs_open_inodescan()
+ * or 0 to scan the entire inode file.
+ * iattr: pointer to returned pointer to file's iattr.
+ *
+ * Returns: 0 and *iattr set to point to gpfs_iattr_t (Successful)
+ * 0 and *iattr set to NULL for no more inodes before termIno
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOMEM buffer too small
+ * GPFS_E_INVAL_ISCAN bad parameters
+ * GPFS_E_INVAL_FSSNAPID the snapshot id provided in the
+ * gpfs iscan is not valid
+ *
+ * Notes: The data returned by gpfs_next_inode() is overwritten by
+ * subsequent calls to gpfs_next_inode() or gpfs_seek_inode().
+ *
+ * The termIno parameter provides a means to partition an
+ * inode scan such that it may be executed on more than one node.
+ */
+int GPFS_API
+gpfs_next_inode(gpfs_iscan_t *iscan,
+ gpfs_ino_t termIno,
+ const gpfs_iattr_t **iattr);
+
+int GPFS_API
+gpfs_next_inode64(gpfs_iscan_t *iscan,
+ gpfs_ino64_t termIno,
+ const gpfs_iattr64_t **iattr);
+
+
+/* NAME: gpfs_next_inode_with_xattrs()
+ *
+ * FUNCTION: Get next inode and its extended attributes from the inode scan.
+ * The set of extended attributes returned were defined when
+ * the inode scan was opened. The scan terminates before the last
+ * inode specified or the last inode in the inode file being
+ * scanned.
+ *
+ * If the inode scan was opened to expressly look for inodes
+ * in a snapshot, and not dittos, gets the next inode skipping
+ * holes, if any.
+ *
+ * Input: iscan: ptr to inode scan descriptor
+ * termIno: scan terminates before this inode number
+ * caller may specify maxIno from gpfs_open_inodescan()
+ * or 0 to scan the entire inode file.
+ * iattr: pointer to returned pointer to file's iattr.
+ * xattrBuf: pointer to returned pointer to xattr buffer
+ * xattrBufLen: returned length of xattr buffer
+ *
+ *
+ * Returns: 0 and *iattr set to point to gpfs_iattr_t (Successful)
+ * 0 and *iattr set to NULL for no more inodes before termIno
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * EFAULT buffer data was overwritten
+ * ENOMEM buffer too small
+ * GPFS_E_INVAL_ISCAN bad parameters
+ * GPFS_E_INVAL_XATTR bad parameters
+ *
+ * Notes: The data returned by gpfs_next_inode() is overwritten by
+ * subsequent calls to gpfs_next_inode(), gpfs_seek_inode()
+ * or gpfs_stat_inode().
+ *
+ * The termIno parameter provides a means to partition an
+ * inode scan such that it may be executed on more than one node.
+ *
+ * The returned values for xattrBuf and xattrBufLen must be
+ * provided to gpfs_next_xattr() to obtain the extended attribute
+ * names and values. The buffer used for the extended attributes
+ * is overwritten by subsequent calls to gpfs_next_inode(),
+ * gpfs_seek_inode() or gpfs_stat_inode();
+ *
+ * The returned pointers to the extended attribute name and value
+ * will be aligned to a double-word boundary.
+ */
+int GPFS_API
+gpfs_next_inode_with_xattrs(gpfs_iscan_t *iscan,
+ gpfs_ino_t termIno,
+ const gpfs_iattr_t **iattr,
+ const char **xattrBuf,
+ unsigned int *xattrBufLen);
+
+int GPFS_API
+gpfs_next_inode_with_xattrs64(gpfs_iscan_t *iscan,
+ gpfs_ino64_t termIno,
+ const gpfs_iattr64_t **iattr,
+ const char **xattrBuf,
+ unsigned int *xattrBufLen);
+
+
+/* NAME: gpfs_next_xattr()
+ *
+ * FUNCTION: Iterate over the extended attributes buffer returned
+ * by get_next_inode_with_xattrs to return the individual
+ * attributes and their values. Note that the attribute names
+ * are null-terminated strings, whereas the atttribute value
+ * contains binary data.
+ *
+ * Input: iscan: ptr to inode scan descriptor
+ * xattrBufLen: ptr to attribute buffer length
+ * xattrBuf: ptr to the ptr to the attribute buffer
+ *
+ * Returns: 0 and *name set to point attribue name (Successful)
+ * also sets: *valueLen to length of attribute value
+ * *value to point to attribute value
+ * *xattrBufLen to remaining length of buffer
+ * **xattrBuf to index next attribute in buffer
+ * 0 and *name set to NULL for no more attributes in buffer
+ * also sets: *valueLen to 0
+ * *value to NULL
+ * *xattrBufLen to 0
+ * **xattrBuf to NULL
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * GPFS_E_INVAL_ISCAN invalid iscan parameter
+ * GPFS_E_INVAL_XATTR invalid xattr parameters
+ *
+ * Notes: The caller is not allowed to modify the returned attribute
+ * names or values. The data returned by gpfs_next_attribute()
+ * may be overwritten by subsequent calls to gpfs_next_attribute()
+ * or other gpfs library calls.
+ */
+int GPFS_API
+gpfs_next_xattr(gpfs_iscan_t *iscan,
+ const char **xattrBuf,
+ unsigned int *xattrBufLen,
+ const char **name,
+ unsigned int *valueLen,
+ const char **value);
+
+
+
+/* NAME: gpfs_seek_inode()
+ *
+ * FUNCTION: Seek to a given inode number.
+ *
+ * Input: iscan: ptr to inode scan descriptor
+ * ino: next inode number to be scanned
+ *
+ * Returns: 0 Successful
+ * -1 Failure and errno is set
+ *
+ * Errno: ENOSYS function not available
+ * GPFS_E_INVAL_ISCAN bad parameters
+ */
+int GPFS_API
+gpfs_seek_inode(gpfs_iscan_t *iscan,
+ gpfs_ino_t ino);
+
+int GPFS_API
+gpfs_seek_inode64(gpfs_iscan_t *iscan,
+ gpfs_ino64_t ino);
+
+
+#ifdef SNAPSHOT_ILM
+
+/* define GPFS generated errno */
+#define GPFS_E_HOLE_IN_IFILE 238 /* hole in inode file */
+
+#endif
+/* NAME: gpfs_stat_inode()
+ * NAME: gpfs_stat_inode_with_xattrs()
+ *
+ * FUNCTION: Seek to the specified inode and get that inode and
+ * its extended attributes from the inode scan. This is
+ * simply a combination of gpfs_seek_inode and get_next_inode
+ * but will only return the specified inode.
+ *
+ * Input: iscan: ptr to inode scan descriptor
+ * ino: inode number to be returned
+ * termIno: prefetch inodes up to this inode
+ * caller may specify maxIno from gpfs_open_inodescan()
+ * or 0 to allow prefetching over the entire inode file.
+ * iattr: pointer to returned pointer to file's iattr.
+ * xattrBuf: pointer to returned pointer to xattr buffer
+ * xattrBufLen: returned length of xattr buffer
+ *
+ * Returns: 0 and *iattr set to point to gpfs_iattr_t (Successful)
+ * 0 and *iattr set to NULL for no more inodes before termIno
+ * or if requested inode does not exist.
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOMEM buffer too small
+ * GPFS_E_INVAL_ISCAN bad parameters
+ * GPFS_E_HOLE_IN_IFILE if we are expressly looking for inodes in
+ * the snapshot file and this one has yet not
+ * been copied into snapshot.
+ *
+ * Notes: The data returned by gpfs_next_inode() is overwritten by
+ * subsequent calls to gpfs_next_inode(), gpfs_seek_inode()
+ * or gpfs_stat_inode().
+ *
+ * The termIno parameter provides a means to partition an
+ * inode scan such that it may be executed on more than one node.
+ * It is only used by this call to control prefetching.
+ *
+ * The returned values for xattrBuf and xattrBufLen must be
+ * provided to gpfs_next_xattr() to obtain the extended attribute
+ * names and values. The buffer used for the extended attributes
+ * is overwritten by subsequent calls to gpfs_next_inode(),
+ * gpfs_seek_inode() or gpfs_stat_inode();
+ */
+int GPFS_API
+gpfs_stat_inode(gpfs_iscan_t *iscan,
+ gpfs_ino_t ino,
+ gpfs_ino_t termIno,
+ const gpfs_iattr_t **iattr);
+
+int GPFS_API
+gpfs_stat_inode64(gpfs_iscan_t *iscan,
+ gpfs_ino64_t ino,
+ gpfs_ino64_t termIno,
+ const gpfs_iattr64_t **iattr);
+
+int GPFS_API
+gpfs_stat_inode_with_xattrs(gpfs_iscan_t *iscan,
+ gpfs_ino_t ino,
+ gpfs_ino_t termIno,
+ const gpfs_iattr_t **iattr,
+ const char **xattrBuf,
+ unsigned int *xattrBufLen);
+
+int GPFS_API
+gpfs_stat_inode_with_xattrs64(gpfs_iscan_t *iscan,
+ gpfs_ino64_t ino,
+ gpfs_ino64_t termIno,
+ const gpfs_iattr64_t **iattr,
+ const char **xattrBuf,
+ unsigned int *xattrBufLen);
+
+
+/* NAME: gpfs_close_inodescan()
+ *
+ * FUNCTION: Close inode file.
+ *
+ * Input: iscan: ptr to inode scan descriptor
+ *
+ * Returns: void
+ *
+ * Errno: None
+ */
+void GPFS_API
+gpfs_close_inodescan(gpfs_iscan_t *iscan);
+
+
+/* NAME: gpfs_cmp_fssnapid()
+ *
+ * FUNCTION: Compare two fssnapIds for the same file system to
+ * determine the order in which the two snapshots were taken.
+ * The 'result' variable will be set as follows:
+ * *result < 0: snapshot 1 was taken before snapshot 2
+ * *result == 0: snapshot 1 and 2 are the same
+ * *result > 0: snapshot 1 was taken after snapshot 2
+ *
+ * Input: fssnapId1: ptr to fssnapId 1
+ * fssnapId2: ptr to fssnapId id 2
+ * result: ptr to returned results
+ *
+ * Returns: 0 and *result is set as described above (Successful)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * GPFS_E_INVAL_FSSNAPID fssnapid1 or fssnapid2 is not a
+ * valid snapshot id
+ * EDOM the two snapshots cannot be compared because
+ * they were taken from two different file systems.
+ */
+int GPFS_API
+gpfs_cmp_fssnapid(const gpfs_fssnap_id_t *fssnapId1,
+ const gpfs_fssnap_id_t *fssnapId2,
+ int *result);
+
+
+/* NAME: gpfs_iopen()
+ *
+ * FUNCTION: Open a file or directory by inode number.
+ *
+ * Input: fssnapHandle: handle for file system and snapshot
+ * being scanned
+ * ino: inode number
+ * open_flags: O_RDONLY for gpfs_iread()
+ * O_WRONLY for gpfs_iwrite()
+ * O_CREAT create the file if it doesn't exist
+ * O_TRUNC if the inode already exists delete it
+ * caller may use GPFS_O_BACKUP to read files for backup
+ * and GPFS_O_RESTORE to write files for restore
+ * statxbuf: used only with O_CREAT/GPFS_O_BACKUP
+ * all other cases set to NULL
+ * symLink: used only with O_CREAT/GPFS_O_BACKUP for a symbolic link
+ * all other cases set to NULL
+ *
+ * Returns: pointer to gpfs_ifile_t (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * ENOENT file not existed
+ * EINVAL missing or bad parameter
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOMEM unable to allocate memory for request
+ * EFORMAT invalid fs version number
+ * EIO error reading original inode
+ * ERANGE error ino is out of range, should use gpfs_iopen64
+ * GPFS_E_INVAL_INUM reserved inode is not allowed to open
+ * GPFS_E_INVAL_IATTR iattr structure was corrupted
+ * see dup() and malloc() ERRORS
+ */
+gpfs_ifile_t * GPFS_API
+gpfs_iopen(gpfs_fssnap_handle_t *fssnapHandle,
+ gpfs_ino_t ino,
+ int open_flags,
+ const gpfs_iattr_t *statxbuf,
+ const char *symLink);
+
+gpfs_ifile_t * GPFS_API
+gpfs_iopen64(gpfs_fssnap_handle_t *fssnapHandle,
+ gpfs_ino64_t ino,
+ int open_flags,
+ const gpfs_iattr64_t *statxbuf,
+ const char *symLink);
+
+
+/* Define gpfs_iopen flags as used by the backup & restore by inode.
+ The backup code will only read the source files.
+ The restore code writes the target files & creates them if they
+ don't already exist. The file length is set by the inode attributes.
+ Consequently, to restore a user file it is unnecessary to include
+ the O_TRUNC flag. */
+#define GPFS_O_BACKUP (O_RDONLY)
+#define GPFS_O_RESTORE (O_WRONLY | O_CREAT)
+
+
+/* NAME: gpfs_iread()
+ *
+ * FUNCTION: Read file opened by gpfs_iopen.
+ *
+ * Input: ifile: pointer to gpfs_ifile_t from gpfs_iopen
+ * buffer: buffer for data to be read
+ * bufferSize: size of buffer (ie amount of data to be read)
+ * In/Out offset: offset of where within the file to read
+ * if successful, offset will be updated to the
+ * next byte after the last one that was read
+ *
+ * Returns: number of bytes read (Successful)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EISDIR file is a directory
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * GPFS_E_INVAL_IFILE bad ifile parameters
+ * see system call read() ERRORS
+ */
+int GPFS_API
+gpfs_iread(gpfs_ifile_t *ifile,
+ void *buffer,
+ int bufferSize,
+ gpfs_off64_t *offset);
+
+
+/* NAME: gpfs_iwrite()
+ *
+ * FUNCTION: Write file opened by gpfs_iopen.
+ *
+ * Input: ifile: pointer to gpfs_ifile_t from gpfs_iopen
+ * buffer: the data to be written
+ * writeLen: how much to write
+ * In/Out offset: offset of where within the file to write
+ * if successful, offset will be updated to the
+ * next byte after the last one that was written
+ *
+ * Returns: number of bytes written (Successful)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EISDIR file is a directory
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * GPFS_E_INVAL_IFILE bad ifile parameters
+ * see system call write() ERRORS
+ */
+int GPFS_API
+gpfs_iwrite(gpfs_ifile_t *ifile,
+ void *buffer,
+ int writeLen,
+ gpfs_off64_t *offset);
+
+
+/* NAME: gpfs_ireaddir()
+ *
+ * FUNCTION: Get next directory entry.
+ *
+ * Input: idir: pointer to gpfs_ifile_t from gpfs_iopen
+ * dirent: pointer to returned pointer to directory entry
+ *
+ * Returns: 0 and pointer to gpfs_direntx set (Successful)
+ * 0 and pointer to gpfs_direntx set to NULL (End of directory)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * ENOTDIR file is not a directory
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * GPFS_E_INVAL_IFILE bad ifile parameter
+ * ENOMEM unable to allocate memory for request
+ *
+ * Notes: The data returned by gpfs_ireaddir() is overwritten by
+ * subsequent calls to gpfs_ireaddir().
+ */
+int GPFS_API
+gpfs_ireaddir(gpfs_ifile_t *idir,
+ const gpfs_direntx_t **dirent);
+
+int GPFS_API
+gpfs_ireaddir64(gpfs_ifile_t *idir,
+ const gpfs_direntx64_t **dirent);
+
+
+int GPFS_API
+gpfs_ireaddirx(gpfs_ifile_t *idir,
+ gpfs_iscan_t *iscan, /* in only */
+ const gpfs_direntx_t **dirent);
+
+int GPFS_API
+gpfs_ireaddirx64(gpfs_ifile_t *idir,
+ gpfs_iscan_t *iscan, /* in only */
+ const gpfs_direntx64_t **dirent);
+
+
+/* NAME: gpfs_iwritedir()
+ *
+ * FUNCTION: Create a directory entry in a directory opened by gpfs_iopen.
+ *
+ * Input: idir: pointer to gpfs_ifile_t from gpfs_iopen
+ * dirent: directory entry to be written
+ *
+ * Returns: 0 (Successful)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * GPFS_E_INVAL_IFILE bad file pointer
+ * ENOTDIR file is not a directory
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOMEM unable to allocate memory for request
+ * EFORMAT invalid dirent version number
+ * see system call write() ERRORS
+ */
+int GPFS_API
+gpfs_iwritedir(gpfs_ifile_t *idir,
+ const gpfs_direntx_t *dirent);
+
+int GPFS_API
+gpfs_iwritedir64(gpfs_ifile_t *idir,
+ const gpfs_direntx64_t *dirent);
+
+
+/* NAME: gpfs_igetattrs()
+ *
+ * FUNCTION: Retrieves all extended file attributes in opaque format.
+ * This function together with gpfs_iputattrs is intended for
+ * use by a backup program to save (gpfs_igetattrs) and
+ * restore (gpfs_iputattrs) all extended file attributes
+ * (ACLs, user attributes, ...) in one call.
+ *
+ * NOTE: This call does not return extended attributes used for
+ * the Data Storage Management (XDSM) API (aka DMAPI).
+ *
+ * Input: ifile: pointer to gpfs_ifile_t from gpfs_iopen
+ * buffer: pointer to buffer for returned attributes
+ * bufferSize: size of buffer
+ * attrSize: ptr to returned size of attributes
+ *
+ * Returns: 0 Successful
+ * -1 Failure and errno is set
+ *
+ * Errno: ENOSYS function not available
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOSPC buffer too small to return all attributes
+ * *attrSizeP will be set to the size necessary
+ * GPFS_E_INVAL_IFILE bad ifile parameters
+ */
+int GPFS_API
+gpfs_igetattrs(gpfs_ifile_t *ifile,
+ void *buffer,
+ int bufferSize,
+ int *attrSize);
+
+/* NAME: gpfs_igetattrsx()
+ *
+ * FUNCTION: Retrieves all extended file attributes in opaque format.
+ * This function together with gpfs_iputattrsx is intended for
+ * use by a backup program to save (gpfs_igetattrsx) and
+ * restore (gpfs_iputattrsx) all extended file attributes
+ * (ACLs, user attributes, ...) in one call.
+ *
+ * NOTE: This call can optionally return extended attributes
+ * used for the Data Storage Management (XDSM) API
+ * (aka DMAPI).
+ *
+ * Input: ifile: pointer to gpfs_ifile_t from gpfs_iopen
+ * flags Define behavior of get attributes
+ * GPFS_ATTRFLAG_NO_PLACEMENT - file attributes for placement
+ * are not saved, neither is the current storage pool.
+ * GPFS_ATTRFLAG_IGNORE_POOL - file attributes for placement
+ * are saved, but the current storage pool is not.
+ * GPFS_ATTRFLAG_INCL_DMAPI - file attributes for dmapi are
+ * included in the returned buffer
+ * GPFS_ATTRFLAG_INCL_ENCR - file attributes for encryption
+ * are included in the returned buffer
+ *
+ * buffer: pointer to buffer for returned attributes
+ * bufferSize: size of buffer
+ * attrSize: ptr to returned size of attributes
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL Not a GPFS file
+ * EINVAL invalid flags provided
+ * ENOSPC buffer too small to return all attributes
+ * *attrSizeP will be set to the size necessary
+ */
+int GPFS_API
+gpfs_igetattrsx(gpfs_ifile_t *ifile,
+ int flags,
+ void *buffer,
+ int bufferSize,
+ int *attrSize);
+
+
+/* NAME: gpfs_igetxattr()
+ *
+ * FUNCTION: Retrieves an extended file attributes from ifile which has been open
+ * by gpfs_iopen().
+ *
+ * NOTE: This call does not return extended attributes used for
+ * the Data Storage Management (XDSM) API (aka DMAPI).
+ *
+ * Input: ifile: pointer to gpfs_ifile_t from gpfs_iopen
+ * buffer: pointer to buffer for key and returned extended
+ * attribute value
+ * bufferSize: size of buffer, should be enough to save attribute value
+ * attrSize: ptr to key length as input and ptr to the returned
+ * size of attributes as putput.
+ *
+ * Returns: 0 Successful
+ * -1 Failure and errno is set
+ *
+ * Errno: ENOSYS function not available
+ * EPERM caller must have superuser priviledges
+ * ESTALE cached fs information was invalid
+ * ENOSPC buffer too small to return all attributes
+ * *attrSize will be set to the size necessary
+ * GPFS_E_INVAL_IFILE bad ifile parameters
+ */
+int GPFS_API
+gpfs_igetxattr(gpfs_ifile_t *ifile,
+ void *buffer,
+ int bufferSize,
+ int *attrSize);
+
+
+/* NAME: gpfs_iputattrs()
+ *
+ * FUNCTION: Sets all extended file attributes of a file.
+ * The buffer passed in should contain extended attribute data
+ * that was obtained by a previous call to gpfs_igetattrs.
+ *
+ * NOTE: This call will not restore extended attributes
+ * used for the Data Storage Management (XDSM) API
+ * (aka DMAPI). They will be silently ignored.
+ *
+ * Input: ifile: pointer to gpfs_ifile_t from gpfs_iopen
+ * buffer: pointer to buffer for returned attributes
+ *
+ * Returns: 0 Successful
+ * -1 Failure and errno is set
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL the buffer does not contain valid attribute data
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * GPFS_E_INVAL_IFILE bad ifile parameters
+ */
+int GPFS_API
+gpfs_iputattrs(gpfs_ifile_t *ifile,
+ void *buffer);
+
+
+/* NAME: gpfs_iputattrsx()
+ *
+ * FUNCTION: Sets all extended file attributes of a file.
+ *
+ * This routine can optionally invoke the policy engine
+ * to match a RESTORE rule using the file's attributes saved
+ * in the extended attributes to set the file's storage pool and
+ * data replication as when calling gpfs_fputattrswithpathname.
+ * When used with the policy the caller should include the
+ * full path to the file, including the file name, to allow
+ * rule selection based on file name or path.
+ *
+ * By default, the routine will not use RESTORE policy rules
+ * for data placement. The pathName parameter will be ignored
+ * and may be set to NULL.
+ *
+ * If the call does not use RESTORE policy rules, or if the
+ * file fails to match a RESTORE rule, or if there are no
+ * RESTORE rules installed, then the storage pool and data
+ * replication are selected as when calling gpfs_fputattrs().
+ *
+ * The buffer passed in should contain extended attribute data
+ * that was obtained by a previous call to gpfs_fgetattrs.
+ *
+ * pathName is a UTF-8 encoded string. On Windows, applications
+ * can convert UTF-16 ("Unicode") to UTF-8 using the platforms
+ * WideCharToMultiByte function.
+ *
+ * NOTE: This call will restore extended attributes
+ * used for the Data Storage Management (XDSM) API
+ * (aka DMAPI) if they are present in the buffer.
+ *
+ * Input: ifile: pointer to gpfs_ifile_t from gpfs_iopen
+ * flags Define behavior of put attributes
+ * GPFS_ATTRFLAG_NO_PLACEMENT - file attributes are restored
+ * but the storage pool and data replication are unchanged
+ * GPFS_ATTRFLAG_IGNORE_POOL - file attributes are restored
+ * but the storage pool and data replication are selected
+ * by matching the saved attributes to a placement rule
+ * instead of restoring the saved storage pool.
+ * GPFS_ATTRFLAG_USE_POLICY - file attributes are restored
+ * but the storage pool and data replication are selected
+ * by matching the saved attributes to a RESTORE rule
+ * instead of restoring the saved storage pool.
+ * GPFS_ATTRFLAG_FINALIZE_ATTRS - file attributes that are restored
+ * after data is retored. If file is immutable/appendOnly
+ * call without this flag before restoring data
+ * then call with this flag after restoring data
+ * GPFS_ATTRFLAG_INCL_ENCR - file attributes for encryption
+ * are restored. Note that this may result in the file's
+ * File Encryption Key (FEK) being changed, and in this
+ * case any prior content in the file is effectively lost.
+ * This option should only be used when the entire file
+ * content is restored after the attributes are restored.
+ *
+ * buffer: pointer to buffer for returned attributes
+ * pathName: pointer to file path and file name for file
+ * May be set to NULL.
+ *
+ * Returns: 0 Successful
+ * -1 Failure and errno is set
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL the buffer does not contain valid attribute data
+ * EINVAL invalid flags provided
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * GPFS_E_INVAL_IFILE bad ifile parameters
+ */
+int GPFS_API
+gpfs_iputattrsx(gpfs_ifile_t *ifile,
+ int flags,
+ void *buffer,
+ const char *pathName);
+
+
+/* NAME: gpfs_igetfilesetname()
+ *
+ * FUNCTION: Retrieves the name of the fileset which contains this file.
+ * The fileset name is a null-terminated string, with a
+ * a maximum length of GPFS_MAXNAMLEN.
+ *
+ * Input: iscan: ptr to gpfs_iscan_t from gpfs_open_inodescan()
+ * filesetId: ia_filesetId returned in an iattr from the iscan
+ * buffer: pointer to buffer for returned fileset name
+ * bufferSize: size of buffer
+ *
+ * Returns: 0 Successful
+ * -1 Failure and errno is set
+ *
+ * Errno: ENOSYS function not available
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOSPC buffer too small to return fileset name
+ * GPFS_E_INVAL_ISCAN bad iscan parameter
+ */
+int GPFS_API
+gpfs_igetfilesetname(gpfs_iscan_t *iscan,
+ unsigned int filesetId,
+ void *buffer,
+ int bufferSize);
+
+
+/* NAME: gpfs_igetstoragepool()
+ *
+ * FUNCTION: Retrieves the name of the storage pool assigned for
+ * this file's data. The storage pool name is a null-terminated
+ * string, with a maximum length of GPFS_MAXNAMLEN.
+ *
+ * Input: iscan: ptr to gpfs_iscan_t from gpfs_open_inodescan()
+ * dataPoolId: ia_dataPoolId returned in an iattr from the iscan
+ * buffer: pointer to buffer for returned attributes
+ * bufferSize: size of buffer
+ *
+ * Returns: 0 Successful
+ * -1 Failure and errno is set
+ *
+ * Errno: ENOSYS function not available
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOSPC buffer too small to return all storage pool name
+ * GPFS_E_INVAL_ISCAN bad iscan parameters
+ */
+int GPFS_API
+gpfs_igetstoragepool(gpfs_iscan_t *iscan,
+ unsigned int dataPoolId,
+ void *buffer,
+ int bufferSize);
+
+
+/* NAME: gpfs_iclose()
+ *
+ * FUNCTION: Close file opened by inode and update dates.
+ *
+ * Input: ifile: pointer to gpfs_ifile_t from gpfs_iopen
+ *
+ * Returns: void
+ */
+void GPFS_API
+gpfs_iclose(gpfs_ifile_t *ifile);
+
+
+/* NAME: gpfs_ireadlink()
+ *
+ * FUNCTION: Read symbolic link by inode number.
+ *
+ * Input: fssnapHandle: handle for file system & snapshot being scanned
+ * ino: inode number of link file to read
+ * buffer: pointer to buffer for returned link data
+ * bufferSize: size of the buffer
+ *
+ * Returns: number of bytes read (Successful)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * GPFS_E_INVAL_FSSNAPHANDLE invalid fssnap handle
+ * see system call readlink() ERRORS
+ */
+int GPFS_API
+gpfs_ireadlink(gpfs_fssnap_handle_t *fssnapHandle,
+ gpfs_ino_t ino,
+ char *buffer,
+ int bufferSize);
+
+int GPFS_API
+gpfs_ireadlink64(gpfs_fssnap_handle_t *fssnapHandle,
+ gpfs_ino64_t ino,
+ char *buffer,
+ int bufferSize);
+
+
+/* NAME: gpfs_sync_fs()
+ *
+ * FUNCTION: sync file system.
+ *
+ * Input: fssnapHandle: handle for file system being restored
+ *
+ * Returns: 0 all data flushed to disk (Successful)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * ENOMEM unable to allocate memory for request
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * GPFS_E_INVAL_FSSNAPHANDLE invalid fssnapHandle
+ */
+int GPFS_API
+gpfs_sync_fs(gpfs_fssnap_handle_t *fssnapHandle);
+
+
+/* NAME: gpfs_enable_restore()
+ *
+ * FUNCTION: Mark file system as enabled for restore on/off
+ *
+ * Input: fssnapHandle: handle for file system to be enabled
+ * or disabled for restore
+ * on_off: flag set to 1 to enable restore
+ * 0 to disable restore
+ *
+ * Returns: 0 (Successful)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL bad parameters
+ * GPFS_E_INVAL_FSSNAPHANDLE invalid fssnapHandle
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOMEM unable to allocate memory for request
+ * E_FS_NOT_RESTORABLE fs is not clean
+ * EALREADY fs already marked as requested
+ * E_RESTORE_STARTED restore in progress
+ *
+ * Notes: EALREADY indicates enable/disable restore was already called
+ * for this fs. The caller must decide if EALREADY represents an
+ * error condition.
+ */
+int GPFS_API
+gpfs_enable_restore(gpfs_fssnap_handle_t *fssnapHandle,
+ int on_off);
+
+
+/* NAME: gpfs_start_restore()
+ *
+ * FUNCTION: Start a restore session.
+ *
+ * Input: fssnapHandle: handle for file system to be restored
+ * restore_flags: Flag to indicate the restore should be started
+ * even if a prior restore has not completed.
+ * old_fssnapId: fssnapId of last restored snapshot
+ * new_fssnapId: fssnapId of snapshot being restored
+ *
+ * Returns: pointer to gpfs_restore_t (Successful)
+ * NULL and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * ENOMEM unable to allocate memory for request
+ * EINVAL missing parameter
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * EDOM restore fs does not match existing fs
+ * ERANGE restore is missing updates
+ * EFORMAT invalid fs version number
+ * GPFS_E_INVAL_FSSNAPHANDLE invalid fssnaphandle
+ * GPFS_E_INVAL_FSSNAPID bad fssnapId parameter
+ * E_FS_NOT_RESTORABLE fs is not clean for restore
+ * E_RESTORE_NOT_ENABLED fs is not enabled for restore
+ * EALREADY Restore already in progress
+ *
+ * Note: EALREADY indicates start restore was already called for
+ * this fs. This could be due to a prior restore process that failed
+ * or it could be due to a concurrent restore process still running.
+ * The caller must decide if EALREADY represents an error condition.
+ */
+gpfs_restore_t * GPFS_API
+gpfs_start_restore(gpfs_fssnap_handle_t *fssnapHandle,
+ int restore_flags,
+ const gpfs_fssnap_id_t *old_fssnapId,
+ const gpfs_fssnap_id_t *new_fssnapId);
+
+#define GPFS_RESTORE_NORMAL 0 /* Restore not started if prior restore
+ has not completed. */
+#define GPFS_RESTORE_FORCED 1 /* Restore starts even if prior restore
+ has not completed. */
+
+
+/* NAME: gpfs_end_restore()
+ *
+ * FUNCTION: End a restore session.
+ *
+ * Input: restoreId: ptr to gpfs_restore_t
+ *
+ * Returns: 0 (Successful)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL bad parameters
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * GPFS_E_INVAL_RESTORE bad restoreId parameter
+ * GPFS_E_FS_NOT_RESTORABLE fs is not clean for restore
+ * GPFS_E_RESTORE_NOT_ENABLED fs is not enabled for restore
+ * EALREADY Restore already ended
+ *
+ * Note: EALREADY indicates end restore was already called for
+ * this fs. This could be due to a concurrent restore process that
+ * already completed. The caller must decide if EALREADY represents
+ * an error condition.
+ */
+int GPFS_API
+gpfs_end_restore(gpfs_restore_t *restoreId);
+
+
+/* NAME: gpfs_ireadx()
+ *
+ * FUNCTION: Block level incremental read on a file opened by gpfs_iopen
+ * with a given incremental scan opened via gpfs_open_inodescan.
+ *
+ * Input: ifile: ptr to gpfs_ifile_t returned from gpfs_iopen()
+ * iscan: ptr to gpfs_iscan_t from gpfs_open_inodescan()
+ * buffer: ptr to buffer for returned data
+ * bufferSize: size of buffer for returned data
+ * offset: ptr to offset value
+ * termOffset: read terminates before reading this offset
+ * caller may specify ia_size for the file's
+ * gpfs_iattr_t or 0 to scan the entire file.
+ * hole: ptr to returned flag to indicate a hole in the file
+ *
+ * Returns: number of bytes read and returned in buffer
+ * or size of hole encountered in the file. (Success)
+ * -1 and errno is set (Failure)
+ *
+ * On input, *offset contains the offset in the file
+ * at which to begin reading to find a difference same file
+ * in a previous snapshot specified when the inodescan was opened.
+ * On return, *offset contains the offset of the first
+ * difference.
+ *
+ * On return, *hole indicates if the change in the file
+ * was data (*hole == 0) and the data is returned in the
+ * buffer provided. The function's value is the amount of data
+ * returned. If the change is a hole in the file,
+ * *hole != 0 and the size of the changed hole is returned
+ * as the function value.
+ *
+ * A call with a NULL buffer pointer will query the next increment
+ * to be read from the current offset. The *offset, *hole and
+ * returned length will be set for the next increment to be read,
+ * but no data will be returned. The bufferSize parameter is
+ * ignored, but the termOffset parameter will limit the
+ * increment returned.
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL missing or bad parameter
+ * EISDIR file is a directory
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * ENOMEM unable to allocate memory for request
+ * EDOM fs snapId does match local fs
+ * ERANGE previous snapId is more recent than scanned snapId
+ * GPFS_E_INVAL_IFILE bad ifile parameter
+ * GPFS_E_INVAL_ISCAN bad iscan parameter
+ * see system call read() ERRORS
+ *
+ * Notes: The termOffset parameter provides a means to partition a
+ * file's data such that it may be read on more than one node.
+ */
+gpfs_off64_t GPFS_API
+gpfs_ireadx(gpfs_ifile_t *ifile, /* in only */
+ gpfs_iscan_t *iscan, /* in only */
+ void *buffer, /* in only */
+ int bufferSize, /* in only */
+ gpfs_off64_t *offset, /* in/out */
+ gpfs_off64_t termOffset, /* in only */
+ int *hole); /* out only */
+
+
+/* NAME: gpfs_ireadx_ext
+ *
+ * FUNCTION: gpfs_ireadx_ext is used to find different blocks between clone
+ * child and parent files. Input and output are the same as
+ * gpfs_ireadx.
+ *
+ * Returns: See gpfs_ireadx()
+ */
+gpfs_off64_t GPFS_API
+gpfs_ireadx_ext(gpfs_ifile_t *ifile, /* in only */
+ gpfs_iscan_t *iscan, /* in only */
+ void *buffer, /* in only */
+ int bufferSize, /* in only */
+ gpfs_off64_t *offset, /* in/out */
+ gpfs_off64_t termOffset, /* in only */
+ int *hole);
+
+
+/* NAME: gpfs_iwritex()
+ *
+ * FUNCTION: Write file opened by gpfs_iopen.
+ * If parameter hole == 0, then write data
+ * addressed by buffer to the given offset for the
+ * given length. If hole != 0, then write
+ * a hole at the given offset for the given length.
+ *
+ * Input: ifile : ptr to gpfs_ifile_t returned from gpfs_iopen()
+ * buffer: ptr to data buffer
+ * writeLen: length of data to write
+ * offset: offset in file to write data
+ * hole: flag =1 to write a "hole"
+ * =0 to write data
+ *
+ * Returns: number of bytes/size of hole written (Success)
+ * -1 and errno is set (Failure)
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL missing or bad parameter
+ * EISDIR file is a directory
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * GPFS_E_INVAL_IFILE bad ifile parameter
+ * see system call write() ERRORS
+ */
+gpfs_off64_t GPFS_API
+gpfs_iwritex(gpfs_ifile_t *ifile, /* in only */
+ void *buffer, /* in only */
+ gpfs_off64_t writeLen, /* in only */
+ gpfs_off64_t offset, /* in only */
+ int hole); /* in only */
+
+
+/* NAME: gpfs_statfspool()
+ *
+ * FUNCTION: Obtain status information about the storage pools
+ *
+ * Input: pathname : path to any file in the file system
+ * poolId : id of first pool to return
+ * on return set to next poolId or -1
+ * to indicate there are no more pools.
+ * options : option flags (currently not used)
+ * nPools : number of stat structs requested or 0
+ * on return number of stat structs in buffer
+ * or if nPools was 0 its value is the max number
+ * of storage pools currently defined
+ * buffer : ptr to return stat structures
+ * bufferSize : sizeof stat buffer
+ *
+ * The user is expected to issue two or more calls. On the first
+ * call the user should pass nPools set to 0 and gpfs will
+ * return in nPools the total number of storage pools currently
+ * defined for the file system indicated by the pathname
+ * and it returns in poolId the id of the first storage pool.
+ * The buffer parameter may be set to NULL for this call.
+ *
+ * The user may then allocate a buffer large enough to contain
+ * a gpfs_statfspool_t structure for each of the pools and issue
+ * a second call to obtain stat information about each pool.
+ * Parameter nPools should be set the number of pools requested.
+ * On return, nPools will be set to the number of stat structs
+ * contained in the buffer, and poolId will be set to the id
+ * of the next storage pool or -1 to indicate there are no
+ * additional storage pools defined.
+ *
+ * Alternatively, if the user has a valid poolId from a previous
+ * call, the user may provide that poolId and a buffer large
+ * enough for a single gpfs_statfspool_t structure, and the call
+ * will return the status for a single storage pool.
+ *
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: Specific error indication
+ * EINVAL
+ */
+int GPFS_API
+gpfs_statfspool(const char *pathname, /* in only: path to file system*/
+ gpfs_pool_t *poolId, /* in out: id of first pool to return
+ on return set to next poolId
+ or -1 when there are no more pools */
+ unsigned int options, /* in only: option flags */
+ int *nPools, /* in out: number of pool stats requested
+ on return number of stat structs
+ returned in buffer or if nPools was
+ set to 0, the return value is the
+ number of pools currently defined */
+ void *buffer, /* ptr to return stat structures */
+ int bufferSize); /* sizeof stat buffer or 0 */
+
+
+/* NAME: gpfs_getpoolname()
+ *
+ * FUNCTION: Retrieves the name of the storage pool assigned for
+ * this file's data. The storage pool name is a null-terminated
+ * string, with a maximum length of GPFS_MAXNAMLEN.
+ *
+ * Input: pathname: path to any file in the file system
+ * poolId: f_poolid returned in gpfs_statfspool_t
+ * buffer: pointer to buffer for returned name
+ * bufferSize: size of buffer
+ *
+ * Returns: 0 Successful
+ * -1 Failure and errno is set
+ *
+ * Errno: ENOSYS function not available
+ * ESTALE file system was unmounted
+ * E_FORMAT_INCOMPAT file system does not support pools
+ * E2BIG buffer too small to return storage pool name
+ */
+int GPFS_API
+gpfs_getpoolname(const char *pathname,
+ gpfs_pool_t poolId,
+ void *buffer,
+ int bufferSize);
+
+
+/* /usr/src/linux/include/linux/fs.h includes /usr/src/linux/include/linux/quota.h
+ which has conflicting definitions. */
+#ifdef _LINUX_QUOTA_
+ #undef Q_SYNC
+ #undef Q_GETQUOTA
+ #undef Q_SETQUOTA
+ #undef Q_QUOTAON
+ #undef Q_QUOTAOFF
+#endif
+
+
+/* GPFS QUOTACTL */
+
+/*
+ * Command definitions for the 'gpfs_quotactl' system call.
+ * The commands are broken into a main command defined below
+ * and a subcommand that is used to convey the type of
+ * quota that is being manipulated (see above).
+ */
+
+#define SUBCMDMASK 0x00ff
+#define SUBCMDSHIFT 8
+#define GPFS_QCMD(cmd, type) (((cmd) << SUBCMDSHIFT) | ((type) & SUBCMDMASK))
+
+#define Q_QUOTAON 0x0100 /* enable quotas */
+#define Q_QUOTAOFF 0x0200 /* disable quotas */
+#define Q_GETQUOTA 0x0300 /* get limits and usage */
+#ifndef _LINUX_SOURCE_COMPAT
+ /* Standard AIX definitions of quota commands */
+ #define Q_SETQUOTA 0x0400 /* set limits */
+ #define Q_SETQLIM Q_SETQUOTA
+#else
+ /* Alternate definitions, for Linux Affinity */
+ #define Q_SETQLIM 0x0400 /* set limits */
+ #define Q_SETQUOTA 0x0700 /* set limits and usage */
+#endif
+#define Q_SETUSE 0x0500 /* set usage */
+#define Q_SYNC 0x0600 /* sync disk copy of a file systems quotas */
+#define Q_SETGRACETIME 0x0900 /* set grace time */
+#define Q_SETGRACETIME_ENHANCE 0x0800 /* set grace time and update all
+ * quota entries */
+#define Q_GETDQPFSET 0x0A00 /* get default quota per fileset */
+#define Q_SETDQPFSET 0x0B00 /* set default quota per fileset */
+#define Q_SETQUOTA_UPDATE_ET 0x0C00 /* this SETQUOTA needs to update entryType */
+#define Q_GETDQPFSYS 0x0D00 /* get default quota per file system */
+#define Q_SETDQPFSYS 0x0E00 /* set default quota per file system */
+
+/* gpfs quota types */
+#define GPFS_USRQUOTA 0
+#define GPFS_GRPQUOTA 1
+#define GPFS_FILESETQUOTA 2
+
+/* define GPFS generated errno */
+#define GPFS_E_NO_QUOTA_INST 237 /* file system does not support quotas */
+
+typedef struct gpfs_quotaInfo
+{
+ gpfs_off64_t blockUsage; /* current block count in 1 KB units*/
+ gpfs_off64_t blockHardLimit; /* absolute limit on disk blks alloc */
+ gpfs_off64_t blockSoftLimit; /* preferred limit on disk blks */
+ gpfs_off64_t blockInDoubt; /* distributed shares + "lost" usage for blks */
+ int inodeUsage; /* current # allocated inodes */
+ int inodeHardLimit; /* absolute limit on allocated inodes */
+ int inodeSoftLimit; /* preferred inode limit */
+ int inodeInDoubt; /* distributed shares + "lost" usage for inodes */
+ gpfs_uid_t quoId; /* uid, gid or fileset id */
+ int entryType; /* entry type, not used */
+ unsigned int blockGraceTime; /* time limit for excessive disk use */
+ unsigned int inodeGraceTime; /* time limit for excessive inode use */
+} gpfs_quotaInfo_t;
+
+
+/* NAME: gpfs_quotactl()
+ *
+ * FUNCTION: Manipulate disk quotas
+ * INPUT: pathname: specifies the pathname of any file within the
+ * mounted file system to which the command is to
+ * be applied
+ * cmd: specifies a quota control command to be applied
+ * to UID/GID/FILESETID id. The cmd parameter can be
+ * constructed using GPFS_QCMD(cmd, type) macro defined
+ * in gpfs.h
+ * id: UID or GID or FILESETID that command applied to.
+ * bufferP: points to the address of an optional, command
+ * specific, data structure that is copied in or out of
+ * the system.
+ *
+ * OUTPUT: bufferP, if applicable.
+ *
+ * Returns: 0 success
+ * -1 failure
+ *
+ * Errno: EACCESS
+ * EFAULT An invalid bufferP parameter is supplied;
+ * the associated structure could not be copied
+ * in or out of the kernel
+ * EINVAL
+ * ENOENT No such file or directory
+ * EPERM The quota control command is privileged and
+ * the caller did not have root user authority
+ * EOPNOTSUPP
+ * GPFS_E_NO_QUOTA_INST The file system does not support quotas
+ */
+int GPFS_API
+gpfs_quotactl(const char *pathname,
+ int cmd,
+ int id,
+ void *bufferP);
+
+
+/* NAME: gpfs_getfilesetid()
+ *
+ * FUNCTION: Translate FilesetName to FilesetID
+ *
+ * INPUT: pathname: specifies the pathname of any file within the
+ * mounted file system to which the command is to
+ * be applied
+ * name: name of the fileset
+ *
+ * OUTPUT: idP: points to the address of an integer that receives the ID
+ *
+ * Returns: 0 success
+ * -1 failure
+ *
+ * Errno: EACCESS
+ * EFAULT An invalid pointer is supplied; the associated
+ * data could not be copied in or out of the kernel
+ * EINVAL
+ * ENOENT No such file, directory or fileset
+ */
+int GPFS_API
+gpfs_getfilesetid(const char *pathname,
+ const char *name,
+ int *idP);
+
+
+/* NAME: gpfs_clone_snap()
+ *
+ * FUNCTION: Create an immutable clone parent from a source file
+ *
+ * Input: sourcePathP: path to source file, which will be cloned
+ * destPathP: path to destination file, to be created
+ *
+ * If destPathP is NULL, then the source file will be changed
+ * in place into an immutable clone parent.
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * ENOENT File does not exist
+ * EACCESS Write access to target or source search permission denied
+ * EINVAL Not a regular file or not a GPFS file system
+ * EFAULT Input argument points outside accessible address space
+ * ENAMETOOLONG Source or destination path name too long
+ * ENOSPC Not enough space on disk
+ * EISDIR Destination is a directory
+ * EXDEV Source and destination aren't in the same file system
+ * EROFS Destination is read-only
+ * EPERM Invalid source file
+ * EEXIST Destination file already exists
+ * EBUSY Source file is open
+ * EFORMAT File system does not support clones
+ * EMEDIUMTYPE File system does not support clones
+ */
+int GPFS_API
+gpfs_clone_snap(const char *sourcePathP, const char *destPathP);
+
+/* NAME: gpfs_clone_copy()
+ *
+ * FUNCTION: Create a clone copy of an immutable clone parent file
+ *
+ * Input: sourcePathP: path to immutable source file, to be cloned
+ * destPathP: path to destination file, to be created
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * ENOENT File does not exist
+ * EACCESS Write access to target or source search permission denied
+ * EINVAL Not a regular file or not a GPFS file system
+ * EFAULT Input argument points outside accessible address space
+ * ENAMETOOLONG Source or destination path name too long
+ * ENOSPC Not enough space on disk
+ * EISDIR Destination is a directory
+ * EXDEV Source and destination aren't in the same file system
+ * EROFS Destination is read-only
+ * EPERM Invalid source or destination file
+ * EEXIST Destination file already exists
+ * EFORMAT File system does not support clones
+ * EMEDIUMTYPE File system does not support clones
+ */
+int GPFS_API
+gpfs_clone_copy(const char *sourcePathP, const char *destPathP);
+
+
+/* NAME: gpfs_declone()
+ *
+ * FUNCTION: Copy blocks from clone parent(s) to child so that the
+ * parent blocks are no longer referenced by the child.
+ *
+ * Input: fileDesc: File descriptor for file to be de-cloned
+ * ancLimit: Ancestor limit (immediate parent only, or all)
+ * nBlocks: Maximum number of GPFS blocks to copy
+ * In/Out: offsetP: Pointer to starting offset within file (will be
+ * updated to offset of next block to process or
+ * -1 if no more blocks)
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * EINVAL Invalid argument to function
+ * EBADF Bad file descriptor or not a GPFS file
+ * EPERM Not a regular file
+ * EACCESS Write access to target file not permitted
+ * EFAULT Input argument points outside accessible address space
+ * ENOSPC Not enough space on disk
+ */
+
+/* Values for ancLimit */
+#define GPFS_CLONE_ALL 0
+#define GPFS_CLONE_PARENT_ONLY 1
+
+int GPFS_API
+gpfs_declone(gpfs_file_t fileDesc, int ancLimit, gpfs_off64_t nBlocks,
+ gpfs_off64_t *offsetP);
+
+/* NAME: gpfs_clone_split()
+ *
+ * FUNCTION: Split a clone child file from its parent. Must call
+ * gpfs_declone first, to remove all references.
+ *
+ * Input: fileDesc: File descriptor for file to be split
+ * ancLimit: Ancestor limit (immediate parent only, or all)
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * EINVAL Invalid argument to function
+ * EBADF Bad file descriptor or not a GPFS file
+ * EPERM Not a regular file or not a clone child
+ * EACCESS Write access to target file not permitted
+ */
+int GPFS_API
+gpfs_clone_split(gpfs_file_t fileDesc, int ancLimit);
+
+/* NAME: gpfs_clone_unsnap()
+ *
+ * FUNCTION: Change a clone parent with no children back into a
+ * normal file.
+ *
+ * Input: fileDesc: File descriptor for file to be un-snapped
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * EINVAL Invalid argument to function
+ * EBADF Bad file descriptor or not a GPFS file
+ * EPERM Not a regular file or not a clone parent
+ * EACCESS Write access to target file not permitted
+ */
+int GPFS_API
+gpfs_clone_unsnap(gpfs_file_t fileDesc);
+
+/* NAME: gpfs_get_fset_masks()
+ *
+ * FUNCTION: return bit masks governing "external" inode and inode-space numbering
+ *
+ * Input: fset_snaphandle: ptr to an fset snaphandle
+ * Output: the bit masks and inodes per block factor.
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * GPFS_E_INVAL_FSSNAPHANDLE invalid fssnapHandle
+ */
+int GPFS_API
+gpfs_get_fset_masks(gpfs_fssnap_handle_t* fset_snapHandle,
+ gpfs_ino64_t* inodeSpaceMask,
+ gpfs_ino64_t* inodeBlockMask,
+ int* inodesPerInodeBlock);
+
+
+/*
+ * API functions for Light Weight Event
+ */
+
+/*
+ * Define light weight event types
+ */
+typedef enum
+{
+ GPFS_LWE_EVENT_UNKNOWN = 0, /* "Uknown event" */
+ GPFS_LWE_EVENT_FILEOPEN = 1, /* 'OPEN' - look at getInfo('OPEN_FLAGS') if you care */
+ GPFS_LWE_EVENT_FILECLOSE = 2, /* "File Close Event" 'CLOSE' */
+ GPFS_LWE_EVENT_FILEREAD = 3, /* "File Read Event" 'READ' */
+ GPFS_LWE_EVENT_FILEWRITE = 4, /* "File Write Event" 'WRITE' */
+ GPFS_LWE_EVENT_FILEDESTROY = 5, /* File is being destroyed 'DESTROY' */
+ GPFS_LWE_EVENT_FILEEVICT = 6, /* OpenFile object is being evicted from memory 'FILE_EVICT' */
+ GPFS_LWE_EVENT_BUFFERFLUSH = 7, /* Data buffer is being written to disk 'BUFFER_FLUSH' */
+ GPFS_LWE_EVENT_POOLTHRESHOLD = 8, /* Storage pool exceeded defined utilization 'POOL_THRESHOLD' */
+ GPFS_LWE_EVENT_FILEDATA = 9, /* "Read/Write/Trunc" event on open file */
+ GPFS_LWE_EVENT_FILERENAME = 10, /* Rename event on open file */
+ GPFS_LWE_EVENT_FILEUNLINK = 11, /* Unlink file event */
+ GPFS_LWE_EVENT_FILERMDIR = 12, /* Remove directory event */
+ GPFS_LWE_EVENT_EVALUATE = 13, /* Evaluate And Set Events */
+
+ GPFS_LWE_EVENT_FILEOPEN_READ = 14, /* Open for Read Only - EVENT 'OPEN_READ' - deprecated, use 'OPEN' */
+ GPFS_LWE_EVENT_FILEOPEN_WRITE = 15, /* Open with Writing privileges - EVENT 'OPEN_WRITE' - deprecated, use 'OPEN' */
+
+ GPFS_LWE_EVENT_FILEPOOL_CHANGE = 16, /* Open with Writing privileges - EVENT 'OPEN_WRITE' - deprecated, use 'OPEN' */
+
+ GPFS_LWE_EVENT_MAX = 17, /* 1 greater than any of the above */
+} gpfs_lwe_eventtype_t;
+
+
+/* Define light weight event response types */
+typedef enum
+{
+ GPFS_LWE_RESP_INVALID = 0, /* "Response Invalid/Unknown" */
+ GPFS_LWE_RESP_CONTINUE = 1, /* "Response Continue" */
+ GPFS_LWE_RESP_ABORT = 2, /* "Response Abort" */
+ GPFS_LWE_RESP_DONTCARE = 3 /* "Response DontCare" */
+} gpfs_lwe_resp_t;
+
+/*
+ * Define light weight event inofrmation
+ */
+#define LWE_DATA_FS_NAME 0x00000001 /* "fsName" */
+#define LWE_DATA_PATH_NAME 0x00000002 /* "pathName" */
+#define LWE_DATA_PATH_NEW_NAME 0x00000004 /* "pathNewName" for reanem */
+#define LWE_DATA_URL 0x00000008 /* "URL" */
+#define LWE_DATA_INODE 0x00000010 /* "inode" */
+#define LWE_DATA_OPEN_FLAGS 0x00000020 /* "openFlags" */
+#define LWE_DATA_POOL_NAME 0x00000040 /* "poolName" */
+#define LWE_DATA_FILE_SIZE 0x00000080 /* "fileSize" */
+#define LWE_DATA_OWNER_UID 0x00000100 /* "ownerUserId" */
+#define LWE_DATA_OWNER_GID 0x00000200 /* "ownerGroupId" */
+#define LWE_DATA_ATIME 0x00000400 /* "atime" */
+#define LWE_DATA_MTIME 0x00000800 /* "mtime" */
+#define LWE_DATA_NOW_TIME 0x00001000 /* "nowTime" */
+#define LWE_DATA_ELAPSED_TIME 0x00002000 /* "elapsedTime" */
+#define LWE_DATA_CLIENT_UID 0x00004000 /* "clientUserId" */
+#define LWE_DATA_CLIENT_GID 0x00008000 /* "clientGroupId" */
+#define LWE_DATA_NFS_IP 0x00010000 /* "clientIp" */
+#define LWE_DATA_PROCESS_ID 0x00020000 /* "processId" */
+#define LWE_DATA_TARGET_POOL_NAME 0x00040000 /* "targetPoolName" */
+#define LWE_DATA_BYTES_READ 0x00080000 /* "bytesRead" */
+#define LWE_DATA_BYTES_WRITTEN 0x00100000 /* "bytesWritten" */
+#define LWE_DATA_CLUSTER_NAME 0x00200000 /* "clusterName" */
+#define LWE_DATA_NODE_NAME 0x00400000 /* "nodeName" */
+
+/*
+ * Define light weight events
+ */
+#define LWE_EVENT_EVALUATED 0x00000001 /* policy was evaluated */
+#define LWE_EVENT_FILEOPEN 0x00000002 /* "op_open" */
+#define LWE_EVENT_FILECLOSE 0x00000004 /* "op_close" */
+#define LWE_EVENT_FILEREAD 0x00000008 /* "op_read" */
+#define LWE_EVENT_FILEWRITE 0x00000010 /* "op_write" */
+#define LWE_EVENT_FILEDESTROY 0x00000020 /* "op_destroy" */
+#define LWE_EVENT_FILEEVICT 0x00000040 /* "op_evict" OpenFile object is being evicted from memory 'FILE_EVICT' */
+#define LWE_EVENT_BUFFERFLUSH 0x00000080 /* "op_buffer_flush" Data buffer is being written to disk 'BUFFER_FLUSH' */
+#define LWE_EVENT_POOLTHRESHOLD 0x00000100 /* "op_pool_threshhold" Storage pool exceeded defined utilization 'POOL_THRESHOLD' */
+#define LWE_EVENT_FILEDATA 0x00000200 /* "op_data" "Read/Write/Trunc" event on open file */
+#define LWE_EVENT_FILERENAME 0x00000400 /* "op_rename" Rename event on open file */
+#define LWE_EVENT_FILEUNLINK 0x00000800 /* "op_unlink" Unlink file event */
+#define LWE_EVENT_FILERMDIR 0x00001000 /* "op_rmdir" Remove directory event */
+#define LWE_EVENT_FILEOPEN_READ 0x00002000 /* "op_open_read" Open for Read Only - EVENT 'OPEN_READ' - deprecated, use 'OPEN' */
+#define LWE_EVENT_FILEOPEN_WRITE 0x00004000 /* "op_open_write" Open with Writing privileges - EVENT 'OPEN_WRITE' - deprecated, use 'OPEN' */
+#define LWE_EVENT_FILEPOOL_CHANGE 0x00008000 /* "op_pool_change" Open with Writing privileges - EVENT 'OPEN_WRITE' - deprecated, use 'OPEN' */
+
+/*
+ * Defines for light weight sessions
+ */
+typedef unsigned long long gpfs_lwe_sessid_t;
+#define GPFS_LWE_NO_SESSION ((gpfs_lwe_sessid_t) 0)
+#define GPFS_LWE_SESSION_INFO_LEN 256
+
+
+/*
+ * Define light weight token to identify access right
+ */
+typedef struct gpfs_lwe_token
+{
+ unsigned long long high;
+ unsigned long long low;
+
+#ifdef __cplusplus
+ bool operator == (const struct gpfs_lwe_token& rhs) const
+ { return high == rhs.high && low == rhs.low; };
+ bool operator != (const struct gpfs_lwe_token& rhs) const
+ { return high != rhs.high || low != rhs.low; };
+#endif /* __cplusplus */
+
+} gpfs_lwe_token_t;
+
+/* Define special tokens */
+static const gpfs_lwe_token_t _gpfs_lwe_no_token = { 0, 0 };
+#define GPFS_LWE_NO_TOKEN _gpfs_lwe_no_token
+
+static const gpfs_lwe_token_t _gpfs_lwe_invalid_token = { 0, 1 };
+#define GPFS_LWE_INVALID_TOKEN _gpfs_lwe_invalid_token
+
+/*
+ * Note: LWE data managers can set a file's off-line bit
+ * or any of the managed bits visible to the policy language
+ * by calling dm_set_region or dm_set_region_nosync
+ * with a LWE session and LWE exclusive token. To set the bits
+ * there must be * exactly one managed region with offset = -1
+ * and size = 0. Any other values will return EINVAL.
+ */
+
+/* LWE also provides light weight regions
+ * that are set via policy rules.
+ */
+#define GPFS_LWE_MAX_REGIONS 2
+
+/* LWE data events are generated from user access
+ * to a LWE managed region. */
+#define GPFS_LWE_DATAEVENT_NONE (0x0)
+#define GPFS_LWE_DATAEVENT_READ (0x1)
+#define GPFS_LWE_DATAEVENT_WRITE (0x2)
+#define GPFS_LWE_DATAEVENT_TRUNCATE (0x4)
+
+
+
+/*
+ * Define light weight event structure
+ */
+typedef struct gpfs_lwe_event {
+ int eventLen; /* offset 0 */
+ gpfs_lwe_eventtype_t eventType; /* offset 4 */
+ gpfs_lwe_token_t eventToken; /* offset 8 <--- Must on DWORD */
+ int isSync; /* offset 16 */
+ int parmLen; /* offset 20 */
+ char* parmP; /* offset 24 <-- Must on DWORD */
+} gpfs_lwe_event_t;
+
+
+
+/*
+ * Define light weight access rights
+ */
+#define GPFS_LWE_RIGHT_NULL 0
+#define GPFS_LWE_RIGHT_SHARED 1
+#define GPFS_LWE_RIGHT_EXCL 2
+
+
+/* Flag indicating whether to wait
+ * when requesting a right or an event
+ */
+#define GPFS_LWE_FLAG_NONE 0
+#define GPFS_LWE_FLAG_WAIT 1
+
+
+
+
+
+/* NAME: gpfs_lwe_create_session()
+ *
+ * FUNCTION: create a light weight event session
+ *
+ * Input: oldsid: existing session id,
+ * Set to GPFS_LWE_NO_SESSION to start new session
+ * - If a session with the same name and id already exists
+ * it is not terminated, nor will outstanding events
+ * be redelivered. This is typically used if a session
+ * is shared between multiple processes.
+ * Set to an existing session's id to resume that session
+ * - If a session with the same name exists, that session
+ * will be terminated. All pending/outstanding events
+ * for the old session will be redelivered on the new one.
+ * This is typically used to take over a session from a
+ * failed/hung process.
+ * sessinfop: session string, unique for each session
+ *
+ * Output: newsidp: session id for new session
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * EINVAL invalid parameters
+ * ENFILE maximum number of sessions have already been created
+ * ENOMEM insufficient memory to create new session
+ * ENOENT session to resume does not exist
+ * EEXIST session to resume exists with different id
+ * EPERM Caller does not hold appropriate privilege
+ */
+int GPFS_API
+gpfs_lwe_create_session(gpfs_lwe_sessid_t oldsid, /* IN */
+ char *sessinfop, /* IN */
+ gpfs_lwe_sessid_t *newsidp); /* OUT */
+
+#define GPFS_MAX_LWE_SESSION_INFO_LEN 100
+
+
+
+/* NAME: gpfs_lwe_destroy_session()
+ *
+ * FUNCTION: destroy a light weight event session
+ *
+ * Input: sid: id of the session to be destroyed
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * EINVAL sid invalid
+ * EBUSY session is busy
+ * EPERM Caller does not hold appropriate privilege
+ */
+int GPFS_API
+gpfs_lwe_destroy_session(gpfs_lwe_sessid_t sid); /* IN */
+
+
+
+
+/* NAME: gpfs_lwe_getall_sessions()
+ *
+ * FUNCTION: fetch all lwe sessions
+ *
+ * Input: nelem: max number of elements
+ * sidbufp: array of session id
+ * nelemp: number of session returned in sidbufp
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * EINVAL pass in args invalid
+ * E2BIG information is too large
+ * EPERM Caller does not hold appropriate privilege
+ */
+int GPFS_API
+gpfs_lwe_getall_sessions(unsigned int nelem, /* IN */
+ gpfs_lwe_sessid_t *sidbufp, /* OUT */
+ unsigned int *nelemp); /* OUT */
+
+
+/* NAME: gpfs_lw_query_session()
+ *
+ * FUNCTION: query session string by id
+ *
+ * Input: sid: id of session to be queryed
+ * buflen: length of buffer
+ * bufp: buffer to store sessions string
+ * rlenp: returned length of bufp
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * EINVAL pass in args invalid
+ * E2BIG information is too large
+ * EPERM Caller does not hold appropriate privilege
+ */
+int GPFS_API
+gpfs_lwe_query_session(gpfs_lwe_sessid_t sid, /* IN */
+ size_t buflen, /* IN */
+ void *bufp, /* OUT */
+ size_t *rlenP); /* OUT */
+
+
+/* NAME: gpfs_lwe_get_events()
+ *
+ * FUNCTION: get events from a light weight session
+ *
+ * Input: sid: id of the session
+ * maxmsgs: max number of event to fetch,
+ * 0 to fetch all possible
+ * flags: GPFS_LWE_EV_WAIT: waiting for new events if event
+ * queue is empty
+ * buflen: length of the buffer
+ * bufp: buffer to hold events
+ * rlenp: returned length of bufp
+ *
+ * Returns: 0 Success
+ * E2BIG information is too large
+ * EINVAL pass in args invalid
+ */
+int GPFS_API
+gpfs_lwe_get_events(gpfs_lwe_sessid_t sid, /* IN */
+ unsigned int maxmsgs, /* IN */
+ unsigned int flags, /* IN */
+ size_t buflen, /* IN */
+ void *bufp, /* OUT */
+ size_t *rlenp); /* OUT */
+
+/* NAME: gpfs_lwe_respond_event()
+ *
+ * FUNCTION: response to a light weight event
+ *
+ * Input: sid: id of the session
+ * token: token of the event
+ * response: response to the event
+ * reterror: return error to event callers
+ *
+ * Returns: 0 Success
+ * EINVAL pass in args invalid
+ *
+ */
+int GPFS_API
+gpfs_lwe_respond_event(gpfs_lwe_sessid_t sid, /* IN */
+ gpfs_lwe_token_t token, /* IN */
+ gpfs_lwe_resp_t response, /* IN */
+ int reterror); /* IN */
+
+
+/* NAME: gpfs_lwe_request_right
+ *
+ * FUNCTION: Request an access right to a file using a dmapi handle
+ *
+ * Input: sid Id of lw session
+ * hanp Pointer to dmapi handle
+ * hlen Length of dmapi handle
+ * right Shared or exclusive access requested
+ * flags Caller will wait to acquire access if necessary
+ *
+ * Output: token Unique identifier for access right
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * ESTALE GPFS not available
+ * EINVAL Invalid arguments
+ * EFAULT Invalid pointer provided
+ * EBADF Bad file
+ * ENOMEM Uable to allocate memory for request
+ * EPERM Caller does not hold appropriate privilege
+ * EAGAIN flags parameter did not include WAIT
+ * and process would be blocked
+ *
+ */
+int GPFS_API
+gpfs_lwe_request_right(gpfs_lwe_sessid_t sid, /* IN */
+ void *hanp, /* IN */
+ size_t hlen, /* IN */
+ unsigned int right, /* IN */
+ unsigned int flags, /* IN */
+ gpfs_lwe_token_t *token); /* OUT */
+
+
+/* NAME: gpfs_lwe_upgrade_right
+ *
+ * FUNCTION: Upgrade an access right from shared to exclusive
+ *
+ * This is a non-blocking call to upgrade an access right
+ * from shared to exclusive. If the token already conveys
+ * exclusive access this call returns imediately with sucess.
+ * If another process also holds a shared access right
+ * this call fails with EBUSY to avoid deadlocks.
+ *
+ * Input: sid Id of lw session
+ * hanp Pointer to dmapi handle
+ * hlen Length of dmapi handle
+ * token Unique identifier for access right
+ *
+ * Output: None
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * ESTALE GPFS not available
+ * EINVAL Invalid arguments
+ * EINVAL The token is invalid
+ * EFAULT Invalid pointer provided
+ * EPERM Caller does not hold appropriate privilege
+ * EPERM Token's right is not shared or exclusive
+ * EBUSY Process would be blocked
+ *
+ */
+int GPFS_API
+gpfs_lwe_upgrade_right(gpfs_lwe_sessid_t sid, /* IN */
+ void *hanp, /* IN */
+ size_t hlen, /* IN */
+ gpfs_lwe_token_t token); /* IN */
+
+
+/* NAME: gpfs_lwe_downgrade_right
+ *
+ * FUNCTION: Downgrade an access right from exclusive to shared
+ *
+ * This reduces an access right from exclusive to shared
+ * without dropping the exclusive right to acquire the shared.
+ * The token must convey exclusive right before the call.
+ *
+ * Input: sid Id of lw session
+ * hanp Pointer to dmapi handle
+ * hlen Length of dmapi handle
+ * token Unique identifier for access right
+ *
+ * Output: None
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * ESTALE GPFS not available
+ * EINVAL Invalid arguments
+ * EINVAL The token is invalid
+ * EFAULT Invalid pointer provided
+ * EPERM Caller does not hold appropriate privilege
+ * EPERM Token's right is not exclusive
+ *
+ */
+int GPFS_API
+gpfs_lwe_downgrade_right(gpfs_lwe_sessid_t sid, /* IN */
+ void *hanp, /* IN */
+ size_t hlen, /* IN */
+ gpfs_lwe_token_t token); /* IN */
+
+
+/* NAME: gpfs_lwe_release_right
+ *
+ * FUNCTION: Release an access right conveyed by a token
+ *
+ * This releases the access right held by a token
+ * and invalidates the token. Once the access right
+ * is released the token cannot be reused.
+ *
+ * Input: sid Id of lw session
+ * hanp Pointer to dmapi handle
+ * hlen Length of dmapi handle
+ * token Unique identifier for access right
+ *
+ * Output: None
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOSYS Function not available
+ * ESTALE GPFS not available
+ * EINVAL Invalid arguments
+ * EINVAL The token is invalid
+ * EFAULT Invalid pointer provided
+ * EPERM Caller does not hold appropriate privilege
+ */
+int GPFS_API
+gpfs_lwe_release_right(gpfs_lwe_sessid_t sid, /* IN */
+ void *hanp, /* IN */
+ size_t hlen, /* IN */
+ gpfs_lwe_token_t token); /* IN */
+
+
+/* NAME: gpfs_lwe_getattrs()
+ *
+ * FUNCTION: Retrieves all extended file attributes in opaque format.
+ * This function together with gpfs_lwe_putattrs is intended for
+ * use by a backup program to save (gpfs_lwe_getattrs) and
+ * restore (gpfs_lwe_putattrs) all extended file attributes
+ * (ACLs, user attributes, ...) in one call.
+ *
+ * NOTE: This call is the lwe equivalent of gpfs_igetattrsx
+ * but uses a file handle to identify the file
+ * and an existing LWE token for locking it.
+ *
+ *
+ * Input: sid Id of lw session
+ * hanp Pointer to dmapi handle
+ * hlen Length of dmapi handle
+ * token Unique identifier for access right
+ * flags Define behavior of get attributes
+ * GPFS_ATTRFLAG_NO_PLACEMENT - file attributes for placement
+ * are not saved, neither is the current storage pool.
+ * GPFS_ATTRFLAG_IGNORE_POOL - file attributes for placement
+ * are saved, but the current storage pool is not.
+ * GPFS_ATTRFLAG_INCL_DMAPI - file attributes for dmapi are
+ * included in the returned buffer
+ * GPFS_ATTRFLAG_INCL_ENCR - file attributes for encryption
+ * are included in the returned buffer
+ *
+ * buffer: pointer to buffer for returned attributes
+ * bufferSize: size of buffer
+ * attrSize: ptr to returned size of attributes
+ *
+ * Returns: 0 Successful
+ * -1 Failure
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL Not a GPFS file
+ * EINVAL invalid flags provided
+ * ENOSPC buffer too small to return all attributes
+ * *attrSizeP will be set to the size necessary
+ */
+int GPFS_API
+gpfs_lwe_getattrs(gpfs_lwe_sessid_t sid,
+ void *hanp,
+ size_t hlen,
+ gpfs_lwe_token_t token,
+ int flags,
+ void *buffer,
+ int bufferSize,
+ int *attrSize);
+
+
+/* NAME: gpfs_lwe_putattrs()
+ *
+ * FUNCTION: Sets all extended file attributes of a file.
+ *
+ * This routine can optionally invoke the policy engine
+ * to match a RESTORE rule using the file's attributes saved
+ * in the extended attributes to set the file's storage pool and
+ * data replication as when calling gpfs_fputattrswithpathname.
+ * When used with the policy the caller should include the
+ * full path to the file, including the file name, to allow
+ * rule selection based on file name or path.
+ *
+ * By default, the routine will not use RESTORE policy rules
+ * for data placement. The pathName parameter will be ignored
+ * and may be set to NULL.
+ *
+ * If the call does not use RESTORE policy rules, or if the
+ * file fails to match a RESTORE rule, or if there are no
+ * RESTORE rules installed, then the storage pool and data
+ * replication are selected as when calling gpfs_fputattrs().
+ *
+ * The buffer passed in should contain extended attribute data
+ * that was obtained by a previous call to gpfs_fgetattrs.
+ *
+ * pathName is a UTF-8 encoded string. On Windows, applications
+ * can convert UTF-16 ("Unicode") to UTF-8 using the platforms
+ * WideCharToMultiByte function.
+ *
+ * NOTE: This call is the lwe equivalent of gpfs_iputaattrsx
+ * but uses a file handle to identify the file
+ * and an existing LWE token for locking it.
+ *
+ *
+ * Input: sid Id of lw session
+ * hanp Pointer to dmapi handle
+ * hlen Length of dmapi handle
+ * token Unique identifier for access right
+ * flags Define behavior of put attributes
+ * GPFS_ATTRFLAG_NO_PLACEMENT - file attributes are restored
+ * but the storage pool and data replication are unchanged
+ * GPFS_ATTRFLAG_IGNORE_POOL - file attributes are restored
+ * but the storage pool and data replication are selected
+ * by matching the saved attributes to a placement rule
+ * instead of restoring the saved storage pool.
+ * GPFS_ATTRFLAG_USE_POLICY - file attributes are restored
+ * but the storage pool and data replication are selected
+ * by matching the saved attributes to a RESTORE rule
+ * instead of restoring the saved storage pool.
+ * GPFS_ATTRFLAG_FINALIZE_ATTRS - file attributes that are restored
+ * after data is retored. If file is immutable/appendOnly
+ * call without this flag before restoring data
+ * then call with this flag after restoring data
+ * GPFS_ATTRFLAG_INCL_ENCR - file attributes for encryption
+ * are restored. Note that this may result in the file's
+ * File Encryption Key (FEK) being changed, and in this
+ * case any prior content in the file is effectively lost.
+ * This option should only be used when the entire file
+ * content is restored after the attributes are restored.
+ *
+ * buffer: pointer to buffer for returned attributes
+ * pathName: pointer to file path and file name for file
+ * May be set to NULL.
+ *
+ * Returns: 0 Successful
+ * -1 Failure and errno is set
+ *
+ * Errno: ENOSYS function not available
+ * EINVAL the buffer does not contain valid attribute data
+ * EINVAL invalid flags provided
+ * EPERM caller must have superuser privilege
+ * ESTALE cached fs information was invalid
+ * GPFS_E_INVAL_IFILE bad ifile parameters
+ */
+int GPFS_API
+gpfs_lwe_putattrs(gpfs_lwe_sessid_t sid,
+ void *hanp,
+ size_t hlen,
+ gpfs_lwe_token_t token,
+ int flags,
+ void *buffer,
+ const char *pathName);
+
+
+
+const char* GPFS_API
+gpfs_get_fspathname_from_fsname(const char* fsname_or_path);
+/* Check that fsname_or_path refers to a GPFS file system and find the path to its root
+ Return a strdup()ed copy of the path -OR- NULL w/errno
+*/
+
+int GPFS_API
+/* experimental */
+gpfs_qos_getstats(
+ const char *fspathname, /* in only: path to file system*/
+ unsigned int options, /* in only: option flags: 0=begin at specified qip, 1=begin after qip */
+ unsigned int qosid, /* in only: 0 or a specific qosid at which to start or continue */
+ gpfs_pool_t poolid, /* in only: -1 or a specific poolid at which to start or continue */
+ unsigned int mqips, /* in only: max number of qip=(qosid,poolid) histories to retrieve */
+ unsigned int nslots, /* in only: max number of time slots of history to retrieve */
+ void *bufferP, /* ptr to return stat structures */
+ unsigned int bufferSize); /* sizeof stat buffer or 0 */
+
+int GPFS_API
+/* experimental */
+gpfs_qos_control(
+ const char *fspathname, /* in only: path to file system*/
+ void *bufferP, /* in/out control/get/set structs */
+ unsigned int bufferSize);
+
+int GPFS_API
+gpfs_qos_set(
+ const char *fspathname,
+ const char *classname, /* "gold", "silver", or .. "1" or "2" .. */
+ int id, /* process id or pgrp or userid */
+ int which, /* process, pgrp or user */
+ double* qshareP); /* return the share, percentage or when negative IOP limit */
+/* if id==0 then getpid() or getpgrp() or getuid()
+ if which==0 or 1 then process, if 2 process then group, if 3 then userid
+ Return -1 on error, with errno=
+ ENOSYS if QOS is not available in the currently installed GPFS software.
+ ENOENT if classname is not recognized.
+ ENXIO if QOS throttling is not active
+ (but classname is recognized and *qshareP has configured value)
+*/
+
+/* For the given process get QOS info */
+int GPFS_API
+gpfs_qos_get(
+ const char *fspathname,
+ int *classnumP,
+ char classname[18], /* "gold", "silver", or .. "1" or "2" .. */
+ int id, /* process id or pgrp or userid */
+ int which, /* process, pgrp or user */
+ double* qshareP); /* return the share, percentage or when negative IOP limit */
+
+/* given classname, set *classnumP and set *qshareP
+ Return -1 on error, with errno=
+ ENOSYS if QOS is not available in the currently installed GPFS software.
+ ENOENT if classname is not recognized.
+ ENXIO if QOS throttling is not active
+ (but classname is recognized, *classnumP and *qshareP have configured values)
+*/
+int GPFS_API
+gpfs_qos_lkupName(
+ const char *fspathname,
+ int *classnumP,
+ const char *classname,
+ double* qshareP);
+
+/* given classnumber, find name and share (similar to above), but start with number instead of name */
+int GPFS_API
+gpfs_qos_lkupVal(
+ const char *fspathname,
+ int val,
+ char classname[18],
+ double* qshareP);
+
+int GPFS_API
+gpfs_ioprio_set(int,int,int); /* do not call directly */
+
+int GPFS_API
+gpfs_ioprio_get(int,int); /* do not call directly */
+
+
+/* NAME: gpfs_enc_file_rewrap_key()
+ *
+ * FUNCTION: Re-wrap the File Encryption Key (FEK) for the file,
+ * replacing the usage of the original (second parameter)
+ * Master Encryption Key (MEK) with the new key provided as
+ * the third parameter. The content of the file remains intact.
+ *
+ * If the FEK is not currently being wrapped with the MEK
+ * identified by the second parameter then no action is taken.
+ *
+ * This function is normally invoked before the original MEK is
+ * removed.
+ *
+ * The file may be opened in read-only mode for this function
+ * to perform the key rewrap.
+ *
+ * Superuser privilege is required to invoke this API.
+ *
+ * INPUT: fileDesc: File descriptor for file whose key is to be rewrapped
+ * orig_key_p: Key ID for the key (MEK) to be replaced
+ * new_key_p: Key ID for the new key (MEK) to be used
+ *
+ * OUTPUT: N/A
+ *
+ * Returns: 0 success
+ * -1 failure
+ *
+ * Errno:
+ * EACCESS Existing or new key cannot be retrieved
+ * The new key is already being used to wrap the
+ * file's FEK
+ * EBADF Bad file descriptor
+ * EINVAL Arguments are invalid: key format is incorrect
+ * EFAULT An invalid pointer is supplied; the associated
+ * data could not be copied in or out of the kernel
+ * E2BIG Key IDs provided are too long
+ * ENOSYS Function not available (cluster or file system not
+ * enabled for encryption)
+ * EPERM File is in a snapshot
+ * Caller must have superuser privilege
+ */
+
+/* The Key ID is a string comprised of the key ID and the remote key
+ server RKM ID, separated by ':' */
+typedef const char *gpfs_enc_key_id_t; /* "<KEY ID> : <KMS ID>" */
+
+int GPFS_API
+gpfs_enc_file_rewrap_key(gpfs_file_t fileDesc,
+ gpfs_enc_key_id_t orig_key_p,
+ gpfs_enc_key_id_t new_key_p);
+
+
+/* NAME: gpfs_enc_get_algo()
+ *
+ * FUNCTION: Retrieve a string describing the encryption algorithm, key
+ * length, Master Encryption Key(s) ID, and wrapping and combining
+ * mechanisms used for the file.
+ *
+ * INPUT: fileDesc: File descriptor for file whose encryption
+ * algorithm is being retrieved
+ * encryption_xattrP: content of the gpfs.Encryption
+ * extended attribute, retrieved by a call to
+ * gpfs_fcntl (with structure type GPFS_FCNTL_GET_XATTR)
+ * xattr_len: length of the data in encryption_xattrP
+ * algo_txt_size: space reserved by the caller for algo_txtP
+ *
+ * OUTPUT: algo_txtP: NULL-terminated string describing the
+ * encryption for the file
+ *
+ * Returns: 0 success
+ * -1 failure
+ *
+ * Errno:
+ * ENOENT File not found
+ * EBADF Bad file handle, not a GPFS file
+ * EACCESS Permission denied
+ * EFAULT Bad address provided
+ * EINVAL Not a regular file
+ * EINVAL Invalid values for xattr_len or algo_txt_size
+ * EINVAL Invalid content of encryption extended attribute
+ * ENOSYS Function not available
+ * E2BIG Output string does not fit in algo_txtP
+ */
+
+int GPFS_API
+gpfs_enc_get_algo(gpfs_file_t fileDesc,
+ const char *encryption_xattrP,
+ int xattr_len,
+ char *algo_txtP,
+ int algo_txt_size);
+
+
+/* NAME: gpfs_init_trace()
+ *
+ * FUNCTION: Initialize the GPFS trace facility and start to use it.
+ * Must be called before calling gpfs_add_trace().
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOENT file not found
+ * ENOMEM Memory allocation failed
+ * EACCESS Permission denied
+ * ENFILE Too many open files
+ * ENOSYS Function not available
+ */
+int GPFS_API
+gpfs_init_trace(void);
+
+/* NAME: gpfs_query_trace()
+ *
+ * FUNCTION: Query and cache the latest settings of GPFS trace facility.
+ * Generally this should be called by the notification handler
+ * for the "traceConfigChanged" event, which is invoked when
+ * something changes in the configuration of the trace facility.
+ *
+ * Returns: 0 Success
+ * -1 Failure
+ *
+ * Errno: ENOENT file not found
+ * ENOMEM Memory allocation failed
+ * EACCESS Permission denied
+ * ENFILE Too many open files
+ * ENOSYS Function not available
+ */
+int GPFS_API
+gpfs_query_trace(void);
+
+/* NAME: gpfs_add_trace()
+ *
+ * FUNCTION: write the logs into GPFS trace driver. When the user specified
+ * parameter "level" is less than or equal to the GPFS trace level,
+ * the log message pointed to by parameter "msg" would be written to
+ * GPFS trace buffer, and user can use mmtracectl command to cut
+ * the GPFS trace buffer into a file to observe. Must be called after
+ * the call to gpfs_init_trace(). Also ensure the gpfs_query_trace()
+ * is called properly to update the gpfs trace level cached in
+ * application, otherwise, the trace may miss to write down to
+ * GPFS trace driver.
+ *
+ * Input: level: the level for this trace generation. When the level
+ * is less than or equal to the GPFS trace level, this
+ * trace record would be written to GPFS trace buffer.
+ * msg: the message string that would be put into GPFS trace buffer.
+ *
+ * Returns: None.
+ */
+void GPFS_API
+gpfs_add_trace(int level, const char *msg);
+
+/* NAME: gpfs_fini_trace()
+ *
+ * FUNCTION: Stop using GPFS trace facility. This should be paired with
+ * gpfs_init_trace(), and must be called after the last
+ * gpfs_add_trace().
+ *
+ * Returns: None.
+ */
+
+void gpfs_fini_trace(void);
+
+/*
+ * When GPFS_64BIT_INODES is defined, use the 64-bit interface definitions as
+ * the default.
+ */
+
+#ifdef GPFS_64BIT_INODES
+ #undef GPFS_D_VERSION
+ #define GPFS_D_VERSION GPFS_D64_VERSION
+ #undef GPFS_IA_VERSION
+ #define GPFS_IA_VERSION GPFS_IA64_VERSION
+
+ #define gpfs_ino_t gpfs_ino64_t
+ #define gpfs_gen_t gpfs_gen64_t
+ #define gpfs_uid_t gpfs_uid64_t
+ #define gpfs_gid_t gpfs_gid64_t
+ #define gpfs_snapid_t gpfs_snapid64_t
+ #define gpfs_nlink_t gpfs_nlink64_t
+ #define gpfs_timestruc_t gpfs_timestruc64_t
+ #define gpfs_direntx_t gpfs_direntx64_t
+ #define gpfs_direntx gpfs_direntx64
+ #define gpfs_iattr_t gpfs_iattr64_t
+
+ #define gpfs_get_snapid_from_fssnaphandle gpfs_get_snapid_from_fssnaphandle64
+ #define gpfs_open_inodescan gpfs_open_inodescan64
+ #define gpfs_open_inodescan_with_xattrs gpfs_open_inodescan_with_xattrs64
+ #define gpfs_next_inode gpfs_next_inode64
+ #define gpfs_next_inode_with_xattrs gpfs_next_inode_with_xattrs64
+ #define gpfs_seek_inode gpfs_seek_inode64
+ #define gpfs_stat_inode gpfs_stat_inode64
+ #define gpfs_stat_inode_with_xattrs gpfs_stat_inode_with_xattrs64
+ #define gpfs_iopen gpfs_iopen64
+ #define gpfs_ireaddir gpfs_ireaddir64
+ #define gpfs_ireaddirx gpfs_ireaddirx64
+ #define gpfs_iwritedir gpfs_iwritedir64
+ #define gpfs_ireadlink gpfs_ireadlink64
+#endif
+
+#define gpfs_icreate gpfs_icreate64
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* H_GPFS */
--
2.17.0
From 2f38ce98ecd32652dbacc7b8bb59a6cebda3b940 Mon Sep 17 00:00:00 2001
From: Christof Schmitt <cs at samba.org>
Date: Tue, 19 Dec 2017 15:13:50 -0700
Subject: [PATCH 3/3] lib: Use gpfs.h from third_party by default on Linux
Default to use the gpfs.h from third_party on Linux. Do not enable this
by default on other platforms, as the code is only used on Linux (AIX
could be added if there is demand).
The option can still be changed manually to disable the gpfs integration
or point to a different directory.
Signed-off-by: Christof Schmitt <cs at samba.org>
---
lib/util/wscript | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/lib/util/wscript b/lib/util/wscript
index d61b11e9e37..c368a712272 100644
--- a/lib/util/wscript
+++ b/lib/util/wscript
@@ -1,3 +1,5 @@
+import os, sys
+
def options(opt):
''' This is a bit strange, but disable is the flag, not enable. '''
opt.add_option('--disable-fault-handling', action='store_true', dest='disable_fault_handling', help=('disable the fault handlers'), default=False)
@@ -18,6 +20,9 @@ def options(opt):
help=("Disable lttng integration"),
action='store_false', dest='enable_lttng')
+ gpfs_h_dir="/usr/lpp/mmfs/include/"
+ if sys.platform == 'linux':
+ gpfs_h_dir=os.path.abspath("third_party/gpfs")
opt.add_option('--with-gpfs',
help=("Directory under which gpfs headers are installed"),
- action="store", dest='gpfs_headers_dir', default="/usr/lpp/mmfs/include/")
+ action="store", dest='gpfs_headers_dir', default=gpfs_h_dir)
--
2.17.0
More information about the samba-technical
mailing list