From 8dfb2be152f9289179499e32c4b258c2499124e8 Mon Sep 17 00:00:00 2001 From: Caubet Serrabou Marc Date: Tue, 16 Apr 2019 14:45:46 +0200 Subject: [PATCH] Added IOR, and GPFS libraries 5.0.3-2 --- System/ior/build | 11 +- .../files/gpfs/5.0.2-3/include/api_event.h | 944 ++++ .../files/gpfs/5.0.2-3/include/api_nsdRAID.h | 422 ++ .../ior/files/gpfs/5.0.2-3/include/api_poll.h | 2912 ++++++++++++ .../files/gpfs/5.0.2-3/include/api_types.h | 66 + System/ior/files/gpfs/5.0.2-3/include/dmapi.h | 647 +++ .../files/gpfs/5.0.2-3/include/dmapi_types.h | 591 +++ System/ior/files/gpfs/5.0.2-3/include/gpfs.h | 4047 +++++++++++++++++ .../files/gpfs/5.0.2-3/include/gpfs_fcntl.h | 1137 +++++ .../ior/files/gpfs/5.0.2-3/include/gpfs_gpl.h | 4047 +++++++++++++++++ .../ior/files/gpfs/5.0.2-3/include/gpfs_lwe.h | 131 + .../gpfs/5.0.2-3/include/gpfs_lweTypes.h | 60 + .../ior/files/gpfs/5.0.2-3/include/gpfs_nfs.h | 746 +++ .../files/gpfs/5.0.2-3/include/gpfs_watch.h | 397 ++ .../files/gpfs/5.0.2-3/lib/libGpfsProvider.so | Bin 0 -> 480444 bytes System/ior/files/gpfs/5.0.2-3/lib/libdmapi.so | Bin 0 -> 36260 bytes .../ior/files/gpfs/5.0.2-3/lib/libextlum.so | Bin 0 -> 6714 bytes System/ior/files/gpfs/5.0.2-3/lib/libgpfs.so | Bin 0 -> 98014 bytes .../files/gpfs/5.0.2-3/lib/libgpfs_crypto.so | Bin 0 -> 8314 bytes .../files/gpfs/5.0.2-3/lib/libgpfsextlum.so | Bin 0 -> 6714 bytes .../ior/files/gpfs/5.0.2-3/lib/libgpfslum.so | Bin 0 -> 6412 bytes .../files/gpfs/5.0.2-3/lib/libgpfswatch.so | Bin 0 -> 129031 bytes System/ior/files/gpfs/5.0.2-3/lib/liblum.so | Bin 0 -> 6412 bytes .../ior/files/gpfs/5.0.2-3/lib/libmmantras.so | Bin 0 -> 410692 bytes .../ior/files/gpfs/5.0.2-3/lib/libmmsdrcli.so | Bin 0 -> 291945 bytes .../ior/files/gpfs/5.0.2-3/lib/tssbrback.so | Bin 0 -> 37043 bytes .../files/gpfs/5.0.2-3/lib/tssbrrestore.so | Bin 0 -> 245968 bytes 27 files changed, 16152 insertions(+), 6 deletions(-) create mode 100644 System/ior/files/gpfs/5.0.2-3/include/api_event.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/api_nsdRAID.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/api_poll.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/api_types.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/dmapi.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/dmapi_types.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/gpfs.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/gpfs_fcntl.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/gpfs_gpl.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/gpfs_lwe.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/gpfs_lweTypes.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/gpfs_nfs.h create mode 100644 System/ior/files/gpfs/5.0.2-3/include/gpfs_watch.h create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/libGpfsProvider.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/libdmapi.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/libextlum.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/libgpfs.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/libgpfs_crypto.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/libgpfsextlum.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/libgpfslum.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/libgpfswatch.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/liblum.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/libmmantras.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/libmmsdrcli.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/tssbrback.so create mode 100755 System/ior/files/gpfs/5.0.2-3/lib/tssbrrestore.so diff --git a/System/ior/build b/System/ior/build index 8b7ce65..3253a73 100755 --- a/System/ior/build +++ b/System/ior/build @@ -6,14 +6,13 @@ pbuild::add_to_group 'System' pbuild::install_docfiles AUTHORS NEWS README_S3 -cd ${SRC_DIR} +export GPFS_VERSION="5.0.2-3" + +export C_INCLUDE_PATH+=":$BUILDBLOCK_DIR/files/gpfs/$GPFS_VERSION/include/" +export LIBRARY_PATH+=":$BUILDBLOCK_DIR/files/gpfs/$GPFS_VERSION/lib/" -# pbuild::compile_in_sourcetree pbuild::pre_configure() { - pbuild::add_configure_args "LIBS=/tmp/libgpfs.so" + cd ${SRC_DIR} ./bootstrap } -pbuild::configure() { - ./configure LIBS=/tmp/libgpfs.so -} diff --git a/System/ior/files/gpfs/5.0.2-3/include/api_event.h b/System/ior/files/gpfs/5.0.2-3/include/api_event.h new file mode 100644 index 0000000..97f60f5 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/api_event.h @@ -0,0 +1,944 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* */ +/* */ +/* Licensed Materials - Property of IBM */ +/* */ +/* Restricted Materials of IBM */ +/* */ +/* (C) COPYRIGHT International Business Machines Corp. 2007,2018 */ +/* All Rights Reserved */ +/* */ +/* US Government Users Restricted Rights - Use, duplication or */ +/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp. */ +/* */ +/* IBM_PROLOG_END_TAG */ +/* @(#)46 1.20 src/avs/fs/mmfs/ts/mmantras/api_event.h, mmfs, avs_rtac502, rtac5021836a 11/17/16 18:55:10 */ + +#ifndef _h_api_event +#define _h_api_event + + + +#include +#include +#include +#include +#include + +/* Define event types */ +enum +{ + /* Internal events */ + MOUNT = 0, + UNMOUNT = 1, + ADDDISK = 2, + DELDISK = 3, + CHDISK = 4, + SGMGR_TAKEOVER = 5, + NODE_FAILURE = 6, + NODE_RECOVERY = 7, + FILESYSTEM_CREATION = 8, + FILESYSTEM_DELETION = 9, + FILESYSTEM_STATE_CHANGE = 10, + NEW_CONNECTION = 11, + EVENT_COLLECTION_BUFFER_OVERFLOW = 12, + TOKEN_MANAGER_STATUS = 13, + HUNG_THREAD = 14, + STGPOOL_UTILIZATION = 15, + SDR_CHANGED = 16, + /* Command events */ + MMADDDISK = 17, + MMDELDISK = 18, + /* Console log events */ + CONSOLE_LOG = 19, + /* Long ioTime warning */ + LONG_IOTIME = 20, + + /* User generated event */ + USER_EVENT = 21, + + /* NSD RAID related events */ + RECOVERYGROUP_TAKEOVER = 22, /* RG server takeover */ + RECOVERYGROUP_RELINQUISH = 23, /* RG server relinquish */ + RECOVERYGROUP_OPEN_FAILED = 24, /* RG open failed */ + RECOVERYGROUP_PANIC = 25, /* RG panic resign */ + PDISK_FAILED = 26, /* pdisk declared dead */ + PDISK_RECOVERED = 27, /* pdisk recovered */ + PDISK_REPLACE_PDISK = 28, /* pdisk disk replacement */ + PDISK_PATH_FAILED = 29, /* pdisk path failed */ + DA_REBUILD_FAILED = 30, /* DA rebuild failed */ + NSD_CKSUM_MISMATCH = 31, /* checksum error on an NSD RPC */ + LOGGROUP_PANIC = 32, + LOGGROUP_OPEN_FAILED = 33, + + /* last event: MAX_EVENT_CLASSES */ + MAX_EVENT_CLASSES = 34 +}; + +#define MAX_EVENT_FIELD 256 // string lengh + +struct EventNameTableEntry +{ + const char *name; + int len; +}; + + +/* Define event names */ +const struct EventNameTableEntry EventNamesP[MAX_EVENT_CLASSES + 1] = +{ + /* 0 */ { "mount", 5 }, + /* 1 */ { "unmount", 7 }, + /* 2 */ { "adddisk", 7 }, + /* 3 */ { "deldisk", 7 }, + /* 4 */ { "chdisk", 6 }, + /* 5 */ { "takeover", 8 }, + /* 6 */ { "failure", 7 }, + /* 7 */ { "recovery", 8 }, + /* 8 */ { "createfs", 8 }, + /* 9 */ { "deletefs", 8 }, + /* 10 */ { "fsstatechange", 13 }, + /* 11 */ { "newconnection", 13 }, + /* 12 */ { "exception", 9 }, + /* 13 */ { "sgStats", 7 }, + /* 14 */ { "hungthread", 10 }, + /* 15 */ { "poolutil", 8 }, + /* 16 */ { "sdrChanged", 10 }, + /* 17 */ { "mmadddisk", 9 }, + /* 18 */ { "mmdeldisk", 9 }, + /* 19 */ { "consoleLog", 10 }, + /* 20 */ { "longIO", 6 }, + /* 21 */ { "userEvent", 9 }, + /* 22 */ { "rgTakeover", 10 }, + /* 23 */ { "rgRelinquish", 12 }, + /* 24 */ { "rgOpenFailed", 12 }, + /* 25 */ { "rgPanic", 7 }, + /* 26 */ { "pdFailed", 8 }, + /* 27 */ { "pdRecovered", 11 }, + /* 28 */ { "pdReplacePdisk", 14 }, + /* 29 */ { "pdPathFailed", 12 }, + /* 30 */ { "daRebuildFailed",15 }, + /* 31 */ { "nsdCksumMismatch",16 }, + /* 32 */ { "lgPanic", 7 }, + /* 33 */ { "lgOpenFailed", 12 }, + { 0, 0 } +}; + + +#if 0 +/* Data for callback for response from each node. */ +typedef struct MyData +{ + char *responseBuffer; + int responseBufferSize; + char *asyncEvents; + int asyncEventsSize; + Mmpmon_Callback_String callback; + FILE *file; + const char *command; +} MyData; +#endif + + +/* Super class of all events classes. */ +class Event +{ + friend class EventsHandler; + + struct timeval creationTime; + char severity[MAX_EVENT_FIELD]; + +public: + Event(); + ~Event(); + + inline struct timeval getCreationTime() { return creationTime; } + inline char *getSeverity() { return severity; } +}; + + +/* Mount, unmount events */ +class MountActionEvent : public Event +{ +private: + char nodeIpAddr[MAX_EVENT_FIELD]; + char fsName[MAX_EVENT_FIELD]; + +public: + MountActionEvent(char *nodeIpAddr, char *fsName); + ~MountActionEvent(); + + inline char *getNodeIpAddr() { return nodeIpAddr; } + inline char *getFsName() { return fsName; } +}; + + +/* Adddisk, deldisk events */ +class DiskActionEvent : public Event +{ +private: + char nodeIpAddr[MAX_EVENT_FIELD]; + char fsName[MAX_EVENT_FIELD]; + char diskName[MAX_EVENT_FIELD]; + +public: + DiskActionEvent(char *nodeIpAddr, char *fsName, char *diskName); + ~DiskActionEvent(); + + inline char *getNodeIpAddr() { return nodeIpAddr; } + inline char *getFsName() { return fsName; } + inline char *getDiskName() { return diskName; } +}; + + +/* Chdisk event */ +class ChdiskEvent : public Event +{ +private: + char nodeIpAddr[MAX_EVENT_FIELD]; + char fsName[MAX_EVENT_FIELD]; + char diskName[MAX_EVENT_FIELD]; + char status[MAX_EVENT_FIELD]; + char availability[MAX_EVENT_FIELD]; + char fgName[MAX_EVENT_FIELD]; + char meta[MAX_EVENT_FIELD]; + char data[MAX_EVENT_FIELD]; + +public: + ChdiskEvent(char *nodeIpAddr, char *fsName, char *diskName, + char *status, char *availability, char *fgName, + char *meta, char *data); + ~ChdiskEvent(); + + inline char *getNodeIpAddr() { return nodeIpAddr; } + inline char *getFsName() { return fsName; } + inline char *getDiskName() { return diskName; } + inline char *getStatus() { return status; } + inline char *getAvailability() { return availability; } + inline char *getFgName() { return fgName; } + inline char *getMeta() { return meta; } + inline char *getData() { return data; } +}; + + +/* Stripe group manager takeover event */ +class SgmgrTakeoverEvent : public Event +{ +private: + char sgmgrIpAddr[MAX_EVENT_FIELD]; + char prevSgmgrIpAddr[MAX_EVENT_FIELD]; + char fsName[MAX_EVENT_FIELD]; + +public: + SgmgrTakeoverEvent(char *sgmgrIpAddr, char *prevSgmgrIpAddr, char *fsName); + ~SgmgrTakeoverEvent(); + + inline char *getSgmgrIpAddr() { return sgmgrIpAddr; } + inline char *getPrevSgmgrIpAddr() { return prevSgmgrIpAddr; } + inline char *getFsName() { return fsName; } +}; + + +/* Node failure, recovery events */ +class NodeStatusEvent : public Event +{ +private: + char nodeIpAddr[MAX_EVENT_FIELD]; + +public: + NodeStatusEvent(char *nodeIpAddr); + ~NodeStatusEvent(); + + inline char *getNodeIpAddr() { return nodeIpAddr; } +}; + + +/* File system creation, deletion events */ +class FilesystemActionEvent : public Event +{ +private: + char sgmgrIpAddr[MAX_EVENT_FIELD]; + char fsName[MAX_EVENT_FIELD]; + +public: + FilesystemActionEvent(char *sgmgrIpAddr, char *fsName); + ~FilesystemActionEvent(); + + inline char *getSgmgrIpAddr() { return sgmgrIpAddr; } + inline char *getFsName() { return fsName; } +}; + + +/* File system state change event */ +class FilesystemStateChangeEvent : public Event +{ +private: + char fsName[MAX_EVENT_FIELD]; + char userUnbalanced[MAX_EVENT_FIELD]; + char metaUnbalanced[MAX_EVENT_FIELD]; + char userIllreplicated[MAX_EVENT_FIELD]; + char metaIllreplicated[MAX_EVENT_FIELD]; + char userExposed[MAX_EVENT_FIELD]; + char metaExposed[MAX_EVENT_FIELD]; + +public: + FilesystemStateChangeEvent(char *fsName, char *userUnbalanced, + char *metaUnbalanced, char *userIllreplicated, + char *metaIllreplicated, char *userExposed, + char *metaExposed); + ~FilesystemStateChangeEvent(); + + inline char *getFsName() { return fsName; } + inline char *getUserUnbalanced() { return userUnbalanced; } + inline char *getMetaUnbalanced() { return metaUnbalanced; } + inline char *getUserIllreplicated() { return userIllreplicated; } + inline char *getMetaIllreplicated() { return metaIllreplicated; } + inline char *getUserExposed() { return userExposed; } + inline char *getMetaExposed() { return metaExposed; } +}; + + +/* Hung thread event */ +class HungThreadEvent : public Event +{ +private: + char nodeIpAddr[MAX_EVENT_FIELD]; + time_t waitTime; + char diagnosis[MAX_EVENT_FIELD]; + +public: + HungThreadEvent(char *nodeAddr, time_t time, char *desc); + ~HungThreadEvent(); + + inline char *getNodeIpAddr() { return nodeIpAddr; } + inline time_t getWaitTime() { return waitTime; } + inline char *getDiagnosis() { return diagnosis; } +}; + + +/* tm stats event */ +class TmStatsEvent: public Event +{ +private: + char nodeIpAddr[MAX_EVENT_FIELD]; + char fsName[MAX_EVENT_FIELD]; + int tmSpace; + int tmRequest; + +public: + TmStatsEvent(char *nodeAddr, char *fsName, int tmSpace, int tmRequest); + ~TmStatsEvent(); + + inline char *getNodeIpAddr() { return nodeIpAddr; } + inline char *getFsName() { return fsName; } + inline int getTmSpace() { return tmSpace; } + inline int getTmRequest() { return tmRequest; } +}; + +#if 0 +/* File system utilization event */ +class FilesystemUtilizationEvent : public Event +{ +private: + char fsName[MAX_EVENT_FIELD]; + int fsUsage; + +public: + FilesystemUtilizationEvent(char *name, int usage); + ~FilesystemUtilizationEvent(); + + inline char *getFsName() { return fsName; } + inline int getFsUsage() { return fsUsage; } +}; +#endif + + +/* Storage pool utilization event */ +class StgPoolUtilizationEvent : public Event +{ +private: + char fsName[MAX_EVENT_FIELD]; + char poolName[MAX_EVENT_FIELD]; + char status[MAX_EVENT_FIELD]; + int poolUsage; + +public: + StgPoolUtilizationEvent(char *fsname, char *poolname, char *status, + int usage); + ~StgPoolUtilizationEvent(); + + inline char *getFsName() { return fsName; } + inline char *getPoolName() { return poolName; } + inline char *getStatus() { return status; } + inline int getPoolUsage() { return poolUsage; } +}; + +class SDRChangedEvent : public Event +{ + private: + char nodeName[MAX_EVENT_FIELD]; + +public: + SDRChangedEvent(char *nodeName); + ~SDRChangedEvent(); + + inline char *getNodeName() { return nodeName; } +}; + +class UserGeneratedEvent : public Event +{ + private: + char nodeName[MAX_EVENT_FIELD]; + char data[MAX_EVENT_FIELD]; + +public: + UserGeneratedEvent(char *nodeName, char *data); + ~UserGeneratedEvent(); + + inline char *getNodeName() { return nodeName; } + inline char *getData() { return data; } +}; + +/* Adddisk, deldisk command events */ +class DiskCmdEvent : public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char fsName[MAX_EVENT_FIELD]; + char diskName[MAX_EVENT_FIELD]; + char cmd[MAX_EVENT_FIELD]; + char status[MAX_EVENT_FIELD]; + int result; + +public: + DiskCmdEvent(char *nodeName, char *fsName, char *diskName, char *cmd, + char *status, int result); + ~DiskCmdEvent(); + + inline char *getNodeName() { return nodeName; } + inline char *getFsName() { return fsName; } + inline char *getDiskName() { return diskName; } + inline char *getCmd() { return cmd; } + inline char *getStatus() { return status; } + inline int getResult() { return result; } +}; + + +/* Console message events */ +class ConsoleLogEvent : public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char msgTxt[MAX_EVENT_FIELD]; + int msgLevel; + +public: + ConsoleLogEvent(char *nodeName, char *msgTxt, int msgLevel); + ~ConsoleLogEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getMsgTxt() { return msgTxt; } + inline int getMsgLevel() { return msgLevel; } +}; + + +/* Long ioTime warning events */ +class LongIoTimeEvent : public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char fsName[MAX_EVENT_FIELD]; + char diskName[MAX_EVENT_FIELD]; + char cmd[MAX_EVENT_FIELD]; + int ioLength; + time_t ioTime; /* in microseconds */ + + +public: + LongIoTimeEvent(char *nodeName, char *fsName, char *diskName, char *cmd, + int ioLength, time_t ioTime_us); + ~LongIoTimeEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getFsName() { return fsName; } + inline char *getDiskName() { return diskName; } + inline char *getCmd() { return cmd; } + inline int getIoLength() { return ioLength; } + inline time_t getIoTime() { return ioTime; } + +}; + +/* NSD RAID related events */ + +/* Recovery Group Takeveover: + RG server has begun serving an RG +*/ +class RgTakeoverEvent : public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char rgName[MAX_EVENT_FIELD]; + char reason[MAX_EVENT_FIELD]; + int err; + +public: + RgTakeoverEvent(char *nodeName, char *rgName, char *reason, int err); + ~RgTakeoverEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getRgName() { return rgName; } + inline char *getReason() { return reason; } + inline int getErr() { return err; } + +}; + +/* Recovery Group Relinquish + RG server has stopped serving an RG + */ +class RgRelinquishEvent: public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char rgName[MAX_EVENT_FIELD]; + char reason[MAX_EVENT_FIELD]; + int err; + +public: + RgRelinquishEvent(char *nodeName, char *rgName, char *reason, int err); + ~RgRelinquishEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getRgName() { return rgName; } + inline char *getReason() { return reason; } + inline int getErr() { return err; } +}; + +/* Recovery Group OpenFailed + rgOpenFailed event will always be followed by rgTakeover with an error + code (and the same reason string.) + */ +class RgOpenFailedEvent: public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char rgName[MAX_EVENT_FIELD]; + char reason[MAX_EVENT_FIELD]; + int err; + +public: + RgOpenFailedEvent(char *nodeName, char *rgName, char *reason, int err); + ~RgOpenFailedEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getRgName() { return rgName; } + inline char *getReason() { return reason; } + inline int getErr() { return err; } +}; + +/* Recovery Group Panic + rgPanic + */ +class RgPanicEvent: public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char rgName[MAX_EVENT_FIELD]; + char reason[MAX_EVENT_FIELD]; + int err; + +public: + RgPanicEvent(char *nodeName, char *rgName, char *reason, int err); + ~RgPanicEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getRgName() { return rgName; } + inline char *getReason() { return reason; } + inline int getErr() { return err; } +}; + +/* Log Group OpenFailed (lgOpenFailed) */ +class LgOpenFailedEvent: public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char rgName[MAX_EVENT_FIELD]; + char lgName[MAX_EVENT_FIELD]; + char reason[MAX_EVENT_FIELD]; + int err; + +public: + LgOpenFailedEvent(char *nodeName, char *rgName, char lgName, + char *reason, int err); + ~LgOpenFailedEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getRgName() { return rgName; } + inline char *getLgName() { return lgName; } + inline char *getReason() { return reason; } + inline int getErr() { return err; } +}; + +/* Log Group Panic (lgPanic) */ +class LgPanicEvent: public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char rgName[MAX_EVENT_FIELD]; + char lgName[MAX_EVENT_FIELD]; + char reason[MAX_EVENT_FIELD]; + int err; + +public: + LgPanicEvent(char *nodeName, char *rgName, char *lgName, + char *reason, int err); + ~LgPanicEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getRgName() { return rgName; } + inline char *getLgName() { return lgName; } + inline char *getReason() { return reason; } + inline int getErr() { return err; } +}; + +/* disk array requires disk replacement */ +class PdReplacePdiskEvent : public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char location[MAX_EVENT_FIELD]; + char fru[MAX_EVENT_FIELD]; + char wwn[MAX_EVENT_FIELD]; /* SCSI World Wide Name */ + char rgName[MAX_EVENT_FIELD]; + char daName[MAX_EVENT_FIELD]; + char pdName[MAX_EVENT_FIELD]; + char state[MAX_EVENT_FIELD]; + int priority; + +public: + PdReplacePdiskEvent(char *nodeName, char *location, char *fru, + char *wwn, char *rgName, char *daName, + char *pdName, char *state, int priority); + ~PdReplacePdiskEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getLocation() { return location; } + inline char *getFru() { return fru; } + inline char *getWwn() { return wwn; } + inline char *getRgName() { return rgName; } + inline char *getDaName() { return daName; } + inline char *getPdName() { return pdName; } + inline char *getState() { return state; } + inline int getPriority() { return priority; } +}; + +/* + * a pDisk has failed + */ +class PdFailedEvent : public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char location[MAX_EVENT_FIELD]; + char fru[MAX_EVENT_FIELD]; + char wwn[MAX_EVENT_FIELD]; /* SCSI World Wide Name */ + char rgName[MAX_EVENT_FIELD]; + char daName[MAX_EVENT_FIELD]; + char pdName[MAX_EVENT_FIELD]; + char state[MAX_EVENT_FIELD]; + +public: + PdFailedEvent(char *nodeName, char *location, char *fru, char *wwn, + char *rgName, char *daName, char *pdName, char *state); + ~PdFailedEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getLocation() { return location; } + inline char *getFru() { return fru; } + inline char *getWwn() { return wwn; } + inline char *getRgName() { return rgName; } + inline char *getDaName() { return daName; } + inline char *getPdName() { return pdName; } + inline char *getState() { return state; } +}; + +/* + * a pDisk has recovered + */ +class PdRecoveredEvent : public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char location[MAX_EVENT_FIELD]; + char fru[MAX_EVENT_FIELD]; + char wwn[MAX_EVENT_FIELD]; /* SCSI World Wide Name */ + char rgName[MAX_EVENT_FIELD]; + char daName[MAX_EVENT_FIELD]; + char pdName[MAX_EVENT_FIELD]; + +public: + PdRecoveredEvent(char *nodeName, char *location, char *fru, char *wwn, + char *rgName, char *daName, char *pdName); + ~PdRecoveredEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getLocation() { return location; } + inline char *getFru() { return fru; } + inline char *getWwn() { return wwn; } + inline char *getRgName() { return rgName; } + inline char *getDaName() { return daName; } + inline char *getPdName() { return pdName; } +}; + +/* + * pdPathFailed + */ +class PdPathFailedEvent : public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char location[MAX_EVENT_FIELD]; + char fru[MAX_EVENT_FIELD]; + char wwn[MAX_EVENT_FIELD]; /* SCSI World Wide Name */ + char rgName[MAX_EVENT_FIELD]; + char daName[MAX_EVENT_FIELD]; + char pdName[MAX_EVENT_FIELD]; + char deviceName[MAX_EVENT_FIELD]; + +public: + PdPathFailedEvent(char *nodeName, char *location, char *fru, char *wwn, + char *rgName, char *daName, char *pdName, + char *deviceName); + ~PdPathFailedEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getLocation() { return location; } + inline char *getFru() { return fru; } + inline char *getWwn() { return wwn; } + inline char *getRgName() { return rgName; } + inline char *getDaName() { return daName; } + inline char *getPdName() { return pdName; } + inline char *getDeviceName(){ return deviceName; } +}; + + +/* + * daRebuildFailed: Decluster Array rebuild failed + */ +class DaRebuildFailedEvent : public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; + char rgName[MAX_EVENT_FIELD]; + char daName[MAX_EVENT_FIELD]; + int remainingRedundancy; + +public: + DaRebuildFailedEvent(char *nodeName, char *rgName, char *daName, + int remainingRedundancy); + ~DaRebuildFailedEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getRgName() { return rgName; } + inline char *getDaName() { return daName; } + inline int getRemainingRedundancy() { return remainingRedundancy; } +}; + +/* + * nsdCksumMismatch: checksum error detected on an NSD RPC transaction + */ + +class NsdCksumMismatchEvent : public Event +{ +private: + char nodeName[MAX_EVENT_FIELD]; /* reporting node */ + char myRole[MAX_EVENT_FIELD]; /* reporting side of the event: + "client" or "server" */ + char ckOtherNode[MAX_EVENT_FIELD]; /* address of the other side involved */ + char ckNSD[MAX_EVENT_FIELD]; /* NSD name of the NSD/Vdisk in question */ + char ckReason[MAX_EVENT_FIELD]; /* reason for checksum error: + "server_detected_error_receiving_for_write" or + "client_detected_error_receiving_on_read" */ + Int64 ckStartSector; /* starting sector of the failing transmission */ + Int32 ckDataLen; /* data length of the failing transmission */ + UInt32 ckErrorCountClient; /* cumulative number of errors for the involved + client since server has begun serving */ + UInt32 ckErrorCountServer; /* cumulative number of errors for the server */ + UInt32 ckErrorCountNSD; /* cumulative number of errors for the involved + NSD since server has begun serving */ + Int32 ckReportingInterval; /* value of the reporting interval at the + time the event was generated */ +public: + NsdCksumMismatchEvent(char *nodeName, char *myRole, char *ckOtherNode, + char *ckNSD, char *ckReason, + Int64 ckStartSector, Int32 ckDataLen, + UInt32 ckErrorCountClient, UInt32 ckErrorCountServer, + UInt32 ckErrorCountNSD, Int32 ckReportingInterval); + ~NsdCksumMismatchEvent() {}; + + inline char *getNodeName() { return nodeName; } + inline char *getMyRole() { return myRole; } + inline char *getCkReason() { return ckReason; } + inline char *getCkNSD() { return ckNSD; } + inline char *getCkOtherNode() { return ckOtherNode; } + inline UInt64 getCkStartSector() { return ckStartSector; } + inline Int32 getCkDataLen() { return ckDataLen; } + inline UInt32 getCkErrorCountClient() { return ckErrorCountClient; } + inline UInt32 getCkErrorCountServer() { return ckErrorCountServer; } + inline UInt32 getCkErrorCountNSD() { return ckErrorCountNSD; } + inline Int32 getCkReportingInterval(){ return ckReportingInterval; } +}; + +/* + * Derived event classes + */ +#define MountEvent MountActionEvent +#define UnmountEvent MountActionEvent +#define AdddiskEvent DiskActionEvent +#define DeldiskEvent DiskActionEvent +#define NodeFailureEvent NodeStatusEvent +#define NodeRecoveryEvent NodeStatusEvent +#define FilesystemCreationEvent FilesystemActionEvent +#define FilesystemDeletionEvent FilesystemActionEvent +#define NewConnectionEvent NodeStatusEvent +#define EventCollectionBufferOverflowEvent NodeStatusEvent +#define MmAdddiskEvent DiskCmdEvent +#define MmDeldiskEvent DiskCmdEvent + + +/* Description of linked list struct for holding an event */ +class EventItem +{ +private: + + /* Ptr to null-terminated string associated with this object */ + char *bufP; + /* Ptr to prev item -or- NULL if front of list */ + EventItem *prevP; + /* Ptr to next item -or- NULL if end of list */ + EventItem *nextP; + +public: + + /* Constructor */ + EventItem(); + + /* Destructor */ + ~EventItem(); + + /* Access member functions */ + void copyBuf(char* _bufP); + inline char* getBufP() const { return bufP; } + inline EventItem* getNextP() const { return nextP; } + + /* Given a string as input, duplicate the string and + create an associated linked list descriptor. */ + static EventItem* strdup(const char *strP); + + /* Append item(s) after this item + which must be current end-of-list. */ + void append(EventItem* _nextP); + + /* Destroy list */ + static void destroyList(EventItem* listP); +}; + + +typedef struct +{ + int (*fn)(Event *event, void *data); + void *data; +} CallbackInfo; + +#ifndef dfprintf +#define dfprintf if (debug) fprintf +#endif + +/* It manages two threads: + 1. receiveHandler: It connects to GPFS daemon and listens to events + genereated in GPFS. When an event occurs, it stores this event to list. + 2. sendHandler: It extracts an event one by one and invokes callback + function registered with each event type. */ +class EventsHandler +{ +private: + + pthread_t sendThread; + pthread_t receiveThread; + + EventItem listAnchor; // nextP points to first in list; prevP always NULL + EventItem* lastInListP; // ptr to last EventItem in list + + CallbackInfo eventCallback[MAX_EVENT_CLASSES]; + MmpmonWrapperUtils *wrapper; + + int debug; + PollingHandler *pollingHandler; // notify polling handler of certain events + + int terminate; + + /* It sleeps until somebody wakes it up. If it is woken up, it checks if there + are events in list. If there are, it extracts an event one by one, + find out event type and invokes callback function of each event. */ + static void *sendHandlerBody(void *arg); + + /* It connects to GPFS daemon and listens to events generated in GPFS. If an + event occurs, it stores this event to list and wakes up sendHandler thread. */ + static void *receiveHandlerBody(void *arg); + + /* Extract an event from list */ + char *getEventFromList(char* bufP, const int bufSize); + + /* Wake up sendHandler thread */ + void wakeSendThread(); + + /* Wait receiveHandler thread */ + void waitReceiveThread(); + + /* Get event type */ + int getEventType(char* response); + + /* Create event object of corresponding type */ + Event *createEventObject(int type, char *response); + +public: + + static MErrno init(PollingHandler *pollH, int debg=0); + + static void term(); + + EventsHandler(MErrno *errP, int debg=0); + + ~EventsHandler(); + + /* Append an event to list */ + void appendEventToList(EventItem* firstItemP, // first item in list to append + EventItem* lastItemP, // last item in list to append + int numItems, // number items being appended + int numBytes); // total bytes being appended + + /* Create threads and wait until they finish */ + void run(); + + /* refresh event registration */ + void refreshEvents(); + + /* External management application registers its callback function by invoking + this function. */ + void registerEventCallback(int type, int (*callback)(Event *event, void *data), void *callbackData); + + MmpmonWrapperUtils *getMmpmonWrapper() { return wrapper; } +}; + + +/* Pointer to EventsHandler object */ +extern EventsHandler *theEventsHandler; + + +/* Callback function which is invoked when we get events. It creates EventItem + object and make it be added to list. */ +static int receiveEvent(char *buf, void *data); + + +#endif /* _h_api_event */ diff --git a/System/ior/files/gpfs/5.0.2-3/include/api_nsdRAID.h b/System/ior/files/gpfs/5.0.2-3/include/api_nsdRAID.h new file mode 100644 index 0000000..ef63939 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/api_nsdRAID.h @@ -0,0 +1,422 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* */ +/* */ +/* Licensed Materials - Property of IBM */ +/* */ +/* Restricted Materials of IBM */ +/* */ +/* (C) COPYRIGHT International Business Machines Corp. 2011,2018 */ +/* All Rights Reserved */ +/* */ +/* US Government Users Restricted Rights - Use, duplication or */ +/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp. */ +/* */ +/* IBM_PROLOG_END_TAG */ +/* @(#)81 1.8 src/avs/fs/mmfs/ts/mmantras/api_nsdRAID.h, mmfs, avs_rtac502, rtac5021836a 5/27/15 08:13:15 */ + +#ifndef _h_api_nsdRAID +#define _h_api_nsdRAID + +/* + * api_nsdRAID.h + * + * classes: + * gpfsRecoveryGroupSdrInfo + * gpfsRecoveryGroup + * gpfsRecoveryGroupDeclusteredArray + * gpfsDeclusteredArrayVdisk + * gpfsDeclusteredArrayPdisk + * gpfsNsdRAIDConfigParms + * gpfsDeclusteredArrayVdiskIoStats + * + * gpfsRecoveryGroupSdrInfo - portion of NSD RAID recovery group + * information stored in GPFS SDR file. + * + * gpfsRecoveryGroup - GPFS recovery group (RG) information + * -- gpfsRecoveryGroupDeclusteredArray - GPFS declustered array (DA) + * information in a Recovery Group + * --- gpfsDeclusteredArrayVdisk - virtual disk (vdisk) information + * in recovery group RG declustered array DA + * --- gpfsDeclusteredArrayPdisk - physical disk (pdisk) information + * in recovery group RG declustered array DA + * + * gpfsNsdRAIDConfigParms - an array of NSD RAID configuration parameters + * -- gpfsNsdRAIDConfigVar - an NSD RAID configuration parameter + * + * gpfsDeclusteredArrayVdiskIoStats + * + * Externals: + * int getNsdRAIDSdrInfo(gpfsRecoveryGroupSdrInfo *rgSdrTableP, + * int *nRgSdrAllocP); + * int getRecoveryGroupSummary(gpfsRecoveryGroup *rgP); + * int getRecoveryGroupDeclusteredArrays(gpfsRecoveryGroup *rgP); + * int getNsdRAIDParameters(gpfsNsdRAIDConfigParms *configTableP, + * int *nAllocP); + * int gpfsRGDefined(); + */ + +#define GNRB_MAX_BASENAME 63 +#define RAID_NAME_LEN (GNRB_MAX_BASENAME + 1) +#define MAX_DA 16 /* RG_MAX_DECLUSTERED_ARRAYS */ + +#define STR8_LEN 8 +#define STR32_LEN 32 +#define STR64_LEN 64 +#define STR128_LEN 128 +#define PDISK_STATE_LEN 160 +#define STATE_STR_LEN STR64_LEN +#define SERVER_LIST_LEN STR128_LEN +#define PATH_LEN STR64_LEN + +#define PVID_MAX_CHARS 20 /* defined in GPFS */ + +/* number of Recovery Group defined in the cluster */ +extern int nRGDefined; /* -1 uninitialized, 0 no RG defined */ + + +/* + * gpfsDeclusteredArrayPdisk - description of a pdisk + */ + +class gpfsDeclusteredArrayPdisk +{ + char gpfsPdiskName[RAID_NAME_LEN]; /* Pdisk Name */ + UInt32 gpfsPdiskReplacementPriority; /* replacementPriority + (daCalcReplacementPriorityLocked) */ + char gpfsPdiskDevicePath[PATH_LEN]; /* path */ + char gpfsPdiskState[PDISK_STATE_LEN];/* State, possible values see: + PdiskState_t::toString() */ + UInt64 gpfsPdiskFreeSpace; /* free space bytes */ + char gpfsPdiskFru[STR32_LEN]; /* Field Replaceable Unit number */ + char gpfsPdiskLocation[STR32_LEN]; /* where the disk is physically located + in the carrier */ + public: + gpfsDeclusteredArrayPdisk(); + ~gpfsDeclusteredArrayPdisk(); + + void init(); + void update(char *pDiskName, int prior, char *path, + char *state, UInt64 freeSpace, char *fru, char *location); + + void print_gpfsDeclusteredArrayPdisk(int verbose = 0); + + char *getPdiskName() { return gpfsPdiskName; } + UInt32 getPdiskReplacementPriority() + { return gpfsPdiskReplacementPriority; } + char *getPdiskDevicePath() { return gpfsPdiskDevicePath; } + char *getPdiskState(){ return gpfsPdiskState; } + UInt64 getPdiskFreeSpace() { return gpfsPdiskFreeSpace; } + char *getPdiskFru() { return gpfsPdiskFru; } + char *getPdiskLocation() { return gpfsPdiskLocation; } +}; + + +/* + * gpfsDeclusteredArrayVdiskIoStats - vdisk IO stats + */ + +class gpfsDeclusteredArrayVdiskIoStats +{ + friend class gpfsDeclusteredArrayVdisk; + + UInt64 gpfsVdiskIoStatRead; + UInt64 gpfsVdiskIoStatShortWrite; + UInt64 gpfsVdiskIoStatMediumWrite; + UInt64 gpfsVdiskIoStatFTW; + UInt64 gpfsVdiskIoStatPromotedFTW; + UInt64 gpfsVdiskIoStatFlushedUpdateWrite; + UInt64 gpfsVdiskIoStatFlushedPromotedFTW; + UInt64 gpfsVdiskIoStatMigrate; + UInt64 gpfsVdiskIoStatScrub; + UInt64 gpfsVdiskIoStatLogWrite; + + public: + gpfsDeclusteredArrayVdiskIoStats(); + ~gpfsDeclusteredArrayVdiskIoStats(); + + void init(); + + UInt64 getVdiskIoStatRead() { return gpfsVdiskIoStatRead; } + UInt64 getVdiskIoStatShortWrite() + { return gpfsVdiskIoStatShortWrite; } + UInt64 getVdiskIoStatMediumWrite() + { return gpfsVdiskIoStatMediumWrite; } + UInt64 getVdiskIoStatFTW() { return gpfsVdiskIoStatFTW; } + UInt64 getVdiskIoStatPromotedFTW() + { return gpfsVdiskIoStatPromotedFTW; } + UInt64 getVdiskIoStatFlushedUpdateWrite() + { return gpfsVdiskIoStatFlushedUpdateWrite; } + UInt64 getVdiskIoStatFlushedPromotedFTW() + { return gpfsVdiskIoStatFlushedPromotedFTW; } + UInt64 getVdiskIoStatMigrate() { return gpfsVdiskIoStatMigrate; } + UInt64 getVdiskIoStatScrub() { return gpfsVdiskIoStatScrub; } + UInt64 getVdiskIoStatLogWrite() { return gpfsVdiskIoStatLogWrite; } +}; + + +/* + * gpfsDeclusteredArrayVdisk - description of a vdisk + */ + +class gpfsDeclusteredArrayVdisk +{ + friend class gpfsDeclusteredArrayVdiskIoStats; + + char gpfsVdiskName[RAID_NAME_LEN]; /* Vdisk name */ + char gpfsVdiskRaidCode[STR32_LEN]; /* RaidCode, see ErasureCodeNames[] + "8WayStriping", + "2WayReplication", + "3WayReplication", + "4WayReplication", + "8+2p", + "8+3p" */ + UInt32 gpfsVdiskBlockSizeInKiB; /* BlockSizeInKiB */ + UInt64 gpfsVdiskSize; /* VdiskSize in bytes */ + char gpfsVdiskState[STATE_STR_LEN];/* State, possible values: + "ok", "critical", "offline", + "%d/%d-degraded" + (faultLevel, faultTolerance)*/ + char gpfsVdiskRemarks[STR32_LEN]; /* Vidsk remarks, possible values: + "log", "" */ + + gpfsDeclusteredArrayVdiskIoStats gpfsVdiskIoStats; + + public: + gpfsDeclusteredArrayVdisk(); + ~gpfsDeclusteredArrayVdisk(); + + void init(); + void update(char *vDiskName, char *vDiskRaidCode, int vDiskBlockSizeInKiB, + UInt64 vDiskSize, char *vDiskState, char *vDiskRemarks); + + void print_gpfsDeclusteredArrayVdisk(int verbose = 0); + + char *getVdiskName() { return gpfsVdiskName; } + char *getVdiskRaidCode() { return gpfsVdiskRaidCode; } + UInt32 getVdiskBlockSizeInKiB() { return gpfsVdiskBlockSizeInKiB; } + UInt64 getVdiskSize() { return gpfsVdiskSize; } + char *getVdiskState() { return gpfsVdiskState; } + char *getVdiskRemarks() { return gpfsVdiskRemarks; } + gpfsDeclusteredArrayVdiskIoStats *getVdiskIoStatsP() + { return &gpfsVdiskIoStats; } +}; + + +/* + * gpfsRecoveryGroupDeclusteredArray - description of a Declustered Array + */ + +class gpfsRecoveryGroupDeclusteredArray +{ + friend class gpfsDeclusteredArrayPdisk; + friend class gpfsDeclusteredArrayVdisk; + + char gpfsDeclusteredArrayName[RAID_NAME_LEN]; /* declustered array name */ + char gpfsDeclusteredArrayNeedsService[STR8_LEN]; /* needs services */ + UInt32 gpfsDeclusteredArrayVdisks; /* number of vDisks */ + UInt32 gpfsDeclusteredArrayPdisks; /* number of pDisks */ + UInt32 gpfsDeclusteredArraySpares; /* Spares */ + UInt32 gpfsDeclusteredArrayReplaceThreshold; /* replace threshold */ + UInt64 gpfsDeclusteredArrayFreeSpace; + UInt32 gpfsDeclusteredArrayScrubDuration; /* scrub duration in days*/ + char gpfsDeclusteredArrayBackgroundTask[STR32_LEN]; /* background task + see: IM_ServiceLevel_tToString() + "inactive" + "rebuild-critical" + "rebuild-1r" + "rebuild-2r" + "rebuild-3r" + "rebuild-offline" + "rebalance" + "scrub1" + "scrub2" + "in-transition" + "metadata" + "error" + "Unknown IM_ServiceLevel_t" */ + UInt32 gpfsDeclusteredArrayTaskPercentComplete; /* task percent complete */ + char gpfsDeclusteredArrayTaskPrioriy[STR32_LEN];/* task prioriy + "high", "low" */ + + gpfsDeclusteredArrayPdisk *daPdiskArrayP;/* pointer to + gpfsDeclusteredArrayPdisk Table */ + + gpfsDeclusteredArrayVdisk *daVdiskArrayP;/* pointer to + gpfsDeclusteredArrayVdisk Table */ + + public: + + gpfsRecoveryGroupDeclusteredArray(); + ~gpfsRecoveryGroupDeclusteredArray(); + + void init(); + void update(char *daName, char *daNeedsService, + int nDaVdisks, int nDaPdisks, int nDaSpares, + int replaceThr, UInt64 freeSpace, int scrubDuration, + char *bgTaskType, int bgTaskPct, char *priority); + + void allocDiskArrays(int nPdisks, int nVdisks); + void deallocDiskArrays(); + + void print_gpfsDeclusterArray(int verbose = 0); + + gpfsDeclusteredArrayPdisk *getDeclusteredArrayPdiskP(int index); + gpfsDeclusteredArrayVdisk *getDeclusteredArrayVdiskP(int index); + + char *getDeclusteredArrayName() + { return gpfsDeclusteredArrayName; } + char *getDeclusteredNeedsService() + { return gpfsDeclusteredArrayNeedsService; } + UInt32 getDeclusteredArrayVdisks () + { return gpfsDeclusteredArrayVdisks; } + UInt32 getDeclusteredArrayPdisks() + { return gpfsDeclusteredArrayPdisks; } + UInt32 getDeclusteredArraySpares() + { return gpfsDeclusteredArraySpares; } + UInt32 getDeclusteredArrayReplaceThreshold() + { return gpfsDeclusteredArrayReplaceThreshold; } + UInt64 getDeclusteredArrayFreeSpace() + { return gpfsDeclusteredArrayFreeSpace; } + UInt32 getDeclusteredArrayScrubDuration() + { return gpfsDeclusteredArrayScrubDuration; } + char *getDeclusteredArrayBackgroundTask() + { return gpfsDeclusteredArrayBackgroundTask; } + UInt32 getDeclusteredArrayTaskPercentComplete() + { return gpfsDeclusteredArrayTaskPercentComplete; } + char *getDeclusteredArrayTaskPrioriy() + { return gpfsDeclusteredArrayTaskPrioriy; } +}; + + +/* + * gpfsRecoveryGroup - description of a recovery group + */ + +class gpfsRecoveryGroup +{ + friend class gpfsRecoveryGroupDeclusteredArray; + + char gpfsRecoveryGroupName[RAID_NAME_LEN]; /* RecoveryGroup Name */ + char gpfsRecoveryGroupActiveServer[STR64_LEN]; /* active server */ + char gpfsRecoveryGroupServers[SERVER_LIST_LEN]; /* primary and backup + servers */ + char gpfsRecoveryGroupId[PVID_MAX_CHARS]; + UInt32 gpfsRecoveryGroupDeclusterArrays; /* DA with vdisks */ + UInt32 gpfsRecoveryGroupVdisks; /* vDdisks */ + UInt32 gpfsRecoveryGroupPdisks; /* pDisks */ + gpfsRecoveryGroupDeclusteredArray gpfsDeclusteredArray[MAX_DA]; + + public: + + gpfsRecoveryGroup(); + ~gpfsRecoveryGroup(); + + void init(); + void updateRgSdrInfo(char *rgName, char *serverList, char *rgId); + void updateRgSummary(int nDas, int nVdisks, int nPdisks); + void updateRgServers(char *activeServerP, char *serversP); + void print_gpfsRecoveryGroup(char *banner); + + char *getRecoveryGroupName() { return gpfsRecoveryGroupName; }; + char *getRecoveryGroupActiveServer() + { return gpfsRecoveryGroupActiveServer; } + char *getRecoveryGroupServers() + { return gpfsRecoveryGroupServers; } + char *getRecoveryGroupId() + { return gpfsRecoveryGroupId; } + UInt32 getRecoveryGroupDeclusterArrays() + { return gpfsRecoveryGroupDeclusterArrays; } + UInt32 getRecoveryGroupVdisks() + { return gpfsRecoveryGroupVdisks; } + UInt32 getRecoveryGroupPdisks() + { return gpfsRecoveryGroupPdisks; } + gpfsRecoveryGroupDeclusteredArray *getRecoveryGroupDeclusterArraysP() + { return gpfsDeclusteredArray; }; + + gpfsRecoveryGroupDeclusteredArray *getDeclusteredArrayP(int index); +}; + + +/* + * gpfsRecoveryGroupSdrInfo - NSD RAID information from GPFS SDR + */ + +class gpfsRecoveryGroupSdrInfo +{ + char gpfsRecoveryGroupName[RAID_NAME_LEN]; + char gpfsRecoveryGroupServerList[SERVER_LIST_LEN]; + char gpfsRecoveryGroupId[PVID_MAX_CHARS]; /* PVID_MAX_CHARS = 20 */ + + public: + + gpfsRecoveryGroupSdrInfo(); + ~gpfsRecoveryGroupSdrInfo(); + + void init(); + void update(char *newName, char *newServerList, char *newId); + void print_gpfsRecoveryGroupSdrInfo(); + + char *getRecoveryGroupName() { return gpfsRecoveryGroupName; }; + char *getRecoveryGroupServerList() { return gpfsRecoveryGroupServerList; }; + char *getRecoveryGroupId() { return gpfsRecoveryGroupId; }; +}; + + +/* + * gpfsNsdRAIDConfigParms - NSD RAID related config parameters/variables + * gpfsNsdRAIDConfigVar - config variable (name and value string) + */ + +class gpfsNsdRAIDConfigVar +{ + friend class gpfsNsdRAIDConfigParms; + + char configVarName[STR64_LEN]; + char configVarValueStr[STR64_LEN]; + + public: + gpfsNsdRAIDConfigVar(); + ~gpfsNsdRAIDConfigVar(); + void init(); + + char *getNsdRaidConfigVar() { return configVarName; }; + char *getNsdRaidConfigValue() { return configVarValueStr; }; +}; + +class gpfsNsdRAIDConfigParms +{ + UInt32 nParms; /* num parameters defined */ + UInt32 nParmsAlloc; /* maximum allocated array */ + gpfsNsdRAIDConfigVar *gpfsNsdRAIDConfigVarTableP; + + public: + gpfsNsdRAIDConfigParms(int maxElem); + ~gpfsNsdRAIDConfigParms(); + + int init(int maxElem); + + UInt32 getNParms() { return nParms; }; + UInt32 getNParmsAlloc() { return nParmsAlloc; }; + void setNParms(int nFound) { nParms = nFound; }; + void setNParmsAlloc(int nAlloc) { nParmsAlloc = nAlloc; }; + int findNsdRAIDConfigParmIndex(char *varName); + void updateNsdRAIDConfigParm(int index, char *varName, char *varValue); + void print_gpfsNsdRAIDConfigParms(); + gpfsNsdRAIDConfigVar *getConfigVarP(int index); +}; + + +extern int getNsdRAIDSdrInfo( + gpfsRecoveryGroupSdrInfo *rgSdrTableP, /* buffer */ + int *nRgSdrAllocP /* in: size of the buffer + out: num of RGs in this cluster */); +extern int getRecoveryGroupSummary(gpfsRecoveryGroup *rgP); +extern int getRecoveryGroupDeclusteredArrays(gpfsRecoveryGroup *rgP); +extern int getNsdRAIDParameters(gpfsNsdRAIDConfigParms *configTableP, + int *nAllocP); + +extern int gpfsRGDefined(); + +#endif /* _h_api_nsdRAID */ diff --git a/System/ior/files/gpfs/5.0.2-3/include/api_poll.h b/System/ior/files/gpfs/5.0.2-3/include/api_poll.h new file mode 100644 index 0000000..e202329 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/api_poll.h @@ -0,0 +1,2912 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* */ +/* */ +/* Licensed Materials - Property of IBM */ +/* */ +/* Restricted Materials of IBM */ +/* */ +/* (C) COPYRIGHT International Business Machines Corp. 2007,2018 */ +/* All Rights Reserved */ +/* */ +/* US Government Users Restricted Rights - Use, duplication or */ +/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp. */ +/* */ +/* IBM_PROLOG_END_TAG */ +/* @(#)49 1.65 src/avs/fs/mmfs/ts/mmantras/api_poll.h, mmfs, avs_rtac502, rtac5021836a 7/9/18 11:44:51 */ + +#ifndef _h_api_poll +#define _h_api_poll + + + +#include +#include +#include +#include +#include +#include + +/* MODS_START */ +#include +/* MODS_END */ + +#include + +/* String length */ +#define NAME_STRING_LEN 256 + +#define PATH_STRING_LEN 1024 + +/* Comma separated string length */ +#define LIST_STRING_LEN 1024 + +/* DJ_MODS_START */ +/* Buf length for Return messages from GPFS */ +#define MMCMD_RET_MSG_BUF_LEN 1024 +/* Number of tokens in a GPFS cmd with small number of parameters */ +#define MAX_NUM_TOKENS_SHORT_CMD 8 + +#define TIME_STAMP_CHARS 25 + +/* DJ_MODS_END */ + +/* Timer thread interval */ +#define TIMER_INTERVAL 300 + +#define ADDRLIST_NODES 64 + +/* rpc objects */ +#define RPC_OBJECTS 7 +#define MAX_NUMBER_BUCKETS 26 +#define MAX_SERVICES 26 +#define MAX_MSG_TYPES 51 +#define MAX_RPC_MAPPED_MSG_TYPES 2 +#define MAX_MSG_RPC MAX_SERVICES * MAX_MSG_TYPES + MAX_RPC_MAPPED_MSG_TYPES + +/* Management application protocol. It is for protocol-specific + functionalities. */ +typedef enum +{ + MGMT_SNMP = 0, + MGMT_CIM = 1 +} MgmtProtocol; + +/* Enable logging */ +#define ENABLE_MMANTRAS_LOG + +/* Maximum log level */ +#define MMANTRAS_LOG_MAX_LEVEL 3 + +/* Supported log levels */ +enum MmantrasLogLevel +{ + INFO = 0, + WARNING = 1, + ERROR = 2, + SEVERE = 3 +}; + +#define LIBMMANTRAS_VERSION 3504 /* version of currently defined MMANTRAS + interface - must update the corresponding + version number at daemon side */ + +extern int libmmantrasVersion(); + +/* Define maximum number of objects */ +#define MAX_NODE 1024 +#define MAX_FS 32 +#define MAX_FILESETV3 10000 +#define MAX_DISK 1024 +#define MAX_POOL 256 +#define MAX_POLICY 32 +#define MAX_RULE 65536 +#define MAX_NSD_SERVER 32 +#define MAX_TASK 1024 +#define MAX_PCACHE_CMD_INFO 39 /* must be >= MAX_PCACHE_CMD */ + +#define CLUSTER_MANAGER 0x1 +#define CLUSTER_STATUS 0x2 +#define CLUSTER_STATE_ALL CLUSTER_MANAGER | CLUSTER_STATUS + +#define AG_STAT_CHANNEL_WAIT 0 +#define AG_STAT_SEND_TIME_TCP 1 +#define AG_STAT_SEND_TIME_VERBS 2 +#define AG_STAT_RECEIVE_TIME_TCP 3 +#define AG_STAT_RPC_LATENCY_TCP 4 +#define AG_STAT_RPC_LATENCY_VERBS 5 +#define AG_STAT_RPC_LATENCY_MIXED 6 + +/* Info structs + The latest data from GPFS is stored in an internal copy of these structs. + The caller has his own copy, which is updated to be consistent with the + internal copy by calling the PollingHandler::update routines. */ + + +/* Asynchronous command execution information */ +class ExecutionTask +{ + friend class PollingHandler; + + char cmd[NAME_STRING_LEN]; + std::vectorargItems; + int (*callbackFn)(void *callbackData); + void *callbackData; + +public: + + ExecutionTask(MErrno *errP); + + ~ExecutionTask(); + + ExecutionTask& operator=(ExecutionTask &t); + + void setCmd(const char *cmdP); + void addArg(char *argP); + + void copyArgs(ExecutionTask *taskP); + + inline char* getCmd() { return cmd; } + inline UInt32 getNumArgItems() { return argItems.size(); } + inline char *getArg(int d) { return argItems.at(d); } +}; + +/* Asynchronous command execution result */ +class ExecutionResult +{ + UInt16 percentComplete; + +public: + ExecutionResult(MErrno *errP); + + ~ExecutionResult(); + + inline UInt16 getPercentComplete() { return percentComplete; } +}; + +/* Disk server information */ +class DiskServerInfo +{ + friend class PollingHandler; + + char name[NAME_STRING_LEN]; + +public: + DiskServerInfo(MErrno *errP); + + ~DiskServerInfo(); + + DiskServerInfo& operator=(DiskServerInfo &d); + + inline char* getName() { return name; } +}; + +/* Disk information */ +class DiskInfo +{ + friend class PollingHandler; + + Boolean_t found; + + /* Indicate whether it is free NSD or not. */ + Boolean_t free; + + char name[NAME_STRING_LEN]; + char nodeName[NAME_STRING_LEN]; // for easy association + + /* Use only when this NSD is free. */ + char poolName[NAME_STRING_LEN]; + + char status[NAME_STRING_LEN]; + char availability[NAME_STRING_LEN]; + char failureGroup[LIST_STRING_LEN]; + + char volumeId[NAME_STRING_LEN]; + + char metadata[NAME_STRING_LEN]; + char data[NAME_STRING_LEN]; + char diskWait[NAME_STRING_LEN]; + UInt64 totalSpace; + UInt64 fullBlockFreeSpace; + UInt64 subBlockFreeSpace; + + double readTime; + double writeTime; + double longestReadTime; + double longestWriteTime; + double shortestReadTime; + double shortestWriteTime; + UInt64 readBytes; + UInt64 writeBytes; + UInt32 readOps; + UInt32 writeOps; + + UInt32 nodePerfCount; // number of nodes that had valid contribution to perf aggregate + + std::vectorserverItems; + std::vectorbackupServerItems; + + void copyServers(DiskInfo *diskP); + int getServerIndex(char *nameP); + void copyBackupServers(DiskInfo *diskP); + int getBackupServerIndex(char *nameP); + +public: + DiskInfo(MErrno *errP); + + ~DiskInfo(); + + DiskInfo& operator=(DiskInfo &d); + void clearStats(); + + inline Boolean_t isFree() { return free; } + + inline char* getName() { return name; } + inline char *getNodeName() { return nodeName; } + + /* Disk stats from EE get fs command */ + inline char *getStatus() { return status; } + inline char *getAvailability() { return availability; } + inline char *getFailureGroupId() { return failureGroup; } + inline char *getVolumeId() { return volumeId; } + inline char *getMetadata() { return metadata; } + inline char *getData() { return data; } + inline char *getDiskWait() { return diskWait; } + inline UInt64 getTotalSpace() { return totalSpace; } + inline UInt64 getFullBlockFreeSpace() { return fullBlockFreeSpace; } + inline UInt64 getSubBlockFreeSpace() { return subBlockFreeSpace; } + + /* Disk performance statistics: see mmpmon ds for details */ + /* Note: getReadTime() and getWriteTime() return the total time of all + operations; divide by the total ops to get average */ + inline double getReadTime() { return readTime; } /* microseconds */ + inline double getWriteTime() { return writeTime; } + inline double getLongestReadTime() { return longestReadTime; } + inline double getLongestWriteTime() { return longestWriteTime; } + inline double getShortestReadTime() { return shortestReadTime; } + inline double getShortestWriteTime() { return shortestWriteTime; } + inline UInt64 getReadBytes() { return readBytes; } + inline UInt64 getWriteBytes() { return writeBytes; } + inline UInt32 getReadOps() { return readOps; } + inline UInt32 getWriteOps() { return writeOps; } + inline UInt32 getNodePerfCount() { return nodePerfCount; } + inline UInt32 getNumServerItems() { return serverItems.size(); } + inline DiskServerInfo *getServer(int d) { return serverItems.at(d); } + inline UInt32 getNumBackupServerItems() { return backupServerItems.size(); } + inline DiskServerInfo *getBackupServer(int d) { return backupServerItems.at(d); } + inline char *getPoolName() { return poolName; } + void updateTotalSpace(UInt64 dSizeInKB) { totalSpace = dSizeInKB; } + void updateDiskInfoStatus(char *dsStatus); +}; + +/* forward decl */ +class FilesystemInfo; + +/* Storage pool information */ +class StoragePoolInfo +{ + friend class PollingHandler; + + char name[NAME_STRING_LEN]; + char status[NAME_STRING_LEN]; + UInt32 numDisks; + UInt64 totalSpace; + UInt64 freeSpace; + + UInt32 parentFS; /* index of parent filesystem */ + Boolean_t found; + + /* Store the list of disk name - primary key */ + std::vectordiskItems; + struct timeval diskRefreshTime; + struct timeval diskPerfRefreshTime; + + void copyDisks(StoragePoolInfo *poolP); + int getDiskInfoIndex(char *nameP); + + UInt64 totalBytesRead; + UInt64 totalBytesWrite; + double totalReadTime; + double totalWriteTime; + void clearStats(); + +public: + StoragePoolInfo(MErrno *errP); + ~StoragePoolInfo(); + StoragePoolInfo& operator=(StoragePoolInfo &sp); + inline char *getName() { return name; } + inline char *getStatus() { return status; } + inline UInt64 getTotalSpace() { return totalSpace; } + inline UInt64 getFreeSpace() { return freeSpace; } + inline UInt32 getParent() { return parentFS; } + inline UInt32 getNumDisks() { return numDisks; } // Use only when file system is mounted + inline UInt32 getNumDiskItems() { return diskItems.size(); } + inline DiskInfo *getDisk(int d) { return diskItems.at(d); } + inline struct timeval getDiskRefreshTime() { return diskRefreshTime; } + inline struct timeval getDiskPerfRefreshTime() { return diskPerfRefreshTime; } + + inline UInt64 getTotalBytesRead() { return totalBytesRead; } + inline UInt64 getTotalBytesWrite() { return totalBytesWrite; } + inline double getTotalReadTime() { return totalReadTime; } + inline double getTotalWriteTime() { return totalWriteTime; } + +}; + +/* Mounted node information */ +class MountedNodeInfo +{ + friend class PollingHandler; + + char name[NAME_STRING_LEN]; + char ipAddr[NAME_STRING_LEN]; + + Boolean_t found; + +public: + MountedNodeInfo(MErrno *errP); + + ~MountedNodeInfo(); + + MountedNodeInfo& operator=(MountedNodeInfo &d); + + inline char* getName() { return name; } + inline char* getIpAddr() { return ipAddr; } +}; + +/* File system policy rule information */ +class RuleInfo +{ + friend class PollingHandler; + + char name[NAME_STRING_LEN]; + char desc[LIST_STRING_LEN]; + +public: + RuleInfo(MErrno *errP); + + ~RuleInfo(); + + RuleInfo& operator=(RuleInfo &d); + + inline char *getName() { return name; } + inline char *getDesc() { return desc; } +}; + +/* File system policy information */ +class PolicyInfo +{ + friend class PollingHandler; + + char name[NAME_STRING_LEN]; + char installUser[NAME_STRING_LEN]; + char installTime[NAME_STRING_LEN]; + + std::vectorruleItems; + + void copyRules(PolicyInfo *piP); + int getRuleInfoIndex(char *nameP); + +public: + PolicyInfo(MErrno *errP); + + ~PolicyInfo(); + + PolicyInfo& operator=(PolicyInfo &d); + + inline char *getName() { return name; } + inline char *getInstallUser() { return installUser; } + inline char *getInstallTime() { return installTime; } + inline UInt32 getNumRules() { return ruleItems.size(); } + inline RuleInfo *getRule(int r) { return ruleItems.at(r); } +}; + +/* File system performance */ +class FilesystemPerf +{ + friend class PollingHandler; + + char fsName[NAME_STRING_LEN]; + char nodeName[NAME_STRING_LEN]; + char nodeIpAddr[NAME_STRING_LEN]; + + UInt64 bytesRead; + UInt64 bytesCache; + UInt64 bytesWritten; + UInt32 reads; + UInt32 caches; + UInt32 writes; + UInt32 openCalls; + UInt32 closeCalls; + UInt32 readCalls; + UInt32 writeCalls; + UInt32 readdirCalls; + UInt64 inodesWritten; + UInt64 inodesRead; + UInt64 inodesDeleted; + UInt64 inodesCreated; + UInt32 statCacheHit; + UInt32 statCacheMiss; + + Boolean_t found; + +public: + FilesystemPerf(MErrno *errP); + + ~FilesystemPerf(); + + FilesystemPerf& operator=(FilesystemPerf &fs); + void clearStats(); + + inline char *getFsName() { return fsName; } + inline char *getNodeName() { return nodeName; } + inline char *getNodeIpAddr() { return nodeIpAddr; } + inline UInt64 getBytesRead() { return bytesRead; } + inline UInt64 getBytesCache() { return bytesCache; } + inline UInt64 getBytesWritten() { return bytesWritten; } + inline UInt32 getReads() { return reads; } + inline UInt32 getCaches() { return caches; } + inline UInt32 getWrites() { return writes; } + inline UInt32 getOpenCalls() { return openCalls; } + inline UInt32 getCloseCalls() { return closeCalls; } + inline UInt32 getReadCalls() { return readCalls; } + inline UInt32 getWriteCalls() { return writeCalls; } + inline UInt32 getReaddirCalls() { return readdirCalls; } + inline UInt64 getInodesWritten() { return inodesWritten; } + inline UInt64 getInodesRead() { return inodesRead; } + inline UInt64 getInodesDeleted() { return inodesDeleted; } + inline UInt64 getInodesCreated() { return inodesCreated; } + inline UInt32 getStatCacheHit() { return statCacheHit; } + inline UInt32 getStatCacheMiss() { return statCacheMiss; } +}; + +/* File system information */ +class FilesystemInfo +{ + friend class PollingHandler; + + char name[NAME_STRING_LEN]; + + /* Manager node name. */ + char manager[NAME_STRING_LEN]; + + char status[NAME_STRING_LEN]; + char xstatus[NAME_STRING_LEN]; + + UInt32 readDuration; + UInt32 writeDuration; + UInt32 numMgmt; + UInt32 numMgrChange; + UInt64 totalSpace; + UInt64 numTotalInodes; + UInt64 freeSpace; + UInt64 numFreeInodes; + UInt64 fullBlockFreeSpace; + UInt64 subBlockFreeSpace; + char threadWait[NAME_STRING_LEN]; + char diskWait[NAME_STRING_LEN]; + + /* Configuration information. */ + UInt64 minFragmentSize; + UInt64 inodeSize; + UInt64 indirectBlockSize; + UInt32 defaultMetadataReplicas; + UInt32 maxMetadataReplicas; + UInt32 defaultDataReplicas; + UInt32 maxDataReplicas; + char blockAllocationType[NAME_STRING_LEN]; + char fileLockingSemantics[NAME_STRING_LEN]; + char aclSemantics[NAME_STRING_LEN]; + UInt64 estimatedAverageFileSize; + UInt64 numNodes; + UInt64 blockSize; + char quotaEnforced[NAME_STRING_LEN]; + char defaultQuotasEnabled[NAME_STRING_LEN]; + UInt64 maxNumInodes; + char filesystemVersion[NAME_STRING_LEN]; + char supportForLargeLuns[NAME_STRING_LEN]; + char dmapiEnabled[NAME_STRING_LEN]; + char exactMtime[NAME_STRING_LEN]; + char suppressAtime[NAME_STRING_LEN]; + char automaticMountOption[NAME_STRING_LEN]; + char additionalMountOptions[NAME_STRING_LEN]; + char defaultMountPoint[NAME_STRING_LEN]; + + UInt64 bytesRead; + UInt64 bytesCache; + UInt64 bytesWritten; + + UInt32 reads; + UInt32 caches; + UInt32 writes; + + UInt32 openCalls; + UInt32 closeCalls; + UInt32 readCalls; + UInt32 writeCalls; + UInt32 readdirCalls; + + UInt64 inodesWritten; + UInt64 inodesRead; + UInt64 inodesDeleted; + UInt64 inodesCreated; + + UInt32 statCacheHit; + UInt32 statCacheMiss; + + UInt32 nodePerfCount; + + /* Store the list of storage pools - primary key */ + std::vectorpoolItems; + struct timeval poolRefreshTime; /* Last data refresh time */ + + /* Store the list of mounted nodes */ + std::vectormountedNodeItems; + + /* Store the list of policies */ + std::vectorpolicyItems; + + /* Store the list of per-node performance */ + std::vectorperfItems; + + /* Workspace indicating this item was found in the SDR file */ + Boolean_t found; + + /* MODS_START */ + bool updated; + /* MODS_END */ + + void copyPools(FilesystemInfo *fsP); + int getStoragePoolInfoIndex(char *nameP); + + void copyMountedNodes(FilesystemInfo *fsP); + int getMountedNodeIndex(char *ipAddrP); + + void copyPolicies(FilesystemInfo *fsP); + int getPolicyInfoIndex(char *nameP); + + void copyPerNodePerfs(FilesystemInfo *fsP); + int getPerNodePerfIndex(char *ipAddrP); + +public: + FilesystemInfo(MErrno *errP); + + ~FilesystemInfo(); + + FilesystemInfo& operator=(FilesystemInfo &fs); + void clearStats(); + + /* Filesystem info from SDR and EE get fs */ + inline char *getName() { return name; } + inline char *getManager() { return manager; } + inline char *getStatus() { return status; } + inline char *getXstatus() { return xstatus; } + + inline UInt32 getReadDuration() { return readDuration; } + inline UInt32 getWriteDuration() { return writeDuration; } + inline UInt32 getNumMgmt() { return numMgmt; } + inline UInt32 getNumMgrChange() { return numMgrChange; } + inline UInt64 getTotalSpace() { return totalSpace; } + inline UInt64 getNumTotalInodes() { return numTotalInodes; } + inline UInt64 getFreeSpace() { return freeSpace; } + inline UInt64 getNumFreeInodes() { return numFreeInodes; } + inline UInt64 getFullBlockFreeSpace() { return fullBlockFreeSpace; } + inline UInt64 getSubBlockFreeSpace() { return subBlockFreeSpace; } + + /* Filesystem performance statistics from mmpmon gfis */ + inline char *getThreadWait() { return threadWait; } + inline char *getDiskWait() { return diskWait; } + + inline UInt64 getMinFragmentSize() { return minFragmentSize; } + inline UInt64 getInodeSize() { return inodeSize; } + inline UInt64 getIndirectBlockSize() { return indirectBlockSize; } + inline UInt64 getEstimatedAverageFileSize() { return estimatedAverageFileSize; } + inline UInt64 getNumNodes() { return numNodes; } + inline UInt64 getBlockSize() { return blockSize; } + inline UInt64 getFSInodeLimit() { return maxNumInodes; } + inline UInt32 getDefaultMetadataReplicas() { return defaultMetadataReplicas; } + inline UInt32 getMaxMetadataReplicas() { return maxMetadataReplicas; } + inline UInt32 getDefaultDataReplicas() { return defaultDataReplicas; } + inline UInt32 getMaxDataReplicas() { return maxDataReplicas; } + inline char *getBlockAllocationType() { return blockAllocationType; } + inline char *getFileLockingSemantics() { return fileLockingSemantics; } + inline char *getAclSemantics() { return aclSemantics; } + inline char *getQuotaEnforced() { return quotaEnforced; } + inline char *getDefaultQuotasEnabled() { return defaultQuotasEnabled; } + inline char *getFilesystemVersion() { return filesystemVersion; } + inline char *getSupportForLargeLuns() { return supportForLargeLuns; } + inline char *getDmapiEnabled() { return dmapiEnabled; } + inline char *getExactMtime() { return exactMtime; } + inline char *getSuppressAtime() { return suppressAtime; } + inline char *getAutomaticMountOption() { return automaticMountOption; } + inline char *getAdditionalMountOptions() { return additionalMountOptions; } + inline char *getDefaultMountPoint() { return defaultMountPoint; } + + inline UInt64 getBytesRead() { return bytesRead; } + inline UInt64 getBytesCache() { return bytesCache; } + inline UInt64 getBytesWritten() { return bytesWritten; } + inline UInt32 getReads() { return reads; } + inline UInt32 getCaches() { return caches; } + inline UInt32 getWrites() { return writes; } + inline UInt32 getOpenCalls() { return openCalls; } + inline UInt32 getCloseCalls() { return closeCalls; } + inline UInt32 getReadCalls() { return readCalls; } + inline UInt32 getWriteCalls() { return writeCalls; } + inline UInt32 getReaddirCalls() { return readdirCalls; } + inline UInt64 getInodesWritten() { return inodesWritten; } + inline UInt64 getInodesRead() { return inodesRead; } + inline UInt64 getInodesDeleted() { return inodesDeleted; } + inline UInt64 getInodesCreated() { return inodesCreated; } + inline UInt32 getStatCacheHit() { return statCacheHit; } + inline UInt32 getStatCacheMiss() { return statCacheMiss; } + + /* Storage pool information from EE get stgpools */ + inline UInt32 getNumStoragePools() { return poolItems.size(); } + inline StoragePoolInfo *getStoragePool(int p) { return poolItems.at(p); } + inline struct timeval getPoolRefreshTime() { return poolRefreshTime; } + + inline UInt32 getNodePerfCount() { return nodePerfCount; } + + inline UInt32 getNumMountedNodes() { return mountedNodeItems.size(); } + inline MountedNodeInfo *getMountedNode(int n) { return mountedNodeItems.at(n); } + + inline UInt32 getNumPolicies() { return policyItems.size(); } + inline PolicyInfo *getPolicy(int n) { return policyItems.at(n); } + + inline UInt32 getNumPerNodePerfs() { return perfItems.size(); } + inline FilesystemPerf *getPerNodePerf(int n) { return perfItems.at(n); } + + /* MODS_START */ + inline bool wasUpdated() { return updated; } + /* MODS_END */ + +}; + +/* Disk access information */ +class DiskAccessInfo +{ + friend class PollingHandler; + + char diskName[NAME_STRING_LEN]; + Boolean_t local; + char deviceName[NAME_STRING_LEN]; + char serverName[NAME_STRING_LEN]; + +public: + DiskAccessInfo(MErrno *errP); + + ~DiskAccessInfo(); + + DiskAccessInfo& operator=(DiskAccessInfo &d); + + inline char *getDiskName() { return diskName; } + inline Boolean_t isLocal() { return local; } + inline char *getDeviceName() { return deviceName; } + inline char *getServerName() { return serverName; } +}; + +/* I/O statistics counted by context + + _response_ begin mmpmon iocs + _mmpmon::iocs_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1262967025 + _tu_ 739667 _other_ 672560 18244 _mb_ 3427 580 _steal_ 5 8 + _cleaner_ 0 910 _sync_ 22 487 _logwrap_ 0 16703 _revoke_ 0 0 + _prefetch_ 9250 0 _logdata_ 9250 0 _nsdworker_ 9250 0 + _response_ end +*/ + +/* Define a version number for ioStatsInfo to allow + future changes in this structure. + */ +#define GPFS_IOCS_VERSION 1 + +class IocStatsInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + char ipAddr[NAME_STRING_LEN]; + + UInt32 iocUnknown_r; + UInt32 iocUnknown_w; + UInt32 iocMBHandler_r; + UInt32 iocMBHandler_w; + UInt32 iocSteal_r; + UInt32 iocSteal_w; + UInt32 iocCleaner_r; + UInt32 iocCleaner_w; + UInt32 iocSync_r; + UInt32 iocSync_w; + UInt32 iocLogwrap_r; + UInt32 iocLogwrap_w; + UInt32 iocRevoke_r; + UInt32 iocRevoke_w; + UInt32 iocPrefetch_r; + UInt32 iocPrefetch_w; + +public: + IocStatsInfo(MErrno *errP); + IocStatsInfo(); + ~IocStatsInfo(); + + IocStatsInfo& operator=(IocStatsInfo &ioc); + + void clearStats(); + + inline UInt32 getIocUnknown_r() { return iocUnknown_r; } + inline UInt32 getIocUnknown_w() { return iocUnknown_w; } + inline UInt32 getIocMBHandler_r() { return iocMBHandler_r; } + inline UInt32 getIocMBHandler_w() { return iocMBHandler_w; } + inline UInt32 getIocSteal_r() { return iocSteal_r; } + inline UInt32 getIocSteal_w() { return iocSteal_w; } + inline UInt32 getIocCleaner_r() { return iocCleaner_r; } + inline UInt32 getIocCleaner_w() { return iocCleaner_w; } + inline UInt32 getIocSync_r() { return iocSync_r; } + inline UInt32 getIocSync_w() { return iocSync_w; } + inline UInt32 getIocLogwrap_r() { return iocLogwrap_r; } + inline UInt32 getIocLogwrap_w() { return iocLogwrap_w; } + inline UInt32 getIocRevoke_r() { return iocRevoke_r; } + inline UInt32 getIocRevoke_w() { return iocRevoke_w; } + inline UInt32 getIocPrefetch_r() { return iocPrefetch_r; } + inline UInt32 getIocPrefetch_w() { return iocPrefetch_w; } + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + inline char *getIpAddr() { return ipAddr; } +}; + +/* vfs statistics + +_response_ begin mmpmon vfss +_mmpmon::vfss_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1262970919 + _tu_ 253243 _access_ 3106 0.037376 _close_ 218 0.033548 _create_ 0 0.000000 + _fclear_ 0 0.000000 _fsync_ 0 0.000000 _fsync_range_ 0 0.000000 + _ftrunc_ 0 0.000000 _getattr_ 13590 7.612393 _link_ 0 0.000000 + _lockctl_ 0 0.000000 _lookup_ 30154 1.026978 _map_lloff_ 0 0.000000 + _mkdir_ 0 0.000000 _mknod_ 0 0.000000 _open_ 218 0.127916 + _read_ 380 0.081198 _write_ 0 0.000000 _mmapRead_ 0 0.000000 + _mmapWrite_ 0 0.000000 _readdir_ 1131 0.459991 _readlink_ 0 0.000000 + _readpage_ 0 0.000000 _remove_ 3104 45.060595 _rename_ 0 0.000000 + _rmdir_ 0 0.000000 _setacl_ 0 0.000000 _setattr_ 0 0.000000 + _symlink_ 0 0.000000 _unmap_ 0 0.000000 _writepage_ 0 0.000000 + _tsfattr_ 0 0.000000 _tsfsattr_ 0 0.000000 _flock_ 0 0.000000 + _setxattr_ 0 0.000000 _getxattr_ 0 0.000000 _listxattr_ 0 0.000000 + _removexattr_ 0 0.000000 _encode_fh_ 0 0.000000 _decode_fh_ 0 0.000000 + _get_dentry_ 0 0.000000 _get_parent_ 0 0.000000 _mount_ 1 13.515959 + _statfs_ 0 0.000000 _sync_ 2796 5.254986 _vget_ 0 0.000000 +_response_ end + +*/ + +/* Define a version number for VfsStatsInfo to allow + future changes in this structure. + */ +#define GPFS_VFSS_VERSION 1 + +class VfsStatsInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + char ipAddr[NAME_STRING_LEN]; + + /* vfs calls */ + UInt32 accessCalls; + UInt32 closeCalls; + UInt32 createCalls; + UInt32 fclearCalls; + UInt32 fsyncCalls; + UInt32 fsync_rangeCalls; + UInt32 ftruncCalls; + UInt32 getattrCalls; + UInt32 linkCalls; + UInt32 lockctlCalls; + UInt32 lookupCalls; + UInt32 map_lloffCalls; + UInt32 mkdirCalls; + UInt32 mknodCalls; + UInt32 openCalls; + UInt32 readCalls; + UInt32 writeCalls; + UInt32 mmapReadCalls; + UInt32 mmapWriteCalls; + UInt32 readdirCalls; + UInt32 readlinkCalls; + UInt32 readpageCalls; + UInt32 removeCalls; + UInt32 renameCalls; + UInt32 rmdirCalls; + UInt32 setaclCalls; + UInt32 setattrCalls; + UInt32 symlinkCalls; + UInt32 unmapCalls; + UInt32 writepageCalls; + UInt32 tsfattrCalls; + UInt32 tsfsattrCalls; + UInt32 flockCalls; + UInt32 setxattrCalls; + UInt32 getxattrCalls; + UInt32 listxattrCalls; + UInt32 removexattrCalls; + UInt32 encode_fhCalls; + UInt32 decode_fhCalls; + UInt32 get_dentryCalls; + UInt32 get_parentCalls; + UInt32 mountCalls; + UInt32 statfsCalls; + UInt32 syncCalls; + UInt32 vgetCalls; + + /* total time spent on each call */ + float accessT; + float closeT; + float createT; + float fclearT; + float fsyncT; + float fsync_rangeT; + float ftruncT; + float getattrT; + float linkT; + float lockctlT; + float lookupT; + float map_lloffT; + float mkdirT; + float mknodT; + float openT; + float readT; + float writeT; + float mmapReadT; + float mmapWriteT; + float readdirT; + float readlinkT; + float readpageT; + float removeT; + float renameT; + float rmdirT; + float setaclT; + float setattrT; + float symlinkT; + float unmapT; + float writepageT; + float tsfattrT; + float tsfsattrT; + float flockT; + float setxattrT; + float getxattrT; + float listxattrT; + float removexattrT; + float encode_fhT; + float decode_fhT; + float get_dentryT; + float get_parentT; + float mountT; + float statfsT; + float syncT; + float vgetT; + +public: + VfsStatsInfo(MErrno *errP); + VfsStatsInfo(); + ~VfsStatsInfo(); + + VfsStatsInfo& operator=(VfsStatsInfo &v); + + void clearStats(); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + inline char *getIpAddr() { return ipAddr; } + inline UInt32 getAccessCalls() { return accessCalls; } + inline UInt32 getCloseCalls() { return closeCalls; } + inline UInt32 getCreateCalls() { return createCalls; } + inline UInt32 getFclearCalls() { return fclearCalls; } + inline UInt32 getFsyncCalls() { return fsyncCalls; } + inline UInt32 getFsync_rangeCalls() { return fsync_rangeCalls; } + inline UInt32 getFtruncCalls() { return ftruncCalls; } + inline UInt32 getGetattrCalls() { return getattrCalls; } + inline UInt32 getLinkCalls() { return linkCalls; } + inline UInt32 getLockctlCalls() { return lockctlCalls; } + inline UInt32 getLookupCalls() { return lookupCalls; } + inline UInt32 getMap_lloffCalls() { return map_lloffCalls; } + inline UInt32 getMkdirCalls() { return mkdirCalls; } + inline UInt32 getMknodCalls() { return mknodCalls; } + inline UInt32 getOpenCalls() { return openCalls; } + inline UInt32 getReadCalls() { return readCalls; } + inline UInt32 getWriteCalls() { return writeCalls; } + inline UInt32 getMmapReadCalls() { return mmapReadCalls; } + inline UInt32 getMmapWriteCalls() { return mmapWriteCalls; } + inline UInt32 getReaddirCalls() { return readdirCalls; } + inline UInt32 getReadlinkCalls() { return readlinkCalls; } + inline UInt32 getReadpageCalls() { return readpageCalls; } + inline UInt32 getRemoveCalls() { return removeCalls; } + inline UInt32 getRenameCalls() { return renameCalls ; } + inline UInt32 getRmdirCalls() { return rmdirCalls; } + inline UInt32 getSetaclCalls() { return setaclCalls; } + inline UInt32 getSetattrCalls() { return setattrCalls; } + inline UInt32 getSymlinkCalls() { return symlinkCalls; } + inline UInt32 getUnmapCalls() { return unmapCalls; } + inline UInt32 getWritepageCalls() { return writepageCalls; } + inline UInt32 getTsfattrCalls() { return tsfattrCalls; } + inline UInt32 getTsfsattrCalls() { return tsfsattrCalls; } + inline UInt32 getFlockCalls() { return flockCalls; } + inline UInt32 getSetxattrCalls() { return setxattrCalls; } + inline UInt32 getGetxattrCalls() { return getxattrCalls; } + inline UInt32 getListxattrCalls() { return listxattrCalls ; } + inline UInt32 getRemovexattrCalls() { return removexattrCalls; } + inline UInt32 getEncode_fhCalls() { return encode_fhCalls; } + inline UInt32 getDecode_fhCalls() { return decode_fhCalls; } + inline UInt32 getGet_dentryCalls() { return get_dentryCalls; } + inline UInt32 getGet_parentCalls() { return get_parentCalls; } + inline UInt32 getMountCalls() { return mountCalls; } + inline UInt32 getStatfsCalls() { return statfsCalls; } + inline UInt32 getSyncCalls() { return syncCalls; } + inline UInt32 getVgetCalls() { return vgetCalls; } + + inline float getAccessTime() { return accessT; } + inline float getCloseTime() { return closeT; } + inline float getCreateTime() { return createT; } + inline float getFclearTime() { return fclearT; } + inline float getFsyncTime() { return fsyncT; } + inline float getFsync_rangeTime() { return fsync_rangeT; } + inline float getFtruncTime() { return ftruncT; } + inline float getGetattrTime() { return getattrT; } + inline float getLinkTime() { return linkT; } + inline float getLockctlTime() { return lockctlT; } + inline float getLookupTime() { return lookupT; } + inline float getMap_lloffTime() { return map_lloffT; } + inline float getMkdirTime() { return mkdirT; } + inline float getMknodTime() { return mknodT; } + inline float getOpenTime() { return openT; } + inline float getReadTime() { return readT; } + inline float getWriteTime() { return writeT; } + inline float getMmapReadTime() { return mmapReadT; } + inline float getMmapWriteTime() { return mmapWriteT; } + inline float getReaddirTime() { return readdirT; } + inline float getReadlinkTime() { return readlinkT; } + inline float getReadpageTime() { return readpageT; } + inline float getRemoveTime() { return removeT; } + inline float getRenameTime() { return renameT ; } + inline float getRmdirTime() { return rmdirT; } + inline float getSetaclTime() { return setaclT; } + inline float getSetattrTime() { return setattrT; } + inline float getSymlinkTime() { return symlinkT; } + inline float getUnmapTime() { return unmapT; } + inline float getWritepageTime() { return writepageT; } + inline float getTimesfattrT() { return tsfattrT; } + inline float getTimesfsattrT() { return tsfsattrT; } + inline float getFlockTime() { return flockT; } + inline float getSetxattrTime() { return setxattrT; } + inline float getGetxattrTime() { return getxattrT; } + inline float getListxattrTime() { return listxattrT ; } + inline float getRemovexattrTime() { return removexattrT; } + inline float getEncode_fhTime() { return encode_fhT; } + inline float getDecode_fhTime() { return decode_fhT; } + inline float getGet_dentryTime() { return get_dentryT; } + inline float getGet_parentTime() { return get_parentT; } + inline float getMountTime() { return mountT; } + inline float getStatfsTime() { return statfsT; } + inline float getSyncTime() { return syncT; } + inline float getVgetTime() { return vgetT; } +}; + +/* Per node thread utilization stats + + _response_ begin mmpmon threads + _mmpmon::threads_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1263415922 + _tu_ 317953 _nthreads_ 127 _seq_ 60149 _noncritical_ 13 28 1473 + _daemonstartup_ 14 16 33 _mbhandler_ 29 29 65 _rcvworker_ 10 11 266 + _revokeworker_ 0 0 35 _rangerevoke_ 0 0 20 _reclockrevoke_ 0 0 10 + _prefetch_ 1 1 72 _sgexception_ 0 3 16 _receiver_ 12 12 16 + _pcache_ 0 0 0 _multithreadworker_ 0 0 974 + _response_ end + +*/ + +/* Define a version number for ThreadUtilInfo to allow + future changes in this structure. + */ +#define GPFS_THRDS_VERSION 1 + +class ThreadUtilInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + char ipAddr[NAME_STRING_LEN]; + + UInt32 nThreads; + UInt32 seq; + + /* Thread pool utilization (current/highest/maximum) */ + threadUtil_t noncritical; + threadUtil_t daemonstartup; + threadUtil_t mbhandler; + threadUtil_t rcvworker; + threadUtil_t revokeworker; + threadUtil_t rangerevoke; + threadUtil_t reclockrevoke; + threadUtil_t prefetch; + threadUtil_t sgexception; + threadUtil_t receiver; + threadUtil_t pcache; + threadUtil_t multithreadworker; + +public: + ThreadUtilInfo(MErrno *errP); + ThreadUtilInfo(); + ~ThreadUtilInfo(); + + ThreadUtilInfo& operator=(ThreadUtilInfo &th_u); + + void clearStats(); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + inline char *getIpAddr() { return ipAddr; } + inline UInt32 getNthreads() { return nThreads; } + inline UInt32 getSeq() { return seq; } + + inline threadUtil_t *getNoncritical() { return &noncritical; } + inline threadUtil_t *getDaemonstartup() { return &daemonstartup; } + inline threadUtil_t *getMbhandler() { return &mbhandler; } + inline threadUtil_t *getRcvworker() { return &rcvworker; } + inline threadUtil_t *getRevokeworker() { return &revokeworker; } + inline threadUtil_t *getRrangerevoke() { return &rangerevoke; } + inline threadUtil_t *getReclockrevoke() { return &reclockrevoke; } + inline threadUtil_t *getPrefetch() { return &prefetch; } + inline threadUtil_t *getSgexception() { return &sgexception; } + inline threadUtil_t *getReceiver() { return &receiver; } + inline threadUtil_t *getPcache() { return &pcache; } + inline Int32 getMultithreadWanted() { return multithreadworker.current; } + inline Int32 getMultithreadRunning() { return multithreadworker.highest; } + inline Int32 getMultithreadLimit() { return multithreadworker.maximum; } + +}; + +/* rpcs stats + * _response_ begin mmpmon rpcs + * _mmpmon::rpcs_ _req_ node _n_ 192.168.56.168 _nn_ node3 _rn_ 192.168.56.167 _rnn_ node2 _rc_ 0 _t_ 1388052336 _tu_ 611492 + * _rpcObj_ _obj_ AG_STAT_CHANNEL_WAIT _nsecs_ 1 _nmins_ 10 _nhours_ 0 _ndays_ 0 + * _stats_ _tmu_ xxxx _av_ x.000, _min_ x.000, _max_ x.000, _cnt_ xxxx + * _stats_ _tmu_ xxxx _av_ x.000, _min_ x.000, _max_ x.000, _cnt_ xxxx + * ......... + * ......... + * _rpcObj_ _obj_ AG_STAT_SEND_TIME_TCP _nsecs_ 1 _nmins_ 10 _nhours_ 0 _ndays_ 0 + * _stats_ _tmu_ xxxx _av_ x.000, _min_ x.000, _max_ x.000, _cnt_ xxxx + * _stats_ _tmu_ xxxx _av_ x.000, _min_ x.000, _max_ x.000, _cnt_ xxxx + * ......... + * ......... + * _response_ end + * + * rpcs ns + * _response_ begin mmpmon rpcs ns + * _mmpmon::rpcs_ _req_ node _n_ 192.168.56.168 _nn_ node3 _rc_ 0 _t_ 1388052336 _tu_ 611492 + * _rpcObj_ _obj_ AG_STAT_CHANNEL_WAIT _nsecs_ 1 _nmins_ 0 _nhours_ 0 _ndays_ 0 + * _stats_ _tmu_ xxxx _av_ x.000, _min_ x.000, _max_ x.000, _cnt_ xxxx + * _rpcObj_ _obj_ AG_STAT_SEND_TIME_TCP _nsecs_ 1 _nmins_ 0 _nhours_ 0 _ndays_ 0 + * _stats_ _tmu_ xxxx _av_ x.000, _min_ x.000, _max_ x.000, _cnt_ xxxx + * _response_ end + * + * rpcs size + * _response_ begin mmpmon rpcs size + * _mmpmon::rpcs_ _req_ size _n_ 192.168.56.167 _nn_ node2 _rc_ 0 _t_ 1388417852 _tu_ 572950 + * _rpcSize_ _size_ 64 _nsecs_ 60 _nmins_ 60 _nhours_ 24 _ndays_ 30 + * _stats_ _tmu_ xxxx _av_ x.000, _min_ x.000, _max_ x.000, _cnt_ xxxx + * ........ + * ........ + * _response_ end + * + * rpcs message + * _response_ begin mmpmon rpcs message + * _mmpmon::rpcs_ _req_ message _n_ 192.168.56.167 _nn_ node2 _rc_ 0 _t_ 13907i61504 _tu_ 332981 + * _rpcObj_ _obj_ xxxx _nsecs_ 60 _nmins_ 60 _nhours_ 24 _ndays_ 30 + * _stats_ _tmu_ xxxx _av_ x.000, _min_ x.000, _max_ x.000, _cnt_ xxxx + * ....... + * ....... + * _response_ end + * + * rpcs raw + * _response_ begin mmpmon rpcs raw + * _mmpmon::rpcs_ _req_ raw _n_ 192.168.56.167 _nn_ node2 _rc_ 0 _t_ xxxx _tu_ xxxx + * _rpcstat_ _rpcstator_ xxxx _rpcstatcnt_ xxxx + * _stat_ _cw_ xxxx _st_ xxxx _rt_ xxxx _rpclt_ xxxx _ds_ xxxx _dr_ xxxx _rdmas_ xxxx _rdmar_ xxxx _ni_ xxxx + * _stat_ _cw_ xxxx _st_ xxxx _rt_ xxxx _rpclt_ xxxx _ds_ xxxx _dr_ xxxx _rdmas_ xxxx _rdmar_ xxxx _ni_ xxxx + * ..... + * _rpcexec_ _rpcexecor_ xxxx _rpcexeccnt_ xxxx + * _stat_ _rpcet_ xxxx _rpcsn_ xxxx _rpcmt_ xxxx + * _stat_ _rpcet_ xxxx _rpcsn_ xxxx _rpcmt_ xxxx + * ..... + * ..... + * _response_ end + * +/* Define a version number for RPCUtilInfo to allow + * future changes in this structure. + */ +#define GPFS_RPC_VERSION 1 + +/* class to mainatain stats for single time unit */ +class PerfSample +{ +public: + double minValue; //min over a single time unit + double maxValue; // max over a single time unit + double sumValue; // average over a single time unit + UInt64 valueCount; // count of stats over a single time unit + + inline PerfSample() + { + clearstats(); + } + inline ~PerfSample(){}; + inline void clearstats() + { + minValue = maxValue = sumValue = valueCount = 0; + } +}; + +/* class to maintain stats for all available secs/mins/hours/days + * for an object */ +class AggregatedRPCPerfStat +{ +public: + UInt32 numSecs; //num of secs maintained for an rpc object + UInt32 numMins; // num of mins maintained for an rpc object + UInt32 numHours; // num of hours maintained for an rpc object + UInt32 numDays; // num of days maintained for an rpc object + PerfSample *secondP; // array of PerfSample for nsecs + PerfSample *minuteP; // array of PerfSample for nmins + PerfSample *hourP; // array of PerfSample for nhours + PerfSample *dayP; //array of PerfSample for ndays + char objName[NAME_STRING_LEN]; //Name of rpc object + AggregatedRPCPerfStat(UInt32 nSeconds, UInt32 nMinutes, UInt32 nHours, UInt32 nDays, char *objectName); + AggregatedRPCPerfStat(); + AggregatedRPCPerfStat(const AggregatedRPCPerfStat& agPerfStat); + ~AggregatedRPCPerfStat(); + AggregatedRPCPerfStat& operator=(AggregatedRPCPerfStat &agPerfStat); + + inline UInt32 getNumSecs() { return numSecs;} + inline UInt32 getNumMins() { return numMins;} + inline UInt32 getNumHours() { return numHours;} + inline UInt32 getNumDays() { return numDays;} + /* return nth sec from secondP array */ + inline PerfSample *getSecs(int n) + { + assert(n < numSecs); + return &(secondP[n]); + } + /* return nth min from minuteP array */ + inline PerfSample *getMins(int n) + { + assert(n < numMins); + return &(minuteP[n]); + } + /* return nth hour from hourP array */ + inline PerfSample *getHours(int n) + { + assert(n < numHours); + return &(hourP[n]); + } + /* return nth day from dayP array */ + inline PerfSample *getDays(int n) + { + assert(n < numDays); + return &(dayP[n]); + } + inline char* getObjectName() + { + return objName; + } +}; + +/* class to maintain rpc stats for every remote node */ +class NodeUtilInfo +{ +public: + char nodeName[NAME_STRING_LEN]; /*Node name*/ + char nodeIpAddr[NAME_STRING_LEN]; /*Node ip address x.x.x.x */ + int numObjects; /*number of rpc objects for which stats is to be maintained */ + AggregatedRPCPerfStat *agRpcPerfStatP[RPC_OBJECTS]; /*array to maintain rpc stats for each rpc object*/ + NodeUtilInfo(MErrno *errP, char *nodeName, char *nodeIpAddr); /*contructor*/ + NodeUtilInfo(); /*constructor*/ + NodeUtilInfo(const NodeUtilInfo& nodeUtilInfo); /*copy constructor*/ + ~NodeUtilInfo(); /*destructor*/ + NodeUtilInfo& operator=(NodeUtilInfo &nodeUtilP); /* = operator overloading */ + inline int getNumObjects() /* returns number of rpc objects for which stats is maintained */ + { + return numObjects; + } + inline AggregatedRPCPerfStat getRPCPerfStatObj(int n) /*returns nth rpc object*/ + { + assert(n < numObjects); + return *(agRpcPerfStatP[n]); + } +}; + +/* class to maintain rpc stats info for all objects */ +class RPCUtilInfo +{ + friend class PollingHandler; + /* array to maintain rpc stats info per node + * node1 to node2, node1 to node3, node1 to node4 */ + NodeUtilInfo *nodeUtilInfo[MAX_NODE]; + UInt32 numNodes; /*number of nodes for which rpc stats is maintained */ +public: + RPCUtilInfo(MErrno *errP); /*constructor*/ + RPCUtilInfo(); /*constructor*/ + RPCUtilInfo(const RPCUtilInfo& rpc_u); /*copy constructor*/ + ~RPCUtilInfo(); /*destructor */ + RPCUtilInfo& operator=(RPCUtilInfo &rpc_u); /* = operator overloading */ + void clearStats(); /* clears the information holded in RPCUtilInfo object */ + + inline NodeUtilInfo getNodeUtilInfo(int n) /* returns rpc state for nth node */ + { + assert(n < numNodes); + return *(nodeUtilInfo[n]); + } + inline UInt32 getNumNodes() /*returns number of nodes */ + { + return numNodes; + } +}; + +class RawRPCStat +{ +public : + UInt64 channelWait; // time waiting to get comm channel (nanoseconds) + UInt64 sendTime; // time to send message (nanoseconds) + UInt64 receiveTime; // time to receive message (nanoseconds) + UInt64 RPCLatency; // round trip time - RPC execution time (nanoseconds) + UInt32 dataSent; // length of payload sent, if any + UInt32 dataReceived; // length of payload received, if any + Boolean_t rdmaSend; // RPC sent via RMDA + Boolean_t rdmaReceive; // RPC received via RMDA + int nodeAddr; // node address + RawRPCStat() + { + channelWait = 0; + sendTime = 0; + receiveTime = 0; + RPCLatency = 0; + dataSent = 0; + dataReceived = 0; + rdmaSend = false; + rdmaReceive = false; + nodeAddr = 0; + } + ~RawRPCStat(){} +}; + +class RawRPCExec +{ +public : + UInt64 RPCExecTime; /* time to execute RPC on target node (nanoseconds)*/ + UInt16 RPCservice_no; /* RPC service number */ + UInt32 RPCmsg_type; /* RPC message type */ + RawRPCExec() + { + RPCExecTime = 0; + RPCservice_no = 0; + RPCmsg_type = 0; + } + ~RawRPCExec(){} +}; + +/* class to maintain network performance stats for raw type */ +class RPCRawUtilInfo +{ + friend class PollingHandler; + RawRPCExec *rpcExecP; /* array to maintain info for rpc exec objects*/ + RawRPCStat *rpcStatP; /*array to maintain info for rpc stat objects*/ + int rpcStatOverRunCount; /*count of buffer overruns for rpc stat*/ + int rpcExecOverRunCount; /*count of buffer overruns for rpc exec*/ + int rpcStatCount; /* rpc stat count*/ + int rpcExecCount; /* rpc exec count*/ +public: + RPCRawUtilInfo(MErrno *errP); + RPCRawUtilInfo(); + ~RPCRawUtilInfo(); + RPCRawUtilInfo& operator=(RPCRawUtilInfo &rpcRaw_u); + void clearStats(); + /* return nth rpc stat object */ + inline RawRPCStat *getRPCStatObj(int n) + { + assert(n < rpcStatCount); + return &rpcStatP[n]; + } + /* return nth rpc exec object */ + inline RawRPCExec *getRPCExecObj(int n) + { + assert(n < rpcExecCount); + return &rpcExecP[n]; + } + inline int getRpcStatOverRunCount() { return rpcStatOverRunCount; } + inline int getRpcExecOverRunCount() { return rpcExecOverRunCount; } + inline int getRpcStatCount() { return rpcStatCount; } + inline int getRpcExecCount() { return rpcExecCount; } +}; + +/* class to maintain network performance stats as per message sizes */ +class RPCSizeUtilInfo +{ + friend class PollingHandler; + /* array to maintain aggregated stat */ + AggregatedRPCPerfStat *agRpcPerfStatP[MAX_NUMBER_BUCKETS]; + int sizePerBucket[MAX_NUMBER_BUCKETS]; /* bucket sizes */ + int numBucketOutput; /* output available for num of buckets */ + + /* Set aggregated rpc performance stat for nth bucket*/ + inline void setRPCPerfStatObj(AggregatedRPCPerfStat *agPerfStat, int n) + { + assert(n < MAX_NUMBER_BUCKETS); + agRpcPerfStatP[n] = agPerfStat; + } +public: + RPCSizeUtilInfo(MErrno *errP); + RPCSizeUtilInfo(); + ~RPCSizeUtilInfo(); + RPCSizeUtilInfo& operator=(RPCSizeUtilInfo &rpc_u); + void clearStats(); + /* get aggregated performance stat for nth bucket */ + inline AggregatedRPCPerfStat getRPCPerfStatObj(int n) + { + assert(n < MAX_NUMBER_BUCKETS && n < numBucketOutput); + return *(agRpcPerfStatP[n]); + } + /* get bucket size for nth bucket */ + inline int getSizePerBucket(int n) + { + assert(n < MAX_NUMBER_BUCKETS && n < numBucketOutput); + return sizePerBucket[n]; + } + /* get total num of buckets available */ + inline int getNumBuckets() + { + return numBucketOutput; + } +}; + +/* class to maintain network performance stats as per message types */ +class RPCMsgUtilInfo +{ + friend class PollingHandler; + /*Aggregated performance stat per message type */ + AggregatedRPCPerfStat *agRpcPerfStatP[MAX_MSG_RPC]; + int numMsgOutput; /*num of message types available */ + + /* set aggaregated stats for nth agRpcPerfStatP */ + inline void setRPCPerfStatObj(AggregatedRPCPerfStat *agPerfStat, int n) + { + assert(n < MAX_MSG_RPC); + agRpcPerfStatP[n] = agPerfStat; + } +public: + RPCMsgUtilInfo(MErrno *errP); + RPCMsgUtilInfo(); + ~RPCMsgUtilInfo(); + RPCMsgUtilInfo& operator=(RPCMsgUtilInfo &rpc_u); + void clearStats(); + + /* get aggaregated stats for nth agRpcPerfStatP */ + inline AggregatedRPCPerfStat *getRPCMsgStatObj(int n) + { + assert(n < MAX_MSG_RPC && n < numMsgOutput); + return agRpcPerfStatP[n]; + } + inline int getNumMsg() + { + return numMsgOutput; + } +}; + +/* class to maintain stats for one secs for an object */ +class AggregatedRPCPerfStatPerSec +{ +public: + PerfSample secondP; /* array of PerfSample for nsecs */ + char objName[NAME_STRING_LEN]; /* Name of rpc object */ + AggregatedRPCPerfStatPerSec(); + ~AggregatedRPCPerfStatPerSec(); + AggregatedRPCPerfStatPerSec(const AggregatedRPCPerfStatPerSec& agPerfStat); /* copy constructor */ +}; + +/* class to maintain aggregated rpc stats info for one sec for all objects */ +class AggregatedRPCUtilInfoPerSec +{ + friend class PollingHandler; + AggregatedRPCPerfStatPerSec * agRpcPerfStatP[RPC_OBJECTS]; + UInt32 numObjects; + /* set the value of AggregatedRPCPerfStat for nth object */ + inline void setRPCPerfStatObj(AggregatedRPCPerfStatPerSec *agPerfStat, int n) + { + assert(n < RPC_OBJECTS); + agRpcPerfStatP[n] = agPerfStat; + } +public: + AggregatedRPCUtilInfoPerSec(); + ~AggregatedRPCUtilInfoPerSec(); + AggregatedRPCUtilInfoPerSec& operator=(AggregatedRPCUtilInfoPerSec &rpc_u); + void clearStats(); + /* return AggregatedRPCPerfStat for nth object */ + inline AggregatedRPCPerfStatPerSec getRPCPerfStatObj(int n) + { + assert(n < numObjects); + return *(agRpcPerfStatP[n]); + } + inline UInt32 getNumObjects() + { + return numObjects; + } +}; + +/* Cache hit miss statistics + + _response_ begin mmpmon chms + _mmpmon::chms_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1263846820 + _tu_ 373341 _dch_ 0 _dcm_ 0 _sch_ 43027 _scm_ 34 + _response_ end + +*/ + +/* Define a version number for CacheStatsInfo to allow + future changes in this structure. + */ +#define GPFS_CHMS_VERSION 1 + +class CacheStatsInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + char ipAddr[NAME_STRING_LEN]; + + UInt32 dataCacheHit; /* _dch_ */ + UInt32 dataCacheMiss; /* _dcm_ */ + UInt32 statCacheHit; /* _sch_ */ + UInt32 statCacheMiss; /* _scm_ */ + +public: + CacheStatsInfo(MErrno *errP); + CacheStatsInfo(); + ~CacheStatsInfo(); + + CacheStatsInfo& operator=(CacheStatsInfo &c); + + void clearStats(); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + inline char *getIpAddr() { return ipAddr; } + inline UInt32 getDataCacheHit() { return dataCacheHit; } + inline UInt32 getDataCacheMiss() { return dataCacheMiss; } + inline UInt32 getStatCacheHit() { return statCacheHit; } + inline UInt32 getStatCacheMiss() { return statCacheMiss; } +}; + +/* + * PANACHE statistics + _response_ begin mmpmon pncs + _mmpmon::pncs_ _n_ 192.168.115.156 _nn_ hs21n20 _rc_ 0 _t_ 1263954355 + _tu_ 209718 _fs_ fs1 _fset_ ro + _br_ 0 _bw_ 0 _ws_ 0 _wl_ 0 _wa_ 0 _ne_ 0 _nf_ 0 _ns_ 0 _nr_ 0 + _ncmd_ 20 _q_ 0 _i_ 0 _c_ 0 _e_ 0 _f_ 0 _n_ 0 + _q_ 0 _i_ 0 _c_ 0 _e_ 0 _f_ 0 _n_ 0 + _q_ 0 _i_ 0 _c_ 0 _e_ 0 _f_ 0 _n_ 0 + ... + _q_ 0 _i_ 0 _c_ 0 _e_ 0 _f_ 0 _n_ 0 + _q_ 0 _i_ 0 _c_ 0 _e_ 0 _f_ 0 _n_ 0 + _response_ end + * + */ +/********************************/ +/* Define a version number for verbsServerStatsInfo to allow + future changes in this structure. + */ +#define GPFS_VERBSSERVERSTATS_VERSION 1 + +class VerbsServerStatsInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + + char destination[NAME_STRING_LEN]; + char state[NAME_STRING_LEN]; + UInt64 curRdma; + UInt64 waitRdma; + UInt64 rdmaRead; + UInt64 rdmaWrite; + UInt64 rdmaReadKb; + UInt64 rdmaWriteKb; + UInt32 device; + UInt32 port; + +public: + VerbsServerStatsInfo(MErrno *errP); + ~VerbsServerStatsInfo(); + + VerbsServerStatsInfo& operator=(VerbsServerStatsInfo &c); + + void clearStats(); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + + inline char *getDestination() { return destination; } + inline char *getState() { return state; } + + inline UInt64 getCurRdma() { return curRdma; } + inline UInt64 getWaitRdma() { return waitRdma; } + inline UInt64 getRdmaRead() { return rdmaRead; } + inline UInt64 getRdmaWrite() { return rdmaWrite; } + inline UInt64 getRdmaReadKb() { return rdmaReadKb; } + inline UInt64 getRdmaWriteKb() { return rdmaWriteKb; } + inline UInt32 getDevice() { return device; } + inline UInt32 getportNum() { return port; } + +}; +/******************************/ + +/******************************/ + +/* Define a version number for verbsClientStatsInfo to allow + future changes in this structure. + */ +#define GPFS_VERBSCLIENTSTATS_VERSION 1 + +class VerbsClientStatsInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + + char destination[NAME_STRING_LEN]; + char state[NAME_STRING_LEN]; + UInt64 curReadWrite; + UInt64 peakReadWrite; + UInt64 fileRead; + UInt64 fileWrite; + UInt64 fileReadKb; + UInt64 fileWriteKb; + UInt32 device; + UInt32 port; + +public: + VerbsClientStatsInfo(MErrno *errP); + ~VerbsClientStatsInfo(); + + VerbsClientStatsInfo& operator=(VerbsClientStatsInfo &c); + + void clearStats(); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + + inline char *getDestination() { return destination; } + inline char *getState() { return state; } + + inline UInt64 getCurReadWrite() { return curReadWrite; } + inline UInt64 getPeakReadWrite() { return peakReadWrite; } + inline UInt64 getFileRead() { return fileRead; } + inline UInt64 getFileWrite() { return fileWrite; } + inline UInt64 getFileReadKb() { return fileReadKb; } + inline UInt64 getFileWriteKb() { return fileWriteKb; } + inline UInt32 getDevice() { return device; } + inline UInt32 getportNum() { return port; } + +}; + +/****************************/ + +/* Define a version number for tscommCfgInfo to allow + future changes in this structure. + */ +#define GPFS_TSCOMMCFG_VERSION 1 + +class TscommCfgInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + + UInt32 portNum; + UInt32 nodeNum; + char nodeAddr[NAME_STRING_LEN]; + char addrList[ADDRLIST_NODES * NAME_STRING_LEN]; + UInt32 curDaemonVer; + UInt32 comptDmnVer; + UInt32 maxComptVer; + UInt32 maxFeatureLevel; + +public: + TscommCfgInfo(MErrno *errP); + ~TscommCfgInfo(); + + TscommCfgInfo& operator=(TscommCfgInfo &c); + + void clearStats(); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + + inline char *getNodeAddr() { return nodeAddr; } + inline char *getAddrList() { return addrList; } + + inline UInt32 getportNum() { return portNum; } + inline UInt32 getnodeNum() { return nodeNum; } + inline UInt32 getcurDaemonVer() { return curDaemonVer; } + inline UInt32 getcomptDmnVer() { return comptDmnVer; } + inline UInt32 getmaxComptVer() { return maxComptVer; } + inline UInt32 getmaxFeatureLevel() { return maxFeatureLevel; } + +}; + +/* Define a version number for ClusterCfgInfo to allow + future changes in this structure. + */ +#define GPFS_CLUSTERCFG_VERSION 1 + +class ClusterCfgInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + + char clusterId[NAME_STRING_LEN]; + UInt32 nodeNumber; + char nodeAddr[NAME_STRING_LEN]; + char hostName[NAME_STRING_LEN]; + char ipAddr[NAME_STRING_LEN]; + char admin[NAME_STRING_LEN]; + char gpnTrans[NAME_STRING_LEN]; + char gpnStatus[NAME_STRING_LEN]; + char nodeStatus[NAME_STRING_LEN]; + UInt32 joinSeq; + UInt32 failCnt; + UInt32 fsManaged; + UInt32 cnfsGrp; + UInt32 readChkSum; + UInt32 writeChkSum; + char lastFail[NAME_STRING_LEN]; + +public: + ClusterCfgInfo(MErrno *errP); + ~ClusterCfgInfo(); + + ClusterCfgInfo& operator=(ClusterCfgInfo &c); + + void clearStats(); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + + inline char *getclusterId() { return clusterId; } + inline UInt32 getnodeNumber() { return nodeNumber; } + inline char *getNodeAddr() { return nodeAddr; } + inline char *getHostName() { return hostName; } + inline char *getIpAddr() { return ipAddr; } + inline char *getAdmin() { return admin; } + inline char *getGpnTrans() { return gpnTrans; } + inline char *getGpnStatus() { return gpnStatus; } + inline char *getNodeStatus() { return nodeStatus; } + + inline UInt32 getjoinSeq() { return joinSeq; } + inline UInt32 getfailCnt() { return failCnt; } + inline UInt32 getfsManaged() { return fsManaged; } + inline UInt32 getcnfsGrp() { return cnfsGrp; } + inline UInt32 getreadChkSum() { return readChkSum; } + inline UInt32 getwriteChkSum() { return writeChkSum; } + inline char *getLastFail() { return lastFail; } + +}; + +/* Define a version number for PCacheStatsInfo to allow + future changes in this structure. + */ +#define GPFS_PNCS_VERSION 1 + +class PCacheStatsInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + char ipAddr[NAME_STRING_LEN]; + + char fsName[NAME_STRING_LEN]; + char fsetName[NAME_STRING_LEN]; + + UInt64 bytesRead; + UInt64 bytesWritten; + UInt32 numExpire; /* msgs exec due to timer */ + UInt32 numForce; /* msgs exec due to Q limit, etc */ + UInt32 numSync; /* msgs exec due to sync cmd */ + UInt32 numRevoke; /* msgs exec due to revoke */ + UInt32 shortest_waitTime; /* in seconds */ + UInt32 longest_waitTime; /* in seconds */ + UInt32 average_waitTime; /* in seconds */ + UInt32 numPcacheCmds; + pCacheCmdInfo_t pCacheCmds[MAX_PCACHE_CMD_INFO]; + UInt64 numMsgExecuted; + UInt32 numHomeConn; + UInt32 numHomeDisc; + UInt32 numFsetExp; + +public: + PCacheStatsInfo(MErrno *errP); + ~PCacheStatsInfo(); + + PCacheStatsInfo& operator=(PCacheStatsInfo &c); + + void clearStats(); + + pCacheCmdInfo_t *getPCacheCmdInfoP(int cmd); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + inline char *getIpAddr() { return ipAddr; } + inline char *getFsName() { return fsName; } + inline char *getFsetName() { return fsetName; } + + inline UInt64 getBytesRead() { return bytesRead; } + inline UInt64 getBytesWritten() { return bytesWritten; } + inline UInt32 getNumExpire() { return numExpire; } + inline UInt32 getNumForce() { return numForce; } + inline UInt32 getNumSync() { return numSync; } + inline UInt32 getNumRevoke() { return numRevoke; } + inline UInt32 getShortest_waitTime() { return shortest_waitTime; } + inline UInt32 getLongest_waitTime() { return longest_waitTime; } + inline UInt32 getAverage_waitTime() { return average_waitTime; } + inline UInt32 getNumPacheCmds() { return numPcacheCmds; } + inline UInt64 getNumMsgExecuted() { return numMsgExecuted; } + inline UInt32 getNumHomeConn() { return numHomeConn; } + inline UInt32 getNumHomeDisc() { return numHomeDisc; } + inline UInt32 getNumFsetExp() { return numFsetExp; } + +}; + +/* + NSD server statistics + + mmpmon nsd_dst + _response_ begin mmpmon nsd_dst + _mmpmon::nsd_dst_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1336694189 _tu_ 901270 _dev_ /dev/rhdisk6 _d_ gpfs6nsd + _r_ _ops_ 127 _b_ 6645760 _tw_ 0.091637 + _w_ _ops_ 29 _b_ 98304 _tw_ 0.170669 + _mmpmon::nsd_dst_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1336694189 _tu_ 901291 _dev_ /dev/rhdisk7 _d_ gpfs7nsd + _r_ _ops_ 51 _b_ 116224 _tw_ 0.014138 + _w_ _ops_ 22 _b_ 33792 _tw_ 0.008239 + _response_ end + + non-server: + + _response_ begin mmpmon nsd_dst + _mmpmon::nsd_dst_ _n_ 192.168.1.10 _nn_ enterprise _rc_ 1 _t_ 1336693954 _tu_ 173891 _dev_ - + _response_ end + + */ +#define GPFS_NSD_DST_VERSION 1 + +class NsdServerStatsInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + char ipAddr[NAME_STRING_LEN]; + + char devName[NAME_STRING_LEN]; /* device name of the disk */ + char nsdName[NAME_STRING_LEN]; /* NSD name */ + + UInt32 readOps; /* number of disk read operations */ + UInt32 writeOps; /* number of disk write operations */ + + UInt64 bytesRead; /* number of bytes read from disk */ + UInt64 bytesWritten; /* number of bytes written to disk */ + + double readTime; /* total time waiting for disk operations, in seconds */ + double writeTime; /* total time waiting for disk operations, in seconds */ + +public: + NsdServerStatsInfo(MErrno *errP); + ~NsdServerStatsInfo(); + + NsdServerStatsInfo& operator=(NsdServerStatsInfo &c); + + void clearStats(); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + inline char *getIpAddr() { return ipAddr; } + inline char *getDevName() { return devName; } + inline char *getNsdName() { return nsdName; } + + inline double getReadTime() { return readTime; } + inline double getWriteTime() { return writeTime; } + inline UInt64 getBytesRead() { return bytesRead; } + inline UInt64 getBytesWritten() { return bytesWritten; } + inline UInt32 getReadOps() { return readOps; } + inline UInt32 getWriteOps() { return writeOps; } +}; + +/* + File system IO stats: list one set of application view stats + for each file system on the node. + + mmpmon fis + _response_ begin mmpmon fis + _mmpmon::fis_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1337051301 _tu_ 718946 _cl_ voyager.gpfs.net _fs_ fs1 _d_ 6 _br_ 33622 _bw_ 0 _oc_ 6 _cc_ 6 _rdc_ 17 _wc_ 0 _dir_ 2 _iu_ 17 + _mmpmon::fis_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1337051301 _tu_ 718946 _cl_ voyager.gpfs.net _fs_ fs3 _d_ 2 _br_ 130881 _bw_ 0 _oc_ 11 _cc_ 11 _rdc_ 47 _wc_ 0 _dir_ 2 _iu_ 7 + _response_ end + + When no file systems are mounted: + + mmpmon fis + _response_ begin mmpmon fis + _mmpmon::fis_ _n_ 192.168.1.8 _nn_ voyager _rc_ 1 _t_ 1337052131 _tu_ 269656 _cl_ - _fs_ - + _response_ end + + */ +#define GPFS_FIOS_VERSION 1 + +class FsIoStatsInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + UInt32 diskCount; /* number of disks in the file system */ + char ipAddr[NAME_STRING_LEN]; + + char fsName[NAME_STRING_LEN]; /* file system */ + + UInt64 bytesRead; /* number of bytes read from disk (disk and cache) */ + UInt64 bytesWritten;/* number of bytes written, to both disk and cache */ + + UInt32 openCalls; /* number of open() call requests serviced by GPFS */ + UInt32 closeCalls; /* number of close() call requests serviced by GPFS */ + UInt32 readCalls; /* number of application read requests serviced by GPFS */ + UInt32 writeCalls; /* number of write requests serviced by GPFS */ + UInt32 readdirCalls;/* number of readdir() call requests serviced by GPFS */ + + UInt64 inodeUpdateCalls; /* number of inode updates to disk */ + +public: + FsIoStatsInfo(MErrno *errP); + ~FsIoStatsInfo(); + + FsIoStatsInfo& operator=(FsIoStatsInfo &c); + + void clearStats(); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + inline char *getIpAddr() { return ipAddr; } + inline char *getFsName() { return fsName; } + + inline UInt32 getDiskCount() { return diskCount; } + inline UInt64 getBytesRead() { return bytesRead; } + inline UInt64 getBytesWritten() { return bytesWritten; } + + inline UInt32 getOpenCalls() { return openCalls; } + inline UInt32 getCloseCalls() { return closeCalls; } + inline UInt32 getReadCalls() { return readCalls; } + inline UInt32 getWriteCalls() { return writeCalls; } + inline UInt32 getReaddirCalls() { return readdirCalls; } + inline UInt64 getInodeUpdateCalls() { return inodeUpdateCalls; } +}; + +/* + Storage pool IO stats: lists one set of application-view stats for + each storage pool on the node. + + mmpmon plios + _response_ begin mmpmon plios + _mmpmon::plios_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1337053867 _tu_ 242440 _cl_ voyager.gpfs.net _fs_ fs1 _pl_ system _d_ 2 _br_ 595314176 _bw_ 1624064 + _mmpmon::plios_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1337053867 _tu_ 242440 _cl_ voyager.gpfs.net _fs_ fs1 _pl_ poolA _d_ 3 _br_ 35840 _bw_ 0 + _mmpmon::plios_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1337053867 _tu_ 242440 _cl_ voyager.gpfs.net _fs_ fs3 _pl_ system _d_ 2 _br_ 56961024 _bw_ 18432 + _response_ end + + + When no file systems are mounted: + + mmpmon plios + _response_ begin mmpmon plios + _mmpmon::plios_ _n_ 192.168.1.8 _nn_ voyager _rc_ 1 _t_ 1337053946 _tu_ 596610 _cl_ - _fs_ - + _response_ end + + */ +#define GPFS_PLIOS_VERSION 1 + +class PoolIoStatsInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + char ipAddr[NAME_STRING_LEN]; + + char fsName[NAME_STRING_LEN]; /* file system */ + char poolName[NAME_STRING_LEN]; /* pool name */ + + UInt32 diskCount; /* number of disks in the file system */ + + UInt64 bytesRead; /* number of bytes read */ + UInt64 bytesWritten; /* number of bytes written */ + +public: + PoolIoStatsInfo(MErrno *errP); + ~PoolIoStatsInfo(); + + PoolIoStatsInfo& operator=(PoolIoStatsInfo &c); + + void clearStats(); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + inline char *getIpAddr() { return ipAddr; } + inline char *getFsName() { return fsName; } + inline char *getPoolName() { return poolName; } + + inline UInt32 getDiskCount() { return diskCount; } + + inline UInt64 getBytesRead() { return bytesRead; } + inline UInt64 getBytesWritten() { return bytesWritten; } +}; + + +/* + Disk Stats + I/O statistics taken over all mounted file systems as seen by the + node and presented as total values for ecah disk in each file system. + + mmpmon ds + _response_ begin mmpmon ds + _mmpmon::ds_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1339704723 _tu_ 718796 _cl_ voyager.gpfs.net _fs_ fs3 _d_ gpfs8nsd + _r_ _ops_ 13 _b_ 46080 _tw_ 0.002274 _qt_ 0.002274 _stw_ 0.000133 _sqt_ 0.000133 _ltw_ 0.000279 _lqt_ 0.000279 + _w_ _ops_ 2 _b_ 1024 _tw_ 0.000715 _qt_ 0.000715 _stw_ 0.000349 _sqt_ 0.000349 _ltw_ 0.000366 _lqt_ 0.000366 + _mmpmon::ds_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1339704723 _tu_ 718824 _cl_ voyager.gpfs.net _fs_ fs3 _d_ gpfs10nsd + _r_ _ops_ 5 _b_ 2560 _tw_ 0.000809 _qt_ 0.000809 _stw_ 0.000151 _sqt_ 0.000151 _ltw_ 0.000174 _lqt_ 0.000174 + _w_ _ops_ 2 _b_ 1024 _tw_ 0.000736 _qt_ 0.000736 _stw_ 0.000361 _sqt_ 0.000361 _ltw_ 0.000375 _lqt_ 0.000375 + _mmpmon::ds_ _n_ 192.168.1.8 _nn_ voyager _rc_ 0 _t_ 1339704723 _tu_ 718855 _cl_ voyager.gpfs.net _fs_ fs6 _d_ gpfs18nsd + _r_ _ops_ 3 _b_ 17408 _tw_ 0.000645 _qt_ 0.000645 _stw_ 0.000145 _sqt_ 0.000145 _ltw_ 0.000260 _lqt_ 0.000260 + _w_ _ops_ 0 _b_ 0 _tw_ 0.000000 _qt_ 0.000000 _stw_ 0.000000 _sqt_ 0.000000 _ltw_ 0.000000 _lqt_ 0.000000 + _response_ end + + When no file systems are mounted: + + mmpmon ds + _response_ begin mmpmon ds + _mmpmon::ds_ _n_ 192.168.1.8 _nn_ voyager _rc_ 1 _t_ 1339704802 _tu_ 927135 _cl_ - _fs_ - + _response_ end + + */ +#define GPFS_DS_VERSION 1 + +class DiskStatsInfo +{ + friend class PollingHandler; + + Int32 version; /* version of this stat structure */ + Int32 length; /* size of this structure */ + Int32 rc; /* return code from mmpmon */ + char ipAddr[NAME_STRING_LEN]; + + char fsName[NAME_STRING_LEN]; /* file system */ + char diskName[NAME_STRING_LEN]; /* disk name */ + char clusterName[NAME_STRING_LEN]; /* clusterName */ + + UInt32 readOps; /* number of disk read operations */ + UInt32 writeOps; /* number of disk write operations */ + + UInt64 bytesRead; /* number of bytes read from disk */ + UInt64 bytesWritten; /* number of bytes written to disk */ + + /* Times are in seconds. */ + double readTime; /* total time waiting for disk operations, in seconds */ + double writeTime; /* total time waiting for disk operations, in seconds */ + + double queueReadTime; /* total time spent between being queued for a disk + operation and the completion of that operation */ + double queueWriteTime; /* total time spent between being queued for a disk + operation and the completion of that operation */ + + double shortestReadTime; /* shortest time spent waiting for a disk oper */ + double shortestWriteTime; + + double shortestQueueReadTime; /* shortest time between being queued for a disk + operation and the completion of that oper. */ + double shortestQueueWriteTime; + + double longestReadTime; /* longest spent waiting for a disk oper */ + double longestWriteTime; + + double longestQueueReadTime; /* longest time between being queued for a disk + operation and the completion of that oper. */ + double longestQueueWriteTime; + +public: + DiskStatsInfo(MErrno *errP); + ~DiskStatsInfo(); + + DiskStatsInfo& operator=(DiskStatsInfo &c); + + void clearStats(); + + inline Int32 getVersion() { return version; } + inline Int32 getLength() { return length; } + inline Int32 getRc() { return rc; } + inline char *getFsName() { return fsName; } + inline char *getDiskName() { return diskName; } + inline char *getIpAddr() { return ipAddr; } + inline char *getClusterName() { return clusterName; } + + inline UInt32 getReadOps() { return readOps; } + inline UInt32 getWriteOps() { return writeOps; } + inline UInt64 getBytesRead() { return bytesRead; } + inline UInt64 getBytesWritten() { return bytesWritten; } + + inline double getReadTime() { return readTime; } + inline double getWriteTime() { return writeTime; } + inline double getQueueReadTime() { return queueReadTime; } + inline double getQueueWriteTime() { return queueWriteTime; } + inline double getShortestReadTime() { return shortestReadTime; } + inline double getShortestWriteTime() { return shortestWriteTime; } + inline double getShortestQueueReadTime() { return shortestQueueReadTime; } + inline double getShortestQueueWriteTime() { return shortestQueueWriteTime; } + inline double getLongestReadTime() { return longestReadTime; } + inline double getLongestWriteTime() { return longestWriteTime; } + inline double getLongestQueueReadTime() { return longestQueueReadTime; } + inline double getLongestQueueWriteTime() { return longestQueueWriteTime; } +}; + + +/* Node information */ +class NodeInfo +{ + friend class PollingHandler; + + char name[NAME_STRING_LEN]; + char ipAddr[NAME_STRING_LEN]; + char platform[NAME_STRING_LEN]; + char endian[NAME_STRING_LEN]; + char type[NAME_STRING_LEN]; + char osname[NAME_STRING_LEN]; + char admin[NAME_STRING_LEN]; + char status[NAME_STRING_LEN]; + char version[NAME_STRING_LEN]; + UInt32 failureCount; + UInt32 threadWait; + char healthy[NAME_STRING_LEN]; + char diagnosis[NAME_STRING_LEN]; + UInt64 pagePoolSize; + UInt32 prefetchThreads; + UInt32 maxMBPS; + UInt32 maxFilesToCache; + UInt32 maxStatCache; + UInt32 worker1Threads; + UInt32 dmapiEventTimeout; + UInt32 dmapiMountTimeout; + UInt32 dmapiSessFailureTimeout; + UInt32 nsdServerWaitTimeWindowOnMount; + UInt32 nsdServerWaitTimeForMount; + char unmountOnDiskFail[32]; + + double readTime; + double writeTime; + + Boolean_t found; + + std::vectordiskAccessItems; + + void copyDiskAccesses(NodeInfo *nodeP); + int getDiskAccessIndex(char *nameP); + + /* I/O statistics counted by context */ + IocStatsInfo *iocStatsP; + + /* vfs statistics */ + VfsStatsInfo *vfsStatsP; + + /* thread pool utilization */ + ThreadUtilInfo *threadUtilP; + + /* rpc performance stat */ + RPCUtilInfo *rpcUtilP; + + /* rpc raw stats */ + RPCRawUtilInfo *rpcRawUtilP; + + /* rpc performance stats according to size */ + RPCSizeUtilInfo *rpcSizeUtilP; + + /* rpc performance stats according to size */ + RPCMsgUtilInfo *rpcMsgUtilP; + + /* aggregation of rpc performance stats per sec on local node */ + AggregatedRPCUtilInfoPerSec *rpcUtilPerSecP; + + /* cache hit/miss stats */ + CacheStatsInfo *cacheStatsP; + + std::vectorPCacheStatsItems; + + TscommCfgInfo *tscommCfgP; + + VerbsClientStatsInfo *verbsClientP; + VerbsServerStatsInfo *verbsServerP; + +public: + NodeInfo(MErrno *errP); + + ~NodeInfo(); + + NodeInfo& operator=(NodeInfo &n); + void clearStats(); + + /* Node info from SDR */ + inline char *getName() { return name; } + inline char *getIpAddr() { return ipAddr; } + inline char *getType() { return type; } + inline char *getEndian() { return endian; } + inline char *getOsName() { return osname; }; + inline char *getVersion() { return version; } + inline char *getPlatform() { return platform; } + + /* Node info from EE get nodes */ + inline char *getAdmin() { return admin; } + inline char *getStatus() { return status; } + inline UInt32 getFailureCount() { return failureCount; } + inline UInt32 getThreadWait() { return threadWait; } + inline char *getHealthy() { return healthy; } + inline char *getDiagnosis() { return diagnosis; } + + inline UInt64 getPagePoolSize() { return pagePoolSize; } + inline UInt32 getPrefetchThreads() { return prefetchThreads; } + inline UInt32 getMaxMBPS() { return maxMBPS; } + inline UInt32 getMaxFilesToCache() { return maxFilesToCache; } + inline UInt32 getMaxStatCache() { return maxStatCache; } + inline UInt32 getWorker1Threads() { return worker1Threads; } + inline UInt32 getDmapiEventTimeout() { return dmapiEventTimeout; } + inline UInt32 getDmapiMountTimeout() { return dmapiMountTimeout; } + inline UInt32 getDmapiSessFailureTimeout() { return dmapiSessFailureTimeout; } + inline UInt32 getNsdServerWaitTimeWindowOnMount() { return nsdServerWaitTimeWindowOnMount; } + inline UInt32 getNsdServerWaitTimeForMount() { return nsdServerWaitTimeForMount; } + inline char *getUnmountOnDiskFail() { return unmountOnDiskFail; } + + inline UInt32 getNumDiskAccesses() { return diskAccessItems.size(); } + inline DiskAccessInfo *getDiskAccess(int d) { return diskAccessItems.at(d); } + + inline VfsStatsInfo *getVfsStatsInfo() { return vfsStatsP; } + inline IocStatsInfo *getIocStatsInfo() { return iocStatsP; } + inline ThreadUtilInfo *getThreadUtilInfo() { return threadUtilP; } + inline RPCUtilInfo *getRPCUtilInfo() { return rpcUtilP; } + inline RPCRawUtilInfo *getRPCRawUtilInfo() { return rpcRawUtilP; } + inline RPCSizeUtilInfo *getRPCSizeUtilInfo() { return rpcSizeUtilP; } + inline RPCMsgUtilInfo *getRPCMsgUtilInfo() { return rpcMsgUtilP; } + inline AggregatedRPCUtilInfoPerSec *getAggregatedRPCUtilInfoPerSec() { return rpcUtilPerSecP; } + inline CacheStatsInfo *getCacheStatsInfo() { return cacheStatsP; } + + inline UInt32 getNumPcacheFsets() { return PCacheStatsItems.size(); } + inline PCacheStatsInfo *getPcacheFset(int d) { return PCacheStatsItems.at(d); } + + inline TscommCfgInfo *getTscommCfgInfoP() { return tscommCfgP;} + inline VerbsClientStatsInfo *getVerbsClientStatsInfoP() { return verbsClientP;} + inline VerbsServerStatsInfo *getVerbsServerStatsInfoP() { return verbsServerP;} + + /* Currently unused */ + inline double getReadTime() { return readTime; } + inline double getWriteTime() { return writeTime; } +}; + +/* Cluster information */ +class ClusterInfo +{ + friend class PollingHandler; + + /* parsable from mmsdrfs */ + char name[NAME_STRING_LEN]; + char id[NAME_STRING_LEN]; + char type[NAME_STRING_LEN]; + char minReleaseLevel[NAME_STRING_LEN]; + char uidDomain[NAME_STRING_LEN]; + char remoteShellCommand[NAME_STRING_LEN]; + char remoteFileCopyCommand[NAME_STRING_LEN]; + char primaryServer[NAME_STRING_LEN]; + char secondaryServer[NAME_STRING_LEN]; + + UInt32 maxBlockSize; + UInt32 distributedTokenServer; + /*UInt32 useDiskLease;*/ + UInt32 failureDetectionTime; + UInt32 tcpPort; + UInt32 minMissedPingTimeout; + UInt32 maxMissedPingTimeout; + + UInt32 sdrfsGenNumber; + + struct timeval clusterRefreshTime; + + /* Store the list of node name - primary key */ + std::vectornodeItems; + struct timeval nodeRefreshTime; + + /* Store the list of file system name - primary key */ + std::vectorfsItems; + struct timeval FSRefreshTime; + struct timeval FSPerfRefreshTime; + + std::vectorfreeDiskItems; + + /* Store the list of ClusterCfgItems */ + std::listClusterCfgItems; + + void copyNodes(ClusterInfo *clP); + void copyFS(ClusterInfo *clP); + void copyFreeDisks(ClusterInfo *clP); + int getNodeInfoIndex(char *ipAddrP); + int getNodeInfoIndexByName(char *nameP); + int getFilesystemInfoIndex(char *nameP); + int getFreeDiskInfoIndex(char *nameP); + + struct timeval diskSDRRefreshTime; + +public: + ClusterInfo(MErrno *errP); + + ~ClusterInfo(); + + ClusterInfo& operator=(ClusterInfo &cl); + + /* member accessors */ + inline char *getName() { return name; } + inline char *getId() { return id; } + inline char *getType() { return type; } + inline char *getMinReleaseLevel() { return minReleaseLevel; } + inline char *getUidDomain() { return uidDomain; } + inline char *getRemoteShellCommand() { return remoteShellCommand; } + inline char *getRemoteFileCopyCommand() { return remoteFileCopyCommand; } + inline char *getPrimaryServer() { return primaryServer; } + inline char *getSecondaryServer() { return secondaryServer; } + inline UInt32 getMaxBlockSize() { return maxBlockSize; } + inline struct timeval getClusterRefreshTime() { return clusterRefreshTime; } + inline UInt32 getSdrfsGenNumber() { return sdrfsGenNumber; } + + inline UInt32 getNumNodes() { return nodeItems.size(); } + inline NodeInfo *getNode(int n) { return nodeItems.at(n); } + inline struct timeval getNodeRefreshTime() { return nodeRefreshTime; } + inline UInt32 getNumFilesystems() { return fsItems.size(); } + inline FilesystemInfo *getFilesystem(int f) { return fsItems.at(f); } + inline struct timeval getFSRefreshTime() { return FSRefreshTime; } + inline struct timeval getFSPerfRefreshTime() { return FSPerfRefreshTime; } + inline UInt32 getDistributedTokenServer() { return distributedTokenServer; } + inline UInt32 getFailureDetectionTime() { return failureDetectionTime; } + inline UInt32 getTCPPort() { return tcpPort; } + inline UInt32 getMinMissedPingTimeout() { return minMissedPingTimeout; } + inline UInt32 getMaxMissedPingTimeout() { return maxMissedPingTimeout; } + inline UInt32 getNumFreeDisks() { return freeDiskItems.size(); } + inline DiskInfo *getFreeDisk(int d) { return freeDiskItems.at(d); } + + inline UInt32 getNumClusterCfgNodes() { return ClusterCfgItems.size(); } + inline ClusterCfgInfo *getClusterCfgInfoP(int d) + { + int cnt = 0; + std::list::const_iterator iterator; + for (iterator = ClusterCfgItems.begin(); iterator != ClusterCfgItems.end(); + ++iterator, cnt++) { + if (cnt == d) + return *iterator; + } + return (ClusterCfgInfo *) NULL; + } +}; + +/* Cluster status information */ +class ClusterStatus +{ + friend class PollingHandler; + +public: + char managerNode[NAME_STRING_LEN]; + char managerIpAddr[NAME_STRING_LEN]; + UInt32 nLocalNodes; /* number of nodes defined in the cluster */ + UInt32 nLocalJoined; /* number of local nodes active in the cluster */ + UInt32 nRmtJoined; /* number of remote nodes joined in this cluster */ + UInt32 nQNodesInCluster; /* number of quorum nodes defined in the cluster */ + UInt32 nQNodesJoined; /* number of quorum nodes active in the cluster */ + UInt32 cfgMinQuorumNodes;/* minimum no of nodes to reach quorum */ + UInt32 quorumAchieved ; /* Quorum achieved (=1), not achieved (=0)*/ + +public: + ClusterStatus(); + ~ClusterStatus(); + + void init(); + + /* member accessors */ + inline char *getManagerNode() { return managerNode; } + inline char *getManagerIpAddr() { return managerIpAddr; } + inline UInt32 getNLocalNodes() { return nLocalNodes; } + inline UInt32 getNLocalJoined() { return nLocalJoined; } + inline UInt32 getNRmtJoined() { return nRmtJoined; } + inline UInt32 getNQNodesInCluster() { return nQNodesInCluster; } + inline UInt32 getNQNodesJoined() { return nQNodesJoined; } + inline UInt32 getCfgMinQuorumNodes() { return cfgMinQuorumNodes; } + inline UInt32 getQuorumAchieved() { return quorumAchieved; } +}; + +/* MODS_START */ +class FileSet +{ + + friend class PollingHandler; + +public: + + UInt32 gpfsFilesetVersion; + char gpfsFilesetName[NAME_STRING_LEN]; + char gpfsFileSystemName[NAME_STRING_LEN]; + char gpfsFilesetID[NAME_STRING_LEN]; + char gpfsFilesetRootINode[NAME_STRING_LEN]; + char gpfsFilesetStatus[NAME_STRING_LEN]; + char gpfsFilesetPath[PATH_STRING_LEN]; + char gpfsFilesetParentID[NAME_STRING_LEN]; + UInt64 gpfsFilesetINodes; + char gpfsFilesetCreated[TIME_STAMP_CHARS]; + UInt64 gpfsFilesetDataInKB; + char gpfsFilesetComment[NAME_STRING_LEN]; + bool gpfsFilesetIsLinked; + bool gpfsFilesetHasComment; + + // methods + inline char* getName() { return gpfsFilesetName; } + inline char* getId() { return gpfsFilesetID; } + inline char* getRootINode() { return gpfsFilesetRootINode; } + inline char* getParentId() { return gpfsFilesetParentID; } + inline UInt64 getINodes() { return gpfsFilesetINodes; } + inline UInt64 getData() { return gpfsFilesetDataInKB; } + inline char* getComment() { return gpfsFilesetComment; } + inline char* getFSName() { return gpfsFileSystemName; } + inline char* getStatus() { return gpfsFilesetStatus; } + inline char* getPath() { return gpfsFilesetPath; } + inline char* getCreated() { return gpfsFilesetCreated; } + inline UInt32 getVersion() { return gpfsFilesetVersion; } + +private: +}; + +class User +{ + friend class PollingHandler; +public: + + User() + { + hasName = false; + } + + char gpfsUserName[NAME_STRING_LEN]; + char gpfsUserFileSystemName[NAME_STRING_LEN]; + char gpfsUserClusterName[NAME_STRING_LEN]; + char gpfsUserHomePath[NAME_STRING_LEN]; + UInt32 gpfsUserId; + UInt32 gpfsMainGroupId; + + // temporary flag to show that this user has a name + bool hasName; + + inline char* getName() { return gpfsUserName; } + inline char* getFSName() { return gpfsUserFileSystemName; } + inline char* getCSName() { return gpfsUserClusterName; } + inline char* getHomePath() { return gpfsUserHomePath; } + inline UInt32 getUserId() { return gpfsUserId; } + inline UInt32 getMainGroupId() { return gpfsMainGroupId; } + +private: +}; + +class Group +{ + friend class PollingHandler; +public: + + Group() { hasName = false; } + + char gpfsGroupName[NAME_STRING_LEN]; + char gpfsGroupFileSystemName[NAME_STRING_LEN]; + char gpfsGroupClusterName[NAME_STRING_LEN]; + UInt32 gpfsGroupId; + + // temporary flag to show that this group has a name + bool hasName; + + inline char* getName() { return gpfsGroupName; } + inline char* getFSName() { return gpfsGroupFileSystemName; } + inline char* getCSName() { return gpfsGroupClusterName; } + inline UInt32 getGroupId() { return gpfsGroupId; } + +private: +}; + +/* DJ_MODS_START */ +class FileOrDirOwner +{ + + friend class PollingHandler; + +public: + + char osOwnerName[NAME_STRING_LEN]; + char osGroupName[NAME_STRING_LEN]; + char osFileOrDirList[NAME_STRING_LEN]; // ',' separated list..same as chown + Boolean_t dir; + Boolean_t jnxn; + + inline char* getOwnerName() { return osOwnerName; } + inline char* getGroupName() { return osGroupName; } + inline char* getFileOrDirList() { return osFileOrDirList; } + inline Boolean_t isDirectory() { return dir; } + inline Boolean_t isJnxn() { return jnxn; } + +private: +}; +/* DJ_MODS_END*/ + +class Quota +{ + +public: + + Quota() + { + gpfsQuotaHeader = 0; + gpfsQuotaVersion = 0; + gpfsQuotaType = 0; + gpfsQuotaID = 0; + gpfsQuotaBlockUsage = 0; + gpfsQuotaBlockQuota = 0; + gpfsQuotaBlockLimit = 0; + gpfsQuotaBlockInDoubt = 0; + gpfsQuotaFilesUsage = 0; + gpfsQuotaFilesQuota = 0; + gpfsQuotaFilesLimit = 0; + gpfsQuotaFilesInDoubt = 0; + gpfsQuotaFilesInDoubt = 0; + + gpfsQuotaClusterName.clear(); + gpfsQuotaFileSystemName.clear(); + gpfsQuotaEntityName.clear(); + gpfsQuotaBlockGrace.clear(); + gpfsQuotaFilesGrace.clear(); + gpfsQuotaRemarks.clear(); + } + + std::string gpfsQuotaClusterName; + UInt32 gpfsQuotaHeader; + UInt32 gpfsQuotaVersion; + std::string gpfsQuotaFileSystemName; + UInt16 gpfsQuotaType; + UInt32 gpfsQuotaID; + std::string gpfsQuotaEntityName; + UInt64 gpfsQuotaBlockUsage; + UInt64 gpfsQuotaBlockQuota; + UInt64 gpfsQuotaBlockLimit; + UInt32 gpfsQuotaBlockInDoubt; + std::string gpfsQuotaBlockGrace; + UInt64 gpfsQuotaFilesUsage; + UInt64 gpfsQuotaFilesQuota; + UInt64 gpfsQuotaFilesLimit; + UInt32 gpfsQuotaFilesInDoubt; + std::string gpfsQuotaFilesGrace; + std::string gpfsQuotaRemarks; + + inline std::string getClusterName() { return gpfsQuotaClusterName; } + inline UInt32 getHeader() { return gpfsQuotaHeader; } + inline UInt32 getVersion() { return gpfsQuotaVersion; } + inline std::string getFileSystemName() { return gpfsQuotaFileSystemName; } + inline UInt16 getType() { return gpfsQuotaType; } + inline UInt32 getId() { return gpfsQuotaID; } + inline std::string getEntityName() { return gpfsQuotaEntityName; } + inline UInt64 getBlockUsage() { return gpfsQuotaBlockUsage; } + inline UInt64 getBlockQuota() { return gpfsQuotaBlockQuota; } + inline UInt64 getBlockLimit() { return gpfsQuotaBlockLimit; } + inline UInt32 getBlockInDoubt() { return gpfsQuotaBlockInDoubt; } + inline std::string getBlockGrace() { return gpfsQuotaBlockGrace; } + inline UInt64 getFilesUsage() { return gpfsQuotaFilesUsage; } + inline UInt64 getFilesQuota() { return gpfsQuotaFilesQuota; } + inline UInt64 getFilesLimit() { return gpfsQuotaFilesLimit; } + inline UInt32 getFilesInDoubt() { return gpfsQuotaFilesInDoubt; } + inline std::string getFilesGrace() { return gpfsQuotaFilesGrace; } + inline std::string getRemarks() { return gpfsQuotaRemarks; } + +private: + +}; +/* MODS_END */ + +#define dfprintf if (debug) fprintf + +/* forward declaration */ +class MmpmonWrapperUtils; +class CommandWrapperUtils; + +/* flag: polling scope */ +#define POLL_CLUSTER 0x01 /* poll local cluster - default */ +#define POLL_ALL_CLUSTERS 0x02 /* poll local and remote clusters (if any) */ +#define POLL_NODE 0x04 /* poll local node only */ + +/* Provide pull API to external tasks */ +class PollingHandler +{ + friend class ClusterInfo; + friend class NodeInfo; + friend class FilesystemInfo; + friend class DiskInfo; + + MmpmonWrapperUtils *wrapper; + + /* Thread for executing predefined command scripts to cache the results. + Potentially long-time taking command scripts should be added here. */ + pthread_t cmdThread; + + /* Thread for doing things regularly. Currently, it wakes up a command + thread periodically. */ + pthread_t timerThread; + + /* Thread for doing configurations. */ + pthread_t dispatchThread; + + CommandWrapperUtils *cmdWrapper; + + /* Flag that decides whether a command thread should terminate. */ + int terminate; + + /* Flag that decides whether thimer thread should terminate. */ + int timer_terminate; + + /* Flag that decides whether dispatch thread should terminate. */ + int execTerminate; + + ClusterInfo *recipe; + + /* Main routine for command thread. */ + static void *cmdHandlerBody(void *argP); + + /* Main routine for timer thread. */ + static void *timerHandlerBody(void *argP); + + /* Main routine for dispatch thread. */ + static void *dispatchHandlerBody(void *argP); + + MErrno initNodeList(); + + void initClusterRecipe(ClusterInfo *infoP); + MErrno checkFailedNode(); + char *grabValue(char *buf, int index, char *answer); + + pthread_mutex_t mutex; + + /* Execution task list. It is added by external tasks. */ + pthread_mutex_t listMutex; + std::vectorexecTaskItems; + + int debug; + MgmtProtocol protocol; + Int32 pid; /* external process id, to identify this connection */ + + /* Update rule info in PolicyInfo */ + MErrno fillRuleInfo(FilesystemInfo *fsP, PolicyInfo *policyP); + + int pollingScope; + int nNodesInList; + +public: + + Int32 getPid() { return pid; } + + MErrno cleanupNodeList(); + PollingHandler(MErrno *errP, MgmtProtocol proto, int debg = 0, + int scope = POLL_CLUSTER); + ~PollingHandler(); + + static MErrno init(MgmtProtocol proto, int debg = 0, + int scope = POLL_CLUSTER); + static void term(); + + MmpmonWrapperUtils *getMmpmonWrapper() { return wrapper; } + + /* Cluster recipe is ClusterInfo object which contains primary keys of + nodes, file systems and disks. It is parsed from mmsdrfs file. */ + MErrno refreshClusterRecipe(int scope = POLL_CLUSTER); + + MErrno parseClusterFile(ClusterInfo *cl); + + /* Get a copy of the cluster info */ + MErrno getClusterInfo(ClusterInfo *clP); + + /* current status of cluster */ + MErrno getClusterStatus(ClusterStatus *clStatusP, + int flag = CLUSTER_STATE_ALL); + + MErrno updateDiskSDRInfo(int norefresh=0); + + /* The following update calls will update both the internal copy of the + data and the caller's copy, which is pointed to by clP. */ + + MErrno updateClusterInfo(ClusterInfo *clP, int norefresh=0); + + /* Update node list which belongs to the specified cluster */ + MErrno updateNodeInfo(ClusterInfo *clP, int norefresh=0); + + /* MODS_START */ + /* Method used to quickly populate mount point for nodes->file systems */ + MErrno updateFilesystemMountPointInfo(ClusterInfo *clP); + /* MODS_END */ + + /* Update filesystem list which belongs to the specified cluster */ + MErrno updateFilesystemInfo(ClusterInfo *clP, int getPerf=0); + + /* Update storage pool list which belongs to the specified filesystem + (NULL=all filesystems) */ + MErrno updateStoragePoolInfo(ClusterInfo *clP, char *fsName=NULL); + + /* Update disk list which belongs to the specified filesystem/pool + (NULL=all pools in the filesystem) */ + MErrno updateDiskInfo(ClusterInfo *clP, char *fsName, char *poolName=NULL, + int getPerf=0); + + MErrno updateFreeDiskInfo(ClusterInfo *clP); + + /* Update per node ioc statistics */ + MErrno updateIocStatsInfo(ClusterInfo *clP); + + /* Update per node VFS statistics */ + MErrno updateVfsStatsInfo(ClusterInfo *clP); + + /* Update per node thread pool utilization statistics */ + MErrno updateThreadUtilInfo(ClusterInfo *clP); + + /* Update per node cache hit miss statistics */ + MErrno updateCacheStatsInfo(ClusterInfo *clP); + + /* Update per node pcache gateway statistics */ + MErrno updatePCacheStatsInfo(ClusterInfo *clP); + + MErrno updateClusterCfgInfo(ClusterInfo *clP); + + MErrno updateTscommCfgInfo(ClusterInfo *clP); + + MErrno updateVerbsClientInfo(ClusterInfo *clP); + + MErrno updateVerbsServerInfo(ClusterInfo *clP); + + MErrno updateRPCUtilInfo(ClusterInfo *clP, Int16 tmu=0, Int16 time=0); + + MErrno updateRPCRawUtilInfo(ClusterInfo *clP); + + MErrno updateRPCSizeUtilInfo(ClusterInfo *clP, Int16 tmu=0, Int16 time=0); + + MErrno updateRPCMsgUtilInfo(ClusterInfo *clP, Int16 tmu=0, Int16 time=0); + + MErrno updateRPCUtilInfoPerSec(ClusterInfo *clP); + + MErrno processCommand(const char *cmd); + + MErrno copyRecipe(ClusterInfo *clP); + + /* Update mounted node info in FilesystemInfo */ + MErrno updateMountedNodeInfo(ClusterInfo *clP); + + /* Update policy info in FilesystemInfo */ + MErrno updatePolicyInfo(ClusterInfo *clP); + + /* Update file system manager node info in FilesystemInfo */ + MErrno updateFilesystemManagerInfo(ClusterInfo *clP); + + /* Update file system configuration info in FilesystemInfo */ + MErrno updateFilesystemConfigInfo(ClusterInfo *clP); + + /* Update disk access info in NodeInfo */ + MErrno updateDiskAccessInfo(ClusterInfo *clP); + + /* Update NSD server info in DiskInfo */ + MErrno updateDiskServerInfo(DiskInfo *diskP, char *serverListP, + char *backupServerListP); + + /* Update indirect disk access info (through NSD servers) in NodeInfo */ + MErrno updateIndirectDiskAccessInfo(ClusterInfo *clP, DiskInfo *diskP); + + /* MODS_START */ + /* Update the file set list */ + MErrno getFileSet(char *fileSystemName, char *fileSetName, FileSet *fileSet); + MErrno getFileSets(char *fileSystemName, std::vector*fileSetList); + + MErrno getFileSets1(char *fileSystemNameP, + FileSet *fileSetListP, /* caller allocated/freed */ + int *nElemP /* in: size of fileSetListP + out: number of filesets needed */ + ); + /* type: users=1, group=2, fileset=3 */ + MErrno getQuota(int type, const char *fsName, + const char *entityName, Quota *quota ); +#ifdef MMANTRAS_QUOTAS + MErrno getQuotas(int type, const char *fsName, + std::vector *quotas ); +#endif + + MErrno createFileSet(FileSet fileSet, + std::string *gpfsMsg, bool isNull); + + MErrno deleteFileSet(FileSet fileSet, + bool force, std::string *gpfsMs); + + MErrno editQuota(char *cFsName, char *cType, + char *cEntityId, UInt64 *cNewFileSoftLim, + UInt64 *cNewFileHardLim, UInt64 *cNewBlockSoftLim, + UInt64 *cNewBlockHardLim, char *cNaramGracePeriod, + std::string *gpfsMsg); + + MErrno editFileset(char *cFsName, char *cType, + char *cEntityId, char *cNewName, char *cNewComment, + std::string *gpfsMsg); + + /* DJ_MODS_START */ + // Link a fileset + MErrno linkFileSet(FileSet jnxnFileset, std::string *gpfsMsg); + + // Unlink a fileset + MErrno unlinkFileSet(const char *fsetNameOrJnxnPath, + const char *tgt, bool isFsetName, bool force, + std::string *gpfsMsg); + + // Change owner or group of a file + // NOTE: This is not GPFS fucntionality per se .. it is a convenience for VSC + MErrno changeOwnerAndOrGroup(FileOrDirOwner newOwnerGrp); + + // Change owner and group of a file/dir to match that of a template + // source file/dir + MErrno changeFileOrDirOwnership(FileOrDirOwner src, + FileOrDirOwner tgt, std::string *gpfsMsg); + + // Change ACLs of a file/dir to match that of a template source file/dir + MErrno changeFileOrDirACL(FileOrDirOwner src, + FileOrDirOwner tgt, int aclType, + std::string *gpfsMsg); + /* DJ_MODS_END */ + +#ifdef MMANTRAS_QUOTAS + MErrno getUsers(char *fsName, char *fsNameMntPt, + char *csName, std::vector *userList); + + MErrno getGroups(char *fsName, char *fsNameMntPt, + char *csName, std::vector *groupList); +#endif + + MErrno getHomePath(char *user, char *path); + MErrno getPrimaryId(char *user, UInt32 *pid); + + /* MODS_END */ + + + /* Get the SDRFS gen number from the local node */ + UInt32 getSdrfsGenNumber(); + UInt32 getSdrfsGenNumberFromRecipe(); + MErrno updateSdrfsGenNumber(UInt32 sdrGen); + + /* Called by a main thread. Wake up timer thread. */ + void wakeupTimerThread(); + + /* Called by a timer thread. Wait a main thread to wake it up. */ + void waitMainThread(); + + /* Called by a timer thread. Wake up command thread which + executes several command scripts. */ + void wakeupCmdThread(); + + /* Called by a command thread. When command thread starts, + it waits timer thread to wake it up. */ + void waitTimerThread(); + + /* Called by a command thread. When command thread finishes, + wake up any waiter thread. */ + void notifyCmdThreadDone(); + + /* Called by external tasks. Wait until the command thread finishes + its work. */ + void waitCmdThreadDone(); + + /* Called by a main thread. When an execution task is being added, + it is called to wake up dispatch thread. */ + void wakeupDispatchThread(); + + /* Called by a dispatch thread. Wait any execution task to be + arrived. */ + void waitExecutionTask(); + + /* Add asynchronous execution task. */ + MErrno addExecutionTask(const char *cmd, char *argP, int (*callbackFn)(void *), + void *callbackData); + + /* Extract an execution task from list. */ + MErrno getExecTaskFromList(ExecutionTask *taskP); + + /* Initialize buffer. */ + MErrno initBuf(char *buf); + + /* Get GPFS daemon state. */ + MErrno getDaemonState(); + + /* MODS_START */ + char *getTimeStampInMilliseconds(char *timeStamp, char *cdateP); + + std::string buffer2string(char * buffer, int itemsToCopy); + std::vector tokenHelper(char *buf, int expectedTokens ); + + void getPollingLock(); + void releasePollingLock(); + /* MODS_END */ + + int getPollingScope() { return pollingScope; }; + int getNNodesInList() { return nNodesInList; }; + Boolean_t isLocalNodeStats() { return (pollingScope & POLL_NODE) ? + true:false; }; + /* Per node statistics */ + MErrno iocStatsInfo(int flags, void *bufferP, int bufferSize, + int *nElemP, int *errP); + MErrno vfsStatsInfo(int flags, void *bufferP, int bufferSize, + int *nElemP, int *errP); + MErrno threadUtilInfo(int flags, void *bufferP, int bufferSize, + int *nElemP, int *errP); + MErrno cacheStatsInfo(int flags, void *bufferP, int bufferSize, + int *nElemP, int *errP); + MErrno pCacheStatsInfo(int flags, void *bufferP, int bufferSize, + int *nElemP, int *errP); + MErrno clusterCfgInfo(int flags, void *bufferP, int bufferSize, + int *nElemP, int *errP); + MErrno nsdServerStatsInfo(int flags, void *bufferP, int bufferSize, + int *nElemP, int *errP); + MErrno fsIoStatsInfo(int flags, void *bufferP, int bufferSize, + int *nElemP, int *errP); + MErrno poolIoStatsInfo(int flags, void *bufferP, int bufferSize, + int *nElemP, int *errP); + MErrno diskStatsInfo(int flags, void *bufferP, int bufferSize, + int *nElemP, int *errP); +}; + +extern PollingHandler *thePollingHandler; + +void ts_log(int level, const char *component, const char* fmtString, ...); +long file_size(char * fname); +void log_update(); + +#endif /* _h_api_poll */ diff --git a/System/ior/files/gpfs/5.0.2-3/include/api_types.h b/System/ior/files/gpfs/5.0.2-3/include/api_types.h new file mode 100644 index 0000000..eee2e2b --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/api_types.h @@ -0,0 +1,66 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* */ +/* */ +/* Licensed Materials - Property of IBM */ +/* */ +/* Restricted Materials of IBM */ +/* */ +/* (C) COPYRIGHT International Business Machines Corp. 2010,2018 */ +/* All Rights Reserved */ +/* */ +/* US Government Users Restricted Rights - Use, duplication or */ +/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp. */ +/* */ +/* IBM_PROLOG_END_TAG */ +/* @(#)18 1.5 src/avs/fs/mmfs/ts/mmantras/api_types.h, mmfs, avs_rtac502, rtac5021836a 12/22/10 14:55:05 */ +#ifndef _h_api_types +#define _h_api_types + +/* + * api_types.h + * type definition used in MMANTRAS library + */ + +typedef enum +{ + M_OK = 0, + M_ERR = 1, + M_RECOVERED = 2 +} MErrno; + +typedef short Int16; +typedef int Int32; +typedef long long Int64; +typedef unsigned short UInt16; +typedef unsigned int UInt32; +typedef unsigned long long UInt64; + +typedef unsigned int Boolean_t; + +struct threadUtil +{ + UInt32 current; + UInt32 highest; + UInt32 maximum; +}; +typedef struct threadUtil threadUtil_t; + +struct pCacheCmdInfo +{ + UInt32 queuedPcacheCmds; + UInt32 inflightPcacheCmds; + UInt32 completedPcacheCmds; + UInt32 errorPcacheCmds; + UInt32 filteredPcacheCmds; + UInt32 enoentPcacheCmds; +}; +typedef struct pCacheCmdInfo pCacheCmdInfo_t; + + +/* mmantras library debug routine */ +extern void ts_print(const char *str); + +#endif /* _h_api_types */ + diff --git a/System/ior/files/gpfs/5.0.2-3/include/dmapi.h b/System/ior/files/gpfs/5.0.2-3/include/dmapi.h new file mode 100644 index 0000000..01a6f61 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/dmapi.h @@ -0,0 +1,647 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* */ +/* */ +/* Licensed Materials - Property of IBM */ +/* */ +/* Restricted Materials of IBM */ +/* */ +/* (C) COPYRIGHT International Business Machines Corp. 1997,2018 */ +/* All Rights Reserved */ +/* */ +/* US Government Users Restricted Rights - Use, duplication or */ +/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp. */ +/* */ +/* IBM_PROLOG_END_TAG */ +/* @(#)05 1.16 src/avs/fs/mmfs/ts/dm/dmapi.h, mmfs, avs_rtac502, rtac5021836a 11/23/09 18:22:10 */ +/* + * + * Define library calls for GPFS DMAPI + * + */ +#ifndef _DMAPI_H +#define _DMAPI_H + +#include "dmapi_types.h" + +/* + * Function declarations for GPFS DMAPI + */ + +#ifdef __cplusplus +extern "C" +{ +#endif + + extern int dm_clear_inherit( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_attrname_t *attrnamep /* IN */ + ); + + extern int dm_create_by_handle( + dm_sessid_t sid, /* IN */ + void *dirhanp, /* IN */ + size_t dirhlen, /* IN */ + dm_token_t token, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + char *cname /* IN */ + ); + + extern int dm_create_session( + dm_sessid_t oldsid, /* IN */ + char *sessinfop, /* IN */ + dm_sessid_t *newsidp /* OUT */ + ); + + extern int dm_create_userevent( + dm_sessid_t sid, /* IN */ + size_t msglen, /* IN */ + void *msgdatap, /* IN */ + dm_token_t *tokenp /* OUT */ + ); + + extern int dm_destroy_session( + dm_sessid_t sid /* IN */ + ); + + extern int dm_downgrade_right( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token /* IN */ + ); + + extern int dm_fd_to_handle( + int fd, /* IN */ + void **hanpp, /* OUT */ + size_t *hlenp /* OUT */ + ); + + extern int dm_find_eventmsg( + dm_sessid_t sid, /* IN */ + dm_token_t token, /* IN */ + size_t buflen, /* IN */ + void *bufp, /* OUT */ + size_t *rlenp /* OUT */ + ); + + extern int dm_get_allocinfo( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_off_t *offp, /* IN/OUT */ + u_int nelem, /* IN */ + dm_extent_t *extentp, /* OUT */ + u_int *nelemp /* OUT */ + ); + + extern int dm_get_bulkall( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + u_int mask, /* IN */ + dm_attrname_t *attrnamep, /* IN */ + dm_attrloc_t *locp, /* IN/OUT */ + size_t buflen, /* IN */ + void *bufp, /* OUT */ + size_t *rlenp /* OUT */ + ); + + extern int dm_get_bulkattr( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + u_int mask, /* IN */ + dm_attrloc_t *locp, /* IN/OUT */ + size_t buflen, /* IN */ + void *bufp, /* OUT */ + size_t *rlenp /* OUT */ + ); + + extern int dm_get_config( + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_config_t flagname, /* IN */ + dm_size_t *retvalp /* OUT */ + ); + + extern int dm_get_config_events( + void *hanp, /* IN */ + size_t hlen, /* IN */ + u_int nelem, /* IN */ + dm_eventset_t *eventsetp, /* OUT */ + u_int *nelemp /* OUT */ + ); + + extern int dm_get_dirattrs( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + u_int mask, /* IN */ + dm_attrloc_t *locp, /* IN/OUT */ + size_t buflen, /* IN */ + void *bufp, /* OUT */ + size_t *rlenp /* OUT */ + ); + + extern int dm_get_dmattr( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_attrname_t *attrnamep, /* IN */ + size_t buflen, /* IN */ + void *bufp, /* OUT */ + size_t *rlenp /* OUT */ + ); + + extern int dm_get_eventlist( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + u_int nelem, /* IN */ + dm_eventset_t *eventsetp, /* OUT */ + u_int *nelemp /* OUT */ + ); + + extern int dm_get_events( + dm_sessid_t sid, /* IN */ + u_int maxmsgs, /* IN */ + u_int flags, /* IN */ + size_t buflen, /* IN */ + void *bufp, /* OUT */ + size_t *rlenp /* OUT */ + ); + + extern int dm_get_fileattr( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + u_int mask, /* IN */ + dm_stat_t *statp /* OUT */ + ); + + extern int dm_get_mountinfo( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + size_t buflen, /* IN */ + void *bufp, /* OUT */ + size_t *rlenp /* OUT */ + ); + + extern int dm_get_region( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + u_int nelem, /* IN */ + dm_region_t *regbufp, /* OUT */ + u_int *nelemp /* OUT */ + ); + + extern int dm_getall_disp( + dm_sessid_t sid, /* IN */ + size_t buflen, /* IN */ + void *bufp, /* OUT */ + size_t *rlenp /* OUT */ + ); + + extern int dm_getall_dmattr( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + size_t buflen, /* IN */ + void *bufp, /* OUT */ + size_t *rlenp /* OUT */ + ); + + extern int dm_getall_inherit( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + u_int nelem, /* IN */ + dm_inherit_t *inheritbufp, /* OUT */ + u_int *nelemp /* OUT */ + ); + + extern int dm_getall_sessions( + u_int nelem, /* IN */ + dm_sessid_t *sidbufp, /* OUT */ + u_int *nelemp /* OUT */ + ); + + extern int dm_getall_tokens( + dm_sessid_t sid, /* IN */ + u_int nelem, /* IN */ + dm_token_t *tokenbufp, /* OUT */ + u_int *nelemp /* OUT */ + ); + + extern int dm_handle_cmp( + void *hanp1, /* IN */ + size_t hlen1, /* IN */ + void *hanp2, /* IN */ + size_t hlen2 /* IN */ + ); + + extern void dm_handle_free( + void *hanp, /* IN */ + size_t hlen /* IN */ + ); + + extern u_int dm_handle_hash( + void *hanp, /* IN */ + size_t hlen /* IN */ + ); + + extern dm_boolean_t dm_handle_is_valid( + void *hanp, /* IN */ + size_t hlen /* IN */ + ); + + extern int dm_handle_to_fshandle( + void *hanp, /* IN */ + size_t hlen, /* IN */ + void **fshanpp, /* OUT */ + size_t *fslenp /* OUT */ + ); + + extern int dm_handle_to_fsid( + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_fsid_t *fsidp /* OUT */ + ); + + extern int dm_handle_to_igen( + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_igen_t *igenp /* OUT */ + ); + + extern int dm_handle_to_ino( + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_ino_t *inop /* OUT */ + ); + + extern int dm_handle_to_snap( + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_snap_t *isnapp /* OUT */ + ); + + extern int dm_handle_to_path( + void *dirhanp, /* IN */ + size_t dirhlen1, /* IN */ + void *targhanp, /* IN */ + size_t targhlen, /* IN */ + size_t buflen, /* IN */ + char *pathbufp, /* OUT */ + size_t *rlenp /* OUT */ + ); + + extern int dm_init_attrloc( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_attrloc_t *locp /* OUT */ + ); + + extern int dm_init_service( + char **versionstrpp /* OUT */ + ); + + extern int dm_make_fshandle( + dm_fsid_t *fsidp, /* IN */ + void **hanpp, /* OUT */ + size_t *hlenp /* OUT */ + ); + + extern int dm_make_handle( + dm_fsid_t *fsidp, /* IN */ + dm_ino_t *inop, /* IN */ + dm_igen_t *igenp, /* IN */ + void **hanpp, /* OUT */ + size_t *hlenp /* OUT */ + ); + + extern int dm_make_xhandle( + dm_fsid_t *fsidp, /* IN */ + dm_ino_t *inop, /* IN */ + dm_igen_t *igenp, /* IN */ + dm_snap_t *isnapp, /* IN */ + void **hanpp, /* OUT */ + size_t *hlenp /* OUT */ + ); + + extern int dm_mkdir_by_handle( + dm_sessid_t sid, /* IN */ + void *dirhanp, /* IN */ + size_t dirhlen, /* IN */ + dm_token_t token, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + char *cname /* IN */ + ); + + extern int dm_move_event( + dm_sessid_t srcsid, /* IN */ + dm_token_t token, /* IN */ + dm_sessid_t targetsid, /* IN */ + dm_token_t *rtokenp /* OUT */ + ); + + extern int dm_obj_ref_hold( + dm_sessid_t sid, /* IN */ + dm_token_t token, /* IN */ + void *hanp, /* IN */ + size_t hlen /* IN */ + ); + + extern int dm_obj_ref_query( + dm_sessid_t sid, /* IN */ + dm_token_t token, /* IN */ + void *hanp, /* IN */ + size_t hlen /* IN */ + ); + + extern int dm_obj_ref_rele( + dm_sessid_t sid, /* IN */ + dm_token_t token, /* IN */ + void *hanp, /* IN */ + size_t hlen /* IN */ + ); + + extern int dm_path_to_fshandle( + char *path, /* IN */ + void **hanpp, /* OUT */ + size_t *hlenp /* OUT */ + ); + + extern int dm_path_to_handle( + char *path, /* IN */ + void **hanpp, /* OUT */ + size_t *hlenp /* OUT */ + ); + + extern int dm_pending( + dm_sessid_t sid, /* IN */ + dm_token_t token, /* IN */ + dm_timestruct_t *delay /* IN */ + ); + + extern int dm_probe_hole( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_off_t off, /* IN */ + dm_size_t len, /* IN */ + dm_off_t *roffp, /* OUT */ + dm_size_t *rlenp /* OUT */ + ); + + extern int dm_punch_hole( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_off_t off, /* IN */ + dm_size_t len /* IN */ + ); + + extern int dm_query_right( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_right_t *rightp /* OUT */ + ); + + extern int dm_query_session( + dm_sessid_t sid, /* IN */ + size_t buflen, /* IN */ + void *bufp, /* OUT */ + size_t *rlenp /* OUT */ + ); + + extern dm_ssize_t dm_read_invis( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_off_t off, /* IN */ + dm_size_t len, /* IN */ + void *bufp /* OUT */ + ); + + extern int dm_release_right( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token /* IN */ + ); + + extern int dm_remove_dmattr( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + int setdtime, /* IN */ + dm_attrname_t *attrnamep /* IN */ + ); + + extern int dm_remove_dmattr_nosync( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + int setdtime, /* IN */ + dm_attrname_t *attrnamep /* IN */ + ); + + extern int dm_request_right( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + u_int flags, /* IN */ + dm_right_t right /* IN */ + ); + + extern int dm_respond_event( + dm_sessid_t sid, /* IN */ + dm_token_t token, /* IN */ + dm_response_t response, /* IN */ + int reterror, /* IN */ + size_t buflen, /* IN */ + void *respbufp /* IN */ + ); + + extern int dm_send_msg( + dm_sessid_t targetsid, /* IN */ + dm_msgtype_t msgtype, /* IN */ + size_t buflen, /* IN */ + void *bufp /* IN */ + ); + + extern int dm_set_disp( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_eventset_t *eventsetp, /* IN */ + u_int maxevent /* IN */ + ); + + extern int dm_set_dmattr( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_attrname_t *attrnamep, /* IN */ + int setdtime, /* IN */ + size_t buflen, /* IN */ + void *bufp /* IN */ + ); + + extern int dm_set_dmattr_nosync( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_attrname_t *attrnamep, /* IN */ + int setdtime, /* IN */ + size_t buflen, /* IN */ + void *bufp /* IN */ + ); + + extern int dm_set_eventlist( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_eventset_t *eventsetp, /* IN */ + u_int maxevent /* IN */ + ); + + extern int dm_set_eventlist_nosync( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_eventset_t *eventsetp, /* IN */ + u_int maxevent /* IN */ + ); + + extern int dm_set_fileattr( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + u_int mask, /* IN */ + dm_fileattr_t *attrp /* IN */ + ); + + extern int dm_set_inherit( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_attrname_t *attrnamep, /* IN */ + mode_t mode /* IN */ + ); + + extern int dm_set_region( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + u_int nelem, /* IN */ + dm_region_t *regbufp, /* IN */ + dm_boolean_t *exactflagp /* OUT */ + ); + + extern int dm_set_region_nosync( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + u_int nelem, /* IN */ + dm_region_t *regbufp, /* IN */ + dm_boolean_t *exactflagp /* OUT */ + ); + + extern int dm_set_return_on_destroy( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + dm_attrname_t *attrnamep, /* IN */ + dm_boolean_t enable /* IN */ + ); + + extern int dm_symlink_by_handle( + dm_sessid_t sid, /* IN */ + void *dirhanp, /* IN */ + size_t dirhlen, /* IN */ + dm_token_t token, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + char *cname, /* IN */ + char *path /* IN */ + ); + + extern int dm_sync_by_handle( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token /* IN */ + ); + + extern int dm_sync_dmattr_by_handle( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token /* IN */ + ); + + extern int dm_upgrade_right( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token /* IN */ + ); + + extern dm_ssize_t dm_write_invis( + dm_sessid_t sid, /* IN */ + void *hanp, /* IN */ + size_t hlen, /* IN */ + dm_token_t token, /* IN */ + int flags, /* IN */ + dm_off_t off, /* IN */ + dm_size_t len, /* IN */ + void *bufp /* IN */ + ); + +#ifdef __cplusplus +} +#endif + +#endif /* _DMAPI_H */ diff --git a/System/ior/files/gpfs/5.0.2-3/include/dmapi_types.h b/System/ior/files/gpfs/5.0.2-3/include/dmapi_types.h new file mode 100644 index 0000000..a53ddd3 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/dmapi_types.h @@ -0,0 +1,591 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* */ +/* */ +/* Licensed Materials - Property of IBM */ +/* */ +/* Restricted Materials of IBM */ +/* */ +/* (C) COPYRIGHT International Business Machines Corp. 1997,2018 */ +/* All Rights Reserved */ +/* */ +/* US Government Users Restricted Rights - Use, duplication or */ +/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp. */ +/* */ +/* IBM_PROLOG_END_TAG */ +/* @(#)06 1.57 src/avs/fs/mmfs/ts/dm/dmapi_types.h, mmfs, avs_rtac502, rtac5021836a 2/17/17 10:31:56 */ +/* + * + * Define external types for GPFS DMAPI + * + */ +#ifndef _DMAPI_TYPES_H +#define _DMAPI_TYPES_H + +#include + +/* + * Type definitions for GPFS DMAPI external interfaces + */ + +/* Basic scalar types */ + +typedef int dm_signed32; +typedef unsigned int dm_unsigned32; +typedef long long dm_signed64; +typedef unsigned long long dm_unsigned64; + +struct dm_scalar128 +{ + dm_unsigned64 high; + dm_unsigned64 low; +#ifdef __cplusplus + bool operator == (const dm_scalar128& rhs) const + { return high == rhs.high && low == rhs.low; }; + bool operator != (const dm_scalar128& rhs) const + { return high != rhs.high || low != rhs.low; }; + bool operator < (const dm_scalar128& rhs) const + { return high < rhs.high || (high == rhs.high && low < rhs.low); }; + bool operator > (const dm_scalar128& rhs) const + { return high > rhs.high || (high == rhs.high && low > rhs.low); }; + bool operator <= (const dm_scalar128& rhs) const + { return high < rhs.high || (high == rhs.high && low <= rhs.low); }; + bool operator >= (const dm_scalar128& rhs) const + { return high > rhs.high || (high == rhs.high && low >= rhs.low); }; +#endif /* __cplusplus */ +}; +typedef struct dm_scalar128 dm_scalar128; + +#define DM_SCALAR128_EQ(x, y) (((x).high==(y).high) && ((x).low==(y).low)) +#define DM_SCALAR128_NE(x, y) (((x).high!=(y).high) || ((x).low!=(y).low)) +#define DM_SCALAR128_LT(x, y) (((x).high<(y).high) || (((x).high==(y).high) && ((x).low<(y).low))) +#define DM_SCALAR128_GT(x, y) (((x).high>(y).high) || (((x).high==(y).high) && ((x).low>(y).low))) +#define DM_SCALAR128_LE(x, y) (((x).high<(y).high) || (((x).high==(y).high) && ((x).low<=(y).low))) +#define DM_SCALAR128_GE(x, y) (((x).high>(y).high) || (((x).high==(y).high) && ((x).low>=(y).low))) + +typedef dm_signed64 dm_off_t; +typedef dm_unsigned64 dm_size_t; +typedef dm_signed64 dm_ssize_t; + +#ifdef _AIX +typedef ino_t dm_ino_t; +#else +typedef dm_unsigned64 dm_ino_t; +#endif + +typedef dm_unsigned64 dm_fsid_t; +typedef dm_unsigned32 dm_igen_t; + +typedef dm_unsigned64 dm_snap_t; +#define DM_SNAP_ROOT ((dm_snap_t) 0) +#define DM_SNAP_INVALID ((dm_snap_t) -1) + +typedef enum +{ + DM_FALSE = 0, + DM_TRUE = 1 +} dm_boolean_t; + +/* Iterator for a filesystem scan */ +typedef dm_signed64 dm_attrloc_t; + +/* Variable-length data */ +struct dm_vardata +{ + int vd_offset; + unsigned int vd_length; +}; +typedef struct dm_vardata dm_vardata_t; + +/* Interpreters for variable length data */ + +#define DM_GET_LEN(basePtr, vardataFieldName) \ + (((basePtr)->vardataFieldName.vd_offset == 0) ? \ + (size_t)DM_INVALID_HLEN : \ + (((basePtr)->vardataFieldName.vd_offset == 1) ? \ + (size_t)DM_GLOBAL_HLEN : \ + ((basePtr)->vardataFieldName.vd_length) \ + )) + +/* The prtType parameter in the DM_GET_VALUE() macro is pointer type + (for example "int *"). The value of the macro is a pointer of the give type, + or NULL if the data length (as given by the DM_GET_LEN() macro) is zero. */ +#define DM_GET_VALUE(basePtr, vardataFieldName, ptrType) \ + (((basePtr)->vardataFieldName.vd_offset == 0) ? \ + (ptrType)DM_INVALID_HANP : \ + (((basePtr)->vardataFieldName.vd_offset == 1) ? \ + (ptrType)DM_GLOBAL_HANP : \ + (((basePtr)->vardataFieldName.vd_length == 0) ? \ + NULL : \ + (ptrType)((char *)(basePtr)+(basePtr)->vardataFieldName.vd_offset)\ + ))) + +/* Iterator for lists of variable length structures */ + +/* The ptrType parameter in the DM_STEP_TO_NEXT() macro is a pointer type + (for example "dm_attrlist_t *"). The value of the macro is a pointer + of the given type, or NULL if the current element is the last in the list.*/ +#define DM_STEP_TO_NEXT(basePtr, ptrType) \ + (((basePtr)->_link == 0) ? NULL : \ + (ptrType)((char *)(basePtr) + (basePtr)->_link)) + +#define DM_ATTR_NAME_SIZE 8 + +/* Name of an extended attribute */ +struct dm_attrname +{ + u_char an_chars[DM_ATTR_NAME_SIZE]; +}; +typedef struct dm_attrname dm_attrname_t; + +/* Session identifier */ +typedef dm_unsigned64 dm_sessid_t; + +/* Node identifier */ +typedef dm_unsigned32 dm_nodeid_t; /* GPFS Specific - not in XDSM standard */ + +/* List of extended attributes */ +struct dm_attrlist +{ + dm_ssize_t _link; + dm_attrname_t al_name; + dm_vardata_t al_data; +}; +typedef struct dm_attrlist dm_attrlist_t; + +/* Attributes of the GPFS DMAPI implementation */ +typedef enum +{ + DM_CONFIG_INVALID, /* Lower than any attribute */ + DM_CONFIG_BULKALL, + DM_CONFIG_CREATE_BY_HANDLE, + DM_CONFIG_DTIME_OVERLOAD, + DM_CONFIG_LEGACY, + DM_CONFIG_LOCK_UPGRADE, + DM_CONFIG_MAX_ATTR_ON_DESTROY, + DM_CONFIG_MAX_ATTRIBUTE_SIZE, + DM_CONFIG_MAX_HANDLE_SIZE, + DM_CONFIG_MAX_MANAGED_REGIONS, + DM_CONFIG_MAX_MESSAGE_DATA, + DM_CONFIG_OBJ_REF, + DM_CONFIG_PENDING, + DM_CONFIG_PERS_ATTRIBUTES, + DM_CONFIG_PERS_EVENTS, + DM_CONFIG_PERS_INHERIT_ATTRIBS, + DM_CONFIG_PERS_MANAGED_REGIONS, + DM_CONFIG_PUNCH_HOLE, + DM_CONFIG_TOTAL_ATTRIBUTE_SPACE, + DM_CONFIG_WILL_RETRY, + DM_CONFIG_MAX /* GPFS specific - higher than any attribute */ +} dm_config_t; + +#define DM_CONFIG_LOWEST (DM_CONFIG_INVALID + 1) /* GPFS specific - lowest attribute */ +#define DM_CONFIG_HIGHEST (DM_CONFIG_MAX -1) /* GPFS specific - highest attribute */ + +/* Names of events */ +typedef enum +{ + DM_EVENT_INVALID, /* Lower than any event */ + DM_EVENT_CLOSE, + DM_EVENT_MOUNT, + DM_EVENT_PREUNMOUNT, DM_EVENT_UNMOUNT, + DM_EVENT_NOSPACE, + DM_EVENT_DEBUT, + DM_EVENT_CREATE, DM_EVENT_POSTCREATE, + DM_EVENT_REMOVE, DM_EVENT_POSTREMOVE, + DM_EVENT_RENAME, DM_EVENT_POSTRENAME, + DM_EVENT_SYMLINK, DM_EVENT_POSTSYMLINK, + DM_EVENT_LINK, DM_EVENT_POSTLINK, + DM_EVENT_READ, + DM_EVENT_WRITE, + DM_EVENT_TRUNCATE, + DM_EVENT_ATTRIBUTE, + DM_EVENT_CANCEL, + DM_EVENT_DESTROY, + DM_EVENT_USER, + DM_EVENT_PREPERMCHANGE, + DM_EVENT_POSTPERMCHANGE, + DM_EVENT_DIRECT_READ, /* GPFS specific */ + DM_EVENT_MAX /* Higher than any event */ +} dm_eventtype_t; + +#define DM_EVENT_BASE_MAX DM_EVENT_PREPERMCHANGE +#define DM_EVENT_MAX_POSSIBLE 32 +#define DM_EVENT_EXP_COUNT (DM_EVENT_MAX-DM_EVNT_BASE_MAX) + +/* Set of events */ +typedef dm_unsigned32 dm_eventset_t; + +#define DM_EVENT_LOWEST (DM_EVENT_INVALID + 1) /* GPFS specific - lowest event */ +#define DM_EVENT_HIGHEST (DM_EVENT_MAX - 1) /* GPFS specific - highest event */ + +/* Operations on sets of events */ + +#define DMEV_SET(ev, eset) (((((int) (ev)) >= DM_EVENT_LOWEST) \ + && (((int) (ev)) <= DM_EVENT_HIGHEST)) \ + ? (eset) |= (((dm_eventset_t) 1) << (((int) (ev)) - 1)) \ + : (eset)) + +#define DMEV_CLR(ev, eset) (((((int) (ev)) >= DM_EVENT_LOWEST) \ + && (((int) (ev)) <= DM_EVENT_HIGHEST)) \ + ? (eset) &= ~(((dm_eventset_t) 1) << (((int) (ev)) - 1)) \ + : (eset)) + +#define DMEV_ZERO(eset) ((eset) = (dm_eventset_t) DM_EVENT_INVALID) + + +#define DMEV_ISSET(ev, eset) ((((int) (ev)) >= DM_EVENT_LOWEST) \ + && (((int) (ev)) <= DM_EVENT_HIGHEST) \ + && (((dm_eventset_t) (eset)) & (((dm_eventset_t) 1) << (((int) (ev)) - 1)))) + +/* GPFS Specific event set operations - not in XDSM standard */ + +/* Add all events to eset */ +#define DMEV_ALL(eset) ((eset) = ~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST)) + +/* check if eset is empty (contains no events) */ +#define DMEV_ISZERO(eset) ((((dm_eventset_t) (eset)) & (~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST))) == (dm_eventset_t) DM_EVENT_INVALID) + +/* check if eset contains all events */ +#define DMEV_ISALL(eset) ((((dm_eventset_t) (eset)) & (~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST))) == ~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST)) + +/* Add to eset2 all events of eset1 */ +#define DMEV_ADD(eset1, eset2) ((eset2) = ((((dm_eventset_t) (eset1)) | ((dm_eventset_t) (eset2))) & (~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST)))) + +/* Remove from eset2 all events of eset1 */ +#define DMEV_REM(eset1, eset2) ((eset2) = (((dm_eventset_t) (eset2)) & (~((dm_eventset_t) (eset1))))) + +/* Restrict eset2 by eset1 (remove from eset2 any event that is not in eset1) */ +#define DMEV_RES(eset1, eset2) ((eset2) = ((((dm_eventset_t) (eset1)) & ((dm_eventset_t) (eset2))) & (~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST)))) + +/* Check if eset1 and eset2 are equal (have the same events) */ +#define DMEV_ISEQ(eset1, eset2) ((((dm_eventset_t) (eset1)) & (~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST))) == (((dm_eventset_t) (eset2)) & (~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST)))) + +/* Check if eset1 and eset2 are disjoint (have no events in common) */ +#define DMEV_ISDISJ(eset1, eset2) ((((dm_eventset_t) (eset1)) & ((dm_eventset_t) (eset2)) & (~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST))) == (dm_eventset_t) DM_EVENT_INVALID) + +/* Check if eset1 is a subset of eset2 (all events of eset1 are in eset2) */ +#define DMEV_ISSUB(eset1, eset2) ((((dm_eventset_t) (eset1)) & ((dm_eventset_t) (eset2)) & (~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST))) == (((dm_eventset_t) (eset1)) & (~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST)))) + +/* Normalize the contents of eset (unused bits in the mask are cleared). + Useful if eset was not obtained entirely by means of DMEV_XXX() macros*/ +#define DMEV_NORM(eset) ((eset) = (((dm_eventset_t)(eset)) & (~((~((dm_eventset_t) DM_EVENT_INVALID)) << DM_EVENT_HIGHEST)))) + +/* Extent types */ +typedef enum +{ + DM_EXTENT_INVALID, + DM_EXTENT_RES, + DM_EXTENT_HOLE +} dm_extenttype_t; + +struct dm_extent +{ + dm_extenttype_t ex_type; + dm_signed32 ex_pad_to_dword; /* dm_off_t is 64b, need to pad */ + dm_off_t ex_offset; + dm_size_t ex_length; +}; +typedef struct dm_extent dm_extent_t; + +/* Disposition information */ +struct dm_dispinfo +{ + dm_ssize_t _link; + dm_vardata_t di_fshandle; + dm_eventset_t di_eventset; +}; +typedef struct dm_dispinfo dm_dispinfo_t; + +typedef dm_scalar128 dm_token_t; + +/* Comparison macros for tokens - GPFS specific - not in XDSM standard */ +#define DM_TOKEN_EQ(x, y) DM_SCALAR128_EQ(x, y) +#define DM_TOKEN_NE(x, y) DM_SCALAR128_NE(x, y) +#define DM_TOKEN_LT(x, y) DM_SCALAR128_LT(x, y) +#define DM_TOKEN_GT(x, y) DM_SCALAR128_GT(x, y) +#define DM_TOKEN_LE(x, y) DM_SCALAR128_LE(x, y) +#define DM_TOKEN_GE(x, y) DM_SCALAR128_GE(x, y) + +/* Sequence number for event cancellation */ +typedef dm_scalar128 dm_sequence_t; + +/* Comparison macros for sequence numbers - GPFS specific - not in XDSM standard */ +#define DM_SEQUENCE_EQ(x, y) DM_SCALAR128_EQ(x, y) +#define DM_SEQUENCE_NE(x, y) DM_SCALAR128_NE(x, y) +#define DM_SEQUENCE_LT(x, y) DM_SCALAR128_LT(x, y) +#define DM_SEQUENCE_GT(x, y) DM_SCALAR128_GT(x, y) +#define DM_SEQUENCE_LE(x, y) DM_SCALAR128_LE(x, y) +#define DM_SEQUENCE_GE(x, y) DM_SCALAR128_GE(x, y) + +/* Event message header */ +struct dm_eventmsg +{ + dm_ssize_t _link; + dm_eventtype_t ev_type; + dm_token_t ev_token; + dm_sequence_t ev_sequence; + dm_nodeid_t ev_nodeid; /* GPFS specific - not in XDSM standard */ + dm_vardata_t ev_data; +}; +typedef struct dm_eventmsg dm_eventmsg_t; + + +/* Cancel event message */ +struct dm_cancel_event +{ + dm_sequence_t ce_sequence; + dm_token_t ce_token; +}; +typedef struct dm_cancel_event dm_cancel_event_t; + +/* Data event message */ +struct dm_data_event +{ + dm_vardata_t de_handle; + dm_off_t de_offset; + dm_size_t de_length; +}; +typedef struct dm_data_event dm_data_event_t; + +/* Destroy event message */ +struct dm_destroy_event +{ + dm_vardata_t ds_handle; + dm_attrname_t ds_attrname; + dm_vardata_t ds_attrcopy; +}; +typedef struct dm_destroy_event dm_destroy_event_t; + +/* Mount event message */ +struct dm_mount_event +{ + mode_t me_mode; + dm_vardata_t me_handle1; + dm_vardata_t me_handle2; + dm_vardata_t me_name1; + dm_vardata_t me_name2; + dm_vardata_t me_roothandle; +}; +typedef struct dm_mount_event dm_mount_event_t; + +/* Namespace event message */ +struct dm_namesp_event +{ + mode_t ne_mode; + dm_vardata_t ne_handle1; + dm_vardata_t ne_handle2; + dm_vardata_t ne_name1; + dm_vardata_t ne_name2; + int ne_retcode; +}; +typedef struct dm_namesp_event dm_namesp_event_t; + +/* Flags for the mode field of mount, preunmount and unmount event messages */ +#define DM_MOUNT_RDONLY (0x1) +#define DM_UNMOUNT_FORCE (0x2) +#define DM_LOCAL_MOUNT (0x4) /* GPFS specific - not in XDSM standard */ +#define DM_REMOTE_MOUNT (0x8) /* GPFS specific - not in XDSM standard */ + +struct dm_timestruct +{ + time_t dm_tv_sec; + dm_signed32 dm_tv_nsec; +}; +typedef struct dm_timestruct dm_timestruct_t; + +/* DMAPI file attributes */ +struct dm_fileattr +{ + mode_t fa_mode; + uid_t fa_uid; + gid_t fa_gid; + time_t fa_atime; + time_t fa_mtime; + time_t fa_ctime; + time_t fa_dtime; + dm_off_t fa_size; +}; +typedef struct dm_fileattr dm_fileattr_t; + +struct dm_fileattr32 +{ + mode_t fa_mode; + uid_t fa_uid; + gid_t fa_gid; + dm_signed32 fa_atime; + dm_signed32 fa_mtime; + dm_signed32 fa_ctime; + dm_signed32 fa_dtime; + dm_off_t fa_size; +}; +typedef struct dm_fileattr32 dm_fileattr32_t; + +struct dm_fileattr64 +{ + mode_t fa_mode; +#if defined(__sun) + u_int fa_uid; + u_int fa_gid; +#else + uid_t fa_uid; + gid_t fa_gid; +#endif + dm_signed32 fa_pad_to_dword; + dm_signed64 fa_atime; + dm_signed64 fa_mtime; + dm_signed64 fa_ctime; + dm_signed64 fa_dtime; + dm_off_t fa_size; +}; +typedef struct dm_fileattr64 dm_fileattr64_t; + +/* Message types for user events */ +typedef enum +{ + DM_MSGTYPE_INVALID, + DM_MSGTYPE_SYNC, + DM_MSGTYPE_ASYNC +} dm_msgtype_t; + +/* Region descriptor */ +struct dm_region +{ + dm_off_t rg_offset; + dm_size_t rg_size; + u_int rg_flags; + dm_signed32 rg_opaque; /* GPFS specific - not in XDSM standard */ +}; +typedef struct dm_region dm_region_t; + +#define DM_REGION_NOEVENT (0x0) +#define DM_REGION_READ (0x1) +#define DM_REGION_WRITE (0x2) +#define DM_REGION_TRUNCATE (0x4) +#define DM_REGION_DIRECT_READ (0x8) /* GPFS specific - read without recall */ + + +/* Responses for dm_respond_event() */ +typedef enum +{ + DM_RESP_INVALID, + DM_RESP_CONTINUE, + DM_RESP_ABORT, + DM_RESP_DONTCARE +} dm_response_t; + +/* Access rights */ +typedef enum +{ + DM_RIGHT_NULL, + DM_RIGHT_SHARED, + DM_RIGHT_EXCL +} dm_right_t; + +/* Status information */ +struct dm_stat +{ + dm_ssize_t _link; + dm_vardata_t dt_handle; + dm_vardata_t dt_compname; + dm_eventset_t dt_emask; + int dt_nevents; + int dt_pers; + int dt_pmanreg; + time_t dt_dtime; + u_int dt_change; + dev_t dt_dev; + dm_ino_t dt_ino; + mode_t dt_mode; + nlink_t dt_nlink; + uid_t dt_uid; + gid_t dt_gid; + dev_t dt_rdev; + dm_off_t dt_size; + time_t dt_atime; + time_t dt_mtime; + time_t dt_ctime; + u_int dt_blksize; + dm_size_t dt_blocks; + int dt_gpfsqa1; /* GPFS specific - not in XDSM standard */ + int dt_gpfsqa2; /* GPFS specific - not in XDSM standard */ + u_int dt_poolid; /* GPFS specific - not in XDSM standard */ + int dt_fopen; /* GPFS specific - not in XDSM standard */ +}; +typedef struct dm_stat dm_stat_t; + + +/* File attribute masks */ +#define DM_AT_ATIME (0x0001) +#define DM_AT_CFLAG (0x0002) +#define DM_AT_CTIME (0x0004) +#define DM_AT_DTIME (0x0008) +#define DM_AT_EMASK (0x0010) +#define DM_AT_GID (0x0020) +#define DM_AT_HANDLE (0x0040) +#define DM_AT_MODE (0x0080) +#define DM_AT_MTIME (0x0100) +#define DM_AT_PATTR (0x0200) +#define DM_AT_PMANR (0x0400) +#define DM_AT_SIZE (0x0800) +#define DM_AT_STAT (0x1000) +#define DM_AT_UID (0x2000) +#define DM_AT_FOPEN (0x4000) /* Is the file open elsewhere? + Only valid on dm_get_fileattr */ + +struct dm_xstat +{ + dm_ssize_t _link; + dm_stat_t dx_statinfo; + dm_vardata_t dx_attrdata; +}; +typedef struct dm_xstat dm_xstat_t; + + +/* Max size of a session label */ +#define DM_SESSION_INFO_LEN 256 + +/* Special session identifier */ +#define DM_NO_SESSION ((dm_sessid_t) 0) + +/* Flag indicating whether to wait in dm_get_events */ +#define DM_EV_WAIT (0x1) + +/* Flag indicating whether to wait in dm_request_right */ +#define DM_RR_WAIT (0x1) + +/* Flag indicating whether the request right call is from panache eviction */ +#define DM_PCACHE_EVICT (0x10) + +/* Special file handles */ +#define DM_GLOBAL_HANP ((void *)(size_t)0xFFFFFFFD) +#define DM_GLOBAL_HLEN ((size_t)0) + +#define DM_INVALID_HANP ((void *)(size_t)0xFFFFFFFF) +#define DM_INVALID_HLEN ((size_t)0) + +/* Special tokens */ +static const dm_token_t _dmNoToken = { 0, 0 }; +#define DM_NO_TOKEN _dmNoToken + +static const dm_token_t _dmInvalidToken = { 0, 1 }; +#define DM_INVALID_TOKEN _dmInvalidToken + +/* Flag for the dm_write_invis() call */ +#define DM_WRITE_SYNC (0x1) + +/* Version identifier + Warning: Do not change this version number unless coordinated with + external callers, for example TSM, of GPFS dmapi library. + */ +#define DM_VER_STR_CONTENTS "GPFS DMAPI 4.10" + +struct dm_inherit +{ + dm_attrname_t ih_name; + mode_t ih_filetype; +}; +typedef struct dm_inherit dm_inherit_t; + +#endif /* _DMAPI_TYPES_H */ diff --git a/System/ior/files/gpfs/5.0.2-3/include/gpfs.h b/System/ior/files/gpfs/5.0.2-3/include/gpfs.h new file mode 100644 index 0000000..75ed4f3 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/gpfs.h @@ -0,0 +1,4047 @@ +/* */ +/* 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.2.212 src/avs/fs/mmfs/ts/util/gpfs.h, mmfs, avs_rtac502, rtac5021836a 8/23/18 07:58:19 */ +/* + * Library calls for GPFS interfaces + */ +#ifndef H_GPFS +#define H_GPFS + +#include + +/* 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 46 + +#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_XATTR_CHANGE = 17, /* EAs of file are changed */ + GPFS_LWE_EVENT_ACL_CHANGE = 18, /* ACLs (both GPFS ACLs and Posix permissions) of a file are changed */ + GPFS_LWE_EVENT_CREATE = 19, /* create, including mkdir, symlink, special file */ + GPFS_LWE_EVENT_GPFSATTR_CHANGE = 20, /* ts-specific attributes of file are changed */ + GPFS_LWE_EVENT_FILETRUNCATE = 21, /* "File Truncate Event" 'TRUNCATE' */ + + GPFS_LWE_EVENT_MAX = 22, /* 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 GPFS_LWE_ATTRCHANGEEVENT_IMMUTABILITY (0x8) +#define GPFS_LWE_ATTRCHANGEEVENT_APPENDONLY (0x10) + + + +/* + * 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; /* " : " */ + +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 */ diff --git a/System/ior/files/gpfs/5.0.2-3/include/gpfs_fcntl.h b/System/ior/files/gpfs/5.0.2-3/include/gpfs_fcntl.h new file mode 100644 index 0000000..e9f3840 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/gpfs_fcntl.h @@ -0,0 +1,1137 @@ +/* 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. + * + */ +/* @(#)51 1.85 src/avs/fs/mmfs/ts/kernext/gpfs_fcntl.h, mmfs, avs_rtac502, rtac5021836a 7/24/18 07:37:06 */ + +/* + * GPFS interface definitions for supporting I/O hints and directives. + * + * Usage: The argument to gpfs_fcntl is composed of the concatenation of + * structures defined in this file. The first structure must be of type + * gpfsFcntlHeader_t. This is immediately followed by additional + * structures, one for each hint or directive supplied. The totalLength + * field of the header contains the length of all of the structures, + * including the header itself. Each structure is defined to be a multiple + * of 8 bytes in length, and the highest alignment requirement of any of the + * data types is also 8 bytes, so the compiler will not insert padding when + * several structures are declared within an outer structure. This makes + * it easier to build up the necessary area before calling gpfs_fcntl. + * + * For example, the following code fragment first releases all cached data + * held on behalf of a file, then tells GPFS that this node will write + * the portion of the file with file offsets between 2G and 3G-1: + * struct + * { + * gpfsFcntlHeader_t hdr; + * gpfsClearFileCache_t rel; + * gpfsAccessRange_t acc; + * } arg; + * + * arg.hdr.totalLength = sizeof(arg); + * arg.hdr.fcntlVersion = GPFS_FCNTL_CURRENT_VERSION; + * arg.hdr.fcntlReserved = 0; + * arg.rel.structLen = sizeof(arg.rel); + * arg.rel.structType = GPFS_CLEAR_FILE_CACHE; + * arg.acc.structLen = sizeof(arg.acc); + * arg.acc.structType = GPFS_ACCESS_RANGE; + * arg.acc.start = 2LL * 1024LL * 1024LL * 1024LL; + * arg.acc.length = 1024 * 1024 * 1024; + * arg.acc.isWrite = 1; + * rc = gpfs_fcntl(handle, &arg); + * + * If gpfs_fcntl returns an error (rc -1), errno will contain the error + * reason, and the errorOffset field of the header will contain the offset + * of the offending structure within the argument area. + * + * In general, the structures within the argument are processed in order. + */ + +#ifndef _h_gpfs_fcntl +#define _h_gpfs_fcntl + +/* open source interfaces */ +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* Header of the parameter area passed to gpfs_fcntl */ +typedef struct +{ + int totalLength; /* length of this structure plus the sum of + the lengths of all structures in this + gpfs_fcntl argument */ + int fcntlVersion; /* version number: GPFS_FCNTL_CURRENT_VERSION */ + int errorOffset; /* returned value giving offset into parameter + area of the structure to which errno + pertains. Only set if errno is set. */ + int fcntlReserved; /* not used, should be set to 0 */ +} gpfsFcntlHeader_t; + +/* Moved it here from tshints.C, since function tschattr also uses it while + * filling in errReason into argument structure. */ +typedef struct +{ + int structLen; /* length of the entire argument */ + int structType; /* identifier of the hint */ +} genericStruct_t; + + +/* Interface version number (fcntlVersion field of gpfsFcntlHeader_t) */ +#define GPFS_FCNTL_CURRENT_VERSION 1 + +/* Maximum length of argument to gpfs_fcntl */ +#define GPFS_MAX_FCNTL_LENGTH 65536 + +/* Maximum length of a name argument passed to or returned from gpfs_fcntl. + Length of buffer must be a multiple of 8. */ +#define GPFS_FCNTL_MAX_NAME_BUFFER 1024 +#define GPFS_FCNTL_MIN_NAME_BUFFER 8 + + +/* Definitions of structType fields for GPFS hints. Hints can be ignored + by GPFS without affecting correct operation, although performance might + suffer. */ +#define GPFS_ACCESS_RANGE 1001 +#define GPFS_FREE_RANGE 1002 +#define GPFS_MULTIPLE_ACCESS_RANGE 1003 +#define GPFS_CLEAR_FILE_CACHE 1004 + +/* Definitions of structType fields for GPFS directives. GPFS must honor + directives, or return an error saying why a directive could not be + honored. */ +#define GPFS_CANCEL_HINTS 2001 +#define GPFS_FCNTL_SET_REPLICATION 2005 +#define GPFS_FCNTL_SET_STORAGEPOOL 2006 +#define GPFS_FCNTL_RESTRIPE_DATA 2007 +#define GPFS_FCNTL_RESTRIPE_RANGE 2008 + +#define GPFS_FCNTL_FSYNC_RANGE 2009 +#define GPFS_FCNTL_COMPRESSION_ON 2010 +#define GPFS_FCNTL_COMPRESSION_OFF 2011 +#define GPFS_FCNTL_COMPRESSION_LIB 2012 + +/* Definitions of structType fields for GPFS inquiries. Inquiries merely + return GPFS attributes of existing files. */ +#define GPFS_FCNTL_GET_REPLICATION 3001 +#define GPFS_FCNTL_GET_STORAGEPOOL 3002 +#define GPFS_FCNTL_GET_FILESETNAME 3003 +#define GPFS_FCNTL_GET_SNAPSHOTNAME 3004 +#define GPFS_FCNTL_GET_DATABLKDISKIDX 3005 /* obsoleted */ +#define GPFS_FCNTL_GET_DATABLKLOC 3006 +#define GPFS_FCNTL_GET_COMPRESSION 3007 +#define GPFS_FCNTL_GET_COMPRESSION_SUPPORT 3008 +#ifdef SNAPSHOT_ILM +#define GPFS_FCNTL_GET_SNAP_MIGRATION_SUPPORT 3009 +#endif + + +/* Structures for specifying the various gpfs_fcntl hints */ + +/* Access range hint: The application will soon access file offsets within + the given range, and will not access offsets outside the range. Violating + this hint may produce worse performance than if no hint was specified. */ +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* hint identifier: GPFS_ACCESS_RANGE */ + long long start; /* start offset in bytes from beginning of file */ + long long length; /* length of range; 0 indicates to end of file */ + int isWrite; /* 0 - read access, 1 - write access */ + char padding[4]; +} gpfsAccessRange_t; + + +/* Free range hint: the application will no longer access file offsets + within the given range, so GPFS is free to flush those file offsets from + its cache. */ +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* hint identifier: GPFS_FREE_RANGE */ + long long start; /* start offset in bytes from beginning of file */ + long long length; /* length of range; 0 indicates to end of file */ +} gpfsFreeRange_t; + + +/* Format of accRangeArray and relRangeArray entries used by + GPFS_MULTIPLE_ACCESS_RANGE hint */ +typedef struct +{ + long long blockNumber; /* data block number to access */ + int start; /* start of range (from beginning of block) */ + int length; /* number of bytes in the range */ + int isWrite; /* 0 - read access, 1 - write access */ + char padding[4]; +} gpfsRangeArray_t; + +/* Multiple access range hint: This hint is used to drive application-defined + prefetching and writebehind. The application will soon access the + portions of the blocks specified in accRangeArray, and has finished + accessing the ranges listed in relRangeArray. The size of a block is + returned by stat in the st_blksize field, so offset OFF of a file is in + block OFF/st_blksize. Up to GPFS_MAX_RANGE_COUNT blocks may be given in + one multiple access range hint. Depending on the current load, GPFS may + initiate prefetching of some or all of these. Each range named in + accRangeArray that is accepted for prefetching should eventually be + released via relRangeArray, or else GPFS will stop prefetching blocks + for this file. */ +#define GPFS_MAX_RANGE_COUNT 8 +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* hint identifier: GPFS_MULTIPLE_ACCESS_RANGE */ + int accRangeCnt; /* on input, number of ranges in accRangeArray + on output, number of processed ranges (the + first n of the given ranges) */ + int relRangeCnt; /* number of ranges in relRangeArray */ + gpfsRangeArray_t accRangeArray[GPFS_MAX_RANGE_COUNT]; /* requested ranges */ + gpfsRangeArray_t relRangeArray[GPFS_MAX_RANGE_COUNT]; /* ranges to release */ +} gpfsMultipleAccessRange_t; + + +/* Clear file cache hint: the application expects to no longer access any + portion of the file, so GPFS should flush and invalidate any cached + data belonging to this file. This may avoid synchronous cache invalidations + on later uses of the file by other nodes. */ +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* hint identifier: GPFS_CLEAR_FILE_CACHE */ +} gpfsClearFileCache_t; + + + +/* Structures for specifying the various gpfs_fcntl directives */ + +/* Cancel all hints: GPFS removes any hints that may have been issued + against this file. Does not affect the contents of the GPFS file cache. + Note that this directive does not cancel the effects of other directives, + such as GPFS_CANCEL_HINTS. */ +typedef struct /* cancelAccessHints hint */ +{ + int structLen; /* length of this structure */ + int structType; /* hint identifier: GPFS_CANCEL_HINTS */ +} gpfsCancelHints_t; + + +/* This directive is used to set a file's replication factors. + However, the directive does not cause the file data to be restriped + immediately. Instead the caller must append a gpfsRestripeData_t directive + or invoke an mmrestripefs or an mmrestripefile command. */ +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* directive identifier: + GPFS_FCNTL_SET_REPLICATION */ + int metadataReplicas; /* Set the number of copies of the file's + indirect blocks. Valid values are 1-3, + but not greater than the value of + maxMetadataReplicas. A value of 0 indicates + not to change the current value. */ + int maxMetadataReplicas; /* Set the maximum number of copies of a file's + indirect blocks. Space in the file's inode + and indirect blocks is reserved for the + maximum number of copies, regardless of the + current value. Valid values are 1-3. + A value of 0 indicates not to change the + current value. */ + int dataReplicas; /* Set the number of copies of the file's + data blocks. Valid values are 1-3, + but cannot be greater than the value of + maxDataReplicas. A value of 0 indicates + not to change the current value. */ + int maxDataReplicas; /* Set the maximum number of copies of a file's + data blocks. Space in the file's inode + and indirect blocks is reserved for the + maximum number of copies, regardless of the + current value. Valid values are 1-3. + A value of 0 indicates not the change the + current value. */ + int errReason; /* returned reason request failed. + Defined below. */ + int errValue1; /* returned value depending upon errReason */ + int errValue2; /* returned value depending upon errReason */ + int reserved; /* unused, but should be set to 0 */ +} gpfsSetReplication_t; + + + +/* Values that may be returned by errReason */ + +/* No reason information was returned. */ +#define GPFS_FCNTL_ERR_NONE 0 + +/* MetadataReplicas is out of range. + errValue1 and errValue2 contain the valid lower and upper range boundaries. */ +#define GPFS_FCNTL_ERR_METADATA_REPLICAS_RANGE 1 + +/* MaxMetadataReplicas is out of range. + errValue1 and errValue2 contain the valid lower and upper range boundaries. */ +#define GPFS_FCNTL_ERR_MAXMETADATA_REPLICAS_RANGE 2 + +/* DataReplicas is out of range. + errValue1 and errValue2 contain the valid lower and upper range boundaries. */ +#define GPFS_FCNTL_ERR_DATA_REPLICAS_RANGE 3 + +/* MaxDataReplicas is out of range. + errValue1 and errValue2 contain the valid lower and upper range boundaries. */ +#define GPFS_FCNTL_ERR_MAXDATA_REPLICAS_RANGE 4 + +/* An attempt to change maxMetadataReplicas or maxDataReplicas or both + was made on a file that is not empty. */ +#define GPFS_FCNTL_ERR_FILE_NOT_EMPTY 5 + +/* MetadataReplicas or dataReplicas or both exceed the number of failure groups. + errValue1 contains the maximum number of metadata failure groups. + errValue2 contains the maximum number of data failure groups. */ +#define GPFS_FCNTL_ERR_REPLICAS_EXCEED_FGMAX 6 + + +/* This directive is used to set a file's assigned storage pool. + However, the directive does not cause the file data to be migrated + immediately. Instead the caller must append a gpfsRestripeData_t + directive or invoke a mmrestripefs or mmrestripefile command. + The caller must have root privileges to change a file's storage pool. */ +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* directive identifier: + GPFS_FCNTL_SET_STORAGEPOOL */ + int errReason; /* returned reason request failed. + Defined below. */ + int errValue1; /* returned value depending upon errReason */ + int errValue2; /* returned value depending upon errReason */ + int reserved; /* unused, but should be set to 0 */ + char buffer[GPFS_FCNTL_MAX_NAME_BUFFER]; /* Null-terminated name of + storage pool to be assigned */ +} gpfsSetStoragePool_t; + + +/* Values that may be returned by errReason */ + +/* Invalid storage pool name was given. */ +#define GPFS_FCNTL_ERR_INVALID_STORAGE_POOL 7 + +/* Invalid storage pool. File cannot be assigned to given pool. */ +#define GPFS_FCNTL_ERR_INVALID_STORAGE_POOL_TYPE 8 + +/* Invalid storage pool. Directories cannot be assigned to given pool. */ +#define GPFS_FCNTL_ERR_INVALID_STORAGE_POOL_ISDIR 9 + +/* Invalid storage pool. System files cannot be assigned to given pool. */ +#define GPFS_FCNTL_ERR_INVALID_STORAGE_POOL_ISLNK 10 + +/* Invalid storage pool. System files cannot be assigned to given pool. */ +#define GPFS_FCNTL_ERR_INVALID_STORAGE_POOL_ISSYS 11 + +/* File system has not been upgraded to support storage pools */ +#define GPFS_FCNTL_ERR_STORAGE_POOL_NOTENABLED 12 + +/* User does not have permission to perform the requested operation */ +#define GPFS_FCNTL_ERR_NOPERM 13 + + + + +/* This directive is used to restripe a file's data blocks to update + its replication and/or migrate its data. The data movement is always + done immediately. */ + +typedef struct +{ + long long startOffset; /* start of range to restripe in bytes */ + long long numOfBlks; /* blocks (size st_blksize) to restripe */ +} gpfsByteRange_t; + +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* directive identifier: + GPFS_FCNTL_RESTRIPE_FILE */ + int options; /* options for restripe command. Defined below. + See mmrestripefs command for details. */ + int errReason; /* returned reason request failed. + Defined below. */ + int errValue1; /* returned value depending upon errReason */ + int errValue2; /* returned value depending upon errReason */ + int reserved1; /* unused, but should be set to 0 */ + int reserved2; /* unused, but should be set to 0 */ +} gpfsRestripeData_t; + +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* directive identifier: + GPFS_FCNTL_RESTRIPE_RANGE */ + int options; /* options for restripe command. Defined below. + See mmrestripefs command for details. */ + int errReason; /* returned reason request failed. + Defined below. */ + int errValue1; /* returned value depending upon errReason */ + int errValue2; /* returned value depending upon errReason */ + gpfsByteRange_t range; /* Should be zero unless + GPFS_FCNTL_RESTRIPE_RANGE_R is set */ + int reserved1; /* unused, but should be set to 0 */ + int reserved2; /* unused, but should be set to 0 */ +} gpfsRestripeRange_t; + +typedef struct { + long long blkNum; + long long diskNum; + long long sector; +} BadBlock; + +/* Maximum length of output buffer in gpfsRestripeRange_t */ +#define MAX_COMP_BUF_LEN (64 * 1024) +/* Maximum count of BadBlock that can be stored in output buffer */ +#define MAX_COMP_BLOCK_NUM ((MAX_COMP_BUF_LEN - sizeof(long long)) / sizeof(BadBlock)) + +typedef struct BadBlockInfo { + long long nBadBlocks; /* number of bad blocks */ + BadBlock badBlocks[0]; /* bad block info array */ +} BadBlockInfo_t; + +/* Difference between gpfsRestripeRange_t and gpfsRestripeRangeV2_t + is that gpfsRestripeRangeV2_t has an outBuf which could be used + to pass information from daemon back to caller. Currently, only + GPFS_FCNTL_RESTRIPE_CM uses the buffer. */ +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* directive identifier: + GPFS_FCNTL_RESTRIPE_RANGE */ + int options; /* options for restripe command. Defined below. + See mmrestripefs command for details. */ + int errReason; /* returned reason request failed. + Defined below. */ + int errValue1; /* returned value depending upon errReason */ + int errValue2; /* returned value depending upon errReason */ + gpfsByteRange_t range; /* Should be zero unless + GPFS_FCNTL_RESTRIPE_RANGE_R is set */ + int reserved1; /* unused, but should be set to 0 */ + int reserved2; /* unused, but should be set to 0 */ + + /* Fields above should be kept the same as gpfsRestripeRange_t. */ + + char *outBuf; /* buffer to store daemon returned info + Caller is responsible to allocate + and deallocate the buffer. + Now only GPFS_FCNTL_RESTRIPE_CM use it + to return bad replica info. */ + int bufLen; /* length of the buffer */ + + int reserved3; /* unused, but should be set to 0 */ +} gpfsRestripeRangeV2_t; + +/* Define values for restripe options. + See mmrestripefs command for complete definitions. */ + +/* Migrate critical data off of suspended disks. */ +#define GPFS_FCNTL_RESTRIPE_M 0x0001 + +/* Replicate data against subsequent failure. */ +#define GPFS_FCNTL_RESTRIPE_R 0x0002 + +/* Place file data in assigned storage pool. */ +#define GPFS_FCNTL_RESTRIPE_P 0x0004 + +/* Rebalance file data */ +#define GPFS_FCNTL_RESTRIPE_B 0x0008 + +/* Restripe a range of file data. On input, the start of the range is given by + range.startOffset (in bytes) and the size is given by range.numOfBlks (using + a block size of st_blksize). If range startOffset is beyond EOF (strictly + greater than st_size for files, and inode.fileSize for directories) + gpfs_fcntl() fails and sets errno to ERANGE. Upon success, range.numOfBlks + is updated to be the last block number that was processed. Thus, the next + iteration should set startOffset to (numOfBlks + 1) * st_blksize. */ +#define GPFS_FCNTL_RESTRIPE_RANGE_R 0x0010 + +/* Compress or uncompress a file according to the compression bit of the file */ +#define GPFS_FCNTL_RESTRIPE_C 0x0020 +/* Compress or uncompress a range according to the compression bit of the file */ +#define GPFS_FCNTL_RESTRIPE_RC 0x0040 + +/* Relocate file data */ +#define GPFS_FCNTL_RESTRIPE_L 0x0080 + +/* Compare file data */ +#define GPFS_FCNTL_RESTRIPE_CM 0x0100 + +/* Fast file system rebalance option */ +#define GPFS_FCNTL_RESTRIPE_B_FAST 0x200 + +/* Compare file data but do not fix mismatch */ +#define GPFS_FCNTL_RESTRIPE_CM_RO 0x0400 + +/* Values that may be returned by errReason */ + +/* Not enough replicas could be created because the desired degree + of replication is larger than the number of failure groups. */ +#define GPFS_FCNTL_ERR_NO_REPLICA_GROUP 14 + +/* Not enough replicas could be created because there was not + enough space left in one of the failure groups. */ +#define GPFS_FCNTL_ERR_NO_REPLICA_SPACE 15 + +/* There was not enough space left on one of the disks to properly + balance the file according to the current stripe method. */ +#define GPFS_FCNTL_ERR_NO_BALANCE_SPACE 16 + +/* The file could not be properly balanced because one or more + disks are unavailable. */ +#define GPFS_FCNTL_ERR_NO_BALANCE_AVAILABLE 17 + +/* All replicas were on disks that have since been deleted + from the stripe group. */ +#define GPFS_FCNTL_ERR_ADDR_BROKEN 18 + +/* No immutable attribute can be set on directories */ +#define GPFS_FCNTL_ERR_NO_IMMUTABLE_DIR 19 + +/* No immutable attribute can be set on system files */ +#define GPFS_FCNTL_ERR_NO_IMMUTABLE_SYSFILE 20 + +/* Immutable and indefinite retention flag wrong */ +#define GPFS_FCNTL_ERR_IMMUTABLE_FLAG 21 + +/* Immutable and indefinite retension flag wrong */ +#define GPFS_FCNTL_ERR_IMMUTABLE_PERM 22 + +/* AppendOnly flag should be set separately */ +#define GPFS_FCNTL_ERR_APPENDONLY_CONFLICT 23 + +/* Cannot set immutable or appendOnly on snapshots */ +#define GPFS_FCNTL_ERR_NOIMMUTABLE_ONSNAP 24 + +/* An attempt to change maxDataReplicas or maxMetadataReplicas + was made on a file that has extended attributes. */ +#define GPFS_FCNTL_ERR_FILE_HAS_XATTRS 25 + +/* This file is not part of a GPFS file system */ +#define GPFS_FCNTL_ERR_NOT_GPFS_FILE 26 + + + + + + +/* Values that may be returned by errValue1 */ + +/* Strict replica allocation option set to be yes */ +#define GPFS_FCNTL_STATUS_STRICT_REPLICA_YES 0x0010 + +/* Strict replica allocation option set to be no */ +#define GPFS_FCNTL_STATUS_STRICT_REPLICA_NO 0x0020 + +/* Strict replica allocation option set to be whenpossible */ +#define GPFS_FCNTL_STATUS_STRICT_REPLICA_WHENPOSSIBLE 0x0040 + +/* Structures for specifying the various gpfs_fcntl inquiries. + The inquiry directives may be used to obtain attributes of a file + such as the file's replication factors, storage pool name, + fileset name or snapshot name. */ + +/* This inquiry is used to obtain a file's replication factors. */ +typedef struct + { + int structLen; /* length of this structure */ + int structType; /* inquiry identifier: + GPFS_FCNTL_GET_REPLICATION */ + int metadataReplicas; /* returns the current number of copies + of indirect blocks for the file. */ + int maxMetadataReplicas; /* returns the maximum number of copies + of indirect blocks for the file. */ + int dataReplicas; /* returns the current number of copies + of data blocks for the file. */ + int maxDataReplicas; /* returns the maximum number of copies + of data blocks for the file. */ + int status; /* returns the status of the file. + Status values defined below. */ + int reserved; /* unused, but should be set to 0 */ +} gpfsGetReplication_t; + + +/* Flag definitions */ + +/* If set this file may have some broken data block. */ +#define GPFS_FCNTL_STATUS_BROKEN 0x80000000 + +/* If set this file may have some data where the only replicas are + on suspended disks; implies some data may be lost if suspended + disks are removed. */ +#define GPFS_FCNTL_STATUS_EXPOSED 0x40000000 + +/* If set this file may not be properly replicated, i.e. some data + may have fewer or more than the desired number of replicas, + or some replicas may be on suspended disks. */ +#define GPFS_FCNTL_STATUS_ILLREPLICATED 0x20000000 + +/* If set this file may not be properly balanced. */ +#define GPFS_FCNTL_STATUS_UNBALANCED 0x10000000 + +/* If set this file has stale data blocks on at least one of the disks + that are marked as unavailable or recovering in the stripe group + descriptor. */ +#define GPFS_FCNTL_STATUS_DATAUPDATEMISS 0x08000000 + +/* If set this file has stale indirect blocks on at least one + unavailable or recovering disk. */ +#define GPFS_FCNTL_STATUS_METAUPDATEMISS 0x04000000 + +/* If set this file may not be properly placed, i.e. some data may + be stored in an incorrect storage pool */ +#define GPFS_FCNTL_STATUS_ILLPLACED 0x02000000 +#define GPFS_FCNTL_STATUS_ILLCOMPRESSED 0x01000000 + +#define GPFS_FCNTL_STATUS_FPO_ILLPLACED 0X00800000 + + + +/* This inquiry is used to obtain the name of the storage pool in which + the file's data is stored. The size of the buffer may vary, but it must be + a multiple of 8. Upon successful completion of the call, the buffer + will contain a null-terminated character string for the name of the + file's storage pool. */ +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* inquiry identifier: + GPFS_FCNTL_GET_STORAGEPOOL */ + char buffer[GPFS_FCNTL_MAX_NAME_BUFFER]; /* returns the file's + storage pool name */ +} gpfsGetStoragePool_t; + + +/* This inquiry is used to obtain the name of the fileset to which this + file has been assigned. The size of the buffer may vary, but it must be + a multiple of 8. Upon successful completion of the call, the buffer + will contain a null-terminated character string for the name of the + file's fileset. */ +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* inquiry identifier: + GPFS_FCNTL_GET_FILESETNAME */ + char buffer[GPFS_FCNTL_MAX_NAME_BUFFER]; /* returns with the file's + fileset name */ +} gpfsGetFilesetName_t; + + +/* This inquiry is used to obtain the name of the snapshot that includes + this file. If the file is not part of a snapshot, then a zero-length + string will be returned. The size of the buffer may vary, but it must be + a multiple of 8. Upon successful completion of the call, the buffer + will contain a null-terminated character string for the name of the + snapshot that includes this file. */ +typedef struct { + int structLen; /* length of this structure */ + int structType; /* inquiry identifier: + GPFS_FCNTL_GET_SNAPSHOTNAME */ + char buffer[GPFS_FCNTL_MAX_NAME_BUFFER]; /* returns with the file's + snapshot name */ +} gpfsGetSnapshotName_t; + +/* Allow tschattr to change file immutable attribute */ +#define GPFS_FCNTL_SET_IMMUTABLE 5000 + +typedef struct { + int structLen; /* length of this structure */ + int structType; /* function identifier: + GPFS_FCNTL_SET_IMMUTABLE */ + int setImmutable; /* value to set the immutable flag */ + int setIndefiniteRetention; /* value to set IndefiniteRetention */ + int errReasonCode; /* reason code */ + int reserved; /* reserved field */ +} gpfsSetImmutable_t; + +#define GPFS_FCNTL_GET_IMMUTABLE 5001 + +typedef struct { + int structLen; /* length of this structure */ + int structType; /* function identifier: + GPFS_FCNTL_GET_IMMUTABLE */ + int immutable; /* value of the immutable flag */ + int indefiniteRetention; /* value of the indefiniteRetention flag */ + int errReasonCode; /* reason code */ + int reserved; /* reserved field */ +} gpfsGetImmutable_t; + +#define GPFS_FCNTL_SET_EXPIRATION_TIME 5002 + +typedef struct { + int structLen; /* length of this structure */ + int structType; /* function identifier: + GPFS_FCNTL_SET_IMMUTABLE */ + long long expTime; /* expiration time */ + int errReasonCode; /* reason code */ + int reserved; /* reserved field */ +} gpfsSetExpTime_t; + +#define GPFS_FCNTL_GET_EXPIRATION_TIME 5003 + +typedef struct { + int structLen; /* length of this structure */ + int structType; /* function identifier: + GPFS_FCNTL_GET_EXPIRATION_TIME */ + long long expTime; /* expiration Time */ + int errReasonCode; /* reason code */ + int reserved; /* reserved field */ +} gpfsGetExpTime_t; + + +#define GPFS_FCNTL_SET_APPENDONLY 5004 + +typedef struct { + int structLen; /* length of this structure */ + int structType; /* function identifier: + GPFS_FCNTL_SET_APPENDONLY */ + int setAppendOnly; /* value to set the appendOnly flag */ + int setIndefiniteRetention; /* value to set IndefiniteRetention */ + int errReasonCode; /* reason code */ + int reserved; /* reserved field */ +} gpfsSetAppendOnly_t; + +#define GPFS_FCNTL_GET_APPENDONLY 5005 + +typedef struct { + int structLen; /* length of this structure */ + int structType; /* function identifier: + GPFS_FCNTL_GET_APPENDONLY */ + int appendOnly; /* value of the appendOnly flag */ + int indefiniteRetention; /* value of the indefiniteRetention flag */ + int errReasonCode; /* reason code */ + int reserved; /* reserved field */ +} gpfsGetAppendOnly_t; + + +/* Deprecated in favor of calling gpfs_prealloc(fd, 0, 0). */ +#define GPFS_FCNTL_COMPACT_DIR 5006 + +typedef struct { + int structLen; /* length of this structure */ + int structType; /* function identifier: + GPFS_FCNTL_COMPACT_DIR */ + int errReasonCode; /* reason code */ + int reserved; /* reserved field */ +} gpfsCompactDir_t; + + + +/* + * Provide access to a file's extended attributes + * + * Extended attributes are persistent name,value pairs assigned to files or + * directories. The name is typically a character string which is terminated + * by a null ('\0') character which is included in the name length. + * Attributes set internally or for dmapi may follow other conventions. + * An attributes's value is a binary string which is not interpreted + * by this api. + * + * Attribute names are typically divided into namespaces, both to avoid + * collisions and to enforce access controls. The namespaces currently + * defined are: + * + * "user." -- requires permission to access file data + * "system." -- used by kernel for access control lists + * "trusted." -- requires admin/root privilege + * "security." -- used by Security Enhanced Linux + * "archive." -- reserved for GPFS + * "dmapi." -- reserved for the X/Open Data Storage Management API (XDSM) + * "gpfs." -- reserved for GPFS + * + * For example, "user.name1" or "system.posix_acl_default". + * Additional namespaces may be defined in future releases. Users should + * restrict the names used to a predefined namespace. + * + * Setting or resetting attributes reserved by GPFS or other middleware + * services may have unintended consequences and is not recommended. + * + * Attributes are created via the SET_XATTR call with a value length of + * zero or more bytes. By default, setting an extended attribute will create + * the attribute if it does not exist or will replace the current value if + * it does. Using the CREATE flag causes a pure create which fails if the + * attribute already exists. Likewise using the REPLACE flag causes a pure + * replace which fails if the attribute does not exist. + * + * Attributes are deleted by calling SET_XATTR with a negative length. Using + * the DELETE flag causes a pure delete which fails if the attribute does + * not exist. + * + * By default, setting or deleting an extended attribute is done + * asynchronously. That is to say, the update is not written to disk until + * some time after the call completes. Using the SYNC option causes the + * update to be committed to disk before the call completes. The update + * to a single attribute is always done atomically. Either the original value + * is retained or the complete new value will be set. + * + * More than one attribute may be set or deleted within a single fcntl call. + * The updates are applied in the order specified in the fcntl vector. + * If the file system fails, there is no guarantee that all updates will + * be applied, even if using the SYNC options. If sync is specified on the + * last update in the vector, then all prior updates to attributes will also + * be written with the final update. + * + * In order to see an attribute via the GET_XATTR or LIST_XATTR call + * the caller must have sufficient privilege to set the attribute. + * + * Errors are returned in the errReturnCode field. + * + * + * Note: Extended attributes are stored as character or binary strings. + * Care should be taken when used on mixed architectures with different + * byte orders or word sizes to insure the attribute values are in an + * architecture independent format. + * + */ +#define GPFS_FCNTL_GET_XATTR 6001 +#define GPFS_FCNTL_SET_XATTR 6002 +#define GPFS_FCNTL_LIST_XATTR 6003 + +#define GPFS_FCNTL_XATTR_MAX_NAMELEN 256 /* includes trailing null char */ +#define GPFS_FCNTL_XATTR_MAX_VALUELEN (16 * 1024) + +#define GPFS_FCNTL_XATTRFLAG_NONE 0x0000 +#define GPFS_FCNTL_XATTRFLAG_SYNC 0x0001 /* synchronous update + All updates are committed + before the call returns */ +#define GPFS_FCNTL_XATTRFLAG_CREATE 0x0002 /* pure create + will fail if already exists */ +#define GPFS_FCNTL_XATTRFLAG_REPLACE 0x0004 /* pure replace + will fail if does not exist */ +#define GPFS_FCNTL_XATTRFLAG_DELETE 0x0008 /* pure delete + will fail if does not exist */ +#define GPFS_FCNTL_XATTRFLAG_NO_CTIME 0x0010 /* Update will not set ctime. + Must have admin authority. */ +#define GPFS_FCNTL_XATTRFLAG_MO_PARENT 0x0020 /* Update clone parent. + Must have admin authority. */ +#define GPFS_FCNTL_XATTRFLAG_RESERVED 0x8000 /* obsolete */ + +/* Define error reason codes for extended attributes */ +#define GPFS_FCNTL_ERR_NO_ATTR 27 +#define GPFS_FCNTL_ERR_ATTR_EXISTS 28 +#define GPFS_FCNTL_ERR_BUFFER_TOO_SMALL 29 +#define GPFS_FCNTL_ERR_NO_ATTR_SPACE 30 +#define GPFS_FCNTL_ERR_INVAL_VALUE 31 + + + +typedef struct { + int structLen; /* length of this structure */ + int structType; /* function identifier: + GPFS_FCNTL_GET_XATTR + or GPFS_FCNTL_SET_XATTR */ + int nameLen; /* length of attribute name + may include trailing '\0' character */ + int bufferLen; /* + for GPFS_FCNTL_GET_XATTR + INPUT: length of buffer + OUTPUT: length of attribute value + + for GPFS_FCNTL_SET_XATTR + INPUT: length of attribute value + length = -1 to delete attribute */ + unsigned int flags; /* defined above. */ + int errReasonCode; /* reason code */ + char buffer[0]; /* buffer for name and value. + + for GPFS_FCNTL_GET_XATTR + + INPUT: name begins at offset 0 + and must be null terminated. + OUTPUT: name is returned unchanged + value begins at nameLen rounded up + to a multiple of 8. + + for GPFS_FCNTL_SET_XATTR + + INPUT: name begins at offset 0 + and must be null terminated. + value begins at nameLen rounded up + to a multiple of 8. + + actual length of buffer should be + nameLen rounded up to a multiple of 8 + + valueLen rounded up to a multiple of 8 + + Buffer size set by caller. Maximum + size is (GPFS_FCNTL_XATTR_MAX_NAMELEN + + GPFS_FCNTL_XATTR_MAX_VALUELEN) */ +} gpfsGetSetXAttr_t; + +typedef struct { + int structLen; /* length of this structure */ + int structType; /* function identifier: + GPFS_FCNTL_LIST_XATTR */ + int bufferLen; /* INPUT: length of buffer + OUTPUT: length of returned list of names */ + int errReasonCode; /* reason code */ + char buffer[0]; + /* buffer for returned list of names + Each attribute name is prefixed with + a 1-byte name length. The next attribute name + follows immediately in the buffer (and is + prefixed with its own length). Following + the last name a '\0' is appended to + terminate the list. The returned bufferLen + includes the final '\0'. + + \6abcdef\3ABC\9user.name\0 + + Caution: An attribute name may include embedded + and/or trailing null bytes: + + \13gpfs.DIRECTIO\11dmapi.t\1\0\3\0\0 + + The actual length of the buffer required + depends on the number of attributes set on + the file and the length of each attribute name. + If the buffer provided is too small for all + of the returned names, the errReasonCode + will be set to GPFS_FCNTL_ERR_BUFFER_TOO_SMALL + and bufferLen will be set to the minimum + size buffer required to list all attributes. + An initial buffer length of 0 may be used to + query the attributes and determine the + correct buffer size for this file. */ + +} gpfsListXAttr_t; + + + + + + +typedef struct OffsetLoc { + long long offset; + int diskNum[]; /* array of locations based on number of replicas returned */ +} OffsetLoc; + +typedef struct FilemapIn { + long long startOffset; /* start offset in bytes */ + long long skipfactor; /* number of bytes to skip before next offset read */ + long long length; /* number of bytes (start offset + length / skipfactor = numblks returned */ + int mreplicas; /* number of replicas user wants. 0 - all, + 1 - primary, 2 - primary and 1st replica, 3 - all */ + int reserved; /* for now to align it to the 8byte boundary */ +} FilemapIn; + +typedef struct FilemapOut { + int numReplicasReturned; + int numBlksReturned; + int blockSize; + int blockSizeHigh; /* High 32bits of block size */ + char buffer [GPFS_MAX_FCNTL_LENGTH-1024]; /* packs offset, disklocation1, disklocation2.... */ +} FilemapOut; + +typedef struct GetDataBlkDiskIdx { + int structLen; /* length of this structure */ + int structType; /* function identifier: + GPFS_FCNTL_GET_DATABLKDISKIDX */ + FilemapIn filemapIn; /* Input parameters specified by the user */ + FilemapOut filemapOut; /* Output data */ +} GetDataBlkDiskIdx; +typedef struct GetDataBlkDiskIdx gpfsGetDataBlkDiskIdx_t; + +typedef struct { + int structLen; /* length of this structure */ + int structType; /* function identifier: + GPFS_FCNTL_FSYNC_RANGE */ + int how; + long long startOffset; + long long length; +} gpfsFsyncRange_t; + +#define GPFS_FCNTL_ERR_COMPRESS_NOTREGULAR 32 +#define GPFS_FCNTL_ERR_COMPRESS_CLONE 33 +#define GPFS_FCNTL_ERR_COMPRESS_SNAPSHOT 34 +#define GPFS_FCNTL_ERR_COMPRESS_OLD_FILESYSTEM 35 +#define GPFS_FCNTL_ERR_COMPRESS_AFM 36 +#define GPFS_FCNTL_ERR_COMPRESS_HYPERALLOC 37 +#define GPFS_FCNTL_ERR_COMPRESS_NOT_ALLOWED 38 + +#define GPFS_FCNTL_ERR_COMPARE_DATA_IN_INODE 39 +#define GPFS_FCNTL_ERR_COMPRESS_LIB_SELECT 40 +#define GPFS_FCNTL_ERR_COMPRESS_LIB_SUPPORT 41 +#define GPFS_FCNTL_ERR_COMPRESS_LIB_LOAD_FAILED 42 +#define GPFS_FCNTL_ERR_DISK_OFFLINE 43 + +/* Turn on or off compression. Zlib compression library is selected by default when using + this GPFS_FCNTL_COMPRESSION_ON structType/directive. Use gpfsSetCompressionLib_t, + with GPFS_FCNTL_COMPRESSION_LIB directive (defined below) to select any other supported + compression library (lz4 is currently supported). This directive only flags the file to + be compressed or uncompressed (and it turns on the file's illCompressed bit). To actually + compress or uncompressed the file, append a gpfsRestripeData_t structure with + GPFS_FCNTL_RESTRIPE_FILE structType and set the GPFS_FCNTL_RESTRIPE_C bit in its options + field. */ +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* directive identifier: GPFS_FCNTL_COMPRESSION_ON + GPFS_FCNTL_COMPRESSION_OFF */ + int errReason; /* returned reason request failed. + Defined below. */ + int errValue1; /* returned value depending upon errReason */ + int errValue2; /* returned value depending upon errReason */ + int reserved; /* unused, but should be set to 0 */ +} gpfsSetCompression_t; + +/* Specify the compression library to be used to compress a file. + Supported compression libraries include "z" and "lz4" (for libz and lz4 compression + libraries). This directive only sets the selected compression library of the file + without actually compressing the file. To unset selected compression library of the + file, use gpfsCsetCompression_t defined above with GPFS_FCNTL_COMPRESSION_OFF as + structType. To actually compress or uncompress the file, append a gpfsRestripeData_t + structure with GPFS_FCNTL_RESTRIPE_FILE as the structType and set the GPFS_FCNTL_RESTRIPE_C + bit in its options field. */ +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* directive identifier: GPFS_FCNTL_COMPRESSION_LIB */ + int errReason; /* returned reason request failed. + Defined below. */ + int errValue1; /* returned value depending upon errReason */ + int errValue2; /* returned value depending upon errReason */ + int reserved; /* unused, but should be set to 0 */ + char *libName; /* Null-terminated name of compression lib to be used */ +} gpfsSetCompressionLib_t; + +/* fle compression status bits */ +#define GPFS_FCNTL_COMPRESS_UNSET 0x0 +#define GPFS_FCNTL_COMPRESS_SET 0x1 +#define GPFS_FCNTL_COMPRESS_ILL_COMPRESSED 0x2 + +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* directive identifier: GPFS_FCNTL_GET_COMPRESSION */ + int compressStatus; /* file compression status bits defined above */ + int errReason; /* returned reason request failed. + Defined below. */ + int errValue1; /* returned value depending upon errReason */ + int errValue2; /* returned value depending upon errReason */ + int reserved1; /* unused, but should be set to 0 */ + int reserved2; /* unused, but should be set to 0 */ +} gpfsGetCompression_t; + +/* compression non-support bits */ +#define GPFS_FCNTL_CANNOT_COMPRESS_OLD_FILESYSTEM 0x1 +#define GPFS_FCNTL_CANNOT_COMPRESS_SNAPSHOT 0x2 +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* directive identifier: GPFS_FCNTL_GET_COMPRESSION_SUPPORT */ + int compressNonSupport; /* compression support status of this object or directory tree + 0: compression is supported. The non-support bit(s) + defined above indicates the reason for non-support otherwise. */ + int errReason; /* returned reason request failed. */ + int errValue1; /* returned value depending upon errReason */ + int errValue2; /* returned value depending upon errReason */ + int reserved1; /* unused, but should be set to 0 */ + int reserved2; /* unused, but should be set to 0 */ +} gpfsGetCompressionSupport_t; + +#ifdef SNAPSHOT_ILM + +/* reason if snapshot migration is unsupported */ +#define GPFS_FCNTL_CANNOT_MIGRATE_SNAP_OLD_FILESYSTEM 0x1 +#define GPFS_FCNTL_CANNOT_MIGRATE_SNAP_OLD_SNAPSHOT 0x2 +typedef struct +{ + int structLen; /* length of this structure */ + int structType; /* directive identifier: GPFS_FCNTL_GET_SNAP_MIGRATION_SUPPORT */ + int supported; /* migration support status of this snapshot + 1/0 - supported/unsupported + if unsupported, unsupportRC contains the reason */ + int unsupportRC; /* reason why unsupported */ + int errReason; /* returned reason request failed */ + int errValue1; /* returned value depending upon errReason */ + int errValue2; /* returned value depending upon errReason */ + int reserved1; /* unused, but should be set to 0 */ +} gpfsGetSnapMigrationSupport_t; + +#endif + +/* NAME: gpfs_fcntl() + * + * FUNCTION: Pass hints and directives to GPFS on behalf of an open file + * + * Returns: 0 Successful + * -1 Failure + * + * Errno: ENOSYS Function not available + * EBADF Bad file handle + * EINVAL Not a GPFS file + * EINVAL Not a regular file + * EINVAL Ill-formed hint or directive + * E2BIG Argument longer than GPFS_MAX_FCNTL_LENGTH + */ + +int GPFS_API +gpfs_fcntl(gpfs_file_t fileDesc, /* Open file descriptor */ + void* fcntlArgP); /* argument list */ + +/* + * NAME: gpfs_restripe_file() + * + * FUNCTION: Restripes a file by calling gpfs_fcntl for noBlocks + * from start offset. If noBlocks 0 ==> use default increment size + * + * Returns: 0 Successful + * -1 Failure + * + * Errno: ENOSYS No quality of service function available + * ENOENT File not found + * EINVAL Not a GPFS file + * ESTALE cached fs information was invalid + */ + +int GPFS_API +gpfs_restripe_file(gpfs_file_t fileDesc, /* Open file descriptor */ + void* fcntlArgP, /* argument list */ + int noBlocks); /* number of blocks used for each + iteration when restriping a + file */ + +/* similar but by logical part number */ +int GPFS_API +gpfs_restripe_file_by_parts(gpfs_file_t fileDesc, + void* fcntlArgP, + int part_number, /* e.g. part 3 of ... */ + int number_of_parts); /* ... 4 parts */ + +#ifdef __cplusplus +} +#endif + +#endif /* _h_gpfs_fcntl */ diff --git a/System/ior/files/gpfs/5.0.2-3/include/gpfs_gpl.h b/System/ior/files/gpfs/5.0.2-3/include/gpfs_gpl.h new file mode 100644 index 0000000..75ed4f3 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/gpfs_gpl.h @@ -0,0 +1,4047 @@ +/* */ +/* 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.2.212 src/avs/fs/mmfs/ts/util/gpfs.h, mmfs, avs_rtac502, rtac5021836a 8/23/18 07:58:19 */ +/* + * Library calls for GPFS interfaces + */ +#ifndef H_GPFS +#define H_GPFS + +#include + +/* 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 46 + +#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_XATTR_CHANGE = 17, /* EAs of file are changed */ + GPFS_LWE_EVENT_ACL_CHANGE = 18, /* ACLs (both GPFS ACLs and Posix permissions) of a file are changed */ + GPFS_LWE_EVENT_CREATE = 19, /* create, including mkdir, symlink, special file */ + GPFS_LWE_EVENT_GPFSATTR_CHANGE = 20, /* ts-specific attributes of file are changed */ + GPFS_LWE_EVENT_FILETRUNCATE = 21, /* "File Truncate Event" 'TRUNCATE' */ + + GPFS_LWE_EVENT_MAX = 22, /* 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 GPFS_LWE_ATTRCHANGEEVENT_IMMUTABILITY (0x8) +#define GPFS_LWE_ATTRCHANGEEVENT_APPENDONLY (0x10) + + + +/* + * 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; /* " : " */ + +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 */ diff --git a/System/ior/files/gpfs/5.0.2-3/include/gpfs_lwe.h b/System/ior/files/gpfs/5.0.2-3/include/gpfs_lwe.h new file mode 100644 index 0000000..fc30416 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/gpfs_lwe.h @@ -0,0 +1,131 @@ +/* */ +/* 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. */ +/* */ +/* @(#)69 1.9 src/avs/fs/mmfs/ts/util/gpfs_lwe.h, mmfs, avs_rtac502, rtac5021836a 1/18/17 17:22:53 */ +/* + * Library calls for GPFS interfaces + */ +#ifndef H_GPFS_LWE +#define H_GPFS_LWE + +#ifdef __cplusplus +extern "C" { +#endif + +static const char LWE_JSON[] = +"{\"type\":\"record\",\ + \"name\":\"LWE\",\ + \"fields\":[\ + {\"name\": \"fsName\", \"type\": \"string\"},\ + {\"name\": \"event\", \"type\": \"string\"},\ + {\"name\": \"pathName\", \"type\": \"string\"},\ + {\"name\": \"pathNewName\", \"type\": \"string\"},\ + {\"name\": \"URL\", \"type\": \"string\"},\ + {\"name\": \"inode\", \"type\": \"long\"},\ + {\"name\": \"openFlags\", \"type\": \"string\"},\ + {\"name\": \"poolName\", \"type\": \"string\"},\ + {\"name\": \"fileSize\", \"type\": \"long\"},\ + {\"name\": \"ownerUserId\", \"type\": \"int\"},\ + {\"name\": \"ownerGroupId\", \"type\": \"int\"},\ + {\"name\": \"atime\", \"type\": \"string\"},\ + {\"name\": \"mtime\", \"type\": \"string\"},\ + {\"name\": \"nowTime\", \"type\": \"string\"},\ + {\"name\": \"elapsedTime\", \"type\": \"string\"},\ + {\"name\": \"clientUserId\", \"type\": \"string\"},\ + {\"name\": \"clientGroupId\", \"type\": \"string\"},\ + {\"name\": \"clientIp\", \"type\": \"string\"},\ + {\"name\": \"processId\", \"type\": \"int\"}\ + {\"name\": \"targetPoolName\", \"type\": \"string\"},\ + {\"name\": \"bytesRead\", \"type\": \"long\"},\ + {\"name\": \"bytesWritten\", \"type\": \"long\"},\ + {\"name\": \"clusterName\", \"type\": \"string\"},\ + {\"name\": \"nodeName\", \"type\": \"string\"},\ + ]}"; + +#define GPFS_DEVNAMEX "/dev/ss0" /* Must be the same as GPFS_DEVNAME */ +#define kLWEvent 169 /* Must be the same as LWEvent in enum kxOps */ +#define LWE_MAX_FIELD 256 +#define LWE_UPDATE 201 +typedef long long Int64_t; + +struct lweHeader +{ + int lwe_version; /* in/out */ + int lwe_fd; /* in */ + int lwe_sync; /* in: sync request */ + int lwe_event; /* in: events requeste */ + /* out: event returned */ + int lwe_data; /* in: data requested */ + /* out: data returned */ + int lwe_rc; /* out for all the rest */ + int lwe_seq; /* Event sequence number */ +}; + +struct lweAttr +{ + struct lweHeader lweHdr; + Int64_t lwe_inode; + int lwe_oiOpenFlags; /* Original value of open flags */ + + /* Original credentials when the file was opened */ + int lwe_userId; + int lwe_groupId; + int lwe_processId; + int lwe_ownerUserId; + int lwe_ownerGroupId; + + Int64_t lwe_fileSize; + Int64_t lwe_bytesRead; + Int64_t lwe_bytesWritten; + Int64_t lwe_elapsedTime; + struct timespec lwe_atime; + struct timespec lwe_mtime; + struct timespec lwe_nowTime; + int lwe_plen; + int lwe_plen2; + char lwe_fsName[LWE_MAX_FIELD+1]; + char lwe_NFS_IP[NFS_IP_SIZE+1]; + char lwe_poolName[LWE_MAX_FIELD+1]; + char lwe_targetPoolName[LWE_MAX_FIELD+1]; + char lwe_clusterName[LWE_MAX_FIELD+1]; + char lwe_nodeName[LWE_MAX_FIELD+1]; + /* keep path at the end */ + char lwe_path[PATH_MAX+1]; + char lwe_path2[PATH_MAX+1]; +}; + +#define LWE_ONE_PATH (sizeof(struct lweAttr)-PATH_MAX) +#define LWE_NO_PATH (sizeof(struct lweAttr)-(PATH_MAX*2)) + +#ifdef __cplusplus +} +#endif + +#endif /* H_GPFS_LWE */ diff --git a/System/ior/files/gpfs/5.0.2-3/include/gpfs_lweTypes.h b/System/ior/files/gpfs/5.0.2-3/include/gpfs_lweTypes.h new file mode 100644 index 0000000..8d84c51 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/gpfs_lweTypes.h @@ -0,0 +1,60 @@ +/* */ +/* 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. */ +/* */ +/* @(#)39 1.11 src/avs/fs/mmfs/ts/util/gpfs_lweTypes.h, mmfs, avs_rtac502, rtac5021836a 2/14/17 13:21:48 */ + +#ifndef _h_lwe_types +#define _h_lwe_types + +/* + * + * The content of this file has been moved to /usr/lpp/mmfs/include/gpfs.h + * with new naming convention as list below + * and the use of this file is deprected. +/* + * lwe_eventtype_t -> gpfs_lwe_eventtype_t + * lwe_resp_t -> gpfs_lwe_resp_t + * lwe_sessid_t -> gpfs_lwe_sessid_t + * lwe_token_t -> gpfs_lwe_token_t + * lwe_event_t -> gpfs_lwe_event_t + * _gpfsLweNoToken -> gpfs_lwe_no_token + * LWE_NO_TOKEN -> GPFS_LWE_NO_TOKEN + * _gpfsLweInvalidToken -> _gpfs_lwe_invalid_token + * LWE_INVALID_TOKEN -> GPFS_LWE_INVALID_TOKEN + */ + +#define MAX_LWESESSION_INFO_LEN 100 + +#define LWE_NO_SESSION 0 +#define LWE_EV_WAIT 0 +#define LWE_EV_NOWAIT 1 + + +#endif /* _h_lwe_types */ diff --git a/System/ior/files/gpfs/5.0.2-3/include/gpfs_nfs.h b/System/ior/files/gpfs/5.0.2-3/include/gpfs_nfs.h new file mode 100644 index 0000000..1c50432 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/gpfs_nfs.h @@ -0,0 +1,746 @@ +/* */ +/* 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. */ +/* */ +/* @(#)83 1.75 src/avs/fs/mmfs/ts/util/gpfs_nfs.h, mmfs, avs_rtac502, rtac5021836a 1/6/17 08:59:35 */ +/* + * Library calls for GPFS interfaces + */ +#ifndef H_GPFS_NFS +#define H_GPFS_NFS + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef WIN32 +struct flock +{}; +#endif + +/* GANESHA common information */ + +#define GPFS_DEVNAMEX "/dev/ss0" /* Must be the same as GPFS_DEVNAME */ +#define kGanesha 140 /* Must be the same as Ganesha in enum kxOps */ + +#define OPENHANDLE_GET_VERSION 100 +#define OPENHANDLE_GET_VERSION2 1002 +#define OPENHANDLE_NAME_TO_HANDLE 101 +#define OPENHANDLE_OPEN_BY_HANDLE 102 +#define OPENHANDLE_LAYOUT_TYPE 106 +#define OPENHANDLE_GET_DEVICEINFO 107 +#define OPENHANDLE_GET_DEVICELIST 108 +#define OPENHANDLE_LAYOUT_GET 109 +#define OPENHANDLE_LAYOUT_RETURN 110 +#define OPENHANDLE_INODE_UPDATE 111 +#define OPENHANDLE_GET_XSTAT 112 +#define OPENHANDLE_SET_XSTAT 113 +#define OPENHANDLE_CHECK_ACCESS 114 +#define OPENHANDLE_OPEN_SHARE_BY_HANDLE 115 +#define OPENHANDLE_GET_LOCK 116 +#define OPENHANDLE_SET_LOCK 117 +#define OPENHANDLE_THREAD_UPDATE 118 +#define OPENHANDLE_LAYOUT_COMMIT 119 +#define OPENHANDLE_DS_READ 120 +#define OPENHANDLE_DS_WRITE 121 +#define OPENHANDLE_GET_VERIFIER 122 +#define OPENHANDLE_FSYNC 123 +#define OPENHANDLE_SHARE_RESERVE 124 +#define OPENHANDLE_GET_NODEID 125 +#define OPENHANDLE_SET_DELEGATION 126 +#define OPENHANDLE_CLOSE_FILE 127 +#define OPENHANDLE_LINK_BY_FH 128 +#define OPENHANDLE_RENAME_BY_FH 129 +#define OPENHANDLE_STAT_BY_NAME 130 +#define OPENHANDLE_GET_HANDLE 131 +#define OPENHANDLE_READLINK_BY_FH 132 +#define OPENHANDLE_UNLINK_BY_NAME 133 +#define OPENHANDLE_CREATE_BY_NAME 134 +#define OPENHANDLE_READ_BY_FD 135 +#define OPENHANDLE_WRITE_BY_FD 136 +#define OPENHANDLE_CREATE_BY_NAME_ATTR 137 +#define OPENHANDLE_GRACE_PERIOD 138 +#define OPENHANDLE_ALLOCATE_BY_FD 139 +#define OPENHANDLE_REOPEN_BY_FD 140 +#define OPENHANDLE_FADVISE_BY_FD 141 +#define OPENHANDLE_SEEK_BY_FD 142 +#define OPENHANDLE_STATFS_BY_FH 143 +#define OPENHANDLE_GETXATTRS 144 +#define OPENHANDLE_SETXATTRS 145 +#define OPENHANDLE_REMOVEXATTRS 146 +#define OPENHANDLE_LISTXATTRS 147 +#define OPENHANDLE_MKNODE_BY_NAME 148 +#define OPENHANDLE_reserved 149 +#define OPENHANDLE_TRACE_ME 150 +#define OPENHANDLE_QUOTA 151 +#define OPENHANDLE_FS_LOCATIONS 152 + +struct trace_arg +{ + uint32_t level; + uint32_t len; + char *str; +}; + +#define ganesha_v1 1 +#define ganesha_v2 2 + +int gpfs_ganesha(int op, void *oarg); + +#define OPENHANDLE_HANDLE_LEN 40 +#define OPENHANDLE_KEY_LEN 28 +#define OPENHANDLE_VERSION 2 + +struct xstat_cred_t +{ + uint32_t principal; /* user id */ + uint32_t group; /* primary group id */ + uint16_t num_groups; /* number secondary groups for this user */ +#define XSTAT_CRED_NGROUPS 32 + uint32_t eGroups[XSTAT_CRED_NGROUPS];/* array of secondary groups */ +}; + +struct gpfs_time_t +{ + uint32_t t_sec; + uint32_t t_nsec; +}; + +struct gpfs_file_handle +{ + uint16_t handle_size; + uint16_t handle_type; + uint16_t handle_version; + uint16_t handle_key_size; + uint32_t handle_fsid[2]; + /* file identifier */ + unsigned char f_handle[OPENHANDLE_HANDLE_LEN]; +}; + +struct name_handle_arg +{ + int dfd; + int flag; + const char *name; + struct gpfs_file_handle *handle; + int expfd; +}; + +struct get_handle_arg +{ + int mountdirfd; + int len; + const char *name; + struct gpfs_file_handle *dir_fh; + struct gpfs_file_handle *out_fh; +}; + +struct open_arg +{ + int mountdirfd; + int flags; + int openfd; + struct gpfs_file_handle *handle; + const char *cli_ip; +}; + +struct link_fh_arg +{ + int mountdirfd; + int len; + const char *name; + struct gpfs_file_handle *dir_fh; + struct gpfs_file_handle *dst_fh; +}; + +struct rename_fh_arg +{ + int mountdirfd; + int old_len; + const char *old_name; + int new_len; + const char *new_name; + struct gpfs_file_handle *old_fh; + struct gpfs_file_handle *new_fh; +}; + +struct glock +{ + int cmd; + int lfd; + void *lock_owner; + struct flock flock; +}; +#define GPFS_F_CANCELLK (1024 + 5) /* Maps to Linux F_CANCELLK */ +#define FL_RECLAIM 4 +#define EGRACE 140 + +struct set_get_lock_arg +{ + int mountdirfd; + struct glock *lock; + int reclaim; +}; + +struct open_share_arg +{ + int mountdirfd; + int flags; + int openfd; + struct gpfs_file_handle *handle; + int share_access; + int share_deny; + int reclaim; +}; + +struct share_reserve_arg +{ + int mountdirfd; + int openfd; + int share_access; + int share_deny; +}; + +struct fadvise_arg +{ + int mountdirfd; + int openfd; + uint64_t offset; + uint64_t length; + uint32_t *hints; +}; + +struct gpfs_io_info { + uint32_t io_what; + uint64_t io_offset; + uint64_t io_len; + uint32_t io_eof; + uint32_t io_alloc; +}; + +struct fseek_arg +{ + int mountdirfd; + int openfd; + struct gpfs_io_info *info; +}; + +struct close_file_arg +{ + int mountdirfd; + int close_fd; + int close_flags; + void *close_owner; +}; + +struct link_arg +{ + int file_fd; + int dir_fd; + const char *name; +}; + +struct readlink_arg +{ + int fd; + char *buffer; + int size; +}; + +struct readlink_fh_arg +{ + int mountdirfd; + struct gpfs_file_handle *handle; + char *buffer; + int size; +}; + +struct nfsd4_pnfs_deviceid { + /** FSAL_ID - to dispatch getdeviceinfo based on */ + uint8_t fsal_id; + /** Break up the remainder into useful chunks */ + uint8_t device_id1; + uint16_t device_id2; + uint32_t device_id4; + uint64_t devid; +}; + +struct gpfs_exp_xdr_stream { + int *p; + int *end; +}; + +enum x_nfsd_fsid { + x_FSID_DEV = 0, + x_FSID_NUM, + x_FSID_MAJOR_MINOR, + x_FSID_ENCODE_DEV, + x_FSID_UUID4_INUM, + x_FSID_UUID8, + x_FSID_UUID16, + x_FSID_UUID16_INUM, + x_FSID_MAX +}; + +enum x_pnfs_layouttype { + x_LAYOUT_NFSV4_1_FILES = 1, + x_LAYOUT_OSD2_OBJECTS = 2, + x_LAYOUT_BLOCK_VOLUME = 3, + + x_NFS4_PNFS_PRIVATE_LAYOUT = 0x80000000 +}; + +/* used for both layout return and recall */ +enum x_pnfs_layoutreturn_type { + x_RETURN_FILE = 1, + x_RETURN_FSID = 2, + x_RETURN_ALL = 3 +}; + +enum x_pnfs_iomode { + x_IOMODE_READ = 1, + x_IOMODE_RW = 2, + x_IOMODE_ANY = 3, +}; + +enum stable_nfs +{ + x_UNSTABLE4 = 0, + x_DATA_SYNC4 = 1, + x_FILE_SYNC4 = 2 +}; + +struct pnfstime4 { + uint64_t seconds; + uint32_t nseconds; +}; + +struct nfsd4_pnfs_dev_iter_res { + uint64_t gd_cookie; /* request/repsonse */ + uint64_t gd_verf; /* request/repsonse */ + uint64_t gd_devid; /* response */ + uint32_t gd_eof; /* response */ +}; + +/* Arguments for set_device_notify */ +struct pnfs_devnotify_arg { + struct nfsd4_pnfs_deviceid dn_devid; /* request */ + uint32_t dn_layout_type; /* request */ + uint32_t dn_notify_types; /* request/response */ +}; + +struct nfsd4_layout_seg { + uint64_t clientid; + uint32_t layout_type; + uint32_t iomode; + uint64_t offset; + uint64_t length; +}; + +struct nfsd4_pnfs_layoutget_arg { + uint64_t lg_minlength; + uint64_t lg_sbid; + struct gpfs_file_handle *lg_fh; + uint32_t lg_iomode; +}; + +struct nfsd4_pnfs_layoutget_res { + struct nfsd4_layout_seg lg_seg; /* request/resopnse */ + uint32_t lg_return_on_close; +}; + +struct nfsd4_pnfs_layoutcommit_arg { + struct nfsd4_layout_seg lc_seg; /* request */ + uint32_t lc_reclaim; /* request */ + uint32_t lc_newoffset; /* request */ + uint64_t lc_last_wr; /* request */ + struct pnfstime4 lc_mtime; /* request */ + uint32_t lc_up_len; /* layout length */ + void *lc_up_layout; /* decoded by callback */ +}; + +struct nfsd4_pnfs_layoutcommit_res { + uint32_t lc_size_chg; /* boolean for response */ + uint64_t lc_newsize; /* response */ +}; + +struct nfsd4_pnfs_layoutreturn_arg { + uint32_t lr_return_type; /* request */ + struct nfsd4_layout_seg lr_seg; /* request */ + uint32_t lr_reclaim; /* request */ + uint32_t lrf_body_len; /* request */ + void *lrf_body; /* request */ + void *lr_cookie; /* fs private */ +}; + +struct x_xdr_netobj { + unsigned int len; + unsigned char *data; +}; +struct pnfs_filelayout_devaddr { + struct x_xdr_netobj r_netid; + struct x_xdr_netobj r_addr; +}; + +/* list of multipath servers */ +struct pnfs_filelayout_multipath { + uint32_t fl_multipath_length; + struct pnfs_filelayout_devaddr *fl_multipath_list; +}; + +struct pnfs_filelayout_device { + uint32_t fl_stripeindices_length; + uint32_t *fl_stripeindices_list; + uint32_t fl_device_length; + struct pnfs_filelayout_multipath *fl_device_list; +}; + +struct pnfs_filelayout_layout { + uint32_t lg_layout_type; /* response */ + uint32_t lg_stripe_type; /* response */ + uint32_t lg_commit_through_mds; /* response */ + uint64_t lg_stripe_unit; /* response */ + uint64_t lg_pattern_offset; /* response */ + uint32_t lg_first_stripe_index; /* response */ + struct nfsd4_pnfs_deviceid device_id; /* response */ + uint32_t lg_fh_length; /* response */ + struct gpfs_file_handle *lg_fh_list; /* response */ +}; + +enum stripetype4 { + STRIPE_SPARSE = 1, + STRIPE_DENSE = 2 +}; + +struct deviceinfo_arg +{ + int mountdirfd; + int type; + struct nfsd4_pnfs_deviceid devid; + struct gpfs_exp_xdr_stream xdr; +}; + +struct layoutget_arg +{ + int fd; + struct gpfs_file_handle *handle; + struct nfsd4_pnfs_layoutget_arg args; + struct pnfs_filelayout_layout *file_layout; + struct gpfs_exp_xdr_stream *xdr; +}; + +struct layoutreturn_arg +{ + int mountdirfd; + struct gpfs_file_handle *handle; + struct nfsd4_pnfs_layoutreturn_arg args; +}; + +struct dsread_arg +{ + int mountdirfd; + struct gpfs_file_handle *handle; + char *bufP; + uint64_t offset; + uint64_t length; + uint64_t *filesize; + int options; +}; + +/* define flags for options */ +#define IO_SKIP_HOLE (1 << 0) /* 01 */ +#define IO_SKIP_DATA (1 << 1) /* 02 */ +#define IO_ALLOCATE (1 << 2) /* 04 */ +#define IO_DEALLOCATE (1 << 3) /* 08 */ + +struct dswrite_arg +{ + int mountdirfd; + struct gpfs_file_handle *handle; + char *bufP; + uint64_t offset; + uint64_t length; + uint32_t stability_wanted; + uint32_t *stability_got; + uint32_t *verifier4; + int options; +}; + +struct read_arg +{ + int mountdirfd; + int fd; + char *bufP; + uint64_t offset; + uint64_t length; + uint32_t stability_wanted; + uint32_t *stability_got; + uint32_t *verifier4; + int options; +}; + +struct write_arg +{ + int mountdirfd; + int fd; + char *bufP; + uint64_t offset; + uint64_t length; + uint32_t stability_wanted; + uint32_t *stability_got; + uint32_t *verifier4; + int options; +}; + +struct alloc_arg +{ + int fd; + uint64_t offset; + uint64_t length; + int options; +}; + +struct layoutcommit_arg +{ + int mountdirfd; + struct gpfs_file_handle *handle; + uint64_t offset; + uint64_t length; + uint32_t reclaim; /* True if this is a reclaim commit */ + uint32_t new_offset; /* True if the client has suggested a new offset */ + uint64_t last_write; /* The offset of the last byte written, if + new_offset if set, otherwise undefined. */ + uint32_t time_changed; /* True if the client provided a new value for mtime */ + struct gpfs_time_t new_time; /* If time_changed is true, the client-supplied + modification tiem for the file. otherwise, undefined. */ + struct gpfs_exp_xdr_stream *xdr; +}; + +struct fsync_arg +{ + int mountdirfd; + struct gpfs_file_handle *handle; + uint64_t offset; + uint64_t length; + uint32_t *verifier4; +}; + +struct statfs_arg +{ + int mountdirfd; + struct gpfs_file_handle *handle; + struct statfs *buf; +}; + +struct stat_arg +{ + int mountdirfd; + struct gpfs_file_handle *handle; + struct stat *buf; +}; + +struct grace_period_arg +{ + int mountdirfd; + int grace_sec; +}; + +struct create_name_arg +{ + int mountdirfd; /* in */ + struct gpfs_file_handle *dir_fh;/* in */ + uint32_t dev; /* in dev or posix flags */ + int mode; /* in */ + int len; /* in */ + const char *name; /* in */ + struct gpfs_file_handle *new_fh;/* out */ + struct stat *buf; /* in/out */ + int attr_valid; /* in */ + int attr_changed; /* in */ + struct gpfs_acl *acl; /* in/out */ +}; + +struct stat_name_arg +{ + int mountdirfd; + int len; + const char *name; + struct gpfs_file_handle *handle; + struct stat *buf; +}; + +struct callback_arg +{ + int interface_version; + int mountdirfd; + int *reason; + struct gpfs_file_handle *handle; + struct glock *fl; + int *flags; + struct stat *buf; + struct pnfs_deviceid *dev_id; + uint32_t *expire_attr; +}; +#define GPFS_INTERFACE_VERSION 10000 +#define GPFS_INTERFACE_SUB_VER 1 + +/* Defines for the flags in callback_arg, keep up to date with CXIUP_xxx */ +#define UP_NLINK 0x00000001 /* update nlink */ +#define UP_MODE 0x00000002 /* update mode and ctime */ +#define UP_OWN 0x00000004 /* update mode,uid,gid and ctime */ +#define UP_SIZE 0x00000008 /* update fsize */ +#define UP_SIZE_BIG 0x00000010 /* update fsize if bigger */ +#define UP_TIMES 0x00000020 /* update all times */ +#define UP_ATIME 0x00000040 /* update atime only */ +#define UP_PERM 0x00000080 /* update fields needed for permission checking*/ +#define UP_RENAME 0x00000100 /* this is a rename op */ +#define UP_DESTROY_FLAG 0x00000200 /* clear destroyIfDelInode flag */ +#define UP_GANESHA 0x00000400 /* this is a ganesha op */ + +/* reason list for reason in callback_arg */ +#define INODE_INVALIDATE 1 +#define INODE_UPDATE 2 +#define INODE_LOCK_GRANTED 3 +#define INODE_LOCK_AGAIN 4 +#define THREAD_STOP 5 +#define THREAD_PAUSE 6 +#define BREAK_DELEGATION 7 +#define LAYOUT_FILE_RECALL 8 +#define LAYOUT_RECALL_ANY 9 +#define LAYOUT_NOTIFY_DEVICEID 10 + +/* define flags for attr_valid */ +#define XATTR_STAT (1 << 0) +#define XATTR_ACL (1 << 1) +#define XATTR_NO_CACHE (1 << 2) +#define XATTR_EXPIRE (1 << 3) +#define XATTR_FSID (1 << 4) + +/* define flags for attr_chaged */ +#define XATTR_MODE (1 << 0) // 01 +#define XATTR_UID (1 << 1) // 02 +#define XATTR_GID (1 << 2) // 04 +#define XATTR_SIZE (1 << 3) // 08 +#define XATTR_ATIME (1 << 4) // 10 +#define XATTR_MTIME (1 << 5) // 20 +#define XATTR_CTIME (1 << 6) // 40 +#define XATTR_ATIME_SET (1 << 7) // 80 +#define XATTR_MTIME_SET (1 << 8) // 100 +#define XATTR_ATIME_NOW (1 << 9) // 200 +#define XATTR_MTIME_NOW (1 << 10)// 400 +#define XATTR_SPACE_RESERVED (1 << 11)// 800 + +struct fsal_fsid { + uint64_t major; + uint64_t minor; +}; + +struct xstat_arg +{ + int attr_valid; + int mountdirfd; + struct gpfs_file_handle *handle; + struct gpfs_acl *acl; + int attr_changed; + struct stat *buf; + struct fsal_fsid *fsid; + uint32_t *expire_attr; +}; + +struct getxattr_arg { + int mountdirfd; + struct gpfs_file_handle *handle; + uint32_t name_len; + char *name; + uint32_t value_len; + void *value; +}; + +struct setxattr_arg { + int mountdirfd; + struct gpfs_file_handle *handle; + int type; + uint32_t name_len; + char *name; + uint32_t value_len; + void *value; +}; + +struct removexattr_arg { + int mountdirfd; + struct gpfs_file_handle *handle; + uint32_t name_len; + char *name; +}; + +struct listxattr_arg { + int mountdirfd; + struct gpfs_file_handle *handle; + uint64_t cookie; + uint64_t verifier; + uint32_t eof; + uint32_t name_len; + void *names; +}; + +struct fs_loc_arg { + int mountdirfd; + struct gpfs_file_handle *handle; + int fs_root_len; + char *fs_root; + int fs_path_len; + char *fs_path; + int fs_server_len; + char *fs_server; +}; + +struct xstat_access_arg +{ + int mountdirfd; + struct gpfs_file_handle *handle; + struct gpfs_acl *acl; + struct xstat_cred_t *cred; + unsigned int posix_mode; + unsigned int access; /* v4maske */ + unsigned int *supported; +}; + +struct quotactl_arg +{ + const char *pathname; + int cmd; + int qid; + void *bufferP; +}; + +#ifdef __cplusplus +} +#endif + +#endif /* H_GPFS_NFS */ diff --git a/System/ior/files/gpfs/5.0.2-3/include/gpfs_watch.h b/System/ior/files/gpfs/5.0.2-3/include/gpfs_watch.h new file mode 100644 index 0000000..c850772 --- /dev/null +++ b/System/ior/files/gpfs/5.0.2-3/include/gpfs_watch.h @@ -0,0 +1,397 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* */ +/* */ +/* Licensed Materials - Property of IBM */ +/* */ +/* Restricted Materials of IBM */ +/* */ +/* (C) COPYRIGHT International Business Machines Corp. 2018 */ +/* All Rights Reserved */ +/* */ +/* US Government Users Restricted Rights - Use, duplication or */ +/* disclosure restricted by GSA ADP Schedule Contract with IBM Corp. */ +/* */ +/* IBM_PROLOG_END_TAG */ +/* */ +/* Copyright (C) 2018 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. */ +/* */ +/* @(#)71 1.5.1.3 src/avs/fs/mmfs/ts/util/gpfs_watch.h, mmfs, avs_rtac502, rtac502s001a 10/1/18 14:10:41 */ +/* + * Library calls for GPFS WATCH FOLDER interfaces + */ +#ifndef _h_gpfs_watch +#define _h_gpfs_watch +/* inotify emulation for GPFS - using LWE/policy, Kafka, and so forth */ +#include +#include +#include + +/* gpfs_diag_watch flags. Log messages written to /var/adm/ras/mmwf.log */ +#define GPFS_WATCH_NODEBUG (0x0) //default +#define GPFS_WATCH_DEBUG (0x1) + +/* public API methods - mimicking the Linux inotify API */ + +/* :notyet: integration of our inotify fd with standard unix fd for poll()ing */ +# ifdef __cplusplus +extern "C" { +# endif +/* NAME: gpfs_init_watch + * + * FUNCTION: The gpfs_init_watch subroutine initializes a watch and returns a + * parent watch descriptor (pwd). The gpfs_init_watch subroutine + * checks if you have enabled watch folder. It also checks if you + * will exceed the maximum number of watches per file system (25). + * + * If you have not enabled watch folder functionality, gpfs_init_watch + * will fail. If you already have 100 watches on your cluster for all + * file systems combined, gpfs_init_watch will fail. + * + * Note: The parent watch descriptor and the child watch descriptors + * are not Linux file descriptors. For example, one cannot poll the + * descriptors. + * + * PARAMETERS: void + * + * RETURNS: The gpfs_init_watch subroutine returns the pwd on success or -1 on + * failure. + * + * Errno: Errno is set if -1 is returned. + * ENOKEY + * Watch folder is not enabled. Check with IBM Spectrum Scale™ + * support to enable it. + * EINTR + * Maximum number of watches were exceeded on this cluster. The + * maximum number of watches allowed per cluster is 100. + * Note: Further errnos might be reported depending on the inner + * instrumentation of the API. Use gpfs_watch_strerror to learn + * more about an error. + * + * EXAMPLES: For an example using gpfs_*_watch, + * see /usr/lpp/mmfs/samples/util/tswf.C. + */ + int gpfs_init_watch(); /* returning an inotify fd */ + +/* NAME: gpfs_add_watch + * + * FUNCTION: The gpfs_add_watch subroutine watches files in the folder + * specified by pathname. The watch is non-recursive like + * Linux inotify. This means that the contents in subdirectories + * under the watched directory are not watched. The gpfs_add_watch + * subroutine registers your intention to watch said folder. In + * addition, it also verifies if the file system that you want to + * watch is owned by the local cluster. Currently, watches over + * file systems mounted on an accessing cluster are not supported. + * + * PARAMETERS: + * pwd + * The parent watch descriptor that is returned by gpfs_init_watch. + * You can set up multiple child watches (directory, fileset, or + * inode space) under the same parent watch as long as they are + * watching the same file system. + * pathname + * The path of the directory that is being watched. + * event_mask + * One or more of the events {IN_ACCESS,IN_ATTRIB,IN_CLOSE_NOWRITE, + * IN_CLOSE_WRITE,IN_CREATE,IN_DELETE, + * IN_DELETE_SELF,IN_MODIFY,IN_MOVED_FROM, + * IN_MOVE_SELF} + * + * RETURNS: The gpfs_add_watch subroutine returns the child watch descriptor (cwd) + * on success or -1 on failure. + * + * Errno: Errno is set if -1 is returned. + * EBADF + * Invalid pwd was passed. + * ENODEV + * The path is not a mounted IBM Spectrum Scale™ file system. + * EXDEV + * The path belongs to a different file system. + * ENOSYS + * This cluster is not the owning cluster for this file system. + * EINTR + * Exceeded the number of watches allowed for a file system (25). + * EDOM + * The file system level needs to be upgraded. Watch folder is + * not supported. + * EDESTADDRREQ + * The message queue for this cluster is not ready. Enable the + * message queue before starting a watch. + * ENODATA + * Message queue error. + * EHOSTUNREACH + * Could not find the node name. + * Note: Further errnos might be reported depending on the inner + * instrumentation of the API. Use gpfs_watch_strerror to learn + * more about an error. + * + * EXAMPLES: For an example using gpfs_*_watch, + * see /usr/lpp/mmfs/samples/util/tswf.C. + */ + /* gpfs_add_watch restriction -- all watches added to a + given inotify fd must be for the same file system */ + int gpfs_add_watch(int fd, const char* pathname, int mask); /* returning an inotify wd */ + +/* NAME: gpfs_add_fset_watch + * + * FUNCTION: The gpfs_add_fset_watch subroutine watches all files and directories + * in the fileset specified by pathname. The watch is recursive in that + * subdirectories in the fileset and their contents are watched. You do + * not have to set up additional watches to watch the subdirectories. + * However, nested dependent or independent filesets under the fileset + * at pathname are not watched. + * + * PARAMETERS: + * pwd + * The parent watch descriptor that is returned by gpfs_init_watch. + * You can set up multiple child watches (directory, fileset, or + * inode space) under the same parent watch as long as they are + * watching the same file system. + * pathname + * The root of the fileset that is being watched. + * event_mask + * One or more of the events {IN_ACCESS,IN_ATTRIB,IN_CLOSE_NOWRITE, + * IN_CLOSE_WRITE,IN_CREATE,IN_DELETE, + * IN_DELETE_SELF,IN_MODIFY,IN_MOVED_FROM, + * IN_MOVE_SELF} + * + * RETURNS: The gpfs_add_fset_watch subroutine returns the child watch descriptor + * (cwd) on success or -1 on failure. + * The gpfs_add_fset_watch subroutine fails if pathname does not point + * to the root of a fileset. + * + * Errno: Errno is set if -1 is returned. + * EBADF + * Invalid pwd was passed. + * ENODEV + * The path is not a mounted IBM Spectrum Scale™ file system. + * EXDEV + * The pathname is not the root of a fileset. + * ENOSYS + * This cluster is not the owning cluster for this file system. + * EINTR + * Exceeded the number of watches allowed for a file system (25). + * EDOM + * The file system level needs to be upgraded. Watch folder is + * not supported. + * EDESTADDRREQ + * The message queue for this cluster is not ready. Enable the + * message queue before starting a watch. + * ENODATA + * Message queue error. + * EHOSTUNREACH + * Could not find the node name. + * Note: Further errnos might be reported depending on the inner + * instrumentation of the API. Use gpfs_watch_strerror to learn + * more about an error. + * + * EXAMPLES: For an example using gpfs_*_watch, + * see /usr/lpp/mmfs/samples/util/tswf.C. + */ + int gpfs_add_fset_watch(int fd, const char* pathname, int mask); + +/* NAME: gpfs_add_inodespace_watch + * + * FUNCTION: The gpfs_add_inodespace_watch subroutine watches all files and + * directories in the inode space specified by pathname. This is a + * recursive watch, so subdirectories and their contents in the inode + * space are also watched. Nested dependent filesets are watched; + * however, nested independent filesets are not watched. + * + * PARAMETERS: + * pwd + * The parent watch descriptor that is returned by gpfs_init_watch. + * You can set up multiple child watches (directory, fileset, or + * inode space) under the same parent watch as long as they are + * watching the same file system. + * pathname + * The root of the fileset of the corresponding inode space that + * is being watched. The pathname is expected to point to the root + * of an independent fileset. + * event_mask + * One or more of the events {IN_ACCESS,IN_ATTRIB,IN_CLOSE_NOWRITE, + * IN_CLOSE_WRITE,IN_CREATE,IN_DELETE, + * IN_DELETE_SELF,IN_MODIFY,IN_MOVED_FROM, + * IN_MOVE_SELF} + * + * RETURNS: The gpfs_add_inodespace_watch subroutine returns the child watch + * descriptor (cwd) on success or -1 on failure. + * + * Errno: Errno is set if -1 is returned. + * EBADF + * Invalid pwd was passed. + * ENODEV + * The path is not a mounted IBM Spectrum Scale™ file system. + * EXDEV + * The pathname is not the root of an independent fileset. + * ENOSYS + * This cluster is not the owning cluster for this file system. + * EINTR + * Exceeded the number of watches allowed for a file system (25). + * EDOM + * The file system level needs to be upgraded. Watch folder is + * not supported. + * EDESTADDRREQ + * The message queue for this cluster is not ready. Enable the + * message queue before starting a watch. + * ENODATA + * Message queue error. + * EHOSTUNREACH + * Could not find the node name. + * Note: Further errnos might be reported depending on the inner + * instrumentation of the API. Use gpfs_watch_strerror to learn + * more about an error. + * + * EXAMPLES: For an example using gpfs_*_watch, + * see /usr/lpp/mmfs/samples/util/tswf.C. + * + */ + int gpfs_add_inodespace_watch(int fd, const char* pathname, int mask); + +/* NAME: gpfs_read_watch + * + * FUNCTION: The gpfs_read_watch subroutine reads a file access event. + * The metadata for the event is populated in buf in the inotify_struct + * format: + * + * struct inotify_event { + * int cwd; // Child watch descriptor + * uint32_t mask; // Mask describing event + * uint32_t cookie; // Unique cookie associating related + * // events such as rename + * uint32_t len; // Size of file path + * char name[]; // Optional null-terminated file path + * }; + * + * The gpfs_read_watch subroutine tries to fill up buf with as + * many events as it can. + * + * PARAMETERS: + * pwd + * The parent watch descriptor that is returned by gpfs_init_watch. + * buf + * Pointer to a preallocated buffer. + * count + * Number of bytes in buf. + * + * RETURNS: The gpfs_read_watch subroutine returns -1 on failure. + * + * Errno: Errno is set if -1 is returned. + * Note: Further errnos might be reported depending on the inner + * instrumentation of the API. Use gpfs_watch_strerror to learn + * more about an error. + * + * EXAMPLES: For an example using gpfs_*_watch, + * see /usr/lpp/mmfs/samples/util/tswf.C. + * + */ + + ssize_t gpfs_read_watch(int fd, void* buf, size_t count); /* read one or more inotify structs (layed end-to-end) */ + +/* NAME: gpfs_rm_watch + * + * FUNCTION: The gpfs_rm_watch subroutine stops the watch for the specified cwd. + * + * PARAMETERS: + * pwd + * The parent watch descriptor that is returned by gpfs_init_watch. + * cwd + * The child watch descriptor that is returned by gpfs_add_*_watch. + * + * RETURNS: The gpfs_rm_watch subroutine returns 0 on success or -1 on error. + * + * Errno: Errno is set if -1 is returned. + * Note: Further errnos might be reported depending on the inner + * instrumentation of the API. Use gpfs_watch_strerror to learn + * more about an error. + * + * EXAMPLES: For an example using gpfs_*_watch, + * see /usr/lpp/mmfs/samples/util/tswf.C. + * + */ + int gpfs_rm_watch(int fd, int wd); /*removing the wd from the inotify fd */ + +/* NAME: gpfs_watch_strerror + * + * FUNCTION: The gpfs_watch_strerror subroutine provides some additional + * information for the last error encountered. + * + * PARAMETERS: + * pwd + * The parent watch descriptor that is returned by gpfs_init_watch. + * + * RETURNS: The gpfs_watch_strerror subroutine returns the character string with + * the error message or NULL if there is no descriptive error. + * + * EXAMPLES: For an example using gpfs_*_watch, + * see /usr/lpp/mmfs/samples/util/tswf.C. + * + */ + const char* gpfs_watch_strerror(int fd); /* C-string describing last error */ + +/* NAME: gpfs_close_watch + * + * FUNCTION: The gpfs_close_watch subroutine destroys resources that are + * associated with a parent watch descriptor (pwd). + * + * PARAMETERS: + * pwd + * The parent watch descriptor that is returned by gpfs_init_watch. + * + * RETURNS: The gpfs_close_watch subroutine returns 0 on success or -1 on failure. + * + * Errno: Errno is set if -1 is returned. + * Note: Further errnos might be reported depending on the inner + * instrumentation of the API. Use gpfs_watch_strerror to learn + * more about an error. + * + * EXAMPLES: For an example using gpfs_*_watch, + * see /usr/lpp/mmfs/samples/util/tswf.C. + * + */ + int gpfs_close_watch(int fd); /* destroying the inotify fd and all associated wds and any other resources */ + +/* NAME: gpfs_diag_watch + * + * FUNCTION: The gpfs_diag_watch subroutine provides some additional diagnostics + * + * RETURNS: + * + * EXAMPLES: For an example using gpfs_*_watch, + * see /usr/lpp/mmfs/samples/util/tswf.C. + */ + int gpfs_diag_watch(int fd, int dflags); /* set diagnostics */ + +# ifdef __cplusplus +} +# endif +#endif /* _h_gpfs_watch */ diff --git a/System/ior/files/gpfs/5.0.2-3/lib/libGpfsProvider.so b/System/ior/files/gpfs/5.0.2-3/lib/libGpfsProvider.so new file mode 100755 index 0000000000000000000000000000000000000000..910a1a8b97ca06336709cfe6155078753a946735 GIT binary patch literal 480444 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

vE-LsY1v5xT$# zJqn>@BeWzc)U=t)n`?w_giu!_bX8R7IU}_4GWJsige)`N6h?(^H9}*JrU?*QZG=Wg zg)THg*BVVHLFjHHbV5{Uv=Lfhgbsty93#{%Ds;3Fy2J>zgV1;*^y^0vXSO#&g+}OG zim*;FLhGVJUv6R-yjaJjTLYoaM(DYy&`KjT&}do?p-pDGxjQO!lM(7;glZtvV1%xS z3KbinZbm2sp*xLGepG0r5gKJ|%7V}=BXn9+DA5R=WrPMm=u9KjH!9TnEtf9G2ptTe z;~+#YLeT6>BOUE2sKNUvBK#rA)<)OIS(#NokF0tlv-+gWnyzy$?Lhm9#usUmt{-Tlu6&&PLDh;MOUsKTufV&*E?oogOypmSLPnG8z~rFJs}=NpOsK9&*-@@n@l;GOzf45m}sBH9j#tv*zZ+AcIR1GxIa6JM>9H ztyL{ZTu3Z!#Hv2ctQwt|2H_-YCXf0H64N;aZNP>n##_@sR$r1BPu_U)J!&*Ze`6C> z8?0-%+RG`HM3Ss7Ur}7mU5S3y@RfBe+8izIZsMtUMI!ch)P&x<7)_{QRRS5q?Fg1^ zv;Kw7M$$bfhtW09CpJ+t8C}(C-AAcM*F2fn%(%t6h4G5S1kUBh(Ui0sHI30VOA~!W zjjkeUi*+gw;42d2IM37^$`hHS@sxO1Vk0RVQ}z3ps^-8OJk9?|S+D7kNG8$z_k}4V z?PoVwBbtm^#i$O_FpCO_3@#uZc~4>7VqL&tt93SoaC`&hzz!atm|z{jWqLBPQp)f? znK8O%MPe=EZPv?-mnPOBQFVD@0&-ZvbJvQ*dXP1#kIywls9^f8#1PSAs(u<%Ww{g~ z__->=e3*p&3Wh;4`H2mt2zRo{+pHywTdX@N%&b|En1c+l1s|RmXHB6*aDM`kqpMo1 z1I2Vd<89WSVtP6fk?ClZkkk0jqNuuSoQXmFcLu=cvV@+2F)m zn$23&HdRa$QDk`D9OLtLVt75#p3UZq&y?Z&iQxmq@KeR`qs8#csgyA6Xy#k3!?^&L zB<8^S$0@tfHRXvRNZiL@MPeOHA_u3zbe!M8^jadt^sZuhCFE*SpPg+?AHj3qd5J+! zyA!qD=a3z6_~qPpw^>(HUqFqPu$|kiH6#qHN|PD^V?M%ZsQOwq-cm zatUev4syt2>pdo@Gr_$kSj<7~*2Vm~UhUS8%=o?aLkT~S@O=sCz)DOGh{=P*~#vm zt$*1Ci%~5qx6(8~g${qlQlj@V(R-EXEf&4AL~k*Nt=1Iie=wr|ZDaa7CV1Bb@0mdP zgIZI#+)fmpZr|~GAY4FDozI#1ZDiG-JjGq{J-!o%VXBrwnz=^HP?c^y_X(AfA}S$Z z#;c)$y9+lNIn6&PoQc5xhB%oYhWZAcqZwnBi%ehijE|7oIki2D`fnm z^IDo8sg@Bo@vyaKRc9JZ0>4>5p=4Ft=uGw*j7As_*0r{tbY9}<{T6hjzB;_>H;hW1 z(F1FqPsA{ZaqK(J^+_3(Tdehj_j{&1aWqV6WT7oqDzc0YxktmPr0Y63i=0$PVxB`+ z;YYA*1MO(eergPTns^LYFEVbmo~96bW#mMX4>u4+o{EPfr*QhOtm8S| zHtSX%5Z73Lak|uJ*3xNd)f($?5?j!)--7GOJgBSWFtwhezp{c-m$bIpU}dp0zp_pu z6@kwy2QMZe-+ou(K@qY|vwA}}-TAF}xl1zn5tm^7Vw-2(A+hOJE$*&(67IDffuc6!04R4ay_%dH6t56WvchVTcr7D+&{} z!lR+^y}x4Qt2@qtC?yMKR*%MN6N_6+g;aZ))#Su!3D#ezr|Q9DS?PvW8Z*DLrc>vo z>~AA=1V>iAX07~KjJF<NmOnJR}#(l zP+TLq{!FbtJRmCcAqj<#GKsgoPo0P4tbNImTi-`}*jg?5?;t-QzkZU>{t|Ylkm`?L zI!D+D_ebkX?JuI6i?rzGf<`2&%~M`Q`=K>}EP9h%HXPR8JmNU^7#%>8*RjV4uBJW4 zYH>M;Eg*Vh`lR}nea4ax2vVQ3_Zh3vf~mTX-2gta&zM@`y3a_JQTSohT}^bKF_=>8 zeMUdVG5d_=m;+wU(#j2-(7UjI-L>Mhpz zbVbvnB80dI9{UXIT~&lbqzJ=!F4|_D&Zcg$QltncNfA=mbjLp9FP=N1`;12@dzkL0 z?0I}=yfl#~VrmP#&v^EI*cjPo+&$BHe;iLKf3wf%r%lg+Nz{ZEVy>k=UQ3GM{n>2t zHmj0xi!~b|HJS$M*XZz_*sAD0V+Xeo$37#AS{#~9GbiHhX$~eXGQ5c>^7$V{#_-$W zIr2FsP|s#l{tgM*&E^4kfDC_+r@w91r;Wz&m)PKK)-xkb@_17ia^C!3wxoiw1bhQPVhFe%}W)<pq@ZKgQo6X~IZw7~`dUIP~IP)c4UP=0Ft*g-mu!VK>QsK&us=po#W8=XrQ- z#HI~a6D*-Zb>ebtv*NgqZLxN6Nb4UCTdW;#8O^+PvOUpVx?McVaX$cQDy9^HA5elg zl%VE$GyGBsn_xUxyH(a{?AfaIDD2D9X%lE0XMH3#6h(S>GDZfBFW6dTps?KO zPer%7D?9-?p9$|iqbvF2#9;Yp2KO8e9#t(%&B-42# z)ffD5Fo&(y`(%OmA&vczL%GNLfoC+D2tzn%%Rzgnga;h$A>R1mF{yC&!>i*$)#aciRt@gAZOs8`1JX^vYN~-N^=P zJeJw9d#lB4^WdMK#S&lkR{NroQMpz=w{Xn1ql8Pa(s|y+T)bIg)2uIWcg3q1Q3DNX z&x+ZHwsY7BKP$rN7UqBI#vErY7TRy^;8ujZHVBts#xqJDZ_Ooc>r>p3NTt<bir&pzi{C-`m&pOWxN30Imh zJUlvIQVu>V#SFOCNt8cE%_GT7G@xS{w^&C~7(SE}kxerHrkklV-JXvbi<#T0KEhjR z){-MTE{QJ+Jn#7V){t{(ZrSn-y9gfoXXd zaLj7jLDpP}=PYp8G|YeL5TFJ#O(wx~Yd*$5ipfDtP3mov(N^n@Qo*X^O=Bae=huI7})pzrwB2n)4dMZPtYpLTMp~wEyRj_Wy{drkG%j zmAfP>L+krC*>k1<}F7{^A*W~T@PER`SuWKHVO zT)1_cRluIRE3t`mdF~m~Up9v2pfqK$gNk@3#wF6Q0nEA=r->3<~^&8m87Hc!(R%-)7GB(I|w3_uPxip6{J)eV{Y-2-A z!q|l{wzn8tNi-Sz#}&rdE@Est(VoU`en}a7uoyc;j2$V)2E^DwVr+my^pNH~DMQmW z;;rW?JCwl3#oU@ zkfgGtxtHa<7mZom#;=EERF-GZjj7qZL>&NSd4S8%Vm->Z)p|fWMw<06+)e7+L)kexMHu4@Fxbo8yel$zpRyvAK~_d-j5+=at3X#bUGm*=7wBi;oqH zQ^ew9#m-u>^Eqx2v?LWfAF^8rVY0K6*jbKxMk^tje7pEOExzKvQWJ3~a1 zo!!OGr%;d72K+>O+FAP?3E3@RH7bVe+=^uw+4(a$0Cs-P_O)2wFmAOzM@V)ycQExn zgWDy|Dq`m(X{T|7hg3fmFLr*!-HS#LW9L4{E%y^BcCW#oEfa)%pe@ z+391uXne-HlKdIRxW&q2yfiU^FxidN!cddW&*`oehjztmhchlR?5{XA;v}to~wW6JfIRWU+H5 zYLEO`N3^G%ncB{aDS!BL3D0xetcR$R!Jjv=ef0hd<5ue?gyhd0HlWoyQtS*dZn3(H zot1>i&f}QgVqHtk0rg%>nCyIbg7N2T@Cw-(B-+!?x@SnpuJ;eo`N_^dcn;fU?ICt< z<*>#2nHn=D)~yK1&Nw!p)w&q#H}Yo!;}&ZM^xTN%n~~%v0YoNVPfa$V&^civw^k^u=_*G33fIzZn0J~UYgiMnC$E? zcAhMDHelYCGps{_y8RJTKAvPt?iah&$Q77HbLPR_jiL z)oL9pc2+WOu?`VCYYEdhpC)$ROw9rHUPm<9*-q?y2VS9i&mr2=&Sg(2e}0b6 zPj>Dhc6Jdvf99~o`hyxX{P#0LvNM70qWKByGxDdOaf?~6(Rw7EFxiQEMsdIA4nsR2 zqRGyRvyDIdh@Ejnd)n#KcBY7(lX(8zX63P6TddQ?&MdL>bg{FMS9~--QBJV4NmhVw zF{bAtgvriKv2(cC=`(h2KFip7DZE1dY#?b*J10D;{8>%;!=F#^yhP{U)XCt8C2U`d z^$_D$YY9T~XQkMgB6ik_okxnDb;eF~WT?4|ngi;+o@nytM6vT@c!lf?5$$Pb{S(U0 zZ_xS4&MsnScd_#i4rzVCVXO5AHEP)DXS-;AB9FkI>5OT8&Y0GrgsC4*5IcY24nu2E zqRGy8#~Xk46FU=#_O!E;w(}&hGmq!bZPpCfLypK2J0~%2wX(#{COS|gXgd7jugTI`H7b`B9cuY^~~pE$Vmv@_>%<+tEutA&WG4O zT3;}3wH~5yNOcX?7j&}rLl*g^CiO6S|Afz2yYg&B%S^UCaDMb%B1P6o@(P(zEj<6#7K(n?AP<1XW3p2u%Syv3&M?xR-s%D$j3%#KlkIbH6 zvEj76xZ+iu`Z&(w=p_rA?98e7*yBaNwgHxR(PT;J{rS_{o3A`tK75e#e1db>J5qINyP zkC+S|XT>enD#rAFIfcj|&00ox;nZDbP%9a2rFVKo|76iWUG$F={S!t1IME+(WkUbQ zzwfF5QT^dAWC*?AJODxT{j+dC2TpY0UJm>!<)_nccHl1^_#+2?$AQZo_*Mt5ao`32 zAA4^C9c7WVj|W8rMTsC9TpNiR#3cyrfNKzRf}%!60YQx$;vNMZa19dCOlXaYqqt3Q z8&K4!D59uAQ9xXR&L9YyAZn^@qysLEqW153p1QrHNi#F&eCIp=|2ZFrlj>V<)vf2= zx^=7GTlKzg27MFggzmH-^ek!gKT=L-J(QyVm7@Q79o-Xf9qdv!}# zw2N>lH*%68><%*_Q3#PTWMX%Ri@)nIvvcuR%5tILUyJ#^h?qN9*@kBh6&81BhE)D)ORG1T3ngjOzdPE6hTV#1m`2@Fq}1$Ur7<^OY23|a z3Vh8LVjs*EA;9H`b?9{ zVJovPusxSUjHoM1ap-=A zy^gFx!9Iq)w_z`5NyMQ8t;eCaOGkf{p}&YrZRq%lr-{1BogvhS=ZlWJGmv`gJ&`%I z2I0Z|pZa{ZZPCQs5~8TWF(`sARiWhm(OomB0|ZY!@Y3VG(#KPEv;|~my%{+DDUU!( zpG-JV`g1QZjk;H8qJaIV;KtljqT}vSGu>u}=3%!78`vD-in+bg!R98xYX9gf>WLQO z!M?7;8aRJNO#y5pSY`$L)RQO#I~Ld#X2)#|ti}_-t{2Fd`vqDdxb;k-*%|{oQ9X|c zs_2-z+AN_CH14o`V6e%3$0a>*)*~C%(B7<}hvBS7c2=B!JduX8x8WRtnTtw2Pq>=g zV8eN;;T&u@ON0yOQ_zx}f#{f9EE-+_G;p?6z_Q65YdFi14V;%)=iflBK%Yg(&WiKQ zbexrFpPl~#ods~tMMtsorwd=q%@iGX)0sk_Il>ipy$xrsXq>MxoB`0l>AKKHn%sl5 z3FxyB*}%EzIB%q%QY*mOjDUJpoX&iBN*li~bDY0R}z8h5|IvWc@6 zoM{J@&Q=i9roRe$< zC_#2soaa1-x(R*WjrOU}xtu?Nb3PP6oHK~A<%QY+~99Asz3`O0(@O5hB$V}Nrf!`aPnwlSO?3}+j|S*HOK zcXvZ0)Mvfun42gX5meBy&l#QB2o#oS!carXjK;0y>?+zl|Cg`#7wx8W=T4V*I! z=hH9;_InAkf%7(8W-Du`72wQ8c2=Bk{vCx9{l16+p>$T9yQJeBY&fshBpP)SFvzIS z^Mo(vE)gAf=P`vo%MIsxu4sU>+HkHGjpq(L&RWBHmIgLLYRHB@&o`X+QY+AB8M3qD zyzu z{a%V};QaJxug?gz0-OP4XT|y6BWXB);h+Lezg~^Ho`!QL!`aPn?qoO{5dx=Qn$9&A z^w}&r=I$1a2&%{Vs^Q!YW=s3b^*9F_&Vh!r9<{UL+$$aDsfKfc=Fg~`h(ShuULt&0 zUx<#oOPE5R)rRvIE~qlY<}nT&j5~>Q=ybiF3a2VSOPQ=c||kXOVDWelnaTqGN7=;VcCWKVN4!UxPVN zpJm7f&ixJN57Y{979u+<&W|2S!`a4g_B5Qm4QDsQ+1+q`QDQ|#b_hCb^J=cO9hSbriL`s`>pAE#EJ&uV06)#uF*rs?wq4u0TV zp?N9lR>OFSbFuJYeIXj>Uzq}DiEv?l;<^v|EEOGdgGFQg2^u(;8_u_34(#`GWCLgU z5ni90s1@KWLUvZ1%ciB_>|i*18_xcQv%BH!X*jzZ&K%*w{KWMXaOR4R+4>Ya_@FV4 z8V%=ehO-da!1?3h9;fbqfRpTW~X14;nbXHk{XJU?-n;y4Y|&L#+U34N7OlIr)J!ea_|J2hP=+ zm!d8V<0a0e!iV*RXq^8>ik%&oZPC5lR^d6^d)2SWCz`^4 z@@niTc-)b}woYF9w$9reGk#lVj(N&XHnN8iLFmH#62f}gI257v7y=)JKAO-&m-CU@ z9nPAPv7y8DGz;w{IhtGtHdLjX!*y;Jdkk>ff-7MUp>g3No_EsN7=(LBygC7)jEoH( zy_=z*8)eK2+*Wc&+OH{aFKf*ab-&XF#O_|OOK#{CxTz}8}<*kCySy|J%=LsgM8L&&kloZ!PKn+s|pKkN;#pCw+e*e^bl) z$7j$-Wzc;y=z}uofBxE%-_IHJ_Zjrp8T1z!bVUaJR0jP>20b-{4rS1NGw3rj=#w(& zK^gQ>8T8lKA4%6|yNv6_LVs7F7$~zDF>1D~ietLOnDpQ;<6diXjA>~XL za5M2MysfHZUW#act-$Z675Hs0&Ntd$106ns4OfRpXS9EI20b)`J_&R>zCLUp(_b&) z!Tt|X{AT+&1=W!?e%kvwygeCJhj&nY0QBbz!e^pr+WYymUo+=czUMohdK28IcoW=s zE+2XOfV9Qy7{(w2ufV&W3n3`xSS>&8Nl5@ZRJ31iYMs;MqFm=-&16f>mn?MbsOscW zGs{Z?-no$4xA7kSY;b`GnMPd!Xs!TqrHZJ_6CHE8Oo7}lG-Iwt3(wSHoNCd2 zq4_56cCn6YauM`1F*bt6iffmH{W@-tVXQ%R)~8YTPGKBs7;l{BF;?8|Fe{q#sgb@4aIYIYp@@UllL0n!c|>6Np>O6{$o?8 z$sI-%STFL8DW@FdCAx;%3ysPz(V{f@{yKL65&3oL-uHVje*rrx`mJgltrpYm~2 zx1ErV$`63|Fa-M`($gs8T7neSx zZWy3atiSUT9>k~RC13b8q;jKP_eDERTeG^;ymfFGSprlVwH?U6Yq!TD^$>Mxy;`DIB_kH^K*Z;z&#Gr8XTI;QIETyXHSCBgo5898B)2v zw?GvhS2dZjqrsK);Rbq8kJxXlWB9=DH|Dy7sn5_nJEV)}?L_0v7O192>hQe8-&n+- z+tqGwlUu}_2v~Eok3=kj?b9&kQ)6%wwaDgvV{YsFjSv16#n80{Fk<(iEU3Z#J={u-XEvYlsvz? zk73@yFf%5kyVKU*v*;?*5bth?2O8oN4RIese1swHL&VT`E;uK*&fi3H1kV@_!9OS3 zPU}`_gBTW@OiJ=KXqqFD&@@!`J#-<> zyPrEl4iK(f#U<0N=0O`-G!%T{058)GvQxwhSTg&r_0T&!JXz80L=`-kYb`#Vy~6ma)32RN&RC+e;>D=+h4hVR31g#BYOM6q(8y_aG9Omh(SERdby zou{w~@0};gQ6qlEUV^5(3k9CvR@*qaO{VB{yn_YLKUhm8zNJMyy*93}mI^m-X`fU} zyIMeUK{PvoEl=+E`mTo454}$E=s?8G2^udTVRz zL~CoHwbh6zj#6pvImcRRW@ae3gSB+Og!QL=GxRqk)zScKX_}3+)i7g9wSp<6;<5ou z%S@^bR05=`^V#DHyau`c;uxtxc1Bx`92Z`yf5Dqms)MYpYpty-tgUj?wr7n0YV9zv zgy!$G`1?B&6@jFTMs7$oQf7@TqM~6CxzSs zSH7oeZabljxfkU)@Y=EW+{IS?c~p)hy-4f_Fm*`%i(&R z!gt}7k9lRi-e0!T&ebO7M|+=I#NHnrsk7@JTKbHoGb~L!r+=@}_TJ^lBc9fK+0ySn zuE2boPG6Hj7lQ`6#Cjpz5wsUU^SK+S&cyq#pi-*659Farj}RSqeW+^rnx6QjZ)a23 z55yDiYgZs)=ett;u>U9;=WCFXZ=PFM*1Pnd=TD)0ci1 zNE4o8DJQZB{8LJ(j?}mOUXSi~PPw+_{m#U-e5W;U88i{%h#C&m456!m2@k=qfSba} z6L&j9xm<%cC}9P3%OKG>fdo3~bmQ`P$*rGvEM&cr(!phL0?v9b@##bqqVvG}!6+?; zX`vq>uHS9G>jKgS?tetbT!1OSH^adaV=YXG7&U1EV~uFP@so6+BMoDKz(c{MJ-k~R zY8V^AD=WrBQW!5p+r&6UQ)Sdmt?(Fc6gIs7N_5QK$P^fB3}Z*bSSvc}enY!-zIC99 z5o&L8bL6v`*#mKIsLTq0{e+@S`?|jH8atgnV@EDI{v`;6hV>Q4)N3R9n`z+?#wF7n2x!g zCf7d3trr^%1xKMAHSmGDPj}DrWmQqX9>k^dXj&5&$i-D|Oq+^zhe$_r3wg=+?<<$1 z#dV%r&ZQR^1i*l=dA98N%EoypjIc-pFo}k z)se(}oVZ{8*5=p5eEgQtA6c51kN;uxE0$KPz3TAkejfE${!kYn9)dR6!|Rmd{U1;b zJ>)v1;jL7IH|u)FC(qwc*L(c_HXicSM`mgrk?nmx3H*}`&$E`!vNYrQpYU+Bn!Y}` zK7+nGgT5kzz7TZF`}xXc>9M@dgy~)7XGp__M)X;%&=aeY5YB z5y)rT=ZTKF5ln%*4#SWb!(92Gc{&i5TOr!q4>0O{^;G%Ur1M#}hsPMA0RSW2M^=nu zpnJpk2-+sbcQu_w-G?`Mj4ult-ghiI=3ZtBOf`n-KItOqB~~2jo8QrzFGn$M00-m% z?eO`0@G$T9ibidN+fg1j>dxdPi`Q*$qP$JDAzoLy*-rBK6r(GQ(YwS0UF{&87v>ky z`b&jo6kaKZ2g`MBqOr0Ec z&jTWRD8@?@7svoN^EA2iG+hZ<3%J+mbG%E*bypgLSHK|YX>#2#W#fAsK#=q_xvr3; z!g9IEuw1Tt-^P4rUVV|HIG5|zwKfhD;}q|0!j{6>R*x~0+`>2Lpdh^3^8Wa4dWh$v8`e3Xc*fX#%jZ; z^(hCiVbuB*7;8ZjqnyeyhOv&Bq2Tsdd{7Vl3}ZR6vtsO$!dPq=%e<+(@e{lrONA}! z#)!uEMVLa5MZy&G>r-GX5pC;JU@Rq^D(q{>0-D?d=6uSSkAOv!|# zBN}%apsCF|gL#6%etESxIunQ?_!u7Y9LvBip)~LHivp|D;pA5jLvlyG}zewo4>whty z65;$Pk+tsn_Y;o>_YsVkpx>i0t!%|e# ztp{`pw*sZ9`PHIv{tIdNwATH+|JX?`)`L1Ygg8q!KcARq?D_4;i#8u*c^*7`HX2M@ z4@Pda@)IpB_h}fDlHRj_P|Nb+Q!?n|Gw7o-=)M{B7k{*9UtfDk!xR2F<9ghs(!Y#kpiH7hV`1&E{NIiMF|f(^Qk2 zCU=~iNp9-m2kbrU=6^SnTv3KXezto|V;AGcTc!JCtT&I>kWce?TQr`3WeWFKEkrSQ zf+4Iigohi#TDd=)?S9gzM(~)Kp`h#RF|I>z5@R{CvpSW z<6eew7sFU2On5#Gx}X+IMB{rTp!p4zy?DD@s!Ti|#-WTtWuSraOv8ABVJt*;R*d_m zFrH-?Z`G_9b$>AS z&>h65Uq^qBlbR#+_Y)r zF)1qQo<=DOcaMaOx(7wa+&xIMO(U2;6l=ik!~dVppSJY(q2S)5as#cymkdr+|bRDnJ@#B5p%EGOH7~zz*olKanQH5}z zMlo0>$y-V z-UqG}`wP5|O8DNL{lfdO?N>i{nEfht2l5wON}(FXOUTK54or{fxf=6b-{=Un;jOMZ zlQ3VW*RR#k!+xY3Sn8P|t|#f>a=?z0-W8(Ze-rG9wLtC#3wdT@h1}kInC?X?jp@A{;46J3Mgv*qn<~nqraM{fPR{E z8FkZP#B8EcsPX)RXgps><3?8&xm(Q4n>l-VJ1%tFNo^JW?$~D*xSxcl!fx^t10vU5 z!M31@QfeX;oVaarKn!=M+O;xXOB)a+?oYTvqc71FyqKGpOKAIVU`}Lz7uprLRy^__ zbx$fE{f>My`$J_+=yevwgAf{3IDg2#iHlw0o|Rg z84mi#u%PZvlFp*;4AC)n5{Cu0{mONR*slV&ul*`?yW^LpY~q20&&US+ z3)U#vLuM0oxIVaQPJ0Q6@yDKpBI?;Sq2N;;yj`3mo&K9Grh?IFl8q!1NH&S19_>|K z;w2kPT%d0djrZ#@WuF+%tqo_XXzb6b&k|1+&G8-4ENpS*?#eDpLDw8bo|&*-06V# zkxAt#^8(9!dqbyl7U8(qJ#-17V8j0YVVMn`a<{qnxVAYPI*ppYq0@+M?$YlAmshTE zYh`HjlCPs%3pGvJG@{d8OC;dz{4eE+;-eQ<=;u~B?h^T=RQzEvS3~q!rn$MI{lQbc z&%MdD)cox z4>GkLMA}969CxyJ6e@MoH4Fy9ye2N-q@T8G!}qjd>Z?*+$)8)}d+l&@;le*~=U7}> zKk2JB#YY z_)4iS>S;GgU54?G=BV4T0)p``8spz!l(vR(ylNpAd=lrO%H%m7xFOYdxKy@qQl@ZH4AB#6Mu@M7kL5(CC(m#`CW> z0E*mO_!Z`h-8?UybRXkSwvX{A-N!^e3@=I)V4(j<42<5E)xWPMC^_tuPfERhiBhb=)jP~Vl{s;1h^Ab(jFGZKexUO&j5opXv`U8r( z?gC_2C7Ws>>3JqM6vns-HrD6kYItN)|7(4NU!g(Z4}StHWO|LIneTVYd|%u{vRW@A z>bb`;7Q<(yWx7+*9!+{MQi2_zH0t^*#rp+#9V0K#?Qg#VZcqEw&vmh1c>foEg>%H2 z7NR#ijfv>}O=BX@Neb9YCjGqEux@|G;QC9goS)hCw9U@X@FgbLYaH(`kjJY?e-nO@ z+lvc3cmlqBg_HA+q7icN?>-su%hpTRWql;*KUxVc!$8gt%zaU3hN{&1?g$pjoQEqbF zC>qNp7D~twQ{up7xwV{yAx^EbB~CXJr;a>B!OnJGp|goo&XN!ZpDAh0 z*doIzgIrp`#3@D_?41&TW$*Np7*SUw8vDx>0^$_AgH4=5HtmhA)XkLvVUiI^yr$pHj=LAhD7TyU32mI!HXCQTq-U+ZI#3^lEoIO(FoJw%$oe7+Y zA?1npovKY65KEla*Z;Zs%mriF{Rryv@s1K z7pR+m^{C&ZDuKET*;#LMr=6L^{1LGL^Us=O@cmwLwckk zZPd+f%zdC9PwkJ*W4j5YISHigiL|#N&GkrMvtt66vOl3yMn1CY^tcq#>w$neeM~bQ z;@_}%>hvBVMEqMc;@?c6(`rMyk0GrQjs59#q_xUK?{_59+i4hZkafsK?{9}?AqP+$ zbpxd3$j*xNp`nB)e^Rfp*x)v562tdD4XIO#^S>}|jwnYX$FM77bAH$rxC_`JFyn$^ z$Z#`UA0rS<5rNSCGR;M(;s3ej0^TCgQTHd&iGvz;i1}7}Hxw#iE1_V;4_>GU)d-;i z$j&O%d#9t27iyD6B;NmNLiLgmIDc$H?QTMKVT$H*4HMUkat%I2u)UCx$6!G(&mG`Pd8?HXn8aPDy# zfsn(*7W;uPa|*DG<{k=ei*hu)zsQi_PUG%!nHRp_4A@jbM~()Xi93zIaJ&{KviX)( z8S4fp56YIg_cYpdGg{^*7_0egMXa_3E50e&3Jh0)CRYSh$#TRXvqj7K!5iEpZ-UnZ+v-&%eCI`@FL1@bz)D?(eyQPwI}kk034e@d}tx+BZeV z+$%`KC8~kSelM%cAAu|LM z0=y``QTLi?Jgg2BgG4#yR{7kNj`>KgRKnG4ZtcVg57z4;ue_jDLx{gZwvb`Y-Vx zYy3|z{)Za>!;Sx;#=oB{ApeK{TmE0ksYTs)7{@fwPsBIsJ{KKxpCF}v^4uc)3Lo*` z^1s#i|JC?kWBji-{?{1);cg81ul)7D)XzS~{{Z9P+4%2f{5u=}BG;b$Z}<=S+jD)V z7f(7IzQ1|gVVDQHt=}3i{qp`h)b*Wa%#oqsbSBv0#?$X{KL4)CYWYZeo)87rsK7!O zhLgjd$S_~+(w5cM@?s^bRcFT6{D*aaA24)q<&S3+SN`ktVjZD+6;oK+^JuG1WG`I{ zB>3idlRM~?7UW(evAEE@hX*dPY~y-CONpo}9KxS?9_nOT0Pe3&@})VMhKhfC4NC$v zr4QMjA;+yr|5vt%S}&rOR%5AB$Dj*%sfn(MHx&^3rKq%Z`Hp≶cc>o{Gh4&qllW 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˜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%0D;#M(hiECBY^H|!~=e#VdI4}#Cy?k(z{^h~bY@Y4 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 literal 0 HcmV?d00001 diff --git a/System/ior/files/gpfs/5.0.2-3/lib/libextlum.so b/System/ior/files/gpfs/5.0.2-3/lib/libextlum.so new file mode 100755 index 0000000000000000000000000000000000000000..ca77f97b327f11c8d34b8246e4052391c410c65b GIT binary patch literal 6714 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�cN@&18_utJk*{>pi_shH@9c;g{XIQ{-9yGuM`yGf zgH053#su8Kq~RjSj+{#A`t;F``}@L`YZ-a{qg?8^?r+o^r|Q>AbYDYvL3Sg$Zkar< ta@1QU$32nzMytKuc{xJ`D|blMZ?>FwKV)0&!pU*BByWlM_DH^D{|CrW!)*Wn literal 0 HcmV?d00001 diff --git a/System/ior/files/gpfs/5.0.2-3/lib/libgpfsextlum.so b/System/ior/files/gpfs/5.0.2-3/lib/libgpfsextlum.so new file mode 100755 index 0000000000000000000000000000000000000000..ca77f97b327f11c8d34b8246e4052391c410c65b GIT binary patch literal 6714 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 literal 0 HcmV?d00001 diff --git a/System/ior/files/gpfs/5.0.2-3/lib/libgpfswatch.so b/System/ior/files/gpfs/5.0.2-3/lib/libgpfswatch.so new file mode 100755 index 0000000000000000000000000000000000000000..17ab72424a91c190e6f09f9b448de770db0e45d6 GIT binary patch literal 129031 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 literal 0 HcmV?d00001 diff --git a/System/ior/files/gpfs/5.0.2-3/lib/liblum.so b/System/ior/files/gpfs/5.0.2-3/lib/liblum.so new file mode 100755 index 0000000000000000000000000000000000000000..409dd7157b013641670c02a0baa288b60c4c180e GIT binary patch literal 6412 zcmeHLZERCz6n^j8LFJ>jAn1%AyFWS|Ms6q!9g^to)^4{+k!m-cfqCuPZfoee(GM7k zaXNPF-DAr7^R+b?|aH^w;KIn{IfT? zJ?A{(e#U^XC+^R~vs=H-MA7e`HuAd-{4f=@ z#@WE*5alAXfzLvCE`kU9nhQ^Lo6ms-KyhsI;K5j!PxQyRBE>$iU$oh!O29fCh>?H0 z@AETne)H(|vuAgfPHyhK0#tw7Y%m&nzhsDGbdg}8Yirvm`y*3bzCzuwChBINX?N6t*bS9k20F;ax@fjaKt_waS z19w<(eD~B`7MyQQL)Boxt@}{2;MR5DY{9K-a)kw_wT}Txt3RACu~O4V@GCa90f+Js zs*0ye(3;*w8Pi-mVaNwj#wiu24Ea@*aVo`E4EY6=aSFx#hWs?jIP~HkL*9on4!JlE zvT}!VyV9d{_k`33&Nv{9nt#gu6=+p`ySwe3_koM5IeSyH0qt;~1L~P7^nk0XpYrQR z1Nmp&rvWTHXhLd!qdREokMA%vpkylW1!SP9`Gr@*_;W$Yn`?6&!l`+4>Vkm&o!;%1 zaxP_JN&v1Q7qkO$<$?|%j$GT4gSdg}6OdNj?uJ1~7%{)_GU&|niP$&}TBe8x>`PSf zW&6jfZvRxBcvny-eiyR^u-goFYCb*Y*H5YX*FMh&m~Zg_7#tQ%&Dret z{``GHAYcC+jLkFk#&PKPAP(~oas~Z-siYsx`$`k%oLg=V=sy*n1LXBfK&R&R8X1bJ ztCkok6DMWN=>zX!YB%&L8N|`@h!Zck2&}#6~Y;{)yv`$sfhteW3G4 zzQ|`w5a~hZ&1R5Ah=Ui=d#cO>6|lM^3m1RVUH0YA@_ zqMw{$g!h62j8L5X1%^r^RC5qS+2viz@*RRA99woYuy(tJ&A|Vg0e;Q0UVdNxdcHJ*Bihep`tR(*f2z>v z-u#N|=b11wZ}SV^UJV@QZmb|m212*r^IT8&D!+!=r5qn4M=t+Ygubh*`@fzirjyg# zIUV413#U6deT>ttj*c6p=1?}|lLGN%c5Io{BCnELqz!|S$nq9#)$;ySI2jp|Qn4-Z zbbKT!c~-AnbHl1Wwmu!)+Qky_{zP_IPLIgZSbuhqeKy(K$K>?3;Y_$6XeMRSA>sy; zS$Qa&9%6EITN2Dnnn^J^6-$KW(L{#Hnb;Worbdj9E;%-&4Wz>G;f5aJ;dq3}gCiN! zGBPqe97}>RXXH>%$S1E4cBjE8nbnLjCF03V)!F*@awE9l+M@M9>yN0)yQF2{;4)7$ zyBy@-N~ICxT z@$SmdYT&4E1Zlk!rTu|1aL-l8zY#F(llG&;6GLD6~=VEv$Z?u2#Gi|2$ zquk&rvzzj7b^NlTia|R8qK)(QIL`HWPa#eN;nQR|TmkB1w0^ibyNYnWE(k|z0}nc< zD)GAVy;+Id7@aGXxSi2?QHj@=&x1;Q4x{~DiBGRvqTU9RrTtiGe-Wd7R*BCm*PAQx z`Q`h&62}Vd^ky?EyffjvsBKZ~Pv(;ChcI2bt!*^A=^Dzk_LAf%WZ5KwID08S-^&-Aa4F lr%^2yYOa;_RbHyK)>kX)wblx)S;OT8SuDa<)^m*l?q62KY5M>G literal 0 HcmV?d00001 diff --git a/System/ior/files/gpfs/5.0.2-3/lib/libmmantras.so b/System/ior/files/gpfs/5.0.2-3/lib/libmmantras.so new file mode 100755 index 0000000000000000000000000000000000000000..eb7daac0d0d0922cc5036ef4bf3c0a9ed21f049f GIT binary patch literal 410692 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

JTOm?Gm0g@+c6RRyP-X*iEt#sTAy-^#6jj_dM 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

< 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

S}c4b(u zq^$r15l)-v!Qjw^8usv&mJ z?aa+)(R|0Qxs{_u0)A!_lV&CyyT`^xAGe!_n=P4#b}I^REB+iSa#a`i%|pAP*-mEo z(xc5o7?oa}ssXTb5F(_^;*G=0YQR4K+lL1B(Ja_arJv1d?B~RTY{#kwzjimUV3=~ zx^98Xt4U-s$4iQ8zrc-;J7<+Kti{MFmZc`I2-Am+_j=LwqV0CG!~9Xx(&=)yZ#Rb} zK=o^iUV)Mh^95F6kf6;>0sh9PeT7rAx!LF^c@G0?vLZ^<0+dwQ4Aac(D*gUDrwfpl z5#M(4X?xrpRRx5B{Ii`i#vtuWIuI!h|9qO>!c8gj zc@N?Z0&=!H9*hLakYD^bp|AKg7iqxN{~}QR)@&%_XgvM|9y-hknm{!N$Y6TicGZAD zW{A_CExV=>`|ESN9`BHFEMs6?-I4wr@63*}*D`M8LtLyTPsNPyx`Y+^iw97YU9(Si zN#pLC6}B(`S@XSBKOvhc`A$7xYo8WGhyiv=yNEn+IcqhOo1XBJ=$I8L85B1hBbD(a zI(R@X`Zb12&Y?WMOQadG1viVpmqUby-AJe|lISCj0GSJ4ce-o?$Ap#RAx{ zEYms}LCUNlWY%UxxjJ-iEd&47A&sGVv0rv@fj^Jyd(QDN7)tK9%f;+D-+98I^AEFI ze8*tBTKtNg^FBiWBLhsfwmQ)XLw=nY;ACMKp5|(~6Nq>N@F7D8{3FQ{$s@?I>$*t) zKn&JheU;2POAh%}2fuROJskx+TC~XTb@#R1k%)yYjimq=SX7{{2SnX-aZ+NgwEQ04HbjVDB4_go;EUD2 zbtH$?C^AAw3&+(VSW~6AQ`qVO`?3~InK5~y9iCuwE0$NouV^fC|t6w`KkJz3l~J0zzKk3QojuvYcQZ+4z(S3}46LpW4i z-@V6RS`}sJPAhB{UO4?@{-yu-v%;A3BQ=t`6`JO_ojkRZHi*G$iR;Q|(j+b>lvjhN zPm#u|Q7(W`^#j5AZ2RE3}(rmz(q zfolh2-WNM#i0o6XF)8kl2s#ufSSkOA+MYwzAG?~Lennyy76wH=P)k+-obIqs`A>Cz zV5NhyEsn{yXhRF+3T)1H(gQNZC08dLioyYNOLIm#y8CeJgymd}Fsn`ON$!o3y0aSu z-;p3$5AF^RRNA3=wf~uMiIr0+4nk8%opT7qR(5zt(m#MOq&z8yIa#a2n>gkPi;pTq z9%f&#e<7+CDC}R5Of~ZK=uaj?Eov^+^=5l$m(K{#ZZ|({QFL>0TkTkNj_oJb!^$;9 z;wa-p%MD%Fm0nkCX;*WKP)J`o3+ntf(4LI;1hvI5yTpNXQ@#lGJ>S&g%k8O{K z>2^8Am!qTJY1GGF0B!+MqX;U|ltvqpLlkG_u7O%*qYI0pc8tUklH>4C)V5 zQ8G2Du!g5q1)2n|sV%uWP^tR&W`zVCq|(MBnt{_xg&fMHoM=TP<@K;gxbGHw35Y#< z4nLpx?9PENDZb5jur(vyf5F~>Q30J*G-B#C@sa0L%K%%^5>E(#=b7x`u`%lY>=_!C z^o|S0MH`z;C4pmp)7lQ0+?>%J}kJB7NYbNPgagcjTe18Z4!*e40f;c7!PE z!7(q(&?-xe?-OWkq>nzT_QfV3TKz;z*dE$o85>FQ-_v{{lgYyCpK)dNqu~77|A>-I z_U(GMf4)J-zii`{As4E3xUIW~Ly;Jw!+o8+IA87gry zg07lb{JGJt5@6~DzI@@v;)c-Tf6pxjLjSi`COlZ0d7wjq4&>xRb>>u;bJV#|Y$9&t zcp{9}s1*gs!a&>~hn&jO5hYT<*3h3|K$)}NqCEPkS4*WknqQc4A#r0QgGrBy7ANHX z#aiVcZo)jIe)olcHy^B+p3DR643m zH>|jFm!St8-&&S7QMN!Rvsc_E6tWz*@lT*-DY=arlQMnXJ&*>I#fsiM+m05M?h$oV z58bMOYGp=P!v4mGq79WSC3W!dV-Z`>;80Fn+rLLsD6Z66<#cT%DrAnRR_?f7joVe{5cC!e7H|7Zsp;%yKK5&vveRN8!$W-7S508K&GyYWVe3nprVJO=#+brn z*#Q?`%dA;2@VI`qA@`LN&@9j#9Gs!M%v0j(>h59vu*UEcEgyg&=Vmf!c|;x#h; z>0u9&){*5Glmcgv(~QWK zb@|5RJFn}fcy*!%FsKX_RrX-Jl(tALDmb~fVYnAM(NlwTFln+=YI5d?k*N|TaP`NC zjG<$N>1i;W(UcmS&{@4`xC7(jxOv=eA=#Edtz?`WiBAMrZjeXUHT!WyX0fU#(|k{@ zqFflzwphv0H}ozZcTpD%nqba^;@fl0mo;b3CO$tyI}fSE=QRa3G|N&q3z-Mh1^$oD zckb|>XxuD{oF|!8@OR0~;wV+N2Cl++k48PzlS~AGG-;x0tSZ{^j66Q~ZN}ilUBKh~( za$#3ur2x#$&^WQ;TcD%u>IKcZozr}5m|Bsyvwu<17$jICm!{d{UI< zSQqGofdjSBnX%pfaekc#@Ot0{mvmmhEyjs>UAwUw3V5U%ehSZ^BdJq zU~vAp&~ibsdi_0jve{dAR(qllA6nsL#qQZvlp{&Dy_hW=(|S7FL6Xc3BB&h>);&z z^p>n(`V(M&g}5jQm+DRabbPzUgQwx;xY=fhYdyLYQkwZU+ z%InnJJ(rVAzsNP>DzItg$8XXq`9w6&4oVJQN$f{*()2eOder3xIF!ZGd9FL$7=VJemp+d;dTQeC~P@a{r-$Tujj5#`_Suk8LY-CYY>;%*Kgc z0!?E)m)O_Gf3ym(u-c!K$pJ*c6%R@mVT5B)3YtHb-jU=ZcVy+b3^^_xvmB43vGu)z|Fx zl0qpu3H>yCc${ELMrkIPT2anX^Adz1Jup*ywR?nEXkf|aHXQ$=eLF!CBbn1oA&%jC ziL%$UgRtdeoYle0Zb&pLU3lP`o;n!vbmqFtN`F!)U0u68D7(DCu;L#D3>wBu0EgVt zlrCN2+|h2a`?!I+`D&kvyPxCF6`9|={X?=mRfA1VQA9NELFnnvE9B<_ ze2e5KGsE7MDzM1FW`SL?yYJ`wNKiw^v&YnK?d$pm$E_guxpP=fC>u|HMP+{SBbguN-`*vV0akg(-I9U`WTt5@qY*L4fgV*wcI~ptH zoaCcM3r1Q2)jd~OwAzPDzW7hxV&Gh(&wKGa6h{z<^_f8$m?~*r`unY@c=>tjl+=_b zq8-^;io`xG^v1w!Br>@NmZn+?{?a1Jsud=GK$nL5StTzr%l-QP6 ztwT=i~Ee$Ql5b%63EKlx+~AgYq+Zz3S##{I@KhGTsqk+9RNm-l4@bwn%Zcj)<(dZectWp zbf2_`VXqWO36o%O{qZ3)p&N;nDGvFE&HVW+*Iy}^4i(c)fnC==Z0zH8m37h@nOjH` z`k*|NlZ&eYsFOXW7&$rxCJFj0uSZp`>-le%a$upI4_Wch>~71lio)`;Yyw<3A7?dK z5Obs68D_e9&a5g&-ZYr*`o+LK1E`VUE|+f7w|t(clv=M}daR)QLnxT6@dAbq1{UJJ zYV2pQ2!$A^%!?^S>EtDYf7A@BI-?IDW8V*$cEGq&CL)|##|ye>W3R6X`ge8hive`o z*J|T#9}Nc}G_GmyH7r28q4LsdNWE2e2!mOtfQDl~3F(&NS2AAymgGQC%D40S#Z2Fg z6AgkIvq{onWi>1Kco|kXLmh%GjvwuDqM7(>Z?sPI*2V2S(S3E>?7){GQfkZ@@nnlz zr`S`=s+r0%yn8wBD7HG%@~{U*7$r~2Dh`Gr;zWkKU@kP;GH7LYwR%4k9priF6?u5p z1`#8WvdQ%Gye<>{RTa&Gm+PuQ__^J)5nj!&(276RGNOM0X9k-6oSF|&&q5QnJK>b` z{K5XX0k*Fo@qeQ8m}ECSi8mEx++Ee~my#72cXMe>uPfI>#;s%THjBUZd}(FTKz23- zPPpd-&EJ3Rj_Xftx2EgPbeo0)=m>QEqFs-YQ_AW3gnK?(M;s( z8`)ouv;pa@gF$ND!i6!xI2B`s)70*YX`4F*vr)XHuCiLwdw4ddZ7tPvoB~E=9d3C; zqoiu%V`N#uui#6VEAAJ^0S#QseLq{cn+8=6JkCR)-waoqslHS))Z*C`CjGN}?u(9b zr!?~L(w#d;g&V`~rp3G_0`ZgH8^&Unv?=ijA-;mQMFYA$aO;ODHB|;*7s$B!};36az#(7 znpzhS7TbB7Zu_Y6%~V!YR11Zj81!7sjg72_XX4ia_VjxjsMvniqWnratIJ@4nFQTf zb%JfDy!Cv9_?i;mOJ_9G88hHI7OGA8we!lL#WYPbMmpRcK4I{tqlRE5h4pA1!B_fj zc-FCA4do>iccclf%he1rC5qdwRdI})8)(J|hx%aHkdKAoL`xZVv>YgHZ24^uzFWFw z{~a{mC3@}=O;IZhR4dedwE_dN^K&E0r$fH)F1bO%0K-P-yG%0r7 z(3Jsy4et7%v7Z$O%!oztD?;OOvWvgdUh-AD1;HJ-a7G31!Oe2AMOR-x)S1n?;;TR? zWu`CJk}Vf$*+SX*XNgkrH8%QUC~_%Y37a1SC7ilj7?lgSpxu03q{J(2fR&f2WXFMF ze#xqmR24vNgj=$4y7#5u+QU1mMohT=KgaE12DZfCH8L6Tf136YOtAmdYv00DBX=1? zpG2J_g9J3gb+75(e>dnLRZN~q1#o{5&G_3=Hs93!;!p!9iG3g0QZDwXPZbMa9PIXX z_mk^?cL}OS0<%6-7od-|@B96BwwU9)jFLNh0sJJj345bbHuhfDfzt6FUsunGiiM<< zp;pw!14tzjOUNn_pwa*m9`b^)De6kSy*2EGjuTS!v1B0s9X|H=_XIz2($I*$$mbTi z5ZQMBXUd4Tv(KIuVJHlgy{61B@v?)9JfD{a=S7ON=iv*;WR6)xwTe0`VuLfT%EU1@ zB-JQV_`BlpZ9-NcwKdb?@eqV23u-{J&p5c9iGM@Z+Z;+(h~QUHh9rcNNri1PbdAgj z)4Rwp>MQr?r`V zl|(iY5b41bsIpzm^U_=+iD+#&SOTEvTJB#MU2@%#pTpRpI%c5M;5yF&PGpYM7u9-F zC65`Z{a@xwbUS46C5ja9iedDakXsc}`Dv=<7A0k@+!IZ&0>4L$7p-&J69Q3_yg*`3 z4%h*5E^uotY69am<;=?^&Uif-6QzQhsFQ}!mXK1warxnSo L5gEy)q162sb{hA9 literal 0 HcmV?d00001 diff --git a/System/ior/files/gpfs/5.0.2-3/lib/libmmsdrcli.so b/System/ior/files/gpfs/5.0.2-3/lib/libmmsdrcli.so new file mode 100755 index 0000000000000000000000000000000000000000..5164fe6b08923b0e3d649bf59fc27de8dc56a2e1 GIT binary patch literal 291945 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�ytVoD;zhuxfL|eU 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 literal 0 HcmV?d00001 diff --git a/System/ior/files/gpfs/5.0.2-3/lib/tssbrback.so b/System/ior/files/gpfs/5.0.2-3/lib/tssbrback.so new file mode 100755 index 0000000000000000000000000000000000000000..e30231e64e9f2af7c969cd98c911ddc34ddf8480 GIT binary patch literal 37043 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