From 93d8f17fbcb55515141807edee74163a0b004eae Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Fri, 21 Sep 2018 11:38:19 -0400 Subject: [PATCH 01/14] 4.1.5 GA Signed-off-by: Kaleb S. KEITHLEY --- glusterfs.spec | 5 ++++- sources | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/glusterfs.spec b/glusterfs.spec index 2019fdc..83df20a 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -217,7 +217,7 @@ Summary: Distributed File System %if ( 0%{_for_fedora_koji_builds} ) Name: glusterfs -Version: 4.1.4 +Version: 4.1.5 Release: %{?prereltag:1.}1%{?prereltag:.%{prereltag}}%{?dist} %else Name: @PACKAGE_NAME@ @@ -1444,6 +1444,9 @@ exit 0 %endif %changelog +* Fri Sep 21 2018 Kaleb S. KEITHLEY - 4.1.5-1 +- 4.1.5 GA + * Thu Sep 6 2018 Kaleb S. KEITHLEY - 4.1.4-1 - 4.1.4 GA diff --git a/sources b/sources index 568f205..fa24cc5 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (glusterfs-4.1.4.tar.gz) = 7ef82170c9025ea74867382acc17e4fde55af82d4b04138fb74800c3fc28f018f9ec493069fd14961310dece6cb386973fb07e00d5cad59a9aaf6020155cba56 +SHA512 (glusterfs-4.1.5.tar.gz) = ae557472b6a263e815b8c4d630b606f8e1334b6604799e499e6f53ea6ff60c2a696160fa427943cc3d01ffee91a57787c91f93a1b914179679038e63d291401f From 723a016af52ab253620e634932591130598b9ce6 Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Thu, 13 Dec 2018 08:21:13 -0500 Subject: [PATCH 02/14] 5.2 GA Signed-off-by: Kaleb S. KEITHLEY --- sources | 1 - 1 file changed, 1 deletion(-) diff --git a/sources b/sources index d264949..022bbd5 100644 --- a/sources +++ b/sources @@ -1,2 +1 @@ -SHA512 (glusterfs-5.1.tar.gz) = db5649166c960c894162b2f2e706d85accff663fff71e80ed5a9f24a3863d2a0e0d94bc42d39baf1002f1ec8ef5445ff791d6d3edd539bfc8d6f6d00d7897db2 SHA512 (glusterfs-5.2.tar.gz) = e676a604410310406dd283d5bc8e17143e2d70d4955497a88e61952193a525978e177949a962bf47405c423ef8d4109e4309b600824eb3984127c4e231ce16f0 From 5493692ebb0de90ea42cd699da9b0fd68fe6df2e Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Wed, 27 Feb 2019 09:04:17 -0500 Subject: [PATCH 03/14] 5.4 GA Signed-off-by: Kaleb S. KEITHLEY --- glusterfs.spec | 12 +++++++++--- sources | 2 +- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/glusterfs.spec b/glusterfs.spec index 7312e52..f71f2cd 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -218,7 +218,7 @@ Summary: Distributed File System %if ( 0%{_for_fedora_koji_builds} ) Name: glusterfs -Version: 5.3 +Version: 5.4 Release: %{?prereltag:0.}1%{?prereltag:.%{prereltag}}%{?dist} %else Name: @PACKAGE_NAME@ @@ -295,6 +295,9 @@ Obsoletes: %{name}-regression-tests %endif Obsoletes: %{name}-ufo Obsoletes: %{name}-ganesha +%if ( 0%{!?_with_gnfs:1} ) +Obsoletes: %{name}-gnfs +%endif Provides: %{name}-common = %{version}-%{release} Provides: %{name}-core = %{version}-%{release} @@ -1435,8 +1438,8 @@ exit 0 %dir %{_sharedstatedir}/glusterd %dir %{_sharedstatedir}/glusterd/events %dir %{_libexecdir}/glusterfs -%dir %{_libexecdir}/glusterfs/events - %{_libexecdir}/glusterfs/events/* +%dir %{_libexecdir}/glusterfs/gfevents + %{_libexecdir}/glusterfs/gfevents/* %{_libexecdir}/glusterfs/peer_eventsapi.py* %{_sbindir}/glustereventsd %{_sbindir}/gluster-eventsapi @@ -1449,6 +1452,9 @@ exit 0 %endif %changelog +* Wed Feb 27 2019 Kaleb S. KEITHLEY - 5.4-1 +- 5.4 GA + * Thu Jan 17 2019 Kaleb S. KEITHLEY - 5.3-1 - 5.3 GA diff --git a/sources b/sources index db028a9..876c1e9 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (glusterfs-5.3.tar.gz) = 8b5405dbbfcc57ece25ac5934c1d63e9a1f8936bcf6d53ebfdca5c144e963550d99bdee667b7ed7b06c608ddfbf40b5738e9c15b17a11362c8478b02a7e0e15f +SHA512 (glusterfs-5.4.tar.gz) = e490bb329e72898fe8f399c73e391682c2763a3624d5cff301ba00f9160ebd720d2c18f3e878f275d535ecd32cc7a50ec17be20b4108adac2c647a3bbd4ba4b7 From b75bbec09f0d462e650b4076f08d89f357acb0db Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Fri, 1 Mar 2019 09:04:06 -0500 Subject: [PATCH 04/14] 5.4 s390x, armv7hl no rdma Signed-off-by: Kaleb S. KEITHLEY --- glusterfs.spec | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/glusterfs.spec b/glusterfs.spec index f71f2cd..90dd4ad 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -92,6 +92,11 @@ # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without rdma %{?_without_rdma:%global _without_rdma --disable-ibverbs} +# No RDMA Support on s390(x) +%ifarch s390 s390x armv7hl +%global _without_rdma --disable-ibverbs +%endif + # server # if you wish to build rpms without server components, compile like this # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without server @@ -219,7 +224,7 @@ Summary: Distributed File System %if ( 0%{_for_fedora_koji_builds} ) Name: glusterfs Version: 5.4 -Release: %{?prereltag:0.}1%{?prereltag:.%{prereltag}}%{?dist} +Release: %{?prereltag:0.}2%{?prereltag:.%{prereltag}}%{?dist} %else Name: @PACKAGE_NAME@ Version: @PACKAGE_VERSION@ @@ -1452,6 +1457,9 @@ exit 0 %endif %changelog +* Fri Mar 1 2019 Kaleb S. KEITHLEY - 5.4-2 +- 5.4 s390x, armv7hl no rdma + * Wed Feb 27 2019 Kaleb S. KEITHLEY - 5.4-1 - 5.4 GA From d35c6fc081d3a9f57ed08ea91f8d709bd9216446 Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Wed, 13 Mar 2019 08:45:19 -0400 Subject: [PATCH 05/14] core: make compute_cksum function op_version compatible dict: handle STR_OLD data type in xdr conversions Signed-off-by: Kaleb S. KEITHLEY --- ...e_cksum-function-op_version-compatib.patch | 180 ++++++++++++++++++ ...STR_OLD-data-type-in-xdr-conversions.patch | 59 ++++++ glusterfs.spec | 10 +- 3 files changed, 248 insertions(+), 1 deletion(-) create mode 100644 0001-core-make-compute_cksum-function-op_version-compatib.patch create mode 100644 0002-dict-handle-STR_OLD-data-type-in-xdr-conversions.patch diff --git a/0001-core-make-compute_cksum-function-op_version-compatib.patch b/0001-core-make-compute_cksum-function-op_version-compatib.patch new file mode 100644 index 0000000..97a0e6e --- /dev/null +++ b/0001-core-make-compute_cksum-function-op_version-compatib.patch @@ -0,0 +1,180 @@ +From a00953ed212a7071b152c4afccd35b92fa5a682a Mon Sep 17 00:00:00 2001 +From: Sanju Rakonde +Date: Mon, 4 Mar 2019 16:53:01 +0530 +Subject: [PATCH] core: make compute_cksum function op_version compatible + +Problem: commit 5a152a changed the mechansim of computing the +checksum. In heterogeneous cluster, peers are running into +rejected state because we have different cksum computation +mechansims in upgraded and non-upgraded nodes. + +Solution: add a check for op-version so that all the nodes +in the cluster follow the same mechanism for computing the +cksum. + +fixes: bz#1684569 + +> Change-Id: I1508f000e8c9895588b6011b8b6cc0eda7102193 +> BUG: bz#1685120 +> Signed-off-by: Sanju Rakonde + +Change-Id: I1508f000e8c9895588b6011b8b6cc0eda7102193 +Signed-off-by: Sanju Rakonde +--- + libglusterfs/src/common-utils.c | 15 ++++++++++----- + libglusterfs/src/common-utils.h | 4 ++-- + libglusterfs/src/globals.h | 4 +++- + xlators/mgmt/glusterd/src/glusterd-utils.c | 12 ++++++++---- + 4 files changed, 23 insertions(+), 12 deletions(-) + +diff --git a/libglusterfs/src/common-utils.c b/libglusterfs/src/common-utils.c +index bd3be7cfe..eefb5f159 100644 +--- a/libglusterfs/src/common-utils.c ++++ b/libglusterfs/src/common-utils.c +@@ -49,6 +49,7 @@ + #include "lkowner.h" + #include "syscall.h" + #include "cli1-xdr.h" ++#include "globals.h" + #define XXH_INLINE_ALL + #include "xxhash.h" + #include +@@ -2020,7 +2021,7 @@ compute_checksum(char *buf, const ssize_t size, uint32_t *checksum) + #define GF_CHECKSUM_BUF_SIZE 1024 + + int +-get_checksum_for_file(int fd, uint32_t *checksum) ++get_checksum_for_file(int fd, uint32_t *checksum, int op_version) + { + int ret = -1; + char buf[GF_CHECKSUM_BUF_SIZE] = { +@@ -2031,8 +2032,12 @@ get_checksum_for_file(int fd, uint32_t *checksum) + sys_lseek(fd, 0L, SEEK_SET); + do { + ret = sys_read(fd, &buf, GF_CHECKSUM_BUF_SIZE); +- if (ret > 0) +- compute_checksum(buf, ret, checksum); ++ if (ret > 0) { ++ if (op_version < GD_OP_VERSION_5_4) ++ compute_checksum(buf, GF_CHECKSUM_BUF_SIZE, checksum); ++ else ++ compute_checksum(buf, ret, checksum); ++ } + } while (ret > 0); + + /* set it back */ +@@ -2042,7 +2047,7 @@ get_checksum_for_file(int fd, uint32_t *checksum) + } + + int +-get_checksum_for_path(char *path, uint32_t *checksum) ++get_checksum_for_path(char *path, uint32_t *checksum, int op_version) + { + int ret = -1; + int fd = -1; +@@ -2058,7 +2063,7 @@ get_checksum_for_path(char *path, uint32_t *checksum) + goto out; + } + +- ret = get_checksum_for_file(fd, checksum); ++ ret = get_checksum_for_file(fd, checksum, op_version); + + out: + if (fd != -1) +diff --git a/libglusterfs/src/common-utils.h b/libglusterfs/src/common-utils.h +index 6a6fd8c98..f623e770c 100644 +--- a/libglusterfs/src/common-utils.h ++++ b/libglusterfs/src/common-utils.h +@@ -830,12 +830,12 @@ int + gf_unlockfd(int fd); + + int +-get_checksum_for_file(int fd, uint32_t *checksum); ++get_checksum_for_file(int fd, uint32_t *checksum, int op_version); + int + log_base2(unsigned long x); + + int +-get_checksum_for_path(char *path, uint32_t *checksum); ++get_checksum_for_path(char *path, uint32_t *checksum, int op_version); + int + get_file_mtime(const char *path, time_t *stamp); + char * +diff --git a/libglusterfs/src/globals.h b/libglusterfs/src/globals.h +index c5595ca7d..fe18589ee 100644 +--- a/libglusterfs/src/globals.h ++++ b/libglusterfs/src/globals.h +@@ -45,7 +45,7 @@ + 1 /* MIN is the fresh start op-version, mostly \ + should not change */ + #define GD_OP_VERSION_MAX \ +- GD_OP_VERSION_5_0 /* MAX VERSION is the maximum \ ++ GD_OP_VERSION_5_4 /* MAX VERSION is the maximum \ + count in VME table, should \ + keep changing with \ + introduction of newer \ +@@ -111,6 +111,8 @@ + + #define GD_OP_VERSION_5_0 50000 /* Op-version for GlusterFS 5.0 */ + ++#define GD_OP_VERSION_5_4 50400 /* Op-version for GlusterFS 5.4 */ ++ + #define GD_OP_VER_PERSISTENT_AFR_XATTRS GD_OP_VERSION_3_6_0 + + #include "xlator.h" +diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c +index 9bb3bc4ba..2a4ff542c 100644 +--- a/xlators/mgmt/glusterd/src/glusterd-utils.c ++++ b/xlators/mgmt/glusterd/src/glusterd-utils.c +@@ -2810,7 +2810,7 @@ glusterd_volume_compute_cksum(glusterd_volinfo_t *volinfo, char *cksum_path, + + cksum_path_final = is_quota_conf ? filepath : sort_filepath; + +- ret = get_checksum_for_path(cksum_path_final, &cksum); ++ ret = get_checksum_for_path(cksum_path_final, &cksum, priv->op_version); + if (ret) { + gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_CKSUM_GET_FAIL, + "unable to get " +@@ -2827,7 +2827,7 @@ glusterd_volume_compute_cksum(glusterd_volinfo_t *volinfo, char *cksum_path, + } + } + +- ret = get_checksum_for_file(fd, &cksum); ++ ret = get_checksum_for_file(fd, &cksum, priv->op_version); + if (ret) + goto out; + +@@ -9415,12 +9415,16 @@ glusterd_check_files_identical(char *filename1, char *filename2, + uint32_t cksum1 = 0; + uint32_t cksum2 = 0; + xlator_t *this = NULL; ++ glusterd_conf_t *priv = NULL; + + GF_ASSERT(filename1); + GF_ASSERT(filename2); + GF_ASSERT(identical); + + this = THIS; ++ GF_VALIDATE_OR_GOTO("glusterd", this, out); ++ priv = this->private; ++ GF_VALIDATE_OR_GOTO(this->name, priv, out); + + ret = sys_stat(filename1, &buf1); + +@@ -9447,11 +9451,11 @@ glusterd_check_files_identical(char *filename1, char *filename2, + goto out; + } + +- ret = get_checksum_for_path(filename1, &cksum1); ++ ret = get_checksum_for_path(filename1, &cksum1, priv->op_version); + if (ret) + goto out; + +- ret = get_checksum_for_path(filename2, &cksum2); ++ ret = get_checksum_for_path(filename2, &cksum2, priv->op_version); + if (ret) + goto out; + +-- +2.20.1 + diff --git a/0002-dict-handle-STR_OLD-data-type-in-xdr-conversions.patch b/0002-dict-handle-STR_OLD-data-type-in-xdr-conversions.patch new file mode 100644 index 0000000..3b42857 --- /dev/null +++ b/0002-dict-handle-STR_OLD-data-type-in-xdr-conversions.patch @@ -0,0 +1,59 @@ +From 8fb4631c65f28dd0a5e0304386efff3c807e64a4 Mon Sep 17 00:00:00 2001 +From: Amar Tumballi +Date: Tue, 5 Mar 2019 08:39:16 +0530 +Subject: [PATCH] dict: handle STR_OLD data type in xdr conversions + +Currently a dict conversion on wire for 3.x protocol happens using +`dict_unserialize()`, which sets the type of data as STR_OLD. But the +new protocol doesn't send it over the wire as its not considered as a +valid format in new processes. + +But considering we deal with old and new protocol when we do a rolling +upgrade, it will allow us to get all the information properly with new +protocol. + +Credits: Krutika Dhananjay + +Fixes: bz#1684385 +Change-Id: I165c0021fb195b399790b9cf14a7416ae75ec84f +Signed-off-by: Amar Tumballi +--- + rpc/xdr/src/glusterfs3.h | 2 ++ + rpc/xdr/src/glusterfs4-xdr.x | 1 + + 2 files changed, 3 insertions(+) + +diff --git a/rpc/xdr/src/glusterfs3.h b/rpc/xdr/src/glusterfs3.h +index 6ab80a829..abc6bf6d5 100644 +--- a/rpc/xdr/src/glusterfs3.h ++++ b/rpc/xdr/src/glusterfs3.h +@@ -728,6 +728,7 @@ dict_to_xdr(dict_t *this, gfx_dict *dict) + break; + + case GF_DATA_TYPE_PTR: ++ case GF_DATA_TYPE_STR_OLD: + index++; + /* Ideally, each type of data stored in dictionary + should have type. A pointer type shouldn't be +@@ -854,6 +855,7 @@ xdr_to_dict(gfx_dict *dict, dict_t **to) + ret = dict_set_iatt(this, key, iatt, false); + break; + case GF_DATA_TYPE_PTR: ++ case GF_DATA_TYPE_STR_OLD: + value = GF_MALLOC(xpair->value.gfx_value_u.other.other_len + 1, + gf_common_mt_char); + if (!value) { +diff --git a/rpc/xdr/src/glusterfs4-xdr.x b/rpc/xdr/src/glusterfs4-xdr.x +index 5ee86c24a..5929e887d 100644 +--- a/rpc/xdr/src/glusterfs4-xdr.x ++++ b/rpc/xdr/src/glusterfs4-xdr.x +@@ -60,6 +60,7 @@ union gfx_value switch (gf_dict_data_type_t type) { + case GF_DATA_TYPE_GFUUID: + opaque uuid[16]; + case GF_DATA_TYPE_PTR: ++ case GF_DATA_TYPE_STR_OLD: + opaque other<>; + }; + +-- +2.20.1 + diff --git a/glusterfs.spec b/glusterfs.spec index 90dd4ad..46f3ebd 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -224,7 +224,7 @@ Summary: Distributed File System %if ( 0%{_for_fedora_koji_builds} ) Name: glusterfs Version: 5.4 -Release: %{?prereltag:0.}2%{?prereltag:.%{prereltag}}%{?dist} +Release: %{?prereltag:0.}3%{?prereltag:.%{prereltag}}%{?dist} %else Name: @PACKAGE_NAME@ Version: @PACKAGE_VERSION@ @@ -241,6 +241,8 @@ Source8: glusterfsd.init %else Source0: @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz %endif +Patch0001: 0001-core-make-compute_cksum-function-op_version-compatib.patch +Patch0002: 0002-dict-handle-STR_OLD-data-type-in-xdr-conversions.patch Requires(pre): shadow-utils @@ -692,6 +694,8 @@ This package provides the glusterfs server daemon. %prep %setup -q -n %{name}-%{version}%{?prereltag} +%patch0001 -p1 +%patch0002 -p1 %if ( ! %{_usepython3} ) echo "fixing python shebangs..." for f in api events extras geo-replication libglusterfs tools xlators; do @@ -1457,6 +1461,10 @@ exit 0 %endif %changelog +* Wed Mar 13 2019 Kaleb S. KEITHLEY - 5.4-3 +- core: make compute_cksum function op_version compatible +- dict: handle STR_OLD data type in xdr conversions + * Fri Mar 1 2019 Kaleb S. KEITHLEY - 5.4-2 - 5.4 s390x, armv7hl no rdma From 0fb013b66bb4ea4b5448c1b159ee22d3163e3f50 Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Fri, 15 Mar 2019 11:51:14 -0400 Subject: [PATCH 06/14] 5.5 GA Signed-off-by: Kaleb S. KEITHLEY --- ...e_cksum-function-op_version-compatib.patch | 180 ------------------ ...STR_OLD-data-type-in-xdr-conversions.patch | 59 ------ glusterfs.spec | 11 +- sources | 2 +- 4 files changed, 6 insertions(+), 246 deletions(-) delete mode 100644 0001-core-make-compute_cksum-function-op_version-compatib.patch delete mode 100644 0002-dict-handle-STR_OLD-data-type-in-xdr-conversions.patch diff --git a/0001-core-make-compute_cksum-function-op_version-compatib.patch b/0001-core-make-compute_cksum-function-op_version-compatib.patch deleted file mode 100644 index 97a0e6e..0000000 --- a/0001-core-make-compute_cksum-function-op_version-compatib.patch +++ /dev/null @@ -1,180 +0,0 @@ -From a00953ed212a7071b152c4afccd35b92fa5a682a Mon Sep 17 00:00:00 2001 -From: Sanju Rakonde -Date: Mon, 4 Mar 2019 16:53:01 +0530 -Subject: [PATCH] core: make compute_cksum function op_version compatible - -Problem: commit 5a152a changed the mechansim of computing the -checksum. In heterogeneous cluster, peers are running into -rejected state because we have different cksum computation -mechansims in upgraded and non-upgraded nodes. - -Solution: add a check for op-version so that all the nodes -in the cluster follow the same mechanism for computing the -cksum. - -fixes: bz#1684569 - -> Change-Id: I1508f000e8c9895588b6011b8b6cc0eda7102193 -> BUG: bz#1685120 -> Signed-off-by: Sanju Rakonde - -Change-Id: I1508f000e8c9895588b6011b8b6cc0eda7102193 -Signed-off-by: Sanju Rakonde ---- - libglusterfs/src/common-utils.c | 15 ++++++++++----- - libglusterfs/src/common-utils.h | 4 ++-- - libglusterfs/src/globals.h | 4 +++- - xlators/mgmt/glusterd/src/glusterd-utils.c | 12 ++++++++---- - 4 files changed, 23 insertions(+), 12 deletions(-) - -diff --git a/libglusterfs/src/common-utils.c b/libglusterfs/src/common-utils.c -index bd3be7cfe..eefb5f159 100644 ---- a/libglusterfs/src/common-utils.c -+++ b/libglusterfs/src/common-utils.c -@@ -49,6 +49,7 @@ - #include "lkowner.h" - #include "syscall.h" - #include "cli1-xdr.h" -+#include "globals.h" - #define XXH_INLINE_ALL - #include "xxhash.h" - #include -@@ -2020,7 +2021,7 @@ compute_checksum(char *buf, const ssize_t size, uint32_t *checksum) - #define GF_CHECKSUM_BUF_SIZE 1024 - - int --get_checksum_for_file(int fd, uint32_t *checksum) -+get_checksum_for_file(int fd, uint32_t *checksum, int op_version) - { - int ret = -1; - char buf[GF_CHECKSUM_BUF_SIZE] = { -@@ -2031,8 +2032,12 @@ get_checksum_for_file(int fd, uint32_t *checksum) - sys_lseek(fd, 0L, SEEK_SET); - do { - ret = sys_read(fd, &buf, GF_CHECKSUM_BUF_SIZE); -- if (ret > 0) -- compute_checksum(buf, ret, checksum); -+ if (ret > 0) { -+ if (op_version < GD_OP_VERSION_5_4) -+ compute_checksum(buf, GF_CHECKSUM_BUF_SIZE, checksum); -+ else -+ compute_checksum(buf, ret, checksum); -+ } - } while (ret > 0); - - /* set it back */ -@@ -2042,7 +2047,7 @@ get_checksum_for_file(int fd, uint32_t *checksum) - } - - int --get_checksum_for_path(char *path, uint32_t *checksum) -+get_checksum_for_path(char *path, uint32_t *checksum, int op_version) - { - int ret = -1; - int fd = -1; -@@ -2058,7 +2063,7 @@ get_checksum_for_path(char *path, uint32_t *checksum) - goto out; - } - -- ret = get_checksum_for_file(fd, checksum); -+ ret = get_checksum_for_file(fd, checksum, op_version); - - out: - if (fd != -1) -diff --git a/libglusterfs/src/common-utils.h b/libglusterfs/src/common-utils.h -index 6a6fd8c98..f623e770c 100644 ---- a/libglusterfs/src/common-utils.h -+++ b/libglusterfs/src/common-utils.h -@@ -830,12 +830,12 @@ int - gf_unlockfd(int fd); - - int --get_checksum_for_file(int fd, uint32_t *checksum); -+get_checksum_for_file(int fd, uint32_t *checksum, int op_version); - int - log_base2(unsigned long x); - - int --get_checksum_for_path(char *path, uint32_t *checksum); -+get_checksum_for_path(char *path, uint32_t *checksum, int op_version); - int - get_file_mtime(const char *path, time_t *stamp); - char * -diff --git a/libglusterfs/src/globals.h b/libglusterfs/src/globals.h -index c5595ca7d..fe18589ee 100644 ---- a/libglusterfs/src/globals.h -+++ b/libglusterfs/src/globals.h -@@ -45,7 +45,7 @@ - 1 /* MIN is the fresh start op-version, mostly \ - should not change */ - #define GD_OP_VERSION_MAX \ -- GD_OP_VERSION_5_0 /* MAX VERSION is the maximum \ -+ GD_OP_VERSION_5_4 /* MAX VERSION is the maximum \ - count in VME table, should \ - keep changing with \ - introduction of newer \ -@@ -111,6 +111,8 @@ - - #define GD_OP_VERSION_5_0 50000 /* Op-version for GlusterFS 5.0 */ - -+#define GD_OP_VERSION_5_4 50400 /* Op-version for GlusterFS 5.4 */ -+ - #define GD_OP_VER_PERSISTENT_AFR_XATTRS GD_OP_VERSION_3_6_0 - - #include "xlator.h" -diff --git a/xlators/mgmt/glusterd/src/glusterd-utils.c b/xlators/mgmt/glusterd/src/glusterd-utils.c -index 9bb3bc4ba..2a4ff542c 100644 ---- a/xlators/mgmt/glusterd/src/glusterd-utils.c -+++ b/xlators/mgmt/glusterd/src/glusterd-utils.c -@@ -2810,7 +2810,7 @@ glusterd_volume_compute_cksum(glusterd_volinfo_t *volinfo, char *cksum_path, - - cksum_path_final = is_quota_conf ? filepath : sort_filepath; - -- ret = get_checksum_for_path(cksum_path_final, &cksum); -+ ret = get_checksum_for_path(cksum_path_final, &cksum, priv->op_version); - if (ret) { - gf_msg(this->name, GF_LOG_ERROR, 0, GD_MSG_CKSUM_GET_FAIL, - "unable to get " -@@ -2827,7 +2827,7 @@ glusterd_volume_compute_cksum(glusterd_volinfo_t *volinfo, char *cksum_path, - } - } - -- ret = get_checksum_for_file(fd, &cksum); -+ ret = get_checksum_for_file(fd, &cksum, priv->op_version); - if (ret) - goto out; - -@@ -9415,12 +9415,16 @@ glusterd_check_files_identical(char *filename1, char *filename2, - uint32_t cksum1 = 0; - uint32_t cksum2 = 0; - xlator_t *this = NULL; -+ glusterd_conf_t *priv = NULL; - - GF_ASSERT(filename1); - GF_ASSERT(filename2); - GF_ASSERT(identical); - - this = THIS; -+ GF_VALIDATE_OR_GOTO("glusterd", this, out); -+ priv = this->private; -+ GF_VALIDATE_OR_GOTO(this->name, priv, out); - - ret = sys_stat(filename1, &buf1); - -@@ -9447,11 +9451,11 @@ glusterd_check_files_identical(char *filename1, char *filename2, - goto out; - } - -- ret = get_checksum_for_path(filename1, &cksum1); -+ ret = get_checksum_for_path(filename1, &cksum1, priv->op_version); - if (ret) - goto out; - -- ret = get_checksum_for_path(filename2, &cksum2); -+ ret = get_checksum_for_path(filename2, &cksum2, priv->op_version); - if (ret) - goto out; - --- -2.20.1 - diff --git a/0002-dict-handle-STR_OLD-data-type-in-xdr-conversions.patch b/0002-dict-handle-STR_OLD-data-type-in-xdr-conversions.patch deleted file mode 100644 index 3b42857..0000000 --- a/0002-dict-handle-STR_OLD-data-type-in-xdr-conversions.patch +++ /dev/null @@ -1,59 +0,0 @@ -From 8fb4631c65f28dd0a5e0304386efff3c807e64a4 Mon Sep 17 00:00:00 2001 -From: Amar Tumballi -Date: Tue, 5 Mar 2019 08:39:16 +0530 -Subject: [PATCH] dict: handle STR_OLD data type in xdr conversions - -Currently a dict conversion on wire for 3.x protocol happens using -`dict_unserialize()`, which sets the type of data as STR_OLD. But the -new protocol doesn't send it over the wire as its not considered as a -valid format in new processes. - -But considering we deal with old and new protocol when we do a rolling -upgrade, it will allow us to get all the information properly with new -protocol. - -Credits: Krutika Dhananjay - -Fixes: bz#1684385 -Change-Id: I165c0021fb195b399790b9cf14a7416ae75ec84f -Signed-off-by: Amar Tumballi ---- - rpc/xdr/src/glusterfs3.h | 2 ++ - rpc/xdr/src/glusterfs4-xdr.x | 1 + - 2 files changed, 3 insertions(+) - -diff --git a/rpc/xdr/src/glusterfs3.h b/rpc/xdr/src/glusterfs3.h -index 6ab80a829..abc6bf6d5 100644 ---- a/rpc/xdr/src/glusterfs3.h -+++ b/rpc/xdr/src/glusterfs3.h -@@ -728,6 +728,7 @@ dict_to_xdr(dict_t *this, gfx_dict *dict) - break; - - case GF_DATA_TYPE_PTR: -+ case GF_DATA_TYPE_STR_OLD: - index++; - /* Ideally, each type of data stored in dictionary - should have type. A pointer type shouldn't be -@@ -854,6 +855,7 @@ xdr_to_dict(gfx_dict *dict, dict_t **to) - ret = dict_set_iatt(this, key, iatt, false); - break; - case GF_DATA_TYPE_PTR: -+ case GF_DATA_TYPE_STR_OLD: - value = GF_MALLOC(xpair->value.gfx_value_u.other.other_len + 1, - gf_common_mt_char); - if (!value) { -diff --git a/rpc/xdr/src/glusterfs4-xdr.x b/rpc/xdr/src/glusterfs4-xdr.x -index 5ee86c24a..5929e887d 100644 ---- a/rpc/xdr/src/glusterfs4-xdr.x -+++ b/rpc/xdr/src/glusterfs4-xdr.x -@@ -60,6 +60,7 @@ union gfx_value switch (gf_dict_data_type_t type) { - case GF_DATA_TYPE_GFUUID: - opaque uuid[16]; - case GF_DATA_TYPE_PTR: -+ case GF_DATA_TYPE_STR_OLD: - opaque other<>; - }; - --- -2.20.1 - diff --git a/glusterfs.spec b/glusterfs.spec index 46f3ebd..f353121 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -223,8 +223,8 @@ Summary: Distributed File System %if ( 0%{_for_fedora_koji_builds} ) Name: glusterfs -Version: 5.4 -Release: %{?prereltag:0.}3%{?prereltag:.%{prereltag}}%{?dist} +Version: 5.5 +Release: %{?prereltag:0.}1%{?prereltag:.%{prereltag}}%{?dist} %else Name: @PACKAGE_NAME@ Version: @PACKAGE_VERSION@ @@ -241,8 +241,6 @@ Source8: glusterfsd.init %else Source0: @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz %endif -Patch0001: 0001-core-make-compute_cksum-function-op_version-compatib.patch -Patch0002: 0002-dict-handle-STR_OLD-data-type-in-xdr-conversions.patch Requires(pre): shadow-utils @@ -694,8 +692,6 @@ This package provides the glusterfs server daemon. %prep %setup -q -n %{name}-%{version}%{?prereltag} -%patch0001 -p1 -%patch0002 -p1 %if ( ! %{_usepython3} ) echo "fixing python shebangs..." for f in api events extras geo-replication libglusterfs tools xlators; do @@ -1461,6 +1457,9 @@ exit 0 %endif %changelog +* Fri Mar 15 2019 Kaleb S. KEITHLEY - 5.5-1 +- 5.5 GA + * Wed Mar 13 2019 Kaleb S. KEITHLEY - 5.4-3 - core: make compute_cksum function op_version compatible - dict: handle STR_OLD data type in xdr conversions diff --git a/sources b/sources index 876c1e9..91c698e 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (glusterfs-5.4.tar.gz) = e490bb329e72898fe8f399c73e391682c2763a3624d5cff301ba00f9160ebd720d2c18f3e878f275d535ecd32cc7a50ec17be20b4108adac2c647a3bbd4ba4b7 +SHA512 (glusterfs-5.5.tar.gz) = 8f82efc952859363dadb50d1d9e63b0a674b8044f3376688763324945335f4cbecdaf7e3cda157e682ab6ff85209f5ff6e3af8f619199124e1a1c10dddb63fd6 From 7b8979ab0984993aa43fe6636e12a11924244e2b Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Tue, 9 Apr 2019 09:12:55 -0400 Subject: [PATCH 07/14] 5.6 GA Signed-off-by: Kaleb S. KEITHLEY --- glusterfs.spec | 5 ++++- sources | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/glusterfs.spec b/glusterfs.spec index f353121..28d9b2d 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -223,7 +223,7 @@ Summary: Distributed File System %if ( 0%{_for_fedora_koji_builds} ) Name: glusterfs -Version: 5.5 +Version: 5.6 Release: %{?prereltag:0.}1%{?prereltag:.%{prereltag}}%{?dist} %else Name: @PACKAGE_NAME@ @@ -1457,6 +1457,9 @@ exit 0 %endif %changelog +* Tue Apr 9 2019 Kaleb S. KEITHLEY - 5.6-1 +- 5.6 GA + * Fri Mar 15 2019 Kaleb S. KEITHLEY - 5.5-1 - 5.5 GA diff --git a/sources b/sources index 91c698e..faabee3 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (glusterfs-5.5.tar.gz) = 8f82efc952859363dadb50d1d9e63b0a674b8044f3376688763324945335f4cbecdaf7e3cda157e682ab6ff85209f5ff6e3af8f619199124e1a1c10dddb63fd6 +SHA512 (glusterfs-5.6.tar.gz) = b64fdc795c325b16481104700b37be6435f6eeec191a7f148cf2adb3161e949c7390040d3f86d938bf46df9cbc747864f50a83041a9455ab878540adfa654f0e From 0a7164937af8c338b71c50dd5f3e4f522963ffbb Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Sat, 6 Jul 2019 09:06:56 -0400 Subject: [PATCH 08/14] 5.7 GA Signed-off-by: Kaleb S. KEITHLEY --- 0001-glupy.patch | 7464 ++++++++++++++++++++++++++++++++++++++++++++++ glusterfs.spec | 7 +- sources | 2 +- 3 files changed, 7471 insertions(+), 2 deletions(-) create mode 100644 0001-glupy.patch diff --git a/0001-glupy.patch b/0001-glupy.patch new file mode 100644 index 0000000..a2d70d5 --- /dev/null +++ b/0001-glupy.patch @@ -0,0 +1,7464 @@ +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/Makefile.am 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,3 @@ ++SUBDIRS = src examples ++ ++CLEANFILES = +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/doc/README.md 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,44 @@ ++This is just the very start for a GlusterFS[1] meta-translator that will ++allow translator code to be written in Python. It's based on the standard ++Python embedding (not extending) techniques, plus a dash of the ctypes module. ++The interface is a pretty minimal adaptation of the dispatches and callbacks ++from the C API[2] to Python, as follows: ++ ++* Dispatch functions and callbacks must be defined on an "xlator" class ++ derived from gluster.Translator so that they'll be auto-registered with ++ the C translator during initialization. ++ ++* For each dispatch or callback function you want to intercept, you define a ++ Python function using the xxx\_fop\_t or xxx\_cbk\_t decorator. ++ ++* The arguments for each operation are different, so you'll need to refer to ++ the C API. GlusterFS-specific types are used (though only loc\_t is fully ++ defined so far) and type correctness is enforced by ctypes. ++ ++* If you do intercept a dispatch function, it is your responsibility to call ++ xxx\_wind (like STACK\_WIND in the C API but operation-specific) to pass ++ the request to the next translator. If you do not intercept a function, it ++ will default the same way as for C (pass through to the same operation with ++ the same arguments on the first child translator). ++ ++* If you intercept a callback function, it is your responsibility to call ++ xxx\_unwind (like STACK\_UNWIND\_STRICT in the C API) to pass the request back ++ to the caller. ++ ++So far only the lookup and create operations are handled this way, to support ++the "negative lookup" example. Now that the basic infrastructure is in place, ++adding more functions should be very quick, though with that much boilerplate I ++might pause to write a code generator. I also plan to add structure ++definitions and interfaces for some of the utility functions in libglusterfs ++(especially those having to do with inode and fd context) in the fairly near ++future. Note that you can also use ctypes to get at anything not explicitly ++exposed to Python already. ++ ++_If you're coming here because of the Linux Journal article, please note that ++the code has evolved since that was written. The version that matches the ++article is here:_ ++ ++https://github.com/jdarcy/glupy/tree/4bbae91ba459ea46ef32f2966562492e4ca9187a ++ ++[1] http://www.gluster.org ++[2] http://pl.atyp.us/hekafs.org/dist/xlator_api_2.html +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/doc/TESTING 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,9 @@ ++Loading a translator written in Python using the glupy meta translator ++------------------------------------------------------------------------------- ++'test.vol' is a simple volfile with the debug-trace Python translator on top ++of a brick. The volfile can be mounted using the following command. ++ ++$ glusterfs --debug -f test.vol /path/to/mntpt ++ ++If then file operations are performed on the newly mounted file system, log ++output would be printed by the Python translator on the standard output. +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/doc/test.vol 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,10 @@ ++volume vol-posix ++ type storage/posix ++ option directory /path/to/brick ++end-volume ++ ++volume vol-glupy ++ type features/glupy ++ option module-name debug-trace ++ subvolumes vol-posix ++end-volume +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/examples/Makefile.am 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,5 @@ ++xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/features ++ ++glupyexamplesdir = $(xlatordir)/glupy ++ ++glupyexamples_PYTHON = negative.py helloworld.py debug-trace.py +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/examples/debug-trace.py 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,777 @@ ++ ++from __future__ import print_function ++import sys ++import stat ++from uuid import UUID ++from time import strftime, localtime ++from gluster.glupy import * ++ ++# This translator was written primarily to test the fop entry point definitions ++# and structure definitions in 'glupy.py'. ++ ++# It is similar to the C language debug-trace translator, which logs the ++# arguments passed to the fops and their corresponding cbk functions. ++ ++dl.get_id.restype = c_long ++dl.get_id.argtypes = [ POINTER(call_frame_t) ] ++ ++dl.get_rootunique.restype = c_uint64 ++dl.get_rootunique.argtypes = [ POINTER(call_frame_t) ] ++ ++def uuid2str (gfid): ++ return str(UUID(''.join(map("{0:02x}".format, gfid)))) ++ ++ ++def st_mode_from_ia (prot, filetype): ++ st_mode = 0 ++ type_bit = 0 ++ prot_bit = 0 ++ ++ if filetype == IA_IFREG: ++ type_bit = stat.S_IFREG ++ elif filetype == IA_IFDIR: ++ type_bit = stat.S_IFDIR ++ elif filetype == IA_IFLNK: ++ type_bit = stat.S_IFLNK ++ elif filetype == IA_IFBLK: ++ type_bit = stat.S_IFBLK ++ elif filetype == IA_IFCHR: ++ type_bit = stat.S_IFCHR ++ elif filetype == IA_IFIFO: ++ type_bit = stat.S_IFIFO ++ elif filetype == IA_IFSOCK: ++ type_bit = stat.S_IFSOCK ++ elif filetype == IA_INVAL: ++ pass ++ ++ ++ if prot.suid: ++ prot_bit |= stat.S_ISUID ++ if prot.sgid: ++ prot_bit |= stat.S_ISGID ++ if prot.sticky: ++ prot_bit |= stat.S_ISVTX ++ ++ if prot.owner.read: ++ prot_bit |= stat.S_IRUSR ++ if prot.owner.write: ++ prot_bit |= stat.S_IWUSR ++ if prot.owner.execn: ++ prot_bit |= stat.S_IXUSR ++ ++ if prot.group.read: ++ prot_bit |= stat.S_IRGRP ++ if prot.group.write: ++ prot_bit |= stat.S_IWGRP ++ if prot.group.execn: ++ prot_bit |= stat.S_IXGRP ++ ++ if prot.other.read: ++ prot_bit |= stat.S_IROTH ++ if prot.other.write: ++ prot_bit |= stat.S_IWOTH ++ if prot.other.execn: ++ prot_bit |= stat.S_IXOTH ++ ++ st_mode = (type_bit | prot_bit) ++ ++ return st_mode ++ ++ ++def trace_stat2str (buf): ++ gfid = uuid2str(buf.contents.ia_gfid) ++ mode = st_mode_from_ia(buf.contents.ia_prot, buf.contents.ia_type) ++ atime_buf = strftime("[%b %d %H:%M:%S]", ++ localtime(buf.contents.ia_atime)) ++ mtime_buf = strftime("[%b %d %H:%M:%S]", ++ localtime(buf.contents.ia_mtime)) ++ ctime_buf = strftime("[%b %d %H:%M:%S]", ++ localtime(buf.contents.ia_ctime)) ++ return ("(gfid={0:s}, ino={1:d}, mode={2:o}, nlink={3:d}, uid ={4:d}, "+ ++ "gid ={5:d}, size={6:d}, blocks={7:d}, atime={8:s}, mtime={9:s}, "+ ++ "ctime={10:s})").format(gfid, buf.contents.ia_no, mode, ++ buf.contents.ia_nlink, ++ buf.contents.ia_uid, ++ buf.contents.ia_gid, ++ buf.contents.ia_size, ++ buf.contents.ia_blocks, ++ atime_buf, mtime_buf, ++ ctime_buf) ++ ++class xlator(Translator): ++ ++ def __init__(self, c_this): ++ Translator.__init__(self, c_this) ++ self.gfids = {} ++ ++ def lookup_fop(self, frame, this, loc, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(loc.contents.gfid) ++ print(("GLUPY TRACE LOOKUP FOP- {0:d}: gfid={1:s}; " + ++ "path={2:s}").format(unique, gfid, loc.contents.path)) ++ self.gfids[key] = gfid ++ dl.wind_lookup(frame, POINTER(xlator_t)(), loc, xdata) ++ return 0 ++ ++ def lookup_cbk(self, frame, cookie, this, op_ret, op_errno, ++ inode, buf, xdata, postparent): ++ unique =dl.get_rootunique(frame) ++ key =dl.get_id(frame) ++ if op_ret == 0: ++ gfid = uuid2str(buf.contents.ia_gfid) ++ statstr = trace_stat2str(buf) ++ postparentstr = trace_stat2str(postparent) ++ print(("GLUPY TRACE LOOKUP CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; *buf={3:s}; " + ++ "*postparent={4:s}").format(unique, gfid, ++ op_ret, statstr, ++ postparentstr)) ++ else: ++ gfid = self.gfids[key] ++ print(("GLUPY TRACE LOOKUP CBK - {0:d}: gfid={1:s};" + ++ " op_ret={2:d}; op_errno={3:d}").format(unique, ++ gfid, ++ op_ret, ++ op_errno)) ++ del self.gfids[key] ++ dl.unwind_lookup(frame, cookie, this, op_ret, op_errno, ++ inode, buf, xdata, postparent) ++ return 0 ++ ++ def create_fop(self, frame, this, loc, flags, mode, umask, fd, ++ xdata): ++ unique = dl.get_rootunique(frame) ++ gfid = uuid2str(loc.contents.gfid) ++ print(("GLUPY TRACE CREATE FOP- {0:d}: gfid={1:s}; path={2:s}; " + ++ "fd={3:s}; flags=0{4:o}; mode=0{5:o}; " + ++ "umask=0{6:o}").format(unique, gfid, loc.contents.path, ++ fd, flags, mode, umask)) ++ dl.wind_create(frame, POINTER(xlator_t)(), loc, flags, mode, ++ umask, fd, xdata) ++ return 0 ++ ++ def create_cbk(self, frame, cookie, this, op_ret, op_errno, fd, ++ inode, buf, preparent, postparent, xdata): ++ unique = dl.get_rootunique(frame) ++ if op_ret >= 0: ++ gfid = uuid2str(inode.contents.gfid) ++ statstr = trace_stat2str(buf) ++ preparentstr = trace_stat2str(preparent) ++ postparentstr = trace_stat2str(postparent) ++ print(("GLUPY TRACE CREATE CBK- {0:d}: gfid={1:s};" + ++ " op_ret={2:d}; fd={3:s}; *stbuf={4:s}; " + ++ "*preparent={5:s};" + ++ " *postparent={6:s}").format(unique, gfid, op_ret, ++ fd, statstr, ++ preparentstr, ++ postparentstr)) ++ else: ++ print(("GLUPY TRACE CREATE CBK- {0:d}: op_ret={1:d}; " + ++ "op_errno={2:d}").format(unique, op_ret, op_errno)) ++ dl.unwind_create(frame, cookie, this, op_ret, op_errno, fd, ++ inode, buf, preparent, postparent, xdata) ++ return 0 ++ ++ def open_fop(self, frame, this, loc, flags, fd, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE OPEN FOP- {0:d}: gfid={1:s}; path={2:s}; "+ ++ "flags={3:d}; fd={4:s}").format(unique, gfid, ++ loc.contents.path, flags, ++ fd)) ++ self.gfids[key] = gfid ++ dl.wind_open(frame, POINTER(xlator_t)(), loc, flags, fd, xdata) ++ return 0 ++ ++ def open_cbk(self, frame, cookie, this, op_ret, op_errno, fd, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ print(("GLUPY TRACE OPEN CBK- {0:d}: gfid={1:s}; op_ret={2:d}; " ++ "op_errno={3:d}; *fd={4:s}").format(unique, gfid, ++ op_ret, op_errno, fd)) ++ del self.gfids[key] ++ dl.unwind_open(frame, cookie, this, op_ret, op_errno, fd, ++ xdata) ++ return 0 ++ ++ def readv_fop(self, frame, this, fd, size, offset, flags, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(fd.contents.inode.contents.gfid) ++ print(("GLUPY TRACE READV FOP- {0:d}: gfid={1:s}; "+ ++ "fd={2:s}; size ={3:d}; offset={4:d}; " + ++ "flags=0{5:x}").format(unique, gfid, fd, size, offset, ++ flags)) ++ self.gfids[key] = gfid ++ dl.wind_readv (frame, POINTER(xlator_t)(), fd, size, offset, ++ flags, xdata) ++ return 0 ++ ++ def readv_cbk(self, frame, cookie, this, op_ret, op_errno, vector, ++ count, buf, iobref, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ if op_ret >= 0: ++ statstr = trace_stat2str(buf) ++ print(("GLUPY TRACE READV CBK- {0:d}: gfid={1:s}, "+ ++ "op_ret={2:d}; *buf={3:s};").format(unique, gfid, ++ op_ret, ++ statstr)) ++ ++ else: ++ print(("GLUPY TRACE READV CBK- {0:d}: gfid={1:s}, "+ ++ "op_ret={2:d}; op_errno={3:d}").format(unique, ++ gfid, ++ op_ret, ++ op_errno)) ++ del self.gfids[key] ++ dl.unwind_readv (frame, cookie, this, op_ret, op_errno, ++ vector, count, buf, iobref, xdata) ++ return 0 ++ ++ def writev_fop(self, frame, this, fd, vector, count, offset, flags, ++ iobref, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(fd.contents.inode.contents.gfid) ++ print(("GLUPY TRACE WRITEV FOP- {0:d}: gfid={1:s}; " + ++ "fd={2:s}; count={3:d}; offset={4:d}; " + ++ "flags=0{5:x}").format(unique, gfid, fd, count, offset, ++ flags)) ++ self.gfids[key] = gfid ++ dl.wind_writev(frame, POINTER(xlator_t)(), fd, vector, count, ++ offset, flags, iobref, xdata) ++ return 0 ++ ++ def writev_cbk(self, frame, cookie, this, op_ret, op_errno, prebuf, ++ postbuf, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ if op_ret >= 0: ++ preopstr = trace_stat2str(prebuf) ++ postopstr = trace_stat2str(postbuf) ++ print(("GLUPY TRACE WRITEV CBK- {0:d}: op_ret={1:d}; " + ++ "*prebuf={2:s}; " + ++ "*postbuf={3:s}").format(unique, op_ret, preopstr, ++ postopstr)) ++ else: ++ gfid = self.gfids[key] ++ print(("GLUPY TRACE WRITEV CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; op_errno={3:d}").format(unique, ++ gfid, ++ op_ret, ++ op_errno)) ++ del self.gfids[key] ++ dl.unwind_writev (frame, cookie, this, op_ret, op_errno, ++ prebuf, postbuf, xdata) ++ return 0 ++ ++ def opendir_fop(self, frame, this, loc, fd, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE OPENDIR FOP- {0:d}: gfid={1:s}; path={2:s}; "+ ++ "fd={3:s}").format(unique, gfid, loc.contents.path, fd)) ++ self.gfids[key] = gfid ++ dl.wind_opendir(frame, POINTER(xlator_t)(), loc, fd, xdata) ++ return 0 ++ ++ def opendir_cbk(self, frame, cookie, this, op_ret, op_errno, fd, ++ xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ print(("GLUPY TRACE OPENDIR CBK- {0:d}: gfid={1:s}; op_ret={2:d};"+ ++ " op_errno={3:d}; fd={4:s}").format(unique, gfid, op_ret, ++ op_errno, fd)) ++ del self.gfids[key] ++ dl.unwind_opendir(frame, cookie, this, op_ret, op_errno, ++ fd, xdata) ++ return 0 ++ ++ def readdir_fop(self, frame, this, fd, size, offset, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(fd.contents.inode.contents.gfid) ++ print(("GLUPY TRACE READDIR FOP- {0:d}: gfid={1:s}; fd={2:s}; " + ++ "size={3:d}; offset={4:d}").format(unique, gfid, fd, size, ++ offset)) ++ self.gfids[key] = gfid ++ dl.wind_readdir(frame, POINTER(xlator_t)(), fd, size, offset, ++ xdata) ++ return 0 ++ ++ def readdir_cbk(self, frame, cookie, this, op_ret, op_errno, buf, ++ xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ print(("GLUPY TRACE READDIR CBK- {0:d}: gfid={1:s}; op_ret={2:d};"+ ++ " op_errno={3:d}").format(unique, gfid, op_ret, op_errno)) ++ del self.gfids[key] ++ dl.unwind_readdir(frame, cookie, this, op_ret, op_errno, buf, ++ xdata) ++ return 0 ++ ++ def readdirp_fop(self, frame, this, fd, size, offset, dictionary): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(fd.contents.inode.contents.gfid) ++ print(("GLUPY TRACE READDIRP FOP- {0:d}: gfid={1:s}; fd={2:s}; "+ ++ " size={3:d}; offset={4:d}").format(unique, gfid, fd, size, ++ offset)) ++ self.gfids[key] = gfid ++ dl.wind_readdirp(frame, POINTER(xlator_t)(), fd, size, offset, ++ dictionary) ++ return 0 ++ ++ def readdirp_cbk(self, frame, cookie, this, op_ret, op_errno, buf, ++ xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ print(("GLUPY TRACE READDIRP CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; op_errno={3:d}").format(unique, gfid, ++ op_ret, op_errno)) ++ del self.gfids[key] ++ dl.unwind_readdirp(frame, cookie, this, op_ret, op_errno, buf, ++ xdata) ++ return 0 ++ ++ def mkdir_fop(self, frame, this, loc, mode, umask, xdata): ++ unique = dl.get_rootunique(frame) ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE MKDIR FOP- {0:d}: gfid={1:s}; path={2:s}; " + ++ "mode={3:d}; umask=0{4:o}").format(unique, gfid, ++ loc.contents.path, mode, ++ umask)) ++ dl.wind_mkdir(frame, POINTER(xlator_t)(), loc, mode, umask, ++ xdata) ++ return 0 ++ ++ def mkdir_cbk(self, frame, cookie, this, op_ret, op_errno, inode, buf, ++ preparent, postparent, xdata): ++ unique = dl.get_rootunique(frame) ++ if op_ret == 0: ++ gfid = uuid2str(inode.contents.gfid) ++ statstr = trace_stat2str(buf) ++ preparentstr = trace_stat2str(preparent) ++ postparentstr = trace_stat2str(postparent) ++ print(("GLUPY TRACE MKDIR CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; *stbuf={3:s}; *prebuf={4:s}; "+ ++ "*postbuf={5:s} ").format(unique, gfid, op_ret, ++ statstr, ++ preparentstr, ++ postparentstr)) ++ else: ++ print(("GLUPY TRACE MKDIR CBK- {0:d}: op_ret={1:d}; "+ ++ "op_errno={2:d}").format(unique, op_ret, op_errno)) ++ dl.unwind_mkdir(frame, cookie, this, op_ret, op_errno, inode, ++ buf, preparent, postparent, xdata) ++ return 0 ++ ++ def rmdir_fop(self, frame, this, loc, flags, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE RMDIR FOP- {0:d}: gfid={1:s}; path={2:s}; "+ ++ "flags={3:d}").format(unique, gfid, loc.contents.path, ++ flags)) ++ self.gfids[key] = gfid ++ dl.wind_rmdir(frame, POINTER(xlator_t)(), loc, flags, xdata) ++ return 0 ++ ++ def rmdir_cbk(self, frame, cookie, this, op_ret, op_errno, preparent, ++ postparent, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ if op_ret == 0: ++ preparentstr = trace_stat2str(preparent) ++ postparentstr = trace_stat2str(postparent) ++ print(("GLUPY TRACE RMDIR CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; *prebuf={3:s}; "+ ++ "*postbuf={4:s}").format(unique, gfid, op_ret, ++ preparentstr, ++ postparentstr)) ++ else: ++ print(("GLUPY TRACE RMDIR CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; op_errno={3:d}").format(unique, ++ gfid, ++ op_ret, ++ op_errno)) ++ del self.gfids[key] ++ dl.unwind_rmdir(frame, cookie, this, op_ret, op_errno, ++ preparent, postparent, xdata) ++ return 0 ++ ++ def stat_fop(self, frame, this, loc, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE STAT FOP- {0:d}: gfid={1:s}; " + ++ " path={2:s}").format(unique, gfid, loc.contents.path)) ++ self.gfids[key] = gfid ++ dl.wind_stat(frame, POINTER(xlator_t)(), loc, xdata) ++ return 0 ++ ++ def stat_cbk(self, frame, cookie, this, op_ret, op_errno, buf, ++ xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ if op_ret == 0: ++ statstr = trace_stat2str(buf) ++ print(("GLUPY TRACE STAT CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; *buf={3:s};").format(unique, ++ gfid, ++ op_ret, ++ statstr)) ++ else: ++ print(("GLUPY TRACE STAT CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; op_errno={3:d}").format(unique, ++ gfid, ++ op_ret, ++ op_errno)) ++ del self.gfids[key] ++ dl.unwind_stat(frame, cookie, this, op_ret, op_errno, ++ buf, xdata) ++ return 0 ++ ++ def fstat_fop(self, frame, this, fd, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(fd.contents.inode.contents.gfid) ++ print(("GLUPY TRACE FSTAT FOP- {0:d}: gfid={1:s}; " + ++ "fd={2:s}").format(unique, gfid, fd)) ++ self.gfids[key] = gfid ++ dl.wind_fstat(frame, POINTER(xlator_t)(), fd, xdata) ++ return 0 ++ ++ def fstat_cbk(self, frame, cookie, this, op_ret, op_errno, buf, ++ xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ if op_ret == 0: ++ statstr = trace_stat2str(buf) ++ print(("GLUPY TRACE FSTAT CBK- {0:d}: gfid={1:s} "+ ++ " op_ret={2:d}; *buf={3:s}").format(unique, ++ gfid, ++ op_ret, ++ statstr)) ++ else: ++ print(("GLUPY TRACE FSTAT CBK- {0:d}: gfid={1:s} "+ ++ "op_ret={2:d}; op_errno={3:d}").format(unique. ++ gfid, ++ op_ret, ++ op_errno)) ++ del self.gfids[key] ++ dl.unwind_fstat(frame, cookie, this, op_ret, op_errno, ++ buf, xdata) ++ return 0 ++ ++ def statfs_fop(self, frame, this, loc, xdata): ++ unique = dl.get_rootunique(frame) ++ if loc.contents.inode: ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ else: ++ gfid = "0" ++ print(("GLUPY TRACE STATFS FOP- {0:d}: gfid={1:s}; "+ ++ "path={2:s}").format(unique, gfid, loc.contents.path)) ++ dl.wind_statfs(frame, POINTER(xlator_t)(), loc, xdata) ++ return 0 ++ ++ def statfs_cbk(self, frame, cookie, this, op_ret, op_errno, buf, ++ xdata): ++ unique = dl.get_rootunique(frame) ++ if op_ret == 0: ++ #TBD: print buf (pointer to an iovec type object) ++ print(("GLUPY TRACE STATFS CBK {0:d}: "+ ++ "op_ret={1:d}").format(unique, op_ret)) ++ else: ++ print(("GLUPY TRACE STATFS CBK- {0:d}"+ ++ "op_ret={1:d}; op_errno={2:d}").format(unique, ++ op_ret, ++ op_errno)) ++ dl.unwind_statfs(frame, cookie, this, op_ret, op_errno, ++ buf, xdata) ++ return 0 ++ ++ def getxattr_fop(self, frame, this, loc, name, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE GETXATTR FOP- {0:d}: gfid={1:s}; path={2:s};"+ ++ " name={3:s}").format(unique, gfid, loc.contents.path, ++ name)) ++ self.gfids[key]=gfid ++ dl.wind_getxattr(frame, POINTER(xlator_t)(), loc, name, xdata) ++ return 0 ++ ++ def getxattr_cbk(self, frame, cookie, this, op_ret, op_errno, ++ dictionary, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ print(("GLUPY TRACE GETXATTR CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; op_errno={3:d}; "+ ++ " dictionary={4:s}").format(unique, gfid, op_ret, op_errno, ++ dictionary)) ++ del self.gfids[key] ++ dl.unwind_getxattr(frame, cookie, this, op_ret, op_errno, ++ dictionary, xdata) ++ return 0 ++ ++ def fgetxattr_fop(self, frame, this, fd, name, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(fd.contents.inode.contents.gfid) ++ print(("GLUPY TRACE FGETXATTR FOP- {0:d}: gfid={1:s}; fd={2:s}; "+ ++ "name={3:s}").format(unique, gfid, fd, name)) ++ self.gfids[key] = gfid ++ dl.wind_fgetxattr(frame, POINTER(xlator_t)(), fd, name, xdata) ++ return 0 ++ ++ def fgetxattr_cbk(self, frame, cookie, this, op_ret, op_errno, ++ dictionary, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ print(("GLUPY TRACE FGETXATTR CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; op_errno={3:d};"+ ++ " dictionary={4:s}").format(unique, gfid, op_ret, ++ op_errno, dictionary)) ++ del self.gfids[key] ++ dl.unwind_fgetxattr(frame, cookie, this, op_ret, op_errno, ++ dictionary, xdata) ++ return 0 ++ ++ def setxattr_fop(self, frame, this, loc, dictionary, flags, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE SETXATTR FOP- {0:d}: gfid={1:s}; path={2:s};"+ ++ " flags={3:d}").format(unique, gfid, loc.contents.path, ++ flags)) ++ self.gfids[key] = gfid ++ dl.wind_setxattr(frame, POINTER(xlator_t)(), loc, dictionary, ++ flags, xdata) ++ return 0 ++ ++ def setxattr_cbk(self, frame, cookie, this, op_ret, op_errno, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ print(("GLUPY TRACE SETXATTR CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; op_errno={3:d}").format(unique, gfid, ++ op_ret, op_errno)) ++ del self.gfids[key] ++ dl.unwind_setxattr(frame, cookie, this, op_ret, op_errno, ++ xdata) ++ return 0 ++ ++ def fsetxattr_fop(self, frame, this, fd, dictionary, flags, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(fd.contents.inode.contents.gfid) ++ print(("GLUPY TRACE FSETXATTR FOP- {0:d}: gfid={1:s}; fd={2:p}; "+ ++ "flags={3:d}").format(unique, gfid, fd, flags)) ++ self.gfids[key] = gfid ++ dl.wind_fsetxattr(frame, POINTER(xlator_t)(), fd, dictionary, ++ flags, xdata) ++ return 0 ++ ++ def fsetxattr_cbk(self, frame, cookie, this, op_ret, op_errno, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ print(("GLUPY TRACE FSETXATTR CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; op_errno={3:d}").format(unique, gfid, ++ op_ret, op_errno)) ++ del self.gfids[key] ++ dl.unwind_fsetxattr(frame, cookie, this, op_ret, op_errno, ++ xdata) ++ return 0 ++ ++ def removexattr_fop(self, frame, this, loc, name, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE REMOVEXATTR FOP- {0:d}: gfid={1:s}; "+ ++ "path={2:s}; name={3:s}").format(unique, gfid, ++ loc.contents.path, ++ name)) ++ self.gfids[key] = gfid ++ dl.wind_removexattr(frame, POINTER(xlator_t)(), loc, name, ++ xdata) ++ return 0 ++ ++ def removexattr_cbk(self, frame, cookie, this, op_ret, op_errno, ++ xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ print(("GLUPY TRACE REMOVEXATTR CBK- {0:d}: gfid={1:s} "+ ++ " op_ret={2:d}; op_errno={3:d}").format(unique, gfid, ++ op_ret, op_errno)) ++ del self.gfids[key] ++ dl.unwind_removexattr(frame, cookie, this, op_ret, op_errno, ++ xdata) ++ return 0 ++ ++ def link_fop(self, frame, this, oldloc, newloc, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ if (newloc.contents.inode): ++ newgfid = uuid2str(newloc.contents.inode.contents.gfid) ++ else: ++ newgfid = "0" ++ oldgfid = uuid2str(oldloc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE LINK FOP-{0:d}: oldgfid={1:s}; oldpath={2:s};"+ ++ "newgfid={3:s};"+ ++ "newpath={4:s}").format(unique, oldgfid, ++ oldloc.contents.path, ++ newgfid, ++ newloc.contents.path)) ++ self.gfids[key] = oldgfid ++ dl.wind_link(frame, POINTER(xlator_t)(), oldloc, newloc, ++ xdata) ++ return 0 ++ ++ def link_cbk(self, frame, cookie, this, op_ret, op_errno, inode, buf, ++ preparent, postparent, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ if op_ret == 0: ++ statstr = trace_stat2str(buf) ++ preparentstr = trace_stat2str(preparent) ++ postparentstr = trace_stat2str(postparent) ++ print(("GLUPY TRACE LINK CBK- {0:d}: op_ret={1:d} "+ ++ "*stbuf={2:s}; *prebuf={3:s}; "+ ++ "*postbuf={4:s} ").format(unique, op_ret, statstr, ++ preparentstr, ++ postparentstr)) ++ else: ++ print(("GLUPY TRACE LINK CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; "+ ++ "op_errno={3:d}").format(unique, gfid, ++ op_ret, op_errno)) ++ del self.gfids[key] ++ dl.unwind_link(frame, cookie, this, op_ret, op_errno, inode, ++ buf, preparent, postparent, xdata) ++ return 0 ++ ++ def unlink_fop(self, frame, this, loc, xflag, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE UNLINK FOP- {0:d}; gfid={1:s}; path={2:s}; "+ ++ "flag={3:d}").format(unique, gfid, loc.contents.path, ++ xflag)) ++ self.gfids[key] = gfid ++ dl.wind_unlink(frame, POINTER(xlator_t)(), loc, xflag, ++ xdata) ++ return 0 ++ ++ def unlink_cbk(self, frame, cookie, this, op_ret, op_errno, ++ preparent, postparent, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ if op_ret == 0: ++ preparentstr = trace_stat2str(preparent) ++ postparentstr = trace_stat2str(postparent) ++ print(("GLUPY TRACE UNLINK CBK- {0:d}: gfid ={1:s}; "+ ++ "op_ret={2:d}; *prebuf={3:s}; "+ ++ "*postbuf={4:s} ").format(unique, gfid, op_ret, ++ preparentstr, ++ postparentstr)) ++ else: ++ print(("GLUPY TRACE UNLINK CBK: {0:d}: gfid ={1:s}; "+ ++ "op_ret={2:d}; "+ ++ "op_errno={3:d}").format(unique, gfid, op_ret, ++ op_errno)) ++ del self.gfids[key] ++ dl.unwind_unlink(frame, cookie, this, op_ret, op_errno, ++ preparent, postparent, xdata) ++ return 0 ++ ++ def readlink_fop(self, frame, this, loc, size, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE READLINK FOP- {0:d}: gfid={1:s}; path={2:s};"+ ++ " size={3:d}").format(unique, gfid, loc.contents.path, ++ size)) ++ self.gfids[key] = gfid ++ dl.wind_readlink(frame, POINTER(xlator_t)(), loc, size, ++ xdata) ++ return 0 ++ ++ def readlink_cbk(self, frame, cookie, this, op_ret, op_errno, ++ buf, stbuf, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ if op_ret == 0: ++ statstr = trace_stat2str(stbuf) ++ print(("GLUPY TRACE READLINK CBK- {0:d}: gfid={1:s} "+ ++ " op_ret={2:d}; op_errno={3:d}; *prebuf={4:s}; "+ ++ "*postbuf={5:s} ").format(unique, gfid, ++ op_ret, op_errno, ++ buf, statstr)) ++ else: ++ print(("GLUPY TRACE READLINK CBK- {0:d}: gfid={1:s} "+ ++ " op_ret={2:d}; op_errno={3:d}").format(unique, ++ gfid, ++ op_ret, ++ op_errno)) ++ del self.gfids[key] ++ dl.unwind_readlink(frame, cookie, this, op_ret, op_errno, buf, ++ stbuf, xdata) ++ return 0 ++ ++ def symlink_fop(self, frame, this, linkpath, loc, umask, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = uuid2str(loc.contents.inode.contents.gfid) ++ print(("GLUPY TRACE SYMLINK FOP- {0:d}: gfid={1:s}; "+ ++ "linkpath={2:s}; path={3:s};"+ ++ "umask=0{4:o}").format(unique, gfid, linkpath, ++ loc.contents.path, umask)) ++ self.gfids[key] = gfid ++ dl.wind_symlink(frame, POINTER(xlator_t)(), linkpath, loc, ++ umask, xdata) ++ return 0 ++ ++ def symlink_cbk(self, frame, cookie, this, op_ret, op_errno, ++ inode, buf, preparent, postparent, xdata): ++ unique = dl.get_rootunique(frame) ++ key = dl.get_id(frame) ++ gfid = self.gfids[key] ++ if op_ret == 0: ++ statstr = trace_stat2str(buf) ++ preparentstr = trace_stat2str(preparent) ++ postparentstr = trace_stat2str(postparent) ++ print(("GLUPY TRACE SYMLINK CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; *stbuf={3:s}; *preparent={4:s}; "+ ++ "*postparent={5:s}").format(unique, gfid, ++ op_ret, statstr, ++ preparentstr, ++ postparentstr)) ++ else: ++ print(("GLUPY TRACE SYMLINK CBK- {0:d}: gfid={1:s}; "+ ++ "op_ret={2:d}; op_errno={3:d}").format(unique, ++ gfid, ++ op_ret, ++ op_errno)) ++ del self.gfids[key] ++ dl.unwind_symlink(frame, cookie, this, op_ret, op_errno, ++ inode, buf, preparent, postparent, xdata) ++ return 0 +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/examples/helloworld.py 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,21 @@ ++ ++from __future__ import print_function ++import sys ++from gluster.glupy import * ++ ++class xlator (Translator): ++ ++ def __init__(self, c_this): ++ Translator.__init__(self, c_this) ++ ++ def lookup_fop(self, frame, this, loc, xdata): ++ print("Python xlator: Hello!") ++ dl.wind_lookup(frame, POINTER(xlator_t)(), loc, xdata) ++ return 0 ++ ++ def lookup_cbk(self, frame, cookie, this, op_ret, op_errno, inode, buf, ++ xdata, postparent): ++ print("Python xlator: Hello again!") ++ dl.unwind_lookup(frame, cookie, this, op_ret, op_errno, inode, buf, ++ xdata, postparent) ++ return 0 +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/examples/negative.py 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,93 @@ ++ ++from __future__ import print_function ++import sys ++from uuid import UUID ++from gluster.glupy import * ++ ++# Negative-lookup-caching example. If a file wasn't there the last time we ++# looked, it's probably still not there. This translator keeps track of ++# those failed lookups for us, and returns ENOENT without needing to pass the ++# call any further for repeated requests. ++ ++# If we were doing this for real, we'd need separate caches for each xlator ++# instance. The easiest way to do this would be to have xlator.__init__ ++# "register" each instance in a module-global dict, with the key as the C ++# translator address and the value as the xlator object itself. For testing ++# and teaching, it's sufficient just to have one cache. The keys are parent ++# GFIDs, and the entries are lists of names within that parent that we know ++# don't exist. ++cache = {} ++ ++# TBD: we need a better way of handling per-request data (frame->local in C). ++dl.get_id.restype = c_long ++dl.get_id.argtypes = [ POINTER(call_frame_t) ] ++ ++def uuid2str (gfid): ++ return str(UUID(''.join(map("{0:02x}".format, gfid)))) ++ ++class xlator (Translator): ++ ++ def __init__ (self, c_this): ++ self.requests = {} ++ Translator.__init__(self, c_this) ++ ++ def lookup_fop (self, frame, this, loc, xdata): ++ pargfid = uuid2str(loc.contents.pargfid) ++ print("lookup FOP: %s:%s" % (pargfid, loc.contents.name)) ++ # Check the cache. ++ if pargfid in cache: ++ if loc.contents.name in cache[pargfid]: ++ print("short-circuiting for %s:%s" % (pargfid, ++ loc.contents.name)) ++ dl.unwind_lookup(frame, 0, this, -1, 2, None, None, None, None) ++ return 0 ++ key = dl.get_id(frame) ++ self.requests[key] = (pargfid, loc.contents.name[:]) ++ # TBD: get real child xl from init, pass it here ++ dl.wind_lookup(frame, POINTER(xlator_t)(), loc, xdata) ++ return 0 ++ ++ def lookup_cbk (self, frame, cookie, this, op_ret, op_errno, inode, buf, ++ xdata, postparent): ++ print("lookup CBK: %d (%d)" % (op_ret, op_errno)) ++ key = dl.get_id(frame) ++ pargfid, name = self.requests[key] ++ # Update the cache. ++ if op_ret == 0: ++ print("found %s, removing from cache" % name) ++ if pargfid in cache: ++ cache[pargfid].discard(name) ++ elif op_errno == 2: # ENOENT ++ print("failed to find %s, adding to cache" % name) ++ if pargfid in cache: ++ cache[pargfid].add(name) ++ else: ++ cache[pargfid] = {name} ++ del self.requests[key] ++ dl.unwind_lookup(frame, cookie, this, op_ret, op_errno, ++ inode, buf, xdata, postparent) ++ return 0 ++ ++ def create_fop (self, frame, this, loc, flags, mode, umask, fd, xdata): ++ pargfid = uuid2str(loc.contents.pargfid) ++ print("create FOP: %s:%s" % (pargfid, loc.contents.name)) ++ key = dl.get_id(frame) ++ self.requests[key] = (pargfid, loc.contents.name[:]) ++ # TBD: get real child xl from init, pass it here ++ dl.wind_create(frame, POINTER(xlator_t)(), loc, flags, mode, umask, fd, xdata) ++ return 0 ++ ++ def create_cbk (self, frame, cookie, this, op_ret, op_errno, fd, inode, ++ buf, preparent, postparent, xdata): ++ print("create CBK: %d (%d)" % (op_ret, op_errno)) ++ key = dl.get_id(frame) ++ pargfid, name = self.requests[key] ++ # Update the cache. ++ if op_ret == 0: ++ print("created %s, removing from cache" % name) ++ if pargfid in cache: ++ cache[pargfid].discard(name) ++ del self.requests[key] ++ dl.unwind_create(frame, cookie, this, op_ret, op_errno, fd, inode, buf, ++ preparent, postparent, xdata) ++ return 0 +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/examples/Makefile.in 2019-07-06 08:50:36.977965653 -0400 +@@ -0,0 +1,622 @@ ++# Makefile.in generated by automake 1.13.4 from Makefile.am. ++# @configure_input@ ++ ++# Copyright (C) 1994-2013 Free Software Foundation, Inc. ++ ++# This Makefile.in is free software; the Free Software Foundation ++# gives unlimited permission to copy and/or distribute it, ++# with or without modifications, as long as this notice is preserved. ++ ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY, to the extent permitted by law; without ++# even the implied warranty of MERCHANTABILITY or FITNESS FOR A ++# PARTICULAR PURPOSE. ++ ++@SET_MAKE@ ++VPATH = @srcdir@ ++am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' ++am__make_running_with_option = \ ++ case $${target_option-} in \ ++ ?) ;; \ ++ *) echo "am__make_running_with_option: internal error: invalid" \ ++ "target option '$${target_option-}' specified" >&2; \ ++ exit 1;; \ ++ esac; \ ++ has_opt=no; \ ++ sane_makeflags=$$MAKEFLAGS; \ ++ if $(am__is_gnu_make); then \ ++ sane_makeflags=$$MFLAGS; \ ++ else \ ++ case $$MAKEFLAGS in \ ++ *\\[\ \ ]*) \ ++ bs=\\; \ ++ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ ++ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ ++ esac; \ ++ fi; \ ++ skip_next=no; \ ++ strip_trailopt () \ ++ { \ ++ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ ++ }; \ ++ for flg in $$sane_makeflags; do \ ++ test $$skip_next = yes && { skip_next=no; continue; }; \ ++ case $$flg in \ ++ *=*|--*) continue;; \ ++ -*I) strip_trailopt 'I'; skip_next=yes;; \ ++ -*I?*) strip_trailopt 'I';; \ ++ -*O) strip_trailopt 'O'; skip_next=yes;; \ ++ -*O?*) strip_trailopt 'O';; \ ++ -*l) strip_trailopt 'l'; skip_next=yes;; \ ++ -*l?*) strip_trailopt 'l';; \ ++ -[dEDm]) skip_next=yes;; \ ++ -[JT]) skip_next=yes;; \ ++ esac; \ ++ case $$flg in \ ++ *$$target_option*) has_opt=yes; break;; \ ++ esac; \ ++ done; \ ++ test $$has_opt = yes ++am__make_dryrun = (target_option=n; $(am__make_running_with_option)) ++am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) ++pkgdatadir = $(datadir)/@PACKAGE@ ++pkgincludedir = $(includedir)/@PACKAGE@ ++pkglibdir = $(libdir)/@PACKAGE@ ++pkglibexecdir = $(libexecdir)/@PACKAGE@ ++am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd ++install_sh_DATA = $(install_sh) -c -m 644 ++install_sh_PROGRAM = $(install_sh) -c ++install_sh_SCRIPT = $(install_sh) -c ++INSTALL_HEADER = $(INSTALL_DATA) ++transform = $(program_transform_name) ++NORMAL_INSTALL = : ++PRE_INSTALL = : ++POST_INSTALL = : ++NORMAL_UNINSTALL = : ++PRE_UNINSTALL = : ++POST_UNINSTALL = : ++build_triplet = @build@ ++host_triplet = @host@ ++subdir = xlators/features/glupy/examples ++DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ ++ $(glupyexamples_PYTHON) $(top_srcdir)/py-compile ++ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 ++am__aclocal_m4_deps = $(top_srcdir)/contrib/aclocal/mkdirp.m4 \ ++ $(top_srcdir)/contrib/aclocal/python.m4 \ ++ $(top_srcdir)/configure.ac ++am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ ++ $(ACLOCAL_M4) ++mkinstalldirs = $(install_sh) -d ++CONFIG_HEADER = $(top_builddir)/config.h $(top_builddir)/site.h ++CONFIG_CLEAN_FILES = ++CONFIG_CLEAN_VPATH_FILES = ++AM_V_P = $(am__v_P_@AM_V@) ++am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) ++am__v_P_0 = false ++am__v_P_1 = : ++AM_V_GEN = $(am__v_GEN_@AM_V@) ++am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) ++am__v_GEN_0 = @echo " GEN " $@; ++am__v_GEN_1 = ++AM_V_at = $(am__v_at_@AM_V@) ++am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) ++am__v_at_0 = @ ++am__v_at_1 = ++SOURCES = ++DIST_SOURCES = ++am__can_run_installinfo = \ ++ case $$AM_UPDATE_INFO_DIR in \ ++ n|no|NO) false;; \ ++ *) (install-info --version) >/dev/null 2>&1;; \ ++ esac ++am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; ++am__vpath_adj = case $$p in \ ++ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ ++ *) f=$$p;; \ ++ esac; ++am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; ++am__install_max = 40 ++am__nobase_strip_setup = \ ++ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` ++am__nobase_strip = \ ++ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" ++am__nobase_list = $(am__nobase_strip_setup); \ ++ for p in $$list; do echo "$$p $$p"; done | \ ++ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ ++ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ ++ if (++n[$$2] == $(am__install_max)) \ ++ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ ++ END { for (dir in files) print dir, files[dir] }' ++am__base_list = \ ++ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ ++ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' ++am__uninstall_files_from_dir = { \ ++ test -z "$$files" \ ++ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ ++ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ ++ $(am__cd) "$$dir" && rm -f $$files; }; \ ++ } ++am__py_compile = PYTHON=$(PYTHON) $(SHELL) $(py_compile) ++am__installdirs = "$(DESTDIR)$(glupyexamplesdir)" ++am__pep3147_tweak = \ ++ sed -e 's|\.py$$||' -e 's|[^/]*$$|__pycache__/&.*.py|' ++py_compile = $(top_srcdir)/py-compile ++am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) ++DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ++ACLOCAL = @ACLOCAL@ ++ACL_LIBS = @ACL_LIBS@ ++AMTAR = @AMTAR@ ++AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ ++AM_LIBTOOLFLAGS = @AM_LIBTOOLFLAGS@ ++AM_MAKEFLAGS = @AM_MAKEFLAGS@ ++AR = @AR@ ++ARGP_LDADD = @ARGP_LDADD@ ++AUTOCONF = @AUTOCONF@ ++AUTOHEADER = @AUTOHEADER@ ++AUTOMAKE = @AUTOMAKE@ ++AWK = @AWK@ ++BUILD_PYTHON_SITE_PACKAGES = @BUILD_PYTHON_SITE_PACKAGES@ ++BUILD_PYTHON_SITE_PACKAGES_EXPANDED = @BUILD_PYTHON_SITE_PACKAGES_EXPANDED@ ++CC = @CC@ ++CCDEPMODE = @CCDEPMODE@ ++CFLAGS = @CFLAGS@ ++CONTRIBDIR = @CONTRIBDIR@ ++CPP = @CPP@ ++CPPFLAGS = @CPPFLAGS@ ++CYGPATH_W = @CYGPATH_W@ ++DEFS = @DEFS@ ++DEPDIR = @DEPDIR@ ++DLLTOOL = @DLLTOOL@ ++DSYMUTIL = @DSYMUTIL@ ++DUMPBIN = @DUMPBIN@ ++ECHO_C = @ECHO_C@ ++ECHO_N = @ECHO_N@ ++ECHO_T = @ECHO_T@ ++EGREP = @EGREP@ ++EVENTS_ENABLED = @EVENTS_ENABLED@ ++EVENTS_SUBDIR = @EVENTS_SUBDIR@ ++EXEEXT = @EXEEXT@ ++FGREP = @FGREP@ ++FUSERMOUNT_SUBDIR = @FUSERMOUNT_SUBDIR@ ++FUSE_CLIENT_SUBDIR = @FUSE_CLIENT_SUBDIR@ ++GEOREP_EXTRAS_SUBDIR = @GEOREP_EXTRAS_SUBDIR@ ++GFAPI_EXTRA_LDFLAGS = @GFAPI_EXTRA_LDFLAGS@ ++GFAPI_LIBS = @GFAPI_LIBS@ ++GFAPI_LT_VERSION = @GFAPI_LT_VERSION@ ++GFAPI_VERSION = @GFAPI_VERSION@ ++GF_CFLAGS = @GF_CFLAGS@ ++GF_CPPFLAGS = @GF_CPPFLAGS@ ++GF_DISTRIBUTION = @GF_DISTRIBUTION@ ++GF_FUSE_CFLAGS = @GF_FUSE_CFLAGS@ ++GF_FUSE_LDADD = @GF_FUSE_LDADD@ ++GF_HOST_OS = @GF_HOST_OS@ ++GF_LDADD = @GF_LDADD@ ++GF_LDFLAGS = @GF_LDFLAGS@ ++GF_NO_UNDEFINED = @GF_NO_UNDEFINED@ ++GF_XLATOR_DEFAULT_LDFLAGS = @GF_XLATOR_DEFAULT_LDFLAGS@ ++GF_XLATOR_LDFLAGS = @GF_XLATOR_LDFLAGS@ ++GLUPY_SUBDIR = @GLUPY_SUBDIR@ ++GLUPY_SUBDIR_MAKEFILE = @GLUPY_SUBDIR_MAKEFILE@ ++GLUPY_SUBDIR_SRC_MAKEFILE = @GLUPY_SUBDIR_SRC_MAKEFILE@ ++GLUSTERD_VOLFILE = @GLUSTERD_VOLFILE@ ++GLUSTERD_WORKDIR = @GLUSTERD_WORKDIR@ ++GLUSTERFSD_MISCDIR = @GLUSTERFSD_MISCDIR@ ++GLUSTERFS_LIBEXECDIR = @GLUSTERFS_LIBEXECDIR@ ++GREP = @GREP@ ++HAVE_ATOMIC_BUILTINS = @HAVE_ATOMIC_BUILTINS@ ++HAVE_BACKTRACE = @HAVE_BACKTRACE@ ++HAVE_LINKAT = @HAVE_LINKAT@ ++HAVE_MALLOC_STATS = @HAVE_MALLOC_STATS@ ++HAVE_SPINLOCK = @HAVE_SPINLOCK@ ++HAVE_STRNLEN = @HAVE_STRNLEN@ ++HAVE_SYNC_BUILTINS = @HAVE_SYNC_BUILTINS@ ++IBVERBS_SUBDIR = @IBVERBS_SUBDIR@ ++INSTALL = @INSTALL@ ++INSTALL_DATA = @INSTALL_DATA@ ++INSTALL_PROGRAM = @INSTALL_PROGRAM@ ++INSTALL_SCRIPT = @INSTALL_SCRIPT@ ++INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ ++LD = @LD@ ++LDFLAGS = @LDFLAGS@ ++LEX = @LEX@ ++LEXLIB = @LEXLIB@ ++LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ ++LIBAIO = @LIBAIO@ ++LIBGFCHANGELOG_LT_VERSION = @LIBGFCHANGELOG_LT_VERSION@ ++LIBGFCHANGELOG_VERSION = @LIBGFCHANGELOG_VERSION@ ++LIBGFDB_VERSION = @LIBGFDB_VERSION@ ++LIBGFRPC_LT_VERSION = @LIBGFRPC_LT_VERSION@ ++LIBGFXDR_LT_VERSION = @LIBGFXDR_LT_VERSION@ ++LIBGLUSTERFS_LT_VERSION = @LIBGLUSTERFS_LT_VERSION@ ++LIBOBJS = @LIBOBJS@ ++LIBS = @LIBS@ ++LIBTOOL = @LIBTOOL@ ++LIB_DL = @LIB_DL@ ++LIPO = @LIPO@ ++LN_S = @LN_S@ ++LTLIBOBJS = @LTLIBOBJS@ ++MAKEINFO = @MAKEINFO@ ++MANIFEST_TOOL = @MANIFEST_TOOL@ ++MATH_LIB = @MATH_LIB@ ++MKDIR_P = @MKDIR_P@ ++NM = @NM@ ++NMEDIT = @NMEDIT@ ++OBJDUMP = @OBJDUMP@ ++OBJEXT = @OBJEXT@ ++OCF_SUBDIR = @OCF_SUBDIR@ ++OTOOL = @OTOOL@ ++OTOOL64 = @OTOOL64@ ++PACKAGE = @PACKAGE@ ++PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ ++PACKAGE_NAME = @PACKAGE_NAME@ ++PACKAGE_RELEASE = @PACKAGE_RELEASE@ ++PACKAGE_STRING = @PACKAGE_STRING@ ++PACKAGE_TARNAME = @PACKAGE_TARNAME@ ++PACKAGE_URL = @PACKAGE_URL@ ++PACKAGE_VERSION = @PACKAGE_VERSION@ ++PATH_SEPARATOR = @PATH_SEPARATOR@ ++PKGCONFIG_UUID = @PKGCONFIG_UUID@ ++PKG_CONFIG = @PKG_CONFIG@ ++PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ ++PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ ++PYTHON = @PYTHON@ ++PYTHON_CFLAGS = @PYTHON_CFLAGS@ ++PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ ++PYTHON_LIBS = @PYTHON_LIBS@ ++PYTHON_PLATFORM = @PYTHON_PLATFORM@ ++PYTHON_PREFIX = @PYTHON_PREFIX@ ++PYTHON_VERSION = @PYTHON_VERSION@ ++RANLIB = @RANLIB@ ++RDMA_SUBDIR = @RDMA_SUBDIR@ ++RLLIBS = @RLLIBS@ ++RPCGEN = @RPCGEN@ ++SBIN_DIR = @SBIN_DIR@ ++SED = @SED@ ++SET_MAKE = @SET_MAKE@ ++SHELL = @SHELL@ ++SIZEOF_INT = @SIZEOF_INT@ ++SIZEOF_LONG = @SIZEOF_LONG@ ++SIZEOF_LONG_LONG = @SIZEOF_LONG_LONG@ ++SIZEOF_SHORT = @SIZEOF_SHORT@ ++SQLITE_CFLAGS = @SQLITE_CFLAGS@ ++SQLITE_LIBS = @SQLITE_LIBS@ ++STRIP = @STRIP@ ++SYNCDAEMON_COMPILE = @SYNCDAEMON_COMPILE@ ++SYNCDAEMON_SUBDIR = @SYNCDAEMON_SUBDIR@ ++SYSCONF_DIR = @SYSCONF_DIR@ ++TIRPC_CFLAGS = @TIRPC_CFLAGS@ ++TIRPC_LIBS = @TIRPC_LIBS@ ++UMOUNTD_SUBDIR = @UMOUNTD_SUBDIR@ ++UNITTEST_CFLAGS = @UNITTEST_CFLAGS@ ++UNITTEST_LDFLAGS = @UNITTEST_LDFLAGS@ ++UNITTEST_LIBS = @UNITTEST_LIBS@ ++URCU_CDS_CFLAGS = @URCU_CDS_CFLAGS@ ++URCU_CDS_LIBS = @URCU_CDS_LIBS@ ++URCU_CFLAGS = @URCU_CFLAGS@ ++URCU_LIBS = @URCU_LIBS@ ++USE_EC_DYNAMIC_AVX = @USE_EC_DYNAMIC_AVX@ ++USE_EC_DYNAMIC_NEON = @USE_EC_DYNAMIC_NEON@ ++USE_EC_DYNAMIC_SSE = @USE_EC_DYNAMIC_SSE@ ++USE_EC_DYNAMIC_X64 = @USE_EC_DYNAMIC_X64@ ++USE_POSIX_ACLS = @USE_POSIX_ACLS@ ++UUID_CFLAGS = @UUID_CFLAGS@ ++UUID_LIBS = @UUID_LIBS@ ++VERSION = @VERSION@ ++XML_CFLAGS = @XML_CFLAGS@ ++XML_LIBS = @XML_LIBS@ ++YACC = @YACC@ ++YFLAGS = @YFLAGS@ ++ZLIB_CFLAGS = @ZLIB_CFLAGS@ ++ZLIB_LIBS = @ZLIB_LIBS@ ++abs_builddir = @abs_builddir@ ++abs_srcdir = @abs_srcdir@ ++abs_top_builddir = @abs_top_builddir@ ++abs_top_srcdir = @abs_top_srcdir@ ++ac_ct_AR = @ac_ct_AR@ ++ac_ct_CC = @ac_ct_CC@ ++ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ ++am__include = @am__include@ ++am__leading_dot = @am__leading_dot@ ++am__quote = @am__quote@ ++am__tar = @am__tar@ ++am__untar = @am__untar@ ++bindir = @bindir@ ++build = @build@ ++build_alias = @build_alias@ ++build_cpu = @build_cpu@ ++build_os = @build_os@ ++build_vendor = @build_vendor@ ++builddir = @builddir@ ++datadir = @datadir@ ++datarootdir = @datarootdir@ ++docdir = @docdir@ ++dvidir = @dvidir@ ++exec_prefix = @exec_prefix@ ++host = @host@ ++host_alias = @host_alias@ ++host_cpu = @host_cpu@ ++host_os = @host_os@ ++host_vendor = @host_vendor@ ++htmldir = @htmldir@ ++includedir = @includedir@ ++infodir = @infodir@ ++initdir = @initdir@ ++install_sh = @install_sh@ ++launchddir = @launchddir@ ++libdir = @libdir@ ++libexecdir = @libexecdir@ ++localedir = @localedir@ ++localstatedir = @localstatedir@ ++mandir = @mandir@ ++mkdir_p = @mkdir_p@ ++mountutildir = @mountutildir@ ++oldincludedir = @oldincludedir@ ++pdfdir = @pdfdir@ ++pkgconfigdir = @pkgconfigdir@ ++pkgpyexecdir = @pkgpyexecdir@ ++pkgpythondir = @pkgpythondir@ ++prefix = @prefix@ ++program_transform_name = @program_transform_name@ ++psdir = @psdir@ ++pyexecdir = @pyexecdir@ ++pythondir = @pythondir@ ++sbindir = @sbindir@ ++sharedstatedir = @sharedstatedir@ ++shrext_cmds = @shrext_cmds@ ++srcdir = @srcdir@ ++sysconfdir = @sysconfdir@ ++systemddir = @systemddir@ ++target_alias = @target_alias@ ++tmpfilesdir = @tmpfilesdir@ ++top_build_prefix = @top_build_prefix@ ++top_builddir = @top_builddir@ ++top_srcdir = @top_srcdir@ ++xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/features ++glupyexamplesdir = $(xlatordir)/glupy ++glupyexamples_PYTHON = negative.py helloworld.py debug-trace.py ++all: all-am ++ ++.SUFFIXES: ++$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) ++ @for dep in $?; do \ ++ case '$(am__configure_deps)' in \ ++ *$$dep*) \ ++ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ ++ && { if test -f $@; then exit 0; else break; fi; }; \ ++ exit 1;; \ ++ esac; \ ++ done; \ ++ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign xlators/features/glupy/examples/Makefile'; \ ++ $(am__cd) $(top_srcdir) && \ ++ $(AUTOMAKE) --foreign xlators/features/glupy/examples/Makefile ++.PRECIOUS: Makefile ++Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status ++ @case '$?' in \ ++ *config.status*) \ ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ ++ *) \ ++ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ ++ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ ++ esac; ++ ++$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++ ++$(top_srcdir)/configure: $(am__configure_deps) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++$(ACLOCAL_M4): $(am__aclocal_m4_deps) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++$(am__aclocal_m4_deps): ++ ++mostlyclean-libtool: ++ -rm -f *.lo ++ ++clean-libtool: ++ -rm -rf .libs _libs ++install-glupyexamplesPYTHON: $(glupyexamples_PYTHON) ++ @$(NORMAL_INSTALL) ++ @list='$(glupyexamples_PYTHON)'; dlist=; list2=; test -n "$(glupyexamplesdir)" || list=; \ ++ if test -n "$$list"; then \ ++ echo " $(MKDIR_P) '$(DESTDIR)$(glupyexamplesdir)'"; \ ++ $(MKDIR_P) "$(DESTDIR)$(glupyexamplesdir)" || exit 1; \ ++ fi; \ ++ for p in $$list; do \ ++ if test -f "$$p"; then b=; else b="$(srcdir)/"; fi; \ ++ if test -f $$b$$p; then \ ++ $(am__strip_dir) \ ++ dlist="$$dlist $$f"; \ ++ list2="$$list2 $$b$$p"; \ ++ else :; fi; \ ++ done; \ ++ for file in $$list2; do echo $$file; done | $(am__base_list) | \ ++ while read files; do \ ++ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(glupyexamplesdir)'"; \ ++ $(INSTALL_DATA) $$files "$(DESTDIR)$(glupyexamplesdir)" || exit $$?; \ ++ done || exit $$?; \ ++ if test -n "$$dlist"; then \ ++ $(am__py_compile) --destdir "$(DESTDIR)" \ ++ --basedir "$(glupyexamplesdir)" $$dlist; \ ++ else :; fi ++ ++uninstall-glupyexamplesPYTHON: ++ @$(NORMAL_UNINSTALL) ++ @list='$(glupyexamples_PYTHON)'; test -n "$(glupyexamplesdir)" || list=; \ ++ py_files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ ++ test -n "$$py_files" || exit 0; \ ++ dir='$(DESTDIR)$(glupyexamplesdir)'; \ ++ pyc_files=`echo "$$py_files" | sed 's|$$|c|'`; \ ++ pyo_files=`echo "$$py_files" | sed 's|$$|o|'`; \ ++ py_files_pep3147=`echo "$$py_files" | $(am__pep3147_tweak)`; \ ++ echo "$$py_files_pep3147";\ ++ pyc_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|c|'`; \ ++ pyo_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|o|'`; \ ++ st=0; \ ++ for files in \ ++ "$$py_files" \ ++ "$$pyc_files" \ ++ "$$pyo_files" \ ++ "$$pyc_files_pep3147" \ ++ "$$pyo_files_pep3147" \ ++ ; do \ ++ $(am__uninstall_files_from_dir) || st=$$?; \ ++ done; \ ++ exit $$st ++tags TAGS: ++ ++ctags CTAGS: ++ ++cscope cscopelist: ++ ++ ++distdir: $(DISTFILES) ++ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ ++ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ ++ list='$(DISTFILES)'; \ ++ dist_files=`for file in $$list; do echo $$file; done | \ ++ sed -e "s|^$$srcdirstrip/||;t" \ ++ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ ++ case $$dist_files in \ ++ */*) $(MKDIR_P) `echo "$$dist_files" | \ ++ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ ++ sort -u` ;; \ ++ esac; \ ++ for file in $$dist_files; do \ ++ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ ++ if test -d $$d/$$file; then \ ++ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ ++ if test -d "$(distdir)/$$file"; then \ ++ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ ++ fi; \ ++ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ ++ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ ++ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ ++ fi; \ ++ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ ++ else \ ++ test -f "$(distdir)/$$file" \ ++ || cp -p $$d/$$file "$(distdir)/$$file" \ ++ || exit 1; \ ++ fi; \ ++ done ++check-am: all-am ++check: check-am ++all-am: Makefile ++installdirs: ++ for dir in "$(DESTDIR)$(glupyexamplesdir)"; do \ ++ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ ++ done ++install: install-am ++install-exec: install-exec-am ++install-data: install-data-am ++uninstall: uninstall-am ++ ++install-am: all-am ++ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am ++ ++installcheck: installcheck-am ++install-strip: ++ if test -z '$(STRIP)'; then \ ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ ++ install; \ ++ else \ ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ ++ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ ++ fi ++mostlyclean-generic: ++ ++clean-generic: ++ ++distclean-generic: ++ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) ++ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) ++ ++maintainer-clean-generic: ++ @echo "This command is intended for maintainers to use" ++ @echo "it deletes files that may require special tools to rebuild." ++clean: clean-am ++ ++clean-am: clean-generic clean-libtool mostlyclean-am ++ ++distclean: distclean-am ++ -rm -f Makefile ++distclean-am: clean-am distclean-generic ++ ++dvi: dvi-am ++ ++dvi-am: ++ ++html: html-am ++ ++html-am: ++ ++info: info-am ++ ++info-am: ++ ++install-data-am: install-glupyexamplesPYTHON ++ ++install-dvi: install-dvi-am ++ ++install-dvi-am: ++ ++install-exec-am: ++ ++install-html: install-html-am ++ ++install-html-am: ++ ++install-info: install-info-am ++ ++install-info-am: ++ ++install-man: ++ ++install-pdf: install-pdf-am ++ ++install-pdf-am: ++ ++install-ps: install-ps-am ++ ++install-ps-am: ++ ++installcheck-am: ++ ++maintainer-clean: maintainer-clean-am ++ -rm -f Makefile ++maintainer-clean-am: distclean-am maintainer-clean-generic ++ ++mostlyclean: mostlyclean-am ++ ++mostlyclean-am: mostlyclean-generic mostlyclean-libtool ++ ++pdf: pdf-am ++ ++pdf-am: ++ ++ps: ps-am ++ ++ps-am: ++ ++uninstall-am: uninstall-glupyexamplesPYTHON ++ ++.MAKE: install-am install-strip ++ ++.PHONY: all all-am check check-am clean clean-generic clean-libtool \ ++ cscopelist-am ctags-am distclean distclean-generic \ ++ distclean-libtool distdir dvi dvi-am html html-am info info-am \ ++ install install-am install-data install-data-am install-dvi \ ++ install-dvi-am install-exec install-exec-am \ ++ install-glupyexamplesPYTHON install-html install-html-am \ ++ install-info install-info-am install-man install-pdf \ ++ install-pdf-am install-ps install-ps-am install-strip \ ++ installcheck installcheck-am installdirs maintainer-clean \ ++ maintainer-clean-generic mostlyclean mostlyclean-generic \ ++ mostlyclean-libtool pdf pdf-am ps ps-am tags-am uninstall \ ++ uninstall-am uninstall-glupyexamplesPYTHON ++ ++ ++# Tell versions [3.59,3.63) of GNU make to not export all variables. ++# Otherwise a system limit (for SysV at least) may be exceeded. ++.NOEXPORT: +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/src/Makefile.am 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,36 @@ ++xlator_LTLIBRARIES = glupy.la ++ ++# Ensure GLUSTER_PYTHON_PATH is passed to glupy.so ++xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/features ++glupydir = $(xlatordir)/glupy ++ ++AM_CPPFLAGS = $(GF_CPPFLAGS) \ ++ -I$(top_srcdir)/libglusterfs/src \ ++ -I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src ++ ++AM_CFLAGS = -Wall -fno-strict-aliasing \ ++ -DGLUSTER_PYTHON_PATH=\"$(glupydir)\" \ ++ -DPATH_GLUSTERFS_GLUPY_MODULE=\"${xlatordir}/glupy${shrext_cmds}\" \ ++ $(GF_CFLAGS) $(PYTHON_CFLAGS) ++ ++# Flags to build glupy.so with ++glupy_la_LDFLAGS = -module -nostartfiles \ ++ -export-symbols $(top_srcdir)/xlators/features/glupy/src/glupy.sym \ ++ $(GF_XLATOR_LDFLAGS) $(PYTHON_LIBS) ++ ++glupy_la_SOURCES = glupy.c ++glupy_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \ ++ -lpthread $(LIB_DL) ++ ++noinst_HEADERS = glupy.h ++ ++# Install __init__.py into the Python site-packages area ++pyglupydir = @BUILD_PYTHON_SITE_PACKAGES@/gluster ++pyglupy_PYTHON = __init__.py ++ ++# Install glupy/__init_-.py into the Python site-packages area ++SUBDIRS = glupy ++ ++CLEANFILES = ++ ++EXTRA_DIST = glupy.sym +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/src/__init__.py.in 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,4 @@ ++#!/usr/bin/python3 ++ ++from pkgutil import extend_path ++__path__ = extend_path(__path__, __name__) +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/src/glupy.c 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,2446 @@ ++/* ++ Copyright (c) 2006-2014 Red Hat, Inc. ++ This file is part of GlusterFS. ++ ++ This file is licensed to you under your choice of the GNU Lesser ++ General Public License, version 3 or any later version (LGPLv3 or ++ later), or the GNU General Public License, version 2 (GPLv2), in all ++ cases as published by the Free Software Foundation. ++*/ ++ ++#include ++#include ++#include ++#include ++ ++#include "glusterfs.h" ++#include "xlator.h" ++#include "logging.h" ++#include "defaults.h" ++ ++#include "glupy.h" ++ ++/* UTILITY FUNCTIONS FOR FOP-SPECIFIC CODE */ ++ ++pthread_key_t gil_init_key; ++ ++PyGILState_STATE ++glupy_enter(void) ++{ ++ if (!pthread_getspecific(gil_init_key)) { ++ PyEval_ReleaseLock(); ++ (void)pthread_setspecific(gil_init_key, (void *)1); ++ } ++ ++ return PyGILState_Ensure(); ++} ++ ++void ++glupy_leave(PyGILState_STATE gstate) ++{ ++ PyGILState_Release(gstate); ++} ++ ++/* FOP: LOOKUP */ ++ ++int32_t ++glupy_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, inode_t *inode, ++ struct iatt *buf, dict_t *xdata, struct iatt *postparent) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_LOOKUP]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_lookup_cbk_t)(priv->cbks[GLUPY_LOOKUP]))( ++ frame, cookie, this, op_ret, op_errno, inode, buf, xdata, postparent); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, xdata, ++ postparent); ++ return 0; ++} ++ ++int32_t ++glupy_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_LOOKUP]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_lookup_t)(priv->fops[GLUPY_LOOKUP]))(frame, this, loc, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_lookup_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->lookup, loc, xdata); ++ return 0; ++} ++ ++void ++wind_lookup(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_lookup_cbk, xl, xl->fops->lookup, loc, xdata); ++} ++ ++void ++unwind_lookup(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata, ++ struct iatt *postparent) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, xdata, ++ postparent); ++} ++ ++void ++set_lookup_fop(long py_this, fop_lookup_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_LOOKUP] = (long)fop; ++} ++ ++void ++set_lookup_cbk(long py_this, fop_lookup_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_LOOKUP] = (long)cbk; ++} ++ ++/* FOP: CREATE */ ++ ++int32_t ++glupy_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, ++ struct iatt *buf, struct iatt *preparent, ++ struct iatt *postparent, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_CREATE]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_create_cbk_t)(priv->cbks[GLUPY_CREATE]))( ++ frame, cookie, this, op_ret, op_errno, fd, inode, buf, preparent, ++ postparent, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, buf, ++ preparent, postparent, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, ++ mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_CREATE]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_create_t)(priv->fops[GLUPY_CREATE]))(frame, this, loc, flags, ++ mode, umask, fd, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_create_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd, ++ xdata); ++ return 0; ++} ++ ++void ++wind_create(call_frame_t *frame, xlator_t *xl, loc_t *loc, int32_t flags, ++ mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_create_cbk, xl, xl->fops->create, loc, flags, mode, ++ umask, fd, xdata); ++} ++ ++void ++unwind_create(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, fd_t *fd, inode_t *inode, struct iatt *buf, ++ struct iatt *preparent, struct iatt *postparent, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, buf, ++ preparent, postparent, xdata); ++} ++ ++void ++set_create_fop(long py_this, fop_create_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_CREATE] = (long)fop; ++} ++ ++void ++set_create_cbk(long py_this, fop_create_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_CREATE] = (long)cbk; ++} ++ ++/* FOP: OPEN */ ++ ++int32_t ++glupy_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_OPEN]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_open_cbk_t)(priv->cbks[GLUPY_OPEN]))( ++ frame, cookie, this, op_ret, op_errno, fd, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, ++ fd_t *fd, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_OPEN]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_open_t)(priv->fops[GLUPY_OPEN]))(frame, this, loc, flags, fd, ++ xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_open_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata); ++ return 0; ++} ++ ++void ++wind_open(call_frame_t *frame, xlator_t *xl, loc_t *loc, int32_t flags, ++ fd_t *fd, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_open_cbk, xl, xl->fops->open, loc, flags, fd, ++ xdata); ++} ++ ++void ++unwind_open(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, fd_t *fd, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, xdata); ++} ++ ++void ++set_open_fop(long py_this, fop_open_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ priv->fops[GLUPY_OPEN] = (long)fop; ++} ++ ++void ++set_open_cbk(long py_this, fop_open_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ priv->cbks[GLUPY_OPEN] = (long)cbk; ++} ++ ++/* FOP: READV */ ++ ++int32_t ++glupy_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, struct iovec *vector, ++ int32_t count, struct iatt *stbuf, struct iobref *iobref, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_READV]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_readv_cbk_t)(priv->cbks[GLUPY_READV]))( ++ frame, cookie, this, op_ret, op_errno, vector, count, stbuf, iobref, ++ xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, stbuf, ++ iobref, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, ++ off_t offset, uint32_t flags, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_READV]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_readv_t)(priv->fops[GLUPY_READV]))(frame, this, fd, size, ++ offset, flags, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_readv_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, xdata); ++ return 0; ++} ++ ++void ++wind_readv(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size, ++ off_t offset, uint32_t flags, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_readv_cbk, xl, xl->fops->readv, fd, size, offset, ++ flags, xdata); ++} ++ ++void ++unwind_readv(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, struct iovec *vector, int32_t count, ++ struct iatt *stbuf, struct iobref *iobref, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, stbuf, ++ iobref, xdata); ++} ++ ++void ++set_readv_fop(long py_this, fop_readv_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ priv->fops[GLUPY_READV] = (long)fop; ++} ++ ++void ++set_readv_cbk(long py_this, fop_readv_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ priv->cbks[GLUPY_READV] = (long)cbk; ++} ++ ++/* FOP: WRITEV */ ++ ++int32_t ++glupy_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, struct iatt *prebuf, ++ struct iatt *postbuf, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_WRITEV]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_writev_cbk_t)(priv->cbks[GLUPY_WRITEV]))( ++ frame, cookie, this, op_ret, op_errno, prebuf, postbuf, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf, ++ xdata); ++ return 0; ++} ++ ++int32_t ++glupy_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, ++ struct iovec *vector, int32_t count, off_t offset, uint32_t flags, ++ struct iobref *iobref, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_WRITEV]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_writev_t)(priv->fops[GLUPY_WRITEV]))( ++ frame, this, fd, vector, count, offset, flags, iobref, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_writev_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->writev, fd, vector, count, offset, ++ flags, iobref, xdata); ++ return 0; ++} ++ ++void ++wind_writev(call_frame_t *frame, xlator_t *xl, fd_t *fd, struct iovec *vector, ++ int32_t count, off_t offset, uint32_t flags, struct iobref *iobref, ++ dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_writev_cbk, xl, xl->fops->writev, fd, vector, count, ++ offset, flags, iobref, xdata); ++} ++ ++void ++unwind_writev(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf, ++ dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf, ++ xdata); ++} ++ ++void ++set_writev_fop(long py_this, fop_writev_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ priv->fops[GLUPY_WRITEV] = (long)fop; ++} ++ ++void ++set_writev_cbk(long py_this, fop_writev_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ priv->cbks[GLUPY_WRITEV] = (long)cbk; ++} ++ ++/* FOP: OPENDIR */ ++ ++int32_t ++glupy_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_OPENDIR]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_opendir_cbk_t)(priv->cbks[GLUPY_OPENDIR]))( ++ frame, cookie, this, op_ret, op_errno, fd, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(opendir, frame, op_ret, op_errno, fd, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_OPENDIR]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_opendir_t)(priv->fops[GLUPY_OPENDIR]))(frame, this, loc, fd, ++ xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_opendir_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->opendir, loc, fd, xdata); ++ return 0; ++} ++ ++void ++wind_opendir(call_frame_t *frame, xlator_t *xl, loc_t *loc, fd_t *fd, ++ dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_opendir_cbk, xl, xl->fops->opendir, loc, fd, xdata); ++} ++ ++void ++unwind_opendir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, fd_t *fd, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(opendir, frame, op_ret, op_errno, fd, xdata); ++} ++ ++void ++set_opendir_fop(long py_this, fop_opendir_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_OPENDIR] = (long)fop; ++} ++ ++void ++set_opendir_cbk(long py_this, fop_opendir_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_OPENDIR] = (long)cbk; ++} ++ ++/* FOP: READDIR */ ++ ++int32_t ++glupy_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_READDIR]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_readdir_cbk_t)(priv->cbks[GLUPY_READDIR]))( ++ frame, cookie, this, op_ret, op_errno, entries, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(readdir, frame, op_ret, op_errno, entries, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, ++ off_t offset, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_READDIR]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_readdir_t)(priv->fops[GLUPY_READDIR]))(frame, this, fd, size, ++ offset, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_readdir_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->readdir, fd, size, offset, xdata); ++ return 0; ++} ++ ++void ++wind_readdir(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size, ++ off_t offset, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_readdir_cbk, xl, xl->fops->readdir, fd, size, ++ offset, xdata); ++} ++ ++void ++unwind_readdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, gf_dirent_t *entries, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(readdir, frame, op_ret, op_errno, entries, xdata); ++} ++ ++void ++set_readdir_fop(long py_this, fop_readdir_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_READDIR] = (long)fop; ++} ++ ++void ++set_readdir_cbk(long py_this, fop_readdir_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_READDIR] = (long)cbk; ++} ++ ++/* FOP: READDIRP */ ++ ++int32_t ++glupy_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_READDIRP]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_readdirp_cbk_t)(priv->cbks[GLUPY_READDIRP]))( ++ frame, cookie, this, op_ret, op_errno, entries, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, entries, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, ++ off_t offset, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_READDIRP]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_readdirp_t)(priv->fops[GLUPY_READDIRP]))(frame, this, fd, size, ++ offset, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_readdirp_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->readdirp, fd, size, offset, xdata); ++ return 0; ++} ++ ++void ++wind_readdirp(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size, ++ off_t offset, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_readdirp_cbk, xl, xl->fops->readdirp, fd, size, ++ offset, xdata); ++} ++ ++void ++unwind_readdirp(call_frame_t *frame, long cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, ++ dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, entries, xdata); ++} ++ ++void ++set_readdirp_fop(long py_this, fop_readdirp_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_READDIRP] = (long)fop; ++} ++ ++void ++set_readdirp_cbk(long py_this, fop_readdirp_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_READDIRP] = (long)cbk; ++} ++ ++/* FOP:STAT */ ++ ++int32_t ++glupy_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, struct iatt *buf, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_STAT]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_stat_cbk_t)(priv->cbks[GLUPY_STAT]))( ++ frame, cookie, this, op_ret, op_errno, buf, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(stat, frame, op_ret, op_errno, buf, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_STAT]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_stat_t)(priv->fops[GLUPY_STAT]))(frame, this, loc, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_stat_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->stat, loc, xdata); ++ return 0; ++} ++ ++void ++wind_stat(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_stat_cbk, xl, xl->fops->stat, loc, xdata); ++} ++ ++void ++unwind_stat(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, struct iatt *buf, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(stat, frame, op_ret, op_errno, buf, xdata); ++} ++ ++void ++set_stat_fop(long py_this, fop_stat_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_STAT] = (long)fop; ++} ++ ++void ++set_stat_cbk(long py_this, fop_stat_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_STAT] = (long)cbk; ++} ++ ++/* FOP: FSTAT */ ++ ++int32_t ++glupy_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, struct iatt *buf, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_FSTAT]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_fstat_cbk_t)(priv->cbks[GLUPY_FSTAT]))( ++ frame, cookie, this, op_ret, op_errno, buf, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(fstat, frame, op_ret, op_errno, buf, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_FSTAT]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_fstat_t)(priv->fops[GLUPY_FSTAT]))(frame, this, fd, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_fstat_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->fstat, fd, xdata); ++ return 0; ++} ++ ++void ++wind_fstat(call_frame_t *frame, xlator_t *xl, fd_t *fd, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_fstat_cbk, xl, xl->fops->fstat, fd, xdata); ++} ++ ++void ++unwind_fstat(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, struct iatt *buf, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(fstat, frame, op_ret, op_errno, buf, xdata); ++} ++ ++void ++set_fstat_fop(long py_this, fop_fstat_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_FSTAT] = (long)fop; ++} ++ ++void ++set_fstat_cbk(long py_this, fop_fstat_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_FSTAT] = (long)cbk; ++} ++ ++/* FOP:STATFS */ ++ ++int32_t ++glupy_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, struct statvfs *buf, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_STATFS]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_statfs_cbk_t)(priv->cbks[GLUPY_STATFS]))( ++ frame, cookie, this, op_ret, op_errno, buf, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(statfs, frame, op_ret, op_errno, buf, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_STATFS]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_statfs_t)(priv->fops[GLUPY_STATFS]))(frame, this, loc, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_statfs_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->statfs, loc, xdata); ++ return 0; ++} ++ ++void ++wind_statfs(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_statfs_cbk, xl, xl->fops->statfs, loc, xdata); ++} ++ ++void ++unwind_statfs(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, struct statvfs *buf, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(statfs, frame, op_ret, op_errno, buf, xdata); ++} ++ ++void ++set_statfs_fop(long py_this, fop_statfs_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_STATFS] = (long)fop; ++} ++ ++void ++set_statfs_cbk(long py_this, fop_statfs_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_STATFS] = (long)cbk; ++} ++ ++/* FOP: SETXATTR */ ++ ++int32_t ++glupy_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_SETXATTR]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_setxattr_cbk_t)(priv->cbks[GLUPY_SETXATTR]))( ++ frame, cookie, this, op_ret, op_errno, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, ++ int32_t flags, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_SETXATTR]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_setxattr_t)(priv->fops[GLUPY_SETXATTR]))(frame, this, loc, dict, ++ flags, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_setxattr_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata); ++ return 0; ++} ++ ++void ++wind_setxattr(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *dict, ++ int32_t flags, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_setxattr_cbk, xl, xl->fops->setxattr, loc, dict, ++ flags, xdata); ++} ++ ++void ++unwind_setxattr(call_frame_t *frame, long cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata); ++} ++ ++void ++set_setxattr_fop(long py_this, fop_setxattr_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_SETXATTR] = (long)fop; ++} ++ ++void ++set_setxattr_cbk(long py_this, fop_setxattr_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_SETXATTR] = (long)cbk; ++} ++ ++/* FOP: GETXATTR */ ++ ++int32_t ++glupy_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *dict, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_GETXATTR]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_getxattr_cbk_t)(priv->cbks[GLUPY_GETXATTR]))( ++ frame, cookie, this, op_ret, op_errno, dict, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, dict, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, ++ const char *name, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_GETXATTR]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_getxattr_t)(priv->fops[GLUPY_GETXATTR]))(frame, this, loc, name, ++ xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_getxattr_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->getxattr, loc, name, xdata); ++ return 0; ++} ++ ++void ++wind_getxattr(call_frame_t *frame, xlator_t *xl, loc_t *loc, const char *name, ++ dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_getxattr_cbk, xl, xl->fops->getxattr, loc, name, ++ xdata); ++} ++ ++void ++unwind_getxattr(call_frame_t *frame, long cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, dict, xdata); ++} ++ ++void ++set_getxattr_fop(long py_this, fop_getxattr_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_GETXATTR] = (long)fop; ++} ++ ++void ++set_getxattr_cbk(long py_this, fop_getxattr_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_GETXATTR] = (long)cbk; ++} ++ ++/* FOP: FSETXATTR */ ++ ++int32_t ++glupy_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_FSETXATTR]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_fsetxattr_cbk_t)(priv->cbks[GLUPY_FSETXATTR]))( ++ frame, cookie, this, op_ret, op_errno, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, ++ int32_t flags, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_FSETXATTR]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_fsetxattr_t)(priv->fops[GLUPY_FSETXATTR]))(frame, this, fd, ++ dict, flags, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_fsetxattr_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata); ++ return 0; ++} ++ ++void ++wind_fsetxattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, dict_t *dict, ++ int32_t flags, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_fsetxattr_cbk, xl, xl->fops->fsetxattr, fd, dict, ++ flags, xdata); ++} ++ ++void ++unwind_fsetxattr(call_frame_t *frame, long cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xdata); ++} ++ ++void ++set_fsetxattr_fop(long py_this, fop_fsetxattr_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_FSETXATTR] = (long)fop; ++} ++ ++void ++set_fsetxattr_cbk(long py_this, fop_fsetxattr_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_FSETXATTR] = (long)cbk; ++} ++ ++/* FOP: FGETXATTR */ ++ ++int32_t ++glupy_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *dict, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_FGETXATTR]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_fgetxattr_cbk_t)(priv->cbks[GLUPY_FGETXATTR]))( ++ frame, cookie, this, op_ret, op_errno, dict, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(fgetxattr, frame, op_ret, op_errno, dict, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_FGETXATTR]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_fgetxattr_t)(priv->fops[GLUPY_FGETXATTR]))(frame, this, fd, ++ name, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_fgetxattr_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata); ++ return 0; ++} ++ ++void ++wind_fgetxattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, const char *name, ++ dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_fgetxattr_cbk, xl, xl->fops->fgetxattr, fd, name, ++ xdata); ++} ++ ++void ++unwind_fgetxattr(call_frame_t *frame, long cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(fgetxattr, frame, op_ret, op_errno, dict, xdata); ++} ++ ++void ++set_fgetxattr_fop(long py_this, fop_fgetxattr_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_FGETXATTR] = (long)fop; ++} ++ ++void ++set_fgetxattr_cbk(long py_this, fop_fgetxattr_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_FGETXATTR] = (long)cbk; ++} ++ ++/* FOP:REMOVEXATTR */ ++ ++int32_t ++glupy_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_REMOVEXATTR]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_removexattr_cbk_t)(priv->cbks[GLUPY_REMOVEXATTR]))( ++ frame, cookie, this, op_ret, op_errno, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, ++ const char *name, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_REMOVEXATTR]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_removexattr_t)(priv->fops[GLUPY_REMOVEXATTR]))(frame, this, loc, ++ name, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_removexattr_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); ++ return 0; ++} ++ ++void ++wind_removexattr(call_frame_t *frame, xlator_t *xl, loc_t *loc, ++ const char *name, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_removexattr_cbk, xl, xl->fops->removexattr, loc, ++ name, xdata); ++} ++ ++void ++unwind_removexattr(call_frame_t *frame, long cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata); ++} ++ ++void ++set_removexattr_fop(long py_this, fop_removexattr_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_REMOVEXATTR] = (long)fop; ++} ++ ++void ++set_removexattr_cbk(long py_this, fop_removexattr_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_REMOVEXATTR] = (long)cbk; ++} ++ ++/* FOP:FREMOVEXATTR */ ++ ++int32_t ++glupy_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_FREMOVEXATTR]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_fremovexattr_cbk_t)(priv->cbks[GLUPY_FREMOVEXATTR]))( ++ frame, cookie, this, op_ret, op_errno, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(fremovexattr, frame, op_ret, op_errno, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, ++ const char *name, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_FREMOVEXATTR]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_fremovexattr_t)(priv->fops[GLUPY_FREMOVEXATTR]))( ++ frame, this, fd, name, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_fremovexattr_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata); ++ return 0; ++} ++ ++void ++wind_fremovexattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, const char *name, ++ dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_fremovexattr_cbk, xl, xl->fops->fremovexattr, fd, ++ name, xdata); ++} ++ ++void ++unwind_fremovexattr(call_frame_t *frame, long cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(fremovexattr, frame, op_ret, op_errno, xdata); ++} ++ ++void ++set_fremovexattr_fop(long py_this, fop_fremovexattr_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_FREMOVEXATTR] = (long)fop; ++} ++ ++void ++set_fremovexattr_cbk(long py_this, fop_fremovexattr_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_FREMOVEXATTR] = (long)cbk; ++} ++ ++/* FOP: LINK*/ ++int32_t ++glupy_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, inode_t *inode, ++ struct iatt *buf, struct iatt *preparent, ++ struct iatt *postparent, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_LINK]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_link_cbk_t)(priv->cbks[GLUPY_LINK]))( ++ frame, cookie, this, op_ret, op_errno, inode, buf, preparent, ++ postparent, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, inode, buf, preparent, ++ postparent, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_LINK]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_link_t)(priv->fops[GLUPY_LINK]))(frame, this, oldloc, newloc, ++ xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_link_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata); ++ return 0; ++} ++ ++void ++wind_link(call_frame_t *frame, xlator_t *xl, loc_t *oldloc, loc_t *newloc, ++ dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_link_cbk, xl, xl->fops->link, oldloc, newloc, ++ xdata); ++} ++ ++void ++unwind_link(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, inode_t *inode, struct iatt *buf, ++ struct iatt *preparent, struct iatt *postparent, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, inode, buf, preparent, ++ postparent, xdata); ++} ++ ++void ++set_link_fop(long py_this, fop_link_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_LINK] = (long)fop; ++} ++ ++void ++set_link_cbk(long py_this, fop_link_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_LINK] = (long)cbk; ++} ++ ++/* FOP: SYMLINK*/ ++int32_t ++glupy_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, inode_t *inode, ++ struct iatt *buf, struct iatt *preparent, ++ struct iatt *postparent, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_SYMLINK]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_symlink_cbk_t)(priv->cbks[GLUPY_SYMLINK]))( ++ frame, cookie, this, op_ret, op_errno, inode, buf, preparent, ++ postparent, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, inode, buf, preparent, ++ postparent, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_symlink(call_frame_t *frame, xlator_t *this, const char *linkname, ++ loc_t *loc, mode_t umask, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_SYMLINK]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_symlink_t)(priv->fops[GLUPY_SYMLINK]))(frame, this, linkname, ++ loc, umask, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_symlink_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->symlink, linkname, loc, umask, xdata); ++ return 0; ++} ++ ++void ++wind_symlink(call_frame_t *frame, xlator_t *xl, const char *linkname, ++ loc_t *loc, mode_t umask, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_symlink_cbk, xl, xl->fops->symlink, linkname, loc, ++ umask, xdata); ++} ++ ++void ++unwind_symlink(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, inode_t *inode, struct iatt *buf, ++ struct iatt *preparent, struct iatt *postparent, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, inode, buf, preparent, ++ postparent, xdata); ++} ++ ++void ++set_symlink_fop(long py_this, fop_symlink_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_SYMLINK] = (long)fop; ++} ++ ++void ++set_symlink_cbk(long py_this, fop_symlink_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_SYMLINK] = (long)cbk; ++} ++ ++/* FOP: READLINK */ ++int32_t ++glupy_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, const char *path, ++ struct iatt *buf, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_READLINK]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_readlink_cbk_t)(priv->cbks[GLUPY_READLINK]))( ++ frame, cookie, this, op_ret, op_errno, path, buf, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(readlink, frame, op_ret, op_errno, path, buf, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_READLINK]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_readlink_t)(priv->fops[GLUPY_READLINK]))(frame, this, loc, size, ++ xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_readlink_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->readlink, loc, size, xdata); ++ return 0; ++} ++ ++void ++wind_readlink(call_frame_t *frame, xlator_t *xl, loc_t *loc, size_t size, ++ dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_readlink_cbk, xl, xl->fops->readlink, loc, size, ++ xdata); ++} ++ ++void ++unwind_readlink(call_frame_t *frame, long cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, const char *path, ++ struct iatt *buf, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(readlink, frame, op_ret, op_errno, path, buf, xdata); ++} ++ ++void ++set_readlink_fop(long py_this, fop_readlink_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_READLINK] = (long)fop; ++} ++ ++void ++set_readlink_cbk(long py_this, fop_readlink_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_READLINK] = (long)cbk; ++} ++ ++/* FOP: UNLINK */ ++ ++int32_t ++glupy_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, struct iatt *preparent, ++ struct iatt *postparent, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_UNLINK]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_unlink_cbk_t)(priv->cbks[GLUPY_UNLINK]))( ++ frame, cookie, this, op_ret, op_errno, preparent, postparent, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, preparent, postparent, ++ xdata); ++ return 0; ++} ++ ++int32_t ++glupy_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_UNLINK]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_unlink_t)(priv->fops[GLUPY_UNLINK]))(frame, this, loc, xflags, ++ xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_unlink_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->unlink, loc, xflags, xdata); ++ return 0; ++} ++ ++void ++wind_unlink(call_frame_t *frame, xlator_t *xl, loc_t *loc, int xflags, ++ dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_unlink_cbk, xl, xl->fops->unlink, loc, xflags, ++ xdata); ++} ++ ++void ++unwind_unlink(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, struct iatt *preparent, struct iatt *postparent, ++ dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, preparent, postparent, ++ xdata); ++} ++ ++void ++set_unlink_fop(long py_this, fop_unlink_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_UNLINK] = (long)fop; ++} ++ ++void ++set_unlink_cbk(long py_this, fop_unlink_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_UNLINK] = (long)cbk; ++} ++ ++/* FOP: MKDIR */ ++ ++int32_t ++glupy_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, inode_t *inode, ++ struct iatt *buf, struct iatt *preparent, ++ struct iatt *postparent, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_MKDIR]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_mkdir_cbk_t)(priv->cbks[GLUPY_MKDIR]))( ++ frame, cookie, this, op_ret, op_errno, inode, buf, preparent, ++ postparent, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(mkdir, frame, op_ret, op_errno, inode, buf, preparent, ++ postparent, xdata); ++ return 0; ++} ++ ++int32_t ++glupy_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, ++ mode_t umask, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_MKDIR]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_mkdir_t)(priv->fops[GLUPY_MKDIR]))(frame, this, loc, mode, ++ umask, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_mkdir_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata); ++ return 0; ++} ++ ++void ++wind_mkdir(call_frame_t *frame, xlator_t *xl, loc_t *loc, mode_t mode, ++ mode_t umask, dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_mkdir_cbk, xl, xl->fops->mkdir, loc, mode, umask, ++ xdata); ++} ++ ++void ++unwind_mkdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, inode_t *inode, struct iatt *buf, ++ struct iatt *preparent, struct iatt *postparent, dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(mkdir, frame, op_ret, op_errno, inode, buf, preparent, ++ postparent, xdata); ++} ++ ++void ++set_mkdir_fop(long py_this, fop_mkdir_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_MKDIR] = (long)fop; ++} ++ ++void ++set_mkdir_cbk(long py_this, fop_mkdir_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_MKDIR] = (long)cbk; ++} ++ ++/* FOP: RMDIR */ ++ ++int32_t ++glupy_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, ++ int32_t op_ret, int32_t op_errno, struct iatt *preparent, ++ struct iatt *postparent, dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ ++ if (!priv->cbks[GLUPY_RMDIR]) { ++ goto unwind; ++ } ++ ++ gstate = glupy_enter(); ++ ret = ((fop_rmdir_cbk_t)(priv->cbks[GLUPY_RMDIR]))( ++ frame, cookie, this, op_ret, op_errno, preparent, postparent, xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++unwind: ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(rmdir, frame, op_ret, op_errno, preparent, postparent, ++ xdata); ++ return 0; ++} ++ ++int32_t ++glupy_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags, ++ dict_t *xdata) ++{ ++ glupy_private_t *priv = this->private; ++ PyGILState_STATE gstate; ++ int32_t ret; ++ static long next_id = 0; ++ ++ if (!priv->fops[GLUPY_RMDIR]) { ++ goto wind; ++ } ++ ++ gstate = glupy_enter(); ++ frame->local = (void *)++next_id; ++ ret = ((fop_rmdir_t)(priv->fops[GLUPY_RMDIR]))(frame, this, loc, xflags, ++ xdata); ++ glupy_leave(gstate); ++ ++ return ret; ++ ++wind: ++ STACK_WIND(frame, glupy_rmdir_cbk, FIRST_CHILD(this), ++ FIRST_CHILD(this)->fops->rmdir, loc, xflags, xdata); ++ return 0; ++} ++ ++void ++wind_rmdir(call_frame_t *frame, xlator_t *xl, loc_t *loc, int xflags, ++ dict_t *xdata) ++{ ++ xlator_t *this = THIS; ++ ++ if (!xl || (xl == this)) { ++ xl = FIRST_CHILD(this); ++ } ++ ++ STACK_WIND(frame, glupy_rmdir_cbk, xl, xl->fops->rmdir, loc, xflags, xdata); ++} ++ ++void ++unwind_rmdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, ++ int32_t op_errno, struct iatt *preparent, struct iatt *postparent, ++ dict_t *xdata) ++{ ++ frame->local = NULL; ++ STACK_UNWIND_STRICT(rmdir, frame, op_ret, op_errno, preparent, postparent, ++ xdata); ++} ++ ++void ++set_rmdir_fop(long py_this, fop_rmdir_t fop) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->fops[GLUPY_RMDIR] = (long)fop; ++} ++ ++void ++set_rmdir_cbk(long py_this, fop_rmdir_cbk_t cbk) ++{ ++ glupy_private_t *priv = ((xlator_t *)py_this)->private; ++ ++ priv->cbks[GLUPY_RMDIR] = (long)cbk; ++} ++ ++/* NON-FOP-SPECIFIC CODE */ ++ ++long ++get_id(call_frame_t *frame) ++{ ++ return (long)(frame->local); ++} ++ ++uint64_t ++get_rootunique(call_frame_t *frame) ++{ ++ return frame->root->unique; ++} ++ ++int32_t ++mem_acct_init(xlator_t *this) ++{ ++ int ret = -1; ++ ++ if (!this) ++ return ret; ++ ++ ret = xlator_mem_acct_init(this, gf_glupy_mt_end); ++ ++ if (ret != 0) { ++ gf_log(this->name, GF_LOG_ERROR, ++ "Memory accounting init" ++ " failed"); ++ return ret; ++ } ++ ++ return ret; ++} ++ ++static void ++py_error_log(const char *name, PyObject *pystr) ++{ ++#if PY_MAJOR_VERSION > 2 ++ char scr[256]; ++ if (PyUnicode_Check(pystr)) { ++ PyObject *tmp = PyUnicode_AsEncodedString(pystr, "UTF-8", "strict"); ++ if (tmp != NULL) { ++ strncpy(scr, PyBytes_AS_STRING(pystr), sizeof(scr)); ++ Py_DECREF(tmp); ++ } else { ++ strncpy(scr, "string encoding error", sizeof(scr)); ++ } ++ } else if (PyBytes_Check(pystr)) { ++ strncpy(scr, PyBytes_AS_STRING(pystr), sizeof(scr)); ++ } else { ++ strncpy(scr, "string encoding error", sizeof(scr)); ++ } ++ gf_log(name, GF_LOG_ERROR, "Python error: %s", scr); ++#else ++ gf_log(name, GF_LOG_ERROR, "Python error: %s", PyString_AsString(pystr)); ++#endif ++} ++ ++static PyObject * ++encode(const char *str) ++{ ++#if PY_MAJOR_VERSION > 2 ++ return PyUnicode_FromString(str); ++#else ++ return PyString_FromString(str); ++#endif ++} ++ ++int32_t ++init(xlator_t *this) ++{ ++ glupy_private_t *priv = NULL; ++ char *module_name = NULL; ++ PyObject *py_mod_name = NULL; ++ PyObject *py_init_func = NULL; ++ PyObject *py_args = NULL; ++ PyObject *syspath = NULL; ++ PyObject *path = NULL; ++ PyObject *error_type = NULL; ++ PyObject *error_msg = NULL; ++ PyObject *error_bt = NULL; ++ static gf_boolean_t py_inited = _gf_false; ++ void *err_cleanup = &&err_return; ++ char libpython[16]; ++ ++ if (dict_get_str(this->options, "module-name", &module_name) != 0) { ++ gf_log(this->name, GF_LOG_ERROR, "missing module-name"); ++ return -1; ++ } ++ ++ priv = GF_CALLOC(1, sizeof(glupy_private_t), gf_glupy_mt_priv); ++ if (!priv) { ++ goto *err_cleanup; ++ } ++ this->private = priv; ++ err_cleanup = &&err_free_priv; ++ ++ if (!py_inited) { ++ /* FIXME: ++ * This hack is necessary because glusterfs (rightly) loads ++ * glupy.so with RTLD_LOCAL but glupy needs libpython to be ++ * loaded with RTLD_GLOBAL even though glupy is correctly ++ * linked with libpython. ++ * This is needed because one of the internal modules of ++ * python 2.x (lib-dynload/_struct.so) does not explicitly ++ * link with libpython. ++ */ ++ snprintf(libpython, sizeof(libpython), "libpython%d.%d.so", ++ PY_MAJOR_VERSION, PY_MINOR_VERSION); ++ if (!dlopen(libpython, RTLD_NOW | RTLD_GLOBAL)) { ++ gf_msg(this->name, GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED, ++ "dlopen(%s) failed: %s", libpython, dlerror()); ++ } ++ ++ /* ++ * This must be done before Py_Initialize(), ++ * because it will duplicate the environment, ++ * and fail to see later environment updates. ++ */ ++ setenv("PATH_GLUSTERFS_GLUPY_MODULE", PATH_GLUSTERFS_GLUPY_MODULE, 1); ++ ++ Py_Initialize(); ++ PyEval_InitThreads(); ++ ++ (void)pthread_key_create(&gil_init_key, NULL); ++ (void)pthread_setspecific(gil_init_key, (void *)1); ++ ++ /* PyEval_InitThreads takes this "for" us. No thanks. */ ++ PyEval_ReleaseLock(); ++ py_inited = _gf_true; ++ } ++ ++ /* Adjust python's path */ ++ syspath = PySys_GetObject("path"); ++ path = encode(GLUSTER_PYTHON_PATH); ++ PyList_Append(syspath, path); ++ Py_DECREF(path); ++ ++ py_mod_name = encode(module_name); ++ if (!py_mod_name) { ++ gf_log(this->name, GF_LOG_ERROR, "could not create name"); ++ if (PyErr_Occurred()) { ++ PyErr_Fetch(&error_type, &error_msg, &error_bt); ++ py_error_log(this->name, error_msg); ++ } ++ goto *err_cleanup; ++ } ++ ++ gf_log(this->name, GF_LOG_DEBUG, "py_mod_name = %s", module_name); ++ priv->py_module = PyImport_Import(py_mod_name); ++ Py_DECREF(py_mod_name); ++ if (!priv->py_module) { ++ gf_log(this->name, GF_LOG_ERROR, "Python import of %s failed", ++ module_name); ++ if (PyErr_Occurred()) { ++ PyErr_Fetch(&error_type, &error_msg, &error_bt); ++ py_error_log(this->name, error_msg); ++ } ++ goto *err_cleanup; ++ } ++ gf_log(this->name, GF_LOG_INFO, "Import of %s succeeded", module_name); ++ err_cleanup = &&err_deref_module; ++ ++ py_init_func = PyObject_GetAttrString(priv->py_module, "xlator"); ++ if (!py_init_func || !PyCallable_Check(py_init_func)) { ++ gf_log(this->name, GF_LOG_ERROR, "missing init func"); ++ if (PyErr_Occurred()) { ++ PyErr_Fetch(&error_type, &error_msg, &error_bt); ++ py_error_log(this->name, error_msg); ++ } ++ goto *err_cleanup; ++ } ++ err_cleanup = &&err_deref_init; ++ ++ py_args = PyTuple_New(1); ++ if (!py_args) { ++ gf_log(this->name, GF_LOG_ERROR, "could not create args"); ++ if (PyErr_Occurred()) { ++ PyErr_Fetch(&error_type, &error_msg, &error_bt); ++ py_error_log(this->name, error_msg); ++ } ++ goto *err_cleanup; ++ } ++ PyTuple_SetItem(py_args, 0, PyLong_FromLong((long)this)); ++ ++ /* TBD: pass in list of children */ ++ priv->py_xlator = PyObject_CallObject(py_init_func, py_args); ++ Py_DECREF(py_args); ++ if (!priv->py_xlator) { ++ gf_log(this->name, GF_LOG_ERROR, "Python init failed"); ++ if (PyErr_Occurred()) { ++ PyErr_Fetch(&error_type, &error_msg, &error_bt); ++ py_error_log(this->name, error_msg); ++ } ++ goto *err_cleanup; ++ } ++ gf_log(this->name, GF_LOG_DEBUG, "init returned %p", priv->py_xlator); ++ ++ return 0; ++ ++err_deref_init: ++ Py_DECREF(py_init_func); ++err_deref_module: ++ Py_DECREF(priv->py_module); ++err_free_priv: ++ GF_FREE(priv); ++err_return: ++ return -1; ++} ++ ++void ++fini(xlator_t *this) ++{ ++ glupy_private_t *priv = this->private; ++ ++ if (!priv) ++ return; ++ Py_DECREF(priv->py_xlator); ++ Py_DECREF(priv->py_module); ++ this->private = NULL; ++ GF_FREE(priv); ++ ++ return; ++} ++ ++struct xlator_fops fops = {.lookup = glupy_lookup, ++ .create = glupy_create, ++ .open = glupy_open, ++ .readv = glupy_readv, ++ .writev = glupy_writev, ++ .opendir = glupy_opendir, ++ .readdir = glupy_readdir, ++ .stat = glupy_stat, ++ .fstat = glupy_fstat, ++ .setxattr = glupy_setxattr, ++ .getxattr = glupy_getxattr, ++ .fsetxattr = glupy_fsetxattr, ++ .fgetxattr = glupy_fgetxattr, ++ .removexattr = glupy_removexattr, ++ .fremovexattr = glupy_fremovexattr, ++ .link = glupy_link, ++ .unlink = glupy_unlink, ++ .readlink = glupy_readlink, ++ .symlink = glupy_symlink, ++ .mkdir = glupy_mkdir, ++ .rmdir = glupy_rmdir, ++ .statfs = glupy_statfs, ++ .readdirp = glupy_readdirp}; ++ ++struct xlator_cbks cbks = {}; ++ ++struct volume_options options[] = { ++ {.key = {NULL}}, ++}; +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/src/glupy.h 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,56 @@ ++/* ++ Copyright (c) 2006-2014 Red Hat, Inc. ++ This file is part of GlusterFS. ++ ++ This file is licensed to you under your choice of the GNU Lesser ++ General Public License, version 3 or any later version (LGPLv3 or ++ later), or the GNU General Public License, version 2 (GPLv2), in all ++ cases as published by the Free Software Foundation. ++*/ ++ ++#ifndef __GLUPY_H__ ++#define __GLUPY_H__ ++ ++#include "mem-types.h" ++ ++enum { ++ GLUPY_LOOKUP = 0, ++ GLUPY_CREATE, ++ GLUPY_OPEN, ++ GLUPY_READV, ++ GLUPY_WRITEV, ++ GLUPY_OPENDIR, ++ GLUPY_READDIR, ++ GLUPY_READDIRP, ++ GLUPY_STAT, ++ GLUPY_FSTAT, ++ GLUPY_STATFS, ++ GLUPY_SETXATTR, ++ GLUPY_GETXATTR, ++ GLUPY_FSETXATTR, ++ GLUPY_FGETXATTR, ++ GLUPY_REMOVEXATTR, ++ GLUPY_FREMOVEXATTR, ++ GLUPY_LINK, ++ GLUPY_UNLINK, ++ GLUPY_READLINK, ++ GLUPY_SYMLINK, ++ GLUPY_MKNOD, ++ GLUPY_MKDIR, ++ GLUPY_RMDIR, ++ GLUPY_N_FUNCS ++}; ++ ++typedef struct { ++ PyObject *py_module; ++ PyObject *py_xlator; ++ long fops[GLUPY_N_FUNCS]; ++ long cbks[GLUPY_N_FUNCS]; ++} glupy_private_t; ++ ++enum gf_glupy_mem_types_ { ++ gf_glupy_mt_priv = gf_common_mt_end + 1, ++ gf_glupy_mt_end ++}; ++ ++#endif /* __GLUPY_H__ */ +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/src/glupy.sym 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,101 @@ ++init ++fini ++fops ++cbks ++options ++notify ++mem_acct_init ++reconfigure ++dumpops ++set_lookup_fop ++set_lookup_cbk ++set_create_fop ++set_create_cbk ++set_open_fop ++set_open_cbk ++set_readv_fop ++set_readv_cbk ++set_writev_fop ++set_writev_cbk ++set_opendir_fop ++set_opendir_cbk ++set_readdir_fop ++set_readdir_cbk ++set_readdirp_fop ++set_readdirp_cbk ++set_stat_fop ++set_stat_cbk ++set_fstat_fop ++set_fstat_cbk ++set_statfs_fop ++set_statfs_cbk ++set_setxattr_fop ++set_setxattr_cbk ++set_getxattr_fop ++set_getxattr_cbk ++set_fsetxattr_fop ++set_fsetxattr_cbk ++set_fgetxattr_fop ++set_fgetxattr_cbk ++set_removexattr_fop ++set_removexattr_cbk ++set_fremovexattr_fop ++set_fremovexattr_cbk ++set_link_fop ++set_link_cbk ++set_symlink_fop ++set_symlink_cbk ++set_readlink_fop ++set_readlink_cbk ++set_unlink_fop ++set_unlink_cbk ++set_mkdir_fop ++set_mkdir_cbk ++set_rmdir_fop ++set_rmdir_cbk ++wind_lookup ++wind_create ++wind_open ++wind_readv ++wind_writev ++wind_opendir ++wind_readdir ++wind_readdirp ++wind_stat ++wind_fstat ++wind_statfs ++wind_setxattr ++wind_getxattr ++wind_fsetxattr ++wind_fgetxattr ++wind_removexattr ++wind_fremovexattr ++wind_link ++wind_symlink ++wind_readlink ++wind_unlink ++wind_mkdir ++wind_rmdir ++unwind_lookup ++unwind_create ++unwind_open ++unwind_readv ++unwind_writev ++unwind_opendir ++unwind_readdir ++unwind_readdirp ++unwind_stat ++unwind_fstat ++unwind_statfs ++unwind_setxattr ++unwind_getxattr ++unwind_fsetxattr ++unwind_fgetxattr ++unwind_removexattr ++unwind_fremovexattr ++unwind_link ++unwind_symlink ++unwind_readlink ++unwind_unlink ++unwind_mkdir ++unwind_rmdir +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/src/glupy/Makefile.am 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,5 @@ ++# Install __init__.py into the Python site-packages area ++pyglupydir = @BUILD_PYTHON_SITE_PACKAGES@/gluster/glupy ++pyglupy_PYTHON = __init__.py ++ ++CLEANFILES = +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/src/glupy/__init__.py 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,852 @@ ++## ++## Copyright (c) 2006-2014 Red Hat, Inc. ++## This file is part of GlusterFS. ++## ++## This file is licensed to you under your choice of the GNU Lesser ++## General Public License, version 3 or any later version (LGPLv3 or ++## later), or the GNU General Public License, version 2 (GPLv2), in all ++## cases as published by the Free Software Foundation. ++## ++ ++import sys ++import os ++from ctypes import * ++ ++dl = CDLL(os.getenv("PATH_GLUSTERFS_GLUPY_MODULE", ""), RTLD_GLOBAL) ++ ++ ++class call_frame_t (Structure): ++ pass ++ ++class dev_t (Structure): ++ pass ++ ++ ++class dict_t (Structure): ++ pass ++ ++ ++class gf_dirent_t (Structure): ++ pass ++ ++ ++class iobref_t (Structure): ++ pass ++ ++ ++class iovec_t (Structure): ++ pass ++ ++ ++class list_head (Structure): ++ pass ++ ++list_head._fields_ = [ ++ ("next", POINTER(list_head)), ++ ("prev", POINTER(list_head)) ++ ] ++ ++ ++class rwxperm_t (Structure): ++ _fields_ = [ ++ ("read", c_uint8, 1), ++ ("write", c_uint8, 1), ++ ("execn", c_uint8, 1) ++ ] ++ ++ ++class statvfs_t (Structure): ++ pass ++ ++ ++class xlator_t (Structure): ++ pass ++ ++ ++class ia_prot_t (Structure): ++ _fields_ = [ ++ ("suid", c_uint8, 1), ++ ("sgid", c_uint8, 1), ++ ("sticky", c_uint8, 1), ++ ("owner", rwxperm_t), ++ ("group", rwxperm_t), ++ ("other", rwxperm_t) ++ ] ++ ++# For checking file type. ++(IA_INVAL, IA_IFREG, IA_IFDIR, IA_IFLNK, IA_IFBLK, IA_IFCHR, IA_IFIFO, ++ IA_IFSOCK) = range(8) ++ ++ ++class iatt_t (Structure): ++ _fields_ = [ ++ ("ia_no", c_uint64), ++ ("ia_gfid", c_ubyte * 16), ++ ("ia_dev", c_uint64), ++ ("ia_type", c_uint), ++ ("ia_prot", ia_prot_t), ++ ("ia_nlink", c_uint32), ++ ("ia_uid", c_uint32), ++ ("ia_gid", c_uint32), ++ ("ia_rdev", c_uint64), ++ ("ia_size", c_uint64), ++ ("ia_blksize", c_uint32), ++ ("ia_blocks", c_uint64), ++ ("ia_atime", c_uint32 ), ++ ("ia_atime_nsec", c_uint32), ++ ("ia_mtime", c_uint32), ++ ("ia_mtime_nsec", c_uint32), ++ ("ia_ctime", c_uint32), ++ ("ia_ctime_nsec", c_uint32) ++ ] ++ ++ ++class mem_pool (Structure): ++ _fields_ = [ ++ ("list", list_head), ++ ("hot_count", c_int), ++ ("cold_count", c_int), ++ ("lock", c_void_p), ++ ("padded_sizeof_type", c_ulong), ++ ("pool", c_void_p), ++ ("pool_end", c_void_p), ++ ("real_sizeof_type", c_int), ++ ("alloc_count", c_uint64), ++ ("pool_misses", c_uint64), ++ ("max_alloc", c_int), ++ ("curr_stdalloc", c_int), ++ ("max_stdalloc", c_int), ++ ("name", c_char_p), ++ ("global_list", list_head) ++ ] ++ ++ ++class U_ctx_key_inode (Union): ++ _fields_ = [ ++ ("key", c_uint64), ++ ("xl_key", POINTER(xlator_t)) ++ ] ++ ++ ++class U_ctx_value1 (Union): ++ _fields_ = [ ++ ("value1", c_uint64), ++ ("ptr1", c_void_p) ++ ] ++ ++ ++class U_ctx_value2 (Union): ++ _fields_ = [ ++ ("value2", c_uint64), ++ ("ptr2", c_void_p) ++ ] ++ ++class inode_ctx (Structure): ++ _anonymous_ = ("u_key", "u_value1", "u_value2",) ++ _fields_ = [ ++ ("u_key", U_ctx_key_inode), ++ ("u_value1", U_ctx_value1), ++ ("u_value2", U_ctx_value2) ++ ] ++ ++class inode_t (Structure): ++ pass ++ ++class inode_table_t (Structure): ++ _fields_ = [ ++ ("lock", c_void_p), ++ ("hashsize", c_size_t), ++ ("name", c_char_p), ++ ("root", POINTER(inode_t)), ++ ("xl", POINTER(xlator_t)), ++ ("lru_limit", c_uint32), ++ ("inode_hash", POINTER(list_head)), ++ ("name_hash", POINTER(list_head)), ++ ("active", list_head), ++ ("active_size", c_uint32), ++ ("lru", list_head), ++ ("lru_size", c_uint32), ++ ("purge", list_head), ++ ("purge_size", c_uint32), ++ ("inode_pool", POINTER(mem_pool)), ++ ("dentry_pool", POINTER(mem_pool)), ++ ("fd_mem_pool", POINTER(mem_pool)) ++ ] ++ ++inode_t._fields_ = [ ++ ("table", POINTER(inode_table_t)), ++ ("gfid", c_ubyte * 16), ++ ("lock", c_void_p), ++ ("nlookup", c_uint64), ++ ("fd_count", c_uint32), ++ ("ref", c_uint32), ++ ("ia_type", c_uint), ++ ("fd_list", list_head), ++ ("dentry_list", list_head), ++ ("hashv", list_head), ++ ("listv", list_head), ++ ("ctx", POINTER(inode_ctx)) ++ ] ++ ++ ++ ++class U_ctx_key_fd (Union): ++ _fields_ = [ ++ ("key", c_uint64), ++ ("xl_key", c_void_p) ++ ] ++ ++class fd_lk_ctx (Structure): ++ _fields_ = [ ++ ("lk_list", list_head), ++ ("ref", c_int), ++ ("lock", c_void_p) ++ ] ++ ++class fd_ctx (Structure): ++ _anonymous_ = ("u_key", "u_value1") ++ _fields_ = [ ++ ("u_key", U_ctx_key_fd), ++ ("u_value1", U_ctx_value1) ++ ] ++ ++class fd_t (Structure): ++ _fields_ = [ ++ ("pid", c_uint64), ++ ("flags", c_int32), ++ ("refcount", c_int32), ++ ("inode_list", list_head), ++ ("inode", POINTER(inode_t)), ++ ("lock", c_void_p), ++ ("ctx", POINTER(fd_ctx)), ++ ("xl_count", c_int), ++ ("lk_ctx", POINTER(fd_lk_ctx)), ++ ("anonymous", c_uint) ++ ] ++ ++class loc_t (Structure): ++ _fields_ = [ ++ ("path", c_char_p), ++ ("name", c_char_p), ++ ("inode", POINTER(inode_t)), ++ ("parent", POINTER(inode_t)), ++ ("gfid", c_ubyte * 16), ++ ("pargfid", c_ubyte * 16), ++ ] ++ ++ ++ ++def _init_op (a_class, fop, cbk, wind, unwind): ++ # Decorators, used by translators. We could pass the signatures as ++ # parameters, but it's actually kind of nice to keep them around for ++ # inspection. ++ a_class.fop_type = CFUNCTYPE(*a_class.fop_sig) ++ a_class.cbk_type = CFUNCTYPE(*a_class.cbk_sig) ++ # Dispatch-function registration. ++ fop.restype = None ++ fop.argtypes = [ c_long, a_class.fop_type ] ++ # Callback-function registration. ++ cbk.restype = None ++ cbk.argtypes = [ c_long, a_class.cbk_type ] ++ # STACK_WIND function. ++ wind.restype = None ++ wind.argtypes = list(a_class.fop_sig[1:]) ++ # STACK_UNWIND function. ++ unwind.restype = None ++ unwind.argtypes = list(a_class.cbk_sig[1:]) ++ ++class OpLookup: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(inode_t), POINTER(iatt_t), ++ POINTER(dict_t), POINTER(iatt_t)) ++_init_op (OpLookup, dl.set_lookup_fop, dl.set_lookup_cbk, ++ dl.wind_lookup, dl.unwind_lookup) ++ ++class OpCreate: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), c_int, c_uint, c_uint, POINTER(fd_t), ++ POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(fd_t), POINTER(inode_t), ++ POINTER(iatt_t), POINTER(iatt_t), POINTER(iatt_t), ++ POINTER(dict_t)) ++_init_op (OpCreate, dl.set_create_fop, dl.set_create_cbk, ++ dl.wind_create, dl.unwind_create) ++ ++class OpOpen: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), c_int, POINTER(fd_t), POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(fd_t), POINTER(dict_t)) ++_init_op (OpOpen, dl.set_open_fop, dl.set_open_cbk, ++ dl.wind_open, dl.unwind_open) ++ ++class OpReadv: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(fd_t), c_size_t, c_long, c_uint32, POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(iovec_t), c_int, POINTER(iatt_t), ++ POINTER(iobref_t), POINTER(dict_t)) ++_init_op (OpReadv, dl.set_readv_fop, dl.set_readv_cbk, ++ dl.wind_readv, dl.unwind_readv) ++class OpWritev: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(fd_t), POINTER(iovec_t), c_int, c_long, c_uint32, ++ POINTER(iobref_t), POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(iatt_t), POINTER(iatt_t), ++ POINTER(dict_t)) ++_init_op (OpWritev, dl.set_writev_fop, dl.set_writev_cbk, ++ dl.wind_writev, dl.unwind_writev) ++ ++class OpOpendir: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), POINTER(fd_t), POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(fd_t), POINTER(dict_t)) ++_init_op (OpOpendir, dl.set_opendir_fop, dl.set_opendir_cbk, ++ dl.wind_opendir, dl.unwind_opendir) ++ ++class OpReaddir: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(fd_t), c_size_t, c_long, POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(gf_dirent_t), POINTER(dict_t)) ++_init_op (OpReaddir, dl.set_readdir_fop, dl.set_readdir_cbk, ++ dl.wind_readdir, dl.unwind_readdir) ++ ++class OpReaddirp: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(fd_t), c_size_t, c_long, POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(gf_dirent_t), POINTER(dict_t)) ++_init_op (OpReaddirp, dl.set_readdirp_fop, dl.set_readdirp_cbk, ++ dl.wind_readdirp, dl.unwind_readdirp) ++ ++class OpStat: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(iatt_t), POINTER(dict_t)) ++_init_op (OpStat, dl.set_stat_fop, dl.set_stat_cbk, ++ dl.wind_stat, dl.unwind_stat) ++ ++class OpFstat: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(fd_t), POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(iatt_t), POINTER(dict_t)) ++_init_op (OpFstat, dl.set_fstat_fop, dl.set_fstat_cbk, ++ dl.wind_fstat, dl.unwind_fstat) ++ ++class OpStatfs: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(statvfs_t), POINTER(dict_t)) ++_init_op (OpStatfs, dl.set_statfs_fop, dl.set_statfs_cbk, ++ dl.wind_statfs, dl.unwind_statfs) ++ ++ ++class OpSetxattr: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), POINTER(dict_t), c_int32, ++ POINTER (dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(dict_t)) ++_init_op (OpSetxattr, dl.set_setxattr_fop, dl.set_setxattr_cbk, ++ dl.wind_setxattr, dl.unwind_setxattr) ++ ++class OpGetxattr: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), c_char_p, POINTER (dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(dict_t), POINTER(dict_t)) ++_init_op (OpGetxattr, dl.set_getxattr_fop, dl.set_getxattr_cbk, ++ dl.wind_getxattr, dl.unwind_getxattr) ++ ++class OpFsetxattr: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(fd_t), POINTER(dict_t), c_int32, ++ POINTER (dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(dict_t)) ++_init_op (OpFsetxattr, dl.set_fsetxattr_fop, dl.set_fsetxattr_cbk, ++ dl.wind_fsetxattr, dl.unwind_fsetxattr) ++ ++class OpFgetxattr: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(fd_t), c_char_p, POINTER (dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(dict_t), POINTER(dict_t)) ++_init_op (OpFgetxattr, dl.set_fgetxattr_fop, dl.set_fgetxattr_cbk, ++ dl.wind_fgetxattr, dl.unwind_fgetxattr) ++ ++class OpRemovexattr: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), c_char_p, POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(dict_t)) ++_init_op (OpRemovexattr, dl.set_removexattr_fop, dl.set_removexattr_cbk, ++ dl.wind_removexattr, dl.unwind_removexattr) ++ ++ ++class OpFremovexattr: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(fd_t), c_char_p, POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(dict_t)) ++_init_op (OpFremovexattr, dl.set_fremovexattr_fop, dl.set_fremovexattr_cbk, ++ dl.wind_fremovexattr, dl.unwind_fremovexattr) ++ ++class OpLink: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), POINTER(loc_t), POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(inode_t), POINTER(iatt_t), ++ POINTER(iatt_t), POINTER(iatt_t), POINTER(dict_t)) ++_init_op (OpLink, dl.set_link_fop, dl.set_link_cbk, ++ dl.wind_link, dl.unwind_link) ++ ++class OpSymlink: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ c_char_p, POINTER(loc_t), c_uint, POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(inode_t), POINTER(iatt_t), ++ POINTER(iatt_t), POINTER(iatt_t), POINTER(dict_t)) ++_init_op (OpSymlink, dl.set_symlink_fop, dl.set_symlink_cbk, ++ dl.wind_symlink, dl.unwind_symlink) ++ ++class OpUnlink: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), c_int, POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(iatt_t), POINTER(iatt_t), ++ POINTER(dict_t)) ++_init_op (OpUnlink, dl.set_unlink_fop, dl.set_unlink_cbk, ++ dl.wind_unlink, dl.unwind_unlink) ++ ++class OpReadlink: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), c_size_t, POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, c_char_p, POINTER(iatt_t), POINTER(dict_t)) ++_init_op (OpReadlink, dl.set_readlink_fop, dl.set_readlink_cbk, ++ dl.wind_readlink, dl.unwind_readlink) ++ ++class OpMkdir: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), c_uint, c_uint, POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(inode_t), POINTER(iatt_t), ++ POINTER(iatt_t), POINTER(iatt_t), POINTER(dict_t)) ++_init_op (OpMkdir, dl.set_mkdir_fop, dl.set_mkdir_cbk, ++ dl.wind_mkdir, dl.unwind_mkdir) ++ ++class OpRmdir: ++ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), ++ POINTER(loc_t), c_int, POINTER(dict_t)) ++ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), ++ c_int, c_int, POINTER(iatt_t), POINTER(iatt_t), ++ POINTER(dict_t)) ++_init_op (OpRmdir, dl.set_rmdir_fop, dl.set_rmdir_cbk, ++ dl.wind_rmdir, dl.unwind_rmdir) ++ ++ ++class Translator: ++ def __init__ (self, c_this): ++ # This is only here to keep references to the stubs we create, ++ # because ctypes doesn't and glupy.so can't because it doesn't ++ # get a pointer to the actual Python object. It's a dictionary ++ # instead of a list in case we ever allow changing fops/cbks ++ # after initialization and need to look them up. ++ self.stub_refs = {} ++ funcs = dir(self.__class__) ++ if "lookup_fop" in funcs: ++ @OpLookup.fop_type ++ def stub (frame, this, loc, xdata, s=self): ++ return s.lookup_fop (frame, this, loc, xdata) ++ self.stub_refs["lookup_fop"] = stub ++ dl.set_lookup_fop(c_this, stub) ++ if "lookup_cbk" in funcs: ++ @OpLookup.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, inode, ++ buf, xdata, postparent, s=self): ++ return s.lookup_cbk(frame, cookie, this, op_ret, ++ op_errno, inode, buf, xdata, ++ postparent) ++ self.stub_refs["lookup_cbk"] = stub ++ dl.set_lookup_cbk(c_this, stub) ++ if "create_fop" in funcs: ++ @OpCreate.fop_type ++ def stub (frame, this, loc, flags, mode, umask, fd, ++ xdata, s=self): ++ return s.create_fop (frame, this, loc, flags, ++ mode, umask, fd, xdata) ++ self.stub_refs["create_fop"] = stub ++ dl.set_create_fop(c_this, stub) ++ if "create_cbk" in funcs: ++ @OpCreate.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, fd, ++ inode, buf, preparent, postparent, xdata, ++ s=self): ++ return s.create_cbk (frame, cookie, this, ++ op_ret, op_errno, fd, ++ inode, buf, preparent, ++ postparent, xdata) ++ self.stub_refs["create_cbk"] = stub ++ dl.set_create_cbk(c_this, stub) ++ if "open_fop" in funcs: ++ @OpOpen.fop_type ++ def stub (frame, this, loc, flags, fd, ++ xdata, s=self): ++ return s.open_fop (frame, this, loc, flags, ++ fd, xdata) ++ self.stub_refs["open_fop"] = stub ++ dl.set_open_fop(c_this, stub) ++ if "open_cbk" in funcs: ++ @OpOpen.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, fd, ++ xdata, s=self): ++ return s.open_cbk (frame, cookie, this, ++ op_ret, op_errno, fd, ++ xdata) ++ self.stub_refs["open_cbk"] = stub ++ dl.set_open_cbk(c_this, stub) ++ if "readv_fop" in funcs: ++ @OpReadv.fop_type ++ def stub (frame, this, fd, size, offset, flags, ++ xdata, s=self): ++ return s.readv_fop (frame, this, fd, size, ++ offset, flags, xdata) ++ self.stub_refs["readv_fop"] = stub ++ dl.set_readv_fop(c_this, stub) ++ if "readv_cbk" in funcs: ++ @OpReadv.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ vector, count, stbuf, iobref, xdata, ++ s=self): ++ return s.readv_cbk (frame, cookie, this, ++ op_ret, op_errno, vector, ++ count, stbuf, iobref, ++ xdata) ++ self.stub_refs["readv_cbk"] = stub ++ dl.set_readv_cbk(c_this, stub) ++ if "writev_fop" in funcs: ++ @OpWritev.fop_type ++ def stub (frame, this, fd, vector, count, ++ offset, flags, iobref, xdata, s=self): ++ return s.writev_fop (frame, this, fd, vector, ++ count, offset, flags, ++ iobref, xdata) ++ self.stub_refs["writev_fop"] = stub ++ dl.set_writev_fop(c_this, stub) ++ if "writev_cbk" in funcs: ++ @OpWritev.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ prebuf, postbuf, xdata, s=self): ++ return s.writev_cbk (frame, cookie, this, ++ op_ret, op_errno, prebuf, ++ postbuf, xdata) ++ self.stub_refs["writev_cbk"] = stub ++ dl.set_writev_cbk(c_this, stub) ++ if "opendir_fop" in funcs: ++ @OpOpendir.fop_type ++ def stub (frame, this, loc, fd, xdata, s=self): ++ return s.opendir_fop (frame, this, loc, fd, ++ xdata) ++ self.stub_refs["opendir_fop"] = stub ++ dl.set_opendir_fop(c_this, stub) ++ if "opendir_cbk" in funcs: ++ @OpOpendir.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, fd, ++ xdata, s=self): ++ return s.opendir_cbk(frame, cookie, this, ++ op_ret, op_errno, fd, ++ xdata) ++ self.stub_refs["opendir_cbk"] = stub ++ dl.set_opendir_cbk(c_this, stub) ++ if "readdir_fop" in funcs: ++ @OpReaddir.fop_type ++ def stub (frame, this, fd, size, offset, xdata, s=self): ++ return s.readdir_fop (frame, this, fd, size, ++ offset, xdata) ++ self.stub_refs["readdir_fop"] = stub ++ dl.set_readdir_fop(c_this, stub) ++ if "readdir_cbk" in funcs: ++ @OpReaddir.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ entries, xdata, s=self): ++ return s.readdir_cbk(frame, cookie, this, ++ op_ret, op_errno, entries, ++ xdata) ++ self.stub_refs["readdir_cbk"] = stub ++ dl.set_readdir_cbk(c_this, stub) ++ if "readdirp_fop" in funcs: ++ @OpReaddirp.fop_type ++ def stub (frame, this, fd, size, offset, xdata, s=self): ++ return s.readdirp_fop (frame, this, fd, size, ++ offset, xdata) ++ self.stub_refs["readdirp_fop"] = stub ++ dl.set_readdirp_fop(c_this, stub) ++ if "readdirp_cbk" in funcs: ++ @OpReaddirp.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ entries, xdata, s=self): ++ return s.readdirp_cbk (frame, cookie, this, ++ op_ret, op_errno, ++ entries, xdata) ++ self.stub_refs["readdirp_cbk"] = stub ++ dl.set_readdirp_cbk(c_this, stub) ++ if "stat_fop" in funcs: ++ @OpStat.fop_type ++ def stub (frame, this, loc, xdata, s=self): ++ return s.stat_fop (frame, this, loc, xdata) ++ self.stub_refs["stat_fop"] = stub ++ dl.set_stat_fop(c_this, stub) ++ if "stat_cbk" in funcs: ++ @OpStat.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, buf, ++ xdata, s=self): ++ return s.stat_cbk(frame, cookie, this, op_ret, ++ op_errno, buf, xdata) ++ self.stub_refs["stat_cbk"] = stub ++ dl.set_stat_cbk(c_this, stub) ++ if "fstat_fop" in funcs: ++ @OpFstat.fop_type ++ def stub (frame, this, fd, xdata, s=self): ++ return s.fstat_fop (frame, this, fd, xdata) ++ self.stub_refs["fstat_fop"] = stub ++ dl.set_fstat_fop(c_this, stub) ++ if "fstat_cbk" in funcs: ++ @OpFstat.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, buf, ++ xdata, s=self): ++ return s.fstat_cbk(frame, cookie, this, op_ret, ++ op_errno, buf, xdata) ++ self.stub_refs["fstat_cbk"] = stub ++ dl.set_fstat_cbk(c_this, stub) ++ if "statfs_fop" in funcs: ++ @OpStatfs.fop_type ++ def stub (frame, this, loc, xdata, s=self): ++ return s.statfs_fop (frame, this, loc, xdata) ++ self.stub_refs["statfs_fop"] = stub ++ dl.set_statfs_fop(c_this, stub) ++ if "statfs_cbk" in funcs: ++ @OpStatfs.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, buf, ++ xdata, s=self): ++ return s.statfs_cbk (frame, cookie, this, ++ op_ret, op_errno, buf, ++ xdata) ++ self.stub_refs["statfs_cbk"] = stub ++ dl.set_statfs_cbk(c_this, stub) ++ if "setxattr_fop" in funcs: ++ @OpSetxattr.fop_type ++ def stub (frame, this, loc, dictionary, flags, xdata, ++ s=self): ++ return s.setxattr_fop (frame, this, loc, ++ dictionary, flags, ++ xdata) ++ self.stub_refs["setxattr_fop"] = stub ++ dl.set_setxattr_fop(c_this, stub) ++ if "setxattr_cbk" in funcs: ++ @OpSetxattr.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, xdata, ++ s=self): ++ return s.setxattr_cbk(frame, cookie, this, ++ op_ret, op_errno, xdata) ++ self.stub_refs["setxattr_cbk"] = stub ++ dl.set_setxattr_cbk(c_this, stub) ++ if "getxattr_fop" in funcs: ++ @OpGetxattr.fop_type ++ def stub (frame, this, loc, name, xdata, s=self): ++ return s.getxattr_fop (frame, this, loc, name, ++ xdata) ++ self.stub_refs["getxattr_fop"] = stub ++ dl.set_getxattr_fop(c_this, stub) ++ if "getxattr_cbk" in funcs: ++ @OpGetxattr.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ dictionary, xdata, s=self): ++ return s.getxattr_cbk(frame, cookie, this, ++ op_ret, op_errno, ++ dictionary, xdata) ++ self.stub_refs["getxattr_cbk"] = stub ++ dl.set_getxattr_cbk(c_this, stub) ++ if "fsetxattr_fop" in funcs: ++ @OpFsetxattr.fop_type ++ def stub (frame, this, fd, dictionary, flags, xdata, ++ s=self): ++ return s.fsetxattr_fop (frame, this, fd, ++ dictionary, flags, ++ xdata) ++ self.stub_refs["fsetxattr_fop"] = stub ++ dl.set_fsetxattr_fop(c_this, stub) ++ if "fsetxattr_cbk" in funcs: ++ @OpFsetxattr.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, xdata, ++ s=self): ++ return s.fsetxattr_cbk(frame, cookie, this, ++ op_ret, op_errno, xdata) ++ self.stub_refs["fsetxattr_cbk"] = stub ++ dl.set_fsetxattr_cbk(c_this, stub) ++ if "fgetxattr_fop" in funcs: ++ @OpFgetxattr.fop_type ++ def stub (frame, this, fd, name, xdata, s=self): ++ return s.fgetxattr_fop (frame, this, fd, name, ++ xdata) ++ self.stub_refs["fgetxattr_fop"] = stub ++ dl.set_fgetxattr_fop(c_this, stub) ++ if "fgetxattr_cbk" in funcs: ++ @OpFgetxattr.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ dictionary, xdata, s=self): ++ return s.fgetxattr_cbk(frame, cookie, this, ++ op_ret, op_errno, ++ dictionary, xdata) ++ self.stub_refs["fgetxattr_cbk"] = stub ++ dl.set_fgetxattr_cbk(c_this, stub) ++ if "removexattr_fop" in funcs: ++ @OpRemovexattr.fop_type ++ def stub (frame, this, loc, name, xdata, s=self): ++ return s.removexattr_fop (frame, this, loc, ++ name, xdata) ++ self.stub_refs["removexattr_fop"] = stub ++ dl.set_removexattr_fop(c_this, stub) ++ if "removexattr_cbk" in funcs: ++ @OpRemovexattr.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ xdata, s=self): ++ return s.removexattr_cbk(frame, cookie, this, ++ op_ret, op_errno, ++ xdata) ++ self.stub_refs["removexattr_cbk"] = stub ++ dl.set_removexattr_cbk(c_this, stub) ++ if "fremovexattr_fop" in funcs: ++ @OpFremovexattr.fop_type ++ def stub (frame, this, fd, name, xdata, s=self): ++ return s.fremovexattr_fop (frame, this, fd, ++ name, xdata) ++ self.stub_refs["fremovexattr_fop"] = stub ++ dl.set_fremovexattr_fop(c_this, stub) ++ if "fremovexattr_cbk" in funcs: ++ @OpFremovexattr.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ xdata, s=self): ++ return s.fremovexattr_cbk(frame, cookie, this, ++ op_ret, op_errno, ++ xdata) ++ self.stub_refs["fremovexattr_cbk"] = stub ++ dl.set_fremovexattr_cbk(c_this, stub) ++ if "link_fop" in funcs: ++ @OpLink.fop_type ++ def stub (frame, this, oldloc, newloc, ++ xdata, s=self): ++ return s.link_fop (frame, this, oldloc, ++ newloc, xdata) ++ self.stub_refs["link_fop"] = stub ++ dl.set_link_fop(c_this, stub) ++ if "link_cbk" in funcs: ++ @OpLink.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ inode, buf, preparent, postparent, xdata, ++ s=self): ++ return s.link_cbk (frame, cookie, this, ++ op_ret, op_errno, inode, ++ buf, preparent, ++ postparent, xdata) ++ self.stub_refs["link_cbk"] = stub ++ dl.set_link_cbk(c_this, stub) ++ if "symlink_fop" in funcs: ++ @OpSymlink.fop_type ++ def stub (frame, this, linkname, loc, ++ umask, xdata, s=self): ++ return s.symlink_fop (frame, this, linkname, ++ loc, umask, xdata) ++ self.stub_refs["symlink_fop"] = stub ++ dl.set_symlink_fop(c_this, stub) ++ if "symlink_cbk" in funcs: ++ @OpSymlink.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ inode, buf, preparent, postparent, xdata, ++ s=self): ++ return s.symlink_cbk (frame, cookie, this, ++ op_ret, op_errno, inode, ++ buf, preparent, ++ postparent, xdata) ++ self.stub_refs["symlink_cbk"] = stub ++ dl.set_symlink_cbk(c_this, stub) ++ if "unlink_fop" in funcs: ++ @OpUnlink.fop_type ++ def stub (frame, this, loc, xflags, ++ xdata, s=self): ++ return s.unlink_fop (frame, this, loc, ++ xflags, xdata) ++ self.stub_refs["unlink_fop"] = stub ++ dl.set_unlink_fop(c_this, stub) ++ if "unlink_cbk" in funcs: ++ @OpUnlink.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ preparent, postparent, xdata, s=self): ++ return s.unlink_cbk (frame, cookie, this, ++ op_ret, op_errno, ++ preparent, postparent, ++ xdata) ++ self.stub_refs["unlink_cbk"] = stub ++ dl.set_unlink_cbk(c_this, stub) ++ if "readlink_fop" in funcs: ++ @OpReadlink.fop_type ++ def stub (frame, this, loc, size, ++ xdata, s=self): ++ return s.readlink_fop (frame, this, loc, ++ size, xdata) ++ self.stub_refs["readlink_fop"] = stub ++ dl.set_readlink_fop(c_this, stub) ++ if "readlink_cbk" in funcs: ++ @OpReadlink.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ path, buf, xdata, s=self): ++ return s.readlink_cbk (frame, cookie, this, ++ op_ret, op_errno, ++ path, buf, xdata) ++ self.stub_refs["readlink_cbk"] = stub ++ dl.set_readlink_cbk(c_this, stub) ++ if "mkdir_fop" in funcs: ++ @OpMkdir.fop_type ++ def stub (frame, this, loc, mode, umask, xdata, ++ s=self): ++ return s.mkdir_fop (frame, this, loc, mode, ++ umask, xdata) ++ self.stub_refs["mkdir_fop"] = stub ++ dl.set_mkdir_fop(c_this, stub) ++ if "mkdir_cbk" in funcs: ++ @OpMkdir.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, inode, ++ buf, preparent, postparent, xdata, s=self): ++ return s.mkdir_cbk (frame, cookie, this, ++ op_ret, op_errno, inode, ++ buf, preparent, ++ postparent, xdata) ++ self.stub_refs["mkdir_cbk"] = stub ++ dl.set_mkdir_cbk(c_this, stub) ++ if "rmdir_fop" in funcs: ++ @OpRmdir.fop_type ++ def stub (frame, this, loc, xflags, ++ xdata, s=self): ++ return s.rmdir_fop (frame, this, loc, ++ xflags, xdata) ++ self.stub_refs["rmdir_fop"] = stub ++ dl.set_rmdir_fop(c_this, stub) ++ if "rmdir_cbk" in funcs: ++ @OpRmdir.cbk_type ++ def stub (frame, cookie, this, op_ret, op_errno, ++ preparent, postparent, xdata, s=self): ++ return s.rmdir_cbk (frame, cookie, this, ++ op_ret, op_errno, ++ preparent, postparent, ++ xdata) ++ self.stub_refs["rmdir_cbk"] = stub ++ dl.set_rmdir_cbk(c_this, stub) +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/src/glupy/Makefile.in 2019-07-06 08:50:37.174969610 -0400 +@@ -0,0 +1,625 @@ ++# Makefile.in generated by automake 1.13.4 from Makefile.am. ++# @configure_input@ ++ ++# Copyright (C) 1994-2013 Free Software Foundation, Inc. ++ ++# This Makefile.in is free software; the Free Software Foundation ++# gives unlimited permission to copy and/or distribute it, ++# with or without modifications, as long as this notice is preserved. ++ ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY, to the extent permitted by law; without ++# even the implied warranty of MERCHANTABILITY or FITNESS FOR A ++# PARTICULAR PURPOSE. ++ ++@SET_MAKE@ ++VPATH = @srcdir@ ++am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' ++am__make_running_with_option = \ ++ case $${target_option-} in \ ++ ?) ;; \ ++ *) echo "am__make_running_with_option: internal error: invalid" \ ++ "target option '$${target_option-}' specified" >&2; \ ++ exit 1;; \ ++ esac; \ ++ has_opt=no; \ ++ sane_makeflags=$$MAKEFLAGS; \ ++ if $(am__is_gnu_make); then \ ++ sane_makeflags=$$MFLAGS; \ ++ else \ ++ case $$MAKEFLAGS in \ ++ *\\[\ \ ]*) \ ++ bs=\\; \ ++ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ ++ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ ++ esac; \ ++ fi; \ ++ skip_next=no; \ ++ strip_trailopt () \ ++ { \ ++ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ ++ }; \ ++ for flg in $$sane_makeflags; do \ ++ test $$skip_next = yes && { skip_next=no; continue; }; \ ++ case $$flg in \ ++ *=*|--*) continue;; \ ++ -*I) strip_trailopt 'I'; skip_next=yes;; \ ++ -*I?*) strip_trailopt 'I';; \ ++ -*O) strip_trailopt 'O'; skip_next=yes;; \ ++ -*O?*) strip_trailopt 'O';; \ ++ -*l) strip_trailopt 'l'; skip_next=yes;; \ ++ -*l?*) strip_trailopt 'l';; \ ++ -[dEDm]) skip_next=yes;; \ ++ -[JT]) skip_next=yes;; \ ++ esac; \ ++ case $$flg in \ ++ *$$target_option*) has_opt=yes; break;; \ ++ esac; \ ++ done; \ ++ test $$has_opt = yes ++am__make_dryrun = (target_option=n; $(am__make_running_with_option)) ++am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) ++pkgdatadir = $(datadir)/@PACKAGE@ ++pkgincludedir = $(includedir)/@PACKAGE@ ++pkglibdir = $(libdir)/@PACKAGE@ ++pkglibexecdir = $(libexecdir)/@PACKAGE@ ++am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd ++install_sh_DATA = $(install_sh) -c -m 644 ++install_sh_PROGRAM = $(install_sh) -c ++install_sh_SCRIPT = $(install_sh) -c ++INSTALL_HEADER = $(INSTALL_DATA) ++transform = $(program_transform_name) ++NORMAL_INSTALL = : ++PRE_INSTALL = : ++POST_INSTALL = : ++NORMAL_UNINSTALL = : ++PRE_UNINSTALL = : ++POST_UNINSTALL = : ++build_triplet = @build@ ++host_triplet = @host@ ++subdir = xlators/features/glupy/src/glupy ++DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ ++ $(pyglupy_PYTHON) $(top_srcdir)/py-compile ++ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 ++am__aclocal_m4_deps = $(top_srcdir)/contrib/aclocal/mkdirp.m4 \ ++ $(top_srcdir)/contrib/aclocal/python.m4 \ ++ $(top_srcdir)/configure.ac ++am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ ++ $(ACLOCAL_M4) ++mkinstalldirs = $(install_sh) -d ++CONFIG_HEADER = $(top_builddir)/config.h $(top_builddir)/site.h ++CONFIG_CLEAN_FILES = ++CONFIG_CLEAN_VPATH_FILES = ++AM_V_P = $(am__v_P_@AM_V@) ++am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) ++am__v_P_0 = false ++am__v_P_1 = : ++AM_V_GEN = $(am__v_GEN_@AM_V@) ++am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) ++am__v_GEN_0 = @echo " GEN " $@; ++am__v_GEN_1 = ++AM_V_at = $(am__v_at_@AM_V@) ++am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) ++am__v_at_0 = @ ++am__v_at_1 = ++SOURCES = ++DIST_SOURCES = ++am__can_run_installinfo = \ ++ case $$AM_UPDATE_INFO_DIR in \ ++ n|no|NO) false;; \ ++ *) (install-info --version) >/dev/null 2>&1;; \ ++ esac ++am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; ++am__vpath_adj = case $$p in \ ++ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ ++ *) f=$$p;; \ ++ esac; ++am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; ++am__install_max = 40 ++am__nobase_strip_setup = \ ++ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` ++am__nobase_strip = \ ++ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" ++am__nobase_list = $(am__nobase_strip_setup); \ ++ for p in $$list; do echo "$$p $$p"; done | \ ++ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ ++ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ ++ if (++n[$$2] == $(am__install_max)) \ ++ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ ++ END { for (dir in files) print dir, files[dir] }' ++am__base_list = \ ++ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ ++ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' ++am__uninstall_files_from_dir = { \ ++ test -z "$$files" \ ++ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ ++ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ ++ $(am__cd) "$$dir" && rm -f $$files; }; \ ++ } ++am__py_compile = PYTHON=$(PYTHON) $(SHELL) $(py_compile) ++am__installdirs = "$(DESTDIR)$(pyglupydir)" ++am__pep3147_tweak = \ ++ sed -e 's|\.py$$||' -e 's|[^/]*$$|__pycache__/&.*.py|' ++py_compile = $(top_srcdir)/py-compile ++am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) ++DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ++ACLOCAL = @ACLOCAL@ ++ACL_LIBS = @ACL_LIBS@ ++AMTAR = @AMTAR@ ++AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ ++AM_LIBTOOLFLAGS = @AM_LIBTOOLFLAGS@ ++AM_MAKEFLAGS = @AM_MAKEFLAGS@ ++AR = @AR@ ++ARGP_LDADD = @ARGP_LDADD@ ++AUTOCONF = @AUTOCONF@ ++AUTOHEADER = @AUTOHEADER@ ++AUTOMAKE = @AUTOMAKE@ ++AWK = @AWK@ ++BUILD_PYTHON_SITE_PACKAGES = @BUILD_PYTHON_SITE_PACKAGES@ ++BUILD_PYTHON_SITE_PACKAGES_EXPANDED = @BUILD_PYTHON_SITE_PACKAGES_EXPANDED@ ++CC = @CC@ ++CCDEPMODE = @CCDEPMODE@ ++CFLAGS = @CFLAGS@ ++CONTRIBDIR = @CONTRIBDIR@ ++CPP = @CPP@ ++CPPFLAGS = @CPPFLAGS@ ++CYGPATH_W = @CYGPATH_W@ ++DEFS = @DEFS@ ++DEPDIR = @DEPDIR@ ++DLLTOOL = @DLLTOOL@ ++DSYMUTIL = @DSYMUTIL@ ++DUMPBIN = @DUMPBIN@ ++ECHO_C = @ECHO_C@ ++ECHO_N = @ECHO_N@ ++ECHO_T = @ECHO_T@ ++EGREP = @EGREP@ ++EVENTS_ENABLED = @EVENTS_ENABLED@ ++EVENTS_SUBDIR = @EVENTS_SUBDIR@ ++EXEEXT = @EXEEXT@ ++FGREP = @FGREP@ ++FUSERMOUNT_SUBDIR = @FUSERMOUNT_SUBDIR@ ++FUSE_CLIENT_SUBDIR = @FUSE_CLIENT_SUBDIR@ ++GEOREP_EXTRAS_SUBDIR = @GEOREP_EXTRAS_SUBDIR@ ++GFAPI_EXTRA_LDFLAGS = @GFAPI_EXTRA_LDFLAGS@ ++GFAPI_LIBS = @GFAPI_LIBS@ ++GFAPI_LT_VERSION = @GFAPI_LT_VERSION@ ++GFAPI_VERSION = @GFAPI_VERSION@ ++GF_CFLAGS = @GF_CFLAGS@ ++GF_CPPFLAGS = @GF_CPPFLAGS@ ++GF_DISTRIBUTION = @GF_DISTRIBUTION@ ++GF_FUSE_CFLAGS = @GF_FUSE_CFLAGS@ ++GF_FUSE_LDADD = @GF_FUSE_LDADD@ ++GF_HOST_OS = @GF_HOST_OS@ ++GF_LDADD = @GF_LDADD@ ++GF_LDFLAGS = @GF_LDFLAGS@ ++GF_NO_UNDEFINED = @GF_NO_UNDEFINED@ ++GF_XLATOR_DEFAULT_LDFLAGS = @GF_XLATOR_DEFAULT_LDFLAGS@ ++GF_XLATOR_LDFLAGS = @GF_XLATOR_LDFLAGS@ ++GLUPY_SUBDIR = @GLUPY_SUBDIR@ ++GLUPY_SUBDIR_MAKEFILE = @GLUPY_SUBDIR_MAKEFILE@ ++GLUPY_SUBDIR_SRC_MAKEFILE = @GLUPY_SUBDIR_SRC_MAKEFILE@ ++GLUSTERD_VOLFILE = @GLUSTERD_VOLFILE@ ++GLUSTERD_WORKDIR = @GLUSTERD_WORKDIR@ ++GLUSTERFSD_MISCDIR = @GLUSTERFSD_MISCDIR@ ++GLUSTERFS_LIBEXECDIR = @GLUSTERFS_LIBEXECDIR@ ++GREP = @GREP@ ++HAVE_ATOMIC_BUILTINS = @HAVE_ATOMIC_BUILTINS@ ++HAVE_BACKTRACE = @HAVE_BACKTRACE@ ++HAVE_LINKAT = @HAVE_LINKAT@ ++HAVE_MALLOC_STATS = @HAVE_MALLOC_STATS@ ++HAVE_SPINLOCK = @HAVE_SPINLOCK@ ++HAVE_STRNLEN = @HAVE_STRNLEN@ ++HAVE_SYNC_BUILTINS = @HAVE_SYNC_BUILTINS@ ++IBVERBS_SUBDIR = @IBVERBS_SUBDIR@ ++INSTALL = @INSTALL@ ++INSTALL_DATA = @INSTALL_DATA@ ++INSTALL_PROGRAM = @INSTALL_PROGRAM@ ++INSTALL_SCRIPT = @INSTALL_SCRIPT@ ++INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ ++LD = @LD@ ++LDFLAGS = @LDFLAGS@ ++LEX = @LEX@ ++LEXLIB = @LEXLIB@ ++LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ ++LIBAIO = @LIBAIO@ ++LIBGFCHANGELOG_LT_VERSION = @LIBGFCHANGELOG_LT_VERSION@ ++LIBGFCHANGELOG_VERSION = @LIBGFCHANGELOG_VERSION@ ++LIBGFDB_VERSION = @LIBGFDB_VERSION@ ++LIBGFRPC_LT_VERSION = @LIBGFRPC_LT_VERSION@ ++LIBGFXDR_LT_VERSION = @LIBGFXDR_LT_VERSION@ ++LIBGLUSTERFS_LT_VERSION = @LIBGLUSTERFS_LT_VERSION@ ++LIBOBJS = @LIBOBJS@ ++LIBS = @LIBS@ ++LIBTOOL = @LIBTOOL@ ++LIB_DL = @LIB_DL@ ++LIPO = @LIPO@ ++LN_S = @LN_S@ ++LTLIBOBJS = @LTLIBOBJS@ ++MAKEINFO = @MAKEINFO@ ++MANIFEST_TOOL = @MANIFEST_TOOL@ ++MATH_LIB = @MATH_LIB@ ++MKDIR_P = @MKDIR_P@ ++NM = @NM@ ++NMEDIT = @NMEDIT@ ++OBJDUMP = @OBJDUMP@ ++OBJEXT = @OBJEXT@ ++OCF_SUBDIR = @OCF_SUBDIR@ ++OTOOL = @OTOOL@ ++OTOOL64 = @OTOOL64@ ++PACKAGE = @PACKAGE@ ++PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ ++PACKAGE_NAME = @PACKAGE_NAME@ ++PACKAGE_RELEASE = @PACKAGE_RELEASE@ ++PACKAGE_STRING = @PACKAGE_STRING@ ++PACKAGE_TARNAME = @PACKAGE_TARNAME@ ++PACKAGE_URL = @PACKAGE_URL@ ++PACKAGE_VERSION = @PACKAGE_VERSION@ ++PATH_SEPARATOR = @PATH_SEPARATOR@ ++PKGCONFIG_UUID = @PKGCONFIG_UUID@ ++PKG_CONFIG = @PKG_CONFIG@ ++PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ ++PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ ++PYTHON = @PYTHON@ ++PYTHON_CFLAGS = @PYTHON_CFLAGS@ ++PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ ++PYTHON_LIBS = @PYTHON_LIBS@ ++PYTHON_PLATFORM = @PYTHON_PLATFORM@ ++PYTHON_PREFIX = @PYTHON_PREFIX@ ++PYTHON_VERSION = @PYTHON_VERSION@ ++RANLIB = @RANLIB@ ++RDMA_SUBDIR = @RDMA_SUBDIR@ ++RLLIBS = @RLLIBS@ ++RPCGEN = @RPCGEN@ ++SBIN_DIR = @SBIN_DIR@ ++SED = @SED@ ++SET_MAKE = @SET_MAKE@ ++SHELL = @SHELL@ ++SIZEOF_INT = @SIZEOF_INT@ ++SIZEOF_LONG = @SIZEOF_LONG@ ++SIZEOF_LONG_LONG = @SIZEOF_LONG_LONG@ ++SIZEOF_SHORT = @SIZEOF_SHORT@ ++SQLITE_CFLAGS = @SQLITE_CFLAGS@ ++SQLITE_LIBS = @SQLITE_LIBS@ ++STRIP = @STRIP@ ++SYNCDAEMON_COMPILE = @SYNCDAEMON_COMPILE@ ++SYNCDAEMON_SUBDIR = @SYNCDAEMON_SUBDIR@ ++SYSCONF_DIR = @SYSCONF_DIR@ ++TIRPC_CFLAGS = @TIRPC_CFLAGS@ ++TIRPC_LIBS = @TIRPC_LIBS@ ++UMOUNTD_SUBDIR = @UMOUNTD_SUBDIR@ ++UNITTEST_CFLAGS = @UNITTEST_CFLAGS@ ++UNITTEST_LDFLAGS = @UNITTEST_LDFLAGS@ ++UNITTEST_LIBS = @UNITTEST_LIBS@ ++URCU_CDS_CFLAGS = @URCU_CDS_CFLAGS@ ++URCU_CDS_LIBS = @URCU_CDS_LIBS@ ++URCU_CFLAGS = @URCU_CFLAGS@ ++URCU_LIBS = @URCU_LIBS@ ++USE_EC_DYNAMIC_AVX = @USE_EC_DYNAMIC_AVX@ ++USE_EC_DYNAMIC_NEON = @USE_EC_DYNAMIC_NEON@ ++USE_EC_DYNAMIC_SSE = @USE_EC_DYNAMIC_SSE@ ++USE_EC_DYNAMIC_X64 = @USE_EC_DYNAMIC_X64@ ++USE_POSIX_ACLS = @USE_POSIX_ACLS@ ++UUID_CFLAGS = @UUID_CFLAGS@ ++UUID_LIBS = @UUID_LIBS@ ++VERSION = @VERSION@ ++XML_CFLAGS = @XML_CFLAGS@ ++XML_LIBS = @XML_LIBS@ ++YACC = @YACC@ ++YFLAGS = @YFLAGS@ ++ZLIB_CFLAGS = @ZLIB_CFLAGS@ ++ZLIB_LIBS = @ZLIB_LIBS@ ++abs_builddir = @abs_builddir@ ++abs_srcdir = @abs_srcdir@ ++abs_top_builddir = @abs_top_builddir@ ++abs_top_srcdir = @abs_top_srcdir@ ++ac_ct_AR = @ac_ct_AR@ ++ac_ct_CC = @ac_ct_CC@ ++ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ ++am__include = @am__include@ ++am__leading_dot = @am__leading_dot@ ++am__quote = @am__quote@ ++am__tar = @am__tar@ ++am__untar = @am__untar@ ++bindir = @bindir@ ++build = @build@ ++build_alias = @build_alias@ ++build_cpu = @build_cpu@ ++build_os = @build_os@ ++build_vendor = @build_vendor@ ++builddir = @builddir@ ++datadir = @datadir@ ++datarootdir = @datarootdir@ ++docdir = @docdir@ ++dvidir = @dvidir@ ++exec_prefix = @exec_prefix@ ++host = @host@ ++host_alias = @host_alias@ ++host_cpu = @host_cpu@ ++host_os = @host_os@ ++host_vendor = @host_vendor@ ++htmldir = @htmldir@ ++includedir = @includedir@ ++infodir = @infodir@ ++initdir = @initdir@ ++install_sh = @install_sh@ ++launchddir = @launchddir@ ++libdir = @libdir@ ++libexecdir = @libexecdir@ ++localedir = @localedir@ ++localstatedir = @localstatedir@ ++mandir = @mandir@ ++mkdir_p = @mkdir_p@ ++mountutildir = @mountutildir@ ++oldincludedir = @oldincludedir@ ++pdfdir = @pdfdir@ ++pkgconfigdir = @pkgconfigdir@ ++pkgpyexecdir = @pkgpyexecdir@ ++pkgpythondir = @pkgpythondir@ ++prefix = @prefix@ ++program_transform_name = @program_transform_name@ ++psdir = @psdir@ ++pyexecdir = @pyexecdir@ ++pythondir = @pythondir@ ++sbindir = @sbindir@ ++sharedstatedir = @sharedstatedir@ ++shrext_cmds = @shrext_cmds@ ++srcdir = @srcdir@ ++sysconfdir = @sysconfdir@ ++systemddir = @systemddir@ ++target_alias = @target_alias@ ++tmpfilesdir = @tmpfilesdir@ ++top_build_prefix = @top_build_prefix@ ++top_builddir = @top_builddir@ ++top_srcdir = @top_srcdir@ ++ ++# Install __init__.py into the Python site-packages area ++pyglupydir = @BUILD_PYTHON_SITE_PACKAGES@/gluster/glupy ++pyglupy_PYTHON = __init__.py ++CLEANFILES = ++all: all-am ++ ++.SUFFIXES: ++$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) ++ @for dep in $?; do \ ++ case '$(am__configure_deps)' in \ ++ *$$dep*) \ ++ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ ++ && { if test -f $@; then exit 0; else break; fi; }; \ ++ exit 1;; \ ++ esac; \ ++ done; \ ++ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign xlators/features/glupy/src/glupy/Makefile'; \ ++ $(am__cd) $(top_srcdir) && \ ++ $(AUTOMAKE) --foreign xlators/features/glupy/src/glupy/Makefile ++.PRECIOUS: Makefile ++Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status ++ @case '$?' in \ ++ *config.status*) \ ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ ++ *) \ ++ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ ++ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ ++ esac; ++ ++$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++ ++$(top_srcdir)/configure: $(am__configure_deps) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++$(ACLOCAL_M4): $(am__aclocal_m4_deps) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++$(am__aclocal_m4_deps): ++ ++mostlyclean-libtool: ++ -rm -f *.lo ++ ++clean-libtool: ++ -rm -rf .libs _libs ++install-pyglupyPYTHON: $(pyglupy_PYTHON) ++ @$(NORMAL_INSTALL) ++ @list='$(pyglupy_PYTHON)'; dlist=; list2=; test -n "$(pyglupydir)" || list=; \ ++ if test -n "$$list"; then \ ++ echo " $(MKDIR_P) '$(DESTDIR)$(pyglupydir)'"; \ ++ $(MKDIR_P) "$(DESTDIR)$(pyglupydir)" || exit 1; \ ++ fi; \ ++ for p in $$list; do \ ++ if test -f "$$p"; then b=; else b="$(srcdir)/"; fi; \ ++ if test -f $$b$$p; then \ ++ $(am__strip_dir) \ ++ dlist="$$dlist $$f"; \ ++ list2="$$list2 $$b$$p"; \ ++ else :; fi; \ ++ done; \ ++ for file in $$list2; do echo $$file; done | $(am__base_list) | \ ++ while read files; do \ ++ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pyglupydir)'"; \ ++ $(INSTALL_DATA) $$files "$(DESTDIR)$(pyglupydir)" || exit $$?; \ ++ done || exit $$?; \ ++ if test -n "$$dlist"; then \ ++ $(am__py_compile) --destdir "$(DESTDIR)" \ ++ --basedir "$(pyglupydir)" $$dlist; \ ++ else :; fi ++ ++uninstall-pyglupyPYTHON: ++ @$(NORMAL_UNINSTALL) ++ @list='$(pyglupy_PYTHON)'; test -n "$(pyglupydir)" || list=; \ ++ py_files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ ++ test -n "$$py_files" || exit 0; \ ++ dir='$(DESTDIR)$(pyglupydir)'; \ ++ pyc_files=`echo "$$py_files" | sed 's|$$|c|'`; \ ++ pyo_files=`echo "$$py_files" | sed 's|$$|o|'`; \ ++ py_files_pep3147=`echo "$$py_files" | $(am__pep3147_tweak)`; \ ++ echo "$$py_files_pep3147";\ ++ pyc_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|c|'`; \ ++ pyo_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|o|'`; \ ++ st=0; \ ++ for files in \ ++ "$$py_files" \ ++ "$$pyc_files" \ ++ "$$pyo_files" \ ++ "$$pyc_files_pep3147" \ ++ "$$pyo_files_pep3147" \ ++ ; do \ ++ $(am__uninstall_files_from_dir) || st=$$?; \ ++ done; \ ++ exit $$st ++tags TAGS: ++ ++ctags CTAGS: ++ ++cscope cscopelist: ++ ++ ++distdir: $(DISTFILES) ++ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ ++ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ ++ list='$(DISTFILES)'; \ ++ dist_files=`for file in $$list; do echo $$file; done | \ ++ sed -e "s|^$$srcdirstrip/||;t" \ ++ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ ++ case $$dist_files in \ ++ */*) $(MKDIR_P) `echo "$$dist_files" | \ ++ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ ++ sort -u` ;; \ ++ esac; \ ++ for file in $$dist_files; do \ ++ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ ++ if test -d $$d/$$file; then \ ++ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ ++ if test -d "$(distdir)/$$file"; then \ ++ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ ++ fi; \ ++ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ ++ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ ++ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ ++ fi; \ ++ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ ++ else \ ++ test -f "$(distdir)/$$file" \ ++ || cp -p $$d/$$file "$(distdir)/$$file" \ ++ || exit 1; \ ++ fi; \ ++ done ++check-am: all-am ++check: check-am ++all-am: Makefile ++installdirs: ++ for dir in "$(DESTDIR)$(pyglupydir)"; do \ ++ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ ++ done ++install: install-am ++install-exec: install-exec-am ++install-data: install-data-am ++uninstall: uninstall-am ++ ++install-am: all-am ++ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am ++ ++installcheck: installcheck-am ++install-strip: ++ if test -z '$(STRIP)'; then \ ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ ++ install; \ ++ else \ ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ ++ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ ++ fi ++mostlyclean-generic: ++ ++clean-generic: ++ -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) ++ ++distclean-generic: ++ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) ++ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) ++ ++maintainer-clean-generic: ++ @echo "This command is intended for maintainers to use" ++ @echo "it deletes files that may require special tools to rebuild." ++clean: clean-am ++ ++clean-am: clean-generic clean-libtool mostlyclean-am ++ ++distclean: distclean-am ++ -rm -f Makefile ++distclean-am: clean-am distclean-generic ++ ++dvi: dvi-am ++ ++dvi-am: ++ ++html: html-am ++ ++html-am: ++ ++info: info-am ++ ++info-am: ++ ++install-data-am: install-pyglupyPYTHON ++ ++install-dvi: install-dvi-am ++ ++install-dvi-am: ++ ++install-exec-am: ++ ++install-html: install-html-am ++ ++install-html-am: ++ ++install-info: install-info-am ++ ++install-info-am: ++ ++install-man: ++ ++install-pdf: install-pdf-am ++ ++install-pdf-am: ++ ++install-ps: install-ps-am ++ ++install-ps-am: ++ ++installcheck-am: ++ ++maintainer-clean: maintainer-clean-am ++ -rm -f Makefile ++maintainer-clean-am: distclean-am maintainer-clean-generic ++ ++mostlyclean: mostlyclean-am ++ ++mostlyclean-am: mostlyclean-generic mostlyclean-libtool ++ ++pdf: pdf-am ++ ++pdf-am: ++ ++ps: ps-am ++ ++ps-am: ++ ++uninstall-am: uninstall-pyglupyPYTHON ++ ++.MAKE: install-am install-strip ++ ++.PHONY: all all-am check check-am clean clean-generic clean-libtool \ ++ cscopelist-am ctags-am distclean distclean-generic \ ++ distclean-libtool distdir dvi dvi-am html html-am info info-am \ ++ install install-am install-data install-data-am install-dvi \ ++ install-dvi-am install-exec install-exec-am install-html \ ++ install-html-am install-info install-info-am install-man \ ++ install-pdf install-pdf-am install-ps install-ps-am \ ++ install-pyglupyPYTHON install-strip installcheck \ ++ installcheck-am installdirs maintainer-clean \ ++ maintainer-clean-generic mostlyclean mostlyclean-generic \ ++ mostlyclean-libtool pdf pdf-am ps ps-am tags-am uninstall \ ++ uninstall-am uninstall-pyglupyPYTHON ++ ++ ++# Tell versions [3.59,3.63) of GNU make to not export all variables. ++# Otherwise a system limit (for SysV at least) may be exceeded. ++.NOEXPORT: +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/src/setup.py.in 2019-07-06 08:49:31.000000000 -0400 +@@ -0,0 +1,24 @@ ++from distutils.core import setup ++ ++DESC = """GlusterFS is a distributed file-system capable of scaling to ++several petabytes. It aggregates various storage bricks over Infiniband ++RDMA or TCP/IP interconnect into one large parallel network file system. ++GlusterFS is one of the most sophisticated file systems in terms of ++features and extensibility. It borrows a powerful concept called ++Translators from GNU Hurd kernel. Much of the code in GlusterFS is in ++user space and easily manageable. ++ ++This package contains Glupy, the Python translator interface for GlusterFS.""" ++ ++setup( ++ name='glusterfs-glupy', ++ version='@PACKAGE_VERSION@', ++ description='Glupy is the Python translator interface for GlusterFS', ++ long_description=DESC, ++ author='Gluster Community', ++ author_email='gluster-devel@gluster.org', ++ license='LGPLv3', ++ url='http://gluster.org/', ++ package_dir={'gluster':''}, ++ packages=['gluster'] ++) +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/src/Makefile.in 2019-07-06 08:50:37.092967963 -0400 +@@ -0,0 +1,954 @@ ++# Makefile.in generated by automake 1.13.4 from Makefile.am. ++# @configure_input@ ++ ++# Copyright (C) 1994-2013 Free Software Foundation, Inc. ++ ++# This Makefile.in is free software; the Free Software Foundation ++# gives unlimited permission to copy and/or distribute it, ++# with or without modifications, as long as this notice is preserved. ++ ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY, to the extent permitted by law; without ++# even the implied warranty of MERCHANTABILITY or FITNESS FOR A ++# PARTICULAR PURPOSE. ++ ++@SET_MAKE@ ++ ++ ++VPATH = @srcdir@ ++am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' ++am__make_running_with_option = \ ++ case $${target_option-} in \ ++ ?) ;; \ ++ *) echo "am__make_running_with_option: internal error: invalid" \ ++ "target option '$${target_option-}' specified" >&2; \ ++ exit 1;; \ ++ esac; \ ++ has_opt=no; \ ++ sane_makeflags=$$MAKEFLAGS; \ ++ if $(am__is_gnu_make); then \ ++ sane_makeflags=$$MFLAGS; \ ++ else \ ++ case $$MAKEFLAGS in \ ++ *\\[\ \ ]*) \ ++ bs=\\; \ ++ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ ++ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ ++ esac; \ ++ fi; \ ++ skip_next=no; \ ++ strip_trailopt () \ ++ { \ ++ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ ++ }; \ ++ for flg in $$sane_makeflags; do \ ++ test $$skip_next = yes && { skip_next=no; continue; }; \ ++ case $$flg in \ ++ *=*|--*) continue;; \ ++ -*I) strip_trailopt 'I'; skip_next=yes;; \ ++ -*I?*) strip_trailopt 'I';; \ ++ -*O) strip_trailopt 'O'; skip_next=yes;; \ ++ -*O?*) strip_trailopt 'O';; \ ++ -*l) strip_trailopt 'l'; skip_next=yes;; \ ++ -*l?*) strip_trailopt 'l';; \ ++ -[dEDm]) skip_next=yes;; \ ++ -[JT]) skip_next=yes;; \ ++ esac; \ ++ case $$flg in \ ++ *$$target_option*) has_opt=yes; break;; \ ++ esac; \ ++ done; \ ++ test $$has_opt = yes ++am__make_dryrun = (target_option=n; $(am__make_running_with_option)) ++am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) ++pkgdatadir = $(datadir)/@PACKAGE@ ++pkgincludedir = $(includedir)/@PACKAGE@ ++pkglibdir = $(libdir)/@PACKAGE@ ++pkglibexecdir = $(libexecdir)/@PACKAGE@ ++am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd ++install_sh_DATA = $(install_sh) -c -m 644 ++install_sh_PROGRAM = $(install_sh) -c ++install_sh_SCRIPT = $(install_sh) -c ++INSTALL_HEADER = $(INSTALL_DATA) ++transform = $(program_transform_name) ++NORMAL_INSTALL = : ++PRE_INSTALL = : ++POST_INSTALL = : ++NORMAL_UNINSTALL = : ++PRE_UNINSTALL = : ++POST_UNINSTALL = : ++build_triplet = @build@ ++host_triplet = @host@ ++subdir = xlators/features/glupy/src ++DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ ++ $(srcdir)/setup.py.in $(srcdir)/__init__.py.in \ ++ $(top_srcdir)/depcomp $(pyglupy_PYTHON) \ ++ $(top_srcdir)/py-compile $(noinst_HEADERS) ++ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 ++am__aclocal_m4_deps = $(top_srcdir)/contrib/aclocal/mkdirp.m4 \ ++ $(top_srcdir)/contrib/aclocal/python.m4 \ ++ $(top_srcdir)/configure.ac ++am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ ++ $(ACLOCAL_M4) ++mkinstalldirs = $(install_sh) -d ++CONFIG_HEADER = $(top_builddir)/config.h $(top_builddir)/site.h ++CONFIG_CLEAN_FILES = setup.py __init__.py ++CONFIG_CLEAN_VPATH_FILES = ++am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; ++am__vpath_adj = case $$p in \ ++ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ ++ *) f=$$p;; \ ++ esac; ++am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; ++am__install_max = 40 ++am__nobase_strip_setup = \ ++ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` ++am__nobase_strip = \ ++ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" ++am__nobase_list = $(am__nobase_strip_setup); \ ++ for p in $$list; do echo "$$p $$p"; done | \ ++ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ ++ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ ++ if (++n[$$2] == $(am__install_max)) \ ++ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ ++ END { for (dir in files) print dir, files[dir] }' ++am__base_list = \ ++ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ ++ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' ++am__uninstall_files_from_dir = { \ ++ test -z "$$files" \ ++ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ ++ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ ++ $(am__cd) "$$dir" && rm -f $$files; }; \ ++ } ++am__installdirs = "$(DESTDIR)$(xlatordir)" "$(DESTDIR)$(pyglupydir)" ++LTLIBRARIES = $(xlator_LTLIBRARIES) ++am__DEPENDENCIES_1 = ++glupy_la_DEPENDENCIES = \ ++ $(top_builddir)/libglusterfs/src/libglusterfs.la \ ++ $(am__DEPENDENCIES_1) ++am_glupy_la_OBJECTS = glupy.lo ++glupy_la_OBJECTS = $(am_glupy_la_OBJECTS) ++AM_V_lt = $(am__v_lt_@AM_V@) ++am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) ++am__v_lt_0 = --silent ++am__v_lt_1 = ++glupy_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ ++ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ ++ $(glupy_la_LDFLAGS) $(LDFLAGS) -o $@ ++AM_V_P = $(am__v_P_@AM_V@) ++am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) ++am__v_P_0 = false ++am__v_P_1 = : ++AM_V_GEN = $(am__v_GEN_@AM_V@) ++am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) ++am__v_GEN_0 = @echo " GEN " $@; ++am__v_GEN_1 = ++AM_V_at = $(am__v_at_@AM_V@) ++am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) ++am__v_at_0 = @ ++am__v_at_1 = ++DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) ++depcomp = $(SHELL) $(top_srcdir)/depcomp ++am__depfiles_maybe = depfiles ++am__mv = mv -f ++COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ ++ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) ++LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ ++ $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ ++ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ ++ $(AM_CFLAGS) $(CFLAGS) ++AM_V_CC = $(am__v_CC_@AM_V@) ++am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) ++am__v_CC_0 = @echo " CC " $@; ++am__v_CC_1 = ++CCLD = $(CC) ++LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ ++ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ ++ $(AM_LDFLAGS) $(LDFLAGS) -o $@ ++AM_V_CCLD = $(am__v_CCLD_@AM_V@) ++am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) ++am__v_CCLD_0 = @echo " CCLD " $@; ++am__v_CCLD_1 = ++SOURCES = $(glupy_la_SOURCES) ++DIST_SOURCES = $(glupy_la_SOURCES) ++RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ ++ ctags-recursive dvi-recursive html-recursive info-recursive \ ++ install-data-recursive install-dvi-recursive \ ++ install-exec-recursive install-html-recursive \ ++ install-info-recursive install-pdf-recursive \ ++ install-ps-recursive install-recursive installcheck-recursive \ ++ installdirs-recursive pdf-recursive ps-recursive \ ++ tags-recursive uninstall-recursive ++am__can_run_installinfo = \ ++ case $$AM_UPDATE_INFO_DIR in \ ++ n|no|NO) false;; \ ++ *) (install-info --version) >/dev/null 2>&1;; \ ++ esac ++am__py_compile = PYTHON=$(PYTHON) $(SHELL) $(py_compile) ++am__pep3147_tweak = \ ++ sed -e 's|\.py$$||' -e 's|[^/]*$$|__pycache__/&.*.py|' ++py_compile = $(top_srcdir)/py-compile ++HEADERS = $(noinst_HEADERS) ++RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ ++ distclean-recursive maintainer-clean-recursive ++am__recursive_targets = \ ++ $(RECURSIVE_TARGETS) \ ++ $(RECURSIVE_CLEAN_TARGETS) \ ++ $(am__extra_recursive_targets) ++AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ ++ distdir ++am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) ++# Read a list of newline-separated strings from the standard input, ++# and print each of them once, without duplicates. Input order is ++# *not* preserved. ++am__uniquify_input = $(AWK) '\ ++ BEGIN { nonempty = 0; } \ ++ { items[$$0] = 1; nonempty = 1; } \ ++ END { if (nonempty) { for (i in items) print i; }; } \ ++' ++# Make sure the list of sources is unique. This is necessary because, ++# e.g., the same source file might be shared among _SOURCES variables ++# for different programs/libraries. ++am__define_uniq_tagged_files = \ ++ list='$(am__tagged_files)'; \ ++ unique=`for i in $$list; do \ ++ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ ++ done | $(am__uniquify_input)` ++ETAGS = etags ++CTAGS = ctags ++DIST_SUBDIRS = $(SUBDIRS) ++DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ++am__relativize = \ ++ dir0=`pwd`; \ ++ sed_first='s,^\([^/]*\)/.*$$,\1,'; \ ++ sed_rest='s,^[^/]*/*,,'; \ ++ sed_last='s,^.*/\([^/]*\)$$,\1,'; \ ++ sed_butlast='s,/*[^/]*$$,,'; \ ++ while test -n "$$dir1"; do \ ++ first=`echo "$$dir1" | sed -e "$$sed_first"`; \ ++ if test "$$first" != "."; then \ ++ if test "$$first" = ".."; then \ ++ dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ ++ dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ ++ else \ ++ first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ ++ if test "$$first2" = "$$first"; then \ ++ dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ ++ else \ ++ dir2="../$$dir2"; \ ++ fi; \ ++ dir0="$$dir0"/"$$first"; \ ++ fi; \ ++ fi; \ ++ dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ ++ done; \ ++ reldir="$$dir2" ++ACLOCAL = @ACLOCAL@ ++ACL_LIBS = @ACL_LIBS@ ++AMTAR = @AMTAR@ ++AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ ++AM_LIBTOOLFLAGS = @AM_LIBTOOLFLAGS@ ++AM_MAKEFLAGS = @AM_MAKEFLAGS@ ++AR = @AR@ ++ARGP_LDADD = @ARGP_LDADD@ ++AUTOCONF = @AUTOCONF@ ++AUTOHEADER = @AUTOHEADER@ ++AUTOMAKE = @AUTOMAKE@ ++AWK = @AWK@ ++BUILD_PYTHON_SITE_PACKAGES = @BUILD_PYTHON_SITE_PACKAGES@ ++BUILD_PYTHON_SITE_PACKAGES_EXPANDED = @BUILD_PYTHON_SITE_PACKAGES_EXPANDED@ ++CC = @CC@ ++CCDEPMODE = @CCDEPMODE@ ++CFLAGS = @CFLAGS@ ++CONTRIBDIR = @CONTRIBDIR@ ++CPP = @CPP@ ++CPPFLAGS = @CPPFLAGS@ ++CYGPATH_W = @CYGPATH_W@ ++DEFS = @DEFS@ ++DEPDIR = @DEPDIR@ ++DLLTOOL = @DLLTOOL@ ++DSYMUTIL = @DSYMUTIL@ ++DUMPBIN = @DUMPBIN@ ++ECHO_C = @ECHO_C@ ++ECHO_N = @ECHO_N@ ++ECHO_T = @ECHO_T@ ++EGREP = @EGREP@ ++EVENTS_ENABLED = @EVENTS_ENABLED@ ++EVENTS_SUBDIR = @EVENTS_SUBDIR@ ++EXEEXT = @EXEEXT@ ++FGREP = @FGREP@ ++FUSERMOUNT_SUBDIR = @FUSERMOUNT_SUBDIR@ ++FUSE_CLIENT_SUBDIR = @FUSE_CLIENT_SUBDIR@ ++GEOREP_EXTRAS_SUBDIR = @GEOREP_EXTRAS_SUBDIR@ ++GFAPI_EXTRA_LDFLAGS = @GFAPI_EXTRA_LDFLAGS@ ++GFAPI_LIBS = @GFAPI_LIBS@ ++GFAPI_LT_VERSION = @GFAPI_LT_VERSION@ ++GFAPI_VERSION = @GFAPI_VERSION@ ++GF_CFLAGS = @GF_CFLAGS@ ++GF_CPPFLAGS = @GF_CPPFLAGS@ ++GF_DISTRIBUTION = @GF_DISTRIBUTION@ ++GF_FUSE_CFLAGS = @GF_FUSE_CFLAGS@ ++GF_FUSE_LDADD = @GF_FUSE_LDADD@ ++GF_HOST_OS = @GF_HOST_OS@ ++GF_LDADD = @GF_LDADD@ ++GF_LDFLAGS = @GF_LDFLAGS@ ++GF_NO_UNDEFINED = @GF_NO_UNDEFINED@ ++GF_XLATOR_DEFAULT_LDFLAGS = @GF_XLATOR_DEFAULT_LDFLAGS@ ++GF_XLATOR_LDFLAGS = @GF_XLATOR_LDFLAGS@ ++GLUPY_SUBDIR = @GLUPY_SUBDIR@ ++GLUPY_SUBDIR_MAKEFILE = @GLUPY_SUBDIR_MAKEFILE@ ++GLUPY_SUBDIR_SRC_MAKEFILE = @GLUPY_SUBDIR_SRC_MAKEFILE@ ++GLUSTERD_VOLFILE = @GLUSTERD_VOLFILE@ ++GLUSTERD_WORKDIR = @GLUSTERD_WORKDIR@ ++GLUSTERFSD_MISCDIR = @GLUSTERFSD_MISCDIR@ ++GLUSTERFS_LIBEXECDIR = @GLUSTERFS_LIBEXECDIR@ ++GREP = @GREP@ ++HAVE_ATOMIC_BUILTINS = @HAVE_ATOMIC_BUILTINS@ ++HAVE_BACKTRACE = @HAVE_BACKTRACE@ ++HAVE_LINKAT = @HAVE_LINKAT@ ++HAVE_MALLOC_STATS = @HAVE_MALLOC_STATS@ ++HAVE_SPINLOCK = @HAVE_SPINLOCK@ ++HAVE_STRNLEN = @HAVE_STRNLEN@ ++HAVE_SYNC_BUILTINS = @HAVE_SYNC_BUILTINS@ ++IBVERBS_SUBDIR = @IBVERBS_SUBDIR@ ++INSTALL = @INSTALL@ ++INSTALL_DATA = @INSTALL_DATA@ ++INSTALL_PROGRAM = @INSTALL_PROGRAM@ ++INSTALL_SCRIPT = @INSTALL_SCRIPT@ ++INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ ++LD = @LD@ ++LDFLAGS = @LDFLAGS@ ++LEX = @LEX@ ++LEXLIB = @LEXLIB@ ++LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ ++LIBAIO = @LIBAIO@ ++LIBGFCHANGELOG_LT_VERSION = @LIBGFCHANGELOG_LT_VERSION@ ++LIBGFCHANGELOG_VERSION = @LIBGFCHANGELOG_VERSION@ ++LIBGFDB_VERSION = @LIBGFDB_VERSION@ ++LIBGFRPC_LT_VERSION = @LIBGFRPC_LT_VERSION@ ++LIBGFXDR_LT_VERSION = @LIBGFXDR_LT_VERSION@ ++LIBGLUSTERFS_LT_VERSION = @LIBGLUSTERFS_LT_VERSION@ ++LIBOBJS = @LIBOBJS@ ++LIBS = @LIBS@ ++LIBTOOL = @LIBTOOL@ ++LIB_DL = @LIB_DL@ ++LIPO = @LIPO@ ++LN_S = @LN_S@ ++LTLIBOBJS = @LTLIBOBJS@ ++MAKEINFO = @MAKEINFO@ ++MANIFEST_TOOL = @MANIFEST_TOOL@ ++MATH_LIB = @MATH_LIB@ ++MKDIR_P = @MKDIR_P@ ++NM = @NM@ ++NMEDIT = @NMEDIT@ ++OBJDUMP = @OBJDUMP@ ++OBJEXT = @OBJEXT@ ++OCF_SUBDIR = @OCF_SUBDIR@ ++OTOOL = @OTOOL@ ++OTOOL64 = @OTOOL64@ ++PACKAGE = @PACKAGE@ ++PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ ++PACKAGE_NAME = @PACKAGE_NAME@ ++PACKAGE_RELEASE = @PACKAGE_RELEASE@ ++PACKAGE_STRING = @PACKAGE_STRING@ ++PACKAGE_TARNAME = @PACKAGE_TARNAME@ ++PACKAGE_URL = @PACKAGE_URL@ ++PACKAGE_VERSION = @PACKAGE_VERSION@ ++PATH_SEPARATOR = @PATH_SEPARATOR@ ++PKGCONFIG_UUID = @PKGCONFIG_UUID@ ++PKG_CONFIG = @PKG_CONFIG@ ++PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ ++PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ ++PYTHON = @PYTHON@ ++PYTHON_CFLAGS = @PYTHON_CFLAGS@ ++PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ ++PYTHON_LIBS = @PYTHON_LIBS@ ++PYTHON_PLATFORM = @PYTHON_PLATFORM@ ++PYTHON_PREFIX = @PYTHON_PREFIX@ ++PYTHON_VERSION = @PYTHON_VERSION@ ++RANLIB = @RANLIB@ ++RDMA_SUBDIR = @RDMA_SUBDIR@ ++RLLIBS = @RLLIBS@ ++RPCGEN = @RPCGEN@ ++SBIN_DIR = @SBIN_DIR@ ++SED = @SED@ ++SET_MAKE = @SET_MAKE@ ++SHELL = @SHELL@ ++SIZEOF_INT = @SIZEOF_INT@ ++SIZEOF_LONG = @SIZEOF_LONG@ ++SIZEOF_LONG_LONG = @SIZEOF_LONG_LONG@ ++SIZEOF_SHORT = @SIZEOF_SHORT@ ++SQLITE_CFLAGS = @SQLITE_CFLAGS@ ++SQLITE_LIBS = @SQLITE_LIBS@ ++STRIP = @STRIP@ ++SYNCDAEMON_COMPILE = @SYNCDAEMON_COMPILE@ ++SYNCDAEMON_SUBDIR = @SYNCDAEMON_SUBDIR@ ++SYSCONF_DIR = @SYSCONF_DIR@ ++TIRPC_CFLAGS = @TIRPC_CFLAGS@ ++TIRPC_LIBS = @TIRPC_LIBS@ ++UMOUNTD_SUBDIR = @UMOUNTD_SUBDIR@ ++UNITTEST_CFLAGS = @UNITTEST_CFLAGS@ ++UNITTEST_LDFLAGS = @UNITTEST_LDFLAGS@ ++UNITTEST_LIBS = @UNITTEST_LIBS@ ++URCU_CDS_CFLAGS = @URCU_CDS_CFLAGS@ ++URCU_CDS_LIBS = @URCU_CDS_LIBS@ ++URCU_CFLAGS = @URCU_CFLAGS@ ++URCU_LIBS = @URCU_LIBS@ ++USE_EC_DYNAMIC_AVX = @USE_EC_DYNAMIC_AVX@ ++USE_EC_DYNAMIC_NEON = @USE_EC_DYNAMIC_NEON@ ++USE_EC_DYNAMIC_SSE = @USE_EC_DYNAMIC_SSE@ ++USE_EC_DYNAMIC_X64 = @USE_EC_DYNAMIC_X64@ ++USE_POSIX_ACLS = @USE_POSIX_ACLS@ ++UUID_CFLAGS = @UUID_CFLAGS@ ++UUID_LIBS = @UUID_LIBS@ ++VERSION = @VERSION@ ++XML_CFLAGS = @XML_CFLAGS@ ++XML_LIBS = @XML_LIBS@ ++YACC = @YACC@ ++YFLAGS = @YFLAGS@ ++ZLIB_CFLAGS = @ZLIB_CFLAGS@ ++ZLIB_LIBS = @ZLIB_LIBS@ ++abs_builddir = @abs_builddir@ ++abs_srcdir = @abs_srcdir@ ++abs_top_builddir = @abs_top_builddir@ ++abs_top_srcdir = @abs_top_srcdir@ ++ac_ct_AR = @ac_ct_AR@ ++ac_ct_CC = @ac_ct_CC@ ++ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ ++am__include = @am__include@ ++am__leading_dot = @am__leading_dot@ ++am__quote = @am__quote@ ++am__tar = @am__tar@ ++am__untar = @am__untar@ ++bindir = @bindir@ ++build = @build@ ++build_alias = @build_alias@ ++build_cpu = @build_cpu@ ++build_os = @build_os@ ++build_vendor = @build_vendor@ ++builddir = @builddir@ ++datadir = @datadir@ ++datarootdir = @datarootdir@ ++docdir = @docdir@ ++dvidir = @dvidir@ ++exec_prefix = @exec_prefix@ ++host = @host@ ++host_alias = @host_alias@ ++host_cpu = @host_cpu@ ++host_os = @host_os@ ++host_vendor = @host_vendor@ ++htmldir = @htmldir@ ++includedir = @includedir@ ++infodir = @infodir@ ++initdir = @initdir@ ++install_sh = @install_sh@ ++launchddir = @launchddir@ ++libdir = @libdir@ ++libexecdir = @libexecdir@ ++localedir = @localedir@ ++localstatedir = @localstatedir@ ++mandir = @mandir@ ++mkdir_p = @mkdir_p@ ++mountutildir = @mountutildir@ ++oldincludedir = @oldincludedir@ ++pdfdir = @pdfdir@ ++pkgconfigdir = @pkgconfigdir@ ++pkgpyexecdir = @pkgpyexecdir@ ++pkgpythondir = @pkgpythondir@ ++prefix = @prefix@ ++program_transform_name = @program_transform_name@ ++psdir = @psdir@ ++pyexecdir = @pyexecdir@ ++pythondir = @pythondir@ ++sbindir = @sbindir@ ++sharedstatedir = @sharedstatedir@ ++shrext_cmds = @shrext_cmds@ ++srcdir = @srcdir@ ++sysconfdir = @sysconfdir@ ++systemddir = @systemddir@ ++target_alias = @target_alias@ ++tmpfilesdir = @tmpfilesdir@ ++top_build_prefix = @top_build_prefix@ ++top_builddir = @top_builddir@ ++top_srcdir = @top_srcdir@ ++xlator_LTLIBRARIES = glupy.la ++ ++# Ensure GLUSTER_PYTHON_PATH is passed to glupy.so ++xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/features ++glupydir = $(xlatordir)/glupy ++AM_CPPFLAGS = $(GF_CPPFLAGS) \ ++ -I$(top_srcdir)/libglusterfs/src \ ++ -I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src ++ ++AM_CFLAGS = -Wall -fno-strict-aliasing \ ++ -DGLUSTER_PYTHON_PATH=\"$(glupydir)\" \ ++ -DPATH_GLUSTERFS_GLUPY_MODULE=\"${xlatordir}/glupy${shrext_cmds}\" \ ++ $(GF_CFLAGS) $(PYTHON_CFLAGS) ++ ++ ++# Flags to build glupy.so with ++glupy_la_LDFLAGS = -module -nostartfiles \ ++ -export-symbols $(top_srcdir)/xlators/features/glupy/src/glupy.sym \ ++ $(GF_XLATOR_LDFLAGS) $(PYTHON_LIBS) ++ ++glupy_la_SOURCES = glupy.c ++glupy_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \ ++ -lpthread $(LIB_DL) ++ ++noinst_HEADERS = glupy.h ++ ++# Install __init__.py into the Python site-packages area ++pyglupydir = @BUILD_PYTHON_SITE_PACKAGES@/gluster ++pyglupy_PYTHON = __init__.py ++ ++# Install glupy/__init_-.py into the Python site-packages area ++SUBDIRS = glupy ++CLEANFILES = ++EXTRA_DIST = glupy.sym ++all: all-recursive ++ ++.SUFFIXES: ++.SUFFIXES: .c .lo .o .obj ++$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) ++ @for dep in $?; do \ ++ case '$(am__configure_deps)' in \ ++ *$$dep*) \ ++ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ ++ && { if test -f $@; then exit 0; else break; fi; }; \ ++ exit 1;; \ ++ esac; \ ++ done; \ ++ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign xlators/features/glupy/src/Makefile'; \ ++ $(am__cd) $(top_srcdir) && \ ++ $(AUTOMAKE) --foreign xlators/features/glupy/src/Makefile ++.PRECIOUS: Makefile ++Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status ++ @case '$?' in \ ++ *config.status*) \ ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ ++ *) \ ++ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ ++ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ ++ esac; ++ ++$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++ ++$(top_srcdir)/configure: $(am__configure_deps) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++$(ACLOCAL_M4): $(am__aclocal_m4_deps) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++$(am__aclocal_m4_deps): ++setup.py: $(top_builddir)/config.status $(srcdir)/setup.py.in ++ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ ++__init__.py: $(top_builddir)/config.status $(srcdir)/__init__.py.in ++ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ ++ ++install-xlatorLTLIBRARIES: $(xlator_LTLIBRARIES) ++ @$(NORMAL_INSTALL) ++ @list='$(xlator_LTLIBRARIES)'; test -n "$(xlatordir)" || list=; \ ++ list2=; for p in $$list; do \ ++ if test -f $$p; then \ ++ list2="$$list2 $$p"; \ ++ else :; fi; \ ++ done; \ ++ test -z "$$list2" || { \ ++ echo " $(MKDIR_P) '$(DESTDIR)$(xlatordir)'"; \ ++ $(MKDIR_P) "$(DESTDIR)$(xlatordir)" || exit 1; \ ++ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(xlatordir)'"; \ ++ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(xlatordir)"; \ ++ } ++ ++uninstall-xlatorLTLIBRARIES: ++ @$(NORMAL_UNINSTALL) ++ @list='$(xlator_LTLIBRARIES)'; test -n "$(xlatordir)" || list=; \ ++ for p in $$list; do \ ++ $(am__strip_dir) \ ++ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(xlatordir)/$$f'"; \ ++ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(xlatordir)/$$f"; \ ++ done ++ ++clean-xlatorLTLIBRARIES: ++ -test -z "$(xlator_LTLIBRARIES)" || rm -f $(xlator_LTLIBRARIES) ++ @list='$(xlator_LTLIBRARIES)'; \ ++ locs=`for p in $$list; do echo $$p; done | \ ++ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ ++ sort -u`; \ ++ test -z "$$locs" || { \ ++ echo rm -f $${locs}; \ ++ rm -f $${locs}; \ ++ } ++ ++glupy.la: $(glupy_la_OBJECTS) $(glupy_la_DEPENDENCIES) $(EXTRA_glupy_la_DEPENDENCIES) ++ $(AM_V_CCLD)$(glupy_la_LINK) -rpath $(xlatordir) $(glupy_la_OBJECTS) $(glupy_la_LIBADD) $(LIBS) ++ ++mostlyclean-compile: ++ -rm -f *.$(OBJEXT) ++ ++distclean-compile: ++ -rm -f *.tab.c ++ ++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/glupy.Plo@am__quote@ ++ ++.c.o: ++@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< ++@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ ++@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c $< ++ ++.c.obj: ++@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` ++@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ ++@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c `$(CYGPATH_W) '$<'` ++ ++.c.lo: ++@am__fastdepCC_TRUE@ $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< ++@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ ++@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $< ++ ++mostlyclean-libtool: ++ -rm -f *.lo ++ ++clean-libtool: ++ -rm -rf .libs _libs ++install-pyglupyPYTHON: $(pyglupy_PYTHON) ++ @$(NORMAL_INSTALL) ++ @list='$(pyglupy_PYTHON)'; dlist=; list2=; test -n "$(pyglupydir)" || list=; \ ++ if test -n "$$list"; then \ ++ echo " $(MKDIR_P) '$(DESTDIR)$(pyglupydir)'"; \ ++ $(MKDIR_P) "$(DESTDIR)$(pyglupydir)" || exit 1; \ ++ fi; \ ++ for p in $$list; do \ ++ if test -f "$$p"; then b=; else b="$(srcdir)/"; fi; \ ++ if test -f $$b$$p; then \ ++ $(am__strip_dir) \ ++ dlist="$$dlist $$f"; \ ++ list2="$$list2 $$b$$p"; \ ++ else :; fi; \ ++ done; \ ++ for file in $$list2; do echo $$file; done | $(am__base_list) | \ ++ while read files; do \ ++ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pyglupydir)'"; \ ++ $(INSTALL_DATA) $$files "$(DESTDIR)$(pyglupydir)" || exit $$?; \ ++ done || exit $$?; \ ++ if test -n "$$dlist"; then \ ++ $(am__py_compile) --destdir "$(DESTDIR)" \ ++ --basedir "$(pyglupydir)" $$dlist; \ ++ else :; fi ++ ++uninstall-pyglupyPYTHON: ++ @$(NORMAL_UNINSTALL) ++ @list='$(pyglupy_PYTHON)'; test -n "$(pyglupydir)" || list=; \ ++ py_files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ ++ test -n "$$py_files" || exit 0; \ ++ dir='$(DESTDIR)$(pyglupydir)'; \ ++ pyc_files=`echo "$$py_files" | sed 's|$$|c|'`; \ ++ pyo_files=`echo "$$py_files" | sed 's|$$|o|'`; \ ++ py_files_pep3147=`echo "$$py_files" | $(am__pep3147_tweak)`; \ ++ echo "$$py_files_pep3147";\ ++ pyc_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|c|'`; \ ++ pyo_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|o|'`; \ ++ st=0; \ ++ for files in \ ++ "$$py_files" \ ++ "$$pyc_files" \ ++ "$$pyo_files" \ ++ "$$pyc_files_pep3147" \ ++ "$$pyo_files_pep3147" \ ++ ; do \ ++ $(am__uninstall_files_from_dir) || st=$$?; \ ++ done; \ ++ exit $$st ++ ++# This directory's subdirectories are mostly independent; you can cd ++# into them and run 'make' without going through this Makefile. ++# To change the values of 'make' variables: instead of editing Makefiles, ++# (1) if the variable is set in 'config.status', edit 'config.status' ++# (which will cause the Makefiles to be regenerated when you run 'make'); ++# (2) otherwise, pass the desired values on the 'make' command line. ++$(am__recursive_targets): ++ @fail=; \ ++ if $(am__make_keepgoing); then \ ++ failcom='fail=yes'; \ ++ else \ ++ failcom='exit 1'; \ ++ fi; \ ++ dot_seen=no; \ ++ target=`echo $@ | sed s/-recursive//`; \ ++ case "$@" in \ ++ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ ++ *) list='$(SUBDIRS)' ;; \ ++ esac; \ ++ for subdir in $$list; do \ ++ echo "Making $$target in $$subdir"; \ ++ if test "$$subdir" = "."; then \ ++ dot_seen=yes; \ ++ local_target="$$target-am"; \ ++ else \ ++ local_target="$$target"; \ ++ fi; \ ++ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ ++ || eval $$failcom; \ ++ done; \ ++ if test "$$dot_seen" = "no"; then \ ++ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ ++ fi; test -z "$$fail" ++ ++ID: $(am__tagged_files) ++ $(am__define_uniq_tagged_files); mkid -fID $$unique ++tags: tags-recursive ++TAGS: tags ++ ++tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) ++ set x; \ ++ here=`pwd`; \ ++ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ ++ include_option=--etags-include; \ ++ empty_fix=.; \ ++ else \ ++ include_option=--include; \ ++ empty_fix=; \ ++ fi; \ ++ list='$(SUBDIRS)'; for subdir in $$list; do \ ++ if test "$$subdir" = .; then :; else \ ++ test ! -f $$subdir/TAGS || \ ++ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ ++ fi; \ ++ done; \ ++ $(am__define_uniq_tagged_files); \ ++ shift; \ ++ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ ++ test -n "$$unique" || unique=$$empty_fix; \ ++ if test $$# -gt 0; then \ ++ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ ++ "$$@" $$unique; \ ++ else \ ++ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ ++ $$unique; \ ++ fi; \ ++ fi ++ctags: ctags-recursive ++ ++CTAGS: ctags ++ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) ++ $(am__define_uniq_tagged_files); \ ++ test -z "$(CTAGS_ARGS)$$unique" \ ++ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ ++ $$unique ++ ++GTAGS: ++ here=`$(am__cd) $(top_builddir) && pwd` \ ++ && $(am__cd) $(top_srcdir) \ ++ && gtags -i $(GTAGS_ARGS) "$$here" ++cscopelist: cscopelist-recursive ++ ++cscopelist-am: $(am__tagged_files) ++ list='$(am__tagged_files)'; \ ++ case "$(srcdir)" in \ ++ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ ++ *) sdir=$(subdir)/$(srcdir) ;; \ ++ esac; \ ++ for i in $$list; do \ ++ if test -f "$$i"; then \ ++ echo "$(subdir)/$$i"; \ ++ else \ ++ echo "$$sdir/$$i"; \ ++ fi; \ ++ done >> $(top_builddir)/cscope.files ++ ++distclean-tags: ++ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags ++ ++distdir: $(DISTFILES) ++ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ ++ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ ++ list='$(DISTFILES)'; \ ++ dist_files=`for file in $$list; do echo $$file; done | \ ++ sed -e "s|^$$srcdirstrip/||;t" \ ++ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ ++ case $$dist_files in \ ++ */*) $(MKDIR_P) `echo "$$dist_files" | \ ++ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ ++ sort -u` ;; \ ++ esac; \ ++ for file in $$dist_files; do \ ++ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ ++ if test -d $$d/$$file; then \ ++ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ ++ if test -d "$(distdir)/$$file"; then \ ++ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ ++ fi; \ ++ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ ++ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ ++ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ ++ fi; \ ++ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ ++ else \ ++ test -f "$(distdir)/$$file" \ ++ || cp -p $$d/$$file "$(distdir)/$$file" \ ++ || exit 1; \ ++ fi; \ ++ done ++ @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ ++ if test "$$subdir" = .; then :; else \ ++ $(am__make_dryrun) \ ++ || test -d "$(distdir)/$$subdir" \ ++ || $(MKDIR_P) "$(distdir)/$$subdir" \ ++ || exit 1; \ ++ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ ++ $(am__relativize); \ ++ new_distdir=$$reldir; \ ++ dir1=$$subdir; dir2="$(top_distdir)"; \ ++ $(am__relativize); \ ++ new_top_distdir=$$reldir; \ ++ echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ ++ echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ ++ ($(am__cd) $$subdir && \ ++ $(MAKE) $(AM_MAKEFLAGS) \ ++ top_distdir="$$new_top_distdir" \ ++ distdir="$$new_distdir" \ ++ am__remove_distdir=: \ ++ am__skip_length_check=: \ ++ am__skip_mode_fix=: \ ++ distdir) \ ++ || exit 1; \ ++ fi; \ ++ done ++check-am: all-am ++check: check-recursive ++all-am: Makefile $(LTLIBRARIES) $(HEADERS) ++installdirs: installdirs-recursive ++installdirs-am: ++ for dir in "$(DESTDIR)$(xlatordir)" "$(DESTDIR)$(pyglupydir)"; do \ ++ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ ++ done ++install: install-recursive ++install-exec: install-exec-recursive ++install-data: install-data-recursive ++uninstall: uninstall-recursive ++ ++install-am: all-am ++ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am ++ ++installcheck: installcheck-recursive ++install-strip: ++ if test -z '$(STRIP)'; then \ ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ ++ install; \ ++ else \ ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ ++ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ ++ fi ++mostlyclean-generic: ++ ++clean-generic: ++ -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) ++ ++distclean-generic: ++ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) ++ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) ++ ++maintainer-clean-generic: ++ @echo "This command is intended for maintainers to use" ++ @echo "it deletes files that may require special tools to rebuild." ++clean: clean-recursive ++ ++clean-am: clean-generic clean-libtool clean-xlatorLTLIBRARIES \ ++ mostlyclean-am ++ ++distclean: distclean-recursive ++ -rm -rf ./$(DEPDIR) ++ -rm -f Makefile ++distclean-am: clean-am distclean-compile distclean-generic \ ++ distclean-tags ++ ++dvi: dvi-recursive ++ ++dvi-am: ++ ++html: html-recursive ++ ++html-am: ++ ++info: info-recursive ++ ++info-am: ++ ++install-data-am: install-pyglupyPYTHON install-xlatorLTLIBRARIES ++ ++install-dvi: install-dvi-recursive ++ ++install-dvi-am: ++ ++install-exec-am: ++ ++install-html: install-html-recursive ++ ++install-html-am: ++ ++install-info: install-info-recursive ++ ++install-info-am: ++ ++install-man: ++ ++install-pdf: install-pdf-recursive ++ ++install-pdf-am: ++ ++install-ps: install-ps-recursive ++ ++install-ps-am: ++ ++installcheck-am: ++ ++maintainer-clean: maintainer-clean-recursive ++ -rm -rf ./$(DEPDIR) ++ -rm -f Makefile ++maintainer-clean-am: distclean-am maintainer-clean-generic ++ ++mostlyclean: mostlyclean-recursive ++ ++mostlyclean-am: mostlyclean-compile mostlyclean-generic \ ++ mostlyclean-libtool ++ ++pdf: pdf-recursive ++ ++pdf-am: ++ ++ps: ps-recursive ++ ++ps-am: ++ ++uninstall-am: uninstall-pyglupyPYTHON uninstall-xlatorLTLIBRARIES ++ ++.MAKE: $(am__recursive_targets) install-am install-strip ++ ++.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am check \ ++ check-am clean clean-generic clean-libtool \ ++ clean-xlatorLTLIBRARIES cscopelist-am ctags ctags-am distclean \ ++ distclean-compile distclean-generic distclean-libtool \ ++ distclean-tags distdir dvi dvi-am html html-am info info-am \ ++ install install-am install-data install-data-am install-dvi \ ++ install-dvi-am install-exec install-exec-am install-html \ ++ install-html-am install-info install-info-am install-man \ ++ install-pdf install-pdf-am install-ps install-ps-am \ ++ install-pyglupyPYTHON install-strip install-xlatorLTLIBRARIES \ ++ installcheck installcheck-am installdirs installdirs-am \ ++ maintainer-clean maintainer-clean-generic mostlyclean \ ++ mostlyclean-compile mostlyclean-generic mostlyclean-libtool \ ++ pdf pdf-am ps ps-am tags tags-am uninstall uninstall-am \ ++ uninstall-pyglupyPYTHON uninstall-xlatorLTLIBRARIES ++ ++ ++# Tell versions [3.59,3.63) of GNU make to not export all variables. ++# Otherwise a system limit (for SysV at least) may be exceeded. ++.NOEXPORT: +--- /dev/null 2019-06-26 14:01:23.038000000 -0400 ++++ xlators/features/glupy/Makefile.in 2019-07-06 08:50:36.896964027 -0400 +@@ -0,0 +1,717 @@ ++# Makefile.in generated by automake 1.13.4 from Makefile.am. ++# @configure_input@ ++ ++# Copyright (C) 1994-2013 Free Software Foundation, Inc. ++ ++# This Makefile.in is free software; the Free Software Foundation ++# gives unlimited permission to copy and/or distribute it, ++# with or without modifications, as long as this notice is preserved. ++ ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY, to the extent permitted by law; without ++# even the implied warranty of MERCHANTABILITY or FITNESS FOR A ++# PARTICULAR PURPOSE. ++ ++@SET_MAKE@ ++VPATH = @srcdir@ ++am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' ++am__make_running_with_option = \ ++ case $${target_option-} in \ ++ ?) ;; \ ++ *) echo "am__make_running_with_option: internal error: invalid" \ ++ "target option '$${target_option-}' specified" >&2; \ ++ exit 1;; \ ++ esac; \ ++ has_opt=no; \ ++ sane_makeflags=$$MAKEFLAGS; \ ++ if $(am__is_gnu_make); then \ ++ sane_makeflags=$$MFLAGS; \ ++ else \ ++ case $$MAKEFLAGS in \ ++ *\\[\ \ ]*) \ ++ bs=\\; \ ++ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ ++ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ ++ esac; \ ++ fi; \ ++ skip_next=no; \ ++ strip_trailopt () \ ++ { \ ++ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ ++ }; \ ++ for flg in $$sane_makeflags; do \ ++ test $$skip_next = yes && { skip_next=no; continue; }; \ ++ case $$flg in \ ++ *=*|--*) continue;; \ ++ -*I) strip_trailopt 'I'; skip_next=yes;; \ ++ -*I?*) strip_trailopt 'I';; \ ++ -*O) strip_trailopt 'O'; skip_next=yes;; \ ++ -*O?*) strip_trailopt 'O';; \ ++ -*l) strip_trailopt 'l'; skip_next=yes;; \ ++ -*l?*) strip_trailopt 'l';; \ ++ -[dEDm]) skip_next=yes;; \ ++ -[JT]) skip_next=yes;; \ ++ esac; \ ++ case $$flg in \ ++ *$$target_option*) has_opt=yes; break;; \ ++ esac; \ ++ done; \ ++ test $$has_opt = yes ++am__make_dryrun = (target_option=n; $(am__make_running_with_option)) ++am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) ++pkgdatadir = $(datadir)/@PACKAGE@ ++pkgincludedir = $(includedir)/@PACKAGE@ ++pkglibdir = $(libdir)/@PACKAGE@ ++pkglibexecdir = $(libexecdir)/@PACKAGE@ ++am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd ++install_sh_DATA = $(install_sh) -c -m 644 ++install_sh_PROGRAM = $(install_sh) -c ++install_sh_SCRIPT = $(install_sh) -c ++INSTALL_HEADER = $(INSTALL_DATA) ++transform = $(program_transform_name) ++NORMAL_INSTALL = : ++PRE_INSTALL = : ++POST_INSTALL = : ++NORMAL_UNINSTALL = : ++PRE_UNINSTALL = : ++POST_UNINSTALL = : ++build_triplet = @build@ ++host_triplet = @host@ ++subdir = xlators/features/glupy ++DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am ++ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 ++am__aclocal_m4_deps = $(top_srcdir)/contrib/aclocal/mkdirp.m4 \ ++ $(top_srcdir)/contrib/aclocal/python.m4 \ ++ $(top_srcdir)/configure.ac ++am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ ++ $(ACLOCAL_M4) ++mkinstalldirs = $(install_sh) -d ++CONFIG_HEADER = $(top_builddir)/config.h $(top_builddir)/site.h ++CONFIG_CLEAN_FILES = ++CONFIG_CLEAN_VPATH_FILES = ++AM_V_P = $(am__v_P_@AM_V@) ++am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) ++am__v_P_0 = false ++am__v_P_1 = : ++AM_V_GEN = $(am__v_GEN_@AM_V@) ++am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) ++am__v_GEN_0 = @echo " GEN " $@; ++am__v_GEN_1 = ++AM_V_at = $(am__v_at_@AM_V@) ++am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) ++am__v_at_0 = @ ++am__v_at_1 = ++SOURCES = ++DIST_SOURCES = ++RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ ++ ctags-recursive dvi-recursive html-recursive info-recursive \ ++ install-data-recursive install-dvi-recursive \ ++ install-exec-recursive install-html-recursive \ ++ install-info-recursive install-pdf-recursive \ ++ install-ps-recursive install-recursive installcheck-recursive \ ++ installdirs-recursive pdf-recursive ps-recursive \ ++ tags-recursive uninstall-recursive ++am__can_run_installinfo = \ ++ case $$AM_UPDATE_INFO_DIR in \ ++ n|no|NO) false;; \ ++ *) (install-info --version) >/dev/null 2>&1;; \ ++ esac ++RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ ++ distclean-recursive maintainer-clean-recursive ++am__recursive_targets = \ ++ $(RECURSIVE_TARGETS) \ ++ $(RECURSIVE_CLEAN_TARGETS) \ ++ $(am__extra_recursive_targets) ++AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ ++ distdir ++am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) ++# Read a list of newline-separated strings from the standard input, ++# and print each of them once, without duplicates. Input order is ++# *not* preserved. ++am__uniquify_input = $(AWK) '\ ++ BEGIN { nonempty = 0; } \ ++ { items[$$0] = 1; nonempty = 1; } \ ++ END { if (nonempty) { for (i in items) print i; }; } \ ++' ++# Make sure the list of sources is unique. This is necessary because, ++# e.g., the same source file might be shared among _SOURCES variables ++# for different programs/libraries. ++am__define_uniq_tagged_files = \ ++ list='$(am__tagged_files)'; \ ++ unique=`for i in $$list; do \ ++ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ ++ done | $(am__uniquify_input)` ++ETAGS = etags ++CTAGS = ctags ++DIST_SUBDIRS = $(SUBDIRS) ++DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ++am__relativize = \ ++ dir0=`pwd`; \ ++ sed_first='s,^\([^/]*\)/.*$$,\1,'; \ ++ sed_rest='s,^[^/]*/*,,'; \ ++ sed_last='s,^.*/\([^/]*\)$$,\1,'; \ ++ sed_butlast='s,/*[^/]*$$,,'; \ ++ while test -n "$$dir1"; do \ ++ first=`echo "$$dir1" | sed -e "$$sed_first"`; \ ++ if test "$$first" != "."; then \ ++ if test "$$first" = ".."; then \ ++ dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ ++ dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ ++ else \ ++ first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ ++ if test "$$first2" = "$$first"; then \ ++ dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ ++ else \ ++ dir2="../$$dir2"; \ ++ fi; \ ++ dir0="$$dir0"/"$$first"; \ ++ fi; \ ++ fi; \ ++ dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ ++ done; \ ++ reldir="$$dir2" ++ACLOCAL = @ACLOCAL@ ++ACL_LIBS = @ACL_LIBS@ ++AMTAR = @AMTAR@ ++AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ ++AM_LIBTOOLFLAGS = @AM_LIBTOOLFLAGS@ ++AM_MAKEFLAGS = @AM_MAKEFLAGS@ ++AR = @AR@ ++ARGP_LDADD = @ARGP_LDADD@ ++AUTOCONF = @AUTOCONF@ ++AUTOHEADER = @AUTOHEADER@ ++AUTOMAKE = @AUTOMAKE@ ++AWK = @AWK@ ++BUILD_PYTHON_SITE_PACKAGES = @BUILD_PYTHON_SITE_PACKAGES@ ++BUILD_PYTHON_SITE_PACKAGES_EXPANDED = @BUILD_PYTHON_SITE_PACKAGES_EXPANDED@ ++CC = @CC@ ++CCDEPMODE = @CCDEPMODE@ ++CFLAGS = @CFLAGS@ ++CONTRIBDIR = @CONTRIBDIR@ ++CPP = @CPP@ ++CPPFLAGS = @CPPFLAGS@ ++CYGPATH_W = @CYGPATH_W@ ++DEFS = @DEFS@ ++DEPDIR = @DEPDIR@ ++DLLTOOL = @DLLTOOL@ ++DSYMUTIL = @DSYMUTIL@ ++DUMPBIN = @DUMPBIN@ ++ECHO_C = @ECHO_C@ ++ECHO_N = @ECHO_N@ ++ECHO_T = @ECHO_T@ ++EGREP = @EGREP@ ++EVENTS_ENABLED = @EVENTS_ENABLED@ ++EVENTS_SUBDIR = @EVENTS_SUBDIR@ ++EXEEXT = @EXEEXT@ ++FGREP = @FGREP@ ++FUSERMOUNT_SUBDIR = @FUSERMOUNT_SUBDIR@ ++FUSE_CLIENT_SUBDIR = @FUSE_CLIENT_SUBDIR@ ++GEOREP_EXTRAS_SUBDIR = @GEOREP_EXTRAS_SUBDIR@ ++GFAPI_EXTRA_LDFLAGS = @GFAPI_EXTRA_LDFLAGS@ ++GFAPI_LIBS = @GFAPI_LIBS@ ++GFAPI_LT_VERSION = @GFAPI_LT_VERSION@ ++GFAPI_VERSION = @GFAPI_VERSION@ ++GF_CFLAGS = @GF_CFLAGS@ ++GF_CPPFLAGS = @GF_CPPFLAGS@ ++GF_DISTRIBUTION = @GF_DISTRIBUTION@ ++GF_FUSE_CFLAGS = @GF_FUSE_CFLAGS@ ++GF_FUSE_LDADD = @GF_FUSE_LDADD@ ++GF_HOST_OS = @GF_HOST_OS@ ++GF_LDADD = @GF_LDADD@ ++GF_LDFLAGS = @GF_LDFLAGS@ ++GF_NO_UNDEFINED = @GF_NO_UNDEFINED@ ++GF_XLATOR_DEFAULT_LDFLAGS = @GF_XLATOR_DEFAULT_LDFLAGS@ ++GF_XLATOR_LDFLAGS = @GF_XLATOR_LDFLAGS@ ++GLUPY_SUBDIR = @GLUPY_SUBDIR@ ++GLUPY_SUBDIR_MAKEFILE = @GLUPY_SUBDIR_MAKEFILE@ ++GLUPY_SUBDIR_SRC_MAKEFILE = @GLUPY_SUBDIR_SRC_MAKEFILE@ ++GLUSTERD_VOLFILE = @GLUSTERD_VOLFILE@ ++GLUSTERD_WORKDIR = @GLUSTERD_WORKDIR@ ++GLUSTERFSD_MISCDIR = @GLUSTERFSD_MISCDIR@ ++GLUSTERFS_LIBEXECDIR = @GLUSTERFS_LIBEXECDIR@ ++GREP = @GREP@ ++HAVE_ATOMIC_BUILTINS = @HAVE_ATOMIC_BUILTINS@ ++HAVE_BACKTRACE = @HAVE_BACKTRACE@ ++HAVE_LINKAT = @HAVE_LINKAT@ ++HAVE_MALLOC_STATS = @HAVE_MALLOC_STATS@ ++HAVE_SPINLOCK = @HAVE_SPINLOCK@ ++HAVE_STRNLEN = @HAVE_STRNLEN@ ++HAVE_SYNC_BUILTINS = @HAVE_SYNC_BUILTINS@ ++IBVERBS_SUBDIR = @IBVERBS_SUBDIR@ ++INSTALL = @INSTALL@ ++INSTALL_DATA = @INSTALL_DATA@ ++INSTALL_PROGRAM = @INSTALL_PROGRAM@ ++INSTALL_SCRIPT = @INSTALL_SCRIPT@ ++INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ ++LD = @LD@ ++LDFLAGS = @LDFLAGS@ ++LEX = @LEX@ ++LEXLIB = @LEXLIB@ ++LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ ++LIBAIO = @LIBAIO@ ++LIBGFCHANGELOG_LT_VERSION = @LIBGFCHANGELOG_LT_VERSION@ ++LIBGFCHANGELOG_VERSION = @LIBGFCHANGELOG_VERSION@ ++LIBGFDB_VERSION = @LIBGFDB_VERSION@ ++LIBGFRPC_LT_VERSION = @LIBGFRPC_LT_VERSION@ ++LIBGFXDR_LT_VERSION = @LIBGFXDR_LT_VERSION@ ++LIBGLUSTERFS_LT_VERSION = @LIBGLUSTERFS_LT_VERSION@ ++LIBOBJS = @LIBOBJS@ ++LIBS = @LIBS@ ++LIBTOOL = @LIBTOOL@ ++LIB_DL = @LIB_DL@ ++LIPO = @LIPO@ ++LN_S = @LN_S@ ++LTLIBOBJS = @LTLIBOBJS@ ++MAKEINFO = @MAKEINFO@ ++MANIFEST_TOOL = @MANIFEST_TOOL@ ++MATH_LIB = @MATH_LIB@ ++MKDIR_P = @MKDIR_P@ ++NM = @NM@ ++NMEDIT = @NMEDIT@ ++OBJDUMP = @OBJDUMP@ ++OBJEXT = @OBJEXT@ ++OCF_SUBDIR = @OCF_SUBDIR@ ++OTOOL = @OTOOL@ ++OTOOL64 = @OTOOL64@ ++PACKAGE = @PACKAGE@ ++PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ ++PACKAGE_NAME = @PACKAGE_NAME@ ++PACKAGE_RELEASE = @PACKAGE_RELEASE@ ++PACKAGE_STRING = @PACKAGE_STRING@ ++PACKAGE_TARNAME = @PACKAGE_TARNAME@ ++PACKAGE_URL = @PACKAGE_URL@ ++PACKAGE_VERSION = @PACKAGE_VERSION@ ++PATH_SEPARATOR = @PATH_SEPARATOR@ ++PKGCONFIG_UUID = @PKGCONFIG_UUID@ ++PKG_CONFIG = @PKG_CONFIG@ ++PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ ++PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ ++PYTHON = @PYTHON@ ++PYTHON_CFLAGS = @PYTHON_CFLAGS@ ++PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ ++PYTHON_LIBS = @PYTHON_LIBS@ ++PYTHON_PLATFORM = @PYTHON_PLATFORM@ ++PYTHON_PREFIX = @PYTHON_PREFIX@ ++PYTHON_VERSION = @PYTHON_VERSION@ ++RANLIB = @RANLIB@ ++RDMA_SUBDIR = @RDMA_SUBDIR@ ++RLLIBS = @RLLIBS@ ++RPCGEN = @RPCGEN@ ++SBIN_DIR = @SBIN_DIR@ ++SED = @SED@ ++SET_MAKE = @SET_MAKE@ ++SHELL = @SHELL@ ++SIZEOF_INT = @SIZEOF_INT@ ++SIZEOF_LONG = @SIZEOF_LONG@ ++SIZEOF_LONG_LONG = @SIZEOF_LONG_LONG@ ++SIZEOF_SHORT = @SIZEOF_SHORT@ ++SQLITE_CFLAGS = @SQLITE_CFLAGS@ ++SQLITE_LIBS = @SQLITE_LIBS@ ++STRIP = @STRIP@ ++SYNCDAEMON_COMPILE = @SYNCDAEMON_COMPILE@ ++SYNCDAEMON_SUBDIR = @SYNCDAEMON_SUBDIR@ ++SYSCONF_DIR = @SYSCONF_DIR@ ++TIRPC_CFLAGS = @TIRPC_CFLAGS@ ++TIRPC_LIBS = @TIRPC_LIBS@ ++UMOUNTD_SUBDIR = @UMOUNTD_SUBDIR@ ++UNITTEST_CFLAGS = @UNITTEST_CFLAGS@ ++UNITTEST_LDFLAGS = @UNITTEST_LDFLAGS@ ++UNITTEST_LIBS = @UNITTEST_LIBS@ ++URCU_CDS_CFLAGS = @URCU_CDS_CFLAGS@ ++URCU_CDS_LIBS = @URCU_CDS_LIBS@ ++URCU_CFLAGS = @URCU_CFLAGS@ ++URCU_LIBS = @URCU_LIBS@ ++USE_EC_DYNAMIC_AVX = @USE_EC_DYNAMIC_AVX@ ++USE_EC_DYNAMIC_NEON = @USE_EC_DYNAMIC_NEON@ ++USE_EC_DYNAMIC_SSE = @USE_EC_DYNAMIC_SSE@ ++USE_EC_DYNAMIC_X64 = @USE_EC_DYNAMIC_X64@ ++USE_POSIX_ACLS = @USE_POSIX_ACLS@ ++UUID_CFLAGS = @UUID_CFLAGS@ ++UUID_LIBS = @UUID_LIBS@ ++VERSION = @VERSION@ ++XML_CFLAGS = @XML_CFLAGS@ ++XML_LIBS = @XML_LIBS@ ++YACC = @YACC@ ++YFLAGS = @YFLAGS@ ++ZLIB_CFLAGS = @ZLIB_CFLAGS@ ++ZLIB_LIBS = @ZLIB_LIBS@ ++abs_builddir = @abs_builddir@ ++abs_srcdir = @abs_srcdir@ ++abs_top_builddir = @abs_top_builddir@ ++abs_top_srcdir = @abs_top_srcdir@ ++ac_ct_AR = @ac_ct_AR@ ++ac_ct_CC = @ac_ct_CC@ ++ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ ++am__include = @am__include@ ++am__leading_dot = @am__leading_dot@ ++am__quote = @am__quote@ ++am__tar = @am__tar@ ++am__untar = @am__untar@ ++bindir = @bindir@ ++build = @build@ ++build_alias = @build_alias@ ++build_cpu = @build_cpu@ ++build_os = @build_os@ ++build_vendor = @build_vendor@ ++builddir = @builddir@ ++datadir = @datadir@ ++datarootdir = @datarootdir@ ++docdir = @docdir@ ++dvidir = @dvidir@ ++exec_prefix = @exec_prefix@ ++host = @host@ ++host_alias = @host_alias@ ++host_cpu = @host_cpu@ ++host_os = @host_os@ ++host_vendor = @host_vendor@ ++htmldir = @htmldir@ ++includedir = @includedir@ ++infodir = @infodir@ ++initdir = @initdir@ ++install_sh = @install_sh@ ++launchddir = @launchddir@ ++libdir = @libdir@ ++libexecdir = @libexecdir@ ++localedir = @localedir@ ++localstatedir = @localstatedir@ ++mandir = @mandir@ ++mkdir_p = @mkdir_p@ ++mountutildir = @mountutildir@ ++oldincludedir = @oldincludedir@ ++pdfdir = @pdfdir@ ++pkgconfigdir = @pkgconfigdir@ ++pkgpyexecdir = @pkgpyexecdir@ ++pkgpythondir = @pkgpythondir@ ++prefix = @prefix@ ++program_transform_name = @program_transform_name@ ++psdir = @psdir@ ++pyexecdir = @pyexecdir@ ++pythondir = @pythondir@ ++sbindir = @sbindir@ ++sharedstatedir = @sharedstatedir@ ++shrext_cmds = @shrext_cmds@ ++srcdir = @srcdir@ ++sysconfdir = @sysconfdir@ ++systemddir = @systemddir@ ++target_alias = @target_alias@ ++tmpfilesdir = @tmpfilesdir@ ++top_build_prefix = @top_build_prefix@ ++top_builddir = @top_builddir@ ++top_srcdir = @top_srcdir@ ++SUBDIRS = src examples ++CLEANFILES = ++all: all-recursive ++ ++.SUFFIXES: ++$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) ++ @for dep in $?; do \ ++ case '$(am__configure_deps)' in \ ++ *$$dep*) \ ++ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ ++ && { if test -f $@; then exit 0; else break; fi; }; \ ++ exit 1;; \ ++ esac; \ ++ done; \ ++ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign xlators/features/glupy/Makefile'; \ ++ $(am__cd) $(top_srcdir) && \ ++ $(AUTOMAKE) --foreign xlators/features/glupy/Makefile ++.PRECIOUS: Makefile ++Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status ++ @case '$?' in \ ++ *config.status*) \ ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ ++ *) \ ++ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ ++ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ ++ esac; ++ ++$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++ ++$(top_srcdir)/configure: $(am__configure_deps) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++$(ACLOCAL_M4): $(am__aclocal_m4_deps) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++$(am__aclocal_m4_deps): ++ ++mostlyclean-libtool: ++ -rm -f *.lo ++ ++clean-libtool: ++ -rm -rf .libs _libs ++ ++# This directory's subdirectories are mostly independent; you can cd ++# into them and run 'make' without going through this Makefile. ++# To change the values of 'make' variables: instead of editing Makefiles, ++# (1) if the variable is set in 'config.status', edit 'config.status' ++# (which will cause the Makefiles to be regenerated when you run 'make'); ++# (2) otherwise, pass the desired values on the 'make' command line. ++$(am__recursive_targets): ++ @fail=; \ ++ if $(am__make_keepgoing); then \ ++ failcom='fail=yes'; \ ++ else \ ++ failcom='exit 1'; \ ++ fi; \ ++ dot_seen=no; \ ++ target=`echo $@ | sed s/-recursive//`; \ ++ case "$@" in \ ++ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ ++ *) list='$(SUBDIRS)' ;; \ ++ esac; \ ++ for subdir in $$list; do \ ++ echo "Making $$target in $$subdir"; \ ++ if test "$$subdir" = "."; then \ ++ dot_seen=yes; \ ++ local_target="$$target-am"; \ ++ else \ ++ local_target="$$target"; \ ++ fi; \ ++ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ ++ || eval $$failcom; \ ++ done; \ ++ if test "$$dot_seen" = "no"; then \ ++ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ ++ fi; test -z "$$fail" ++ ++ID: $(am__tagged_files) ++ $(am__define_uniq_tagged_files); mkid -fID $$unique ++tags: tags-recursive ++TAGS: tags ++ ++tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) ++ set x; \ ++ here=`pwd`; \ ++ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ ++ include_option=--etags-include; \ ++ empty_fix=.; \ ++ else \ ++ include_option=--include; \ ++ empty_fix=; \ ++ fi; \ ++ list='$(SUBDIRS)'; for subdir in $$list; do \ ++ if test "$$subdir" = .; then :; else \ ++ test ! -f $$subdir/TAGS || \ ++ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ ++ fi; \ ++ done; \ ++ $(am__define_uniq_tagged_files); \ ++ shift; \ ++ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ ++ test -n "$$unique" || unique=$$empty_fix; \ ++ if test $$# -gt 0; then \ ++ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ ++ "$$@" $$unique; \ ++ else \ ++ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ ++ $$unique; \ ++ fi; \ ++ fi ++ctags: ctags-recursive ++ ++CTAGS: ctags ++ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) ++ $(am__define_uniq_tagged_files); \ ++ test -z "$(CTAGS_ARGS)$$unique" \ ++ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ ++ $$unique ++ ++GTAGS: ++ here=`$(am__cd) $(top_builddir) && pwd` \ ++ && $(am__cd) $(top_srcdir) \ ++ && gtags -i $(GTAGS_ARGS) "$$here" ++cscopelist: cscopelist-recursive ++ ++cscopelist-am: $(am__tagged_files) ++ list='$(am__tagged_files)'; \ ++ case "$(srcdir)" in \ ++ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ ++ *) sdir=$(subdir)/$(srcdir) ;; \ ++ esac; \ ++ for i in $$list; do \ ++ if test -f "$$i"; then \ ++ echo "$(subdir)/$$i"; \ ++ else \ ++ echo "$$sdir/$$i"; \ ++ fi; \ ++ done >> $(top_builddir)/cscope.files ++ ++distclean-tags: ++ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags ++ ++distdir: $(DISTFILES) ++ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ ++ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ ++ list='$(DISTFILES)'; \ ++ dist_files=`for file in $$list; do echo $$file; done | \ ++ sed -e "s|^$$srcdirstrip/||;t" \ ++ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ ++ case $$dist_files in \ ++ */*) $(MKDIR_P) `echo "$$dist_files" | \ ++ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ ++ sort -u` ;; \ ++ esac; \ ++ for file in $$dist_files; do \ ++ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ ++ if test -d $$d/$$file; then \ ++ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ ++ if test -d "$(distdir)/$$file"; then \ ++ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ ++ fi; \ ++ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ ++ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ ++ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ ++ fi; \ ++ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ ++ else \ ++ test -f "$(distdir)/$$file" \ ++ || cp -p $$d/$$file "$(distdir)/$$file" \ ++ || exit 1; \ ++ fi; \ ++ done ++ @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ ++ if test "$$subdir" = .; then :; else \ ++ $(am__make_dryrun) \ ++ || test -d "$(distdir)/$$subdir" \ ++ || $(MKDIR_P) "$(distdir)/$$subdir" \ ++ || exit 1; \ ++ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ ++ $(am__relativize); \ ++ new_distdir=$$reldir; \ ++ dir1=$$subdir; dir2="$(top_distdir)"; \ ++ $(am__relativize); \ ++ new_top_distdir=$$reldir; \ ++ echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ ++ echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ ++ ($(am__cd) $$subdir && \ ++ $(MAKE) $(AM_MAKEFLAGS) \ ++ top_distdir="$$new_top_distdir" \ ++ distdir="$$new_distdir" \ ++ am__remove_distdir=: \ ++ am__skip_length_check=: \ ++ am__skip_mode_fix=: \ ++ distdir) \ ++ || exit 1; \ ++ fi; \ ++ done ++check-am: all-am ++check: check-recursive ++all-am: Makefile ++installdirs: installdirs-recursive ++installdirs-am: ++install: install-recursive ++install-exec: install-exec-recursive ++install-data: install-data-recursive ++uninstall: uninstall-recursive ++ ++install-am: all-am ++ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am ++ ++installcheck: installcheck-recursive ++install-strip: ++ if test -z '$(STRIP)'; then \ ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ ++ install; \ ++ else \ ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ ++ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ ++ fi ++mostlyclean-generic: ++ ++clean-generic: ++ -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) ++ ++distclean-generic: ++ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) ++ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) ++ ++maintainer-clean-generic: ++ @echo "This command is intended for maintainers to use" ++ @echo "it deletes files that may require special tools to rebuild." ++clean: clean-recursive ++ ++clean-am: clean-generic clean-libtool mostlyclean-am ++ ++distclean: distclean-recursive ++ -rm -f Makefile ++distclean-am: clean-am distclean-generic distclean-tags ++ ++dvi: dvi-recursive ++ ++dvi-am: ++ ++html: html-recursive ++ ++html-am: ++ ++info: info-recursive ++ ++info-am: ++ ++install-data-am: ++ ++install-dvi: install-dvi-recursive ++ ++install-dvi-am: ++ ++install-exec-am: ++ ++install-html: install-html-recursive ++ ++install-html-am: ++ ++install-info: install-info-recursive ++ ++install-info-am: ++ ++install-man: ++ ++install-pdf: install-pdf-recursive ++ ++install-pdf-am: ++ ++install-ps: install-ps-recursive ++ ++install-ps-am: ++ ++installcheck-am: ++ ++maintainer-clean: maintainer-clean-recursive ++ -rm -f Makefile ++maintainer-clean-am: distclean-am maintainer-clean-generic ++ ++mostlyclean: mostlyclean-recursive ++ ++mostlyclean-am: mostlyclean-generic mostlyclean-libtool ++ ++pdf: pdf-recursive ++ ++pdf-am: ++ ++ps: ps-recursive ++ ++ps-am: ++ ++uninstall-am: ++ ++.MAKE: $(am__recursive_targets) install-am install-strip ++ ++.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am check \ ++ check-am clean clean-generic clean-libtool cscopelist-am ctags \ ++ ctags-am distclean distclean-generic distclean-libtool \ ++ distclean-tags distdir dvi dvi-am html html-am info info-am \ ++ install install-am install-data install-data-am install-dvi \ ++ install-dvi-am install-exec install-exec-am install-html \ ++ install-html-am install-info install-info-am install-man \ ++ install-pdf install-pdf-am install-ps install-ps-am \ ++ install-strip installcheck installcheck-am installdirs \ ++ installdirs-am maintainer-clean maintainer-clean-generic \ ++ mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \ ++ ps ps-am tags tags-am uninstall uninstall-am ++ ++ ++# Tell versions [3.59,3.63) of GNU make to not export all variables. ++# Otherwise a system limit (for SysV at least) may be exceeded. ++.NOEXPORT: diff --git a/glusterfs.spec b/glusterfs.spec index 28d9b2d..cb23c0d 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -223,7 +223,7 @@ Summary: Distributed File System %if ( 0%{_for_fedora_koji_builds} ) Name: glusterfs -Version: 5.6 +Version: 5.7 Release: %{?prereltag:0.}1%{?prereltag:.%{prereltag}}%{?dist} %else Name: @PACKAGE_NAME@ @@ -241,6 +241,7 @@ Source8: glusterfsd.init %else Source0: @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz %endif +Patch1: 0001-glupy.patch Requires(pre): shadow-utils @@ -692,6 +693,7 @@ This package provides the glusterfs server daemon. %prep %setup -q -n %{name}-%{version}%{?prereltag} +%patch1 %if ( ! %{_usepython3} ) echo "fixing python shebangs..." for f in api events extras geo-replication libglusterfs tools xlators; do @@ -1457,6 +1459,9 @@ exit 0 %endif %changelog +* Wed Jul 3 2019 Kaleb S. KEITHLEY - 5.7-1 +- 5.7 GA + * Tue Apr 9 2019 Kaleb S. KEITHLEY - 5.6-1 - 5.6 GA diff --git a/sources b/sources index faabee3..8b4cbe9 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (glusterfs-5.6.tar.gz) = b64fdc795c325b16481104700b37be6435f6eeec191a7f148cf2adb3161e949c7390040d3f86d938bf46df9cbc747864f50a83041a9455ab878540adfa654f0e +SHA512 (glusterfs-5.7.tar.gz) = 0dae6cca06fd481cf3f9d8dc980efd334349340214a353b015a6810dd482272535bc9c15bc488dc5086ccddef2f72e351190b833e5da7dabe3055ad68cbe282b From 3c1fa29f92a3dd00e881880ec5b9501e7e72ff81 Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Thu, 18 Jul 2019 14:47:15 -0400 Subject: [PATCH 09/14] 5.8 GA Signed-off-by: Kaleb S. KEITHLEY --- glusterfs.spec | 7 ++++--- sources | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/glusterfs.spec b/glusterfs.spec index cb23c0d..a2bbc8f 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -223,7 +223,7 @@ Summary: Distributed File System %if ( 0%{_for_fedora_koji_builds} ) Name: glusterfs -Version: 5.7 +Version: 5.8 Release: %{?prereltag:0.}1%{?prereltag:.%{prereltag}}%{?dist} %else Name: @PACKAGE_NAME@ @@ -241,7 +241,6 @@ Source8: glusterfsd.init %else Source0: @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz %endif -Patch1: 0001-glupy.patch Requires(pre): shadow-utils @@ -693,7 +692,6 @@ This package provides the glusterfs server daemon. %prep %setup -q -n %{name}-%{version}%{?prereltag} -%patch1 %if ( ! %{_usepython3} ) echo "fixing python shebangs..." for f in api events extras geo-replication libglusterfs tools xlators; do @@ -1459,6 +1457,9 @@ exit 0 %endif %changelog +* Thu Jul 20 2019 Kaleb S. KEITHLEY - 5.8-1 +- 5.8 GA + * Wed Jul 3 2019 Kaleb S. KEITHLEY - 5.7-1 - 5.7 GA diff --git a/sources b/sources index 8b4cbe9..f442e50 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (glusterfs-5.7.tar.gz) = 0dae6cca06fd481cf3f9d8dc980efd334349340214a353b015a6810dd482272535bc9c15bc488dc5086ccddef2f72e351190b833e5da7dabe3055ad68cbe282b +SHA512 (glusterfs-5.8.tar.gz) = e22853bc97503cc45b614c41a120ee298a94bc02c5820550f5853f83e14ea39f77a2543a82670515e01d930ab0fb6d0e253488fdc4bf156091dceb04e282a1a4 From b224d3d5a0eae796c209193b0c1bef0e659b4b47 Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Wed, 7 Aug 2019 07:56:01 -0400 Subject: [PATCH 10/14] 5.9 GA Signed-off-by: Kaleb S. KEITHLEY --- 0001-glupy.patch | 7464 ---------------------------------------------- glusterfs.spec | 5 +- sources | 2 +- 3 files changed, 5 insertions(+), 7466 deletions(-) delete mode 100644 0001-glupy.patch diff --git a/0001-glupy.patch b/0001-glupy.patch deleted file mode 100644 index a2d70d5..0000000 --- a/0001-glupy.patch +++ /dev/null @@ -1,7464 +0,0 @@ ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/Makefile.am 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,3 @@ -+SUBDIRS = src examples -+ -+CLEANFILES = ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/doc/README.md 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,44 @@ -+This is just the very start for a GlusterFS[1] meta-translator that will -+allow translator code to be written in Python. It's based on the standard -+Python embedding (not extending) techniques, plus a dash of the ctypes module. -+The interface is a pretty minimal adaptation of the dispatches and callbacks -+from the C API[2] to Python, as follows: -+ -+* Dispatch functions and callbacks must be defined on an "xlator" class -+ derived from gluster.Translator so that they'll be auto-registered with -+ the C translator during initialization. -+ -+* For each dispatch or callback function you want to intercept, you define a -+ Python function using the xxx\_fop\_t or xxx\_cbk\_t decorator. -+ -+* The arguments for each operation are different, so you'll need to refer to -+ the C API. GlusterFS-specific types are used (though only loc\_t is fully -+ defined so far) and type correctness is enforced by ctypes. -+ -+* If you do intercept a dispatch function, it is your responsibility to call -+ xxx\_wind (like STACK\_WIND in the C API but operation-specific) to pass -+ the request to the next translator. If you do not intercept a function, it -+ will default the same way as for C (pass through to the same operation with -+ the same arguments on the first child translator). -+ -+* If you intercept a callback function, it is your responsibility to call -+ xxx\_unwind (like STACK\_UNWIND\_STRICT in the C API) to pass the request back -+ to the caller. -+ -+So far only the lookup and create operations are handled this way, to support -+the "negative lookup" example. Now that the basic infrastructure is in place, -+adding more functions should be very quick, though with that much boilerplate I -+might pause to write a code generator. I also plan to add structure -+definitions and interfaces for some of the utility functions in libglusterfs -+(especially those having to do with inode and fd context) in the fairly near -+future. Note that you can also use ctypes to get at anything not explicitly -+exposed to Python already. -+ -+_If you're coming here because of the Linux Journal article, please note that -+the code has evolved since that was written. The version that matches the -+article is here:_ -+ -+https://github.com/jdarcy/glupy/tree/4bbae91ba459ea46ef32f2966562492e4ca9187a -+ -+[1] http://www.gluster.org -+[2] http://pl.atyp.us/hekafs.org/dist/xlator_api_2.html ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/doc/TESTING 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,9 @@ -+Loading a translator written in Python using the glupy meta translator -+------------------------------------------------------------------------------- -+'test.vol' is a simple volfile with the debug-trace Python translator on top -+of a brick. The volfile can be mounted using the following command. -+ -+$ glusterfs --debug -f test.vol /path/to/mntpt -+ -+If then file operations are performed on the newly mounted file system, log -+output would be printed by the Python translator on the standard output. ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/doc/test.vol 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,10 @@ -+volume vol-posix -+ type storage/posix -+ option directory /path/to/brick -+end-volume -+ -+volume vol-glupy -+ type features/glupy -+ option module-name debug-trace -+ subvolumes vol-posix -+end-volume ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/examples/Makefile.am 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,5 @@ -+xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/features -+ -+glupyexamplesdir = $(xlatordir)/glupy -+ -+glupyexamples_PYTHON = negative.py helloworld.py debug-trace.py ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/examples/debug-trace.py 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,777 @@ -+ -+from __future__ import print_function -+import sys -+import stat -+from uuid import UUID -+from time import strftime, localtime -+from gluster.glupy import * -+ -+# This translator was written primarily to test the fop entry point definitions -+# and structure definitions in 'glupy.py'. -+ -+# It is similar to the C language debug-trace translator, which logs the -+# arguments passed to the fops and their corresponding cbk functions. -+ -+dl.get_id.restype = c_long -+dl.get_id.argtypes = [ POINTER(call_frame_t) ] -+ -+dl.get_rootunique.restype = c_uint64 -+dl.get_rootunique.argtypes = [ POINTER(call_frame_t) ] -+ -+def uuid2str (gfid): -+ return str(UUID(''.join(map("{0:02x}".format, gfid)))) -+ -+ -+def st_mode_from_ia (prot, filetype): -+ st_mode = 0 -+ type_bit = 0 -+ prot_bit = 0 -+ -+ if filetype == IA_IFREG: -+ type_bit = stat.S_IFREG -+ elif filetype == IA_IFDIR: -+ type_bit = stat.S_IFDIR -+ elif filetype == IA_IFLNK: -+ type_bit = stat.S_IFLNK -+ elif filetype == IA_IFBLK: -+ type_bit = stat.S_IFBLK -+ elif filetype == IA_IFCHR: -+ type_bit = stat.S_IFCHR -+ elif filetype == IA_IFIFO: -+ type_bit = stat.S_IFIFO -+ elif filetype == IA_IFSOCK: -+ type_bit = stat.S_IFSOCK -+ elif filetype == IA_INVAL: -+ pass -+ -+ -+ if prot.suid: -+ prot_bit |= stat.S_ISUID -+ if prot.sgid: -+ prot_bit |= stat.S_ISGID -+ if prot.sticky: -+ prot_bit |= stat.S_ISVTX -+ -+ if prot.owner.read: -+ prot_bit |= stat.S_IRUSR -+ if prot.owner.write: -+ prot_bit |= stat.S_IWUSR -+ if prot.owner.execn: -+ prot_bit |= stat.S_IXUSR -+ -+ if prot.group.read: -+ prot_bit |= stat.S_IRGRP -+ if prot.group.write: -+ prot_bit |= stat.S_IWGRP -+ if prot.group.execn: -+ prot_bit |= stat.S_IXGRP -+ -+ if prot.other.read: -+ prot_bit |= stat.S_IROTH -+ if prot.other.write: -+ prot_bit |= stat.S_IWOTH -+ if prot.other.execn: -+ prot_bit |= stat.S_IXOTH -+ -+ st_mode = (type_bit | prot_bit) -+ -+ return st_mode -+ -+ -+def trace_stat2str (buf): -+ gfid = uuid2str(buf.contents.ia_gfid) -+ mode = st_mode_from_ia(buf.contents.ia_prot, buf.contents.ia_type) -+ atime_buf = strftime("[%b %d %H:%M:%S]", -+ localtime(buf.contents.ia_atime)) -+ mtime_buf = strftime("[%b %d %H:%M:%S]", -+ localtime(buf.contents.ia_mtime)) -+ ctime_buf = strftime("[%b %d %H:%M:%S]", -+ localtime(buf.contents.ia_ctime)) -+ return ("(gfid={0:s}, ino={1:d}, mode={2:o}, nlink={3:d}, uid ={4:d}, "+ -+ "gid ={5:d}, size={6:d}, blocks={7:d}, atime={8:s}, mtime={9:s}, "+ -+ "ctime={10:s})").format(gfid, buf.contents.ia_no, mode, -+ buf.contents.ia_nlink, -+ buf.contents.ia_uid, -+ buf.contents.ia_gid, -+ buf.contents.ia_size, -+ buf.contents.ia_blocks, -+ atime_buf, mtime_buf, -+ ctime_buf) -+ -+class xlator(Translator): -+ -+ def __init__(self, c_this): -+ Translator.__init__(self, c_this) -+ self.gfids = {} -+ -+ def lookup_fop(self, frame, this, loc, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(loc.contents.gfid) -+ print(("GLUPY TRACE LOOKUP FOP- {0:d}: gfid={1:s}; " + -+ "path={2:s}").format(unique, gfid, loc.contents.path)) -+ self.gfids[key] = gfid -+ dl.wind_lookup(frame, POINTER(xlator_t)(), loc, xdata) -+ return 0 -+ -+ def lookup_cbk(self, frame, cookie, this, op_ret, op_errno, -+ inode, buf, xdata, postparent): -+ unique =dl.get_rootunique(frame) -+ key =dl.get_id(frame) -+ if op_ret == 0: -+ gfid = uuid2str(buf.contents.ia_gfid) -+ statstr = trace_stat2str(buf) -+ postparentstr = trace_stat2str(postparent) -+ print(("GLUPY TRACE LOOKUP CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; *buf={3:s}; " + -+ "*postparent={4:s}").format(unique, gfid, -+ op_ret, statstr, -+ postparentstr)) -+ else: -+ gfid = self.gfids[key] -+ print(("GLUPY TRACE LOOKUP CBK - {0:d}: gfid={1:s};" + -+ " op_ret={2:d}; op_errno={3:d}").format(unique, -+ gfid, -+ op_ret, -+ op_errno)) -+ del self.gfids[key] -+ dl.unwind_lookup(frame, cookie, this, op_ret, op_errno, -+ inode, buf, xdata, postparent) -+ return 0 -+ -+ def create_fop(self, frame, this, loc, flags, mode, umask, fd, -+ xdata): -+ unique = dl.get_rootunique(frame) -+ gfid = uuid2str(loc.contents.gfid) -+ print(("GLUPY TRACE CREATE FOP- {0:d}: gfid={1:s}; path={2:s}; " + -+ "fd={3:s}; flags=0{4:o}; mode=0{5:o}; " + -+ "umask=0{6:o}").format(unique, gfid, loc.contents.path, -+ fd, flags, mode, umask)) -+ dl.wind_create(frame, POINTER(xlator_t)(), loc, flags, mode, -+ umask, fd, xdata) -+ return 0 -+ -+ def create_cbk(self, frame, cookie, this, op_ret, op_errno, fd, -+ inode, buf, preparent, postparent, xdata): -+ unique = dl.get_rootunique(frame) -+ if op_ret >= 0: -+ gfid = uuid2str(inode.contents.gfid) -+ statstr = trace_stat2str(buf) -+ preparentstr = trace_stat2str(preparent) -+ postparentstr = trace_stat2str(postparent) -+ print(("GLUPY TRACE CREATE CBK- {0:d}: gfid={1:s};" + -+ " op_ret={2:d}; fd={3:s}; *stbuf={4:s}; " + -+ "*preparent={5:s};" + -+ " *postparent={6:s}").format(unique, gfid, op_ret, -+ fd, statstr, -+ preparentstr, -+ postparentstr)) -+ else: -+ print(("GLUPY TRACE CREATE CBK- {0:d}: op_ret={1:d}; " + -+ "op_errno={2:d}").format(unique, op_ret, op_errno)) -+ dl.unwind_create(frame, cookie, this, op_ret, op_errno, fd, -+ inode, buf, preparent, postparent, xdata) -+ return 0 -+ -+ def open_fop(self, frame, this, loc, flags, fd, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE OPEN FOP- {0:d}: gfid={1:s}; path={2:s}; "+ -+ "flags={3:d}; fd={4:s}").format(unique, gfid, -+ loc.contents.path, flags, -+ fd)) -+ self.gfids[key] = gfid -+ dl.wind_open(frame, POINTER(xlator_t)(), loc, flags, fd, xdata) -+ return 0 -+ -+ def open_cbk(self, frame, cookie, this, op_ret, op_errno, fd, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ print(("GLUPY TRACE OPEN CBK- {0:d}: gfid={1:s}; op_ret={2:d}; " -+ "op_errno={3:d}; *fd={4:s}").format(unique, gfid, -+ op_ret, op_errno, fd)) -+ del self.gfids[key] -+ dl.unwind_open(frame, cookie, this, op_ret, op_errno, fd, -+ xdata) -+ return 0 -+ -+ def readv_fop(self, frame, this, fd, size, offset, flags, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(fd.contents.inode.contents.gfid) -+ print(("GLUPY TRACE READV FOP- {0:d}: gfid={1:s}; "+ -+ "fd={2:s}; size ={3:d}; offset={4:d}; " + -+ "flags=0{5:x}").format(unique, gfid, fd, size, offset, -+ flags)) -+ self.gfids[key] = gfid -+ dl.wind_readv (frame, POINTER(xlator_t)(), fd, size, offset, -+ flags, xdata) -+ return 0 -+ -+ def readv_cbk(self, frame, cookie, this, op_ret, op_errno, vector, -+ count, buf, iobref, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ if op_ret >= 0: -+ statstr = trace_stat2str(buf) -+ print(("GLUPY TRACE READV CBK- {0:d}: gfid={1:s}, "+ -+ "op_ret={2:d}; *buf={3:s};").format(unique, gfid, -+ op_ret, -+ statstr)) -+ -+ else: -+ print(("GLUPY TRACE READV CBK- {0:d}: gfid={1:s}, "+ -+ "op_ret={2:d}; op_errno={3:d}").format(unique, -+ gfid, -+ op_ret, -+ op_errno)) -+ del self.gfids[key] -+ dl.unwind_readv (frame, cookie, this, op_ret, op_errno, -+ vector, count, buf, iobref, xdata) -+ return 0 -+ -+ def writev_fop(self, frame, this, fd, vector, count, offset, flags, -+ iobref, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(fd.contents.inode.contents.gfid) -+ print(("GLUPY TRACE WRITEV FOP- {0:d}: gfid={1:s}; " + -+ "fd={2:s}; count={3:d}; offset={4:d}; " + -+ "flags=0{5:x}").format(unique, gfid, fd, count, offset, -+ flags)) -+ self.gfids[key] = gfid -+ dl.wind_writev(frame, POINTER(xlator_t)(), fd, vector, count, -+ offset, flags, iobref, xdata) -+ return 0 -+ -+ def writev_cbk(self, frame, cookie, this, op_ret, op_errno, prebuf, -+ postbuf, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ if op_ret >= 0: -+ preopstr = trace_stat2str(prebuf) -+ postopstr = trace_stat2str(postbuf) -+ print(("GLUPY TRACE WRITEV CBK- {0:d}: op_ret={1:d}; " + -+ "*prebuf={2:s}; " + -+ "*postbuf={3:s}").format(unique, op_ret, preopstr, -+ postopstr)) -+ else: -+ gfid = self.gfids[key] -+ print(("GLUPY TRACE WRITEV CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; op_errno={3:d}").format(unique, -+ gfid, -+ op_ret, -+ op_errno)) -+ del self.gfids[key] -+ dl.unwind_writev (frame, cookie, this, op_ret, op_errno, -+ prebuf, postbuf, xdata) -+ return 0 -+ -+ def opendir_fop(self, frame, this, loc, fd, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE OPENDIR FOP- {0:d}: gfid={1:s}; path={2:s}; "+ -+ "fd={3:s}").format(unique, gfid, loc.contents.path, fd)) -+ self.gfids[key] = gfid -+ dl.wind_opendir(frame, POINTER(xlator_t)(), loc, fd, xdata) -+ return 0 -+ -+ def opendir_cbk(self, frame, cookie, this, op_ret, op_errno, fd, -+ xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ print(("GLUPY TRACE OPENDIR CBK- {0:d}: gfid={1:s}; op_ret={2:d};"+ -+ " op_errno={3:d}; fd={4:s}").format(unique, gfid, op_ret, -+ op_errno, fd)) -+ del self.gfids[key] -+ dl.unwind_opendir(frame, cookie, this, op_ret, op_errno, -+ fd, xdata) -+ return 0 -+ -+ def readdir_fop(self, frame, this, fd, size, offset, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(fd.contents.inode.contents.gfid) -+ print(("GLUPY TRACE READDIR FOP- {0:d}: gfid={1:s}; fd={2:s}; " + -+ "size={3:d}; offset={4:d}").format(unique, gfid, fd, size, -+ offset)) -+ self.gfids[key] = gfid -+ dl.wind_readdir(frame, POINTER(xlator_t)(), fd, size, offset, -+ xdata) -+ return 0 -+ -+ def readdir_cbk(self, frame, cookie, this, op_ret, op_errno, buf, -+ xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ print(("GLUPY TRACE READDIR CBK- {0:d}: gfid={1:s}; op_ret={2:d};"+ -+ " op_errno={3:d}").format(unique, gfid, op_ret, op_errno)) -+ del self.gfids[key] -+ dl.unwind_readdir(frame, cookie, this, op_ret, op_errno, buf, -+ xdata) -+ return 0 -+ -+ def readdirp_fop(self, frame, this, fd, size, offset, dictionary): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(fd.contents.inode.contents.gfid) -+ print(("GLUPY TRACE READDIRP FOP- {0:d}: gfid={1:s}; fd={2:s}; "+ -+ " size={3:d}; offset={4:d}").format(unique, gfid, fd, size, -+ offset)) -+ self.gfids[key] = gfid -+ dl.wind_readdirp(frame, POINTER(xlator_t)(), fd, size, offset, -+ dictionary) -+ return 0 -+ -+ def readdirp_cbk(self, frame, cookie, this, op_ret, op_errno, buf, -+ xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ print(("GLUPY TRACE READDIRP CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; op_errno={3:d}").format(unique, gfid, -+ op_ret, op_errno)) -+ del self.gfids[key] -+ dl.unwind_readdirp(frame, cookie, this, op_ret, op_errno, buf, -+ xdata) -+ return 0 -+ -+ def mkdir_fop(self, frame, this, loc, mode, umask, xdata): -+ unique = dl.get_rootunique(frame) -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE MKDIR FOP- {0:d}: gfid={1:s}; path={2:s}; " + -+ "mode={3:d}; umask=0{4:o}").format(unique, gfid, -+ loc.contents.path, mode, -+ umask)) -+ dl.wind_mkdir(frame, POINTER(xlator_t)(), loc, mode, umask, -+ xdata) -+ return 0 -+ -+ def mkdir_cbk(self, frame, cookie, this, op_ret, op_errno, inode, buf, -+ preparent, postparent, xdata): -+ unique = dl.get_rootunique(frame) -+ if op_ret == 0: -+ gfid = uuid2str(inode.contents.gfid) -+ statstr = trace_stat2str(buf) -+ preparentstr = trace_stat2str(preparent) -+ postparentstr = trace_stat2str(postparent) -+ print(("GLUPY TRACE MKDIR CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; *stbuf={3:s}; *prebuf={4:s}; "+ -+ "*postbuf={5:s} ").format(unique, gfid, op_ret, -+ statstr, -+ preparentstr, -+ postparentstr)) -+ else: -+ print(("GLUPY TRACE MKDIR CBK- {0:d}: op_ret={1:d}; "+ -+ "op_errno={2:d}").format(unique, op_ret, op_errno)) -+ dl.unwind_mkdir(frame, cookie, this, op_ret, op_errno, inode, -+ buf, preparent, postparent, xdata) -+ return 0 -+ -+ def rmdir_fop(self, frame, this, loc, flags, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE RMDIR FOP- {0:d}: gfid={1:s}; path={2:s}; "+ -+ "flags={3:d}").format(unique, gfid, loc.contents.path, -+ flags)) -+ self.gfids[key] = gfid -+ dl.wind_rmdir(frame, POINTER(xlator_t)(), loc, flags, xdata) -+ return 0 -+ -+ def rmdir_cbk(self, frame, cookie, this, op_ret, op_errno, preparent, -+ postparent, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ if op_ret == 0: -+ preparentstr = trace_stat2str(preparent) -+ postparentstr = trace_stat2str(postparent) -+ print(("GLUPY TRACE RMDIR CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; *prebuf={3:s}; "+ -+ "*postbuf={4:s}").format(unique, gfid, op_ret, -+ preparentstr, -+ postparentstr)) -+ else: -+ print(("GLUPY TRACE RMDIR CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; op_errno={3:d}").format(unique, -+ gfid, -+ op_ret, -+ op_errno)) -+ del self.gfids[key] -+ dl.unwind_rmdir(frame, cookie, this, op_ret, op_errno, -+ preparent, postparent, xdata) -+ return 0 -+ -+ def stat_fop(self, frame, this, loc, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE STAT FOP- {0:d}: gfid={1:s}; " + -+ " path={2:s}").format(unique, gfid, loc.contents.path)) -+ self.gfids[key] = gfid -+ dl.wind_stat(frame, POINTER(xlator_t)(), loc, xdata) -+ return 0 -+ -+ def stat_cbk(self, frame, cookie, this, op_ret, op_errno, buf, -+ xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ if op_ret == 0: -+ statstr = trace_stat2str(buf) -+ print(("GLUPY TRACE STAT CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; *buf={3:s};").format(unique, -+ gfid, -+ op_ret, -+ statstr)) -+ else: -+ print(("GLUPY TRACE STAT CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; op_errno={3:d}").format(unique, -+ gfid, -+ op_ret, -+ op_errno)) -+ del self.gfids[key] -+ dl.unwind_stat(frame, cookie, this, op_ret, op_errno, -+ buf, xdata) -+ return 0 -+ -+ def fstat_fop(self, frame, this, fd, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(fd.contents.inode.contents.gfid) -+ print(("GLUPY TRACE FSTAT FOP- {0:d}: gfid={1:s}; " + -+ "fd={2:s}").format(unique, gfid, fd)) -+ self.gfids[key] = gfid -+ dl.wind_fstat(frame, POINTER(xlator_t)(), fd, xdata) -+ return 0 -+ -+ def fstat_cbk(self, frame, cookie, this, op_ret, op_errno, buf, -+ xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ if op_ret == 0: -+ statstr = trace_stat2str(buf) -+ print(("GLUPY TRACE FSTAT CBK- {0:d}: gfid={1:s} "+ -+ " op_ret={2:d}; *buf={3:s}").format(unique, -+ gfid, -+ op_ret, -+ statstr)) -+ else: -+ print(("GLUPY TRACE FSTAT CBK- {0:d}: gfid={1:s} "+ -+ "op_ret={2:d}; op_errno={3:d}").format(unique. -+ gfid, -+ op_ret, -+ op_errno)) -+ del self.gfids[key] -+ dl.unwind_fstat(frame, cookie, this, op_ret, op_errno, -+ buf, xdata) -+ return 0 -+ -+ def statfs_fop(self, frame, this, loc, xdata): -+ unique = dl.get_rootunique(frame) -+ if loc.contents.inode: -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ else: -+ gfid = "0" -+ print(("GLUPY TRACE STATFS FOP- {0:d}: gfid={1:s}; "+ -+ "path={2:s}").format(unique, gfid, loc.contents.path)) -+ dl.wind_statfs(frame, POINTER(xlator_t)(), loc, xdata) -+ return 0 -+ -+ def statfs_cbk(self, frame, cookie, this, op_ret, op_errno, buf, -+ xdata): -+ unique = dl.get_rootunique(frame) -+ if op_ret == 0: -+ #TBD: print buf (pointer to an iovec type object) -+ print(("GLUPY TRACE STATFS CBK {0:d}: "+ -+ "op_ret={1:d}").format(unique, op_ret)) -+ else: -+ print(("GLUPY TRACE STATFS CBK- {0:d}"+ -+ "op_ret={1:d}; op_errno={2:d}").format(unique, -+ op_ret, -+ op_errno)) -+ dl.unwind_statfs(frame, cookie, this, op_ret, op_errno, -+ buf, xdata) -+ return 0 -+ -+ def getxattr_fop(self, frame, this, loc, name, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE GETXATTR FOP- {0:d}: gfid={1:s}; path={2:s};"+ -+ " name={3:s}").format(unique, gfid, loc.contents.path, -+ name)) -+ self.gfids[key]=gfid -+ dl.wind_getxattr(frame, POINTER(xlator_t)(), loc, name, xdata) -+ return 0 -+ -+ def getxattr_cbk(self, frame, cookie, this, op_ret, op_errno, -+ dictionary, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ print(("GLUPY TRACE GETXATTR CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; op_errno={3:d}; "+ -+ " dictionary={4:s}").format(unique, gfid, op_ret, op_errno, -+ dictionary)) -+ del self.gfids[key] -+ dl.unwind_getxattr(frame, cookie, this, op_ret, op_errno, -+ dictionary, xdata) -+ return 0 -+ -+ def fgetxattr_fop(self, frame, this, fd, name, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(fd.contents.inode.contents.gfid) -+ print(("GLUPY TRACE FGETXATTR FOP- {0:d}: gfid={1:s}; fd={2:s}; "+ -+ "name={3:s}").format(unique, gfid, fd, name)) -+ self.gfids[key] = gfid -+ dl.wind_fgetxattr(frame, POINTER(xlator_t)(), fd, name, xdata) -+ return 0 -+ -+ def fgetxattr_cbk(self, frame, cookie, this, op_ret, op_errno, -+ dictionary, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ print(("GLUPY TRACE FGETXATTR CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; op_errno={3:d};"+ -+ " dictionary={4:s}").format(unique, gfid, op_ret, -+ op_errno, dictionary)) -+ del self.gfids[key] -+ dl.unwind_fgetxattr(frame, cookie, this, op_ret, op_errno, -+ dictionary, xdata) -+ return 0 -+ -+ def setxattr_fop(self, frame, this, loc, dictionary, flags, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE SETXATTR FOP- {0:d}: gfid={1:s}; path={2:s};"+ -+ " flags={3:d}").format(unique, gfid, loc.contents.path, -+ flags)) -+ self.gfids[key] = gfid -+ dl.wind_setxattr(frame, POINTER(xlator_t)(), loc, dictionary, -+ flags, xdata) -+ return 0 -+ -+ def setxattr_cbk(self, frame, cookie, this, op_ret, op_errno, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ print(("GLUPY TRACE SETXATTR CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; op_errno={3:d}").format(unique, gfid, -+ op_ret, op_errno)) -+ del self.gfids[key] -+ dl.unwind_setxattr(frame, cookie, this, op_ret, op_errno, -+ xdata) -+ return 0 -+ -+ def fsetxattr_fop(self, frame, this, fd, dictionary, flags, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(fd.contents.inode.contents.gfid) -+ print(("GLUPY TRACE FSETXATTR FOP- {0:d}: gfid={1:s}; fd={2:p}; "+ -+ "flags={3:d}").format(unique, gfid, fd, flags)) -+ self.gfids[key] = gfid -+ dl.wind_fsetxattr(frame, POINTER(xlator_t)(), fd, dictionary, -+ flags, xdata) -+ return 0 -+ -+ def fsetxattr_cbk(self, frame, cookie, this, op_ret, op_errno, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ print(("GLUPY TRACE FSETXATTR CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; op_errno={3:d}").format(unique, gfid, -+ op_ret, op_errno)) -+ del self.gfids[key] -+ dl.unwind_fsetxattr(frame, cookie, this, op_ret, op_errno, -+ xdata) -+ return 0 -+ -+ def removexattr_fop(self, frame, this, loc, name, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE REMOVEXATTR FOP- {0:d}: gfid={1:s}; "+ -+ "path={2:s}; name={3:s}").format(unique, gfid, -+ loc.contents.path, -+ name)) -+ self.gfids[key] = gfid -+ dl.wind_removexattr(frame, POINTER(xlator_t)(), loc, name, -+ xdata) -+ return 0 -+ -+ def removexattr_cbk(self, frame, cookie, this, op_ret, op_errno, -+ xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ print(("GLUPY TRACE REMOVEXATTR CBK- {0:d}: gfid={1:s} "+ -+ " op_ret={2:d}; op_errno={3:d}").format(unique, gfid, -+ op_ret, op_errno)) -+ del self.gfids[key] -+ dl.unwind_removexattr(frame, cookie, this, op_ret, op_errno, -+ xdata) -+ return 0 -+ -+ def link_fop(self, frame, this, oldloc, newloc, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ if (newloc.contents.inode): -+ newgfid = uuid2str(newloc.contents.inode.contents.gfid) -+ else: -+ newgfid = "0" -+ oldgfid = uuid2str(oldloc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE LINK FOP-{0:d}: oldgfid={1:s}; oldpath={2:s};"+ -+ "newgfid={3:s};"+ -+ "newpath={4:s}").format(unique, oldgfid, -+ oldloc.contents.path, -+ newgfid, -+ newloc.contents.path)) -+ self.gfids[key] = oldgfid -+ dl.wind_link(frame, POINTER(xlator_t)(), oldloc, newloc, -+ xdata) -+ return 0 -+ -+ def link_cbk(self, frame, cookie, this, op_ret, op_errno, inode, buf, -+ preparent, postparent, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ if op_ret == 0: -+ statstr = trace_stat2str(buf) -+ preparentstr = trace_stat2str(preparent) -+ postparentstr = trace_stat2str(postparent) -+ print(("GLUPY TRACE LINK CBK- {0:d}: op_ret={1:d} "+ -+ "*stbuf={2:s}; *prebuf={3:s}; "+ -+ "*postbuf={4:s} ").format(unique, op_ret, statstr, -+ preparentstr, -+ postparentstr)) -+ else: -+ print(("GLUPY TRACE LINK CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; "+ -+ "op_errno={3:d}").format(unique, gfid, -+ op_ret, op_errno)) -+ del self.gfids[key] -+ dl.unwind_link(frame, cookie, this, op_ret, op_errno, inode, -+ buf, preparent, postparent, xdata) -+ return 0 -+ -+ def unlink_fop(self, frame, this, loc, xflag, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE UNLINK FOP- {0:d}; gfid={1:s}; path={2:s}; "+ -+ "flag={3:d}").format(unique, gfid, loc.contents.path, -+ xflag)) -+ self.gfids[key] = gfid -+ dl.wind_unlink(frame, POINTER(xlator_t)(), loc, xflag, -+ xdata) -+ return 0 -+ -+ def unlink_cbk(self, frame, cookie, this, op_ret, op_errno, -+ preparent, postparent, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ if op_ret == 0: -+ preparentstr = trace_stat2str(preparent) -+ postparentstr = trace_stat2str(postparent) -+ print(("GLUPY TRACE UNLINK CBK- {0:d}: gfid ={1:s}; "+ -+ "op_ret={2:d}; *prebuf={3:s}; "+ -+ "*postbuf={4:s} ").format(unique, gfid, op_ret, -+ preparentstr, -+ postparentstr)) -+ else: -+ print(("GLUPY TRACE UNLINK CBK: {0:d}: gfid ={1:s}; "+ -+ "op_ret={2:d}; "+ -+ "op_errno={3:d}").format(unique, gfid, op_ret, -+ op_errno)) -+ del self.gfids[key] -+ dl.unwind_unlink(frame, cookie, this, op_ret, op_errno, -+ preparent, postparent, xdata) -+ return 0 -+ -+ def readlink_fop(self, frame, this, loc, size, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE READLINK FOP- {0:d}: gfid={1:s}; path={2:s};"+ -+ " size={3:d}").format(unique, gfid, loc.contents.path, -+ size)) -+ self.gfids[key] = gfid -+ dl.wind_readlink(frame, POINTER(xlator_t)(), loc, size, -+ xdata) -+ return 0 -+ -+ def readlink_cbk(self, frame, cookie, this, op_ret, op_errno, -+ buf, stbuf, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ if op_ret == 0: -+ statstr = trace_stat2str(stbuf) -+ print(("GLUPY TRACE READLINK CBK- {0:d}: gfid={1:s} "+ -+ " op_ret={2:d}; op_errno={3:d}; *prebuf={4:s}; "+ -+ "*postbuf={5:s} ").format(unique, gfid, -+ op_ret, op_errno, -+ buf, statstr)) -+ else: -+ print(("GLUPY TRACE READLINK CBK- {0:d}: gfid={1:s} "+ -+ " op_ret={2:d}; op_errno={3:d}").format(unique, -+ gfid, -+ op_ret, -+ op_errno)) -+ del self.gfids[key] -+ dl.unwind_readlink(frame, cookie, this, op_ret, op_errno, buf, -+ stbuf, xdata) -+ return 0 -+ -+ def symlink_fop(self, frame, this, linkpath, loc, umask, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = uuid2str(loc.contents.inode.contents.gfid) -+ print(("GLUPY TRACE SYMLINK FOP- {0:d}: gfid={1:s}; "+ -+ "linkpath={2:s}; path={3:s};"+ -+ "umask=0{4:o}").format(unique, gfid, linkpath, -+ loc.contents.path, umask)) -+ self.gfids[key] = gfid -+ dl.wind_symlink(frame, POINTER(xlator_t)(), linkpath, loc, -+ umask, xdata) -+ return 0 -+ -+ def symlink_cbk(self, frame, cookie, this, op_ret, op_errno, -+ inode, buf, preparent, postparent, xdata): -+ unique = dl.get_rootunique(frame) -+ key = dl.get_id(frame) -+ gfid = self.gfids[key] -+ if op_ret == 0: -+ statstr = trace_stat2str(buf) -+ preparentstr = trace_stat2str(preparent) -+ postparentstr = trace_stat2str(postparent) -+ print(("GLUPY TRACE SYMLINK CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; *stbuf={3:s}; *preparent={4:s}; "+ -+ "*postparent={5:s}").format(unique, gfid, -+ op_ret, statstr, -+ preparentstr, -+ postparentstr)) -+ else: -+ print(("GLUPY TRACE SYMLINK CBK- {0:d}: gfid={1:s}; "+ -+ "op_ret={2:d}; op_errno={3:d}").format(unique, -+ gfid, -+ op_ret, -+ op_errno)) -+ del self.gfids[key] -+ dl.unwind_symlink(frame, cookie, this, op_ret, op_errno, -+ inode, buf, preparent, postparent, xdata) -+ return 0 ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/examples/helloworld.py 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,21 @@ -+ -+from __future__ import print_function -+import sys -+from gluster.glupy import * -+ -+class xlator (Translator): -+ -+ def __init__(self, c_this): -+ Translator.__init__(self, c_this) -+ -+ def lookup_fop(self, frame, this, loc, xdata): -+ print("Python xlator: Hello!") -+ dl.wind_lookup(frame, POINTER(xlator_t)(), loc, xdata) -+ return 0 -+ -+ def lookup_cbk(self, frame, cookie, this, op_ret, op_errno, inode, buf, -+ xdata, postparent): -+ print("Python xlator: Hello again!") -+ dl.unwind_lookup(frame, cookie, this, op_ret, op_errno, inode, buf, -+ xdata, postparent) -+ return 0 ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/examples/negative.py 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,93 @@ -+ -+from __future__ import print_function -+import sys -+from uuid import UUID -+from gluster.glupy import * -+ -+# Negative-lookup-caching example. If a file wasn't there the last time we -+# looked, it's probably still not there. This translator keeps track of -+# those failed lookups for us, and returns ENOENT without needing to pass the -+# call any further for repeated requests. -+ -+# If we were doing this for real, we'd need separate caches for each xlator -+# instance. The easiest way to do this would be to have xlator.__init__ -+# "register" each instance in a module-global dict, with the key as the C -+# translator address and the value as the xlator object itself. For testing -+# and teaching, it's sufficient just to have one cache. The keys are parent -+# GFIDs, and the entries are lists of names within that parent that we know -+# don't exist. -+cache = {} -+ -+# TBD: we need a better way of handling per-request data (frame->local in C). -+dl.get_id.restype = c_long -+dl.get_id.argtypes = [ POINTER(call_frame_t) ] -+ -+def uuid2str (gfid): -+ return str(UUID(''.join(map("{0:02x}".format, gfid)))) -+ -+class xlator (Translator): -+ -+ def __init__ (self, c_this): -+ self.requests = {} -+ Translator.__init__(self, c_this) -+ -+ def lookup_fop (self, frame, this, loc, xdata): -+ pargfid = uuid2str(loc.contents.pargfid) -+ print("lookup FOP: %s:%s" % (pargfid, loc.contents.name)) -+ # Check the cache. -+ if pargfid in cache: -+ if loc.contents.name in cache[pargfid]: -+ print("short-circuiting for %s:%s" % (pargfid, -+ loc.contents.name)) -+ dl.unwind_lookup(frame, 0, this, -1, 2, None, None, None, None) -+ return 0 -+ key = dl.get_id(frame) -+ self.requests[key] = (pargfid, loc.contents.name[:]) -+ # TBD: get real child xl from init, pass it here -+ dl.wind_lookup(frame, POINTER(xlator_t)(), loc, xdata) -+ return 0 -+ -+ def lookup_cbk (self, frame, cookie, this, op_ret, op_errno, inode, buf, -+ xdata, postparent): -+ print("lookup CBK: %d (%d)" % (op_ret, op_errno)) -+ key = dl.get_id(frame) -+ pargfid, name = self.requests[key] -+ # Update the cache. -+ if op_ret == 0: -+ print("found %s, removing from cache" % name) -+ if pargfid in cache: -+ cache[pargfid].discard(name) -+ elif op_errno == 2: # ENOENT -+ print("failed to find %s, adding to cache" % name) -+ if pargfid in cache: -+ cache[pargfid].add(name) -+ else: -+ cache[pargfid] = {name} -+ del self.requests[key] -+ dl.unwind_lookup(frame, cookie, this, op_ret, op_errno, -+ inode, buf, xdata, postparent) -+ return 0 -+ -+ def create_fop (self, frame, this, loc, flags, mode, umask, fd, xdata): -+ pargfid = uuid2str(loc.contents.pargfid) -+ print("create FOP: %s:%s" % (pargfid, loc.contents.name)) -+ key = dl.get_id(frame) -+ self.requests[key] = (pargfid, loc.contents.name[:]) -+ # TBD: get real child xl from init, pass it here -+ dl.wind_create(frame, POINTER(xlator_t)(), loc, flags, mode, umask, fd, xdata) -+ return 0 -+ -+ def create_cbk (self, frame, cookie, this, op_ret, op_errno, fd, inode, -+ buf, preparent, postparent, xdata): -+ print("create CBK: %d (%d)" % (op_ret, op_errno)) -+ key = dl.get_id(frame) -+ pargfid, name = self.requests[key] -+ # Update the cache. -+ if op_ret == 0: -+ print("created %s, removing from cache" % name) -+ if pargfid in cache: -+ cache[pargfid].discard(name) -+ del self.requests[key] -+ dl.unwind_create(frame, cookie, this, op_ret, op_errno, fd, inode, buf, -+ preparent, postparent, xdata) -+ return 0 ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/examples/Makefile.in 2019-07-06 08:50:36.977965653 -0400 -@@ -0,0 +1,622 @@ -+# Makefile.in generated by automake 1.13.4 from Makefile.am. -+# @configure_input@ -+ -+# Copyright (C) 1994-2013 Free Software Foundation, Inc. -+ -+# This Makefile.in is free software; the Free Software Foundation -+# gives unlimited permission to copy and/or distribute it, -+# with or without modifications, as long as this notice is preserved. -+ -+# This program is distributed in the hope that it will be useful, -+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without -+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A -+# PARTICULAR PURPOSE. -+ -+@SET_MAKE@ -+VPATH = @srcdir@ -+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' -+am__make_running_with_option = \ -+ case $${target_option-} in \ -+ ?) ;; \ -+ *) echo "am__make_running_with_option: internal error: invalid" \ -+ "target option '$${target_option-}' specified" >&2; \ -+ exit 1;; \ -+ esac; \ -+ has_opt=no; \ -+ sane_makeflags=$$MAKEFLAGS; \ -+ if $(am__is_gnu_make); then \ -+ sane_makeflags=$$MFLAGS; \ -+ else \ -+ case $$MAKEFLAGS in \ -+ *\\[\ \ ]*) \ -+ bs=\\; \ -+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ -+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ -+ esac; \ -+ fi; \ -+ skip_next=no; \ -+ strip_trailopt () \ -+ { \ -+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ -+ }; \ -+ for flg in $$sane_makeflags; do \ -+ test $$skip_next = yes && { skip_next=no; continue; }; \ -+ case $$flg in \ -+ *=*|--*) continue;; \ -+ -*I) strip_trailopt 'I'; skip_next=yes;; \ -+ -*I?*) strip_trailopt 'I';; \ -+ -*O) strip_trailopt 'O'; skip_next=yes;; \ -+ -*O?*) strip_trailopt 'O';; \ -+ -*l) strip_trailopt 'l'; skip_next=yes;; \ -+ -*l?*) strip_trailopt 'l';; \ -+ -[dEDm]) skip_next=yes;; \ -+ -[JT]) skip_next=yes;; \ -+ esac; \ -+ case $$flg in \ -+ *$$target_option*) has_opt=yes; break;; \ -+ esac; \ -+ done; \ -+ test $$has_opt = yes -+am__make_dryrun = (target_option=n; $(am__make_running_with_option)) -+am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) -+pkgdatadir = $(datadir)/@PACKAGE@ -+pkgincludedir = $(includedir)/@PACKAGE@ -+pkglibdir = $(libdir)/@PACKAGE@ -+pkglibexecdir = $(libexecdir)/@PACKAGE@ -+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd -+install_sh_DATA = $(install_sh) -c -m 644 -+install_sh_PROGRAM = $(install_sh) -c -+install_sh_SCRIPT = $(install_sh) -c -+INSTALL_HEADER = $(INSTALL_DATA) -+transform = $(program_transform_name) -+NORMAL_INSTALL = : -+PRE_INSTALL = : -+POST_INSTALL = : -+NORMAL_UNINSTALL = : -+PRE_UNINSTALL = : -+POST_UNINSTALL = : -+build_triplet = @build@ -+host_triplet = @host@ -+subdir = xlators/features/glupy/examples -+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ -+ $(glupyexamples_PYTHON) $(top_srcdir)/py-compile -+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 -+am__aclocal_m4_deps = $(top_srcdir)/contrib/aclocal/mkdirp.m4 \ -+ $(top_srcdir)/contrib/aclocal/python.m4 \ -+ $(top_srcdir)/configure.ac -+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ -+ $(ACLOCAL_M4) -+mkinstalldirs = $(install_sh) -d -+CONFIG_HEADER = $(top_builddir)/config.h $(top_builddir)/site.h -+CONFIG_CLEAN_FILES = -+CONFIG_CLEAN_VPATH_FILES = -+AM_V_P = $(am__v_P_@AM_V@) -+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) -+am__v_P_0 = false -+am__v_P_1 = : -+AM_V_GEN = $(am__v_GEN_@AM_V@) -+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) -+am__v_GEN_0 = @echo " GEN " $@; -+am__v_GEN_1 = -+AM_V_at = $(am__v_at_@AM_V@) -+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) -+am__v_at_0 = @ -+am__v_at_1 = -+SOURCES = -+DIST_SOURCES = -+am__can_run_installinfo = \ -+ case $$AM_UPDATE_INFO_DIR in \ -+ n|no|NO) false;; \ -+ *) (install-info --version) >/dev/null 2>&1;; \ -+ esac -+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; -+am__vpath_adj = case $$p in \ -+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ -+ *) f=$$p;; \ -+ esac; -+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; -+am__install_max = 40 -+am__nobase_strip_setup = \ -+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` -+am__nobase_strip = \ -+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" -+am__nobase_list = $(am__nobase_strip_setup); \ -+ for p in $$list; do echo "$$p $$p"; done | \ -+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ -+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ -+ if (++n[$$2] == $(am__install_max)) \ -+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ -+ END { for (dir in files) print dir, files[dir] }' -+am__base_list = \ -+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ -+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' -+am__uninstall_files_from_dir = { \ -+ test -z "$$files" \ -+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ -+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ -+ $(am__cd) "$$dir" && rm -f $$files; }; \ -+ } -+am__py_compile = PYTHON=$(PYTHON) $(SHELL) $(py_compile) -+am__installdirs = "$(DESTDIR)$(glupyexamplesdir)" -+am__pep3147_tweak = \ -+ sed -e 's|\.py$$||' -e 's|[^/]*$$|__pycache__/&.*.py|' -+py_compile = $(top_srcdir)/py-compile -+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) -+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) -+ACLOCAL = @ACLOCAL@ -+ACL_LIBS = @ACL_LIBS@ -+AMTAR = @AMTAR@ -+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ -+AM_LIBTOOLFLAGS = @AM_LIBTOOLFLAGS@ -+AM_MAKEFLAGS = @AM_MAKEFLAGS@ -+AR = @AR@ -+ARGP_LDADD = @ARGP_LDADD@ -+AUTOCONF = @AUTOCONF@ -+AUTOHEADER = @AUTOHEADER@ -+AUTOMAKE = @AUTOMAKE@ -+AWK = @AWK@ -+BUILD_PYTHON_SITE_PACKAGES = @BUILD_PYTHON_SITE_PACKAGES@ -+BUILD_PYTHON_SITE_PACKAGES_EXPANDED = @BUILD_PYTHON_SITE_PACKAGES_EXPANDED@ -+CC = @CC@ -+CCDEPMODE = @CCDEPMODE@ -+CFLAGS = @CFLAGS@ -+CONTRIBDIR = @CONTRIBDIR@ -+CPP = @CPP@ -+CPPFLAGS = @CPPFLAGS@ -+CYGPATH_W = @CYGPATH_W@ -+DEFS = @DEFS@ -+DEPDIR = @DEPDIR@ -+DLLTOOL = @DLLTOOL@ -+DSYMUTIL = @DSYMUTIL@ -+DUMPBIN = @DUMPBIN@ -+ECHO_C = @ECHO_C@ -+ECHO_N = @ECHO_N@ -+ECHO_T = @ECHO_T@ -+EGREP = @EGREP@ -+EVENTS_ENABLED = @EVENTS_ENABLED@ -+EVENTS_SUBDIR = @EVENTS_SUBDIR@ -+EXEEXT = @EXEEXT@ -+FGREP = @FGREP@ -+FUSERMOUNT_SUBDIR = @FUSERMOUNT_SUBDIR@ -+FUSE_CLIENT_SUBDIR = @FUSE_CLIENT_SUBDIR@ -+GEOREP_EXTRAS_SUBDIR = @GEOREP_EXTRAS_SUBDIR@ -+GFAPI_EXTRA_LDFLAGS = @GFAPI_EXTRA_LDFLAGS@ -+GFAPI_LIBS = @GFAPI_LIBS@ -+GFAPI_LT_VERSION = @GFAPI_LT_VERSION@ -+GFAPI_VERSION = @GFAPI_VERSION@ -+GF_CFLAGS = @GF_CFLAGS@ -+GF_CPPFLAGS = @GF_CPPFLAGS@ -+GF_DISTRIBUTION = @GF_DISTRIBUTION@ -+GF_FUSE_CFLAGS = @GF_FUSE_CFLAGS@ -+GF_FUSE_LDADD = @GF_FUSE_LDADD@ -+GF_HOST_OS = @GF_HOST_OS@ -+GF_LDADD = @GF_LDADD@ -+GF_LDFLAGS = @GF_LDFLAGS@ -+GF_NO_UNDEFINED = @GF_NO_UNDEFINED@ -+GF_XLATOR_DEFAULT_LDFLAGS = @GF_XLATOR_DEFAULT_LDFLAGS@ -+GF_XLATOR_LDFLAGS = @GF_XLATOR_LDFLAGS@ -+GLUPY_SUBDIR = @GLUPY_SUBDIR@ -+GLUPY_SUBDIR_MAKEFILE = @GLUPY_SUBDIR_MAKEFILE@ -+GLUPY_SUBDIR_SRC_MAKEFILE = @GLUPY_SUBDIR_SRC_MAKEFILE@ -+GLUSTERD_VOLFILE = @GLUSTERD_VOLFILE@ -+GLUSTERD_WORKDIR = @GLUSTERD_WORKDIR@ -+GLUSTERFSD_MISCDIR = @GLUSTERFSD_MISCDIR@ -+GLUSTERFS_LIBEXECDIR = @GLUSTERFS_LIBEXECDIR@ -+GREP = @GREP@ -+HAVE_ATOMIC_BUILTINS = @HAVE_ATOMIC_BUILTINS@ -+HAVE_BACKTRACE = @HAVE_BACKTRACE@ -+HAVE_LINKAT = @HAVE_LINKAT@ -+HAVE_MALLOC_STATS = @HAVE_MALLOC_STATS@ -+HAVE_SPINLOCK = @HAVE_SPINLOCK@ -+HAVE_STRNLEN = @HAVE_STRNLEN@ -+HAVE_SYNC_BUILTINS = @HAVE_SYNC_BUILTINS@ -+IBVERBS_SUBDIR = @IBVERBS_SUBDIR@ -+INSTALL = @INSTALL@ -+INSTALL_DATA = @INSTALL_DATA@ -+INSTALL_PROGRAM = @INSTALL_PROGRAM@ -+INSTALL_SCRIPT = @INSTALL_SCRIPT@ -+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ -+LD = @LD@ -+LDFLAGS = @LDFLAGS@ -+LEX = @LEX@ -+LEXLIB = @LEXLIB@ -+LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ -+LIBAIO = @LIBAIO@ -+LIBGFCHANGELOG_LT_VERSION = @LIBGFCHANGELOG_LT_VERSION@ -+LIBGFCHANGELOG_VERSION = @LIBGFCHANGELOG_VERSION@ -+LIBGFDB_VERSION = @LIBGFDB_VERSION@ -+LIBGFRPC_LT_VERSION = @LIBGFRPC_LT_VERSION@ -+LIBGFXDR_LT_VERSION = @LIBGFXDR_LT_VERSION@ -+LIBGLUSTERFS_LT_VERSION = @LIBGLUSTERFS_LT_VERSION@ -+LIBOBJS = @LIBOBJS@ -+LIBS = @LIBS@ -+LIBTOOL = @LIBTOOL@ -+LIB_DL = @LIB_DL@ -+LIPO = @LIPO@ -+LN_S = @LN_S@ -+LTLIBOBJS = @LTLIBOBJS@ -+MAKEINFO = @MAKEINFO@ -+MANIFEST_TOOL = @MANIFEST_TOOL@ -+MATH_LIB = @MATH_LIB@ -+MKDIR_P = @MKDIR_P@ -+NM = @NM@ -+NMEDIT = @NMEDIT@ -+OBJDUMP = @OBJDUMP@ -+OBJEXT = @OBJEXT@ -+OCF_SUBDIR = @OCF_SUBDIR@ -+OTOOL = @OTOOL@ -+OTOOL64 = @OTOOL64@ -+PACKAGE = @PACKAGE@ -+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ -+PACKAGE_NAME = @PACKAGE_NAME@ -+PACKAGE_RELEASE = @PACKAGE_RELEASE@ -+PACKAGE_STRING = @PACKAGE_STRING@ -+PACKAGE_TARNAME = @PACKAGE_TARNAME@ -+PACKAGE_URL = @PACKAGE_URL@ -+PACKAGE_VERSION = @PACKAGE_VERSION@ -+PATH_SEPARATOR = @PATH_SEPARATOR@ -+PKGCONFIG_UUID = @PKGCONFIG_UUID@ -+PKG_CONFIG = @PKG_CONFIG@ -+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ -+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ -+PYTHON = @PYTHON@ -+PYTHON_CFLAGS = @PYTHON_CFLAGS@ -+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ -+PYTHON_LIBS = @PYTHON_LIBS@ -+PYTHON_PLATFORM = @PYTHON_PLATFORM@ -+PYTHON_PREFIX = @PYTHON_PREFIX@ -+PYTHON_VERSION = @PYTHON_VERSION@ -+RANLIB = @RANLIB@ -+RDMA_SUBDIR = @RDMA_SUBDIR@ -+RLLIBS = @RLLIBS@ -+RPCGEN = @RPCGEN@ -+SBIN_DIR = @SBIN_DIR@ -+SED = @SED@ -+SET_MAKE = @SET_MAKE@ -+SHELL = @SHELL@ -+SIZEOF_INT = @SIZEOF_INT@ -+SIZEOF_LONG = @SIZEOF_LONG@ -+SIZEOF_LONG_LONG = @SIZEOF_LONG_LONG@ -+SIZEOF_SHORT = @SIZEOF_SHORT@ -+SQLITE_CFLAGS = @SQLITE_CFLAGS@ -+SQLITE_LIBS = @SQLITE_LIBS@ -+STRIP = @STRIP@ -+SYNCDAEMON_COMPILE = @SYNCDAEMON_COMPILE@ -+SYNCDAEMON_SUBDIR = @SYNCDAEMON_SUBDIR@ -+SYSCONF_DIR = @SYSCONF_DIR@ -+TIRPC_CFLAGS = @TIRPC_CFLAGS@ -+TIRPC_LIBS = @TIRPC_LIBS@ -+UMOUNTD_SUBDIR = @UMOUNTD_SUBDIR@ -+UNITTEST_CFLAGS = @UNITTEST_CFLAGS@ -+UNITTEST_LDFLAGS = @UNITTEST_LDFLAGS@ -+UNITTEST_LIBS = @UNITTEST_LIBS@ -+URCU_CDS_CFLAGS = @URCU_CDS_CFLAGS@ -+URCU_CDS_LIBS = @URCU_CDS_LIBS@ -+URCU_CFLAGS = @URCU_CFLAGS@ -+URCU_LIBS = @URCU_LIBS@ -+USE_EC_DYNAMIC_AVX = @USE_EC_DYNAMIC_AVX@ -+USE_EC_DYNAMIC_NEON = @USE_EC_DYNAMIC_NEON@ -+USE_EC_DYNAMIC_SSE = @USE_EC_DYNAMIC_SSE@ -+USE_EC_DYNAMIC_X64 = @USE_EC_DYNAMIC_X64@ -+USE_POSIX_ACLS = @USE_POSIX_ACLS@ -+UUID_CFLAGS = @UUID_CFLAGS@ -+UUID_LIBS = @UUID_LIBS@ -+VERSION = @VERSION@ -+XML_CFLAGS = @XML_CFLAGS@ -+XML_LIBS = @XML_LIBS@ -+YACC = @YACC@ -+YFLAGS = @YFLAGS@ -+ZLIB_CFLAGS = @ZLIB_CFLAGS@ -+ZLIB_LIBS = @ZLIB_LIBS@ -+abs_builddir = @abs_builddir@ -+abs_srcdir = @abs_srcdir@ -+abs_top_builddir = @abs_top_builddir@ -+abs_top_srcdir = @abs_top_srcdir@ -+ac_ct_AR = @ac_ct_AR@ -+ac_ct_CC = @ac_ct_CC@ -+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ -+am__include = @am__include@ -+am__leading_dot = @am__leading_dot@ -+am__quote = @am__quote@ -+am__tar = @am__tar@ -+am__untar = @am__untar@ -+bindir = @bindir@ -+build = @build@ -+build_alias = @build_alias@ -+build_cpu = @build_cpu@ -+build_os = @build_os@ -+build_vendor = @build_vendor@ -+builddir = @builddir@ -+datadir = @datadir@ -+datarootdir = @datarootdir@ -+docdir = @docdir@ -+dvidir = @dvidir@ -+exec_prefix = @exec_prefix@ -+host = @host@ -+host_alias = @host_alias@ -+host_cpu = @host_cpu@ -+host_os = @host_os@ -+host_vendor = @host_vendor@ -+htmldir = @htmldir@ -+includedir = @includedir@ -+infodir = @infodir@ -+initdir = @initdir@ -+install_sh = @install_sh@ -+launchddir = @launchddir@ -+libdir = @libdir@ -+libexecdir = @libexecdir@ -+localedir = @localedir@ -+localstatedir = @localstatedir@ -+mandir = @mandir@ -+mkdir_p = @mkdir_p@ -+mountutildir = @mountutildir@ -+oldincludedir = @oldincludedir@ -+pdfdir = @pdfdir@ -+pkgconfigdir = @pkgconfigdir@ -+pkgpyexecdir = @pkgpyexecdir@ -+pkgpythondir = @pkgpythondir@ -+prefix = @prefix@ -+program_transform_name = @program_transform_name@ -+psdir = @psdir@ -+pyexecdir = @pyexecdir@ -+pythondir = @pythondir@ -+sbindir = @sbindir@ -+sharedstatedir = @sharedstatedir@ -+shrext_cmds = @shrext_cmds@ -+srcdir = @srcdir@ -+sysconfdir = @sysconfdir@ -+systemddir = @systemddir@ -+target_alias = @target_alias@ -+tmpfilesdir = @tmpfilesdir@ -+top_build_prefix = @top_build_prefix@ -+top_builddir = @top_builddir@ -+top_srcdir = @top_srcdir@ -+xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/features -+glupyexamplesdir = $(xlatordir)/glupy -+glupyexamples_PYTHON = negative.py helloworld.py debug-trace.py -+all: all-am -+ -+.SUFFIXES: -+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) -+ @for dep in $?; do \ -+ case '$(am__configure_deps)' in \ -+ *$$dep*) \ -+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ -+ && { if test -f $@; then exit 0; else break; fi; }; \ -+ exit 1;; \ -+ esac; \ -+ done; \ -+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign xlators/features/glupy/examples/Makefile'; \ -+ $(am__cd) $(top_srcdir) && \ -+ $(AUTOMAKE) --foreign xlators/features/glupy/examples/Makefile -+.PRECIOUS: Makefile -+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status -+ @case '$?' in \ -+ *config.status*) \ -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ -+ *) \ -+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ -+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ -+ esac; -+ -+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+ -+$(top_srcdir)/configure: $(am__configure_deps) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+$(ACLOCAL_M4): $(am__aclocal_m4_deps) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+$(am__aclocal_m4_deps): -+ -+mostlyclean-libtool: -+ -rm -f *.lo -+ -+clean-libtool: -+ -rm -rf .libs _libs -+install-glupyexamplesPYTHON: $(glupyexamples_PYTHON) -+ @$(NORMAL_INSTALL) -+ @list='$(glupyexamples_PYTHON)'; dlist=; list2=; test -n "$(glupyexamplesdir)" || list=; \ -+ if test -n "$$list"; then \ -+ echo " $(MKDIR_P) '$(DESTDIR)$(glupyexamplesdir)'"; \ -+ $(MKDIR_P) "$(DESTDIR)$(glupyexamplesdir)" || exit 1; \ -+ fi; \ -+ for p in $$list; do \ -+ if test -f "$$p"; then b=; else b="$(srcdir)/"; fi; \ -+ if test -f $$b$$p; then \ -+ $(am__strip_dir) \ -+ dlist="$$dlist $$f"; \ -+ list2="$$list2 $$b$$p"; \ -+ else :; fi; \ -+ done; \ -+ for file in $$list2; do echo $$file; done | $(am__base_list) | \ -+ while read files; do \ -+ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(glupyexamplesdir)'"; \ -+ $(INSTALL_DATA) $$files "$(DESTDIR)$(glupyexamplesdir)" || exit $$?; \ -+ done || exit $$?; \ -+ if test -n "$$dlist"; then \ -+ $(am__py_compile) --destdir "$(DESTDIR)" \ -+ --basedir "$(glupyexamplesdir)" $$dlist; \ -+ else :; fi -+ -+uninstall-glupyexamplesPYTHON: -+ @$(NORMAL_UNINSTALL) -+ @list='$(glupyexamples_PYTHON)'; test -n "$(glupyexamplesdir)" || list=; \ -+ py_files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ -+ test -n "$$py_files" || exit 0; \ -+ dir='$(DESTDIR)$(glupyexamplesdir)'; \ -+ pyc_files=`echo "$$py_files" | sed 's|$$|c|'`; \ -+ pyo_files=`echo "$$py_files" | sed 's|$$|o|'`; \ -+ py_files_pep3147=`echo "$$py_files" | $(am__pep3147_tweak)`; \ -+ echo "$$py_files_pep3147";\ -+ pyc_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|c|'`; \ -+ pyo_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|o|'`; \ -+ st=0; \ -+ for files in \ -+ "$$py_files" \ -+ "$$pyc_files" \ -+ "$$pyo_files" \ -+ "$$pyc_files_pep3147" \ -+ "$$pyo_files_pep3147" \ -+ ; do \ -+ $(am__uninstall_files_from_dir) || st=$$?; \ -+ done; \ -+ exit $$st -+tags TAGS: -+ -+ctags CTAGS: -+ -+cscope cscopelist: -+ -+ -+distdir: $(DISTFILES) -+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ -+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ -+ list='$(DISTFILES)'; \ -+ dist_files=`for file in $$list; do echo $$file; done | \ -+ sed -e "s|^$$srcdirstrip/||;t" \ -+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ -+ case $$dist_files in \ -+ */*) $(MKDIR_P) `echo "$$dist_files" | \ -+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ -+ sort -u` ;; \ -+ esac; \ -+ for file in $$dist_files; do \ -+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ -+ if test -d $$d/$$file; then \ -+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ -+ if test -d "$(distdir)/$$file"; then \ -+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ -+ fi; \ -+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ -+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ -+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ -+ fi; \ -+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ -+ else \ -+ test -f "$(distdir)/$$file" \ -+ || cp -p $$d/$$file "$(distdir)/$$file" \ -+ || exit 1; \ -+ fi; \ -+ done -+check-am: all-am -+check: check-am -+all-am: Makefile -+installdirs: -+ for dir in "$(DESTDIR)$(glupyexamplesdir)"; do \ -+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ -+ done -+install: install-am -+install-exec: install-exec-am -+install-data: install-data-am -+uninstall: uninstall-am -+ -+install-am: all-am -+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am -+ -+installcheck: installcheck-am -+install-strip: -+ if test -z '$(STRIP)'; then \ -+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ -+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ -+ install; \ -+ else \ -+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ -+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ -+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ -+ fi -+mostlyclean-generic: -+ -+clean-generic: -+ -+distclean-generic: -+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) -+ -+maintainer-clean-generic: -+ @echo "This command is intended for maintainers to use" -+ @echo "it deletes files that may require special tools to rebuild." -+clean: clean-am -+ -+clean-am: clean-generic clean-libtool mostlyclean-am -+ -+distclean: distclean-am -+ -rm -f Makefile -+distclean-am: clean-am distclean-generic -+ -+dvi: dvi-am -+ -+dvi-am: -+ -+html: html-am -+ -+html-am: -+ -+info: info-am -+ -+info-am: -+ -+install-data-am: install-glupyexamplesPYTHON -+ -+install-dvi: install-dvi-am -+ -+install-dvi-am: -+ -+install-exec-am: -+ -+install-html: install-html-am -+ -+install-html-am: -+ -+install-info: install-info-am -+ -+install-info-am: -+ -+install-man: -+ -+install-pdf: install-pdf-am -+ -+install-pdf-am: -+ -+install-ps: install-ps-am -+ -+install-ps-am: -+ -+installcheck-am: -+ -+maintainer-clean: maintainer-clean-am -+ -rm -f Makefile -+maintainer-clean-am: distclean-am maintainer-clean-generic -+ -+mostlyclean: mostlyclean-am -+ -+mostlyclean-am: mostlyclean-generic mostlyclean-libtool -+ -+pdf: pdf-am -+ -+pdf-am: -+ -+ps: ps-am -+ -+ps-am: -+ -+uninstall-am: uninstall-glupyexamplesPYTHON -+ -+.MAKE: install-am install-strip -+ -+.PHONY: all all-am check check-am clean clean-generic clean-libtool \ -+ cscopelist-am ctags-am distclean distclean-generic \ -+ distclean-libtool distdir dvi dvi-am html html-am info info-am \ -+ install install-am install-data install-data-am install-dvi \ -+ install-dvi-am install-exec install-exec-am \ -+ install-glupyexamplesPYTHON install-html install-html-am \ -+ install-info install-info-am install-man install-pdf \ -+ install-pdf-am install-ps install-ps-am install-strip \ -+ installcheck installcheck-am installdirs maintainer-clean \ -+ maintainer-clean-generic mostlyclean mostlyclean-generic \ -+ mostlyclean-libtool pdf pdf-am ps ps-am tags-am uninstall \ -+ uninstall-am uninstall-glupyexamplesPYTHON -+ -+ -+# Tell versions [3.59,3.63) of GNU make to not export all variables. -+# Otherwise a system limit (for SysV at least) may be exceeded. -+.NOEXPORT: ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/src/Makefile.am 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,36 @@ -+xlator_LTLIBRARIES = glupy.la -+ -+# Ensure GLUSTER_PYTHON_PATH is passed to glupy.so -+xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/features -+glupydir = $(xlatordir)/glupy -+ -+AM_CPPFLAGS = $(GF_CPPFLAGS) \ -+ -I$(top_srcdir)/libglusterfs/src \ -+ -I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src -+ -+AM_CFLAGS = -Wall -fno-strict-aliasing \ -+ -DGLUSTER_PYTHON_PATH=\"$(glupydir)\" \ -+ -DPATH_GLUSTERFS_GLUPY_MODULE=\"${xlatordir}/glupy${shrext_cmds}\" \ -+ $(GF_CFLAGS) $(PYTHON_CFLAGS) -+ -+# Flags to build glupy.so with -+glupy_la_LDFLAGS = -module -nostartfiles \ -+ -export-symbols $(top_srcdir)/xlators/features/glupy/src/glupy.sym \ -+ $(GF_XLATOR_LDFLAGS) $(PYTHON_LIBS) -+ -+glupy_la_SOURCES = glupy.c -+glupy_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \ -+ -lpthread $(LIB_DL) -+ -+noinst_HEADERS = glupy.h -+ -+# Install __init__.py into the Python site-packages area -+pyglupydir = @BUILD_PYTHON_SITE_PACKAGES@/gluster -+pyglupy_PYTHON = __init__.py -+ -+# Install glupy/__init_-.py into the Python site-packages area -+SUBDIRS = glupy -+ -+CLEANFILES = -+ -+EXTRA_DIST = glupy.sym ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/src/__init__.py.in 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,4 @@ -+#!/usr/bin/python3 -+ -+from pkgutil import extend_path -+__path__ = extend_path(__path__, __name__) ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/src/glupy.c 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,2446 @@ -+/* -+ Copyright (c) 2006-2014 Red Hat, Inc. -+ This file is part of GlusterFS. -+ -+ This file is licensed to you under your choice of the GNU Lesser -+ General Public License, version 3 or any later version (LGPLv3 or -+ later), or the GNU General Public License, version 2 (GPLv2), in all -+ cases as published by the Free Software Foundation. -+*/ -+ -+#include -+#include -+#include -+#include -+ -+#include "glusterfs.h" -+#include "xlator.h" -+#include "logging.h" -+#include "defaults.h" -+ -+#include "glupy.h" -+ -+/* UTILITY FUNCTIONS FOR FOP-SPECIFIC CODE */ -+ -+pthread_key_t gil_init_key; -+ -+PyGILState_STATE -+glupy_enter(void) -+{ -+ if (!pthread_getspecific(gil_init_key)) { -+ PyEval_ReleaseLock(); -+ (void)pthread_setspecific(gil_init_key, (void *)1); -+ } -+ -+ return PyGILState_Ensure(); -+} -+ -+void -+glupy_leave(PyGILState_STATE gstate) -+{ -+ PyGILState_Release(gstate); -+} -+ -+/* FOP: LOOKUP */ -+ -+int32_t -+glupy_lookup_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, inode_t *inode, -+ struct iatt *buf, dict_t *xdata, struct iatt *postparent) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_LOOKUP]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_lookup_cbk_t)(priv->cbks[GLUPY_LOOKUP]))( -+ frame, cookie, this, op_ret, op_errno, inode, buf, xdata, postparent); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, xdata, -+ postparent); -+ return 0; -+} -+ -+int32_t -+glupy_lookup(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_LOOKUP]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_lookup_t)(priv->fops[GLUPY_LOOKUP]))(frame, this, loc, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_lookup_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->lookup, loc, xdata); -+ return 0; -+} -+ -+void -+wind_lookup(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_lookup_cbk, xl, xl->fops->lookup, loc, xdata); -+} -+ -+void -+unwind_lookup(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, inode_t *inode, struct iatt *buf, dict_t *xdata, -+ struct iatt *postparent) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(lookup, frame, op_ret, op_errno, inode, buf, xdata, -+ postparent); -+} -+ -+void -+set_lookup_fop(long py_this, fop_lookup_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_LOOKUP] = (long)fop; -+} -+ -+void -+set_lookup_cbk(long py_this, fop_lookup_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_LOOKUP] = (long)cbk; -+} -+ -+/* FOP: CREATE */ -+ -+int32_t -+glupy_create_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, fd_t *fd, inode_t *inode, -+ struct iatt *buf, struct iatt *preparent, -+ struct iatt *postparent, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_CREATE]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_create_cbk_t)(priv->cbks[GLUPY_CREATE]))( -+ frame, cookie, this, op_ret, op_errno, fd, inode, buf, preparent, -+ postparent, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, buf, -+ preparent, postparent, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_create(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, -+ mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_CREATE]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_create_t)(priv->fops[GLUPY_CREATE]))(frame, this, loc, flags, -+ mode, umask, fd, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_create_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->create, loc, flags, mode, umask, fd, -+ xdata); -+ return 0; -+} -+ -+void -+wind_create(call_frame_t *frame, xlator_t *xl, loc_t *loc, int32_t flags, -+ mode_t mode, mode_t umask, fd_t *fd, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_create_cbk, xl, xl->fops->create, loc, flags, mode, -+ umask, fd, xdata); -+} -+ -+void -+unwind_create(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, fd_t *fd, inode_t *inode, struct iatt *buf, -+ struct iatt *preparent, struct iatt *postparent, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(create, frame, op_ret, op_errno, fd, inode, buf, -+ preparent, postparent, xdata); -+} -+ -+void -+set_create_fop(long py_this, fop_create_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_CREATE] = (long)fop; -+} -+ -+void -+set_create_cbk(long py_this, fop_create_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_CREATE] = (long)cbk; -+} -+ -+/* FOP: OPEN */ -+ -+int32_t -+glupy_open_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_OPEN]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_open_cbk_t)(priv->cbks[GLUPY_OPEN]))( -+ frame, cookie, this, op_ret, op_errno, fd, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_open(call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, -+ fd_t *fd, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_OPEN]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_open_t)(priv->fops[GLUPY_OPEN]))(frame, this, loc, flags, fd, -+ xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_open_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->open, loc, flags, fd, xdata); -+ return 0; -+} -+ -+void -+wind_open(call_frame_t *frame, xlator_t *xl, loc_t *loc, int32_t flags, -+ fd_t *fd, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_open_cbk, xl, xl->fops->open, loc, flags, fd, -+ xdata); -+} -+ -+void -+unwind_open(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, fd_t *fd, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(open, frame, op_ret, op_errno, fd, xdata); -+} -+ -+void -+set_open_fop(long py_this, fop_open_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ priv->fops[GLUPY_OPEN] = (long)fop; -+} -+ -+void -+set_open_cbk(long py_this, fop_open_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ priv->cbks[GLUPY_OPEN] = (long)cbk; -+} -+ -+/* FOP: READV */ -+ -+int32_t -+glupy_readv_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, struct iovec *vector, -+ int32_t count, struct iatt *stbuf, struct iobref *iobref, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_READV]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_readv_cbk_t)(priv->cbks[GLUPY_READV]))( -+ frame, cookie, this, op_ret, op_errno, vector, count, stbuf, iobref, -+ xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, stbuf, -+ iobref, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_readv(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, -+ off_t offset, uint32_t flags, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_READV]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_readv_t)(priv->fops[GLUPY_READV]))(frame, this, fd, size, -+ offset, flags, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_readv_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->readv, fd, size, offset, flags, xdata); -+ return 0; -+} -+ -+void -+wind_readv(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size, -+ off_t offset, uint32_t flags, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_readv_cbk, xl, xl->fops->readv, fd, size, offset, -+ flags, xdata); -+} -+ -+void -+unwind_readv(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, struct iovec *vector, int32_t count, -+ struct iatt *stbuf, struct iobref *iobref, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(readv, frame, op_ret, op_errno, vector, count, stbuf, -+ iobref, xdata); -+} -+ -+void -+set_readv_fop(long py_this, fop_readv_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ priv->fops[GLUPY_READV] = (long)fop; -+} -+ -+void -+set_readv_cbk(long py_this, fop_readv_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ priv->cbks[GLUPY_READV] = (long)cbk; -+} -+ -+/* FOP: WRITEV */ -+ -+int32_t -+glupy_writev_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, struct iatt *prebuf, -+ struct iatt *postbuf, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_WRITEV]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_writev_cbk_t)(priv->cbks[GLUPY_WRITEV]))( -+ frame, cookie, this, op_ret, op_errno, prebuf, postbuf, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf, -+ xdata); -+ return 0; -+} -+ -+int32_t -+glupy_writev(call_frame_t *frame, xlator_t *this, fd_t *fd, -+ struct iovec *vector, int32_t count, off_t offset, uint32_t flags, -+ struct iobref *iobref, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_WRITEV]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_writev_t)(priv->fops[GLUPY_WRITEV]))( -+ frame, this, fd, vector, count, offset, flags, iobref, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_writev_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->writev, fd, vector, count, offset, -+ flags, iobref, xdata); -+ return 0; -+} -+ -+void -+wind_writev(call_frame_t *frame, xlator_t *xl, fd_t *fd, struct iovec *vector, -+ int32_t count, off_t offset, uint32_t flags, struct iobref *iobref, -+ dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_writev_cbk, xl, xl->fops->writev, fd, vector, count, -+ offset, flags, iobref, xdata); -+} -+ -+void -+unwind_writev(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, struct iatt *prebuf, struct iatt *postbuf, -+ dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(writev, frame, op_ret, op_errno, prebuf, postbuf, -+ xdata); -+} -+ -+void -+set_writev_fop(long py_this, fop_writev_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ priv->fops[GLUPY_WRITEV] = (long)fop; -+} -+ -+void -+set_writev_cbk(long py_this, fop_writev_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ priv->cbks[GLUPY_WRITEV] = (long)cbk; -+} -+ -+/* FOP: OPENDIR */ -+ -+int32_t -+glupy_opendir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, fd_t *fd, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_OPENDIR]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_opendir_cbk_t)(priv->cbks[GLUPY_OPENDIR]))( -+ frame, cookie, this, op_ret, op_errno, fd, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(opendir, frame, op_ret, op_errno, fd, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_opendir(call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_OPENDIR]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_opendir_t)(priv->fops[GLUPY_OPENDIR]))(frame, this, loc, fd, -+ xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_opendir_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->opendir, loc, fd, xdata); -+ return 0; -+} -+ -+void -+wind_opendir(call_frame_t *frame, xlator_t *xl, loc_t *loc, fd_t *fd, -+ dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_opendir_cbk, xl, xl->fops->opendir, loc, fd, xdata); -+} -+ -+void -+unwind_opendir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, fd_t *fd, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(opendir, frame, op_ret, op_errno, fd, xdata); -+} -+ -+void -+set_opendir_fop(long py_this, fop_opendir_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_OPENDIR] = (long)fop; -+} -+ -+void -+set_opendir_cbk(long py_this, fop_opendir_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_OPENDIR] = (long)cbk; -+} -+ -+/* FOP: READDIR */ -+ -+int32_t -+glupy_readdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_READDIR]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_readdir_cbk_t)(priv->cbks[GLUPY_READDIR]))( -+ frame, cookie, this, op_ret, op_errno, entries, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(readdir, frame, op_ret, op_errno, entries, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_readdir(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, -+ off_t offset, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_READDIR]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_readdir_t)(priv->fops[GLUPY_READDIR]))(frame, this, fd, size, -+ offset, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_readdir_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->readdir, fd, size, offset, xdata); -+ return 0; -+} -+ -+void -+wind_readdir(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size, -+ off_t offset, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_readdir_cbk, xl, xl->fops->readdir, fd, size, -+ offset, xdata); -+} -+ -+void -+unwind_readdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, gf_dirent_t *entries, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(readdir, frame, op_ret, op_errno, entries, xdata); -+} -+ -+void -+set_readdir_fop(long py_this, fop_readdir_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_READDIR] = (long)fop; -+} -+ -+void -+set_readdir_cbk(long py_this, fop_readdir_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_READDIR] = (long)cbk; -+} -+ -+/* FOP: READDIRP */ -+ -+int32_t -+glupy_readdirp_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_READDIRP]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_readdirp_cbk_t)(priv->cbks[GLUPY_READDIRP]))( -+ frame, cookie, this, op_ret, op_errno, entries, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, entries, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_readdirp(call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, -+ off_t offset, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_READDIRP]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_readdirp_t)(priv->fops[GLUPY_READDIRP]))(frame, this, fd, size, -+ offset, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_readdirp_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->readdirp, fd, size, offset, xdata); -+ return 0; -+} -+ -+void -+wind_readdirp(call_frame_t *frame, xlator_t *xl, fd_t *fd, size_t size, -+ off_t offset, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_readdirp_cbk, xl, xl->fops->readdirp, fd, size, -+ offset, xdata); -+} -+ -+void -+unwind_readdirp(call_frame_t *frame, long cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, gf_dirent_t *entries, -+ dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(readdirp, frame, op_ret, op_errno, entries, xdata); -+} -+ -+void -+set_readdirp_fop(long py_this, fop_readdirp_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_READDIRP] = (long)fop; -+} -+ -+void -+set_readdirp_cbk(long py_this, fop_readdirp_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_READDIRP] = (long)cbk; -+} -+ -+/* FOP:STAT */ -+ -+int32_t -+glupy_stat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, struct iatt *buf, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_STAT]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_stat_cbk_t)(priv->cbks[GLUPY_STAT]))( -+ frame, cookie, this, op_ret, op_errno, buf, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(stat, frame, op_ret, op_errno, buf, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_stat(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_STAT]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_stat_t)(priv->fops[GLUPY_STAT]))(frame, this, loc, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_stat_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->stat, loc, xdata); -+ return 0; -+} -+ -+void -+wind_stat(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_stat_cbk, xl, xl->fops->stat, loc, xdata); -+} -+ -+void -+unwind_stat(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, struct iatt *buf, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(stat, frame, op_ret, op_errno, buf, xdata); -+} -+ -+void -+set_stat_fop(long py_this, fop_stat_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_STAT] = (long)fop; -+} -+ -+void -+set_stat_cbk(long py_this, fop_stat_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_STAT] = (long)cbk; -+} -+ -+/* FOP: FSTAT */ -+ -+int32_t -+glupy_fstat_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, struct iatt *buf, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_FSTAT]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_fstat_cbk_t)(priv->cbks[GLUPY_FSTAT]))( -+ frame, cookie, this, op_ret, op_errno, buf, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(fstat, frame, op_ret, op_errno, buf, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_fstat(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_FSTAT]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_fstat_t)(priv->fops[GLUPY_FSTAT]))(frame, this, fd, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_fstat_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->fstat, fd, xdata); -+ return 0; -+} -+ -+void -+wind_fstat(call_frame_t *frame, xlator_t *xl, fd_t *fd, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_fstat_cbk, xl, xl->fops->fstat, fd, xdata); -+} -+ -+void -+unwind_fstat(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, struct iatt *buf, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(fstat, frame, op_ret, op_errno, buf, xdata); -+} -+ -+void -+set_fstat_fop(long py_this, fop_fstat_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_FSTAT] = (long)fop; -+} -+ -+void -+set_fstat_cbk(long py_this, fop_fstat_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_FSTAT] = (long)cbk; -+} -+ -+/* FOP:STATFS */ -+ -+int32_t -+glupy_statfs_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, struct statvfs *buf, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_STATFS]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_statfs_cbk_t)(priv->cbks[GLUPY_STATFS]))( -+ frame, cookie, this, op_ret, op_errno, buf, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(statfs, frame, op_ret, op_errno, buf, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_statfs(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_STATFS]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_statfs_t)(priv->fops[GLUPY_STATFS]))(frame, this, loc, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_statfs_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->statfs, loc, xdata); -+ return 0; -+} -+ -+void -+wind_statfs(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_statfs_cbk, xl, xl->fops->statfs, loc, xdata); -+} -+ -+void -+unwind_statfs(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, struct statvfs *buf, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(statfs, frame, op_ret, op_errno, buf, xdata); -+} -+ -+void -+set_statfs_fop(long py_this, fop_statfs_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_STATFS] = (long)fop; -+} -+ -+void -+set_statfs_cbk(long py_this, fop_statfs_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_STATFS] = (long)cbk; -+} -+ -+/* FOP: SETXATTR */ -+ -+int32_t -+glupy_setxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_SETXATTR]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_setxattr_cbk_t)(priv->cbks[GLUPY_SETXATTR]))( -+ frame, cookie, this, op_ret, op_errno, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_setxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, -+ int32_t flags, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_SETXATTR]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_setxattr_t)(priv->fops[GLUPY_SETXATTR]))(frame, this, loc, dict, -+ flags, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_setxattr_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->setxattr, loc, dict, flags, xdata); -+ return 0; -+} -+ -+void -+wind_setxattr(call_frame_t *frame, xlator_t *xl, loc_t *loc, dict_t *dict, -+ int32_t flags, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_setxattr_cbk, xl, xl->fops->setxattr, loc, dict, -+ flags, xdata); -+} -+ -+void -+unwind_setxattr(call_frame_t *frame, long cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(setxattr, frame, op_ret, op_errno, xdata); -+} -+ -+void -+set_setxattr_fop(long py_this, fop_setxattr_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_SETXATTR] = (long)fop; -+} -+ -+void -+set_setxattr_cbk(long py_this, fop_setxattr_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_SETXATTR] = (long)cbk; -+} -+ -+/* FOP: GETXATTR */ -+ -+int32_t -+glupy_getxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *dict, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_GETXATTR]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_getxattr_cbk_t)(priv->cbks[GLUPY_GETXATTR]))( -+ frame, cookie, this, op_ret, op_errno, dict, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, dict, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_getxattr(call_frame_t *frame, xlator_t *this, loc_t *loc, -+ const char *name, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_GETXATTR]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_getxattr_t)(priv->fops[GLUPY_GETXATTR]))(frame, this, loc, name, -+ xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_getxattr_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->getxattr, loc, name, xdata); -+ return 0; -+} -+ -+void -+wind_getxattr(call_frame_t *frame, xlator_t *xl, loc_t *loc, const char *name, -+ dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_getxattr_cbk, xl, xl->fops->getxattr, loc, name, -+ xdata); -+} -+ -+void -+unwind_getxattr(call_frame_t *frame, long cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(getxattr, frame, op_ret, op_errno, dict, xdata); -+} -+ -+void -+set_getxattr_fop(long py_this, fop_getxattr_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_GETXATTR] = (long)fop; -+} -+ -+void -+set_getxattr_cbk(long py_this, fop_getxattr_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_GETXATTR] = (long)cbk; -+} -+ -+/* FOP: FSETXATTR */ -+ -+int32_t -+glupy_fsetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_FSETXATTR]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_fsetxattr_cbk_t)(priv->cbks[GLUPY_FSETXATTR]))( -+ frame, cookie, this, op_ret, op_errno, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_fsetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *dict, -+ int32_t flags, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_FSETXATTR]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_fsetxattr_t)(priv->fops[GLUPY_FSETXATTR]))(frame, this, fd, -+ dict, flags, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_fsetxattr_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->fsetxattr, fd, dict, flags, xdata); -+ return 0; -+} -+ -+void -+wind_fsetxattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, dict_t *dict, -+ int32_t flags, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_fsetxattr_cbk, xl, xl->fops->fsetxattr, fd, dict, -+ flags, xdata); -+} -+ -+void -+unwind_fsetxattr(call_frame_t *frame, long cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(fsetxattr, frame, op_ret, op_errno, xdata); -+} -+ -+void -+set_fsetxattr_fop(long py_this, fop_fsetxattr_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_FSETXATTR] = (long)fop; -+} -+ -+void -+set_fsetxattr_cbk(long py_this, fop_fsetxattr_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_FSETXATTR] = (long)cbk; -+} -+ -+/* FOP: FGETXATTR */ -+ -+int32_t -+glupy_fgetxattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *dict, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_FGETXATTR]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_fgetxattr_cbk_t)(priv->cbks[GLUPY_FGETXATTR]))( -+ frame, cookie, this, op_ret, op_errno, dict, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(fgetxattr, frame, op_ret, op_errno, dict, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_fgetxattr(call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_FGETXATTR]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_fgetxattr_t)(priv->fops[GLUPY_FGETXATTR]))(frame, this, fd, -+ name, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_fgetxattr_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->fgetxattr, fd, name, xdata); -+ return 0; -+} -+ -+void -+wind_fgetxattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, const char *name, -+ dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_fgetxattr_cbk, xl, xl->fops->fgetxattr, fd, name, -+ xdata); -+} -+ -+void -+unwind_fgetxattr(call_frame_t *frame, long cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *dict, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(fgetxattr, frame, op_ret, op_errno, dict, xdata); -+} -+ -+void -+set_fgetxattr_fop(long py_this, fop_fgetxattr_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_FGETXATTR] = (long)fop; -+} -+ -+void -+set_fgetxattr_cbk(long py_this, fop_fgetxattr_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_FGETXATTR] = (long)cbk; -+} -+ -+/* FOP:REMOVEXATTR */ -+ -+int32_t -+glupy_removexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_REMOVEXATTR]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_removexattr_cbk_t)(priv->cbks[GLUPY_REMOVEXATTR]))( -+ frame, cookie, this, op_ret, op_errno, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_removexattr(call_frame_t *frame, xlator_t *this, loc_t *loc, -+ const char *name, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_REMOVEXATTR]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_removexattr_t)(priv->fops[GLUPY_REMOVEXATTR]))(frame, this, loc, -+ name, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_removexattr_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->removexattr, loc, name, xdata); -+ return 0; -+} -+ -+void -+wind_removexattr(call_frame_t *frame, xlator_t *xl, loc_t *loc, -+ const char *name, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_removexattr_cbk, xl, xl->fops->removexattr, loc, -+ name, xdata); -+} -+ -+void -+unwind_removexattr(call_frame_t *frame, long cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(removexattr, frame, op_ret, op_errno, xdata); -+} -+ -+void -+set_removexattr_fop(long py_this, fop_removexattr_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_REMOVEXATTR] = (long)fop; -+} -+ -+void -+set_removexattr_cbk(long py_this, fop_removexattr_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_REMOVEXATTR] = (long)cbk; -+} -+ -+/* FOP:FREMOVEXATTR */ -+ -+int32_t -+glupy_fremovexattr_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_FREMOVEXATTR]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_fremovexattr_cbk_t)(priv->cbks[GLUPY_FREMOVEXATTR]))( -+ frame, cookie, this, op_ret, op_errno, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(fremovexattr, frame, op_ret, op_errno, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_fremovexattr(call_frame_t *frame, xlator_t *this, fd_t *fd, -+ const char *name, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_FREMOVEXATTR]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_fremovexattr_t)(priv->fops[GLUPY_FREMOVEXATTR]))( -+ frame, this, fd, name, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_fremovexattr_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->fremovexattr, fd, name, xdata); -+ return 0; -+} -+ -+void -+wind_fremovexattr(call_frame_t *frame, xlator_t *xl, fd_t *fd, const char *name, -+ dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_fremovexattr_cbk, xl, xl->fops->fremovexattr, fd, -+ name, xdata); -+} -+ -+void -+unwind_fremovexattr(call_frame_t *frame, long cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(fremovexattr, frame, op_ret, op_errno, xdata); -+} -+ -+void -+set_fremovexattr_fop(long py_this, fop_fremovexattr_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_FREMOVEXATTR] = (long)fop; -+} -+ -+void -+set_fremovexattr_cbk(long py_this, fop_fremovexattr_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_FREMOVEXATTR] = (long)cbk; -+} -+ -+/* FOP: LINK*/ -+int32_t -+glupy_link_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, inode_t *inode, -+ struct iatt *buf, struct iatt *preparent, -+ struct iatt *postparent, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_LINK]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_link_cbk_t)(priv->cbks[GLUPY_LINK]))( -+ frame, cookie, this, op_ret, op_errno, inode, buf, preparent, -+ postparent, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, inode, buf, preparent, -+ postparent, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_link(call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_LINK]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_link_t)(priv->fops[GLUPY_LINK]))(frame, this, oldloc, newloc, -+ xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_link_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->link, oldloc, newloc, xdata); -+ return 0; -+} -+ -+void -+wind_link(call_frame_t *frame, xlator_t *xl, loc_t *oldloc, loc_t *newloc, -+ dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_link_cbk, xl, xl->fops->link, oldloc, newloc, -+ xdata); -+} -+ -+void -+unwind_link(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, inode_t *inode, struct iatt *buf, -+ struct iatt *preparent, struct iatt *postparent, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(link, frame, op_ret, op_errno, inode, buf, preparent, -+ postparent, xdata); -+} -+ -+void -+set_link_fop(long py_this, fop_link_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_LINK] = (long)fop; -+} -+ -+void -+set_link_cbk(long py_this, fop_link_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_LINK] = (long)cbk; -+} -+ -+/* FOP: SYMLINK*/ -+int32_t -+glupy_symlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, inode_t *inode, -+ struct iatt *buf, struct iatt *preparent, -+ struct iatt *postparent, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_SYMLINK]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_symlink_cbk_t)(priv->cbks[GLUPY_SYMLINK]))( -+ frame, cookie, this, op_ret, op_errno, inode, buf, preparent, -+ postparent, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, inode, buf, preparent, -+ postparent, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_symlink(call_frame_t *frame, xlator_t *this, const char *linkname, -+ loc_t *loc, mode_t umask, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_SYMLINK]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_symlink_t)(priv->fops[GLUPY_SYMLINK]))(frame, this, linkname, -+ loc, umask, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_symlink_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->symlink, linkname, loc, umask, xdata); -+ return 0; -+} -+ -+void -+wind_symlink(call_frame_t *frame, xlator_t *xl, const char *linkname, -+ loc_t *loc, mode_t umask, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_symlink_cbk, xl, xl->fops->symlink, linkname, loc, -+ umask, xdata); -+} -+ -+void -+unwind_symlink(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, inode_t *inode, struct iatt *buf, -+ struct iatt *preparent, struct iatt *postparent, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(symlink, frame, op_ret, op_errno, inode, buf, preparent, -+ postparent, xdata); -+} -+ -+void -+set_symlink_fop(long py_this, fop_symlink_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_SYMLINK] = (long)fop; -+} -+ -+void -+set_symlink_cbk(long py_this, fop_symlink_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_SYMLINK] = (long)cbk; -+} -+ -+/* FOP: READLINK */ -+int32_t -+glupy_readlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, const char *path, -+ struct iatt *buf, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_READLINK]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_readlink_cbk_t)(priv->cbks[GLUPY_READLINK]))( -+ frame, cookie, this, op_ret, op_errno, path, buf, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(readlink, frame, op_ret, op_errno, path, buf, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_readlink(call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_READLINK]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_readlink_t)(priv->fops[GLUPY_READLINK]))(frame, this, loc, size, -+ xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_readlink_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->readlink, loc, size, xdata); -+ return 0; -+} -+ -+void -+wind_readlink(call_frame_t *frame, xlator_t *xl, loc_t *loc, size_t size, -+ dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_readlink_cbk, xl, xl->fops->readlink, loc, size, -+ xdata); -+} -+ -+void -+unwind_readlink(call_frame_t *frame, long cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, const char *path, -+ struct iatt *buf, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(readlink, frame, op_ret, op_errno, path, buf, xdata); -+} -+ -+void -+set_readlink_fop(long py_this, fop_readlink_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_READLINK] = (long)fop; -+} -+ -+void -+set_readlink_cbk(long py_this, fop_readlink_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_READLINK] = (long)cbk; -+} -+ -+/* FOP: UNLINK */ -+ -+int32_t -+glupy_unlink_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, struct iatt *preparent, -+ struct iatt *postparent, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_UNLINK]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_unlink_cbk_t)(priv->cbks[GLUPY_UNLINK]))( -+ frame, cookie, this, op_ret, op_errno, preparent, postparent, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, preparent, postparent, -+ xdata); -+ return 0; -+} -+ -+int32_t -+glupy_unlink(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_UNLINK]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_unlink_t)(priv->fops[GLUPY_UNLINK]))(frame, this, loc, xflags, -+ xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_unlink_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->unlink, loc, xflags, xdata); -+ return 0; -+} -+ -+void -+wind_unlink(call_frame_t *frame, xlator_t *xl, loc_t *loc, int xflags, -+ dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_unlink_cbk, xl, xl->fops->unlink, loc, xflags, -+ xdata); -+} -+ -+void -+unwind_unlink(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, struct iatt *preparent, struct iatt *postparent, -+ dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(unlink, frame, op_ret, op_errno, preparent, postparent, -+ xdata); -+} -+ -+void -+set_unlink_fop(long py_this, fop_unlink_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_UNLINK] = (long)fop; -+} -+ -+void -+set_unlink_cbk(long py_this, fop_unlink_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_UNLINK] = (long)cbk; -+} -+ -+/* FOP: MKDIR */ -+ -+int32_t -+glupy_mkdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, inode_t *inode, -+ struct iatt *buf, struct iatt *preparent, -+ struct iatt *postparent, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_MKDIR]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_mkdir_cbk_t)(priv->cbks[GLUPY_MKDIR]))( -+ frame, cookie, this, op_ret, op_errno, inode, buf, preparent, -+ postparent, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(mkdir, frame, op_ret, op_errno, inode, buf, preparent, -+ postparent, xdata); -+ return 0; -+} -+ -+int32_t -+glupy_mkdir(call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, -+ mode_t umask, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_MKDIR]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_mkdir_t)(priv->fops[GLUPY_MKDIR]))(frame, this, loc, mode, -+ umask, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_mkdir_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->mkdir, loc, mode, umask, xdata); -+ return 0; -+} -+ -+void -+wind_mkdir(call_frame_t *frame, xlator_t *xl, loc_t *loc, mode_t mode, -+ mode_t umask, dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_mkdir_cbk, xl, xl->fops->mkdir, loc, mode, umask, -+ xdata); -+} -+ -+void -+unwind_mkdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, inode_t *inode, struct iatt *buf, -+ struct iatt *preparent, struct iatt *postparent, dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(mkdir, frame, op_ret, op_errno, inode, buf, preparent, -+ postparent, xdata); -+} -+ -+void -+set_mkdir_fop(long py_this, fop_mkdir_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_MKDIR] = (long)fop; -+} -+ -+void -+set_mkdir_cbk(long py_this, fop_mkdir_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_MKDIR] = (long)cbk; -+} -+ -+/* FOP: RMDIR */ -+ -+int32_t -+glupy_rmdir_cbk(call_frame_t *frame, void *cookie, xlator_t *this, -+ int32_t op_ret, int32_t op_errno, struct iatt *preparent, -+ struct iatt *postparent, dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ -+ if (!priv->cbks[GLUPY_RMDIR]) { -+ goto unwind; -+ } -+ -+ gstate = glupy_enter(); -+ ret = ((fop_rmdir_cbk_t)(priv->cbks[GLUPY_RMDIR]))( -+ frame, cookie, this, op_ret, op_errno, preparent, postparent, xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+unwind: -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(rmdir, frame, op_ret, op_errno, preparent, postparent, -+ xdata); -+ return 0; -+} -+ -+int32_t -+glupy_rmdir(call_frame_t *frame, xlator_t *this, loc_t *loc, int xflags, -+ dict_t *xdata) -+{ -+ glupy_private_t *priv = this->private; -+ PyGILState_STATE gstate; -+ int32_t ret; -+ static long next_id = 0; -+ -+ if (!priv->fops[GLUPY_RMDIR]) { -+ goto wind; -+ } -+ -+ gstate = glupy_enter(); -+ frame->local = (void *)++next_id; -+ ret = ((fop_rmdir_t)(priv->fops[GLUPY_RMDIR]))(frame, this, loc, xflags, -+ xdata); -+ glupy_leave(gstate); -+ -+ return ret; -+ -+wind: -+ STACK_WIND(frame, glupy_rmdir_cbk, FIRST_CHILD(this), -+ FIRST_CHILD(this)->fops->rmdir, loc, xflags, xdata); -+ return 0; -+} -+ -+void -+wind_rmdir(call_frame_t *frame, xlator_t *xl, loc_t *loc, int xflags, -+ dict_t *xdata) -+{ -+ xlator_t *this = THIS; -+ -+ if (!xl || (xl == this)) { -+ xl = FIRST_CHILD(this); -+ } -+ -+ STACK_WIND(frame, glupy_rmdir_cbk, xl, xl->fops->rmdir, loc, xflags, xdata); -+} -+ -+void -+unwind_rmdir(call_frame_t *frame, long cookie, xlator_t *this, int32_t op_ret, -+ int32_t op_errno, struct iatt *preparent, struct iatt *postparent, -+ dict_t *xdata) -+{ -+ frame->local = NULL; -+ STACK_UNWIND_STRICT(rmdir, frame, op_ret, op_errno, preparent, postparent, -+ xdata); -+} -+ -+void -+set_rmdir_fop(long py_this, fop_rmdir_t fop) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->fops[GLUPY_RMDIR] = (long)fop; -+} -+ -+void -+set_rmdir_cbk(long py_this, fop_rmdir_cbk_t cbk) -+{ -+ glupy_private_t *priv = ((xlator_t *)py_this)->private; -+ -+ priv->cbks[GLUPY_RMDIR] = (long)cbk; -+} -+ -+/* NON-FOP-SPECIFIC CODE */ -+ -+long -+get_id(call_frame_t *frame) -+{ -+ return (long)(frame->local); -+} -+ -+uint64_t -+get_rootunique(call_frame_t *frame) -+{ -+ return frame->root->unique; -+} -+ -+int32_t -+mem_acct_init(xlator_t *this) -+{ -+ int ret = -1; -+ -+ if (!this) -+ return ret; -+ -+ ret = xlator_mem_acct_init(this, gf_glupy_mt_end); -+ -+ if (ret != 0) { -+ gf_log(this->name, GF_LOG_ERROR, -+ "Memory accounting init" -+ " failed"); -+ return ret; -+ } -+ -+ return ret; -+} -+ -+static void -+py_error_log(const char *name, PyObject *pystr) -+{ -+#if PY_MAJOR_VERSION > 2 -+ char scr[256]; -+ if (PyUnicode_Check(pystr)) { -+ PyObject *tmp = PyUnicode_AsEncodedString(pystr, "UTF-8", "strict"); -+ if (tmp != NULL) { -+ strncpy(scr, PyBytes_AS_STRING(pystr), sizeof(scr)); -+ Py_DECREF(tmp); -+ } else { -+ strncpy(scr, "string encoding error", sizeof(scr)); -+ } -+ } else if (PyBytes_Check(pystr)) { -+ strncpy(scr, PyBytes_AS_STRING(pystr), sizeof(scr)); -+ } else { -+ strncpy(scr, "string encoding error", sizeof(scr)); -+ } -+ gf_log(name, GF_LOG_ERROR, "Python error: %s", scr); -+#else -+ gf_log(name, GF_LOG_ERROR, "Python error: %s", PyString_AsString(pystr)); -+#endif -+} -+ -+static PyObject * -+encode(const char *str) -+{ -+#if PY_MAJOR_VERSION > 2 -+ return PyUnicode_FromString(str); -+#else -+ return PyString_FromString(str); -+#endif -+} -+ -+int32_t -+init(xlator_t *this) -+{ -+ glupy_private_t *priv = NULL; -+ char *module_name = NULL; -+ PyObject *py_mod_name = NULL; -+ PyObject *py_init_func = NULL; -+ PyObject *py_args = NULL; -+ PyObject *syspath = NULL; -+ PyObject *path = NULL; -+ PyObject *error_type = NULL; -+ PyObject *error_msg = NULL; -+ PyObject *error_bt = NULL; -+ static gf_boolean_t py_inited = _gf_false; -+ void *err_cleanup = &&err_return; -+ char libpython[16]; -+ -+ if (dict_get_str(this->options, "module-name", &module_name) != 0) { -+ gf_log(this->name, GF_LOG_ERROR, "missing module-name"); -+ return -1; -+ } -+ -+ priv = GF_CALLOC(1, sizeof(glupy_private_t), gf_glupy_mt_priv); -+ if (!priv) { -+ goto *err_cleanup; -+ } -+ this->private = priv; -+ err_cleanup = &&err_free_priv; -+ -+ if (!py_inited) { -+ /* FIXME: -+ * This hack is necessary because glusterfs (rightly) loads -+ * glupy.so with RTLD_LOCAL but glupy needs libpython to be -+ * loaded with RTLD_GLOBAL even though glupy is correctly -+ * linked with libpython. -+ * This is needed because one of the internal modules of -+ * python 2.x (lib-dynload/_struct.so) does not explicitly -+ * link with libpython. -+ */ -+ snprintf(libpython, sizeof(libpython), "libpython%d.%d.so", -+ PY_MAJOR_VERSION, PY_MINOR_VERSION); -+ if (!dlopen(libpython, RTLD_NOW | RTLD_GLOBAL)) { -+ gf_msg(this->name, GF_LOG_WARNING, 0, LG_MSG_DLOPEN_FAILED, -+ "dlopen(%s) failed: %s", libpython, dlerror()); -+ } -+ -+ /* -+ * This must be done before Py_Initialize(), -+ * because it will duplicate the environment, -+ * and fail to see later environment updates. -+ */ -+ setenv("PATH_GLUSTERFS_GLUPY_MODULE", PATH_GLUSTERFS_GLUPY_MODULE, 1); -+ -+ Py_Initialize(); -+ PyEval_InitThreads(); -+ -+ (void)pthread_key_create(&gil_init_key, NULL); -+ (void)pthread_setspecific(gil_init_key, (void *)1); -+ -+ /* PyEval_InitThreads takes this "for" us. No thanks. */ -+ PyEval_ReleaseLock(); -+ py_inited = _gf_true; -+ } -+ -+ /* Adjust python's path */ -+ syspath = PySys_GetObject("path"); -+ path = encode(GLUSTER_PYTHON_PATH); -+ PyList_Append(syspath, path); -+ Py_DECREF(path); -+ -+ py_mod_name = encode(module_name); -+ if (!py_mod_name) { -+ gf_log(this->name, GF_LOG_ERROR, "could not create name"); -+ if (PyErr_Occurred()) { -+ PyErr_Fetch(&error_type, &error_msg, &error_bt); -+ py_error_log(this->name, error_msg); -+ } -+ goto *err_cleanup; -+ } -+ -+ gf_log(this->name, GF_LOG_DEBUG, "py_mod_name = %s", module_name); -+ priv->py_module = PyImport_Import(py_mod_name); -+ Py_DECREF(py_mod_name); -+ if (!priv->py_module) { -+ gf_log(this->name, GF_LOG_ERROR, "Python import of %s failed", -+ module_name); -+ if (PyErr_Occurred()) { -+ PyErr_Fetch(&error_type, &error_msg, &error_bt); -+ py_error_log(this->name, error_msg); -+ } -+ goto *err_cleanup; -+ } -+ gf_log(this->name, GF_LOG_INFO, "Import of %s succeeded", module_name); -+ err_cleanup = &&err_deref_module; -+ -+ py_init_func = PyObject_GetAttrString(priv->py_module, "xlator"); -+ if (!py_init_func || !PyCallable_Check(py_init_func)) { -+ gf_log(this->name, GF_LOG_ERROR, "missing init func"); -+ if (PyErr_Occurred()) { -+ PyErr_Fetch(&error_type, &error_msg, &error_bt); -+ py_error_log(this->name, error_msg); -+ } -+ goto *err_cleanup; -+ } -+ err_cleanup = &&err_deref_init; -+ -+ py_args = PyTuple_New(1); -+ if (!py_args) { -+ gf_log(this->name, GF_LOG_ERROR, "could not create args"); -+ if (PyErr_Occurred()) { -+ PyErr_Fetch(&error_type, &error_msg, &error_bt); -+ py_error_log(this->name, error_msg); -+ } -+ goto *err_cleanup; -+ } -+ PyTuple_SetItem(py_args, 0, PyLong_FromLong((long)this)); -+ -+ /* TBD: pass in list of children */ -+ priv->py_xlator = PyObject_CallObject(py_init_func, py_args); -+ Py_DECREF(py_args); -+ if (!priv->py_xlator) { -+ gf_log(this->name, GF_LOG_ERROR, "Python init failed"); -+ if (PyErr_Occurred()) { -+ PyErr_Fetch(&error_type, &error_msg, &error_bt); -+ py_error_log(this->name, error_msg); -+ } -+ goto *err_cleanup; -+ } -+ gf_log(this->name, GF_LOG_DEBUG, "init returned %p", priv->py_xlator); -+ -+ return 0; -+ -+err_deref_init: -+ Py_DECREF(py_init_func); -+err_deref_module: -+ Py_DECREF(priv->py_module); -+err_free_priv: -+ GF_FREE(priv); -+err_return: -+ return -1; -+} -+ -+void -+fini(xlator_t *this) -+{ -+ glupy_private_t *priv = this->private; -+ -+ if (!priv) -+ return; -+ Py_DECREF(priv->py_xlator); -+ Py_DECREF(priv->py_module); -+ this->private = NULL; -+ GF_FREE(priv); -+ -+ return; -+} -+ -+struct xlator_fops fops = {.lookup = glupy_lookup, -+ .create = glupy_create, -+ .open = glupy_open, -+ .readv = glupy_readv, -+ .writev = glupy_writev, -+ .opendir = glupy_opendir, -+ .readdir = glupy_readdir, -+ .stat = glupy_stat, -+ .fstat = glupy_fstat, -+ .setxattr = glupy_setxattr, -+ .getxattr = glupy_getxattr, -+ .fsetxattr = glupy_fsetxattr, -+ .fgetxattr = glupy_fgetxattr, -+ .removexattr = glupy_removexattr, -+ .fremovexattr = glupy_fremovexattr, -+ .link = glupy_link, -+ .unlink = glupy_unlink, -+ .readlink = glupy_readlink, -+ .symlink = glupy_symlink, -+ .mkdir = glupy_mkdir, -+ .rmdir = glupy_rmdir, -+ .statfs = glupy_statfs, -+ .readdirp = glupy_readdirp}; -+ -+struct xlator_cbks cbks = {}; -+ -+struct volume_options options[] = { -+ {.key = {NULL}}, -+}; ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/src/glupy.h 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,56 @@ -+/* -+ Copyright (c) 2006-2014 Red Hat, Inc. -+ This file is part of GlusterFS. -+ -+ This file is licensed to you under your choice of the GNU Lesser -+ General Public License, version 3 or any later version (LGPLv3 or -+ later), or the GNU General Public License, version 2 (GPLv2), in all -+ cases as published by the Free Software Foundation. -+*/ -+ -+#ifndef __GLUPY_H__ -+#define __GLUPY_H__ -+ -+#include "mem-types.h" -+ -+enum { -+ GLUPY_LOOKUP = 0, -+ GLUPY_CREATE, -+ GLUPY_OPEN, -+ GLUPY_READV, -+ GLUPY_WRITEV, -+ GLUPY_OPENDIR, -+ GLUPY_READDIR, -+ GLUPY_READDIRP, -+ GLUPY_STAT, -+ GLUPY_FSTAT, -+ GLUPY_STATFS, -+ GLUPY_SETXATTR, -+ GLUPY_GETXATTR, -+ GLUPY_FSETXATTR, -+ GLUPY_FGETXATTR, -+ GLUPY_REMOVEXATTR, -+ GLUPY_FREMOVEXATTR, -+ GLUPY_LINK, -+ GLUPY_UNLINK, -+ GLUPY_READLINK, -+ GLUPY_SYMLINK, -+ GLUPY_MKNOD, -+ GLUPY_MKDIR, -+ GLUPY_RMDIR, -+ GLUPY_N_FUNCS -+}; -+ -+typedef struct { -+ PyObject *py_module; -+ PyObject *py_xlator; -+ long fops[GLUPY_N_FUNCS]; -+ long cbks[GLUPY_N_FUNCS]; -+} glupy_private_t; -+ -+enum gf_glupy_mem_types_ { -+ gf_glupy_mt_priv = gf_common_mt_end + 1, -+ gf_glupy_mt_end -+}; -+ -+#endif /* __GLUPY_H__ */ ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/src/glupy.sym 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,101 @@ -+init -+fini -+fops -+cbks -+options -+notify -+mem_acct_init -+reconfigure -+dumpops -+set_lookup_fop -+set_lookup_cbk -+set_create_fop -+set_create_cbk -+set_open_fop -+set_open_cbk -+set_readv_fop -+set_readv_cbk -+set_writev_fop -+set_writev_cbk -+set_opendir_fop -+set_opendir_cbk -+set_readdir_fop -+set_readdir_cbk -+set_readdirp_fop -+set_readdirp_cbk -+set_stat_fop -+set_stat_cbk -+set_fstat_fop -+set_fstat_cbk -+set_statfs_fop -+set_statfs_cbk -+set_setxattr_fop -+set_setxattr_cbk -+set_getxattr_fop -+set_getxattr_cbk -+set_fsetxattr_fop -+set_fsetxattr_cbk -+set_fgetxattr_fop -+set_fgetxattr_cbk -+set_removexattr_fop -+set_removexattr_cbk -+set_fremovexattr_fop -+set_fremovexattr_cbk -+set_link_fop -+set_link_cbk -+set_symlink_fop -+set_symlink_cbk -+set_readlink_fop -+set_readlink_cbk -+set_unlink_fop -+set_unlink_cbk -+set_mkdir_fop -+set_mkdir_cbk -+set_rmdir_fop -+set_rmdir_cbk -+wind_lookup -+wind_create -+wind_open -+wind_readv -+wind_writev -+wind_opendir -+wind_readdir -+wind_readdirp -+wind_stat -+wind_fstat -+wind_statfs -+wind_setxattr -+wind_getxattr -+wind_fsetxattr -+wind_fgetxattr -+wind_removexattr -+wind_fremovexattr -+wind_link -+wind_symlink -+wind_readlink -+wind_unlink -+wind_mkdir -+wind_rmdir -+unwind_lookup -+unwind_create -+unwind_open -+unwind_readv -+unwind_writev -+unwind_opendir -+unwind_readdir -+unwind_readdirp -+unwind_stat -+unwind_fstat -+unwind_statfs -+unwind_setxattr -+unwind_getxattr -+unwind_fsetxattr -+unwind_fgetxattr -+unwind_removexattr -+unwind_fremovexattr -+unwind_link -+unwind_symlink -+unwind_readlink -+unwind_unlink -+unwind_mkdir -+unwind_rmdir ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/src/glupy/Makefile.am 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,5 @@ -+# Install __init__.py into the Python site-packages area -+pyglupydir = @BUILD_PYTHON_SITE_PACKAGES@/gluster/glupy -+pyglupy_PYTHON = __init__.py -+ -+CLEANFILES = ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/src/glupy/__init__.py 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,852 @@ -+## -+## Copyright (c) 2006-2014 Red Hat, Inc. -+## This file is part of GlusterFS. -+## -+## This file is licensed to you under your choice of the GNU Lesser -+## General Public License, version 3 or any later version (LGPLv3 or -+## later), or the GNU General Public License, version 2 (GPLv2), in all -+## cases as published by the Free Software Foundation. -+## -+ -+import sys -+import os -+from ctypes import * -+ -+dl = CDLL(os.getenv("PATH_GLUSTERFS_GLUPY_MODULE", ""), RTLD_GLOBAL) -+ -+ -+class call_frame_t (Structure): -+ pass -+ -+class dev_t (Structure): -+ pass -+ -+ -+class dict_t (Structure): -+ pass -+ -+ -+class gf_dirent_t (Structure): -+ pass -+ -+ -+class iobref_t (Structure): -+ pass -+ -+ -+class iovec_t (Structure): -+ pass -+ -+ -+class list_head (Structure): -+ pass -+ -+list_head._fields_ = [ -+ ("next", POINTER(list_head)), -+ ("prev", POINTER(list_head)) -+ ] -+ -+ -+class rwxperm_t (Structure): -+ _fields_ = [ -+ ("read", c_uint8, 1), -+ ("write", c_uint8, 1), -+ ("execn", c_uint8, 1) -+ ] -+ -+ -+class statvfs_t (Structure): -+ pass -+ -+ -+class xlator_t (Structure): -+ pass -+ -+ -+class ia_prot_t (Structure): -+ _fields_ = [ -+ ("suid", c_uint8, 1), -+ ("sgid", c_uint8, 1), -+ ("sticky", c_uint8, 1), -+ ("owner", rwxperm_t), -+ ("group", rwxperm_t), -+ ("other", rwxperm_t) -+ ] -+ -+# For checking file type. -+(IA_INVAL, IA_IFREG, IA_IFDIR, IA_IFLNK, IA_IFBLK, IA_IFCHR, IA_IFIFO, -+ IA_IFSOCK) = range(8) -+ -+ -+class iatt_t (Structure): -+ _fields_ = [ -+ ("ia_no", c_uint64), -+ ("ia_gfid", c_ubyte * 16), -+ ("ia_dev", c_uint64), -+ ("ia_type", c_uint), -+ ("ia_prot", ia_prot_t), -+ ("ia_nlink", c_uint32), -+ ("ia_uid", c_uint32), -+ ("ia_gid", c_uint32), -+ ("ia_rdev", c_uint64), -+ ("ia_size", c_uint64), -+ ("ia_blksize", c_uint32), -+ ("ia_blocks", c_uint64), -+ ("ia_atime", c_uint32 ), -+ ("ia_atime_nsec", c_uint32), -+ ("ia_mtime", c_uint32), -+ ("ia_mtime_nsec", c_uint32), -+ ("ia_ctime", c_uint32), -+ ("ia_ctime_nsec", c_uint32) -+ ] -+ -+ -+class mem_pool (Structure): -+ _fields_ = [ -+ ("list", list_head), -+ ("hot_count", c_int), -+ ("cold_count", c_int), -+ ("lock", c_void_p), -+ ("padded_sizeof_type", c_ulong), -+ ("pool", c_void_p), -+ ("pool_end", c_void_p), -+ ("real_sizeof_type", c_int), -+ ("alloc_count", c_uint64), -+ ("pool_misses", c_uint64), -+ ("max_alloc", c_int), -+ ("curr_stdalloc", c_int), -+ ("max_stdalloc", c_int), -+ ("name", c_char_p), -+ ("global_list", list_head) -+ ] -+ -+ -+class U_ctx_key_inode (Union): -+ _fields_ = [ -+ ("key", c_uint64), -+ ("xl_key", POINTER(xlator_t)) -+ ] -+ -+ -+class U_ctx_value1 (Union): -+ _fields_ = [ -+ ("value1", c_uint64), -+ ("ptr1", c_void_p) -+ ] -+ -+ -+class U_ctx_value2 (Union): -+ _fields_ = [ -+ ("value2", c_uint64), -+ ("ptr2", c_void_p) -+ ] -+ -+class inode_ctx (Structure): -+ _anonymous_ = ("u_key", "u_value1", "u_value2",) -+ _fields_ = [ -+ ("u_key", U_ctx_key_inode), -+ ("u_value1", U_ctx_value1), -+ ("u_value2", U_ctx_value2) -+ ] -+ -+class inode_t (Structure): -+ pass -+ -+class inode_table_t (Structure): -+ _fields_ = [ -+ ("lock", c_void_p), -+ ("hashsize", c_size_t), -+ ("name", c_char_p), -+ ("root", POINTER(inode_t)), -+ ("xl", POINTER(xlator_t)), -+ ("lru_limit", c_uint32), -+ ("inode_hash", POINTER(list_head)), -+ ("name_hash", POINTER(list_head)), -+ ("active", list_head), -+ ("active_size", c_uint32), -+ ("lru", list_head), -+ ("lru_size", c_uint32), -+ ("purge", list_head), -+ ("purge_size", c_uint32), -+ ("inode_pool", POINTER(mem_pool)), -+ ("dentry_pool", POINTER(mem_pool)), -+ ("fd_mem_pool", POINTER(mem_pool)) -+ ] -+ -+inode_t._fields_ = [ -+ ("table", POINTER(inode_table_t)), -+ ("gfid", c_ubyte * 16), -+ ("lock", c_void_p), -+ ("nlookup", c_uint64), -+ ("fd_count", c_uint32), -+ ("ref", c_uint32), -+ ("ia_type", c_uint), -+ ("fd_list", list_head), -+ ("dentry_list", list_head), -+ ("hashv", list_head), -+ ("listv", list_head), -+ ("ctx", POINTER(inode_ctx)) -+ ] -+ -+ -+ -+class U_ctx_key_fd (Union): -+ _fields_ = [ -+ ("key", c_uint64), -+ ("xl_key", c_void_p) -+ ] -+ -+class fd_lk_ctx (Structure): -+ _fields_ = [ -+ ("lk_list", list_head), -+ ("ref", c_int), -+ ("lock", c_void_p) -+ ] -+ -+class fd_ctx (Structure): -+ _anonymous_ = ("u_key", "u_value1") -+ _fields_ = [ -+ ("u_key", U_ctx_key_fd), -+ ("u_value1", U_ctx_value1) -+ ] -+ -+class fd_t (Structure): -+ _fields_ = [ -+ ("pid", c_uint64), -+ ("flags", c_int32), -+ ("refcount", c_int32), -+ ("inode_list", list_head), -+ ("inode", POINTER(inode_t)), -+ ("lock", c_void_p), -+ ("ctx", POINTER(fd_ctx)), -+ ("xl_count", c_int), -+ ("lk_ctx", POINTER(fd_lk_ctx)), -+ ("anonymous", c_uint) -+ ] -+ -+class loc_t (Structure): -+ _fields_ = [ -+ ("path", c_char_p), -+ ("name", c_char_p), -+ ("inode", POINTER(inode_t)), -+ ("parent", POINTER(inode_t)), -+ ("gfid", c_ubyte * 16), -+ ("pargfid", c_ubyte * 16), -+ ] -+ -+ -+ -+def _init_op (a_class, fop, cbk, wind, unwind): -+ # Decorators, used by translators. We could pass the signatures as -+ # parameters, but it's actually kind of nice to keep them around for -+ # inspection. -+ a_class.fop_type = CFUNCTYPE(*a_class.fop_sig) -+ a_class.cbk_type = CFUNCTYPE(*a_class.cbk_sig) -+ # Dispatch-function registration. -+ fop.restype = None -+ fop.argtypes = [ c_long, a_class.fop_type ] -+ # Callback-function registration. -+ cbk.restype = None -+ cbk.argtypes = [ c_long, a_class.cbk_type ] -+ # STACK_WIND function. -+ wind.restype = None -+ wind.argtypes = list(a_class.fop_sig[1:]) -+ # STACK_UNWIND function. -+ unwind.restype = None -+ unwind.argtypes = list(a_class.cbk_sig[1:]) -+ -+class OpLookup: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(inode_t), POINTER(iatt_t), -+ POINTER(dict_t), POINTER(iatt_t)) -+_init_op (OpLookup, dl.set_lookup_fop, dl.set_lookup_cbk, -+ dl.wind_lookup, dl.unwind_lookup) -+ -+class OpCreate: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), c_int, c_uint, c_uint, POINTER(fd_t), -+ POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(fd_t), POINTER(inode_t), -+ POINTER(iatt_t), POINTER(iatt_t), POINTER(iatt_t), -+ POINTER(dict_t)) -+_init_op (OpCreate, dl.set_create_fop, dl.set_create_cbk, -+ dl.wind_create, dl.unwind_create) -+ -+class OpOpen: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), c_int, POINTER(fd_t), POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(fd_t), POINTER(dict_t)) -+_init_op (OpOpen, dl.set_open_fop, dl.set_open_cbk, -+ dl.wind_open, dl.unwind_open) -+ -+class OpReadv: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(fd_t), c_size_t, c_long, c_uint32, POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(iovec_t), c_int, POINTER(iatt_t), -+ POINTER(iobref_t), POINTER(dict_t)) -+_init_op (OpReadv, dl.set_readv_fop, dl.set_readv_cbk, -+ dl.wind_readv, dl.unwind_readv) -+class OpWritev: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(fd_t), POINTER(iovec_t), c_int, c_long, c_uint32, -+ POINTER(iobref_t), POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(iatt_t), POINTER(iatt_t), -+ POINTER(dict_t)) -+_init_op (OpWritev, dl.set_writev_fop, dl.set_writev_cbk, -+ dl.wind_writev, dl.unwind_writev) -+ -+class OpOpendir: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), POINTER(fd_t), POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(fd_t), POINTER(dict_t)) -+_init_op (OpOpendir, dl.set_opendir_fop, dl.set_opendir_cbk, -+ dl.wind_opendir, dl.unwind_opendir) -+ -+class OpReaddir: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(fd_t), c_size_t, c_long, POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(gf_dirent_t), POINTER(dict_t)) -+_init_op (OpReaddir, dl.set_readdir_fop, dl.set_readdir_cbk, -+ dl.wind_readdir, dl.unwind_readdir) -+ -+class OpReaddirp: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(fd_t), c_size_t, c_long, POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(gf_dirent_t), POINTER(dict_t)) -+_init_op (OpReaddirp, dl.set_readdirp_fop, dl.set_readdirp_cbk, -+ dl.wind_readdirp, dl.unwind_readdirp) -+ -+class OpStat: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(iatt_t), POINTER(dict_t)) -+_init_op (OpStat, dl.set_stat_fop, dl.set_stat_cbk, -+ dl.wind_stat, dl.unwind_stat) -+ -+class OpFstat: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(fd_t), POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(iatt_t), POINTER(dict_t)) -+_init_op (OpFstat, dl.set_fstat_fop, dl.set_fstat_cbk, -+ dl.wind_fstat, dl.unwind_fstat) -+ -+class OpStatfs: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(statvfs_t), POINTER(dict_t)) -+_init_op (OpStatfs, dl.set_statfs_fop, dl.set_statfs_cbk, -+ dl.wind_statfs, dl.unwind_statfs) -+ -+ -+class OpSetxattr: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), POINTER(dict_t), c_int32, -+ POINTER (dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(dict_t)) -+_init_op (OpSetxattr, dl.set_setxattr_fop, dl.set_setxattr_cbk, -+ dl.wind_setxattr, dl.unwind_setxattr) -+ -+class OpGetxattr: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), c_char_p, POINTER (dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(dict_t), POINTER(dict_t)) -+_init_op (OpGetxattr, dl.set_getxattr_fop, dl.set_getxattr_cbk, -+ dl.wind_getxattr, dl.unwind_getxattr) -+ -+class OpFsetxattr: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(fd_t), POINTER(dict_t), c_int32, -+ POINTER (dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(dict_t)) -+_init_op (OpFsetxattr, dl.set_fsetxattr_fop, dl.set_fsetxattr_cbk, -+ dl.wind_fsetxattr, dl.unwind_fsetxattr) -+ -+class OpFgetxattr: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(fd_t), c_char_p, POINTER (dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(dict_t), POINTER(dict_t)) -+_init_op (OpFgetxattr, dl.set_fgetxattr_fop, dl.set_fgetxattr_cbk, -+ dl.wind_fgetxattr, dl.unwind_fgetxattr) -+ -+class OpRemovexattr: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), c_char_p, POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(dict_t)) -+_init_op (OpRemovexattr, dl.set_removexattr_fop, dl.set_removexattr_cbk, -+ dl.wind_removexattr, dl.unwind_removexattr) -+ -+ -+class OpFremovexattr: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(fd_t), c_char_p, POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(dict_t)) -+_init_op (OpFremovexattr, dl.set_fremovexattr_fop, dl.set_fremovexattr_cbk, -+ dl.wind_fremovexattr, dl.unwind_fremovexattr) -+ -+class OpLink: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), POINTER(loc_t), POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(inode_t), POINTER(iatt_t), -+ POINTER(iatt_t), POINTER(iatt_t), POINTER(dict_t)) -+_init_op (OpLink, dl.set_link_fop, dl.set_link_cbk, -+ dl.wind_link, dl.unwind_link) -+ -+class OpSymlink: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ c_char_p, POINTER(loc_t), c_uint, POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(inode_t), POINTER(iatt_t), -+ POINTER(iatt_t), POINTER(iatt_t), POINTER(dict_t)) -+_init_op (OpSymlink, dl.set_symlink_fop, dl.set_symlink_cbk, -+ dl.wind_symlink, dl.unwind_symlink) -+ -+class OpUnlink: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), c_int, POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(iatt_t), POINTER(iatt_t), -+ POINTER(dict_t)) -+_init_op (OpUnlink, dl.set_unlink_fop, dl.set_unlink_cbk, -+ dl.wind_unlink, dl.unwind_unlink) -+ -+class OpReadlink: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), c_size_t, POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, c_char_p, POINTER(iatt_t), POINTER(dict_t)) -+_init_op (OpReadlink, dl.set_readlink_fop, dl.set_readlink_cbk, -+ dl.wind_readlink, dl.unwind_readlink) -+ -+class OpMkdir: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), c_uint, c_uint, POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(inode_t), POINTER(iatt_t), -+ POINTER(iatt_t), POINTER(iatt_t), POINTER(dict_t)) -+_init_op (OpMkdir, dl.set_mkdir_fop, dl.set_mkdir_cbk, -+ dl.wind_mkdir, dl.unwind_mkdir) -+ -+class OpRmdir: -+ fop_sig = (c_int, POINTER(call_frame_t), POINTER(xlator_t), -+ POINTER(loc_t), c_int, POINTER(dict_t)) -+ cbk_sig = (c_int, POINTER(call_frame_t), c_long, POINTER(xlator_t), -+ c_int, c_int, POINTER(iatt_t), POINTER(iatt_t), -+ POINTER(dict_t)) -+_init_op (OpRmdir, dl.set_rmdir_fop, dl.set_rmdir_cbk, -+ dl.wind_rmdir, dl.unwind_rmdir) -+ -+ -+class Translator: -+ def __init__ (self, c_this): -+ # This is only here to keep references to the stubs we create, -+ # because ctypes doesn't and glupy.so can't because it doesn't -+ # get a pointer to the actual Python object. It's a dictionary -+ # instead of a list in case we ever allow changing fops/cbks -+ # after initialization and need to look them up. -+ self.stub_refs = {} -+ funcs = dir(self.__class__) -+ if "lookup_fop" in funcs: -+ @OpLookup.fop_type -+ def stub (frame, this, loc, xdata, s=self): -+ return s.lookup_fop (frame, this, loc, xdata) -+ self.stub_refs["lookup_fop"] = stub -+ dl.set_lookup_fop(c_this, stub) -+ if "lookup_cbk" in funcs: -+ @OpLookup.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, inode, -+ buf, xdata, postparent, s=self): -+ return s.lookup_cbk(frame, cookie, this, op_ret, -+ op_errno, inode, buf, xdata, -+ postparent) -+ self.stub_refs["lookup_cbk"] = stub -+ dl.set_lookup_cbk(c_this, stub) -+ if "create_fop" in funcs: -+ @OpCreate.fop_type -+ def stub (frame, this, loc, flags, mode, umask, fd, -+ xdata, s=self): -+ return s.create_fop (frame, this, loc, flags, -+ mode, umask, fd, xdata) -+ self.stub_refs["create_fop"] = stub -+ dl.set_create_fop(c_this, stub) -+ if "create_cbk" in funcs: -+ @OpCreate.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, fd, -+ inode, buf, preparent, postparent, xdata, -+ s=self): -+ return s.create_cbk (frame, cookie, this, -+ op_ret, op_errno, fd, -+ inode, buf, preparent, -+ postparent, xdata) -+ self.stub_refs["create_cbk"] = stub -+ dl.set_create_cbk(c_this, stub) -+ if "open_fop" in funcs: -+ @OpOpen.fop_type -+ def stub (frame, this, loc, flags, fd, -+ xdata, s=self): -+ return s.open_fop (frame, this, loc, flags, -+ fd, xdata) -+ self.stub_refs["open_fop"] = stub -+ dl.set_open_fop(c_this, stub) -+ if "open_cbk" in funcs: -+ @OpOpen.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, fd, -+ xdata, s=self): -+ return s.open_cbk (frame, cookie, this, -+ op_ret, op_errno, fd, -+ xdata) -+ self.stub_refs["open_cbk"] = stub -+ dl.set_open_cbk(c_this, stub) -+ if "readv_fop" in funcs: -+ @OpReadv.fop_type -+ def stub (frame, this, fd, size, offset, flags, -+ xdata, s=self): -+ return s.readv_fop (frame, this, fd, size, -+ offset, flags, xdata) -+ self.stub_refs["readv_fop"] = stub -+ dl.set_readv_fop(c_this, stub) -+ if "readv_cbk" in funcs: -+ @OpReadv.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ vector, count, stbuf, iobref, xdata, -+ s=self): -+ return s.readv_cbk (frame, cookie, this, -+ op_ret, op_errno, vector, -+ count, stbuf, iobref, -+ xdata) -+ self.stub_refs["readv_cbk"] = stub -+ dl.set_readv_cbk(c_this, stub) -+ if "writev_fop" in funcs: -+ @OpWritev.fop_type -+ def stub (frame, this, fd, vector, count, -+ offset, flags, iobref, xdata, s=self): -+ return s.writev_fop (frame, this, fd, vector, -+ count, offset, flags, -+ iobref, xdata) -+ self.stub_refs["writev_fop"] = stub -+ dl.set_writev_fop(c_this, stub) -+ if "writev_cbk" in funcs: -+ @OpWritev.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ prebuf, postbuf, xdata, s=self): -+ return s.writev_cbk (frame, cookie, this, -+ op_ret, op_errno, prebuf, -+ postbuf, xdata) -+ self.stub_refs["writev_cbk"] = stub -+ dl.set_writev_cbk(c_this, stub) -+ if "opendir_fop" in funcs: -+ @OpOpendir.fop_type -+ def stub (frame, this, loc, fd, xdata, s=self): -+ return s.opendir_fop (frame, this, loc, fd, -+ xdata) -+ self.stub_refs["opendir_fop"] = stub -+ dl.set_opendir_fop(c_this, stub) -+ if "opendir_cbk" in funcs: -+ @OpOpendir.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, fd, -+ xdata, s=self): -+ return s.opendir_cbk(frame, cookie, this, -+ op_ret, op_errno, fd, -+ xdata) -+ self.stub_refs["opendir_cbk"] = stub -+ dl.set_opendir_cbk(c_this, stub) -+ if "readdir_fop" in funcs: -+ @OpReaddir.fop_type -+ def stub (frame, this, fd, size, offset, xdata, s=self): -+ return s.readdir_fop (frame, this, fd, size, -+ offset, xdata) -+ self.stub_refs["readdir_fop"] = stub -+ dl.set_readdir_fop(c_this, stub) -+ if "readdir_cbk" in funcs: -+ @OpReaddir.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ entries, xdata, s=self): -+ return s.readdir_cbk(frame, cookie, this, -+ op_ret, op_errno, entries, -+ xdata) -+ self.stub_refs["readdir_cbk"] = stub -+ dl.set_readdir_cbk(c_this, stub) -+ if "readdirp_fop" in funcs: -+ @OpReaddirp.fop_type -+ def stub (frame, this, fd, size, offset, xdata, s=self): -+ return s.readdirp_fop (frame, this, fd, size, -+ offset, xdata) -+ self.stub_refs["readdirp_fop"] = stub -+ dl.set_readdirp_fop(c_this, stub) -+ if "readdirp_cbk" in funcs: -+ @OpReaddirp.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ entries, xdata, s=self): -+ return s.readdirp_cbk (frame, cookie, this, -+ op_ret, op_errno, -+ entries, xdata) -+ self.stub_refs["readdirp_cbk"] = stub -+ dl.set_readdirp_cbk(c_this, stub) -+ if "stat_fop" in funcs: -+ @OpStat.fop_type -+ def stub (frame, this, loc, xdata, s=self): -+ return s.stat_fop (frame, this, loc, xdata) -+ self.stub_refs["stat_fop"] = stub -+ dl.set_stat_fop(c_this, stub) -+ if "stat_cbk" in funcs: -+ @OpStat.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, buf, -+ xdata, s=self): -+ return s.stat_cbk(frame, cookie, this, op_ret, -+ op_errno, buf, xdata) -+ self.stub_refs["stat_cbk"] = stub -+ dl.set_stat_cbk(c_this, stub) -+ if "fstat_fop" in funcs: -+ @OpFstat.fop_type -+ def stub (frame, this, fd, xdata, s=self): -+ return s.fstat_fop (frame, this, fd, xdata) -+ self.stub_refs["fstat_fop"] = stub -+ dl.set_fstat_fop(c_this, stub) -+ if "fstat_cbk" in funcs: -+ @OpFstat.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, buf, -+ xdata, s=self): -+ return s.fstat_cbk(frame, cookie, this, op_ret, -+ op_errno, buf, xdata) -+ self.stub_refs["fstat_cbk"] = stub -+ dl.set_fstat_cbk(c_this, stub) -+ if "statfs_fop" in funcs: -+ @OpStatfs.fop_type -+ def stub (frame, this, loc, xdata, s=self): -+ return s.statfs_fop (frame, this, loc, xdata) -+ self.stub_refs["statfs_fop"] = stub -+ dl.set_statfs_fop(c_this, stub) -+ if "statfs_cbk" in funcs: -+ @OpStatfs.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, buf, -+ xdata, s=self): -+ return s.statfs_cbk (frame, cookie, this, -+ op_ret, op_errno, buf, -+ xdata) -+ self.stub_refs["statfs_cbk"] = stub -+ dl.set_statfs_cbk(c_this, stub) -+ if "setxattr_fop" in funcs: -+ @OpSetxattr.fop_type -+ def stub (frame, this, loc, dictionary, flags, xdata, -+ s=self): -+ return s.setxattr_fop (frame, this, loc, -+ dictionary, flags, -+ xdata) -+ self.stub_refs["setxattr_fop"] = stub -+ dl.set_setxattr_fop(c_this, stub) -+ if "setxattr_cbk" in funcs: -+ @OpSetxattr.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, xdata, -+ s=self): -+ return s.setxattr_cbk(frame, cookie, this, -+ op_ret, op_errno, xdata) -+ self.stub_refs["setxattr_cbk"] = stub -+ dl.set_setxattr_cbk(c_this, stub) -+ if "getxattr_fop" in funcs: -+ @OpGetxattr.fop_type -+ def stub (frame, this, loc, name, xdata, s=self): -+ return s.getxattr_fop (frame, this, loc, name, -+ xdata) -+ self.stub_refs["getxattr_fop"] = stub -+ dl.set_getxattr_fop(c_this, stub) -+ if "getxattr_cbk" in funcs: -+ @OpGetxattr.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ dictionary, xdata, s=self): -+ return s.getxattr_cbk(frame, cookie, this, -+ op_ret, op_errno, -+ dictionary, xdata) -+ self.stub_refs["getxattr_cbk"] = stub -+ dl.set_getxattr_cbk(c_this, stub) -+ if "fsetxattr_fop" in funcs: -+ @OpFsetxattr.fop_type -+ def stub (frame, this, fd, dictionary, flags, xdata, -+ s=self): -+ return s.fsetxattr_fop (frame, this, fd, -+ dictionary, flags, -+ xdata) -+ self.stub_refs["fsetxattr_fop"] = stub -+ dl.set_fsetxattr_fop(c_this, stub) -+ if "fsetxattr_cbk" in funcs: -+ @OpFsetxattr.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, xdata, -+ s=self): -+ return s.fsetxattr_cbk(frame, cookie, this, -+ op_ret, op_errno, xdata) -+ self.stub_refs["fsetxattr_cbk"] = stub -+ dl.set_fsetxattr_cbk(c_this, stub) -+ if "fgetxattr_fop" in funcs: -+ @OpFgetxattr.fop_type -+ def stub (frame, this, fd, name, xdata, s=self): -+ return s.fgetxattr_fop (frame, this, fd, name, -+ xdata) -+ self.stub_refs["fgetxattr_fop"] = stub -+ dl.set_fgetxattr_fop(c_this, stub) -+ if "fgetxattr_cbk" in funcs: -+ @OpFgetxattr.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ dictionary, xdata, s=self): -+ return s.fgetxattr_cbk(frame, cookie, this, -+ op_ret, op_errno, -+ dictionary, xdata) -+ self.stub_refs["fgetxattr_cbk"] = stub -+ dl.set_fgetxattr_cbk(c_this, stub) -+ if "removexattr_fop" in funcs: -+ @OpRemovexattr.fop_type -+ def stub (frame, this, loc, name, xdata, s=self): -+ return s.removexattr_fop (frame, this, loc, -+ name, xdata) -+ self.stub_refs["removexattr_fop"] = stub -+ dl.set_removexattr_fop(c_this, stub) -+ if "removexattr_cbk" in funcs: -+ @OpRemovexattr.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ xdata, s=self): -+ return s.removexattr_cbk(frame, cookie, this, -+ op_ret, op_errno, -+ xdata) -+ self.stub_refs["removexattr_cbk"] = stub -+ dl.set_removexattr_cbk(c_this, stub) -+ if "fremovexattr_fop" in funcs: -+ @OpFremovexattr.fop_type -+ def stub (frame, this, fd, name, xdata, s=self): -+ return s.fremovexattr_fop (frame, this, fd, -+ name, xdata) -+ self.stub_refs["fremovexattr_fop"] = stub -+ dl.set_fremovexattr_fop(c_this, stub) -+ if "fremovexattr_cbk" in funcs: -+ @OpFremovexattr.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ xdata, s=self): -+ return s.fremovexattr_cbk(frame, cookie, this, -+ op_ret, op_errno, -+ xdata) -+ self.stub_refs["fremovexattr_cbk"] = stub -+ dl.set_fremovexattr_cbk(c_this, stub) -+ if "link_fop" in funcs: -+ @OpLink.fop_type -+ def stub (frame, this, oldloc, newloc, -+ xdata, s=self): -+ return s.link_fop (frame, this, oldloc, -+ newloc, xdata) -+ self.stub_refs["link_fop"] = stub -+ dl.set_link_fop(c_this, stub) -+ if "link_cbk" in funcs: -+ @OpLink.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ inode, buf, preparent, postparent, xdata, -+ s=self): -+ return s.link_cbk (frame, cookie, this, -+ op_ret, op_errno, inode, -+ buf, preparent, -+ postparent, xdata) -+ self.stub_refs["link_cbk"] = stub -+ dl.set_link_cbk(c_this, stub) -+ if "symlink_fop" in funcs: -+ @OpSymlink.fop_type -+ def stub (frame, this, linkname, loc, -+ umask, xdata, s=self): -+ return s.symlink_fop (frame, this, linkname, -+ loc, umask, xdata) -+ self.stub_refs["symlink_fop"] = stub -+ dl.set_symlink_fop(c_this, stub) -+ if "symlink_cbk" in funcs: -+ @OpSymlink.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ inode, buf, preparent, postparent, xdata, -+ s=self): -+ return s.symlink_cbk (frame, cookie, this, -+ op_ret, op_errno, inode, -+ buf, preparent, -+ postparent, xdata) -+ self.stub_refs["symlink_cbk"] = stub -+ dl.set_symlink_cbk(c_this, stub) -+ if "unlink_fop" in funcs: -+ @OpUnlink.fop_type -+ def stub (frame, this, loc, xflags, -+ xdata, s=self): -+ return s.unlink_fop (frame, this, loc, -+ xflags, xdata) -+ self.stub_refs["unlink_fop"] = stub -+ dl.set_unlink_fop(c_this, stub) -+ if "unlink_cbk" in funcs: -+ @OpUnlink.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ preparent, postparent, xdata, s=self): -+ return s.unlink_cbk (frame, cookie, this, -+ op_ret, op_errno, -+ preparent, postparent, -+ xdata) -+ self.stub_refs["unlink_cbk"] = stub -+ dl.set_unlink_cbk(c_this, stub) -+ if "readlink_fop" in funcs: -+ @OpReadlink.fop_type -+ def stub (frame, this, loc, size, -+ xdata, s=self): -+ return s.readlink_fop (frame, this, loc, -+ size, xdata) -+ self.stub_refs["readlink_fop"] = stub -+ dl.set_readlink_fop(c_this, stub) -+ if "readlink_cbk" in funcs: -+ @OpReadlink.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ path, buf, xdata, s=self): -+ return s.readlink_cbk (frame, cookie, this, -+ op_ret, op_errno, -+ path, buf, xdata) -+ self.stub_refs["readlink_cbk"] = stub -+ dl.set_readlink_cbk(c_this, stub) -+ if "mkdir_fop" in funcs: -+ @OpMkdir.fop_type -+ def stub (frame, this, loc, mode, umask, xdata, -+ s=self): -+ return s.mkdir_fop (frame, this, loc, mode, -+ umask, xdata) -+ self.stub_refs["mkdir_fop"] = stub -+ dl.set_mkdir_fop(c_this, stub) -+ if "mkdir_cbk" in funcs: -+ @OpMkdir.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, inode, -+ buf, preparent, postparent, xdata, s=self): -+ return s.mkdir_cbk (frame, cookie, this, -+ op_ret, op_errno, inode, -+ buf, preparent, -+ postparent, xdata) -+ self.stub_refs["mkdir_cbk"] = stub -+ dl.set_mkdir_cbk(c_this, stub) -+ if "rmdir_fop" in funcs: -+ @OpRmdir.fop_type -+ def stub (frame, this, loc, xflags, -+ xdata, s=self): -+ return s.rmdir_fop (frame, this, loc, -+ xflags, xdata) -+ self.stub_refs["rmdir_fop"] = stub -+ dl.set_rmdir_fop(c_this, stub) -+ if "rmdir_cbk" in funcs: -+ @OpRmdir.cbk_type -+ def stub (frame, cookie, this, op_ret, op_errno, -+ preparent, postparent, xdata, s=self): -+ return s.rmdir_cbk (frame, cookie, this, -+ op_ret, op_errno, -+ preparent, postparent, -+ xdata) -+ self.stub_refs["rmdir_cbk"] = stub -+ dl.set_rmdir_cbk(c_this, stub) ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/src/glupy/Makefile.in 2019-07-06 08:50:37.174969610 -0400 -@@ -0,0 +1,625 @@ -+# Makefile.in generated by automake 1.13.4 from Makefile.am. -+# @configure_input@ -+ -+# Copyright (C) 1994-2013 Free Software Foundation, Inc. -+ -+# This Makefile.in is free software; the Free Software Foundation -+# gives unlimited permission to copy and/or distribute it, -+# with or without modifications, as long as this notice is preserved. -+ -+# This program is distributed in the hope that it will be useful, -+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without -+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A -+# PARTICULAR PURPOSE. -+ -+@SET_MAKE@ -+VPATH = @srcdir@ -+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' -+am__make_running_with_option = \ -+ case $${target_option-} in \ -+ ?) ;; \ -+ *) echo "am__make_running_with_option: internal error: invalid" \ -+ "target option '$${target_option-}' specified" >&2; \ -+ exit 1;; \ -+ esac; \ -+ has_opt=no; \ -+ sane_makeflags=$$MAKEFLAGS; \ -+ if $(am__is_gnu_make); then \ -+ sane_makeflags=$$MFLAGS; \ -+ else \ -+ case $$MAKEFLAGS in \ -+ *\\[\ \ ]*) \ -+ bs=\\; \ -+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ -+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ -+ esac; \ -+ fi; \ -+ skip_next=no; \ -+ strip_trailopt () \ -+ { \ -+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ -+ }; \ -+ for flg in $$sane_makeflags; do \ -+ test $$skip_next = yes && { skip_next=no; continue; }; \ -+ case $$flg in \ -+ *=*|--*) continue;; \ -+ -*I) strip_trailopt 'I'; skip_next=yes;; \ -+ -*I?*) strip_trailopt 'I';; \ -+ -*O) strip_trailopt 'O'; skip_next=yes;; \ -+ -*O?*) strip_trailopt 'O';; \ -+ -*l) strip_trailopt 'l'; skip_next=yes;; \ -+ -*l?*) strip_trailopt 'l';; \ -+ -[dEDm]) skip_next=yes;; \ -+ -[JT]) skip_next=yes;; \ -+ esac; \ -+ case $$flg in \ -+ *$$target_option*) has_opt=yes; break;; \ -+ esac; \ -+ done; \ -+ test $$has_opt = yes -+am__make_dryrun = (target_option=n; $(am__make_running_with_option)) -+am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) -+pkgdatadir = $(datadir)/@PACKAGE@ -+pkgincludedir = $(includedir)/@PACKAGE@ -+pkglibdir = $(libdir)/@PACKAGE@ -+pkglibexecdir = $(libexecdir)/@PACKAGE@ -+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd -+install_sh_DATA = $(install_sh) -c -m 644 -+install_sh_PROGRAM = $(install_sh) -c -+install_sh_SCRIPT = $(install_sh) -c -+INSTALL_HEADER = $(INSTALL_DATA) -+transform = $(program_transform_name) -+NORMAL_INSTALL = : -+PRE_INSTALL = : -+POST_INSTALL = : -+NORMAL_UNINSTALL = : -+PRE_UNINSTALL = : -+POST_UNINSTALL = : -+build_triplet = @build@ -+host_triplet = @host@ -+subdir = xlators/features/glupy/src/glupy -+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ -+ $(pyglupy_PYTHON) $(top_srcdir)/py-compile -+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 -+am__aclocal_m4_deps = $(top_srcdir)/contrib/aclocal/mkdirp.m4 \ -+ $(top_srcdir)/contrib/aclocal/python.m4 \ -+ $(top_srcdir)/configure.ac -+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ -+ $(ACLOCAL_M4) -+mkinstalldirs = $(install_sh) -d -+CONFIG_HEADER = $(top_builddir)/config.h $(top_builddir)/site.h -+CONFIG_CLEAN_FILES = -+CONFIG_CLEAN_VPATH_FILES = -+AM_V_P = $(am__v_P_@AM_V@) -+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) -+am__v_P_0 = false -+am__v_P_1 = : -+AM_V_GEN = $(am__v_GEN_@AM_V@) -+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) -+am__v_GEN_0 = @echo " GEN " $@; -+am__v_GEN_1 = -+AM_V_at = $(am__v_at_@AM_V@) -+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) -+am__v_at_0 = @ -+am__v_at_1 = -+SOURCES = -+DIST_SOURCES = -+am__can_run_installinfo = \ -+ case $$AM_UPDATE_INFO_DIR in \ -+ n|no|NO) false;; \ -+ *) (install-info --version) >/dev/null 2>&1;; \ -+ esac -+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; -+am__vpath_adj = case $$p in \ -+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ -+ *) f=$$p;; \ -+ esac; -+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; -+am__install_max = 40 -+am__nobase_strip_setup = \ -+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` -+am__nobase_strip = \ -+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" -+am__nobase_list = $(am__nobase_strip_setup); \ -+ for p in $$list; do echo "$$p $$p"; done | \ -+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ -+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ -+ if (++n[$$2] == $(am__install_max)) \ -+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ -+ END { for (dir in files) print dir, files[dir] }' -+am__base_list = \ -+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ -+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' -+am__uninstall_files_from_dir = { \ -+ test -z "$$files" \ -+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ -+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ -+ $(am__cd) "$$dir" && rm -f $$files; }; \ -+ } -+am__py_compile = PYTHON=$(PYTHON) $(SHELL) $(py_compile) -+am__installdirs = "$(DESTDIR)$(pyglupydir)" -+am__pep3147_tweak = \ -+ sed -e 's|\.py$$||' -e 's|[^/]*$$|__pycache__/&.*.py|' -+py_compile = $(top_srcdir)/py-compile -+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) -+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) -+ACLOCAL = @ACLOCAL@ -+ACL_LIBS = @ACL_LIBS@ -+AMTAR = @AMTAR@ -+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ -+AM_LIBTOOLFLAGS = @AM_LIBTOOLFLAGS@ -+AM_MAKEFLAGS = @AM_MAKEFLAGS@ -+AR = @AR@ -+ARGP_LDADD = @ARGP_LDADD@ -+AUTOCONF = @AUTOCONF@ -+AUTOHEADER = @AUTOHEADER@ -+AUTOMAKE = @AUTOMAKE@ -+AWK = @AWK@ -+BUILD_PYTHON_SITE_PACKAGES = @BUILD_PYTHON_SITE_PACKAGES@ -+BUILD_PYTHON_SITE_PACKAGES_EXPANDED = @BUILD_PYTHON_SITE_PACKAGES_EXPANDED@ -+CC = @CC@ -+CCDEPMODE = @CCDEPMODE@ -+CFLAGS = @CFLAGS@ -+CONTRIBDIR = @CONTRIBDIR@ -+CPP = @CPP@ -+CPPFLAGS = @CPPFLAGS@ -+CYGPATH_W = @CYGPATH_W@ -+DEFS = @DEFS@ -+DEPDIR = @DEPDIR@ -+DLLTOOL = @DLLTOOL@ -+DSYMUTIL = @DSYMUTIL@ -+DUMPBIN = @DUMPBIN@ -+ECHO_C = @ECHO_C@ -+ECHO_N = @ECHO_N@ -+ECHO_T = @ECHO_T@ -+EGREP = @EGREP@ -+EVENTS_ENABLED = @EVENTS_ENABLED@ -+EVENTS_SUBDIR = @EVENTS_SUBDIR@ -+EXEEXT = @EXEEXT@ -+FGREP = @FGREP@ -+FUSERMOUNT_SUBDIR = @FUSERMOUNT_SUBDIR@ -+FUSE_CLIENT_SUBDIR = @FUSE_CLIENT_SUBDIR@ -+GEOREP_EXTRAS_SUBDIR = @GEOREP_EXTRAS_SUBDIR@ -+GFAPI_EXTRA_LDFLAGS = @GFAPI_EXTRA_LDFLAGS@ -+GFAPI_LIBS = @GFAPI_LIBS@ -+GFAPI_LT_VERSION = @GFAPI_LT_VERSION@ -+GFAPI_VERSION = @GFAPI_VERSION@ -+GF_CFLAGS = @GF_CFLAGS@ -+GF_CPPFLAGS = @GF_CPPFLAGS@ -+GF_DISTRIBUTION = @GF_DISTRIBUTION@ -+GF_FUSE_CFLAGS = @GF_FUSE_CFLAGS@ -+GF_FUSE_LDADD = @GF_FUSE_LDADD@ -+GF_HOST_OS = @GF_HOST_OS@ -+GF_LDADD = @GF_LDADD@ -+GF_LDFLAGS = @GF_LDFLAGS@ -+GF_NO_UNDEFINED = @GF_NO_UNDEFINED@ -+GF_XLATOR_DEFAULT_LDFLAGS = @GF_XLATOR_DEFAULT_LDFLAGS@ -+GF_XLATOR_LDFLAGS = @GF_XLATOR_LDFLAGS@ -+GLUPY_SUBDIR = @GLUPY_SUBDIR@ -+GLUPY_SUBDIR_MAKEFILE = @GLUPY_SUBDIR_MAKEFILE@ -+GLUPY_SUBDIR_SRC_MAKEFILE = @GLUPY_SUBDIR_SRC_MAKEFILE@ -+GLUSTERD_VOLFILE = @GLUSTERD_VOLFILE@ -+GLUSTERD_WORKDIR = @GLUSTERD_WORKDIR@ -+GLUSTERFSD_MISCDIR = @GLUSTERFSD_MISCDIR@ -+GLUSTERFS_LIBEXECDIR = @GLUSTERFS_LIBEXECDIR@ -+GREP = @GREP@ -+HAVE_ATOMIC_BUILTINS = @HAVE_ATOMIC_BUILTINS@ -+HAVE_BACKTRACE = @HAVE_BACKTRACE@ -+HAVE_LINKAT = @HAVE_LINKAT@ -+HAVE_MALLOC_STATS = @HAVE_MALLOC_STATS@ -+HAVE_SPINLOCK = @HAVE_SPINLOCK@ -+HAVE_STRNLEN = @HAVE_STRNLEN@ -+HAVE_SYNC_BUILTINS = @HAVE_SYNC_BUILTINS@ -+IBVERBS_SUBDIR = @IBVERBS_SUBDIR@ -+INSTALL = @INSTALL@ -+INSTALL_DATA = @INSTALL_DATA@ -+INSTALL_PROGRAM = @INSTALL_PROGRAM@ -+INSTALL_SCRIPT = @INSTALL_SCRIPT@ -+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ -+LD = @LD@ -+LDFLAGS = @LDFLAGS@ -+LEX = @LEX@ -+LEXLIB = @LEXLIB@ -+LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ -+LIBAIO = @LIBAIO@ -+LIBGFCHANGELOG_LT_VERSION = @LIBGFCHANGELOG_LT_VERSION@ -+LIBGFCHANGELOG_VERSION = @LIBGFCHANGELOG_VERSION@ -+LIBGFDB_VERSION = @LIBGFDB_VERSION@ -+LIBGFRPC_LT_VERSION = @LIBGFRPC_LT_VERSION@ -+LIBGFXDR_LT_VERSION = @LIBGFXDR_LT_VERSION@ -+LIBGLUSTERFS_LT_VERSION = @LIBGLUSTERFS_LT_VERSION@ -+LIBOBJS = @LIBOBJS@ -+LIBS = @LIBS@ -+LIBTOOL = @LIBTOOL@ -+LIB_DL = @LIB_DL@ -+LIPO = @LIPO@ -+LN_S = @LN_S@ -+LTLIBOBJS = @LTLIBOBJS@ -+MAKEINFO = @MAKEINFO@ -+MANIFEST_TOOL = @MANIFEST_TOOL@ -+MATH_LIB = @MATH_LIB@ -+MKDIR_P = @MKDIR_P@ -+NM = @NM@ -+NMEDIT = @NMEDIT@ -+OBJDUMP = @OBJDUMP@ -+OBJEXT = @OBJEXT@ -+OCF_SUBDIR = @OCF_SUBDIR@ -+OTOOL = @OTOOL@ -+OTOOL64 = @OTOOL64@ -+PACKAGE = @PACKAGE@ -+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ -+PACKAGE_NAME = @PACKAGE_NAME@ -+PACKAGE_RELEASE = @PACKAGE_RELEASE@ -+PACKAGE_STRING = @PACKAGE_STRING@ -+PACKAGE_TARNAME = @PACKAGE_TARNAME@ -+PACKAGE_URL = @PACKAGE_URL@ -+PACKAGE_VERSION = @PACKAGE_VERSION@ -+PATH_SEPARATOR = @PATH_SEPARATOR@ -+PKGCONFIG_UUID = @PKGCONFIG_UUID@ -+PKG_CONFIG = @PKG_CONFIG@ -+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ -+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ -+PYTHON = @PYTHON@ -+PYTHON_CFLAGS = @PYTHON_CFLAGS@ -+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ -+PYTHON_LIBS = @PYTHON_LIBS@ -+PYTHON_PLATFORM = @PYTHON_PLATFORM@ -+PYTHON_PREFIX = @PYTHON_PREFIX@ -+PYTHON_VERSION = @PYTHON_VERSION@ -+RANLIB = @RANLIB@ -+RDMA_SUBDIR = @RDMA_SUBDIR@ -+RLLIBS = @RLLIBS@ -+RPCGEN = @RPCGEN@ -+SBIN_DIR = @SBIN_DIR@ -+SED = @SED@ -+SET_MAKE = @SET_MAKE@ -+SHELL = @SHELL@ -+SIZEOF_INT = @SIZEOF_INT@ -+SIZEOF_LONG = @SIZEOF_LONG@ -+SIZEOF_LONG_LONG = @SIZEOF_LONG_LONG@ -+SIZEOF_SHORT = @SIZEOF_SHORT@ -+SQLITE_CFLAGS = @SQLITE_CFLAGS@ -+SQLITE_LIBS = @SQLITE_LIBS@ -+STRIP = @STRIP@ -+SYNCDAEMON_COMPILE = @SYNCDAEMON_COMPILE@ -+SYNCDAEMON_SUBDIR = @SYNCDAEMON_SUBDIR@ -+SYSCONF_DIR = @SYSCONF_DIR@ -+TIRPC_CFLAGS = @TIRPC_CFLAGS@ -+TIRPC_LIBS = @TIRPC_LIBS@ -+UMOUNTD_SUBDIR = @UMOUNTD_SUBDIR@ -+UNITTEST_CFLAGS = @UNITTEST_CFLAGS@ -+UNITTEST_LDFLAGS = @UNITTEST_LDFLAGS@ -+UNITTEST_LIBS = @UNITTEST_LIBS@ -+URCU_CDS_CFLAGS = @URCU_CDS_CFLAGS@ -+URCU_CDS_LIBS = @URCU_CDS_LIBS@ -+URCU_CFLAGS = @URCU_CFLAGS@ -+URCU_LIBS = @URCU_LIBS@ -+USE_EC_DYNAMIC_AVX = @USE_EC_DYNAMIC_AVX@ -+USE_EC_DYNAMIC_NEON = @USE_EC_DYNAMIC_NEON@ -+USE_EC_DYNAMIC_SSE = @USE_EC_DYNAMIC_SSE@ -+USE_EC_DYNAMIC_X64 = @USE_EC_DYNAMIC_X64@ -+USE_POSIX_ACLS = @USE_POSIX_ACLS@ -+UUID_CFLAGS = @UUID_CFLAGS@ -+UUID_LIBS = @UUID_LIBS@ -+VERSION = @VERSION@ -+XML_CFLAGS = @XML_CFLAGS@ -+XML_LIBS = @XML_LIBS@ -+YACC = @YACC@ -+YFLAGS = @YFLAGS@ -+ZLIB_CFLAGS = @ZLIB_CFLAGS@ -+ZLIB_LIBS = @ZLIB_LIBS@ -+abs_builddir = @abs_builddir@ -+abs_srcdir = @abs_srcdir@ -+abs_top_builddir = @abs_top_builddir@ -+abs_top_srcdir = @abs_top_srcdir@ -+ac_ct_AR = @ac_ct_AR@ -+ac_ct_CC = @ac_ct_CC@ -+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ -+am__include = @am__include@ -+am__leading_dot = @am__leading_dot@ -+am__quote = @am__quote@ -+am__tar = @am__tar@ -+am__untar = @am__untar@ -+bindir = @bindir@ -+build = @build@ -+build_alias = @build_alias@ -+build_cpu = @build_cpu@ -+build_os = @build_os@ -+build_vendor = @build_vendor@ -+builddir = @builddir@ -+datadir = @datadir@ -+datarootdir = @datarootdir@ -+docdir = @docdir@ -+dvidir = @dvidir@ -+exec_prefix = @exec_prefix@ -+host = @host@ -+host_alias = @host_alias@ -+host_cpu = @host_cpu@ -+host_os = @host_os@ -+host_vendor = @host_vendor@ -+htmldir = @htmldir@ -+includedir = @includedir@ -+infodir = @infodir@ -+initdir = @initdir@ -+install_sh = @install_sh@ -+launchddir = @launchddir@ -+libdir = @libdir@ -+libexecdir = @libexecdir@ -+localedir = @localedir@ -+localstatedir = @localstatedir@ -+mandir = @mandir@ -+mkdir_p = @mkdir_p@ -+mountutildir = @mountutildir@ -+oldincludedir = @oldincludedir@ -+pdfdir = @pdfdir@ -+pkgconfigdir = @pkgconfigdir@ -+pkgpyexecdir = @pkgpyexecdir@ -+pkgpythondir = @pkgpythondir@ -+prefix = @prefix@ -+program_transform_name = @program_transform_name@ -+psdir = @psdir@ -+pyexecdir = @pyexecdir@ -+pythondir = @pythondir@ -+sbindir = @sbindir@ -+sharedstatedir = @sharedstatedir@ -+shrext_cmds = @shrext_cmds@ -+srcdir = @srcdir@ -+sysconfdir = @sysconfdir@ -+systemddir = @systemddir@ -+target_alias = @target_alias@ -+tmpfilesdir = @tmpfilesdir@ -+top_build_prefix = @top_build_prefix@ -+top_builddir = @top_builddir@ -+top_srcdir = @top_srcdir@ -+ -+# Install __init__.py into the Python site-packages area -+pyglupydir = @BUILD_PYTHON_SITE_PACKAGES@/gluster/glupy -+pyglupy_PYTHON = __init__.py -+CLEANFILES = -+all: all-am -+ -+.SUFFIXES: -+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) -+ @for dep in $?; do \ -+ case '$(am__configure_deps)' in \ -+ *$$dep*) \ -+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ -+ && { if test -f $@; then exit 0; else break; fi; }; \ -+ exit 1;; \ -+ esac; \ -+ done; \ -+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign xlators/features/glupy/src/glupy/Makefile'; \ -+ $(am__cd) $(top_srcdir) && \ -+ $(AUTOMAKE) --foreign xlators/features/glupy/src/glupy/Makefile -+.PRECIOUS: Makefile -+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status -+ @case '$?' in \ -+ *config.status*) \ -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ -+ *) \ -+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ -+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ -+ esac; -+ -+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+ -+$(top_srcdir)/configure: $(am__configure_deps) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+$(ACLOCAL_M4): $(am__aclocal_m4_deps) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+$(am__aclocal_m4_deps): -+ -+mostlyclean-libtool: -+ -rm -f *.lo -+ -+clean-libtool: -+ -rm -rf .libs _libs -+install-pyglupyPYTHON: $(pyglupy_PYTHON) -+ @$(NORMAL_INSTALL) -+ @list='$(pyglupy_PYTHON)'; dlist=; list2=; test -n "$(pyglupydir)" || list=; \ -+ if test -n "$$list"; then \ -+ echo " $(MKDIR_P) '$(DESTDIR)$(pyglupydir)'"; \ -+ $(MKDIR_P) "$(DESTDIR)$(pyglupydir)" || exit 1; \ -+ fi; \ -+ for p in $$list; do \ -+ if test -f "$$p"; then b=; else b="$(srcdir)/"; fi; \ -+ if test -f $$b$$p; then \ -+ $(am__strip_dir) \ -+ dlist="$$dlist $$f"; \ -+ list2="$$list2 $$b$$p"; \ -+ else :; fi; \ -+ done; \ -+ for file in $$list2; do echo $$file; done | $(am__base_list) | \ -+ while read files; do \ -+ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pyglupydir)'"; \ -+ $(INSTALL_DATA) $$files "$(DESTDIR)$(pyglupydir)" || exit $$?; \ -+ done || exit $$?; \ -+ if test -n "$$dlist"; then \ -+ $(am__py_compile) --destdir "$(DESTDIR)" \ -+ --basedir "$(pyglupydir)" $$dlist; \ -+ else :; fi -+ -+uninstall-pyglupyPYTHON: -+ @$(NORMAL_UNINSTALL) -+ @list='$(pyglupy_PYTHON)'; test -n "$(pyglupydir)" || list=; \ -+ py_files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ -+ test -n "$$py_files" || exit 0; \ -+ dir='$(DESTDIR)$(pyglupydir)'; \ -+ pyc_files=`echo "$$py_files" | sed 's|$$|c|'`; \ -+ pyo_files=`echo "$$py_files" | sed 's|$$|o|'`; \ -+ py_files_pep3147=`echo "$$py_files" | $(am__pep3147_tweak)`; \ -+ echo "$$py_files_pep3147";\ -+ pyc_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|c|'`; \ -+ pyo_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|o|'`; \ -+ st=0; \ -+ for files in \ -+ "$$py_files" \ -+ "$$pyc_files" \ -+ "$$pyo_files" \ -+ "$$pyc_files_pep3147" \ -+ "$$pyo_files_pep3147" \ -+ ; do \ -+ $(am__uninstall_files_from_dir) || st=$$?; \ -+ done; \ -+ exit $$st -+tags TAGS: -+ -+ctags CTAGS: -+ -+cscope cscopelist: -+ -+ -+distdir: $(DISTFILES) -+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ -+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ -+ list='$(DISTFILES)'; \ -+ dist_files=`for file in $$list; do echo $$file; done | \ -+ sed -e "s|^$$srcdirstrip/||;t" \ -+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ -+ case $$dist_files in \ -+ */*) $(MKDIR_P) `echo "$$dist_files" | \ -+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ -+ sort -u` ;; \ -+ esac; \ -+ for file in $$dist_files; do \ -+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ -+ if test -d $$d/$$file; then \ -+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ -+ if test -d "$(distdir)/$$file"; then \ -+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ -+ fi; \ -+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ -+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ -+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ -+ fi; \ -+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ -+ else \ -+ test -f "$(distdir)/$$file" \ -+ || cp -p $$d/$$file "$(distdir)/$$file" \ -+ || exit 1; \ -+ fi; \ -+ done -+check-am: all-am -+check: check-am -+all-am: Makefile -+installdirs: -+ for dir in "$(DESTDIR)$(pyglupydir)"; do \ -+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ -+ done -+install: install-am -+install-exec: install-exec-am -+install-data: install-data-am -+uninstall: uninstall-am -+ -+install-am: all-am -+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am -+ -+installcheck: installcheck-am -+install-strip: -+ if test -z '$(STRIP)'; then \ -+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ -+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ -+ install; \ -+ else \ -+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ -+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ -+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ -+ fi -+mostlyclean-generic: -+ -+clean-generic: -+ -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) -+ -+distclean-generic: -+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) -+ -+maintainer-clean-generic: -+ @echo "This command is intended for maintainers to use" -+ @echo "it deletes files that may require special tools to rebuild." -+clean: clean-am -+ -+clean-am: clean-generic clean-libtool mostlyclean-am -+ -+distclean: distclean-am -+ -rm -f Makefile -+distclean-am: clean-am distclean-generic -+ -+dvi: dvi-am -+ -+dvi-am: -+ -+html: html-am -+ -+html-am: -+ -+info: info-am -+ -+info-am: -+ -+install-data-am: install-pyglupyPYTHON -+ -+install-dvi: install-dvi-am -+ -+install-dvi-am: -+ -+install-exec-am: -+ -+install-html: install-html-am -+ -+install-html-am: -+ -+install-info: install-info-am -+ -+install-info-am: -+ -+install-man: -+ -+install-pdf: install-pdf-am -+ -+install-pdf-am: -+ -+install-ps: install-ps-am -+ -+install-ps-am: -+ -+installcheck-am: -+ -+maintainer-clean: maintainer-clean-am -+ -rm -f Makefile -+maintainer-clean-am: distclean-am maintainer-clean-generic -+ -+mostlyclean: mostlyclean-am -+ -+mostlyclean-am: mostlyclean-generic mostlyclean-libtool -+ -+pdf: pdf-am -+ -+pdf-am: -+ -+ps: ps-am -+ -+ps-am: -+ -+uninstall-am: uninstall-pyglupyPYTHON -+ -+.MAKE: install-am install-strip -+ -+.PHONY: all all-am check check-am clean clean-generic clean-libtool \ -+ cscopelist-am ctags-am distclean distclean-generic \ -+ distclean-libtool distdir dvi dvi-am html html-am info info-am \ -+ install install-am install-data install-data-am install-dvi \ -+ install-dvi-am install-exec install-exec-am install-html \ -+ install-html-am install-info install-info-am install-man \ -+ install-pdf install-pdf-am install-ps install-ps-am \ -+ install-pyglupyPYTHON install-strip installcheck \ -+ installcheck-am installdirs maintainer-clean \ -+ maintainer-clean-generic mostlyclean mostlyclean-generic \ -+ mostlyclean-libtool pdf pdf-am ps ps-am tags-am uninstall \ -+ uninstall-am uninstall-pyglupyPYTHON -+ -+ -+# Tell versions [3.59,3.63) of GNU make to not export all variables. -+# Otherwise a system limit (for SysV at least) may be exceeded. -+.NOEXPORT: ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/src/setup.py.in 2019-07-06 08:49:31.000000000 -0400 -@@ -0,0 +1,24 @@ -+from distutils.core import setup -+ -+DESC = """GlusterFS is a distributed file-system capable of scaling to -+several petabytes. It aggregates various storage bricks over Infiniband -+RDMA or TCP/IP interconnect into one large parallel network file system. -+GlusterFS is one of the most sophisticated file systems in terms of -+features and extensibility. It borrows a powerful concept called -+Translators from GNU Hurd kernel. Much of the code in GlusterFS is in -+user space and easily manageable. -+ -+This package contains Glupy, the Python translator interface for GlusterFS.""" -+ -+setup( -+ name='glusterfs-glupy', -+ version='@PACKAGE_VERSION@', -+ description='Glupy is the Python translator interface for GlusterFS', -+ long_description=DESC, -+ author='Gluster Community', -+ author_email='gluster-devel@gluster.org', -+ license='LGPLv3', -+ url='http://gluster.org/', -+ package_dir={'gluster':''}, -+ packages=['gluster'] -+) ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/src/Makefile.in 2019-07-06 08:50:37.092967963 -0400 -@@ -0,0 +1,954 @@ -+# Makefile.in generated by automake 1.13.4 from Makefile.am. -+# @configure_input@ -+ -+# Copyright (C) 1994-2013 Free Software Foundation, Inc. -+ -+# This Makefile.in is free software; the Free Software Foundation -+# gives unlimited permission to copy and/or distribute it, -+# with or without modifications, as long as this notice is preserved. -+ -+# This program is distributed in the hope that it will be useful, -+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without -+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A -+# PARTICULAR PURPOSE. -+ -+@SET_MAKE@ -+ -+ -+VPATH = @srcdir@ -+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' -+am__make_running_with_option = \ -+ case $${target_option-} in \ -+ ?) ;; \ -+ *) echo "am__make_running_with_option: internal error: invalid" \ -+ "target option '$${target_option-}' specified" >&2; \ -+ exit 1;; \ -+ esac; \ -+ has_opt=no; \ -+ sane_makeflags=$$MAKEFLAGS; \ -+ if $(am__is_gnu_make); then \ -+ sane_makeflags=$$MFLAGS; \ -+ else \ -+ case $$MAKEFLAGS in \ -+ *\\[\ \ ]*) \ -+ bs=\\; \ -+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ -+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ -+ esac; \ -+ fi; \ -+ skip_next=no; \ -+ strip_trailopt () \ -+ { \ -+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ -+ }; \ -+ for flg in $$sane_makeflags; do \ -+ test $$skip_next = yes && { skip_next=no; continue; }; \ -+ case $$flg in \ -+ *=*|--*) continue;; \ -+ -*I) strip_trailopt 'I'; skip_next=yes;; \ -+ -*I?*) strip_trailopt 'I';; \ -+ -*O) strip_trailopt 'O'; skip_next=yes;; \ -+ -*O?*) strip_trailopt 'O';; \ -+ -*l) strip_trailopt 'l'; skip_next=yes;; \ -+ -*l?*) strip_trailopt 'l';; \ -+ -[dEDm]) skip_next=yes;; \ -+ -[JT]) skip_next=yes;; \ -+ esac; \ -+ case $$flg in \ -+ *$$target_option*) has_opt=yes; break;; \ -+ esac; \ -+ done; \ -+ test $$has_opt = yes -+am__make_dryrun = (target_option=n; $(am__make_running_with_option)) -+am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) -+pkgdatadir = $(datadir)/@PACKAGE@ -+pkgincludedir = $(includedir)/@PACKAGE@ -+pkglibdir = $(libdir)/@PACKAGE@ -+pkglibexecdir = $(libexecdir)/@PACKAGE@ -+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd -+install_sh_DATA = $(install_sh) -c -m 644 -+install_sh_PROGRAM = $(install_sh) -c -+install_sh_SCRIPT = $(install_sh) -c -+INSTALL_HEADER = $(INSTALL_DATA) -+transform = $(program_transform_name) -+NORMAL_INSTALL = : -+PRE_INSTALL = : -+POST_INSTALL = : -+NORMAL_UNINSTALL = : -+PRE_UNINSTALL = : -+POST_UNINSTALL = : -+build_triplet = @build@ -+host_triplet = @host@ -+subdir = xlators/features/glupy/src -+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ -+ $(srcdir)/setup.py.in $(srcdir)/__init__.py.in \ -+ $(top_srcdir)/depcomp $(pyglupy_PYTHON) \ -+ $(top_srcdir)/py-compile $(noinst_HEADERS) -+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 -+am__aclocal_m4_deps = $(top_srcdir)/contrib/aclocal/mkdirp.m4 \ -+ $(top_srcdir)/contrib/aclocal/python.m4 \ -+ $(top_srcdir)/configure.ac -+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ -+ $(ACLOCAL_M4) -+mkinstalldirs = $(install_sh) -d -+CONFIG_HEADER = $(top_builddir)/config.h $(top_builddir)/site.h -+CONFIG_CLEAN_FILES = setup.py __init__.py -+CONFIG_CLEAN_VPATH_FILES = -+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; -+am__vpath_adj = case $$p in \ -+ $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ -+ *) f=$$p;; \ -+ esac; -+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; -+am__install_max = 40 -+am__nobase_strip_setup = \ -+ srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` -+am__nobase_strip = \ -+ for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" -+am__nobase_list = $(am__nobase_strip_setup); \ -+ for p in $$list; do echo "$$p $$p"; done | \ -+ sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ -+ $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ -+ if (++n[$$2] == $(am__install_max)) \ -+ { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ -+ END { for (dir in files) print dir, files[dir] }' -+am__base_list = \ -+ sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ -+ sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' -+am__uninstall_files_from_dir = { \ -+ test -z "$$files" \ -+ || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \ -+ || { echo " ( cd '$$dir' && rm -f" $$files ")"; \ -+ $(am__cd) "$$dir" && rm -f $$files; }; \ -+ } -+am__installdirs = "$(DESTDIR)$(xlatordir)" "$(DESTDIR)$(pyglupydir)" -+LTLIBRARIES = $(xlator_LTLIBRARIES) -+am__DEPENDENCIES_1 = -+glupy_la_DEPENDENCIES = \ -+ $(top_builddir)/libglusterfs/src/libglusterfs.la \ -+ $(am__DEPENDENCIES_1) -+am_glupy_la_OBJECTS = glupy.lo -+glupy_la_OBJECTS = $(am_glupy_la_OBJECTS) -+AM_V_lt = $(am__v_lt_@AM_V@) -+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) -+am__v_lt_0 = --silent -+am__v_lt_1 = -+glupy_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ -+ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ -+ $(glupy_la_LDFLAGS) $(LDFLAGS) -o $@ -+AM_V_P = $(am__v_P_@AM_V@) -+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) -+am__v_P_0 = false -+am__v_P_1 = : -+AM_V_GEN = $(am__v_GEN_@AM_V@) -+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) -+am__v_GEN_0 = @echo " GEN " $@; -+am__v_GEN_1 = -+AM_V_at = $(am__v_at_@AM_V@) -+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) -+am__v_at_0 = @ -+am__v_at_1 = -+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) -+depcomp = $(SHELL) $(top_srcdir)/depcomp -+am__depfiles_maybe = depfiles -+am__mv = mv -f -+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ -+ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ -+ $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ -+ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ -+ $(AM_CFLAGS) $(CFLAGS) -+AM_V_CC = $(am__v_CC_@AM_V@) -+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) -+am__v_CC_0 = @echo " CC " $@; -+am__v_CC_1 = -+CCLD = $(CC) -+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ -+ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ -+ $(AM_LDFLAGS) $(LDFLAGS) -o $@ -+AM_V_CCLD = $(am__v_CCLD_@AM_V@) -+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) -+am__v_CCLD_0 = @echo " CCLD " $@; -+am__v_CCLD_1 = -+SOURCES = $(glupy_la_SOURCES) -+DIST_SOURCES = $(glupy_la_SOURCES) -+RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ -+ ctags-recursive dvi-recursive html-recursive info-recursive \ -+ install-data-recursive install-dvi-recursive \ -+ install-exec-recursive install-html-recursive \ -+ install-info-recursive install-pdf-recursive \ -+ install-ps-recursive install-recursive installcheck-recursive \ -+ installdirs-recursive pdf-recursive ps-recursive \ -+ tags-recursive uninstall-recursive -+am__can_run_installinfo = \ -+ case $$AM_UPDATE_INFO_DIR in \ -+ n|no|NO) false;; \ -+ *) (install-info --version) >/dev/null 2>&1;; \ -+ esac -+am__py_compile = PYTHON=$(PYTHON) $(SHELL) $(py_compile) -+am__pep3147_tweak = \ -+ sed -e 's|\.py$$||' -e 's|[^/]*$$|__pycache__/&.*.py|' -+py_compile = $(top_srcdir)/py-compile -+HEADERS = $(noinst_HEADERS) -+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ -+ distclean-recursive maintainer-clean-recursive -+am__recursive_targets = \ -+ $(RECURSIVE_TARGETS) \ -+ $(RECURSIVE_CLEAN_TARGETS) \ -+ $(am__extra_recursive_targets) -+AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ -+ distdir -+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) -+# Read a list of newline-separated strings from the standard input, -+# and print each of them once, without duplicates. Input order is -+# *not* preserved. -+am__uniquify_input = $(AWK) '\ -+ BEGIN { nonempty = 0; } \ -+ { items[$$0] = 1; nonempty = 1; } \ -+ END { if (nonempty) { for (i in items) print i; }; } \ -+' -+# Make sure the list of sources is unique. This is necessary because, -+# e.g., the same source file might be shared among _SOURCES variables -+# for different programs/libraries. -+am__define_uniq_tagged_files = \ -+ list='$(am__tagged_files)'; \ -+ unique=`for i in $$list; do \ -+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ -+ done | $(am__uniquify_input)` -+ETAGS = etags -+CTAGS = ctags -+DIST_SUBDIRS = $(SUBDIRS) -+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) -+am__relativize = \ -+ dir0=`pwd`; \ -+ sed_first='s,^\([^/]*\)/.*$$,\1,'; \ -+ sed_rest='s,^[^/]*/*,,'; \ -+ sed_last='s,^.*/\([^/]*\)$$,\1,'; \ -+ sed_butlast='s,/*[^/]*$$,,'; \ -+ while test -n "$$dir1"; do \ -+ first=`echo "$$dir1" | sed -e "$$sed_first"`; \ -+ if test "$$first" != "."; then \ -+ if test "$$first" = ".."; then \ -+ dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ -+ dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ -+ else \ -+ first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ -+ if test "$$first2" = "$$first"; then \ -+ dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ -+ else \ -+ dir2="../$$dir2"; \ -+ fi; \ -+ dir0="$$dir0"/"$$first"; \ -+ fi; \ -+ fi; \ -+ dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ -+ done; \ -+ reldir="$$dir2" -+ACLOCAL = @ACLOCAL@ -+ACL_LIBS = @ACL_LIBS@ -+AMTAR = @AMTAR@ -+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ -+AM_LIBTOOLFLAGS = @AM_LIBTOOLFLAGS@ -+AM_MAKEFLAGS = @AM_MAKEFLAGS@ -+AR = @AR@ -+ARGP_LDADD = @ARGP_LDADD@ -+AUTOCONF = @AUTOCONF@ -+AUTOHEADER = @AUTOHEADER@ -+AUTOMAKE = @AUTOMAKE@ -+AWK = @AWK@ -+BUILD_PYTHON_SITE_PACKAGES = @BUILD_PYTHON_SITE_PACKAGES@ -+BUILD_PYTHON_SITE_PACKAGES_EXPANDED = @BUILD_PYTHON_SITE_PACKAGES_EXPANDED@ -+CC = @CC@ -+CCDEPMODE = @CCDEPMODE@ -+CFLAGS = @CFLAGS@ -+CONTRIBDIR = @CONTRIBDIR@ -+CPP = @CPP@ -+CPPFLAGS = @CPPFLAGS@ -+CYGPATH_W = @CYGPATH_W@ -+DEFS = @DEFS@ -+DEPDIR = @DEPDIR@ -+DLLTOOL = @DLLTOOL@ -+DSYMUTIL = @DSYMUTIL@ -+DUMPBIN = @DUMPBIN@ -+ECHO_C = @ECHO_C@ -+ECHO_N = @ECHO_N@ -+ECHO_T = @ECHO_T@ -+EGREP = @EGREP@ -+EVENTS_ENABLED = @EVENTS_ENABLED@ -+EVENTS_SUBDIR = @EVENTS_SUBDIR@ -+EXEEXT = @EXEEXT@ -+FGREP = @FGREP@ -+FUSERMOUNT_SUBDIR = @FUSERMOUNT_SUBDIR@ -+FUSE_CLIENT_SUBDIR = @FUSE_CLIENT_SUBDIR@ -+GEOREP_EXTRAS_SUBDIR = @GEOREP_EXTRAS_SUBDIR@ -+GFAPI_EXTRA_LDFLAGS = @GFAPI_EXTRA_LDFLAGS@ -+GFAPI_LIBS = @GFAPI_LIBS@ -+GFAPI_LT_VERSION = @GFAPI_LT_VERSION@ -+GFAPI_VERSION = @GFAPI_VERSION@ -+GF_CFLAGS = @GF_CFLAGS@ -+GF_CPPFLAGS = @GF_CPPFLAGS@ -+GF_DISTRIBUTION = @GF_DISTRIBUTION@ -+GF_FUSE_CFLAGS = @GF_FUSE_CFLAGS@ -+GF_FUSE_LDADD = @GF_FUSE_LDADD@ -+GF_HOST_OS = @GF_HOST_OS@ -+GF_LDADD = @GF_LDADD@ -+GF_LDFLAGS = @GF_LDFLAGS@ -+GF_NO_UNDEFINED = @GF_NO_UNDEFINED@ -+GF_XLATOR_DEFAULT_LDFLAGS = @GF_XLATOR_DEFAULT_LDFLAGS@ -+GF_XLATOR_LDFLAGS = @GF_XLATOR_LDFLAGS@ -+GLUPY_SUBDIR = @GLUPY_SUBDIR@ -+GLUPY_SUBDIR_MAKEFILE = @GLUPY_SUBDIR_MAKEFILE@ -+GLUPY_SUBDIR_SRC_MAKEFILE = @GLUPY_SUBDIR_SRC_MAKEFILE@ -+GLUSTERD_VOLFILE = @GLUSTERD_VOLFILE@ -+GLUSTERD_WORKDIR = @GLUSTERD_WORKDIR@ -+GLUSTERFSD_MISCDIR = @GLUSTERFSD_MISCDIR@ -+GLUSTERFS_LIBEXECDIR = @GLUSTERFS_LIBEXECDIR@ -+GREP = @GREP@ -+HAVE_ATOMIC_BUILTINS = @HAVE_ATOMIC_BUILTINS@ -+HAVE_BACKTRACE = @HAVE_BACKTRACE@ -+HAVE_LINKAT = @HAVE_LINKAT@ -+HAVE_MALLOC_STATS = @HAVE_MALLOC_STATS@ -+HAVE_SPINLOCK = @HAVE_SPINLOCK@ -+HAVE_STRNLEN = @HAVE_STRNLEN@ -+HAVE_SYNC_BUILTINS = @HAVE_SYNC_BUILTINS@ -+IBVERBS_SUBDIR = @IBVERBS_SUBDIR@ -+INSTALL = @INSTALL@ -+INSTALL_DATA = @INSTALL_DATA@ -+INSTALL_PROGRAM = @INSTALL_PROGRAM@ -+INSTALL_SCRIPT = @INSTALL_SCRIPT@ -+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ -+LD = @LD@ -+LDFLAGS = @LDFLAGS@ -+LEX = @LEX@ -+LEXLIB = @LEXLIB@ -+LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ -+LIBAIO = @LIBAIO@ -+LIBGFCHANGELOG_LT_VERSION = @LIBGFCHANGELOG_LT_VERSION@ -+LIBGFCHANGELOG_VERSION = @LIBGFCHANGELOG_VERSION@ -+LIBGFDB_VERSION = @LIBGFDB_VERSION@ -+LIBGFRPC_LT_VERSION = @LIBGFRPC_LT_VERSION@ -+LIBGFXDR_LT_VERSION = @LIBGFXDR_LT_VERSION@ -+LIBGLUSTERFS_LT_VERSION = @LIBGLUSTERFS_LT_VERSION@ -+LIBOBJS = @LIBOBJS@ -+LIBS = @LIBS@ -+LIBTOOL = @LIBTOOL@ -+LIB_DL = @LIB_DL@ -+LIPO = @LIPO@ -+LN_S = @LN_S@ -+LTLIBOBJS = @LTLIBOBJS@ -+MAKEINFO = @MAKEINFO@ -+MANIFEST_TOOL = @MANIFEST_TOOL@ -+MATH_LIB = @MATH_LIB@ -+MKDIR_P = @MKDIR_P@ -+NM = @NM@ -+NMEDIT = @NMEDIT@ -+OBJDUMP = @OBJDUMP@ -+OBJEXT = @OBJEXT@ -+OCF_SUBDIR = @OCF_SUBDIR@ -+OTOOL = @OTOOL@ -+OTOOL64 = @OTOOL64@ -+PACKAGE = @PACKAGE@ -+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ -+PACKAGE_NAME = @PACKAGE_NAME@ -+PACKAGE_RELEASE = @PACKAGE_RELEASE@ -+PACKAGE_STRING = @PACKAGE_STRING@ -+PACKAGE_TARNAME = @PACKAGE_TARNAME@ -+PACKAGE_URL = @PACKAGE_URL@ -+PACKAGE_VERSION = @PACKAGE_VERSION@ -+PATH_SEPARATOR = @PATH_SEPARATOR@ -+PKGCONFIG_UUID = @PKGCONFIG_UUID@ -+PKG_CONFIG = @PKG_CONFIG@ -+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ -+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ -+PYTHON = @PYTHON@ -+PYTHON_CFLAGS = @PYTHON_CFLAGS@ -+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ -+PYTHON_LIBS = @PYTHON_LIBS@ -+PYTHON_PLATFORM = @PYTHON_PLATFORM@ -+PYTHON_PREFIX = @PYTHON_PREFIX@ -+PYTHON_VERSION = @PYTHON_VERSION@ -+RANLIB = @RANLIB@ -+RDMA_SUBDIR = @RDMA_SUBDIR@ -+RLLIBS = @RLLIBS@ -+RPCGEN = @RPCGEN@ -+SBIN_DIR = @SBIN_DIR@ -+SED = @SED@ -+SET_MAKE = @SET_MAKE@ -+SHELL = @SHELL@ -+SIZEOF_INT = @SIZEOF_INT@ -+SIZEOF_LONG = @SIZEOF_LONG@ -+SIZEOF_LONG_LONG = @SIZEOF_LONG_LONG@ -+SIZEOF_SHORT = @SIZEOF_SHORT@ -+SQLITE_CFLAGS = @SQLITE_CFLAGS@ -+SQLITE_LIBS = @SQLITE_LIBS@ -+STRIP = @STRIP@ -+SYNCDAEMON_COMPILE = @SYNCDAEMON_COMPILE@ -+SYNCDAEMON_SUBDIR = @SYNCDAEMON_SUBDIR@ -+SYSCONF_DIR = @SYSCONF_DIR@ -+TIRPC_CFLAGS = @TIRPC_CFLAGS@ -+TIRPC_LIBS = @TIRPC_LIBS@ -+UMOUNTD_SUBDIR = @UMOUNTD_SUBDIR@ -+UNITTEST_CFLAGS = @UNITTEST_CFLAGS@ -+UNITTEST_LDFLAGS = @UNITTEST_LDFLAGS@ -+UNITTEST_LIBS = @UNITTEST_LIBS@ -+URCU_CDS_CFLAGS = @URCU_CDS_CFLAGS@ -+URCU_CDS_LIBS = @URCU_CDS_LIBS@ -+URCU_CFLAGS = @URCU_CFLAGS@ -+URCU_LIBS = @URCU_LIBS@ -+USE_EC_DYNAMIC_AVX = @USE_EC_DYNAMIC_AVX@ -+USE_EC_DYNAMIC_NEON = @USE_EC_DYNAMIC_NEON@ -+USE_EC_DYNAMIC_SSE = @USE_EC_DYNAMIC_SSE@ -+USE_EC_DYNAMIC_X64 = @USE_EC_DYNAMIC_X64@ -+USE_POSIX_ACLS = @USE_POSIX_ACLS@ -+UUID_CFLAGS = @UUID_CFLAGS@ -+UUID_LIBS = @UUID_LIBS@ -+VERSION = @VERSION@ -+XML_CFLAGS = @XML_CFLAGS@ -+XML_LIBS = @XML_LIBS@ -+YACC = @YACC@ -+YFLAGS = @YFLAGS@ -+ZLIB_CFLAGS = @ZLIB_CFLAGS@ -+ZLIB_LIBS = @ZLIB_LIBS@ -+abs_builddir = @abs_builddir@ -+abs_srcdir = @abs_srcdir@ -+abs_top_builddir = @abs_top_builddir@ -+abs_top_srcdir = @abs_top_srcdir@ -+ac_ct_AR = @ac_ct_AR@ -+ac_ct_CC = @ac_ct_CC@ -+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ -+am__include = @am__include@ -+am__leading_dot = @am__leading_dot@ -+am__quote = @am__quote@ -+am__tar = @am__tar@ -+am__untar = @am__untar@ -+bindir = @bindir@ -+build = @build@ -+build_alias = @build_alias@ -+build_cpu = @build_cpu@ -+build_os = @build_os@ -+build_vendor = @build_vendor@ -+builddir = @builddir@ -+datadir = @datadir@ -+datarootdir = @datarootdir@ -+docdir = @docdir@ -+dvidir = @dvidir@ -+exec_prefix = @exec_prefix@ -+host = @host@ -+host_alias = @host_alias@ -+host_cpu = @host_cpu@ -+host_os = @host_os@ -+host_vendor = @host_vendor@ -+htmldir = @htmldir@ -+includedir = @includedir@ -+infodir = @infodir@ -+initdir = @initdir@ -+install_sh = @install_sh@ -+launchddir = @launchddir@ -+libdir = @libdir@ -+libexecdir = @libexecdir@ -+localedir = @localedir@ -+localstatedir = @localstatedir@ -+mandir = @mandir@ -+mkdir_p = @mkdir_p@ -+mountutildir = @mountutildir@ -+oldincludedir = @oldincludedir@ -+pdfdir = @pdfdir@ -+pkgconfigdir = @pkgconfigdir@ -+pkgpyexecdir = @pkgpyexecdir@ -+pkgpythondir = @pkgpythondir@ -+prefix = @prefix@ -+program_transform_name = @program_transform_name@ -+psdir = @psdir@ -+pyexecdir = @pyexecdir@ -+pythondir = @pythondir@ -+sbindir = @sbindir@ -+sharedstatedir = @sharedstatedir@ -+shrext_cmds = @shrext_cmds@ -+srcdir = @srcdir@ -+sysconfdir = @sysconfdir@ -+systemddir = @systemddir@ -+target_alias = @target_alias@ -+tmpfilesdir = @tmpfilesdir@ -+top_build_prefix = @top_build_prefix@ -+top_builddir = @top_builddir@ -+top_srcdir = @top_srcdir@ -+xlator_LTLIBRARIES = glupy.la -+ -+# Ensure GLUSTER_PYTHON_PATH is passed to glupy.so -+xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/features -+glupydir = $(xlatordir)/glupy -+AM_CPPFLAGS = $(GF_CPPFLAGS) \ -+ -I$(top_srcdir)/libglusterfs/src \ -+ -I$(top_srcdir)/rpc/xdr/src -I$(top_builddir)/rpc/xdr/src -+ -+AM_CFLAGS = -Wall -fno-strict-aliasing \ -+ -DGLUSTER_PYTHON_PATH=\"$(glupydir)\" \ -+ -DPATH_GLUSTERFS_GLUPY_MODULE=\"${xlatordir}/glupy${shrext_cmds}\" \ -+ $(GF_CFLAGS) $(PYTHON_CFLAGS) -+ -+ -+# Flags to build glupy.so with -+glupy_la_LDFLAGS = -module -nostartfiles \ -+ -export-symbols $(top_srcdir)/xlators/features/glupy/src/glupy.sym \ -+ $(GF_XLATOR_LDFLAGS) $(PYTHON_LIBS) -+ -+glupy_la_SOURCES = glupy.c -+glupy_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \ -+ -lpthread $(LIB_DL) -+ -+noinst_HEADERS = glupy.h -+ -+# Install __init__.py into the Python site-packages area -+pyglupydir = @BUILD_PYTHON_SITE_PACKAGES@/gluster -+pyglupy_PYTHON = __init__.py -+ -+# Install glupy/__init_-.py into the Python site-packages area -+SUBDIRS = glupy -+CLEANFILES = -+EXTRA_DIST = glupy.sym -+all: all-recursive -+ -+.SUFFIXES: -+.SUFFIXES: .c .lo .o .obj -+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) -+ @for dep in $?; do \ -+ case '$(am__configure_deps)' in \ -+ *$$dep*) \ -+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ -+ && { if test -f $@; then exit 0; else break; fi; }; \ -+ exit 1;; \ -+ esac; \ -+ done; \ -+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign xlators/features/glupy/src/Makefile'; \ -+ $(am__cd) $(top_srcdir) && \ -+ $(AUTOMAKE) --foreign xlators/features/glupy/src/Makefile -+.PRECIOUS: Makefile -+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status -+ @case '$?' in \ -+ *config.status*) \ -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ -+ *) \ -+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ -+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ -+ esac; -+ -+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+ -+$(top_srcdir)/configure: $(am__configure_deps) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+$(ACLOCAL_M4): $(am__aclocal_m4_deps) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+$(am__aclocal_m4_deps): -+setup.py: $(top_builddir)/config.status $(srcdir)/setup.py.in -+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ -+__init__.py: $(top_builddir)/config.status $(srcdir)/__init__.py.in -+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ -+ -+install-xlatorLTLIBRARIES: $(xlator_LTLIBRARIES) -+ @$(NORMAL_INSTALL) -+ @list='$(xlator_LTLIBRARIES)'; test -n "$(xlatordir)" || list=; \ -+ list2=; for p in $$list; do \ -+ if test -f $$p; then \ -+ list2="$$list2 $$p"; \ -+ else :; fi; \ -+ done; \ -+ test -z "$$list2" || { \ -+ echo " $(MKDIR_P) '$(DESTDIR)$(xlatordir)'"; \ -+ $(MKDIR_P) "$(DESTDIR)$(xlatordir)" || exit 1; \ -+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(xlatordir)'"; \ -+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(xlatordir)"; \ -+ } -+ -+uninstall-xlatorLTLIBRARIES: -+ @$(NORMAL_UNINSTALL) -+ @list='$(xlator_LTLIBRARIES)'; test -n "$(xlatordir)" || list=; \ -+ for p in $$list; do \ -+ $(am__strip_dir) \ -+ echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(xlatordir)/$$f'"; \ -+ $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(xlatordir)/$$f"; \ -+ done -+ -+clean-xlatorLTLIBRARIES: -+ -test -z "$(xlator_LTLIBRARIES)" || rm -f $(xlator_LTLIBRARIES) -+ @list='$(xlator_LTLIBRARIES)'; \ -+ locs=`for p in $$list; do echo $$p; done | \ -+ sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ -+ sort -u`; \ -+ test -z "$$locs" || { \ -+ echo rm -f $${locs}; \ -+ rm -f $${locs}; \ -+ } -+ -+glupy.la: $(glupy_la_OBJECTS) $(glupy_la_DEPENDENCIES) $(EXTRA_glupy_la_DEPENDENCIES) -+ $(AM_V_CCLD)$(glupy_la_LINK) -rpath $(xlatordir) $(glupy_la_OBJECTS) $(glupy_la_LIBADD) $(LIBS) -+ -+mostlyclean-compile: -+ -rm -f *.$(OBJEXT) -+ -+distclean-compile: -+ -rm -f *.tab.c -+ -+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/glupy.Plo@am__quote@ -+ -+.c.o: -+@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< -+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po -+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ -+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c $< -+ -+.c.obj: -+@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` -+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po -+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ -+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c `$(CYGPATH_W) '$<'` -+ -+.c.lo: -+@am__fastdepCC_TRUE@ $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< -+@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo -+@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ -+@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -+@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $< -+ -+mostlyclean-libtool: -+ -rm -f *.lo -+ -+clean-libtool: -+ -rm -rf .libs _libs -+install-pyglupyPYTHON: $(pyglupy_PYTHON) -+ @$(NORMAL_INSTALL) -+ @list='$(pyglupy_PYTHON)'; dlist=; list2=; test -n "$(pyglupydir)" || list=; \ -+ if test -n "$$list"; then \ -+ echo " $(MKDIR_P) '$(DESTDIR)$(pyglupydir)'"; \ -+ $(MKDIR_P) "$(DESTDIR)$(pyglupydir)" || exit 1; \ -+ fi; \ -+ for p in $$list; do \ -+ if test -f "$$p"; then b=; else b="$(srcdir)/"; fi; \ -+ if test -f $$b$$p; then \ -+ $(am__strip_dir) \ -+ dlist="$$dlist $$f"; \ -+ list2="$$list2 $$b$$p"; \ -+ else :; fi; \ -+ done; \ -+ for file in $$list2; do echo $$file; done | $(am__base_list) | \ -+ while read files; do \ -+ echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pyglupydir)'"; \ -+ $(INSTALL_DATA) $$files "$(DESTDIR)$(pyglupydir)" || exit $$?; \ -+ done || exit $$?; \ -+ if test -n "$$dlist"; then \ -+ $(am__py_compile) --destdir "$(DESTDIR)" \ -+ --basedir "$(pyglupydir)" $$dlist; \ -+ else :; fi -+ -+uninstall-pyglupyPYTHON: -+ @$(NORMAL_UNINSTALL) -+ @list='$(pyglupy_PYTHON)'; test -n "$(pyglupydir)" || list=; \ -+ py_files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \ -+ test -n "$$py_files" || exit 0; \ -+ dir='$(DESTDIR)$(pyglupydir)'; \ -+ pyc_files=`echo "$$py_files" | sed 's|$$|c|'`; \ -+ pyo_files=`echo "$$py_files" | sed 's|$$|o|'`; \ -+ py_files_pep3147=`echo "$$py_files" | $(am__pep3147_tweak)`; \ -+ echo "$$py_files_pep3147";\ -+ pyc_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|c|'`; \ -+ pyo_files_pep3147=`echo "$$py_files_pep3147" | sed 's|$$|o|'`; \ -+ st=0; \ -+ for files in \ -+ "$$py_files" \ -+ "$$pyc_files" \ -+ "$$pyo_files" \ -+ "$$pyc_files_pep3147" \ -+ "$$pyo_files_pep3147" \ -+ ; do \ -+ $(am__uninstall_files_from_dir) || st=$$?; \ -+ done; \ -+ exit $$st -+ -+# This directory's subdirectories are mostly independent; you can cd -+# into them and run 'make' without going through this Makefile. -+# To change the values of 'make' variables: instead of editing Makefiles, -+# (1) if the variable is set in 'config.status', edit 'config.status' -+# (which will cause the Makefiles to be regenerated when you run 'make'); -+# (2) otherwise, pass the desired values on the 'make' command line. -+$(am__recursive_targets): -+ @fail=; \ -+ if $(am__make_keepgoing); then \ -+ failcom='fail=yes'; \ -+ else \ -+ failcom='exit 1'; \ -+ fi; \ -+ dot_seen=no; \ -+ target=`echo $@ | sed s/-recursive//`; \ -+ case "$@" in \ -+ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ -+ *) list='$(SUBDIRS)' ;; \ -+ esac; \ -+ for subdir in $$list; do \ -+ echo "Making $$target in $$subdir"; \ -+ if test "$$subdir" = "."; then \ -+ dot_seen=yes; \ -+ local_target="$$target-am"; \ -+ else \ -+ local_target="$$target"; \ -+ fi; \ -+ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ -+ || eval $$failcom; \ -+ done; \ -+ if test "$$dot_seen" = "no"; then \ -+ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ -+ fi; test -z "$$fail" -+ -+ID: $(am__tagged_files) -+ $(am__define_uniq_tagged_files); mkid -fID $$unique -+tags: tags-recursive -+TAGS: tags -+ -+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) -+ set x; \ -+ here=`pwd`; \ -+ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ -+ include_option=--etags-include; \ -+ empty_fix=.; \ -+ else \ -+ include_option=--include; \ -+ empty_fix=; \ -+ fi; \ -+ list='$(SUBDIRS)'; for subdir in $$list; do \ -+ if test "$$subdir" = .; then :; else \ -+ test ! -f $$subdir/TAGS || \ -+ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ -+ fi; \ -+ done; \ -+ $(am__define_uniq_tagged_files); \ -+ shift; \ -+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ -+ test -n "$$unique" || unique=$$empty_fix; \ -+ if test $$# -gt 0; then \ -+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ -+ "$$@" $$unique; \ -+ else \ -+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ -+ $$unique; \ -+ fi; \ -+ fi -+ctags: ctags-recursive -+ -+CTAGS: ctags -+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) -+ $(am__define_uniq_tagged_files); \ -+ test -z "$(CTAGS_ARGS)$$unique" \ -+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ -+ $$unique -+ -+GTAGS: -+ here=`$(am__cd) $(top_builddir) && pwd` \ -+ && $(am__cd) $(top_srcdir) \ -+ && gtags -i $(GTAGS_ARGS) "$$here" -+cscopelist: cscopelist-recursive -+ -+cscopelist-am: $(am__tagged_files) -+ list='$(am__tagged_files)'; \ -+ case "$(srcdir)" in \ -+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ -+ *) sdir=$(subdir)/$(srcdir) ;; \ -+ esac; \ -+ for i in $$list; do \ -+ if test -f "$$i"; then \ -+ echo "$(subdir)/$$i"; \ -+ else \ -+ echo "$$sdir/$$i"; \ -+ fi; \ -+ done >> $(top_builddir)/cscope.files -+ -+distclean-tags: -+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags -+ -+distdir: $(DISTFILES) -+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ -+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ -+ list='$(DISTFILES)'; \ -+ dist_files=`for file in $$list; do echo $$file; done | \ -+ sed -e "s|^$$srcdirstrip/||;t" \ -+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ -+ case $$dist_files in \ -+ */*) $(MKDIR_P) `echo "$$dist_files" | \ -+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ -+ sort -u` ;; \ -+ esac; \ -+ for file in $$dist_files; do \ -+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ -+ if test -d $$d/$$file; then \ -+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ -+ if test -d "$(distdir)/$$file"; then \ -+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ -+ fi; \ -+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ -+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ -+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ -+ fi; \ -+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ -+ else \ -+ test -f "$(distdir)/$$file" \ -+ || cp -p $$d/$$file "$(distdir)/$$file" \ -+ || exit 1; \ -+ fi; \ -+ done -+ @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ -+ if test "$$subdir" = .; then :; else \ -+ $(am__make_dryrun) \ -+ || test -d "$(distdir)/$$subdir" \ -+ || $(MKDIR_P) "$(distdir)/$$subdir" \ -+ || exit 1; \ -+ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ -+ $(am__relativize); \ -+ new_distdir=$$reldir; \ -+ dir1=$$subdir; dir2="$(top_distdir)"; \ -+ $(am__relativize); \ -+ new_top_distdir=$$reldir; \ -+ echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ -+ echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ -+ ($(am__cd) $$subdir && \ -+ $(MAKE) $(AM_MAKEFLAGS) \ -+ top_distdir="$$new_top_distdir" \ -+ distdir="$$new_distdir" \ -+ am__remove_distdir=: \ -+ am__skip_length_check=: \ -+ am__skip_mode_fix=: \ -+ distdir) \ -+ || exit 1; \ -+ fi; \ -+ done -+check-am: all-am -+check: check-recursive -+all-am: Makefile $(LTLIBRARIES) $(HEADERS) -+installdirs: installdirs-recursive -+installdirs-am: -+ for dir in "$(DESTDIR)$(xlatordir)" "$(DESTDIR)$(pyglupydir)"; do \ -+ test -z "$$dir" || $(MKDIR_P) "$$dir"; \ -+ done -+install: install-recursive -+install-exec: install-exec-recursive -+install-data: install-data-recursive -+uninstall: uninstall-recursive -+ -+install-am: all-am -+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am -+ -+installcheck: installcheck-recursive -+install-strip: -+ if test -z '$(STRIP)'; then \ -+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ -+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ -+ install; \ -+ else \ -+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ -+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ -+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ -+ fi -+mostlyclean-generic: -+ -+clean-generic: -+ -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) -+ -+distclean-generic: -+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) -+ -+maintainer-clean-generic: -+ @echo "This command is intended for maintainers to use" -+ @echo "it deletes files that may require special tools to rebuild." -+clean: clean-recursive -+ -+clean-am: clean-generic clean-libtool clean-xlatorLTLIBRARIES \ -+ mostlyclean-am -+ -+distclean: distclean-recursive -+ -rm -rf ./$(DEPDIR) -+ -rm -f Makefile -+distclean-am: clean-am distclean-compile distclean-generic \ -+ distclean-tags -+ -+dvi: dvi-recursive -+ -+dvi-am: -+ -+html: html-recursive -+ -+html-am: -+ -+info: info-recursive -+ -+info-am: -+ -+install-data-am: install-pyglupyPYTHON install-xlatorLTLIBRARIES -+ -+install-dvi: install-dvi-recursive -+ -+install-dvi-am: -+ -+install-exec-am: -+ -+install-html: install-html-recursive -+ -+install-html-am: -+ -+install-info: install-info-recursive -+ -+install-info-am: -+ -+install-man: -+ -+install-pdf: install-pdf-recursive -+ -+install-pdf-am: -+ -+install-ps: install-ps-recursive -+ -+install-ps-am: -+ -+installcheck-am: -+ -+maintainer-clean: maintainer-clean-recursive -+ -rm -rf ./$(DEPDIR) -+ -rm -f Makefile -+maintainer-clean-am: distclean-am maintainer-clean-generic -+ -+mostlyclean: mostlyclean-recursive -+ -+mostlyclean-am: mostlyclean-compile mostlyclean-generic \ -+ mostlyclean-libtool -+ -+pdf: pdf-recursive -+ -+pdf-am: -+ -+ps: ps-recursive -+ -+ps-am: -+ -+uninstall-am: uninstall-pyglupyPYTHON uninstall-xlatorLTLIBRARIES -+ -+.MAKE: $(am__recursive_targets) install-am install-strip -+ -+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am check \ -+ check-am clean clean-generic clean-libtool \ -+ clean-xlatorLTLIBRARIES cscopelist-am ctags ctags-am distclean \ -+ distclean-compile distclean-generic distclean-libtool \ -+ distclean-tags distdir dvi dvi-am html html-am info info-am \ -+ install install-am install-data install-data-am install-dvi \ -+ install-dvi-am install-exec install-exec-am install-html \ -+ install-html-am install-info install-info-am install-man \ -+ install-pdf install-pdf-am install-ps install-ps-am \ -+ install-pyglupyPYTHON install-strip install-xlatorLTLIBRARIES \ -+ installcheck installcheck-am installdirs installdirs-am \ -+ maintainer-clean maintainer-clean-generic mostlyclean \ -+ mostlyclean-compile mostlyclean-generic mostlyclean-libtool \ -+ pdf pdf-am ps ps-am tags tags-am uninstall uninstall-am \ -+ uninstall-pyglupyPYTHON uninstall-xlatorLTLIBRARIES -+ -+ -+# Tell versions [3.59,3.63) of GNU make to not export all variables. -+# Otherwise a system limit (for SysV at least) may be exceeded. -+.NOEXPORT: ---- /dev/null 2019-06-26 14:01:23.038000000 -0400 -+++ xlators/features/glupy/Makefile.in 2019-07-06 08:50:36.896964027 -0400 -@@ -0,0 +1,717 @@ -+# Makefile.in generated by automake 1.13.4 from Makefile.am. -+# @configure_input@ -+ -+# Copyright (C) 1994-2013 Free Software Foundation, Inc. -+ -+# This Makefile.in is free software; the Free Software Foundation -+# gives unlimited permission to copy and/or distribute it, -+# with or without modifications, as long as this notice is preserved. -+ -+# This program is distributed in the hope that it will be useful, -+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without -+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A -+# PARTICULAR PURPOSE. -+ -+@SET_MAKE@ -+VPATH = @srcdir@ -+am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' -+am__make_running_with_option = \ -+ case $${target_option-} in \ -+ ?) ;; \ -+ *) echo "am__make_running_with_option: internal error: invalid" \ -+ "target option '$${target_option-}' specified" >&2; \ -+ exit 1;; \ -+ esac; \ -+ has_opt=no; \ -+ sane_makeflags=$$MAKEFLAGS; \ -+ if $(am__is_gnu_make); then \ -+ sane_makeflags=$$MFLAGS; \ -+ else \ -+ case $$MAKEFLAGS in \ -+ *\\[\ \ ]*) \ -+ bs=\\; \ -+ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ -+ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ -+ esac; \ -+ fi; \ -+ skip_next=no; \ -+ strip_trailopt () \ -+ { \ -+ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ -+ }; \ -+ for flg in $$sane_makeflags; do \ -+ test $$skip_next = yes && { skip_next=no; continue; }; \ -+ case $$flg in \ -+ *=*|--*) continue;; \ -+ -*I) strip_trailopt 'I'; skip_next=yes;; \ -+ -*I?*) strip_trailopt 'I';; \ -+ -*O) strip_trailopt 'O'; skip_next=yes;; \ -+ -*O?*) strip_trailopt 'O';; \ -+ -*l) strip_trailopt 'l'; skip_next=yes;; \ -+ -*l?*) strip_trailopt 'l';; \ -+ -[dEDm]) skip_next=yes;; \ -+ -[JT]) skip_next=yes;; \ -+ esac; \ -+ case $$flg in \ -+ *$$target_option*) has_opt=yes; break;; \ -+ esac; \ -+ done; \ -+ test $$has_opt = yes -+am__make_dryrun = (target_option=n; $(am__make_running_with_option)) -+am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) -+pkgdatadir = $(datadir)/@PACKAGE@ -+pkgincludedir = $(includedir)/@PACKAGE@ -+pkglibdir = $(libdir)/@PACKAGE@ -+pkglibexecdir = $(libexecdir)/@PACKAGE@ -+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd -+install_sh_DATA = $(install_sh) -c -m 644 -+install_sh_PROGRAM = $(install_sh) -c -+install_sh_SCRIPT = $(install_sh) -c -+INSTALL_HEADER = $(INSTALL_DATA) -+transform = $(program_transform_name) -+NORMAL_INSTALL = : -+PRE_INSTALL = : -+POST_INSTALL = : -+NORMAL_UNINSTALL = : -+PRE_UNINSTALL = : -+POST_UNINSTALL = : -+build_triplet = @build@ -+host_triplet = @host@ -+subdir = xlators/features/glupy -+DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am -+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 -+am__aclocal_m4_deps = $(top_srcdir)/contrib/aclocal/mkdirp.m4 \ -+ $(top_srcdir)/contrib/aclocal/python.m4 \ -+ $(top_srcdir)/configure.ac -+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ -+ $(ACLOCAL_M4) -+mkinstalldirs = $(install_sh) -d -+CONFIG_HEADER = $(top_builddir)/config.h $(top_builddir)/site.h -+CONFIG_CLEAN_FILES = -+CONFIG_CLEAN_VPATH_FILES = -+AM_V_P = $(am__v_P_@AM_V@) -+am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) -+am__v_P_0 = false -+am__v_P_1 = : -+AM_V_GEN = $(am__v_GEN_@AM_V@) -+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) -+am__v_GEN_0 = @echo " GEN " $@; -+am__v_GEN_1 = -+AM_V_at = $(am__v_at_@AM_V@) -+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) -+am__v_at_0 = @ -+am__v_at_1 = -+SOURCES = -+DIST_SOURCES = -+RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \ -+ ctags-recursive dvi-recursive html-recursive info-recursive \ -+ install-data-recursive install-dvi-recursive \ -+ install-exec-recursive install-html-recursive \ -+ install-info-recursive install-pdf-recursive \ -+ install-ps-recursive install-recursive installcheck-recursive \ -+ installdirs-recursive pdf-recursive ps-recursive \ -+ tags-recursive uninstall-recursive -+am__can_run_installinfo = \ -+ case $$AM_UPDATE_INFO_DIR in \ -+ n|no|NO) false;; \ -+ *) (install-info --version) >/dev/null 2>&1;; \ -+ esac -+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \ -+ distclean-recursive maintainer-clean-recursive -+am__recursive_targets = \ -+ $(RECURSIVE_TARGETS) \ -+ $(RECURSIVE_CLEAN_TARGETS) \ -+ $(am__extra_recursive_targets) -+AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \ -+ distdir -+am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) -+# Read a list of newline-separated strings from the standard input, -+# and print each of them once, without duplicates. Input order is -+# *not* preserved. -+am__uniquify_input = $(AWK) '\ -+ BEGIN { nonempty = 0; } \ -+ { items[$$0] = 1; nonempty = 1; } \ -+ END { if (nonempty) { for (i in items) print i; }; } \ -+' -+# Make sure the list of sources is unique. This is necessary because, -+# e.g., the same source file might be shared among _SOURCES variables -+# for different programs/libraries. -+am__define_uniq_tagged_files = \ -+ list='$(am__tagged_files)'; \ -+ unique=`for i in $$list; do \ -+ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ -+ done | $(am__uniquify_input)` -+ETAGS = etags -+CTAGS = ctags -+DIST_SUBDIRS = $(SUBDIRS) -+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) -+am__relativize = \ -+ dir0=`pwd`; \ -+ sed_first='s,^\([^/]*\)/.*$$,\1,'; \ -+ sed_rest='s,^[^/]*/*,,'; \ -+ sed_last='s,^.*/\([^/]*\)$$,\1,'; \ -+ sed_butlast='s,/*[^/]*$$,,'; \ -+ while test -n "$$dir1"; do \ -+ first=`echo "$$dir1" | sed -e "$$sed_first"`; \ -+ if test "$$first" != "."; then \ -+ if test "$$first" = ".."; then \ -+ dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \ -+ dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \ -+ else \ -+ first2=`echo "$$dir2" | sed -e "$$sed_first"`; \ -+ if test "$$first2" = "$$first"; then \ -+ dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \ -+ else \ -+ dir2="../$$dir2"; \ -+ fi; \ -+ dir0="$$dir0"/"$$first"; \ -+ fi; \ -+ fi; \ -+ dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \ -+ done; \ -+ reldir="$$dir2" -+ACLOCAL = @ACLOCAL@ -+ACL_LIBS = @ACL_LIBS@ -+AMTAR = @AMTAR@ -+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ -+AM_LIBTOOLFLAGS = @AM_LIBTOOLFLAGS@ -+AM_MAKEFLAGS = @AM_MAKEFLAGS@ -+AR = @AR@ -+ARGP_LDADD = @ARGP_LDADD@ -+AUTOCONF = @AUTOCONF@ -+AUTOHEADER = @AUTOHEADER@ -+AUTOMAKE = @AUTOMAKE@ -+AWK = @AWK@ -+BUILD_PYTHON_SITE_PACKAGES = @BUILD_PYTHON_SITE_PACKAGES@ -+BUILD_PYTHON_SITE_PACKAGES_EXPANDED = @BUILD_PYTHON_SITE_PACKAGES_EXPANDED@ -+CC = @CC@ -+CCDEPMODE = @CCDEPMODE@ -+CFLAGS = @CFLAGS@ -+CONTRIBDIR = @CONTRIBDIR@ -+CPP = @CPP@ -+CPPFLAGS = @CPPFLAGS@ -+CYGPATH_W = @CYGPATH_W@ -+DEFS = @DEFS@ -+DEPDIR = @DEPDIR@ -+DLLTOOL = @DLLTOOL@ -+DSYMUTIL = @DSYMUTIL@ -+DUMPBIN = @DUMPBIN@ -+ECHO_C = @ECHO_C@ -+ECHO_N = @ECHO_N@ -+ECHO_T = @ECHO_T@ -+EGREP = @EGREP@ -+EVENTS_ENABLED = @EVENTS_ENABLED@ -+EVENTS_SUBDIR = @EVENTS_SUBDIR@ -+EXEEXT = @EXEEXT@ -+FGREP = @FGREP@ -+FUSERMOUNT_SUBDIR = @FUSERMOUNT_SUBDIR@ -+FUSE_CLIENT_SUBDIR = @FUSE_CLIENT_SUBDIR@ -+GEOREP_EXTRAS_SUBDIR = @GEOREP_EXTRAS_SUBDIR@ -+GFAPI_EXTRA_LDFLAGS = @GFAPI_EXTRA_LDFLAGS@ -+GFAPI_LIBS = @GFAPI_LIBS@ -+GFAPI_LT_VERSION = @GFAPI_LT_VERSION@ -+GFAPI_VERSION = @GFAPI_VERSION@ -+GF_CFLAGS = @GF_CFLAGS@ -+GF_CPPFLAGS = @GF_CPPFLAGS@ -+GF_DISTRIBUTION = @GF_DISTRIBUTION@ -+GF_FUSE_CFLAGS = @GF_FUSE_CFLAGS@ -+GF_FUSE_LDADD = @GF_FUSE_LDADD@ -+GF_HOST_OS = @GF_HOST_OS@ -+GF_LDADD = @GF_LDADD@ -+GF_LDFLAGS = @GF_LDFLAGS@ -+GF_NO_UNDEFINED = @GF_NO_UNDEFINED@ -+GF_XLATOR_DEFAULT_LDFLAGS = @GF_XLATOR_DEFAULT_LDFLAGS@ -+GF_XLATOR_LDFLAGS = @GF_XLATOR_LDFLAGS@ -+GLUPY_SUBDIR = @GLUPY_SUBDIR@ -+GLUPY_SUBDIR_MAKEFILE = @GLUPY_SUBDIR_MAKEFILE@ -+GLUPY_SUBDIR_SRC_MAKEFILE = @GLUPY_SUBDIR_SRC_MAKEFILE@ -+GLUSTERD_VOLFILE = @GLUSTERD_VOLFILE@ -+GLUSTERD_WORKDIR = @GLUSTERD_WORKDIR@ -+GLUSTERFSD_MISCDIR = @GLUSTERFSD_MISCDIR@ -+GLUSTERFS_LIBEXECDIR = @GLUSTERFS_LIBEXECDIR@ -+GREP = @GREP@ -+HAVE_ATOMIC_BUILTINS = @HAVE_ATOMIC_BUILTINS@ -+HAVE_BACKTRACE = @HAVE_BACKTRACE@ -+HAVE_LINKAT = @HAVE_LINKAT@ -+HAVE_MALLOC_STATS = @HAVE_MALLOC_STATS@ -+HAVE_SPINLOCK = @HAVE_SPINLOCK@ -+HAVE_STRNLEN = @HAVE_STRNLEN@ -+HAVE_SYNC_BUILTINS = @HAVE_SYNC_BUILTINS@ -+IBVERBS_SUBDIR = @IBVERBS_SUBDIR@ -+INSTALL = @INSTALL@ -+INSTALL_DATA = @INSTALL_DATA@ -+INSTALL_PROGRAM = @INSTALL_PROGRAM@ -+INSTALL_SCRIPT = @INSTALL_SCRIPT@ -+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ -+LD = @LD@ -+LDFLAGS = @LDFLAGS@ -+LEX = @LEX@ -+LEXLIB = @LEXLIB@ -+LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ -+LIBAIO = @LIBAIO@ -+LIBGFCHANGELOG_LT_VERSION = @LIBGFCHANGELOG_LT_VERSION@ -+LIBGFCHANGELOG_VERSION = @LIBGFCHANGELOG_VERSION@ -+LIBGFDB_VERSION = @LIBGFDB_VERSION@ -+LIBGFRPC_LT_VERSION = @LIBGFRPC_LT_VERSION@ -+LIBGFXDR_LT_VERSION = @LIBGFXDR_LT_VERSION@ -+LIBGLUSTERFS_LT_VERSION = @LIBGLUSTERFS_LT_VERSION@ -+LIBOBJS = @LIBOBJS@ -+LIBS = @LIBS@ -+LIBTOOL = @LIBTOOL@ -+LIB_DL = @LIB_DL@ -+LIPO = @LIPO@ -+LN_S = @LN_S@ -+LTLIBOBJS = @LTLIBOBJS@ -+MAKEINFO = @MAKEINFO@ -+MANIFEST_TOOL = @MANIFEST_TOOL@ -+MATH_LIB = @MATH_LIB@ -+MKDIR_P = @MKDIR_P@ -+NM = @NM@ -+NMEDIT = @NMEDIT@ -+OBJDUMP = @OBJDUMP@ -+OBJEXT = @OBJEXT@ -+OCF_SUBDIR = @OCF_SUBDIR@ -+OTOOL = @OTOOL@ -+OTOOL64 = @OTOOL64@ -+PACKAGE = @PACKAGE@ -+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ -+PACKAGE_NAME = @PACKAGE_NAME@ -+PACKAGE_RELEASE = @PACKAGE_RELEASE@ -+PACKAGE_STRING = @PACKAGE_STRING@ -+PACKAGE_TARNAME = @PACKAGE_TARNAME@ -+PACKAGE_URL = @PACKAGE_URL@ -+PACKAGE_VERSION = @PACKAGE_VERSION@ -+PATH_SEPARATOR = @PATH_SEPARATOR@ -+PKGCONFIG_UUID = @PKGCONFIG_UUID@ -+PKG_CONFIG = @PKG_CONFIG@ -+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ -+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ -+PYTHON = @PYTHON@ -+PYTHON_CFLAGS = @PYTHON_CFLAGS@ -+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ -+PYTHON_LIBS = @PYTHON_LIBS@ -+PYTHON_PLATFORM = @PYTHON_PLATFORM@ -+PYTHON_PREFIX = @PYTHON_PREFIX@ -+PYTHON_VERSION = @PYTHON_VERSION@ -+RANLIB = @RANLIB@ -+RDMA_SUBDIR = @RDMA_SUBDIR@ -+RLLIBS = @RLLIBS@ -+RPCGEN = @RPCGEN@ -+SBIN_DIR = @SBIN_DIR@ -+SED = @SED@ -+SET_MAKE = @SET_MAKE@ -+SHELL = @SHELL@ -+SIZEOF_INT = @SIZEOF_INT@ -+SIZEOF_LONG = @SIZEOF_LONG@ -+SIZEOF_LONG_LONG = @SIZEOF_LONG_LONG@ -+SIZEOF_SHORT = @SIZEOF_SHORT@ -+SQLITE_CFLAGS = @SQLITE_CFLAGS@ -+SQLITE_LIBS = @SQLITE_LIBS@ -+STRIP = @STRIP@ -+SYNCDAEMON_COMPILE = @SYNCDAEMON_COMPILE@ -+SYNCDAEMON_SUBDIR = @SYNCDAEMON_SUBDIR@ -+SYSCONF_DIR = @SYSCONF_DIR@ -+TIRPC_CFLAGS = @TIRPC_CFLAGS@ -+TIRPC_LIBS = @TIRPC_LIBS@ -+UMOUNTD_SUBDIR = @UMOUNTD_SUBDIR@ -+UNITTEST_CFLAGS = @UNITTEST_CFLAGS@ -+UNITTEST_LDFLAGS = @UNITTEST_LDFLAGS@ -+UNITTEST_LIBS = @UNITTEST_LIBS@ -+URCU_CDS_CFLAGS = @URCU_CDS_CFLAGS@ -+URCU_CDS_LIBS = @URCU_CDS_LIBS@ -+URCU_CFLAGS = @URCU_CFLAGS@ -+URCU_LIBS = @URCU_LIBS@ -+USE_EC_DYNAMIC_AVX = @USE_EC_DYNAMIC_AVX@ -+USE_EC_DYNAMIC_NEON = @USE_EC_DYNAMIC_NEON@ -+USE_EC_DYNAMIC_SSE = @USE_EC_DYNAMIC_SSE@ -+USE_EC_DYNAMIC_X64 = @USE_EC_DYNAMIC_X64@ -+USE_POSIX_ACLS = @USE_POSIX_ACLS@ -+UUID_CFLAGS = @UUID_CFLAGS@ -+UUID_LIBS = @UUID_LIBS@ -+VERSION = @VERSION@ -+XML_CFLAGS = @XML_CFLAGS@ -+XML_LIBS = @XML_LIBS@ -+YACC = @YACC@ -+YFLAGS = @YFLAGS@ -+ZLIB_CFLAGS = @ZLIB_CFLAGS@ -+ZLIB_LIBS = @ZLIB_LIBS@ -+abs_builddir = @abs_builddir@ -+abs_srcdir = @abs_srcdir@ -+abs_top_builddir = @abs_top_builddir@ -+abs_top_srcdir = @abs_top_srcdir@ -+ac_ct_AR = @ac_ct_AR@ -+ac_ct_CC = @ac_ct_CC@ -+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ -+am__include = @am__include@ -+am__leading_dot = @am__leading_dot@ -+am__quote = @am__quote@ -+am__tar = @am__tar@ -+am__untar = @am__untar@ -+bindir = @bindir@ -+build = @build@ -+build_alias = @build_alias@ -+build_cpu = @build_cpu@ -+build_os = @build_os@ -+build_vendor = @build_vendor@ -+builddir = @builddir@ -+datadir = @datadir@ -+datarootdir = @datarootdir@ -+docdir = @docdir@ -+dvidir = @dvidir@ -+exec_prefix = @exec_prefix@ -+host = @host@ -+host_alias = @host_alias@ -+host_cpu = @host_cpu@ -+host_os = @host_os@ -+host_vendor = @host_vendor@ -+htmldir = @htmldir@ -+includedir = @includedir@ -+infodir = @infodir@ -+initdir = @initdir@ -+install_sh = @install_sh@ -+launchddir = @launchddir@ -+libdir = @libdir@ -+libexecdir = @libexecdir@ -+localedir = @localedir@ -+localstatedir = @localstatedir@ -+mandir = @mandir@ -+mkdir_p = @mkdir_p@ -+mountutildir = @mountutildir@ -+oldincludedir = @oldincludedir@ -+pdfdir = @pdfdir@ -+pkgconfigdir = @pkgconfigdir@ -+pkgpyexecdir = @pkgpyexecdir@ -+pkgpythondir = @pkgpythondir@ -+prefix = @prefix@ -+program_transform_name = @program_transform_name@ -+psdir = @psdir@ -+pyexecdir = @pyexecdir@ -+pythondir = @pythondir@ -+sbindir = @sbindir@ -+sharedstatedir = @sharedstatedir@ -+shrext_cmds = @shrext_cmds@ -+srcdir = @srcdir@ -+sysconfdir = @sysconfdir@ -+systemddir = @systemddir@ -+target_alias = @target_alias@ -+tmpfilesdir = @tmpfilesdir@ -+top_build_prefix = @top_build_prefix@ -+top_builddir = @top_builddir@ -+top_srcdir = @top_srcdir@ -+SUBDIRS = src examples -+CLEANFILES = -+all: all-recursive -+ -+.SUFFIXES: -+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) -+ @for dep in $?; do \ -+ case '$(am__configure_deps)' in \ -+ *$$dep*) \ -+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ -+ && { if test -f $@; then exit 0; else break; fi; }; \ -+ exit 1;; \ -+ esac; \ -+ done; \ -+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign xlators/features/glupy/Makefile'; \ -+ $(am__cd) $(top_srcdir) && \ -+ $(AUTOMAKE) --foreign xlators/features/glupy/Makefile -+.PRECIOUS: Makefile -+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status -+ @case '$?' in \ -+ *config.status*) \ -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ -+ *) \ -+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ -+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ -+ esac; -+ -+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+ -+$(top_srcdir)/configure: $(am__configure_deps) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+$(ACLOCAL_M4): $(am__aclocal_m4_deps) -+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh -+$(am__aclocal_m4_deps): -+ -+mostlyclean-libtool: -+ -rm -f *.lo -+ -+clean-libtool: -+ -rm -rf .libs _libs -+ -+# This directory's subdirectories are mostly independent; you can cd -+# into them and run 'make' without going through this Makefile. -+# To change the values of 'make' variables: instead of editing Makefiles, -+# (1) if the variable is set in 'config.status', edit 'config.status' -+# (which will cause the Makefiles to be regenerated when you run 'make'); -+# (2) otherwise, pass the desired values on the 'make' command line. -+$(am__recursive_targets): -+ @fail=; \ -+ if $(am__make_keepgoing); then \ -+ failcom='fail=yes'; \ -+ else \ -+ failcom='exit 1'; \ -+ fi; \ -+ dot_seen=no; \ -+ target=`echo $@ | sed s/-recursive//`; \ -+ case "$@" in \ -+ distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \ -+ *) list='$(SUBDIRS)' ;; \ -+ esac; \ -+ for subdir in $$list; do \ -+ echo "Making $$target in $$subdir"; \ -+ if test "$$subdir" = "."; then \ -+ dot_seen=yes; \ -+ local_target="$$target-am"; \ -+ else \ -+ local_target="$$target"; \ -+ fi; \ -+ ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \ -+ || eval $$failcom; \ -+ done; \ -+ if test "$$dot_seen" = "no"; then \ -+ $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \ -+ fi; test -z "$$fail" -+ -+ID: $(am__tagged_files) -+ $(am__define_uniq_tagged_files); mkid -fID $$unique -+tags: tags-recursive -+TAGS: tags -+ -+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) -+ set x; \ -+ here=`pwd`; \ -+ if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \ -+ include_option=--etags-include; \ -+ empty_fix=.; \ -+ else \ -+ include_option=--include; \ -+ empty_fix=; \ -+ fi; \ -+ list='$(SUBDIRS)'; for subdir in $$list; do \ -+ if test "$$subdir" = .; then :; else \ -+ test ! -f $$subdir/TAGS || \ -+ set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \ -+ fi; \ -+ done; \ -+ $(am__define_uniq_tagged_files); \ -+ shift; \ -+ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ -+ test -n "$$unique" || unique=$$empty_fix; \ -+ if test $$# -gt 0; then \ -+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ -+ "$$@" $$unique; \ -+ else \ -+ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ -+ $$unique; \ -+ fi; \ -+ fi -+ctags: ctags-recursive -+ -+CTAGS: ctags -+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) -+ $(am__define_uniq_tagged_files); \ -+ test -z "$(CTAGS_ARGS)$$unique" \ -+ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ -+ $$unique -+ -+GTAGS: -+ here=`$(am__cd) $(top_builddir) && pwd` \ -+ && $(am__cd) $(top_srcdir) \ -+ && gtags -i $(GTAGS_ARGS) "$$here" -+cscopelist: cscopelist-recursive -+ -+cscopelist-am: $(am__tagged_files) -+ list='$(am__tagged_files)'; \ -+ case "$(srcdir)" in \ -+ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ -+ *) sdir=$(subdir)/$(srcdir) ;; \ -+ esac; \ -+ for i in $$list; do \ -+ if test -f "$$i"; then \ -+ echo "$(subdir)/$$i"; \ -+ else \ -+ echo "$$sdir/$$i"; \ -+ fi; \ -+ done >> $(top_builddir)/cscope.files -+ -+distclean-tags: -+ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags -+ -+distdir: $(DISTFILES) -+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ -+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ -+ list='$(DISTFILES)'; \ -+ dist_files=`for file in $$list; do echo $$file; done | \ -+ sed -e "s|^$$srcdirstrip/||;t" \ -+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ -+ case $$dist_files in \ -+ */*) $(MKDIR_P) `echo "$$dist_files" | \ -+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ -+ sort -u` ;; \ -+ esac; \ -+ for file in $$dist_files; do \ -+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ -+ if test -d $$d/$$file; then \ -+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ -+ if test -d "$(distdir)/$$file"; then \ -+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ -+ fi; \ -+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ -+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ -+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ -+ fi; \ -+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ -+ else \ -+ test -f "$(distdir)/$$file" \ -+ || cp -p $$d/$$file "$(distdir)/$$file" \ -+ || exit 1; \ -+ fi; \ -+ done -+ @list='$(DIST_SUBDIRS)'; for subdir in $$list; do \ -+ if test "$$subdir" = .; then :; else \ -+ $(am__make_dryrun) \ -+ || test -d "$(distdir)/$$subdir" \ -+ || $(MKDIR_P) "$(distdir)/$$subdir" \ -+ || exit 1; \ -+ dir1=$$subdir; dir2="$(distdir)/$$subdir"; \ -+ $(am__relativize); \ -+ new_distdir=$$reldir; \ -+ dir1=$$subdir; dir2="$(top_distdir)"; \ -+ $(am__relativize); \ -+ new_top_distdir=$$reldir; \ -+ echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \ -+ echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \ -+ ($(am__cd) $$subdir && \ -+ $(MAKE) $(AM_MAKEFLAGS) \ -+ top_distdir="$$new_top_distdir" \ -+ distdir="$$new_distdir" \ -+ am__remove_distdir=: \ -+ am__skip_length_check=: \ -+ am__skip_mode_fix=: \ -+ distdir) \ -+ || exit 1; \ -+ fi; \ -+ done -+check-am: all-am -+check: check-recursive -+all-am: Makefile -+installdirs: installdirs-recursive -+installdirs-am: -+install: install-recursive -+install-exec: install-exec-recursive -+install-data: install-data-recursive -+uninstall: uninstall-recursive -+ -+install-am: all-am -+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am -+ -+installcheck: installcheck-recursive -+install-strip: -+ if test -z '$(STRIP)'; then \ -+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ -+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ -+ install; \ -+ else \ -+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ -+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ -+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ -+ fi -+mostlyclean-generic: -+ -+clean-generic: -+ -test -z "$(CLEANFILES)" || rm -f $(CLEANFILES) -+ -+distclean-generic: -+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) -+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) -+ -+maintainer-clean-generic: -+ @echo "This command is intended for maintainers to use" -+ @echo "it deletes files that may require special tools to rebuild." -+clean: clean-recursive -+ -+clean-am: clean-generic clean-libtool mostlyclean-am -+ -+distclean: distclean-recursive -+ -rm -f Makefile -+distclean-am: clean-am distclean-generic distclean-tags -+ -+dvi: dvi-recursive -+ -+dvi-am: -+ -+html: html-recursive -+ -+html-am: -+ -+info: info-recursive -+ -+info-am: -+ -+install-data-am: -+ -+install-dvi: install-dvi-recursive -+ -+install-dvi-am: -+ -+install-exec-am: -+ -+install-html: install-html-recursive -+ -+install-html-am: -+ -+install-info: install-info-recursive -+ -+install-info-am: -+ -+install-man: -+ -+install-pdf: install-pdf-recursive -+ -+install-pdf-am: -+ -+install-ps: install-ps-recursive -+ -+install-ps-am: -+ -+installcheck-am: -+ -+maintainer-clean: maintainer-clean-recursive -+ -rm -f Makefile -+maintainer-clean-am: distclean-am maintainer-clean-generic -+ -+mostlyclean: mostlyclean-recursive -+ -+mostlyclean-am: mostlyclean-generic mostlyclean-libtool -+ -+pdf: pdf-recursive -+ -+pdf-am: -+ -+ps: ps-recursive -+ -+ps-am: -+ -+uninstall-am: -+ -+.MAKE: $(am__recursive_targets) install-am install-strip -+ -+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am check \ -+ check-am clean clean-generic clean-libtool cscopelist-am ctags \ -+ ctags-am distclean distclean-generic distclean-libtool \ -+ distclean-tags distdir dvi dvi-am html html-am info info-am \ -+ install install-am install-data install-data-am install-dvi \ -+ install-dvi-am install-exec install-exec-am install-html \ -+ install-html-am install-info install-info-am install-man \ -+ install-pdf install-pdf-am install-ps install-ps-am \ -+ install-strip installcheck installcheck-am installdirs \ -+ installdirs-am maintainer-clean maintainer-clean-generic \ -+ mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \ -+ ps ps-am tags tags-am uninstall uninstall-am -+ -+ -+# Tell versions [3.59,3.63) of GNU make to not export all variables. -+# Otherwise a system limit (for SysV at least) may be exceeded. -+.NOEXPORT: diff --git a/glusterfs.spec b/glusterfs.spec index a2bbc8f..235eec6 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -223,7 +223,7 @@ Summary: Distributed File System %if ( 0%{_for_fedora_koji_builds} ) Name: glusterfs -Version: 5.8 +Version: 5.9 Release: %{?prereltag:0.}1%{?prereltag:.%{prereltag}}%{?dist} %else Name: @PACKAGE_NAME@ @@ -1457,6 +1457,9 @@ exit 0 %endif %changelog +* Wed Aug 7 2019 Kaleb S. KEITHLEY - 5.9-1 +- 5.9 GA + * Thu Jul 20 2019 Kaleb S. KEITHLEY - 5.8-1 - 5.8 GA diff --git a/sources b/sources index f442e50..410efe4 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (glusterfs-5.8.tar.gz) = e22853bc97503cc45b614c41a120ee298a94bc02c5820550f5853f83e14ea39f77a2543a82670515e01d930ab0fb6d0e253488fdc4bf156091dceb04e282a1a4 +SHA512 (glusterfs-5.9.tar.gz) = 57cb1ce6b63b6e107ecc2c8fc41eae4599c14a651cdbe774649487c2822ca1186b04d47ec81cbe33bd78bd164414e3098689352c0aee51131c8161117e9d8c4a From adc4aca0468df1c945f83c2f3c097073e2db5f13 Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Wed, 9 Oct 2019 08:41:02 -0400 Subject: [PATCH 11/14] 5.10 GA Signed-off-by: Kaleb S. KEITHLEY --- glusterfs.spec | 5 ++++- sources | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/glusterfs.spec b/glusterfs.spec index 235eec6..f616e02 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -223,7 +223,7 @@ Summary: Distributed File System %if ( 0%{_for_fedora_koji_builds} ) Name: glusterfs -Version: 5.9 +Version: 5.10 Release: %{?prereltag:0.}1%{?prereltag:.%{prereltag}}%{?dist} %else Name: @PACKAGE_NAME@ @@ -1457,6 +1457,9 @@ exit 0 %endif %changelog +* Wed Oct 9 2019 Kaleb S. KEITHLEY - 5.10-1 +- 5.10 GA + * Wed Aug 7 2019 Kaleb S. KEITHLEY - 5.9-1 - 5.9 GA diff --git a/sources b/sources index 410efe4..bcd0952 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (glusterfs-5.9.tar.gz) = 57cb1ce6b63b6e107ecc2c8fc41eae4599c14a651cdbe774649487c2822ca1186b04d47ec81cbe33bd78bd164414e3098689352c0aee51131c8161117e9d8c4a +SHA512 (glusterfs-5.10.tar.gz) = 9268327575eac3108993d70405c32ad16bf16c472399e8da168e1207abeb9b762a90e547371361c783bcd76fddb678347b1c8ef9892c048922ea1233637eb889 From f20df8d231ea56a168e47b54c64c7443fd0f9e7b Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Wed, 9 Oct 2019 10:11:46 -0400 Subject: [PATCH 12/14] 5.10 GA Signed-off-by: Kaleb S. KEITHLEY --- glusterfs.spec | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/glusterfs.spec b/glusterfs.spec index f616e02..032a44a 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -27,7 +27,7 @@ # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without bd %{?_without_bd:%global _without_bd --disable-bd-xlator} -%if ( 0%{?rhel} && 0%{?rhel} > 7 ) +%if ( 0%{?fedora} && 0%{?fedora} > 30 ) || ( 0%{?rhel} && 0%{?rhel} > 7 ) %global _without_bd --without-bd %endif @@ -1463,7 +1463,7 @@ exit 0 * Wed Aug 7 2019 Kaleb S. KEITHLEY - 5.9-1 - 5.9 GA -* Thu Jul 20 2019 Kaleb S. KEITHLEY - 5.8-1 +* Thu Jul 18 2019 Kaleb S. KEITHLEY - 5.8-1 - 5.8 GA * Wed Jul 3 2019 Kaleb S. KEITHLEY - 5.7-1 From c8d2d2e9d208d1c8bd2a68ca80c443a962b69c02 Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Wed, 9 Oct 2019 11:22:10 -0400 Subject: [PATCH 13/14] 5.10 GA Signed-off-by: Kaleb S. KEITHLEY --- glusterfs.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/glusterfs.spec b/glusterfs.spec index 032a44a..8218baa 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -28,7 +28,7 @@ %{?_without_bd:%global _without_bd --disable-bd-xlator} %if ( 0%{?fedora} && 0%{?fedora} > 30 ) || ( 0%{?rhel} && 0%{?rhel} > 7 ) -%global _without_bd --without-bd +%global _without_bd --disable-bd-xlator %endif # cmocka From f7e237c819c6aaf3865157f593b008801afeddbc Mon Sep 17 00:00:00 2001 From: "Kaleb S. KEITHLEY" Date: Thu, 10 Oct 2019 07:52:40 -0400 Subject: [PATCH 14/14] f32+ --without-glupy Signed-off-by: Kaleb S. KEITHLEY --- glusterfs.spec | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/glusterfs.spec b/glusterfs.spec index 8218baa..93a4a06 100644 --- a/glusterfs.spec +++ b/glusterfs.spec @@ -56,6 +56,15 @@ # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without georeplication %{?_without_georeplication:%global _without_georeplication --disable-georeplication} +# glupy +# if you wish to compile an rpm without glupy support... +# rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --without glupy +%{?_without_glupy:%global _without_glupy --disable-glupy} + +%if ( 0%{?fedora} && 0%{?fedora} > 31 ) +%global _without_glupy --disable-glupy +%endif + # gnfs # if you wish to compile an rpm with the legacy gNFS server xlator # rpmbuild -ta @PACKAGE_NAME@-@PACKAGE_VERSION@.tar.gz --with gnfs @@ -707,6 +716,7 @@ sed -i -e 's/--quiet//' configure.ac %{?_with_cmocka} \ %{?_with_debug} \ %{?_with_firewalld} \ + %{?_without_glupy} \ %{?_with_gnfs} \ %{?_with_tmpfilesdir} \ %{?_with_valgrind} \ @@ -1131,12 +1141,14 @@ exit 0 %exclude %{_includedir}/glusterfs/api %exclude %{_libdir}/libgfapi.so %{_libdir}/*.so +%if ( 0%{!?_without_glupy:1} ) # Glupy Translator examples %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy/debug-trace.* %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy/helloworld.* %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy/negative.* +%endif %{_libdir}/pkgconfig/libgfchangelog.pc %if ( 0%{!?_without_tiering:1} ) %{_libdir}/pkgconfig/libgfdb.pc @@ -1145,11 +1157,13 @@ exit 0 %files extra-xlators %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/encryption %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/encryption/rot-13.so +%if ( 0%{!?_without_glupy:1} ) %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy.so %if ( %{_usepython3} ) %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy/__pycache__ %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/glupy/__pycache__/* +%endif %endif %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/features/quiesce.so %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/playground @@ -1157,6 +1171,7 @@ exit 0 %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/testing %dir %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/testing/performance %{_libdir}/glusterfs/%{version}%{?prereltag}/xlator/testing/performance/symlink-cache.so +%if ( 0%{!?_without_glupy:1} ) # Glupy Python files %if ( %{_usepython3} ) %dir %{python3_sitelib}/gluster @@ -1169,6 +1184,7 @@ exit 0 %dir %{python2_sitelib}/gluster/glupy %{python2_sitelib}/gluster/glupy/* %endif +%endif %files fuse # glusterfs is a symlink to glusterfsd, -server depends on -fuse. @@ -1248,11 +1264,15 @@ exit 0 # so that all other gluster submodules can reside in the same namespace. %if ( %{_usepython3} ) %dir %{python3_sitelib}/gluster +%if ( 0%{!?_without_glupy:1} ) %{python3_sitelib}/gluster/__init__.* +%endif %{python3_sitelib}/gluster/cliutils %else %dir %{python2_sitelib}/gluster +%if ( 0%{!?_without_glupy:1} ) %{python2_sitelib}/gluster/__init__.* +%endif %{python2_sitelib}/gluster/cliutils %endif @@ -1457,6 +1477,9 @@ exit 0 %endif %changelog +* Wed Oct 9 2019 Kaleb S. KEITHLEY +- f32+ --without-glupy + * Wed Oct 9 2019 Kaleb S. KEITHLEY - 5.10-1 - 5.10 GA