From 3171ebcfdad5ccd5fbec4b10a5729c6c38a16cec Mon Sep 17 00:00:00 2001 From: Spencer Bliven Date: Thu, 28 Mar 2019 10:25:49 +0100 Subject: [PATCH 01/11] Start anaconda build module Not currently tested pending AFS volume creation. Derives from EM/crYOLO. --- Programming/anaconda/build | 42 +++++++++++++++++++ Programming/anaconda/files/config-2018.12.sh | 9 ++++ Programming/anaconda/files/variants | 2 + Programming/anaconda/modulefile | 43 ++++++++++++++++++++ 4 files changed, 96 insertions(+) create mode 100755 Programming/anaconda/build create mode 100644 Programming/anaconda/files/config-2018.12.sh create mode 100644 Programming/anaconda/files/variants create mode 100644 Programming/anaconda/modulefile diff --git a/Programming/anaconda/build b/Programming/anaconda/build new file mode 100755 index 0000000..772faa4 --- /dev/null +++ b/Programming/anaconda/build @@ -0,0 +1,42 @@ +#!/usr/bin/env modbuild + +pbuild::add_to_group 'Programming' +pbuild::prep() { + echo "prepping" + source "${BUILDBLOCK_DIR}/files/config-$V.sh" + + mkdir -p "$SRC_DIR" + echo curl -fsSLo "$SRC_DIR/miniconda.sh" "https://repo.anaconda.com/miniconda/Miniconda2-${CONDA_VERSION}-Linux-x86_64.sh" + curl -fsSLo "$SRC_DIR/miniconda.sh" "https://repo.anaconda.com/miniconda/Miniconda2-${CONDA_VERSION}-Linux-x86_64.sh" +} + +pbuild::configure() { + : +} + +pbuild::compile() { + : +} + +pbuild::install() { + source "${BUILDBLOCK_DIR}/files/config-$V.sh" + + mkdir -p $PREFIX + + # Install conda + bash "$SRC_DIR/miniconda.sh" -b -p $PREFIX/conda + + # Load conda + source "$PREFIX/conda/etc/profile.d/conda.sh" + + # Install anaconda versions + for PY in "${PYTHON_VERSION[@]}"; do + conda install -y anaconda=$V python=$PY + done + + # Deactivate + source deactivate + + # Unload conda; + #unset $(set|sed -rn 's/^(_?conda[a-z_]*).*$/\1/pI'); +} diff --git a/Programming/anaconda/files/config-2018.12.sh b/Programming/anaconda/files/config-2018.12.sh new file mode 100644 index 0000000..f1ba9d1 --- /dev/null +++ b/Programming/anaconda/files/config-2018.12.sh @@ -0,0 +1,9 @@ +# version-specific settings + +# Miniconda version. Defaults to "latest" +# Should match the version distributed with anaconda +CONDA_VERSION=4.5.12 + +# List of python versions to install +PYTHON_VERSIONS=(2.7) + diff --git a/Programming/anaconda/files/variants b/Programming/anaconda/files/variants new file mode 100644 index 0000000..7310e93 --- /dev/null +++ b/Programming/anaconda/files/variants @@ -0,0 +1,2 @@ +anaconda/2018.12 unstable + diff --git a/Programming/anaconda/modulefile b/Programming/anaconda/modulefile new file mode 100644 index 0000000..e9e240f --- /dev/null +++ b/Programming/anaconda/modulefile @@ -0,0 +1,43 @@ +#%Module + +module-whatis "Anaconda software distribution and conda package manager" +module-url "https://www.anaconda.com/" +module-license "3-clause BSD License and 3rd party software licenses. https://docs.continuum.io/anaconda/eula/" +module-maintainer "Spencer Bliven " + +module-help " +Anaconda is a package manager, an environment manager, a Python/R data science distribution, and a collection of over 1,500+ open source packages. Anaconda is free and easy to install, and it offers free community support. + +Conda is an open source package management system and environment management system that runs on Windows, macOS and Linux. Conda quickly installs, runs and updates packages and their dependencies. Conda easily creates, saves, loads and switches between environments on your local computer. It was created for Python programs, but it can package and distribute software for any language. + +Conda as a package manager helps you find and install packages. If you need a package that requires a different version of Python, you do not need to switch to a different environment manager, because conda is also an environment manager. With just a few commands, you can set up a totally separate environment to run that different version of Python, while continuing to run your usual version of Python in your normal environment. + +This package provides the conda command (miniconda), as well as releases of the Anaconda distribution, built against several python versions. +" + +set dont-setenv { LD_LIBRARY_PATH } + +# Check for supported shell types +set shelltype [module-info shelltype] +switch -- $shelltype { + "sh" { + } + default { + puts stderr "Shells of type '$shelltype' are NOT supported!" + } +} + +switch [module-info mode] { + "load" { + puts stdout "source \"$PREFIX/conda/etc/profile.d/conda.sh\";\n" + } + "unload" - + "remove" { + # Deactivate + puts stderr "which deactivate && source deactivate || source $PREFIX/conda/bin/deactivate;\n" + + # Unload conda + puts stdout {unset $(set|sed -rn 's/^(_?conda[a-z_]*).*$/\1/pI');} + } +} + From ef321a2920a6aa6d4181f0e97e40dba4e68a5e61 Mon Sep 17 00:00:00 2001 From: Spencer Bliven Date: Fri, 29 Mar 2019 20:49:06 +0100 Subject: [PATCH 02/11] Starting fftw module (BROKEN) --- Compiler/fftw/build | 45 ++++++++++++++++++++++++++++++++++++ Compiler/fftw/files/variants | 1 + Compiler/fftw/modulefile | 12 ++++++++++ 3 files changed, 58 insertions(+) create mode 100755 Compiler/fftw/build create mode 100644 Compiler/fftw/files/variants create mode 100644 Compiler/fftw/modulefile diff --git a/Compiler/fftw/build b/Compiler/fftw/build new file mode 100755 index 0000000..b352bf0 --- /dev/null +++ b/Compiler/fftw/build @@ -0,0 +1,45 @@ +#!/usr/bin/env modbuild + +pbuild::add_to_group 'Compiler' + +pbuild::set_download_url "http://www.fftw.org/fftw-$V.tar.gz" +pbuild::set_sha256sum "fftw-3.3.8.tar.gz:6113262f6e92c5bd474f2875fa1b01054c4ad5040f6b0da7c03c98821d9ae303" + +pbuild::install_docfiles 'COPYRIGHT' 'COPYING' 'README' 'NEWS' + +pbuild::pre_configure() { + echo "PRECONFIGURE" >&2 + pbuild::add_configure_args "CC=${MPICC}" + pbuild::add_configure_args "CXX=${MPICXX}" + + # Multithreading. Enabling both is fine + pbuild::add_configure_args "--enable-threads" + pbuild::add_configure_args "--enable-openmp" + + # MPI support + pbuild::add_configure_args "--enable-mpi" + + # CPU optimizations + pbuild::add_configure_args "--enable-sse2" + pbuild::add_configure_args "--enable-avx2" +} + +pbuild::configure() { + echo "CONFIGURING" >&2 + pwd >&2 + ls >&2 + ./configure +} + +pbuild::compile() { + echo "COMPILING" >&2 + echo "PWD=$PWD" >&2 + echo "ls:" >&2 + ls >&2 + echo "make:" >&2 + make + exit 1 +} + +#pbuild::install() { +#} diff --git a/Compiler/fftw/files/variants b/Compiler/fftw/files/variants new file mode 100644 index 0000000..24178fb --- /dev/null +++ b/Compiler/fftw/files/variants @@ -0,0 +1 @@ +fftw/3.3.8 unstable gcc/8.2.0 mpich/3.2.1 openmpi/3.1.3 diff --git a/Compiler/fftw/modulefile b/Compiler/fftw/modulefile new file mode 100644 index 0000000..26a1cda --- /dev/null +++ b/Compiler/fftw/modulefile @@ -0,0 +1,12 @@ +#%Module + +module-whatis "Fastest Fourier Transform in the West" +module-url "http://www.fftw.org/" +module-license "GPL; http://www.fftw.org/doc/License-and-Copyright.html" +module-maintainer "Spencer Bliven " + +module-help " +FFTW is a C subroutine library for computing the discrete Fourier transform (DFT) in one or more dimensions, of arbitrary input size, and of both real and complex data (as well as of even/odd data, i.e. the discrete cosine/sine transforms or DCT/DST). +" + + From f06815bd3d922e28d4007216683c00565ef08c94 Mon Sep 17 00:00:00 2001 From: Spencer Bliven Date: Mon, 1 Apr 2019 13:41:14 +0200 Subject: [PATCH 03/11] Removing python installation from anaconda build script. This would be better done in dependent modules. --- Programming/anaconda/build | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/Programming/anaconda/build b/Programming/anaconda/build index 772faa4..1682e85 100755 --- a/Programming/anaconda/build +++ b/Programming/anaconda/build @@ -2,7 +2,6 @@ pbuild::add_to_group 'Programming' pbuild::prep() { - echo "prepping" source "${BUILDBLOCK_DIR}/files/config-$V.sh" mkdir -p "$SRC_DIR" @@ -25,18 +24,4 @@ pbuild::install() { # Install conda bash "$SRC_DIR/miniconda.sh" -b -p $PREFIX/conda - - # Load conda - source "$PREFIX/conda/etc/profile.d/conda.sh" - - # Install anaconda versions - for PY in "${PYTHON_VERSION[@]}"; do - conda install -y anaconda=$V python=$PY - done - - # Deactivate - source deactivate - - # Unload conda; - #unset $(set|sed -rn 's/^(_?conda[a-z_]*).*$/\1/pI'); } From f72dacb7b8b39f6cdb37d714f88ae85ebef4f17f Mon Sep 17 00:00:00 2001 From: Bliven Spencer Edward Date: Thu, 4 Apr 2019 11:12:48 +0200 Subject: [PATCH 04/11] Fix fftw build script --- Compiler/fftw/build | 21 --------------------- 1 file changed, 21 deletions(-) diff --git a/Compiler/fftw/build b/Compiler/fftw/build index b352bf0..74cdc91 100755 --- a/Compiler/fftw/build +++ b/Compiler/fftw/build @@ -8,7 +8,6 @@ pbuild::set_sha256sum "fftw-3.3.8.tar.gz:6113262f6e92c5bd474f2875fa1b01054c4ad50 pbuild::install_docfiles 'COPYRIGHT' 'COPYING' 'README' 'NEWS' pbuild::pre_configure() { - echo "PRECONFIGURE" >&2 pbuild::add_configure_args "CC=${MPICC}" pbuild::add_configure_args "CXX=${MPICXX}" @@ -23,23 +22,3 @@ pbuild::pre_configure() { pbuild::add_configure_args "--enable-sse2" pbuild::add_configure_args "--enable-avx2" } - -pbuild::configure() { - echo "CONFIGURING" >&2 - pwd >&2 - ls >&2 - ./configure -} - -pbuild::compile() { - echo "COMPILING" >&2 - echo "PWD=$PWD" >&2 - echo "ls:" >&2 - ls >&2 - echo "make:" >&2 - make - exit 1 -} - -#pbuild::install() { -#} From 2b7aa706e8d45795233d48b0bc4729229fc4b1ee Mon Sep 17 00:00:00 2001 From: Bliven Spencer Edward Date: Thu, 4 Apr 2019 12:03:14 +0200 Subject: [PATCH 05/11] Adding fftw/gcc7.3.0 variant --- Compiler/fftw/files/variants | 1 + 1 file changed, 1 insertion(+) diff --git a/Compiler/fftw/files/variants b/Compiler/fftw/files/variants index 24178fb..437bb3a 100644 --- a/Compiler/fftw/files/variants +++ b/Compiler/fftw/files/variants @@ -1 +1,2 @@ fftw/3.3.8 unstable gcc/8.2.0 mpich/3.2.1 openmpi/3.1.3 +fftw/3.3.8 unstable gcc/7.3.0 mpich/3.2.1 openmpi/3.1.3 From 8ce24107fc3ef00c4cd068bd62260f3c4d1bc7f1 Mon Sep 17 00:00:00 2001 From: Spencer Bliven Date: Mon, 8 Apr 2019 16:55:09 +0200 Subject: [PATCH 06/11] Update anaconda module - Update build script with best practices for variables, download location, etc. - Format modulefile info - Activate base environment by default - More robust unloading script --- Programming/anaconda/build | 17 +++++------ Programming/anaconda/files/config-2018.12.sh | 3 -- Programming/anaconda/modulefile | 32 +++++++++++++++----- 3 files changed, 32 insertions(+), 20 deletions(-) diff --git a/Programming/anaconda/build b/Programming/anaconda/build index 1682e85..91c547e 100755 --- a/Programming/anaconda/build +++ b/Programming/anaconda/build @@ -1,12 +1,12 @@ #!/usr/bin/env modbuild pbuild::add_to_group 'Programming' -pbuild::prep() { - source "${BUILDBLOCK_DIR}/files/config-$V.sh" - mkdir -p "$SRC_DIR" - echo curl -fsSLo "$SRC_DIR/miniconda.sh" "https://repo.anaconda.com/miniconda/Miniconda2-${CONDA_VERSION}-Linux-x86_64.sh" - curl -fsSLo "$SRC_DIR/miniconda.sh" "https://repo.anaconda.com/miniconda/Miniconda2-${CONDA_VERSION}-Linux-x86_64.sh" +source "${BUILDBLOCK_DIR}/files/config-${V_PKG}.sh" + +pbuild::pre_prep() { + curl -fsSLo "$PMODULES_DISTFILESDIR/Miniconda2-${CONDA_VERSION}-Linux-x86_64.sh" \ + "https://repo.anaconda.com/miniconda/Miniconda2-${CONDA_VERSION}-Linux-x86_64.sh" } pbuild::configure() { @@ -18,10 +18,7 @@ pbuild::compile() { } pbuild::install() { - source "${BUILDBLOCK_DIR}/files/config-$V.sh" - - mkdir -p $PREFIX - # Install conda - bash "$SRC_DIR/miniconda.sh" -b -p $PREFIX/conda + bash "$PMODULES_DISTFILESDIR/Miniconda2-${CONDA_VERSION}-Linux-x86_64.sh" \ + -b -p "$PREFIX/conda" } diff --git a/Programming/anaconda/files/config-2018.12.sh b/Programming/anaconda/files/config-2018.12.sh index f1ba9d1..db97718 100644 --- a/Programming/anaconda/files/config-2018.12.sh +++ b/Programming/anaconda/files/config-2018.12.sh @@ -4,6 +4,3 @@ # Should match the version distributed with anaconda CONDA_VERSION=4.5.12 -# List of python versions to install -PYTHON_VERSIONS=(2.7) - diff --git a/Programming/anaconda/modulefile b/Programming/anaconda/modulefile index e9e240f..6085ca9 100644 --- a/Programming/anaconda/modulefile +++ b/Programming/anaconda/modulefile @@ -1,18 +1,30 @@ -#%Module +#%Module1.0 -module-whatis "Anaconda software distribution and conda package manager" +module-whatis "Conda package manager and Anaconda software distribution" module-url "https://www.anaconda.com/" module-license "3-clause BSD License and 3rd party software licenses. https://docs.continuum.io/anaconda/eula/" module-maintainer "Spencer Bliven " module-help " -Anaconda is a package manager, an environment manager, a Python/R data science distribution, and a collection of over 1,500+ open source packages. Anaconda is free and easy to install, and it offers free community support. +Anaconda is a package manager, an environment manager, a Python/R data science +distribution, and a collection of over 1,500+ open source packages. Anaconda is +free and easy to install, and it offers free community support. -Conda is an open source package management system and environment management system that runs on Windows, macOS and Linux. Conda quickly installs, runs and updates packages and their dependencies. Conda easily creates, saves, loads and switches between environments on your local computer. It was created for Python programs, but it can package and distribute software for any language. +Conda is an open source package management system and environment management +system that runs on Windows, macOS and Linux. Conda quickly installs, runs and +updates packages and their dependencies. Conda easily creates, saves, loads and +switches between environments on your local computer. It was created for Python +programs, but it can package and distribute software for any language. -Conda as a package manager helps you find and install packages. If you need a package that requires a different version of Python, you do not need to switch to a different environment manager, because conda is also an environment manager. With just a few commands, you can set up a totally separate environment to run that different version of Python, while continuing to run your usual version of Python in your normal environment. +Conda as a package manager helps you find and install packages. If you need a +package that requires a different version of Python, you do not need to switch +to a different environment manager, because conda is also an environment +manager. With just a few commands, you can set up a totally separate +environment to run that different version of Python, while continuing to run +your usual version of Python in your normal environment. -This package provides the conda command (miniconda), as well as releases of the Anaconda distribution, built against several python versions. +This package provides the conda command (miniconda), as well as releases of the +Anaconda distribution, built against several python versions. " set dont-setenv { LD_LIBRARY_PATH } @@ -29,12 +41,18 @@ switch -- $shelltype { switch [module-info mode] { "load" { + #TODO check whether another conda version is present (conflicts) + + puts stderr "Using conda from $P/$V\n" puts stdout "source \"$PREFIX/conda/etc/profile.d/conda.sh\";\n" + + # Activate base + puts stdout "conda activate;\n" } "unload" - "remove" { # Deactivate - puts stderr "which deactivate && source deactivate || source $PREFIX/conda/bin/deactivate;\n" + puts stdout {while [[ "${CONDA_SHLVL:-0}" -gt 0 ]]; do conda deactivate; done;} # Unload conda puts stdout {unset $(set|sed -rn 's/^(_?conda[a-z_]*).*$/\1/pI');} From 80c0f57986ac481256a24a9e4c10e92cc9bbed25 Mon Sep 17 00:00:00 2001 From: Spencer Bliven Date: Tue, 9 Apr 2019 14:38:53 +0200 Subject: [PATCH 07/11] Move fftw to MPI category --- {Compiler => MPI}/fftw/build | 0 {Compiler => MPI}/fftw/files/variants | 0 {Compiler => MPI}/fftw/modulefile | 0 3 files changed, 0 insertions(+), 0 deletions(-) rename {Compiler => MPI}/fftw/build (100%) rename {Compiler => MPI}/fftw/files/variants (100%) rename {Compiler => MPI}/fftw/modulefile (100%) diff --git a/Compiler/fftw/build b/MPI/fftw/build similarity index 100% rename from Compiler/fftw/build rename to MPI/fftw/build diff --git a/Compiler/fftw/files/variants b/MPI/fftw/files/variants similarity index 100% rename from Compiler/fftw/files/variants rename to MPI/fftw/files/variants diff --git a/Compiler/fftw/modulefile b/MPI/fftw/modulefile similarity index 100% rename from Compiler/fftw/modulefile rename to MPI/fftw/modulefile From e44ae11c704eceb414efe86cffec9739cceed374 Mon Sep 17 00:00:00 2001 From: Spencer Bliven Date: Tue, 9 Apr 2019 14:51:32 +0200 Subject: [PATCH 08/11] Reinstall fftw into MPI category - Minor Updates based on Achim's suggestions. --- MPI/fftw/README | 7 +++++++ MPI/fftw/build | 3 ++- MPI/fftw/files/variants | 3 +-- MPI/fftw/modulefile | 5 ++++- 4 files changed, 14 insertions(+), 4 deletions(-) create mode 100644 MPI/fftw/README diff --git a/MPI/fftw/README b/MPI/fftw/README new file mode 100644 index 0000000..f7675db --- /dev/null +++ b/MPI/fftw/README @@ -0,0 +1,7 @@ +FFTW +==== + +FFTW is highly optimized, but downgrades if run on an older processor. It +should be built compiled on a system with SSE2 and AVX2 support (e.g. merlin). + +This module requires PMODULE_VERSION > 1.0.0 to compile. diff --git a/MPI/fftw/build b/MPI/fftw/build index 74cdc91..7334359 100755 --- a/MPI/fftw/build +++ b/MPI/fftw/build @@ -1,6 +1,7 @@ #!/usr/bin/env modbuild +# Needs to be built with SSE2 and AVX2 support, but should run on architectures without this -pbuild::add_to_group 'Compiler' +pbuild::add_to_group 'MPI' pbuild::set_download_url "http://www.fftw.org/fftw-$V.tar.gz" pbuild::set_sha256sum "fftw-3.3.8.tar.gz:6113262f6e92c5bd474f2875fa1b01054c4ad5040f6b0da7c03c98821d9ae303" diff --git a/MPI/fftw/files/variants b/MPI/fftw/files/variants index 437bb3a..fa8f4ad 100644 --- a/MPI/fftw/files/variants +++ b/MPI/fftw/files/variants @@ -1,2 +1 @@ -fftw/3.3.8 unstable gcc/8.2.0 mpich/3.2.1 openmpi/3.1.3 -fftw/3.3.8 unstable gcc/7.3.0 mpich/3.2.1 openmpi/3.1.3 +fftw/3.3.8 unstable gcc/{7.3.0,8.2.0} mpich/3.2.1 openmpi/3.1.3 diff --git a/MPI/fftw/modulefile b/MPI/fftw/modulefile index 26a1cda..c8cc91b 100644 --- a/MPI/fftw/modulefile +++ b/MPI/fftw/modulefile @@ -6,7 +6,10 @@ module-license "GPL; http://www.fftw.org/doc/License-and-Copyright.html" module-maintainer "Spencer Bliven " module-help " -FFTW is a C subroutine library for computing the discrete Fourier transform (DFT) in one or more dimensions, of arbitrary input size, and of both real and complex data (as well as of even/odd data, i.e. the discrete cosine/sine transforms or DCT/DST). +FFTW is a C subroutine library for computing the discrete Fourier transform +(DFT) in one or more dimensions, of arbitrary input size, and of both real and +complex data (as well as of even/odd data, i.e. the discrete cosine/sine +transforms or DCT/DST). " From 6c3811a98f81694f9f8871d18ac33a0db2875a15 Mon Sep 17 00:00:00 2001 From: Caubet Serrabou Marc Date: Tue, 16 Apr 2019 10:52:45 +0200 Subject: [PATCH 09/11] Added IOR --- System/ior/3.2.0/variants | 1 + System/ior/build | 24 ++++++++++++++++++++++++ System/ior/modulefile | 10 ++++++++++ 3 files changed, 35 insertions(+) create mode 100644 System/ior/3.2.0/variants create mode 100755 System/ior/build create mode 100644 System/ior/modulefile diff --git a/System/ior/3.2.0/variants b/System/ior/3.2.0/variants new file mode 100644 index 0000000..58ca82c --- /dev/null +++ b/System/ior/3.2.0/variants @@ -0,0 +1 @@ +ior/3.2.0_merlin unstable gcc/8.3.0 openmpi/3.1.3 diff --git a/System/ior/build b/System/ior/build new file mode 100755 index 0000000..102f361 --- /dev/null +++ b/System/ior/build @@ -0,0 +1,24 @@ +#!/usr/bin/env modbuild + +# pbuild::set_download_url "https://github.com/hpc/ior/releases/download/${V_PKG}/$P-${V_PKG}.tar.gz" +# pbuild::set_download_url "https://github.com/hpc/ior/archive/${V_PKG}.zip" +pbuild::set_download_url "https://github.com/hpc/ior/archive/${V_PKG}.tar.gz" + +pbuild::add_to_group 'Tools' + +pbuild::install_docfiles AUTHORS COPYING NEWS README.md README_S3 + +cd ${SRC_DIR} + +# pbuild::compile_in_sourcetree +pbuild::pre_configure() { + pbuild::add_configure_args "LIBS=/usr/lpp/mmfs/lib/libgpfs.so" + ./bootstrap" +} +pbuild::configure() { + ./configure LIBS=/usr/lpp/mmfs/lib/libgpfs.so" +} + +pbuild::compile + +pbuild::install diff --git a/System/ior/modulefile b/System/ior/modulefile new file mode 100644 index 0000000..5326213 --- /dev/null +++ b/System/ior/modulefile @@ -0,0 +1,10 @@ +#%Module1.0 + +module-whatis "HPC IO Benchmark Repository" +module-url "https://github.com/hpc/ior" +module-license "See COPYRIGHT" +module-maintainer "Marc Caubet " +module-help " +This repo now contains both IOR and mdtest. This should be +only for stress tests and usually by an administrator. +" From ab00a45e6650ff781c8ad35153a1a6944e8e9786 Mon Sep 17 00:00:00 2001 From: Caubet Serrabou Marc Date: Tue, 16 Apr 2019 11:03:11 +0200 Subject: [PATCH 10/11] Added IOR --- System/ior/build | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/System/ior/build b/System/ior/build index 102f361..8b7ce65 100755 --- a/System/ior/build +++ b/System/ior/build @@ -1,24 +1,19 @@ #!/usr/bin/env modbuild -# pbuild::set_download_url "https://github.com/hpc/ior/releases/download/${V_PKG}/$P-${V_PKG}.tar.gz" -# pbuild::set_download_url "https://github.com/hpc/ior/archive/${V_PKG}.zip" pbuild::set_download_url "https://github.com/hpc/ior/archive/${V_PKG}.tar.gz" -pbuild::add_to_group 'Tools' +pbuild::add_to_group 'System' -pbuild::install_docfiles AUTHORS COPYING NEWS README.md README_S3 +pbuild::install_docfiles AUTHORS NEWS README_S3 cd ${SRC_DIR} # pbuild::compile_in_sourcetree pbuild::pre_configure() { - pbuild::add_configure_args "LIBS=/usr/lpp/mmfs/lib/libgpfs.so" - ./bootstrap" + pbuild::add_configure_args "LIBS=/tmp/libgpfs.so" + cd ${SRC_DIR} + ./bootstrap } pbuild::configure() { - ./configure LIBS=/usr/lpp/mmfs/lib/libgpfs.so" + ./configure LIBS=/tmp/libgpfs.so } - -pbuild::compile - -pbuild::install From 8dfb2be152f9289179499e32c4b258c2499124e8 Mon Sep 17 00:00:00 2001 From: Caubet Serrabou Marc Date: Tue, 16 Apr 2019 14:45:46 +0200 Subject: [PATCH 11/11] 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 zcmeGF3tUuH_dkx0re&H%nnjjHhDDY&1EN@2c)`##C$TcE009+6n7EkQjnqmaitcuK ziqy)?itc7N%1XP_-K>l(^-NZhT`+r!-+HgT&di#_IcCrE`MkcL*Z=iDHSY6%@3q%n zd+qx^XPC<~MvrLUuAR@m_VAtJ1FHPoFzFJ}@Z6qq=kule(tI81-@|=}vTVmlOxv56 z?l$S{(C15FA>@IWoCi#N&I3m=Z-*a8D zg$I$`_k@q9@F&IV+ebB^`|s#8Q*kn!`&x**iu8P=;ug`ppSV)REs^`1But^Om}K0p zY!`lC2UjZiBckxj&Y|O_C--#a}GoEH4O?(D@=1cqtjxqn7rtWcjq2Q|}JV3%PCA?EY1o5Qr z5Wz=@ZopKz&y+aKHLug>XZqYFoE=Of**ge4L7yxk$0%LPz!P3UpL^+ZzlvK)ad#>_ zUD9Vu=oY*!s4Ng=G!=lyN<%s=yMIR19l;Ar*E=vB<%0N zfH|b+7}2$a!b2Q-my^t1lCDC+OGu`#+)r`HgH9oCy5cVuSp>5cznJcCS8?`jcj9{z z=%8fnxO%!7B;aHU_Y;|mTx1KtDSoV^a|;F#`JzNjPy*v9{U?OaQF_iJJWpXI?!z*y zlZtylBJZPcqTJU|I7;pj97CT(`rM_`Z9s(M8l~cA(*5xgf0aWnk>buJE|0=HBuzj< zi1wEIzZ~hx2oFM%z@nUZ@~xbYM=(C1`|TS(y!`V17g zjdYKzP;g%g+spkb6UF}?DjdKw!oMORf}Rxru#%~x`x*2}qPUmnbD)Zwpze_t*9r95 zm+xZ#sU$dGs9H)FlC;-Sc#iM~yXccB4i-`T)%5A5NxC1b@VO2heJF0O#LuF*KJ>X! zWbPq;l9F$y?tfD{k5K&CinnjCq??mO=2W`>N+KrP0up}gz#3jl;1rb);)?0hj2pRz zP?l;>lPD4{@v4&{zr;Qi^TeT7pVIpb$>YBPg3|b zx_=gHC5PML4h*=za2M>N9DBILok8i&Q2hStUR1UT3LVVplxDQzZkGFlBrKrt z5fyLW{>#3Ru-t*abzs0_=@WGDSUX^S7e^n|>yWgy{SQcpJ8F&ZkUhs_v_GKRlkGd+ zJ-qkAg!E3GZ=CAHFIeGEn%Ap+|89L3C!{Z| zol?26-8|nuoh#$c^BwyB`6(Od)aGm z6YKLGNgUSeSj*YhQR?32j#gZfy0_!)@EAuN*3R~IEZrX`xF3bb)5mSC<0l^b1?=N+ zVI78j_W;56IvsI(j2I;GI8W1;y`BVz_5NV`*z3bnm8?BiL2iiR_1e(hpA4t?3?+j! zxa>It_ounUgSW3tipQP`eHE8pQ|P^o9-FZr)K?ba@xozl#k@K}u$DuAw9n}5bvo7* z&da%0(q~1v4*AK1^XQXLp8|=SBH>gCr%_la_jX>GXYC97NLE_G*0tv6A@GAOTEqI}X zkkwZe@z>C&TH>#zu!cU@(dT;MZlDl*sG9^M{mpcL3w>@CPS3fw6L*L3cS@-9yqmat zgs)Ta_tO0m`Ycu4eRO}n;0GyOuHv*#eZPWa9(Iv?gt+>oy%(lFGx4+T{><}kD!lvk z1q)}?_SrA^@@E%LI5el?{ypFM^`>cESDj#edH1uMFIrOa*hAG_C-IlbG6VHqEP|L&5v?mYU@6F&Uz!)^N(-ZE@ayB{{J?()>yE6$s7+)*_-W$CBC z_uYtbosQc3wETvC$GrdIM}wdHVUO(F-k$$+!($7pj{oVjUcYR9r*Qb`Cq6qhzp~@z z`Io%&*veba|GD=jQ&_dgNI>554-=v0KLWy0zUsKb`VNmxUcdH|*VG;%i^r zJo<`{N;<#aV@6Ww^D92vf6hC14u0(7-dmm@Qq^a|hBqp%8a|L#3$=l*{^ck**r zO-*m#rLb%2E0<2o*gE0z^yCZUNBuR(x8U+)H;n#l=i=rYCoEiW`PDx^d*iuF?l`k~ zug8B~a>4nRJ@D^2UH9)g^3IlT4_R=-vTHUqTz_f#whtejGPU}Y?)QCt*6p9wz5QDF z+e@4O-1hAWwd)_b_aJMZx^+{#ef;dGcmH_cjIYO^diUm218+@zwB2EAJ~(7m`*wXM zzPs+?4ht^7@2=Bsyk_MQMI9bo_Tin^F1WnQLreUVuKV}ul2i8T^LdYiRTt-FR_%G& zTX#K>GBd8~q{r5rdEbO~FWDqkkup4&1 zb?Reldc|L|{k7NLTzlHp51rfTtwAf_dH?JsKQAxcT>Z-WDc3GI_V(l(2W&{>6cjtT4V%5!_3yH*9%y}K)q5q8xcRfA&y6gFq4vyUPU+arpR19p`S(GHO3=<>EE3OTNc? z^rP#$y6c(hk?&q7yUTw`dAiy2deEK68NXY7{p8WVb{yfZ=Sq+Ekl=ThKa)0%Zg#%r z;r|;v`fr$&xaoP{V_dq(qaXE5boWD&N4*3_xyv6%n?yH%cJi>Z)nk0!M@a z^}poNPLhsym%qZJ9v6F*YyFw-_H6U;XPt*1&hlvgCl7Vk|2rM1x%r{cquqAx=`Q~; zmDjCaQt6<;P5-qX_4SO0ANqQXW8cxZ>Xz^A9(Fc+jKh?ztDa=-#xgW zyC1&yX#YVfl$+n)_Nezq4{(>C;CJWC=+Mti|D_(|?JXYl81FHT?d>sMP4sAopL^7A zUC`amCH>v&>j#f=g*^JvMRZW-=7+H!w%8r-1U6qF+SYsk?$`av9_{ud5Bp0!`W?=J-SWNJLmua@w1jAL4fGgSfAFZ^Q6B!ej2=$7*>i-4`~x%| zQkQIVz2wmziapwSKaYOB!lV7K^=SWHJ;tl2_i}H~e|W6Zj`vuf1gKnY{z>%k+wxP~ z^NshYmwvQ9cN=e~c#LmbJ?5h_S|GaF`6iKW`akiQe=qf@m+NSpbgTD;9(ERajKf_# z_*#!~2Jim3m1|Fr{uuJ`^V4J9{cxd&KQHrW&jW|J+jCTkJKvJ*&Y$9U=YOJp?N;7u zk9K%J`N6GzGpW38dWt;e@v}VaZ#U3g{}CSJ=N=yIYJZRMsuT57H#>)Tw37qQbeBJa zl(^|B^_X`aA>PezojukehaBLpe<_UvZhF##?(&((Bc zJ;vcFH14_Ce}%_>Y8};=oBppn?0Mx7cRN>k$QOCoxsoz+kKgWBF z&j+=0_s>EaC*Az^%AW3a&hS{D|3d2uH$4w|^wVEG=DQ+~ebyNs>)!W0+S?3|asFTr zKi}X{UjqW}e)zhxJKx2_{@EV=uEAqoKHB5l<1~+c{lFPM-x0p?jUo z`7XZ3E*+SupnifYp6k7fFK2K^#y$4t!1p%2sMpQc#n*65dnVeOWWL*Y9n!@Y+;0!& zPcY)X$=p6k|H(#B)c7`xgMWT%jbCN#5piE(52HU052)$d-pRy#eX8M`4l#OC4>tT| zVo!aaSbJ6;E%Lt^{zen{1|K2%Pcg(@EysQ;o|O+T1??Q)GKKZDOnHRZDHucY-G z`{7{2zen|o%TMJx!q?T;X_@gGH7C9bdEe2+7nf_~zZL#d4?pA_YxLK3HS!xp9@!z^ z5Ds$bl49|g(apDyFEiKVYmXuQY5akF~s`{7DT z1wFN2nDk3c;Ok2cVLogKTJG}o6x9#-xHpYI52bkm*ZGOI9;5#}L;H$FzVcBcUnPo; zBM3d|QeNBs{b(=&ANtcM_*^1FhZ^4ZTWmc(Debv(gz=B9CrRX+e~OjgQ`$ptQ!Ia( zv_t=arXAYvBy1*yy~&=0Y@^@&OYf44KPwN8^=EG>Z-P9;K9|}(uD;U#6Xb=CO{Us> z2TDDLq#o^d_;YVl-ln^a{vOmHa6LBM@O5VzJ9}SZ_%ay>(q$Z|G_yC&m*L8_TzWEEo_ZEj9OJ+W>5r8M89TE~;JbH-k#CZD$9{L^N?zxa z-{MSp2aBCMDP(_U7(Ptx64z(6J^|lwwBf0``6`nBSmzj5Uy$}tC+*=qYJa#cB7M-) zB>f`U(7yO#hEE@E3|}GTJzD(W7eCnJm?>jNpZ|kT&p+D$opHEXq0ADZp_LO}4 zQGIf`HW@v5hY8n5wEhHN`J2I;#GVt$Jn*#+{Y43eZwkcPv!2#Pkk2{D_>G2Nz8XYN zoueLer~#wjHLW;`VaaXyf|i$C%?%! z)-2-~EqnOdEbZJMZ#taa&NHao(BJ4NZ@K8H7d?GN&(xERe7bbFKaIJ*MMDiAI)w^O z*Xz=+cSt*IkaqZ@`2P%Q7|6F?{MKIdwDvN5&i;n5$AL2?-%!x_`8{d38^oWL4;g

i2o-$jCS3XeU=oJFk~^{+hJs17y7Q$#^?c^mk7)dg6{V_JoAr zB<-!vGWLHW&>!luZzPmwqu*|akCOoVQ{<(( zd@FkyK4%{zzteOBUz+fKY2f{&-M)2%k*`19$oJ@K47&Fi!#DU$L3@e)_Y4yGeujTQ z+UJU4hHoBaGF&7DNIuf=z88)Dx5*A%UrE1cl9y1I8+E?Zju!c!jQkuE_%2H~d_tA$s(dFn|@hx&@!Y4q6j_>5olA7Jb`PV8AL<6e_x6x;1# z8ST@dr?HQb|5ofgtdrsWGM?D-KaDng{W#OHZ2q|;MbGCZ!}G-cfwbP>b|veRy@fxD z#tHELFJtZhZk*Xy);@ofNSfe+QDzTpD)MK!F zY(2h8*}LN2C@}-F%1aB2 zr&0#N)AL*+0)c`HD{_m@C>ch!WQ;pK%b%T(pd$iG*?9j`M>}f zM9V_Cc?B3c+RhklWn@l>4BYle+%~NpW2cCnKLY)y78GZdPYsro6!AzN4CY}X^3z0= zT^6DVtb9s#-n1Dm?iw_?qOd6c%!-oo+>ymJ74uvYF~~V#pv(ix%d(3~rWVqCNEyr} z#;eu~%W@|d6^ty-FU;e~sLV{#4%^f6-R0c14lF2kDjgRwH#s$$*=`K0|C74^Kg*w8 z+~4nk=N469eCER1%iT6c+e=@Mf7A$&q~Rr|0lOm zVE2eXAU8kX)+Tj?QbwpYDeV|%p(2@jM%c!3gNwLWXCO-~YJYagGyc{`E@@)g)F3L2 zSHZmUCeExBet8hiPnwXL}H(sHv_Y1_LSVh zB64Z6pJv_2Fkw$}!DwIAN-~tgr|bG~mWKDSb}QycyEW{pnqpE#_pD6E_AR?oQuB&R zie*5I$<7wY&7!s{o^@9dNTz+dqh&{WiDwxD0U8ACGG(;&g&pOczb%2$g!{4?L+nyS zT9~VbNNiepiP_sbMj-KCfNHmVn5)D*9y9&^@Zf40W z96RvdI@T8vJE_`v%i~@L1K~{U{vF)31W?&lZWT^$|G zPNE#0Jitt!INm@@@|ZhgT78DeF*&)oq?~q6V+zWrmE;dAnHi#81MMeqC^GSk*y7th zL-C_Uipbc84WejWg?1B>I#zZ&^xK^vFaZ9Q3K~{YQCw~u9lM529%u?ZqKt-vGfMIc zD41fa$Ouwliz;w}HL`e0NifiVL}5`u*&HHfLQc1vP?4z%duVo4g>DmbbUGao)1#t8 zA0WMktGTzW3F?G`^%U|RObvDqU=j?VB+p%U|B3%dr?Kohe@%!t;QjFOK0 zrQb{b!wd4vyi$;F&Q0Y2$IXT|V@Q9$X_KPs?84G=dXDjTMQNkP9vqO6ROwky&2y$D zw`uHYCOb34+0N0;Grw*7vHKDh7}9w#qGUw+g=0R*aLhMaJ-2?RJhF@|Bpi{BHDhe; zXv<&{Ew77d1^Ks@#cBzpn0gsfR#uYt&r{1vgj3U&Y|PZsf0}X3{BzQ~v`U;&0e8 z2Ft^O{C`-QfYLCcw4mUOvVW>U`vZ&5A$jyXuo&j{~&rqNx7k2zwiRJVKN zkK^&b%iU#gO_2eKn=UU!cK1};b*!|{@mSqiWd)`Gm9`XF1F<%Y@6<{DD}~8&gv$kG zt@aG^58IDj`zYdnrAPG!)>BA_cKH#<{X?tl%0$12YKzwDKUF90k5#AZ;U6lrcWkZ- z|Di73gSo6(!GEej4T_m1v@y&d@lU6XWP3X25jE15oO@5d8FA6y_3#~Ckl4G1HcOGL z@??K@cKNi@l8drSD$27 zaGdv-lU;@iTfJVbI2N8k*R_Rx)?t^@@lJ;`TDIS@WwU!OTAyPN6SKE>A5&v>*#*I{ z8TC`_c|n?qblnHadX!BmD359wC`@eiYuEDujD0}dW=oBE-i}P6q0a1ZEXXaTh4~aZ4=eUfp##dYg0^|3Bp4hskB zRBE;BnP31XpeB|_XLO}=Z0APh?FFl6feL4vBRz*DDXf@hkKG)w`BAe&OMlkVcKRsu z9(&-+$ja8!YPCIbWN8dynunUKd%%6>e@xTC^!0wK_eK6)_D^Fvc zE!R`f9QC=rnKdwv7VEjCI5?mkqvOcUQ=$8=IK^+bni*OAmViC^(K#l!9FMhh>~Iz9 zvgB0OiN&EF@S+VdR$Q527I#h)xHrb82@KG+f=bwBwKx*<8FX}qZdd9c84m28!}S^| z|1Jg-Q(otBQ?$I1Hr)1D&w1eMu++Tmz@5gns*ENM$4=Fyy9LYur{}ZXOPCxmm50e9 zIzoGbZo-yb2;Z>t)8Kz zfv6)9yw1{Q<{4yOyg>13qQcRKU9++M&2DcFOFaAc0P}Fhbp-EE4|FBN@g?rrIX1-9 zo#^$;7@xS5#k3W@7>G9dHkH=DB9u={bbEE+SpT@R;bb#qI1cP2hw^E5?Mu^R^BfH& z884ic7L-jB9peh}3h5Dm$;%-d7-;N^WH+V6)kJ49w0Q3{E>0U*Hm#(hD1V%>3_Y}L z2+c4!+r|q6q^_J^Jt&!ypUaO-93w(XOls+0F|D4~Xw*51D?*r~?6+KJ`9ic5F38Q# zF1@ITI%al$0UcqMm>e8M>W|k?M6*83b)P{3sq`9jd2C*2^-iUb$_ONnnK~0)vb-dZ z7XGFpbRN{ff&<26l$I8kI4y>Pw(g|&nP<_l)p#yk20ePChLHirE;=VkiJ?+TD~hFj zu@QF3ZC{x;u$^5v;ODY%CK!xkhd`J7`m=l+Nt8Z7b5XHbOhg{Yr?Ro;DPkbjz~n%w zyj;#Q!*Yv?Ceu^?jKbiE!l0c_9#1-!ynz7`tJ^jTbA;E{yU8@q;?aqklI`JxUNw#k zq_G19PAS{IyA94BMtO9x2RP*FvNVl-ARK-C7oAKoI@u@dn9_N^j#;`#_G>(DlL5#p zq978RLW%K`xa*5S5pl-|If&l8FD}P%x><+CsJ06_ps?%=+9jICW*1Tlo|-WxIR0F> zM;I=awAtS7j?3ITYzn;v;Z>(Y=Zq_feIgZ^Z=BOXyl^gM3M3-Y`$#CCz zr1%Sp={pbf#ef36+{WYcvaC79dHTUwM74{VXnD#1=pDi20j@d!^ITKx-tzbFNG7LD zRcB8nrT@5?uDvd{HVm>GXGYf0?A?01-)^`OC%5S+8G5_oR^N_BlA$(jyP@5^eFO%@ zdh8!n&wt^qU3`%wQgp{)!RzAaO9PnacW=~-oH1ZZjh*KE)5@k`*tFczG4xhW=^R=| z`@lePtYmTuJ-sZ=#dl~*b7%626_%Z2cX8^6ccoLZJ@>S+uRvt%R_#YipRpUYuchtU zk9BTTLcLQ%Ynr^7p_rkVYa%MF-@$@($Yqh0;-5v|WWr*V7G~I!hRVnCH$`%b*oF9N z6)nq+dt!Z^5@?fj41Likm-aSuV$%k*%s0cz29_3titsk<%$cOu<=a*Pn)G?QBReX4 zbs{UdiefD2+EzQiLv>DRVR?ajx{FFZ(xu3vIl87QD=H{puR0ey+^&b`QUj#d`N?0@ zu4(;+(V8aa$am9XUBvIxjiaTgyIH0A9%eauJCBdMI|cj~z5Rb;;`m3l{s+@lvio$k zyWZg(|G`uhNTmgno|1PrBll|f`|Ry0!anbIjIQnr-r>oyqig{4o_SZ#Zk$e$WV7Lo zti+`aw-HMwO=?N(r7nPXg6$Q6Lx^AfPwwx0^?$gZji&FC>?*G9_u8WA+I;I$q8yWg zo#5=)&Pl__`0;J1$YPTh`ny>Y^A%V3l0@QMN)m}{TM`rHEQzpoBZ;wbn6nYMRf$t5 z*`t2j$hkKcr2fd+`oNW@utT*H| z#_>uRpT@MY#5LdKfH`1syg}wTWO18RC2O2usWVA+)D&YV&q-n?23}einVnylgw$zwi?byh+kv5fXelibk*jRpb(#}BH>o_v7kDgE?S;NQSL7e*; zRkGi>5X#L9xhxy|)NGf|mv=rq4&ita;V>?xO`fbHSVCXYbIHB!IwaXV|B5-pR=$X- zJ8A3s*xFOnoDL2tD$+9%OS{xciaOSA^Fpgv7BtVrY{_E2T^-pBx$HRI=Q(EWjj`8O zY!{o0*ujFAQFhzX6Yy?-oBr>*xYYXoGz z>7qOW63+Q9MOy)85v$;l~bws zuR-v8404ZMUaVoU#ZHbc2krLJW&yg}jbyhD2x9XOq(zpacK$IvXSehIuNtVsrh#~1 zIJ&TS2ED6d9=&8lo;5|bV)nBedmolnrWmS3*TqaAxv+Q^y&G(nmj6*tbPNUt>H!8D z?&$74gU;S~(LB)PNry`nMdg2g#PomJ(yX%n^fyjI^v+IJcEQXL{TUJ37Sngw_-%9U z+xGk$@ryZy(r%%y7(3wDGr41!IU}n~AFM>ir(LL42Ufcy?tW$wwbgu22j?;LbqGG| zb6Cz>oT$7$wxG30#DvIV#GGN9w;dfbcwhiM{>zwMkXM0$Y;w4V^?}+Fbm&+ zh#8(@o0=Ki>`9A;v`B^-v0osKO=h1w??#>3qFH5wvd3i4tl(pWnKNhN75gH3t!5^V z#rV4bd|G4wS%BTpZ1>&BS9sc-UdW5NvarmspFPuf;OD#Msi|g{2&Y+Gvxuzex*AqLO9P3PWv@N6YP0 zLeEy&fQXVI!$!L$FZ8IzKtMY~wKrIt%CA^OJQ=$%mZpl8am;(X89|ebdNg!ol~IqS zn&Gp>*eTF{50G89D;=@P>@Q#agB0f7lh_2&^$kXf=z7s?bnI5^7=WY4w*35$%4J@N za#jmQN6wBOgqovS;}r4;P1$YE5dx{X__6}MFf5N*{wF5wtU=jk-nIwJtYN$Nbj9KB z|4X*HIxi4)-hZ~NbF6mU9QSuCzkjex`oC;#_LP{vbu)fsY+FF{9TrQ`-wLt&itFhj zhGS~;o40N~UMZYSRcZEeu;k$0c+@NR37uc&bH%$d2x^c1)3__7kf{35zJ zJ{h<2JP_CqoL4$0R1OpXqT`LcV~+(K05~&pmuK#>3+U-&F0HR8lLhph*iw4QioW;` zS^XT3gng%t9yxSacJlGb$EQZ_`$z6lj_>aqHete$p(C>c$EO&2!h~$lkxTv*sNh{8 z^G8WzCG6jjFnn?=HWmucQ3+;Hb3Mo%u7u&}09_R)j_`a?nYA5#HUmI0fmM1 z7pwR3?Mw0a4HhHcf#reA4@UYueDRU=?R`&5dW!aa_~;C3T6_8uC4KoZH_~6uZSOll zoG(lma`4Ua_l9d9J&FZv`A+ulHrSy_?z8!|q6dEsd7}J{WQZ(UX7o7u zPVze$PQKEEZ&dncDE;dcKSuFQiqBNMrT8-x->mp+6~9CA^3wpOeGO1_igvlJhv zc>HFTeZ?z&y5bWQ|FGhd6mS0)2Xy%rKTgS~DSm&&rz`#u#b+x10>uXvFMr~mi!ed) z1C)G@;&T)~P4P*JuT%VJ#V=F*K*cvG{&vN$RlNLk2;14H_(PQZI>nDre4J{BHz__| z@nwqlD}IsU(-eQJ;?oshsrXFApR4$w;+H6Xq2jwMzE<(e6~9dJ0mU~czLa?SbMAa~ zlHdD*sOIAwJPmhz#XIO|{0_xmsN{XBT;MB3ewyMJ3x{Bb{Qd-q`ZOO>^4}`?*^2*7@s*0V z%Y^8K9(=6_zsQ5H^Wc|x@bw=2N)J9xeqRKB(DuiB@ChD#k_SJ{gAaM|jUN0u55CER zw>K%cqxjntzfAFYijP<2is6-=ny*)S=qFqv*Gk1-6k%!2ru09g_$0+QD1Msa zOBKJ;gHKX+YWa|oFIReIE1rHTA#yb+erSaC`PM3ay5jBMNkYGSoj!3AXDRuvh?FZ$ zjnDMcTahbW@d**u=gU-liqaEQ{1C-YQ2Yp`Cr9zL%#B>r6rUSmeZG+5D-=Il@fRz; zQt`c&Jqs0onc^2Iex%~-6kn_KFH`*8imz9Es?xJk@y{#y2E`w$Rtb&qKv`iucu<{*L{u-cxo`y!_-1r;1ZN_New1uXw$0O;Ei3n>I+3q5A_ak*4;qc=}1M$Q4xlNlMQI#b2-Z9K|0I(c<$>Q+#j5hZKLL;%6&9QSp_E z&sF&@RQzd*uT}g^#V=BPAEm!e@%JnFWs1K?@%4(ApO#~7D-~~AjLD=y@$?f+k!!8u zlOn9o*Qoeo6u(aKHOihQ#YcV6b?z$Yj^8H8L(ichgg3jK=julO{@rz$>O@$?gRktia$&7If_49@zWH4 zj^aa#pP=~Jia%HJm5QIJ_=Sp}r1)CJpQrdmia%fRb&Bty>UWvqFHrLJiqBU3O2y|W zzCrPm6~9*T`HF8;e1YQEDgJn6XOrTmD0xfqot1pE;-@P49g3f(c;A!J_Ft&@PMTNx z;}kzb$;T_cNbw1ZpQ-pH#TP5yulN$hrz!p-Wly@|LrOkV@kcB9pyDr7@)Hz)iIUGz ze7xePDgI`~hZKLR;%6(qOyygtc=<_pj$NpDz0a*x{4Awsk>Vdz`PM0Zwvu0__&JKN zSNvSXuT;GJG%&|DD87@*cdg9-WWm*Sfhf4S1LL-Cc0 z_dOMD|5qr!li~}M{y4?YQ}XeOKUv8qD1N?@Pg49+CGS`K0wtfO_$w8kuK24IpQ-r1 zN`FxCmn(jP;;&YEaui>s_-Ts2M)4uVS1W$D;;&VFrQ#ZW{3ON4DgJh)KVI>7C_X{)cPc(f@k5nX;uk6YOy!?C#V=R#%M^dHlCM|%D8;W-e6ivi6u(00U#s}rlzgM&?^XOd#Xqd{ zG%3DH$yhOe{w^h7r}$Tu{4&MArucfruTlI;#jjBM8x+4*$*)!X8;WmK ze1+1pPVsXT-=z3Al^#p+Zz;Z6@oy`BhvMH+yl-W+{lBaDPKtj|@o|c8RD8VR-&cHs z;s>j8B`N+`#rqZifzp$v_zxAIuK2r^o=nAmq~wE&uT}CB6#uc3&r$p*il3(VPZb|h z{5r+YR{Up*uT=bc#V=I+=ZddY{07A@Qv6qnuT%WjieIMq17^Ne^B!2ivLmZnTp@0_@LtRmHr8eZ&va- zivLOR(-gm5@gc?ktoYfAKT+jdsrY2YFI4<5N>8og7c2QiihoG)b&CI0=~<@u8Z<0ZNah_Wx+(Uu&P6>EHbhPp3OzK2Zuc zwbIq+8errQZe%?4#4ZJU~k8w}n{eYYQBBD<> z;5gtW#+`xp2X18C9=IED1LK`r2zLjrXS^Mld`#tM{2g!);9ABTfe!?(WV{~uAm9+= z4}jx=a~Qt~d@yj3@hiYRfzuhU0zL%T&-iiRLxB?*F9+@g9LIPu@L|9{#&-Z84&3}F z%6}tp0&o-KYk-dcZe%}(W4{$Bx$-o$-!*o-Z{XvBeT;hop8(wa zZ?1n}KX4P{&cFfSM#k-dlYtu;@7zo{1-PE^cHsWNb&S6QP6e)Iyb*W+a3$mQzypCp zj6VQQ1I}UmCh#EOAmdknPXtb9ybAavU_ax>flmfbV7wf7FmN2>#lWWk`xxH=d@6AB zA6);y>A+2luK^wc+{kzy@KE3e#&dy(0oOAw1s)Du$9Ot$25>Fo$-pCkD;ZA&J`Fg; zcpPvha1P^9z$1Z!jE4e`0#0XqBJk7~_A`DQ_&neQ#>;`v2aaRB82AEUALBcKvw@p` z=lTcE0d8V^4R9`SBjb6%lYtu;&jro{u4h~doDW>bcsg(aa4qA>z*B%L8BYYB3LIiQ z4j2%`b<-m1}zXPrSu4TLtcouLa#*YJE0-V5jIq;>xaf}xOUk2=Bd5NYVt_JoqP6oafIDv6r;2PjK#=U{B1NJfQ34A?p^KV@L zz_q|lj5`D00Nlv9J@Add4UBhwL-;1(ddAyKL8wJ zJPvpna1P^9zz+fk84m?s4xG;TMBs;j{fv`=R{$q4?hE`da2(^_z>fg?821Ez6u9{p zu7BWq;3meMfgb~IWZWM3ao`5VJ2w)30=S;>cHk$0>ll9r{1k94acEnq+6WZ<`f6Bzdeeg`;?ac|&vfqjg70>1~` zyq)VGxDmLCacAK7fg2gO2mS!Kf$`3-34aJ&&v-lVN5FNAzXSdlxR&uo;7@=n8LtQa z6gb5A1K@SQIgH-~{tP(C_!Z#w!0C)v0e=qcXZ$$u7r+UOmjizZ9LIPu@CINX<2!)A z0&f0^>mRrYxQX#Kz+VG5GM)##5x9ZzT;Okj>lv2M7&ypyDDZc{>5NYV-U{qzoDBRua027Lz&`-TG42igBe0KgPvC99 z&COi@z|Fu-j5`DW1l-8DJ@9tm2F5#^2>%RR&v-lVFTiz-zXSdixR&uo;NO5N8LtO! z0S+<#0C)#*4&yh0e+LdSeg$|Za602vz<&Vy89xsEZ{P&R%Ypv{j$^zS_%C1|<2!&` zft$B+{R88OKHS9k8elw13^y{K2izXGf$?16J%H;OmjZVHu46nMxFc{aAe_T^6flm?!a>GEf$@q=IGyo{z+Hg-jFW-!%5gY>abIA3H6k3x zxHs^=z&^%3f%gM${*mh+7_Wwhn;3Tn-XFM;aeLryzzvLdenl8x;S1L@-VThTop2rF z?||{DQn;4!M&JX1D;ci`J_tC(_yb_Pni9@o{3h_hz(K~Z0OQrXa602vz=r_)89xqu zC~yMf<-m9qE*!^rF)+Sj8TK*00~klK;pQK>{(%#Kn;2gMjH9P;Bjb6%y@4AT&jmgb zxSnw-Fph%5b&RJ2ns6NB#lZOLN!Z8u4q&|66mH(i z^$(m5+(ekh1-@{8m|5NN;Sc-xGOuhXZ{OO;$A`7{bynrz5GC|wR&5$GKC5DK=KR4c zN!C}sPiFPt(v>N6hEZ(fLBShC*4wf>895^?n$@pCJj07jnz~3JA47#cNS$hm2|>@ z^4?@=7qRrf%$mVtDPm;R>Nke8eq+nOvD&uWge3Lymy`jHNmo+8pbQU&hU&o^KcJu{ zbqUA5+9|w>M$IX;nN{Z{TA5WviOm%E(t-}Y(N+10J1BWlX4M~=Ra>n2w7AZ!+MHSS zmDP#X8C9!6o}d9TVEMj^(qvfN)324sU1ieFtx?{La0QdbO|%( zui3G+^OWQ5^8dVg3a$v=jriujN&jEPujzOjpGDI%%?N$n!(+OwXUS29jdz#MzHmBBiM?Htw~KXf02wwsZC2eQ~NQSz6gLXQ}s)_I(BJ%m1|O$7-pjS5v6p%x=_ z6NH{NLRUwH@{Q0YBQy&_HyEMmQK3_f(0U_uE`*AV(3q%DPb2iY5jq({rx_uCROnao zCt3NZ5jq?~y^T=!s8FL3y4wh~htQwgiBo@D&klv39x_7L8KF%SVXZSlpGAePGD5SA z&{_yRVT7KK3gsH1TqE=lgsw9}_e6zGHbOxobRC2WjnKTP&_PBh-3VO>q2WfTAS$$- zMn7^vvJn~&p~H<(W>n}MBXpP%8VI4C)Uznvu~DIAMrbc1)DuD<8=-xpLi3H#PgihL z`SUXpsy9ME(LFU|IP(G{w8029L8#gYeH0ZMWQ5)|LaQM(#RxqU6*|BOy=a8)htLos zbVpQZ8x8POlqZZ(6@(5oLYGE`-ZVl>j8GATT4>`y>2jh%_Zgv6mU8LFLg)h{G%PAq zX@ts*rep{`Y=n-A3QaOX(~M9L2rV>1dq;%^7@XW)4e!zeA-v~{G&~hU*DJnF<2<>HrMnULGBXmksD8&f1R5g)fzVGh5mI(vk-dQ z2t6DXnrnozj7@hz=m8^C8x=as2%T+&E{D)OBUBa@@*ANkCcDWHI^PJL9Tn zV^ruOBh=mqy$_+KM(DMu&^RNs<8rRMCn0pX5n2`%>Su(0G(xvQXrd9SjtX@$LR*Z` zTnMEaq2j2}H(S^R!V(@p=V(CtQOoDn(_La!U4 zgQ7y^Mre!?+7m+e8ljyZN1Qp<2nCH$m?Er8jL?@+p}s~a%Lu&

vE-LsY1v5xT$# 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≶cc>o{Gh4&qllW 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˜!wgr0L{sk{elv$_wQxcFYbu6WF31m;1=P#lKNWaq0E}1Mvqd z-t>gqdGJH;)OBt9G-y6*kf!e(SD%3g=FB?Q;oKRVO@C~a9;_@u#cSo+2H(f#$FBay zQ-*7d@J&YeLL)rfXr+ zg_I5@{(>O>#WC~z-=B}P8LuB|;%Si2#L=9u=$oX5b!aJ{G~YmlG-sgn)_)z4X`5)C zZ!|A8nv|E8Iorte(-Ob0N^-Xa$!$}vU9Z`vL4Iify3-QIYh3$F4D5Y?QTwkc7ftde z>JKr3?p^-b)$eqDD!bG<8QG%^gNIMN8F$t6bcJQAGpWk98WLqb0l zw8-v;ZWp5K8$^e|99P8WNJ%vCH{Vj+26<1r;rxr%TjV`0TV*jyZ*zTst8Fs$)kf|{ zBRAB@U1sEl8o5CvH)*@cZMIa`!N~ofCEkblhSK8qf3(E!|Dg2Jw~?H$bA11oXjaw5 zl|&kMqp|TzKOAvrk7mm^@s3zBbHzeKKH88M81fN@ynx6bNP8Bm0eUrSQ^%j|-Wve`g()(sj zKqcEmj`^PC&Np(sja)yX@5YY^_%qL#rMEOwW(-fZt|^MDMUu5_l_a7%KFH}-P{no5 zd{3^H)Hx-*sHiX>&^q$JmaXy>O0RBpfXl5YA&&YILwzN?_6;royr4&(U|_wK5`O>8 zI5`Wv~vBsXrm$ua+t+=eflbZZqoe*a4A_`bN7SpTB*Qns7i zI3qW~$X#pXZZ>k)8oA3!?y;5Irc6K2v`D(4OC!3og6P_Kl!xp`CH(lgQ^G3khW#I{ zx5z3jvHy?K+a-u*D?Ys?6T3DqHL#!Ir35Rx1S?PBW4A%4KZnlzq&6C&2Lct2@vt#{ zgfSf^vm*jP@wCMVZ&*%CptBZvf~r`z2E8Zh(%FQ8#@rRNPYrLMAGl2p9tXuZ5n`zX z7_(fAp4@JU*T^3qK;dNtD(rm;dK2&IDp8Z1rFEPy)v{GiLFwI!FX{#f>_-A^)^NL+ zNV^mKPQ5~6fJed?L}rMrfZB#!4+S9ZD~&KeH=K6V$+Sk%H_6vp$M4H&iSz#`y-o?_;#@yzXkIWhQw+^CLo>zDOeC76A8aqzSw^mx zkvqi59cknaF>?En+~5E?Z$zNNAoj<{lpE)(QF_NG?2GwRo>uvUw>xX!xX>>n(NK4@ z6bF9)2GknyDu>MsVo|;EE5D5t%Z%c9E%EyYME&af0hMfJF`jMYB1SGlg~a!u3}FTl zof%v?{m;d?FCe~mqDb&Q^hZt~Uu)SaYfyTrLGJ$NB5^7b7}Zj#C~)4vP*)Jur2*gH z+AxW0xWAzq#IA#aqP59ThZimD=~5-joc_BH`2%rBe_T338-+Jr0ZnlQjOf7 zS~kg!TDHiaA5dz1UjwCg)OM451o?-`d|J^q$UT%IIhYu>GPEzVj#pd9LB{7$t+&V^ zE%ANi7N`28;}@%x`By^of)<@)cF%QkWmBbQ<1dKj4uE%AN{$z8JD(U>bJ8tP z^iA@%)>~zPmiT=!l-|!Z+bbROJ;_~Zjz>|J6Fy zzlQn&qW)+}0QEKnvuq<5F>)D3u7{D!Fmhc;?vm{$_Yo40`v2SJ|B4>xU$u_)ua>Pc z2c`G(;_a305+ipd(Vd;JQDasbj&&Oa0N+C|%|l>SC;kdf7ZE_-+v?6cL}YOrGZqGP#e?ZM%Bv|Pkteh0AjQ>2Y1kY9C*2&Ry*C4rIgbY$%t|xl3j?*Z@ zH>r-WN;4}5kmYk1#BpxhyU@!t6E#RJLMaK)23p{+eWaExGK^>*38MKM#xx7$2i6N-zhLFmzgFUU_VfLhi=DV{D@#rC z5$criZ7o}50ZQ+W`2k7)28(fWe!jon$em~8E@2(o&8Bt-DNW4(NOMAvCbVlK?{6Gz z+Mt=EK{hXPBCb>P$p5T^W*5@@5*5n33Z=LEcGJAWXx?o!DKEWfjL}RX&8v;(Wu*D& zTLIl}lboH6=AK5A@{(o;)*Ey-l zU$YK5hmhuLsL+RAMCmom-4;2A^RIj8fD-79uds{^Z^VJ=%dTsOui^ZPGt-yjDuPzY ztd5lZ87aFUT%QS=!@|vx;`I@ERRe#2oUTqCK*(s;aVRodalCq}yOoSveci2n{9Cu- zR#C6vuN;(=bmP82Tz)~gOQd{cI3uroShzw2fOdM0U@Uv6|dN13YT0vu3$0?NsamS)81M`V(=P3KWn zgUgq(+V*BW`pUKLT2B~X>aI1Z4|dm@3HrHf&ABJ*b!kAxA<|9TrYFZ~6v$oLWGovtmFEIWGto@|^%DG(V_T&9)wFOHqdCa;T(RC7qQd ztE90~ZFo{xskBORUU_(7AB?}d&_JicDa{`EC4`*frgpLp28oo90u?>G*+8G+eR=Us zcO!$VY!XpL{Y4+bMdJF{aqMm zKQ-6@yqcF;jn5zAJ3UAH@#ZfbqW#;M(IY)2bmzW&pRY_JW$#DI_gIK;KvGz|-;H5V zys@=x(WqOU9_N8)UUgxBxRzQ&Wi%9UHo_=1_^<(_6W|O5$YabI7*01UrpW^uT1SP` z*g0Q%yyeiO$qyXBXiJxYAgpxcbX?{1{2?@{CxS&TzSl+Hi7~hyrU!$ek~_e$<7KI? zU&u=cywK?NyvGkG;ye%81ceOwiA=!MoJr#*jrJ&S!qjx~Hm3g6dJUne%hbeml0#shcs)Q_Re#V5Ubm^u05JBUU+sObF#Z{8IHeu za6i+}NLBs`Jb$Y|;>PBW6P)U}n>?%cmoI^v`g(hXd&`<;ieoq&UZtvql)=X_o2wlZX zW0IcWdfjvdKcT_?kuulCdx^(yqNydr)EJM9x708cB4n-!9iXn0A=iL~$oR!fE@dmv zADVMP&d{6-b1qsm9Qm==wL{xs{iP|U*QLBpch`e?y@xtOU2fT8=}IJ!^q^lMy75FB`EBEW|LAjW?i#$-9t zu2SSxcAiS;FW5be@QqS?dX>PexJ*}M@={d9z4KU%S8!dlY>NaPLmquV0#7zZrk?kymQfl>M_ zx@E3u>>N6v5Be7`YM0aV^V?5}l#`VT$4XHkw?%ql7~D@%<;SirdP`}KT2{6ix@Bj1 z{587Y=i}arV5%T}sJdwCz)PIJjHASv`2ISW$*iVlEW*$u-Dv8wxQXf57$0UQz??r+ z6#%f%0Y#t*N34@VIDaJiW;))AlVP~_PEy^w`_W#Z^WjJDfo|x4>?GCqhZig6LdERs z`#Bw!{~zeP=yJuroAC{O*Hho8D}JaT(^4Ac`Ts%RyTOcceSh-0>ie4l<>~g@P2X=~ zSS9MaCvHOD=lL)X0%nW)PU1j}zNsG!{snqX(D$R~Lf;q6a{4aaaCW5Zk5I`TPyuY( zG+b%yPa2$JXX#K+9qyVt`px^hQ7^B*qTFBXZm0OSTWN3@{&Ls*TzC8J+YD*F-5vtZ z1I@wi_H+L21$KMYt9tt@v_tH2|Muf{`*e;!5ZMhxN~%Yl3Yg0kG_}?Tz1cutu5zFa z98%G->6rM;Q{-cN;PMq*F72HGM?Zg2MbX%dq*3b{XZZO=&Q|oH(mL#C@n)!W1+KvM z+{=`&pKmp(b_TJ=SviAoYswjVYc%-CErS{}TRDlh8T?d?3i$#i%EUKPTjf6Ff!yeX zW*sX!pHG*QVVvCPBu;oDW%$q!CKA$3+a@H@PX4@qFSeDB;{<;s(Ujke3I4bUzM%^e z-@%RPzNcb_lUsgTLU5?*6Yc>hKjUHo+$Vfu=$;ce9b)!v&x@%0Ua${~87?k|5IcFo z95xSgU|eAWn-?zN6=ttTEQBR)gI1u3TBIHN5tc>rodxBz-15Qs`VCx9)&(a->2eqy zf-emH=$=%>6Ec)fIedFr=#88(5WhZh z=Sc*?w@~xJOFx$azaC4LFv(s(w!W0J!IrPM91UJ*%`5v(R$I7z2iQ4J;VOdD9ELH+ zOm5lI+yy`EfXV6Y<1)W*+=KD!FOV)3M0$P~y0eP5E8o`xGoQPRa*i?sy+->b%iFLf zrN^9Pb8gv6W8-WF2u%5Pa?(ZG&orP&@sf5r{xC-zR~9LTknQl3Bl$h^!r8a?YpXkN z9b7gRw{sos)nlNDYJF8%&LC+;L0i+nKB{rA0aZk&Xr=k_8Cq#|4$|p8lL4vjvH}+uX5CM-pUt}WrN8tCGf>M1NIUeGNVGf&YL?ekcubefXCh^* z%8;MoDZEOSXK^E^=lXFa{P=B8xby9W&hPX1Vca&Ev3Nmz>IC4M{-qzxr2`M~j{g(7 zitSf${xcBq@(7ZNrherz(<8UEOY&dx-VHp)vpOZm_;djk+Mb7(c;j{F(ab! zrw+his1f<+YiVYm|OM>_5(1h9lt)AD^~nCrdu$Ugo~(L%#`an zgv;>beW>R_w9(R_$p+s$);k((3S_dV7!f(;p5W2Lx8a zFFi?2h=wZ|qbPBfbMu1PYvM|A8Tm>P8Y&Q$44%0(?py zfc$Zy^az64U3%LYy?7)w*Aqe2y>u39LES%fS^ z#JKcfeAa6z9Fd>(!e#7eJbDh4j($1^rRy(1aGwXuwpVEO`!hoTb{qr^ywT zqH5I%0}N_}Jo;aSqHnbWV=Q}432O+LFc{&J9B}B%r>4CE*#t2W85yerkrC@ll7%jw zd=R>5f#zw>S#%N~$7ID}2(vUHxC&-H=Wv4O16~mX+@waF7p^25C!@lQwIo!MilqmK zOFq0Ha}DXo6-(H%wW`<==`x0-s95|S5HMpWE2h{LZ2azND1nQwFK&Lrdkea8>mrlq zo2iiJFq0=2YGh|+W(Fdvy63KF4V9FjC*3o{+%wzUGaY5$%y0Z|eahB}*zm|;a!?Z6F z2|TvVD0Smw6vs!69Q&d==*fwC1i!wAW-8n2p*JyDC3@&%K3_7}mq7aCDyMjHyFNXi z46B|d{0u#L&bge&+)d_|==cbgoM{?RAK9SW3Z){Aei=%}Zntr#1!x57wq8GoN&j*op|~c`hX4-Agfc zsOR%hIwMB2Cj1AY{0@t?(eo8b#{$87umS=>8$BDpzMkJ^R(6q~GlIfj^xV_uOPYKM zYJvVXJ$UOOQGB*^%mm|~HGt;;T^rL#_;xSb620BsCwa_aAZM~NGENY^j z*_nDyQ-*7#!14$jcd6`dQ7TQ!;%>e~UchLxfIA*MQf~; z&l7l7%=G;66fpNIR1wtkZ0flPjjHD~)$>{CL_JrUo~umH6^VLgXX?2MDxp7bglwdy z{`|a+wG26sq1iPrkv>js^yhzpXX^Rl$K3t4{@iGH?}JxS&*i>%LC>@9gD8i?!Q1Hh zK^;!!&zoR{L_Hh7zMg-hmpVP4q(Le{&sX?-$pO9ul8P%|&#En_=L7f-p6U4#G8fh1 z6e_`1h(_jW>NyRKs^@)G&)xB#dM-3Q7nz<567|f^)N@1`u8|6iWKvUq?oH*hB6H$y zzC=EMLe)k+zXH8b&%ZtDAlt_0Vo1ch-CPGb7^SmTH0#XC5M?1O)<(~nO2_vS2)Cj`zu~(V9C}>^Bsdoy-bT^ObUc|ucSC@J zqWcCDA!P)=zM{LBn+{=|yGs3H6qly{bd5X@k;y)H67l7blW;|K_wCsbn(z}d;l21r zc+Q<>le@V(ph6}6Oux0%@2O~1{f0^k*Z~vjB-3q*={h~GV{8$*;|k~l(V4%2PN=;jrkf4?;QU=)*#>zXa`5hja4A~i9N)Dd#T}C% z#jmhd8yyc*I_AtZut1`YDQ7^(i_JyzsbgJlmyg2sPa7TQOLw0;`No$+R^zIzj*rx- ztkdx@ayM89Q>bK)>3Ah|{1p^rlgmv!k_#QzTI8tL5?>ca$+;ZXcoDL~e$??^WEMKU zD3+tZ^llm^>Bo1)-Ft~VkLX~2Tm()zwO{tIna0;K9zkuEv(y5u@;m&9y8g-cC+K+p zdmzQVuvQx#Cn+8C<4X}=5_N3+`hHwsei@;TpHP<=8jW+dRI*K9Y4Un}FfEZ);LR-h5*&*b-SD8ZXfOqAR{imA7uP}3eeZ=u z^Cm)y`S6W47VWNdY}C-+i54|}eT&{>qad3W{YZz8dZla0VHVa-H)8Na^0 z*1}(?mmaj&f$Cm*C?uFkdPv0QPBz=*EJJ?5Ra<+VhIbE!S9mugcJX;AjNj&YDCX#G z>X_rSsY4U7M05a!I~s$NL+be^-azo9iQa^M%|xGJW?&0j-l7#k6bDuqZ0SIA&CV7A z(xfOpn3l*B4>{3O=t4J{T*)%;KWrYzZE|c4Gay1eu;wZ`#cY@?V*Z;VYkg0KMRqO& z)3?F4Z7i~$AqJ>`qDIbyy%H^Ay!#f(Ge_@2i%intG>XSRf)?o_uPc{~?IV4e!4T}lH zwvO1o^q_n$(eHw*tNyw`~~zMt<+O29v_ZN2e6)59{fb3ELn_!-e0{hy}* ze}CNcp2t5IwE!n;&`$XFB)ti&8Ju?|2zcKlrxR17PkcZ(K9AoKnFP-FEeS>LH zMdQ~BndFyVw%*XW;YJKy?|2939gULwSArhPW38T&K%f1C{ARiSG5`7$;e`EXp#)!` zF8N^5d&}C-1HQm{4xZ7g<#E%MkuvO$;@D|k*{$J?IAF;mr`WjtEU#=7j-HNR&($b@ zy|tS0YbYaAG;3`MPjX^6dWoE%G2zB>JV08={qfbHib)B_{{iqp&QEF>M53uXNAz*< zo-E=Y2VTvr0HDbl!=~9*ygT5OSN^0v8_6rje!cQBQ+KDxPZjFeNhNzYpOY6I#b+~h zQjRgC!*Ho2ky$iFz+zr>7-QHHnk>QvCfLnZ_pjDVT<03Vxnr2p?Qx;9eYu{A#hqCRw#irNjUJUu_~D@@K5_#(hb zIvwgE^*`x7D4$~9jix@r z7R@>xY?0Iq=oP{G9A<;$+~{l1P=95=vBxafC4p(|!>4x2QR+8=x{}Ve6q77VZN~Ky zJ!&vL352{m9HCq#bmNg|`oWrxbF`25X;;T-p8(p8cU1UyXhq}dKt`;~^hiuL9-Cx6 zYsfsXQBr+l7MdQhrcbqL6b}11*=plh)Oen1Rv?Zk2UPSATz^y zF=o1O0_Uvv8{m7cN{0$-XNRgFj_O*XdX+N*$KE9NeFKale_sR_#1-zSAIhr?I$(4z`k=k>K9HDT zBsw}0F=LO2lh~Cc@<}3^Rbb#N;V(ho&`G}YjW3v$4|L#}ri*72z&T?xW4}c3pO9&R z{ddDYCINh79DE$X7dh}X2Hr0LJSon5KEbCr@Vs$OoBJk!r^LYzB=}_x{MXwZ`1det zP}G%i@Shlqj&tC*8}_#nzwd=_E$f|E7Oh8S(*X>d8DXPhrbsP!%aCjM+QgIEdl z4=Kv`%H3g1ePhQ87uN>8k&f24z(EoZuHksbDe!T;DT1ftJJwx~^jw}SXJR%_oD<+g zrPZU(2Jt?Gie|llA?zRAI2V-XrvQ`_rbV8TYE*B)rkeX_*;xw z7hi#X1cWDA7W_^vCSqm+vNO+UES|BE!~^Wi;!qu~aT*Rg2_X*aSK6 z3eqaOn|I^x^!7cDhwC5`bUE`RWqbKKDB|u^GT8y0sByAMekn)2`~to)fp>oR_D_Uw z|Kvl+A>0qbu~`~6IEl$h0zaHC(7qUiN95um0A~^U3Pgh(s3_ZZOKY5Lc{iH%_88Z_ zt9IASheh5h$Ur@i|9nKAm)@!^onS4gG?lmMIK}4Gu+-Xg3Y161v z*qd_#>wPnNdjmKph@EF51m^?>F^CXH0m2_|pwrWkUg40Yu?yz}*5x2}+2r!-{swwd z0F?6q18pe-=tmB;@fN3*-2Vps*v2K_4ooCg@z#|S#sf$nIaZw5d) z2Qbi^2%7IezcL0U2S9toLHiN(5C=NnKrat~V#xYf(+T>!OXkxI^uz!t^S&|g>s>uU%B&PO$l zsLpj%cQ??71E2+Q(18T)?m(MII};TKK$((_!L9_w&tP%LzHgv?1E5UD2D*6yKv%kS z{J1f&cL0>B*g%&P6kFcJdaZ#rO^S=fG;E;H5cCcQI?zBD2S6Dx4fHmG4tAiA-R#7A zFaWwT4tf?rk8q&fO{{AIpv@gL9|{FuYlwT!M85tXm(aG7n(9 zwHUe7d&{NcG((Z(P#nVh0}TcJi71$BjruJBYn)4$xClc~b1Z(JPQ9Z+E?^psrf&SV z2F14qvL>@v9aL9_oSf&gmK3EkTO{(vmhLp{2jv%opahU`3~{}!~PwdC?aCxNeSXK zBlZx|EI`B_u?XugBo%@^jEyP=ZlF&gGibU?n`$JR5Tvz_bn$~L5s94@G>msvR0p?WwKsm+PG3E~lO50vyn<_yDq9r}8QDeKv^V>`p& z)8XHb;7mdWehR@iBCsl-fM0ckQ`t@qK9*k$emBA|bAk9R16>Qg{5Z$_VxSH1Id8fH zEjQ3t1EBSBP>w(EdIwr)pmzm8lQGT=>%9ckpA3m+O*hb?0njdS(BTB#*I^xFphpKl znTibS2?YJoMbE(o+A#nMr}RNn2)fjP9&4bVW61j&U@9`K-y$h^4?EC*8t5wy^cdP9 z5(j;QpoIi2)7Q23Mk1ysevF7pOYhB563tp}Gu^8kmJDKHmNJ5)h~;o#;cHaY_{V|u zA-tR@K0|y2im8U8OMvGgaTJ+E(cq%!jRyKBhO93hvy)NlK+t&(^ehAYH~=~#4!Q;d z&;uW2;3xzAZvd3p$*@)tbhra;Z%Vt>fod49#eIs?WxOjHU#JFVEkkiNQ5@`0%rR;` z1Jszc4D=L&Zgdg<5d-ZU0AdGHwTz)X0mfUMIVO*FC@wJ+r#lpywH`4P zcf#V-l*CamzcHG2aYRzc=7B9{fXGfw_Y-)w~Y$Mpv#S;?z64StN#;{0v`$M|G zIy|~P0`PdrsSpTtQII=+iBoZt>`GV0&Ig~_UjUbCPu|M${2oiB@eA8?POu}7#S$sf z;zy9;!PCippKw8LSv9c!jtGwq7vOE0dy08<7mp=5a><*3klR#{2m){Z@mN`))S`(sf)6 z>q&-{I|0Ic#$MbzuGt`0-t z@*n0bc$23vJ|8kQT@A;EEKKUHQfty-^lX-|!5xuYbV`F2zTJQHIhU3 zD61>2&JImkB0DfzF#Xzk7BumGFyjDDO;=KPJSx^8jc6i~3N-O-G)Q!DB%~J64Ry{i zUxTU$eKnO(3hmbtLpjFL(xM)_;P^OY%8<^6zbKBsT=8SBsmO6YnSKC=y@AMedWcXm zeo=cJ@^!Lag9YAKF@l@M0xX*PD;`9^DyOn2TctL>1hFTe*yRLN#lCG<8S*kC6%K|o zJ`9T-vxf$ZvX!CIeK;=1FJ_zxoMNXNN2m*Cu1K^~8mQ@>3qJ`_xAYDQs;^uWype=J zkO%Qc$QsI5wi>7Six;+!-qpH!^X8V?0~d_{vIu{pq-+_P%EmL91(MRTpa_}?^;s5) zp7M`Ks84Ou+mYhcJ4Cv!mM3pkIltwTlW5k3DE#fMG00w-YrH)%QKP5TGxK98)9qUw zbVdL=5752{d^@B-xr8u(07!*V-XRY{+X3X=*ps87dC*x1myx9yKNt+Tu>4gF@qp(CANNW59mBuOsZSnpD5Z8!t6L`nhRU4rJ=eoAqT zH0~UaCpm+2%RbCGC%5d=*bAXO&ZpNPnje4??`!3E=7=f@N3@(6&PJ)}3vVEGqC*BU zSQqq#L4LRqd_^aQoA)Q^hmo?0;d+3|)7p-OsJ7#60HkKN-=pnNlD6ZF1{)t_1S{Wh z^3a2lmX?H}1K=vI#%iS`TunISm@0+GP94q>f-5%+@BX7e_f(^HJ9~ba2QB&pVNefs^MnSYp~EyXiEgPTtUw zHB)8hdJwwXNHsmqcAo2CKgeE90_7cTy-17%!{bl}%yiy_VH60@3480$hSNTZ>r*5# zit+(*GDobF;+x2)Pqv{9+pk8rD}Wg3hbMzk;7(E8zHzeJA8xquz8(1-qqvdeTjeOl z=~%^3BTmPqtiT;chr9Kih$q7t`;p%m&eQ~)hsJTPQR{38=Xk@Jg3lq4&x(E8=%AO6 z({%7LLI4COpA*bosV(EvWIxj3EV(Epz#q4aP1xIRpw?2GFlj*;OhKWs{wDL!Y-1rq z%bDTy^N0q1rgeNuW(eN~BC|zkp(hn;IWt_KB?cuSp|v8YmM>Rwc+iZaS%-xRwVW3o zp(UIarS~a@kiWji=^_pdJrRX_(nwk1Mmk;|(Mis{Fb4ytOlNTKB+!FYZT27Ucy)Mm~8{`HpsK*B04tsLEr8O#975 z1#dl(U<3qZF_8CM6e?b;cw8gC74xP}dUT?2iH#Ql1RebG>uB!=IgbMplwEt1dQoGkt0;GU|G#Rz@^Vxjw;ci6iWDqvqOM zxi^YehbVN=IHzO|SM66Cu zVH0M1-_fn2sq+s}B~52xN=hPcfS9dnjD<2^1Sz16jCZn=!2NjY7?V4Mp$xwG@5fj- z+@DcpS@^oM&`D6wumxY@P5RaubXf%d+BnPXyQRI9LU$i-&1Ku(nzOqIfHY~<7n&91N7f_7`oRG$V z6(Z%gU~9V5*#o)h;?fgTQ-2T!F!kUjI=&u2B19LiiEVELQ6*@m2B^B0YOeJL@2P+U4@2=*Tu7e%3HEtjh~mJIwX0 zJZcp>sT{3fC1Fm*u~>AwOQF)eh-&;|PVU<*6@98spP6q*%Jaq7AwmU+GnC7|SAkwM z_3?Cd;FD44sC`Q3IheSp^%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 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 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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