glusterfs-containers-tests.git -

	Commit message (Collapse)	Author	Age	Files	Lines
*	Fix str/list/tuple distinguishing in library functions to support py3	Valerii Ponomarov	2019-11-28	2	-8/+12
\| \| \| \| \| \| \| \| \| \|	We try to distinguish strings from other iterable object types in several our library functions and now it is not compatible with py3. The problem is that in py2 strings don't have "__iter__" method, but it exists in case of py3. So, fix it by using py2/3 compatible check for string types. Change-Id: I3f833b5e79f1563a3ae6a2bb9ae43d8919d82c30
*	Add test for creation of PVC when one node down	adityaramteke	2019-11-27	1	-1/+1
\| \| \| \| \| \| \|	The purpose of this test case is to confirm that provisioning succeeds if at least 3 nodes are UP in a CNS cluster with nodes >3. Change-Id: I7fc1f851114d921f65e819db23502776526e6827
*	Add TC deleting bunch of PVC's during network failure	Arun Kumar	2019-11-26	1	-5/+11
\| \| \| \| \| \| \| \|	Create network failure while deleting PVC's Network side failure is introduced by opening and closing the ports related to gluster-blockd. Change-Id: Id3a749aa1a051bbce99b85046fa0a79831e85dd5
*	Fix library 'power_off_gluster_node_vm'	Nitin Goyal	2019-11-22	1	-0/+1
\| \| \| \| \| \| \|	Fix the library via adding cleanup power_on_vm which was missed during library creation. Change-Id: I6b2fe78378cac61cee5d630562c0ba7201bbaa4e
*	Add TC restart initiator node when gluster node is down	Nitin Goyal	2019-11-22	3	-5/+140
\| \| \| \| \| \| \|	Add new TC where we verify iscsi rediscovery is happening properly on restart of initiator nodes when one gluster node is down. Change-Id: I515bb27d43843f7c19c4a12b6531a212e9c3285a
*	Add new TC verify PID's of gluster volume	Nitin Goyal	2019-11-21	1	-1/+7
\| \| \| \| \| \| \|	Add new TC where it will verify PID's of gluster volumes are same when volume options value is different. Change-Id: Ie0cae1ad3fdfd35e4c0e7f01e3a048b62b185369
*	Modify and move 'topology_volumes_with_bricks' func to 'heketi_ops.py'	Sri Vignesh	2019-11-21	1	-0/+32
\| \| \| \| \| \| \| \|	Move 'topology_volumes_with_bricks' func to the "heketi_ops" module to be able to use it in other test cases. Change-Id: I7cca884a4f3fb34ec15bb947d3c39d9226e294d0 Signed-off-by: Sri Vignesh <sselvan@redhat.com>
*	Add test for inconsistencies in targetcli when BHV is down	Aditya Ramteke	2019-11-19	1	-2/+3
\| \| \| \| \| \| \|	Confirm no inconsistencies occur in targetcli when block devices are created with one block hosting volume down. Change-Id: I2a755ef2a88c6e6ca5326be3787ac07c0fb7db26
*	Fix test case "test_heketi_node_add_with_valid_cluster"	vamahaja	2019-11-19	2	-0/+69
\| \| \| \| \| \| \| \| \| \|	Fix consists of - - Remove steps for add device validation. - Add steps for gluser peer status validation. - Add steps for endpoints validation. Change-Id: I773a883b1ea8bb2bc93660db3459fd864fcd1317 Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Add new oc libraries	kasturiNarra	2019-11-15	1	-0/+138
\| \| \| \|	Change-Id: I78eb0975c60d1c16b05914bed74b6f942dd0335e
*	Add test case to automate heketi add node into valid cluster	vamahaja	2019-11-14	1	-0/+6
\| \| \| \| \|	Change-Id: I4a2ac7b819929c2de6c8ea5520257800d2e134cc Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Add TC creating bunch of PVCs during network failure	Arun Kumar	2019-11-08	1	-6/+30
\| \| \| \| \| \| \| \|	Create network side failure by opening and closing the ports related to gluster-blockd during creation of the PVC's, Verify PVC's are bound and validate multipath. Change-Id: Ibc53a13e2abb8674661da83d5881a13bbb2ad7fb
*	Make 'provisioner' be autocalculated for storage classes	Valerii Ponomarov	2019-10-31	2	-8/+29
\| \| \| \| \| \| \| \| \| \| \| \| \| \| \|	In OCS 3.11.4 was changed the approach for 'provisioners' in storage classes due to the BugZilla bugs [1] and [2]. So, change the approach for getting 'provisioner' value in this project making it be autocalculated based on the data taken from the block provisioner pod, which is located in the working namespace. [1] https://bugzilla.redhat.com/show_bug.cgi?id=1732787 [2] https://bugzilla.redhat.com/show_bug.cgi?id=1738394 Change-Id: Ic1037038e39abba2b2a1ad6dc3ddbfe42473cb88 Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Add possibility to check Heketi DB inconsistencies after each tc	Valerii Ponomarov	2019-10-25	1	-0/+33
\| \| \| \| \| \| \| \| \|	Define 'check_heketi_db_inconsistencies' config option setting there 'False' or 'True' values. Default value is 'True'. If heketi client doesn't support the 'heketi db check' feature, then 'heketi db check' just won't be performed. Change-Id: I7faff35b15e40d864c0377ae7fee154e217d8eae
*	Add library to get heketi block volumes by name prefix	vamahaja	2019-10-17	1	-0/+32
\| \| \| \| \| \| \| \| \| \| \| \| \| \|	This change required due to - 1. Get block volume by prefix is common step which is used in two places for now and will be used in other places too. 2. Hence add library "heketi_blockvolume_list_by_name_prefix" in heketi_ops.py. 3. And use added library and update code from class "GlusterStabilityTestSetup" and "TestGlusterBlockStability". Change-Id: I9e60d58d5c84380104081335745270b3d21ff071 Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Add test cases to perform heketi cluster operations with nodes	vamahaja	2019-10-17	3	-0/+164
\| \| \| \| \|	Change-Id: I22410ad8c81ca71ac9c2cbaddd66f086abcdf3c5 Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Add library to add/remove iptables rule on host	vamahaja	2019-10-17	1	-0/+50
\| \| \| \| \|	Change-Id: I1055b232711c95fdbf89ba9fe8b9d61a561fbcd5 Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Add new library heketi_node_remove	Nitin Goyal	2019-10-10	1	-0/+34
\| \| \| \|	Change-Id: I96759bbcd74cad7755c99255b4b96261133d5adc
*	Add support for new resource type	kasturiNarra	2019-10-10	1	-4/+11
\| \| \| \| \| \| \| \| \|	As of now user can only pass dc name as argument to validate iscsi and multipath session, with this support user can also pass pod name by specifying rtype=pod Change-Id: Iecc86edc2a2239fc05535f0e4f7e9ae93d5e76f5
*	Add TC Fail tcmu-runner service while creating and deleting pvc	Arun Kumar	2019-09-25	1	-0/+30
\| \| \| \| \| \| \| \| \| \|	Create 8 Block PVC and wait for them to get bound. Delete created PVC's and create 8 more PVC's simultaneously. Kill the tcmu-runner service while PVC creation and deletion is in the progress. Restart all the services related to block volumes and verify all pending operations are completed sucessfully. Change-Id: I0cb4cd29b92233a65be93f4b96f1a9a0cb8bed9f
*	[Lib+tc]Add testcase and library to validate total count of volumes	Sri Vignesh	2019-09-25	1	-0/+33
\| \| \| \| \| \| \| \|	Add library to check db results Validate count of volumes of heketi and db are same Change-Id: I6e75f2d8d5f19a94c1dced5a07f9c948b4de9ef4 Signed-off-by: Sri Vignesh <sselvan@redhat.com>
*	Fix typos in verify_volume_name_prefix function's description	adityaramteke	2019-09-23	1	-1/+1
\| \| \| \|	Change-Id: I46ad6aefd3c699b4ce7807db89c2016791a48e05
*	Add multiple PVCs states waiter	Valerii Ponomarov	2019-09-23	2	-49/+64
\| \| \| \| \| \| \| \|	Add new function called 'wait_for_pvcs_be_bound', which allows us to wait for 'Bound' state of multiple PVCs using single timeout. Also, reuse this new function in the baseclass.py Change-Id: Ia3809d322925b90fdef984db59b3e9e83a82abc7
*	Fix heketi_blockvolume_create lib description	Nitin Goyal	2019-09-19	1	-1/+1
\| \| \| \| \| \|	Change the 'cluster' to 'clusters' in kwargs description. Change-Id: Iac9170d0549adc6bb5b76f5772de47d1db083951
*	Remove json description from heketi_device_add lib	Nitin Goyal	2019-09-19	1	-1/+0
\| \| \| \| \| \| \|	Remove json description from heketi_device_add library as it is not supported. Change-Id: If3121294dc9456587af36d65726842f399730a9b
*	[Revert] "Fix heketi_device_add library"	Nitin Goyal	2019-09-19	1	-2/+0
\| \| \| \| \| \|	This reverts commit 046244942f7ad3f5f24b675dfa299ad955f1412f. Change-Id: I1f49d613af3dd236bf4113db757cbf9ce752e973
*	Add waiter for multiple resources absence	Valerii Ponomarov	2019-09-19	2	-38/+65
\| \| \| \| \| \| \| \| \| \|	Add new function called 'wait_for_resources_absence', which allows us to wait for absense of multiple resources using single timeout. Also, reuse this new function in the baseclass.py for PVC/PV removal waitings. Change-Id: I6e3daae012199e50d3aeb68b697cfae801b0b49b
*	Merge heketi node operation tests in one class and fix library	vamahaja	2019-09-19	1	-17/+20
\| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \|	Fix consists of - - Use "**kwargs" approach in the "heketi_node_list" function as it is done in lots of other functions. - Parse the CLI output in the "heketi_node_list" function using regex instead of the splitting and stripping strings. - Combine test cases related to the same feature into one module - test_heketi_node_operations.py - Remove redundant checks which already exist in common libraries. - Remove unnecessary logging. Change-Id: I815ddfbbacb765140229e7630ec87a6bbaa6255b Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Add testcase for passing clusterid when creating storage class	Ashmitha	2019-09-18	2	-3/+5
\| \| \| \|	Change-Id: I4a6fd02f5713b4e86a9d70cdaffd3ca9369932f4
*	Add TC create and delete PVC's when block services are down	Nitin Goyal	2019-09-16	1	-1/+6
\| \| \| \| \| \| \|	Add new TC verify PVC's create and delete fails while gluster-blockd and tcmu-runner services are down on one node. Change-Id: I5acbcfd6c9a227c0cce21c62f5e162caf970aa22
*	Fix multiple usages of waiters	Valerii Ponomarov	2019-09-16	3	-10/+17
\| \| \| \| \| \| \| \| \| \| \| \| \| \| \| \|	Fix consists of 2 parts: - Calculate correctly left time for waiting in 'scale_dcs_pod_amount_and_wait' function. Before, it had bug, where we were waiting less time than requested. And it led to the unexpected timeout errors. Example: it could fail waiting only 180sec having 600sec as real timeout. - Reset 'attempts' on the instantiated 'waiter's to avoid redundant waiting reusing the single waiter instance. Example. On deletion of 20 PVCs we save about 1,5 minutes. In whole test suite we create much more PVCs than 20. Change-Id: I5d06a63dd0c2c5bd67fdb09fef87948d65e6bf22
*	Fix heketi_device_add library	Nitin Goyal	2019-09-16	1	-0/+2
\| \| \| \| \| \|	As part of the fix loaded the output into json which was missed. Change-Id: Ia3d07f768362232ec2b34641be1a6ae4c4eec399
*	Add test cases for the heketi zones feature	Valerii Ponomarov	2019-09-13	1	-1/+9
\| \| \| \| \| \| \| \| \| \|	Add 10 test cases for testing Heketi zones feature. To make all the Heketi zones test cases run in the single suite using the same cluster set 'common.allow_heketi_zones_update' config option to "True" value. By default it is set to "False" and only small set of test cases can run having such value. Change-Id: I69a1f7c96c9f52a06134e715e113ccd9b06764e6
*	Fix test cases which are failing to delete volume after test completion	vamahaja	2019-09-13	1	-0/+42
\| \| \| \| \| \| \| \| \| \| \|	In test case when we use large disk size, heketi takes time to create volume and due to timeout it gives error. Add fix in such test cases to check if volume created after getting an exception, get details of such volumes or raise exception in case it fails to create volume. Change-Id: I1c23a8c6558c23edf8947771e4f41a4bd3ffd66a Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Fix self.node issue in GlusterBlockBaseClass class	vamahaja	2019-09-13	1	-7/+8
\| \| \| \| \| \| \| \| \|	Gluster block test cases failed with error "self.node" variable not found as self.node variable is not created in "GlusterStabilityTestSetup" class. Fixed change in baseclass.py by using variable "self.ocp_client[0]". Change-Id: I2affabbb626b7e266a9bb243d3ec249229ec9670 Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Fix get gluster pod library for independent cluster	vamahaja	2019-09-13	1	-0/+3
\| \| \| \| \| \| \| \| \| \| \| \|	"get_ocp_gluster_pod_details" library gives error "IndexError: list index out of range" in case of independent mode setup as "get_custom_resource" returns "[[]]" which in not none. Added fix to check if any element present in list. Change-Id: Iffd081f835ffaf9cb50c020cd297444ea2678950 Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Add test case to try creation of storage class with duplicate name	Ashmitha	2019-09-12	2	-2/+5
\| \| \| \|	Change-Id: If30737958bc667264fc01fe81d411f406b501918
*	Add test cases to perform heketi cluster operations	vamahaja	2019-09-11	1	-0/+44
\| \| \| \| \|	Change-Id: I5886680a0d5666c68c677893e0fb327be0e80760 Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Move func get_block_hosting_volume_by_pvc_name to baseclass	kasturiNarra	2019-09-09	1	-0/+23
\| \| \| \| \| \| \| \|	Move get_block_hosting_volume_by_pvc_name from test_restart_gluster_services to baseclass to be able to reuse it in other test modules. Change-Id: I65847792601b422293d4baed2ccade664ad7e54b
*	Add TC abrupt reboot of initiator node	Nitin Goyal	2019-09-06	1	-0/+26
\| \| \| \| \| \| \|	Add new TC where we verify rediscovery of iscsi paths which happen after abrupt reboot of initiator node. Change-Id: I841e875881c47f8215d48821cd76c0399d43badc
*	Add Error msg in GlusterBlockBaseClass	Nitin Goyal	2019-09-06	1	-9/+21
\| \| \| \| \| \| \|	Added Error msg in GlusterBlockBaseClass for better visibility in case of failures or debugging purpose. Change-Id: Ia92cd6f6129cb5aa55f6f8e807ef056e54691956
*	Correct description of libraries in gluster_ops module	Nitin Goyal	2019-09-06	1	-2/+2
\| \| \| \| \| \|	Changed the description of libraries in gluster_ops where it was wrong. Change-Id: I8ea9ec4ff1f28250d4544d6329b386271cf1e551
*	[Library]: Modification in block volume create with name	Sri Vignesh	2019-09-05	1	-3/+3
\| \| \| \| \| \| \| \|	modification in block volume name parameter passed twice while creating Change-Id: Ieb827a8e7fa40a84eed7f8c5e90760710e6615b2 Signed-off-by: Sri Vignesh <sselvan@redhat.com>
*	Add functionality to create more than 1 DC in parallel	Valerii Ponomarov	2019-09-04	2	-23/+97
\| \| \| \| \| \| \| \|	We have test cases which create more than 1 app DC at once. So, add functionality to be able to create bunch of DCs in parallel and reuse it in one of test cases. Change-Id: Id606d02c31a919bbc6d49d59714dd5628c6a835d
*	Fix pep8 errors in the files of the 'openshift-storage-libs' dir	Valerii Ponomarov	2019-09-03	6	-43/+43
\| \| \| \|	Change-Id: Iaa7deca275958d4de68601dc16d1920f3dab85f2
*	Fix "openshift_storage_version" to get valid version for OCS 3.10 & 3.9	vamahaja	2019-08-28	1	-4/+14
\| \| \| \| \|	Change-Id: Ia0325c4309837fe3f89eab3c066775f9fb1ab1de Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Fix error handling logic in the "vmware" cloud provider	Nitin Goyal	2019-08-27	1	-4/+4
\| \| \| \| \| \| \| \|	Fix error handling logic in the "vmware" cloud provider module by adding "raise" statement in places where it is lost. Change-Id: I92e97da4109bc6ab7368b41d2a6886e9f2be31c1
*	Remove extra '-' from create_secret	Nitin Goyal	2019-08-20	2	-2/+2
\| \| \| \|	Change-Id: I2ebc1c2e7e7aefb5e0d70342a7ec243a12b0663b
*	Fix test cases skipped due to closed bugs	vamahaja	2019-08-19	2	-1/+98
\| \| \| \| \| \| \| \|	Add fix to test cases which are skipped due to bugs - BZ-1644685, BZ-1652913, BZ-1634745, BZ-1635736, BZ-1636477, BZ-1641668 Change-Id: I03a7f7dddaba5d3e41770969352b2263c84cb920 Signed-off-by: vamahaja <vamahaja@redhat.com>
*	Add OCS version check for test cases	vamahaja	2019-08-14	1	-0/+179
\| \| \| \|	Change-Id: I4196cb1395a3720e03f62473d11e5f46d797c355

/* Copyright (c) 2006-2012 Red Hat, Inc. <http://www.redhat.com> 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 _CONFIG_H #define _CONFIG_H #include "config.h" #endif #define __XOPEN_SOURCE 500 #include <openssl/md5.h> #include <stdint.h> #include <sys/time.h> #include <sys/resource.h> #include <errno.h> #include <libgen.h> #include <pthread.h> #include <ftw.h> #include <sys/stat.h> #include <signal.h> #include <sys/uio.h> #ifndef GF_BSD_HOST_OS #include <alloca.h> #endif /* GF_BSD_HOST_OS */ #ifdef HAVE_LINKAT #include <fcntl.h> #endif /* HAVE_LINKAT */ #include "glusterfs.h" #include "checksum.h" #include "dict.h" #include "logging.h" #include "posix.h" #include "xlator.h" #include "defaults.h" #include "common-utils.h" #include "compat-errno.h" #include "compat.h" #include "byte-order.h" #include "syscall.h" #include "statedump.h" #include "locking.h" #include "timer.h" #include "glusterfs3-xdr.h" #include "hashfn.h" #include "posix-aio.h" #include "glusterfs-acl.h" extern char *marker_xattrs[]; #define ALIGN_SIZE 4096 #undef HAVE_SET_FSID #ifdef HAVE_SET_FSID #define DECLARE_OLD_FS_ID_VAR uid_t old_fsuid; gid_t old_fsgid; #define SET_FS_ID(uid, gid) do { \ old_fsuid = setfsuid (uid); \ old_fsgid = setfsgid (gid); \ } while (0) #define SET_TO_OLD_FS_ID() do { \ setfsuid (old_fsuid); \ setfsgid (old_fsgid); \ } while (0) #else #define DECLARE_OLD_FS_ID_VAR #define SET_FS_ID(uid, gid) #define SET_TO_OLD_FS_ID() #endif int posix_forget (xlator_t *this, inode_t *inode) { uint64_t tmp_cache = 0; if (!inode_ctx_del (inode, this, &tmp_cache)) dict_destroy ((dict_t *)(long)tmp_cache); return 0; } /* Regular fops */ int32_t posix_lookup (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { struct iatt buf = {0, }; int32_t op_ret = -1; int32_t entry_ret = 0; int32_t op_errno = 0; dict_t * xattr = NULL; char * real_path = NULL; char * par_path = NULL; struct iatt postparent = {0,}; int32_t gfidless = 0; struct posix_private *priv = NULL; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); priv = this->private; /* The Hidden directory should be for housekeeping purpose and it should not get any gfid on it */ if (__is_root_gfid (loc->pargfid) && loc->name && (strcmp (loc->name, GF_HIDDEN_PATH) == 0)) { gf_log (this->name, GF_LOG_WARNING, "Lookup issued on %s, which is not permitted", GF_HIDDEN_PATH); op_errno = EPERM; op_ret = -1; goto out; } op_ret = dict_get_int32 (xdata, GF_GFIDLESS_LOOKUP, &gfidless); op_ret = -1; if (uuid_is_null (loc->pargfid) || (loc->name == NULL)) { /* nameless lookup */ MAKE_INODE_HANDLE (real_path, this, loc, &buf); } else { MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &buf); if (uuid_is_null (loc->inode->gfid)) { posix_gfid_heal (this, real_path, loc, xdata); MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &buf); } } op_errno = errno; if (op_ret == -1) { if (op_errno != ENOENT) { gf_log (this->name, GF_LOG_ERROR, "lstat on %s failed: %s", real_path, strerror (op_errno)); } entry_ret = -1; goto parent; } if (xdata && (op_ret == 0)) { xattr = posix_lookup_xattr_fill (this, real_path, loc, xdata, &buf); } parent: if (par_path) { op_ret = posix_pstat (this, loc->pargfid, par_path, &postparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "post-operation lstat on parent %s failed: %s", par_path, strerror (op_errno)); if (op_errno == ENOENT) /* If parent directory is missing in a lookup, errno should be ESTALE (bad handle) and not ENOENT (missing entry) */ op_errno = ESTALE; goto out; } } op_ret = entry_ret; out: if (xattr) dict_ref (xattr); if (!op_ret && !gfidless && uuid_is_null (buf.ia_gfid)) { gf_log (this->name, GF_LOG_ERROR, "buf->ia_gfid is null for " "%s", (real_path) ? real_path: ""); op_ret = -1; op_errno = ENODATA; } STACK_UNWIND_STRICT (lookup, frame, op_ret, op_errno, (loc)?loc->inode:NULL, &buf, xattr, &postparent); if (xattr) dict_unref (xattr); return 0; } int32_t posix_stat (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { struct iatt buf = {0,}; int32_t op_ret = -1; int32_t op_errno = 0; struct posix_private *priv = NULL; char *real_path = NULL; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); priv = this->private; VALIDATE_OR_GOTO (priv, out); SET_FS_ID (frame->root->uid, frame->root->gid); MAKE_INODE_HANDLE (real_path, this, loc, &buf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, (op_errno == ENOENT)? GF_LOG_DEBUG:GF_LOG_ERROR, "lstat on %s failed: %s", real_path, strerror (op_errno)); goto out; } op_ret = 0; out: SET_TO_OLD_FS_ID(); STACK_UNWIND_STRICT (stat, frame, op_ret, op_errno, &buf, NULL); return 0; } static int posix_do_chmod (xlator_t *this, const char *path, struct iatt *stbuf) { int32_t ret = -1; mode_t mode = 0; struct stat stat; int is_symlink = 0; ret = sys_lstat (path, &stat); if (ret != 0) { gf_log (this->name, GF_LOG_WARNING, "lstat failed: %s (%s)", path, strerror (errno)); goto out; } if (S_ISLNK (stat.st_mode)) is_symlink = 1; mode = st_mode_from_ia (stbuf->ia_prot, stbuf->ia_type); ret = lchmod (path, mode); if ((ret == -1) && (errno == ENOSYS)) { /* in Linux symlinks are always in mode 0777 and no such call as lchmod exists. */ gf_log (this->name, GF_LOG_DEBUG, "%s (%s)", path, strerror (errno)); if (is_symlink) { ret = 0; goto out; } ret = chmod (path, mode); } out: return ret; } static int posix_do_chown (xlator_t *this, const char *path, struct iatt *stbuf, int32_t valid) { int32_t ret = -1; uid_t uid = -1; gid_t gid = -1; if (valid & GF_SET_ATTR_UID) uid = stbuf->ia_uid; if (valid & GF_SET_ATTR_GID) gid = stbuf->ia_gid; ret = lchown (path, uid, gid); return ret; } static int posix_do_utimes (xlator_t *this, const char *path, struct iatt *stbuf) { int32_t ret = -1; struct timeval tv[2] = {{0,},{0,}}; struct stat stat; int is_symlink = 0; ret = sys_lstat (path, &stat); if (ret != 0) { gf_log (this->name, GF_LOG_WARNING, "%s (%s)", path, strerror (errno)); goto out; } if (S_ISLNK (stat.st_mode)) is_symlink = 1; tv[0].tv_sec = stbuf->ia_atime; tv[0].tv_usec = stbuf->ia_atime_nsec / 1000; tv[1].tv_sec = stbuf->ia_mtime; tv[1].tv_usec = stbuf->ia_mtime_nsec / 1000; ret = lutimes (path, tv); if ((ret == -1) && (errno == ENOSYS)) { gf_log (this->name, GF_LOG_DEBUG, "%s (%s)", path, strerror (errno)); if (is_symlink) { ret = 0; goto out; } ret = utimes (path, tv); } out: return ret; } int posix_setattr (call_frame_t *frame, xlator_t *this, loc_t *loc, struct iatt *stbuf, int32_t valid, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; char * real_path = 0; struct iatt statpre = {0,}; struct iatt statpost = {0,}; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); SET_FS_ID (frame->root->uid, frame->root->gid); MAKE_INODE_HANDLE (real_path, this, loc, &statpre); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "setattr (lstat) on %s failed: %s", real_path, strerror (op_errno)); goto out; } if (valid & (GF_SET_ATTR_UID | GF_SET_ATTR_GID)){ op_ret = posix_do_chown (this, real_path, stbuf, valid); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "setattr (chown) on %s failed: %s", real_path, strerror (op_errno)); goto out; } } if (valid & GF_SET_ATTR_MODE) { op_ret = posix_do_chmod (this, real_path, stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "setattr (chmod) on %s failed: %s", real_path, strerror (op_errno)); goto out; } } if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) { op_ret = posix_do_utimes (this, real_path, stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "setattr (utimes) on %s failed: %s", real_path, strerror (op_errno)); goto out; } } if (!valid) { op_ret = lchown (real_path, -1, -1); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "lchown (%s, -1, -1) failed => (%s)", real_path, strerror (op_errno)); goto out; } } op_ret = posix_pstat (this, loc->gfid, real_path, &statpost); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "setattr (lstat) on %s failed: %s", real_path, strerror (op_errno)); goto out; } op_ret = 0; out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (setattr, frame, op_ret, op_errno, &statpre, &statpost, NULL); return 0; } int32_t posix_do_fchown (xlator_t *this, int fd, struct iatt *stbuf, int32_t valid) { int ret = -1; uid_t uid = -1; gid_t gid = -1; if (valid & GF_SET_ATTR_UID) uid = stbuf->ia_uid; if (valid & GF_SET_ATTR_GID) gid = stbuf->ia_gid; ret = fchown (fd, uid, gid); return ret; } int32_t posix_do_fchmod (xlator_t *this, int fd, struct iatt *stbuf) { mode_t mode = 0; mode = st_mode_from_ia (stbuf->ia_prot, stbuf->ia_type); return fchmod (fd, mode); } static int posix_do_futimes (xlator_t *this, int fd, struct iatt *stbuf) { gf_log (this->name, GF_LOG_WARNING, "function not implemented fd(%d)", fd); errno = ENOSYS; return -1; } int posix_fsetattr (call_frame_t *frame, xlator_t *this, fd_t *fd, struct iatt *stbuf, int32_t valid, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; struct iatt statpre = {0,}; struct iatt statpost = {0,}; struct posix_fd *pfd = NULL; int32_t ret = -1; DECLARE_OLD_FS_ID_VAR; SET_FS_ID (frame->root->uid, frame->root->gid); VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (fd, out); ret = posix_fd_ctx_get (fd, this, &pfd); if (ret < 0) { op_errno = -ret; gf_log (this->name, GF_LOG_DEBUG, "pfd is NULL from fd=%p", fd); goto out; } op_ret = posix_fdstat (this, pfd->fd, &statpre); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "fsetattr (fstat) failed on fd=%p: %s", fd, strerror (op_errno)); goto out; } if (valid & GF_SET_ATTR_MODE) { op_ret = posix_do_fchmod (this, pfd->fd, stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "fsetattr (fchmod) failed on fd=%p: %s", fd, strerror (op_errno)); goto out; } } if (valid & (GF_SET_ATTR_UID | GF_SET_ATTR_GID)) { op_ret = posix_do_fchown (this, pfd->fd, stbuf, valid); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "fsetattr (fchown) failed on fd=%p: %s", fd, strerror (op_errno)); goto out; } } if (valid & (GF_SET_ATTR_ATIME | GF_SET_ATTR_MTIME)) { op_ret = posix_do_futimes (this, pfd->fd, stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "fsetattr (futimes) on failed fd=%p: %s", fd, strerror (op_errno)); goto out; } } if (!valid) { op_ret = fchown (pfd->fd, -1, -1); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "fchown (%d, -1, -1) failed => (%s)", pfd->fd, strerror (op_errno)); goto out; } } op_ret = posix_fdstat (this, pfd->fd, &statpost); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "fsetattr (fstat) failed on fd=%p: %s", fd, strerror (op_errno)); goto out; } op_ret = 0; out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (fsetattr, frame, op_ret, op_errno, &statpre, &statpost, NULL); return 0; } static int32_t posix_do_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t flags, off_t offset, size_t len, struct iatt *statpre, struct iatt *statpost) { struct posix_fd *pfd = NULL; int32_t ret = -1; DECLARE_OLD_FS_ID_VAR; SET_FS_ID (frame->root->uid, frame->root->gid); VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (fd, out); ret = posix_fd_ctx_get (fd, this, &pfd); if (ret < 0) { gf_log (this->name, GF_LOG_DEBUG, "pfd is NULL from fd=%p", fd); goto out; } ret = posix_fdstat (this, pfd->fd, statpre); if (ret == -1) { ret = -errno; gf_log (this->name, GF_LOG_ERROR, "fallocate (fstat) failed on fd=%p: %s", fd, strerror (errno)); goto out; } ret = sys_fallocate(pfd->fd, flags, offset, len); if (ret == -1) { ret = -errno; goto out; } ret = posix_fdstat (this, pfd->fd, statpost); if (ret == -1) { ret = -errno; gf_log (this->name, GF_LOG_ERROR, "fallocate (fstat) failed on fd=%p: %s", fd, strerror (errno)); goto out; } out: SET_TO_OLD_FS_ID (); return ret; } char* _page_aligned_alloc (size_t size, char **aligned_buf) { char *alloc_buf = NULL; char *buf = NULL; alloc_buf = GF_CALLOC (1, (size + ALIGN_SIZE), gf_posix_mt_char); if (!alloc_buf) goto out; /* page aligned buffer */ buf = GF_ALIGN_BUF (alloc_buf, ALIGN_SIZE); *aligned_buf = buf; out: return alloc_buf; } static int32_t _posix_do_zerofill(int fd, off_t offset, off_t len, int o_direct) { off_t num_vect = 0; off_t num_loop = 1; off_t idx = 0; int32_t op_ret = -1; int32_t vect_size = VECTOR_SIZE; off_t remain = 0; off_t extra = 0; struct iovec *vector = NULL; char *iov_base = NULL; char *alloc_buf = NULL; if (len == 0) return 0; if (len < VECTOR_SIZE) vect_size = len; num_vect = len / (vect_size); remain = len % vect_size ; if (num_vect > MAX_NO_VECT) { extra = num_vect % MAX_NO_VECT; num_loop = num_vect / MAX_NO_VECT; num_vect = MAX_NO_VECT; } vector = GF_CALLOC (num_vect, sizeof(struct iovec), gf_common_mt_iovec); if (!vector) return -1; if (o_direct) { alloc_buf = _page_aligned_alloc(vect_size, &iov_base); if (!alloc_buf) { gf_log ("_posix_do_zerofill", GF_LOG_DEBUG, "memory alloc failed, vect_size %d: %s", vect_size, strerror(errno)); GF_FREE(vector); return -1; } } else { iov_base = GF_CALLOC (vect_size, sizeof(char), gf_common_mt_char); if (!iov_base) { GF_FREE(vector); return -1; } } for (idx = 0; idx < num_vect; idx++) { vector[idx].iov_base = iov_base; vector[idx].iov_len = vect_size; } if (lseek(fd, offset, SEEK_SET) < 0) { op_ret = -1; goto err; } for (idx = 0; idx < num_loop; idx++) { op_ret = writev(fd, vector, num_vect); if (op_ret < 0) goto err; } if (extra) { op_ret = writev(fd, vector, extra); if (op_ret < 0) goto err; } if (remain) { vector[0].iov_len = remain; op_ret = writev(fd, vector , 1); if (op_ret < 0) goto err; } err: if (o_direct) GF_FREE(alloc_buf); else GF_FREE(iov_base); GF_FREE(vector); return op_ret; } static int32_t posix_do_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, off_t len, struct iatt *statpre, struct iatt *statpost) { struct posix_fd *pfd = NULL; int32_t ret = -1; DECLARE_OLD_FS_ID_VAR; SET_FS_ID (frame->root->uid, frame->root->gid); VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (fd, out); ret = posix_fd_ctx_get (fd, this, &pfd); if (ret < 0) { gf_log (this->name, GF_LOG_DEBUG, "pfd is NULL from fd=%p", fd); goto out; } ret = posix_fdstat (this, pfd->fd, statpre); if (ret == -1) { ret = -errno; gf_log (this->name, GF_LOG_ERROR, "pre-operation fstat failed on fd = %p: %s", fd, strerror (errno)); goto out; } ret = _posix_do_zerofill(pfd->fd, offset, len, pfd->flags & O_DIRECT); if (ret < 0) { ret = -errno; gf_log(this->name, GF_LOG_ERROR, "zerofill failed on fd %d length %" PRId64 " %s", pfd->fd, len, strerror(errno)); goto out; } if (pfd->flags & (O_SYNC|O_DSYNC)) { ret = fsync (pfd->fd); if (ret) { gf_log (this->name, GF_LOG_ERROR, "fsync() in writev on fd %d failed: %s", pfd->fd, strerror (errno)); ret = -errno; goto out; } } ret = posix_fdstat (this, pfd->fd, statpost); if (ret == -1) { ret = -errno; gf_log (this->name, GF_LOG_ERROR, "post operation fstat failed on fd=%p: %s", fd, strerror (errno)); goto out; } out: SET_TO_OLD_FS_ID (); return ret; } static int32_t _posix_fallocate(call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t keep_size, off_t offset, size_t len, dict_t *xdata) { int32_t ret; int32_t flags = 0; struct iatt statpre = {0,}; struct iatt statpost = {0,}; #ifdef FALLOC_FL_KEEP_SIZE if (keep_size) flags = FALLOC_FL_KEEP_SIZE; #endif /* FALLOC_FL_KEEP_SIZE */ ret = posix_do_fallocate(frame, this, fd, flags, offset, len, &statpre, &statpost); if (ret < 0) goto err; STACK_UNWIND_STRICT(fallocate, frame, 0, 0, &statpre, &statpost, NULL); return 0; err: STACK_UNWIND_STRICT(fallocate, frame, -1, -ret, NULL, NULL, NULL); return 0; } static int32_t posix_discard(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, size_t len, dict_t *xdata) { int32_t ret; #ifndef FALLOC_FL_KEEP_SIZE ret = EOPNOTSUPP; #else /* FALLOC_FL_KEEP_SIZE */ int32_t flags = FALLOC_FL_KEEP_SIZE|FALLOC_FL_PUNCH_HOLE; struct iatt statpre = {0,}; struct iatt statpost = {0,}; ret = posix_do_fallocate(frame, this, fd, flags, offset, len, &statpre, &statpost); if (ret < 0) goto err; STACK_UNWIND_STRICT(discard, frame, 0, 0, &statpre, &statpost, NULL); return 0; err: #endif /* FALLOC_FL_KEEP_SIZE */ STACK_UNWIND_STRICT(discard, frame, -1, -ret, NULL, NULL, NULL); return 0; } static int32_t posix_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset, off_t len, dict_t *xdata) { int32_t ret = 0; struct iatt statpre = {0,}; struct iatt statpost = {0,}; ret = posix_do_zerofill(frame, this, fd, offset, len, &statpre, &statpost); if (ret < 0) goto err; STACK_UNWIND_STRICT(zerofill, frame, 0, 0, &statpre, &statpost, NULL); return 0; err: STACK_UNWIND_STRICT(zerofill, frame, -1, -ret, NULL, NULL, NULL); return 0; } int32_t posix_opendir (call_frame_t *frame, xlator_t *this, loc_t *loc, fd_t *fd, dict_t *xdata) { char * real_path = NULL; int32_t op_ret = -1; int32_t op_errno = EINVAL; DIR * dir = NULL; struct posix_fd * pfd = NULL; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); VALIDATE_OR_GOTO (fd, out); SET_FS_ID (frame->root->uid, frame->root->gid); MAKE_INODE_HANDLE (real_path, this, loc, NULL); op_ret = -1; dir = opendir (real_path); if (dir == NULL) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "opendir failed on %s: %s", real_path, strerror (op_errno)); goto out; } op_ret = dirfd (dir); if (op_ret < 0) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "dirfd() failed on %s: %s", real_path, strerror (op_errno)); goto out; } pfd = GF_CALLOC (1, sizeof (*pfd), gf_posix_mt_posix_fd); if (!pfd) { op_errno = errno; goto out; } pfd->dir = dir; pfd->fd = dirfd (dir); op_ret = fd_ctx_set (fd, this, (uint64_t)(long)pfd); if (op_ret) gf_log (this->name, GF_LOG_WARNING, "failed to set the fd context path=%s fd=%p", real_path, fd); op_ret = 0; out: if (op_ret == -1) { if (dir) { closedir (dir); dir = NULL; } if (pfd) { GF_FREE (pfd); pfd = NULL; } } SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (opendir, frame, op_ret, op_errno, fd, NULL); return 0; } int32_t posix_releasedir (xlator_t *this, fd_t *fd) { struct posix_fd * pfd = NULL; uint64_t tmp_pfd = 0; int ret = 0; struct posix_private *priv = NULL; VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (fd, out); ret = fd_ctx_del (fd, this, &tmp_pfd); if (ret < 0) { gf_log (this->name, GF_LOG_DEBUG, "pfd from fd=%p is NULL", fd); goto out; } pfd = (struct posix_fd *)(long)tmp_pfd; if (!pfd->dir) { gf_log (this->name, GF_LOG_WARNING, "pfd->dir is NULL for fd=%p", fd); goto out; } priv = this->private; pthread_mutex_lock (&priv->janitor_lock); { INIT_LIST_HEAD (&pfd->list); list_add_tail (&pfd->list, &priv->janitor_fds); pthread_cond_signal (&priv->janitor_cond); } pthread_mutex_unlock (&priv->janitor_lock); out: return 0; } int32_t posix_readlink (call_frame_t *frame, xlator_t *this, loc_t *loc, size_t size, dict_t *xdata) { char * dest = NULL; int32_t op_ret = -1; int32_t op_errno = 0; char * real_path = NULL; struct iatt stbuf = {0,}; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); SET_FS_ID (frame->root->uid, frame->root->gid); dest = alloca (size + 1); MAKE_INODE_HANDLE (real_path, this, loc, &stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "lstat on %s failed: %s", real_path, strerror (op_errno)); goto out; } op_ret = sys_readlink (real_path, dest, size); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "readlink on %s failed: %s", real_path, strerror (op_errno)); goto out; } dest[op_ret] = 0; out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (readlink, frame, op_ret, op_errno, dest, &stbuf, NULL); return 0; } int posix_mknod (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, dev_t dev, mode_t umask, dict_t *xdata) { int tmp_fd = 0; int32_t op_ret = -1; int32_t op_errno = 0; char *real_path = 0; char *par_path = 0; struct iatt stbuf = { 0, }; struct posix_private *priv = NULL; gid_t gid = 0; struct iatt preparent = {0,}; struct iatt postparent = {0,}; void * uuid_req = NULL; int32_t nlink_samepgfid = 0; char *pgfid_xattr_key = NULL; gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); priv = this->private; VALIDATE_OR_GOTO (priv, out); MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, NULL); gid = frame->root->gid; SET_FS_ID (frame->root->uid, gid); op_ret = posix_pstat (this, loc->pargfid, par_path, &preparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "pre-operation lstat on parent of %s failed: %s", real_path, strerror (op_errno)); goto out; } if (preparent.ia_prot.sgid) { gid = preparent.ia_gid; } /* Check if the 'gfid' already exists, because this mknod may be an internal call from distribute for creating 'linkfile', and that linkfile may be for a hardlinked file */ if (dict_get (xdata, GLUSTERFS_INTERNAL_FOP_KEY)) { dict_del (xdata, GLUSTERFS_INTERNAL_FOP_KEY); op_ret = dict_get_ptr (xdata, "gfid-req", &uuid_req); if (op_ret) { gf_log (this->name, GF_LOG_DEBUG, "failed to get the gfid from dict for %s", loc->path); goto real_op; } op_ret = posix_create_link_if_gfid_exists (this, uuid_req, real_path); if (!op_ret) goto post_op; } real_op: #ifdef __NetBSD__ if (S_ISFIFO(mode)) op_ret = mkfifo (real_path, mode); else #endif /* __NetBSD__ */ op_ret = mknod (real_path, mode, dev); if (op_ret == -1) { op_errno = errno; if ((op_errno == EINVAL) && S_ISREG (mode)) { /* Over Darwin, mknod with (S_IFREG|mode) doesn't work */ tmp_fd = creat (real_path, mode); if (tmp_fd == -1) { gf_log (this->name, GF_LOG_ERROR, "create failed on %s: %s", real_path, strerror (errno)); goto out; } close (tmp_fd); } else { gf_log (this->name, GF_LOG_ERROR, "mknod on %s failed: %s", real_path, strerror (op_errno)); goto out; } } entry_created = _gf_true; op_ret = posix_gfid_set (this, real_path, loc, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting gfid on %s failed", real_path); } else { gfid_set = _gf_true; } #ifndef HAVE_SET_FSID op_ret = lchown (real_path, frame->root->uid, gid); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "lchown on %s failed: %s", real_path, strerror (op_errno)); goto out; } #endif post_op: op_ret = posix_acl_xattr_set (this, real_path, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting ACLs on %s failed (%s)", real_path, strerror (errno)); } if (priv->update_pgfid_nlinks) { MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, loc->pargfid); nlink_samepgfid = 1; SET_PGFID_XATTR (real_path, pgfid_xattr_key, nlink_samepgfid, XATTR_CREATE, op_ret, this, ignore); } ignore: op_ret = posix_entry_create_xattr_set (this, real_path, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting xattrs on %s failed (%s)", real_path, strerror (errno)); } op_ret = posix_pstat (this, NULL, real_path, &stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "mknod on %s failed: %s", real_path, strerror (op_errno)); goto out; } op_ret = posix_pstat (this, loc->pargfid, par_path, &postparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "post-operation lstat on parent %s failed: %s", par_path, strerror (op_errno)); goto out; } op_ret = 0; out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (mknod, frame, op_ret, op_errno, (loc)?loc->inode:NULL, &stbuf, &preparent, &postparent, NULL); if (op_ret < 0) { if (entry_created) { if (S_ISREG (mode)) sys_unlink (real_path); else sys_rmdir (real_path); } if (gfid_set) posix_gfid_unset (this, xdata); } return 0; } int posix_mkdir (call_frame_t *frame, xlator_t *this, loc_t *loc, mode_t mode, mode_t umask, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; char *real_path = NULL, *gfid_path = NULL; char *par_path = NULL; struct iatt stbuf = {0, }; struct posix_private *priv = NULL; gid_t gid = 0; struct iatt preparent = {0,}; struct iatt postparent = {0,}; gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; void *uuid_req = NULL; ssize_t size = 0; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); /* The Hidden directory should be for housekeeping purpose and it should not get created from a user request */ if (__is_root_gfid (loc->pargfid) && (strcmp (loc->name, GF_HIDDEN_PATH) == 0)) { gf_log (this->name, GF_LOG_WARNING, "mkdir issued on %s, which is not permitted", GF_HIDDEN_PATH); op_errno = EPERM; op_ret = -1; goto out; } priv = this->private; VALIDATE_OR_GOTO (priv, out); MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, NULL); gid = frame->root->gid; op_ret = posix_pstat (this, NULL, real_path, &stbuf); SET_FS_ID (frame->root->uid, gid); op_ret = dict_get_ptr (xdata, "gfid-req", &uuid_req); if (uuid_req && !uuid_is_null (uuid_req)) { op_ret = posix_istat (this, uuid_req, NULL, &stbuf); if ((op_ret == 0) && IA_ISDIR (stbuf.ia_type)) { size = posix_handle_path (this, uuid_req, NULL, NULL, 0); if (size > 0) gfid_path = alloca (size); if (gfid_path) posix_handle_path (this, uuid_req, NULL, gfid_path, size); gf_log (this->name, GF_LOG_WARNING, "mkdir (%s): gfid (%s) is already associated " "with directory (%s). Hence, both directories " "will share same gfid and this can lead to " "inconsistencies.", loc->path, uuid_utoa (uuid_req), gfid_path ? gfid_path : "<NULL>"); } } op_ret = posix_pstat (this, loc->pargfid, par_path, &preparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "pre-operation lstat on parent %s failed: %s", par_path, strerror (op_errno)); goto out; } if (preparent.ia_prot.sgid) { gid = preparent.ia_gid; mode |= S_ISGID; } op_ret = mkdir (real_path, mode); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "mkdir of %s failed: %s", real_path, strerror (op_errno)); goto out; } entry_created = _gf_true; op_ret = posix_gfid_set (this, real_path, loc, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting gfid on %s failed", real_path); } else { gfid_set = _gf_true; } #ifndef HAVE_SET_FSID op_ret = chown (real_path, frame->root->uid, gid); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "chown on %s failed: %s", real_path, strerror (op_errno)); goto out; } #endif op_ret = posix_acl_xattr_set (this, real_path, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting ACLs on %s failed (%s)", real_path, strerror (errno)); } op_ret = posix_entry_create_xattr_set (this, real_path, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting xattrs on %s failed (%s)", real_path, strerror (errno)); } op_ret = posix_pstat (this, NULL, real_path, &stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "lstat on %s failed: %s", real_path, strerror (op_errno)); goto out; } op_ret = posix_pstat (this, loc->pargfid, par_path, &postparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "post-operation lstat on parent of %s failed: %s", real_path, strerror (op_errno)); goto out; } op_ret = 0; out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (mkdir, frame, op_ret, op_errno, (loc)?loc->inode:NULL, &stbuf, &preparent, &postparent, NULL); if (op_ret < 0) { if (entry_created) sys_rmdir (real_path); if (gfid_set) posix_gfid_unset (this, xdata); } return 0; } int32_t posix_unlink_gfid_handle_and_entry (xlator_t *this, const char *real_path, struct iatt *stbuf, int32_t *op_errno) { int32_t ret = 0; /* Unlink the gfid_handle_first */ if (stbuf && stbuf->ia_nlink == 1) { ret = posix_handle_unset (this, stbuf->ia_gfid, NULL); if (ret) { gf_log (this->name, GF_LOG_ERROR, "unlink of gfid handle failed for path:%s with" " gfid %s with errno:%s", real_path, uuid_utoa (stbuf->ia_gfid), strerror (errno)); } } /* Unlink the actual file */ ret = sys_unlink (real_path); if (ret == -1) { if (op_errno) *op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "unlink of %s failed: %s", real_path, strerror (errno)); goto err; } return 0; err: return -1; } int32_t posix_unlink (call_frame_t *frame, xlator_t *this, loc_t *loc, int xflag, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; char *real_path = NULL; char *par_path = NULL; int32_t fd = -1; struct iatt stbuf = {0,}; struct posix_private *priv = NULL; struct iatt preparent = {0,}; struct iatt postparent = {0,}; char *pgfid_xattr_key = NULL; int32_t nlink_samepgfid = 0; int32_t unlink_if_linkto = 0; int32_t check_open_fd = 0; int32_t skip_unlink = 0; ssize_t xattr_size = -1; int32_t is_dht_linkto_file = 0; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); SET_FS_ID (frame->root->uid, frame->root->gid); MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &stbuf); op_ret = posix_pstat (this, loc->pargfid, par_path, &preparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "pre-operation lstat on parent %s failed: %s", par_path, strerror (op_errno)); goto out; } priv = this->private; op_ret = dict_get_int32 (xdata, DHT_SKIP_OPEN_FD_UNLINK, &check_open_fd); if (!op_ret && check_open_fd) { LOCK (&loc->inode->lock); if (loc->inode->fd_count) { skip_unlink = 1; } UNLOCK (&loc->inode->lock); gf_log (this->name, GF_LOG_INFO, "open-fd-key-status: " "%"PRIu32" for %s", skip_unlink, real_path); if (skip_unlink) { op_ret = -1; op_errno = EBUSY; goto out; } } op_ret = dict_get_int32 (xdata, DHT_SKIP_NON_LINKTO_UNLINK, &unlink_if_linkto); if (!op_ret && unlink_if_linkto) { LOCK (&loc->inode->lock); xattr_size = sys_lgetxattr (real_path, LINKTO, NULL, 0); if (xattr_size <= 0) { skip_unlink = 1; } else { is_dht_linkto_file = IS_DHT_LINKFILE_MODE (&stbuf); if (!is_dht_linkto_file) skip_unlink = 1; } UNLOCK (&loc->inode->lock); gf_log (this->name, GF_LOG_INFO, "linkto_xattr status: " "%"PRIu32" for %s", skip_unlink, real_path); if (skip_unlink) { op_ret = -1; op_errno = EBUSY; goto out; } } if (priv->background_unlink) { if (IA_ISREG (loc->inode->ia_type)) { fd = open (real_path, O_RDONLY); if (fd == -1) { op_ret = -1; op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "open of %s failed: %s", real_path, strerror (op_errno)); goto out; } } } if (priv->update_pgfid_nlinks && (stbuf.ia_nlink > 1)) { MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, loc->pargfid); LOCK (&loc->inode->lock); { UNLINK_MODIFY_PGFID_XATTR (real_path, pgfid_xattr_key, nlink_samepgfid, 0, op_ret, this, unlock); } unlock: UNLOCK (&loc->inode->lock); if (op_ret < 0) { gf_log (this->name, GF_LOG_WARNING, "modification of " "parent gfid xattr failed (path:%s gfid:%s)", real_path, uuid_utoa (loc->inode->gfid)); goto out; } } op_ret = posix_unlink_gfid_handle_and_entry (this, real_path, &stbuf, &op_errno); if (op_ret == -1) { goto out; } op_ret = posix_pstat (this, loc->pargfid, par_path, &postparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "post-operation lstat on parent %s failed: %s", par_path, strerror (op_errno)); goto out; } op_ret = 0; out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (unlink, frame, op_ret, op_errno, &preparent, &postparent, NULL); if (fd != -1) { close (fd); } return 0; } int posix_rmdir (call_frame_t *frame, xlator_t *this, loc_t *loc, int flags, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; char * real_path = NULL; char * par_path = NULL; char * gfid_str = NULL; struct iatt preparent = {0,}; struct iatt postparent = {0,}; struct iatt stbuf; struct posix_private *priv = NULL; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); SET_FS_ID (frame->root->uid, frame->root->gid); /* The Hidden directory should be for housekeeping purpose and it should not get deleted from inside process */ if (__is_root_gfid (loc->pargfid) && (strcmp (loc->name, GF_HIDDEN_PATH) == 0)) { gf_log (this->name, GF_LOG_WARNING, "rmdir issued on %s, which is not permitted", GF_HIDDEN_PATH); op_errno = EPERM; op_ret = -1; goto out; } priv = this->private; MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &stbuf); op_ret = posix_pstat (this, loc->pargfid, par_path, &preparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "pre-operation lstat on parent %s failed: %s", par_path, strerror (op_errno)); goto out; } if (flags) { gfid_str = uuid_utoa (stbuf.ia_gfid); char *tmp_path = alloca (strlen (priv->trash_path) + strlen ("/") + strlen (gfid_str) + 1); mkdir (priv->trash_path, 0755); sprintf (tmp_path, "%s/%s", priv->trash_path, gfid_str); op_ret = rename (real_path, tmp_path); } else { op_ret = rmdir (real_path); } op_errno = errno; if (op_ret == 0) { posix_handle_unset (this, stbuf.ia_gfid, NULL); } if (op_errno == EEXIST) /* Solaris sets errno = EEXIST instead of ENOTEMPTY */ op_errno = ENOTEMPTY; /* No need to log a common error as ENOTEMPTY */ if (op_ret == -1 && op_errno != ENOTEMPTY) { gf_log (this->name, GF_LOG_ERROR, "rmdir of %s failed: %s", real_path, strerror (op_errno)); } if (op_ret == -1) { gf_log (this->name, (op_errno == ENOTEMPTY) ? GF_LOG_DEBUG : GF_LOG_ERROR, "%s on %s failed", (flags) ? "rename" : "rmdir", real_path); goto out; } op_ret = posix_pstat (this, loc->pargfid, par_path, &postparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "post-operation lstat on parent of %s failed: %s", par_path, strerror (op_errno)); goto out; } out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (rmdir, frame, op_ret, op_errno, &preparent, &postparent, NULL); return 0; } int posix_symlink (call_frame_t *frame, xlator_t *this, const char *linkname, loc_t *loc, mode_t umask, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; char * real_path = 0; char * par_path = 0; struct iatt stbuf = { 0, }; struct posix_private *priv = NULL; gid_t gid = 0; struct iatt preparent = {0,}; struct iatt postparent = {0,}; char *pgfid_xattr_key = NULL; int32_t nlink_samepgfid = 0; gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (linkname, out); VALIDATE_OR_GOTO (loc, out); priv = this->private; VALIDATE_OR_GOTO (priv, out); MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &stbuf); SET_FS_ID (frame->root->uid, gid); gid = frame->root->gid; op_ret = posix_pstat (this, loc->pargfid, par_path, &preparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "pre-operation lstat on parent %s failed: %s", par_path, strerror (op_errno)); goto out; } if (preparent.ia_prot.sgid) { gid = preparent.ia_gid; } op_ret = symlink (linkname, real_path); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "symlink of %s --> %s failed: %s", real_path, linkname, strerror (op_errno)); goto out; } entry_created = _gf_true; op_ret = posix_gfid_set (this, real_path, loc, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting gfid on %s failed", real_path); } else { gfid_set = _gf_true; } #ifndef HAVE_SET_FSID op_ret = lchown (real_path, frame->root->uid, gid); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "lchown failed on %s: %s", real_path, strerror (op_errno)); goto out; } #endif op_ret = posix_acl_xattr_set (this, real_path, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting ACLs on %s failed (%s)", real_path, strerror (errno)); } if (priv->update_pgfid_nlinks) { MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, loc->pargfid); nlink_samepgfid = 1; SET_PGFID_XATTR (real_path, pgfid_xattr_key, nlink_samepgfid, XATTR_CREATE, op_ret, this, ignore); } ignore: op_ret = posix_entry_create_xattr_set (this, real_path, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting xattrs on %s failed (%s)", real_path, strerror (errno)); } op_ret = posix_pstat (this, NULL, real_path, &stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "lstat failed on %s: %s", real_path, strerror (op_errno)); goto out; } op_ret = posix_pstat (this, loc->pargfid, par_path, &postparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "post-operation lstat on parent %s failed: %s", par_path, strerror (op_errno)); goto out; } op_ret = 0; out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (symlink, frame, op_ret, op_errno, (loc)?loc->inode:NULL, &stbuf, &preparent, &postparent, NULL); if (op_ret < 0) { if (entry_created) sys_unlink (real_path); if (gfid_set) posix_gfid_unset (this, xdata); } return 0; } int posix_rename (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; char *real_oldpath = NULL; char *real_newpath = NULL; char *par_oldpath = NULL; char *par_newpath = NULL; struct iatt stbuf = {0, }; struct posix_private *priv = NULL; char was_present = 1; struct iatt preoldparent = {0, }; struct iatt postoldparent = {0, }; struct iatt prenewparent = {0, }; struct iatt postnewparent = {0, }; char olddirid[64]; char newdirid[64]; uuid_t victim = {0}; int was_dir = 0; int nlink = 0; char *pgfid_xattr_key = NULL; int32_t nlink_samepgfid = 0; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (oldloc, out); VALIDATE_OR_GOTO (newloc, out); priv = this->private; VALIDATE_OR_GOTO (priv, out); SET_FS_ID (frame->root->uid, frame->root->gid); MAKE_ENTRY_HANDLE (real_oldpath, par_oldpath, this, oldloc, NULL); MAKE_ENTRY_HANDLE (real_newpath, par_newpath, this, newloc, &stbuf); op_ret = posix_pstat (this, oldloc->pargfid, par_oldpath, &preoldparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "pre-operation lstat on parent %s failed: %s", par_oldpath, strerror (op_errno)); goto out; } op_ret = posix_pstat (this, newloc->pargfid, par_newpath, &prenewparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "pre-operation lstat on parent of %s failed: %s", par_newpath, strerror (op_errno)); goto out; } op_ret = posix_pstat (this, NULL, real_newpath, &stbuf); if ((op_ret == -1) && (errno == ENOENT)){ was_present = 0; } else { uuid_copy (victim, stbuf.ia_gfid); if (IA_ISDIR (stbuf.ia_type)) was_dir = 1; nlink = stbuf.ia_nlink; } if (was_present && IA_ISDIR(stbuf.ia_type) && !newloc->inode) { gf_log (this->name, GF_LOG_WARNING, "found directory at %s while expecting ENOENT", real_newpath); op_ret = -1; op_errno = EEXIST; goto out; } if (was_present && IA_ISDIR(stbuf.ia_type) && uuid_compare (newloc->inode->gfid, stbuf.ia_gfid)) { gf_log (this->name, GF_LOG_WARNING, "found directory %s at %s while renaming %s", uuid_utoa_r (newloc->inode->gfid, olddirid), real_newpath, uuid_utoa_r (stbuf.ia_gfid, newdirid)); op_ret = -1; op_errno = EEXIST; goto out; } if (IA_ISDIR (oldloc->inode->ia_type)) posix_handle_unset (this, oldloc->inode->gfid, NULL); LOCK (&oldloc->inode->lock); { if (!IA_ISDIR (oldloc->inode->ia_type) && priv->update_pgfid_nlinks) { MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, oldloc->pargfid); UNLINK_MODIFY_PGFID_XATTR (real_oldpath, pgfid_xattr_key, nlink_samepgfid, 0, op_ret, this, unlock); } op_ret = sys_rename (real_oldpath, real_newpath); if (op_ret == -1) { op_errno = errno; gf_log (this->name, (op_errno == ENOTEMPTY ? GF_LOG_DEBUG : GF_LOG_ERROR), "rename of %s to %s failed: %s", real_oldpath, real_newpath, strerror (op_errno)); if (priv->update_pgfid_nlinks && !IA_ISDIR (oldloc->inode->ia_type)) { LINK_MODIFY_PGFID_XATTR (real_oldpath, pgfid_xattr_key, nlink_samepgfid, 0, op_ret, this, unlock); } goto unlock; } if (!IA_ISDIR (oldloc->inode->ia_type) && priv->update_pgfid_nlinks) { MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, newloc->pargfid); LINK_MODIFY_PGFID_XATTR (real_newpath, pgfid_xattr_key, nlink_samepgfid, 0, op_ret, this, unlock); } } unlock: UNLOCK (&oldloc->inode->lock); if (op_ret < 0) { gf_log (this->name, GF_LOG_WARNING, "modification of " "parent gfid xattr failed (gfid:%s)", uuid_utoa (oldloc->inode->gfid)); goto out; } if (was_dir) posix_handle_unset (this, victim, NULL); if (was_present && !was_dir && nlink == 1) posix_handle_unset (this, victim, NULL); if (IA_ISDIR (oldloc->inode->ia_type)) { posix_handle_soft (this, real_newpath, newloc, oldloc->inode->gfid, NULL); } op_ret = posix_pstat (this, NULL, real_newpath, &stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "lstat on %s failed: %s", real_newpath, strerror (op_errno)); goto out; } op_ret = posix_pstat (this, oldloc->pargfid, par_oldpath, &postoldparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "post-operation lstat on parent %s failed: %s", par_oldpath, strerror (op_errno)); goto out; } op_ret = posix_pstat (this, newloc->pargfid, par_newpath, &postnewparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "post-operation lstat on parent %s failed: %s", par_newpath, strerror (op_errno)); goto out; } op_ret = 0; out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (rename, frame, op_ret, op_errno, &stbuf, &preoldparent, &postoldparent, &prenewparent, &postnewparent, NULL); return 0; } int posix_link (call_frame_t *frame, xlator_t *this, loc_t *oldloc, loc_t *newloc, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; char *real_oldpath = 0; char *real_newpath = 0; char *par_newpath = 0; struct iatt stbuf = {0, }; struct posix_private *priv = NULL; struct iatt preparent = {0,}; struct iatt postparent = {0,}; int32_t nlink_samepgfid = 0; char *pgfid_xattr_key = NULL; gf_boolean_t entry_created = _gf_false; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (oldloc, out); VALIDATE_OR_GOTO (newloc, out); priv = this->private; VALIDATE_OR_GOTO (priv, out); SET_FS_ID (frame->root->uid, frame->root->gid); MAKE_INODE_HANDLE (real_oldpath, this, oldloc, &stbuf); MAKE_ENTRY_HANDLE (real_newpath, par_newpath, this, newloc, &stbuf); op_ret = posix_pstat (this, newloc->pargfid, par_newpath, &preparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "lstat failed: %s: %s", par_newpath, strerror (op_errno)); goto out; } op_ret = sys_link (real_oldpath, real_newpath); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "link %s to %s failed: %s", real_oldpath, real_newpath, strerror (op_errno)); goto out; } entry_created = _gf_true; op_ret = posix_pstat (this, NULL, real_newpath, &stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "lstat on %s failed: %s", real_newpath, strerror (op_errno)); goto out; } op_ret = posix_pstat (this, newloc->pargfid, par_newpath, &postparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "lstat failed: %s: %s", par_newpath, strerror (op_errno)); goto out; } if (priv->update_pgfid_nlinks) { MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, newloc->pargfid); LOCK (&newloc->inode->lock); { LINK_MODIFY_PGFID_XATTR (real_newpath, pgfid_xattr_key, nlink_samepgfid, 0, op_ret, this, unlock); } unlock: UNLOCK (&newloc->inode->lock); if (op_ret < 0) { gf_log (this->name, GF_LOG_WARNING, "modification of " "parent gfid xattr failed (path:%s gfid:%s)", real_newpath, uuid_utoa (newloc->inode->gfid)); goto out; } } op_ret = 0; out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (link, frame, op_ret, op_errno, (oldloc)?oldloc->inode:NULL, &stbuf, &preparent, &postparent, NULL); if (op_ret < 0) { if (entry_created) sys_unlink (real_newpath); } return 0; } int32_t posix_truncate (call_frame_t *frame, xlator_t *this, loc_t *loc, off_t offset, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; char *real_path = 0; struct posix_private *priv = NULL; struct iatt prebuf = {0,}; struct iatt postbuf = {0,}; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); priv = this->private; VALIDATE_OR_GOTO (priv, out); SET_FS_ID (frame->root->uid, frame->root->gid); MAKE_INODE_HANDLE (real_path, this, loc, &prebuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "pre-operation lstat on %s failed: %s", real_path, strerror (op_errno)); goto out; } op_ret = truncate (real_path, offset); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "truncate on %s failed: %s", real_path, strerror (op_errno)); goto out; } op_ret = posix_pstat (this, loc->gfid, real_path, &postbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "lstat on %s failed: %s", real_path, strerror (op_errno)); goto out; } op_ret = 0; out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (truncate, frame, op_ret, op_errno, &prebuf, &postbuf, NULL); return 0; } int posix_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) { int32_t op_ret = -1; int32_t op_errno = 0; int32_t _fd = -1; int _flags = 0; char * real_path = NULL; char * par_path = NULL; struct iatt stbuf = {0, }; struct posix_fd * pfd = NULL; struct posix_private * priv = NULL; char was_present = 1; gid_t gid = 0; struct iatt preparent = {0,}; struct iatt postparent = {0,}; int nlink_samepgfid = 0; char * pgfid_xattr_key = NULL; gf_boolean_t entry_created = _gf_false, gfid_set = _gf_false; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (this->private, out); VALIDATE_OR_GOTO (loc, out); VALIDATE_OR_GOTO (fd, out); priv = this->private; VALIDATE_OR_GOTO (priv, out); MAKE_ENTRY_HANDLE (real_path, par_path, this, loc, &stbuf); gid = frame->root->gid; SET_FS_ID (frame->root->uid, gid); op_ret = posix_pstat (this, loc->pargfid, par_path, &preparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "pre-operation lstat on parent %s failed: %s", par_path, strerror (op_errno)); goto out; } if (preparent.ia_prot.sgid) { gid = preparent.ia_gid; } if (!flags) { _flags = O_CREAT | O_RDWR | O_EXCL; } else { _flags = flags | O_CREAT; } op_ret = posix_pstat (this, NULL, real_path, &stbuf); if ((op_ret == -1) && (errno == ENOENT)) { was_present = 0; } if (priv->o_direct) _flags |= O_DIRECT; _fd = open (real_path, _flags, mode); if (_fd == -1) { op_errno = errno; op_ret = -1; gf_log (this->name, GF_LOG_ERROR, "open on %s failed: %s", real_path, strerror (op_errno)); goto out; } if ((_flags & O_CREAT) && (_flags & O_EXCL)) { entry_created = _gf_true; } if (was_present) goto fill_stat; op_ret = posix_gfid_set (this, real_path, loc, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting gfid on %s failed", real_path); } else { gfid_set = _gf_true; } #ifndef HAVE_SET_FSID op_ret = chown (real_path, frame->root->uid, gid); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "chown on %s failed: %s", real_path, strerror (op_errno)); } #endif op_ret = posix_acl_xattr_set (this, real_path, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting ACLs on %s failed (%s)", real_path, strerror (errno)); } if (priv->update_pgfid_nlinks) { MAKE_PGFID_XATTR_KEY (pgfid_xattr_key, PGFID_XATTR_KEY_PREFIX, loc->pargfid); nlink_samepgfid = 1; SET_PGFID_XATTR (real_path, pgfid_xattr_key, nlink_samepgfid, XATTR_CREATE, op_ret, this, ignore); } ignore: op_ret = posix_entry_create_xattr_set (this, real_path, xdata); if (op_ret) { gf_log (this->name, GF_LOG_ERROR, "setting xattrs on %s failed (%s)", real_path, strerror (errno)); } fill_stat: op_ret = posix_fdstat (this, _fd, &stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "fstat on %d failed: %s", _fd, strerror (op_errno)); goto out; } op_ret = posix_pstat (this, loc->pargfid, par_path, &postparent); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "post-operation lstat on parent %s failed: %s", par_path, strerror (op_errno)); goto out; } op_ret = -1; pfd = GF_CALLOC (1, sizeof (*pfd), gf_posix_mt_posix_fd); if (!pfd) { op_errno = errno; goto out; } pfd->flags = flags; pfd->fd = _fd; op_ret = fd_ctx_set (fd, this, (uint64_t)(long)pfd); if (op_ret) gf_log (this->name, GF_LOG_WARNING, "failed to set the fd context path=%s fd=%p", real_path, fd); LOCK (&priv->lock); { priv->nr_files++; } UNLOCK (&priv->lock); op_ret = 0; out: SET_TO_OLD_FS_ID (); if ((-1 == op_ret) && (_fd != -1)) { close (_fd); } STACK_UNWIND_STRICT (create, frame, op_ret, op_errno, fd, (loc)?loc->inode:NULL, &stbuf, &preparent, &postparent, xdata); if (op_ret < 0) { if (entry_created) sys_unlink (real_path); if (gfid_set) posix_gfid_unset (this, xdata); } return 0; } int32_t posix_open (call_frame_t *frame, xlator_t *this, loc_t *loc, int32_t flags, fd_t *fd, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; char *real_path = NULL; int32_t _fd = -1; struct posix_fd *pfd = NULL; struct posix_private *priv = NULL; struct iatt stbuf = {0, }; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (this->private, out); VALIDATE_OR_GOTO (loc, out); VALIDATE_OR_GOTO (fd, out); priv = this->private; VALIDATE_OR_GOTO (priv, out); MAKE_INODE_HANDLE (real_path, this, loc, &stbuf); if (IA_ISLNK (stbuf.ia_type)) { op_ret = -1; op_errno = ELOOP; goto out; } op_ret = -1; SET_FS_ID (frame->root->uid, frame->root->gid); if (priv->o_direct) flags |= O_DIRECT; _fd = open (real_path, flags, 0); if (_fd == -1) { op_ret = -1; op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "open on %s, flags: %d: %s", real_path, flags, strerror (op_errno)); goto out; } pfd = GF_CALLOC (1, sizeof (*pfd), gf_posix_mt_posix_fd); if (!pfd) { op_errno = errno; goto out; } pfd->flags = flags; pfd->fd = _fd; op_ret = fd_ctx_set (fd, this, (uint64_t)(long)pfd); if (op_ret) gf_log (this->name, GF_LOG_WARNING, "failed to set the fd context path=%s fd=%p", real_path, fd); LOCK (&priv->lock); { priv->nr_files++; } UNLOCK (&priv->lock); op_ret = 0; out: if (op_ret == -1) { if (_fd != -1) { close (_fd); } } SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (open, frame, op_ret, op_errno, fd, NULL); return 0; } int posix_readv (call_frame_t *frame, xlator_t *this, fd_t *fd, size_t size, off_t offset, uint32_t flags, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; int _fd = -1; struct posix_private * priv = NULL; struct iobuf * iobuf = NULL; struct iobref * iobref = NULL; struct iovec vec = {0,}; struct posix_fd * pfd = NULL; struct iatt stbuf = {0,}; int ret = -1; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (fd, out); VALIDATE_OR_GOTO (this->private, out); priv = this->private; VALIDATE_OR_GOTO (priv, out); ret = posix_fd_ctx_get (fd, this, &pfd); if (ret < 0) { op_errno = -ret; gf_log (this->name, GF_LOG_WARNING, "pfd is NULL from fd=%p", fd); goto out; } if (!size) { op_errno = EINVAL; gf_log (this->name, GF_LOG_WARNING, "size=%"GF_PRI_SIZET, size); goto out; } iobuf = iobuf_get2 (this->ctx->iobuf_pool, size); if (!iobuf) { op_errno = ENOMEM; goto out; } _fd = pfd->fd; op_ret = pread (_fd, iobuf->ptr, size, offset); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "read failed on fd=%p: %s", fd, strerror (op_errno)); goto out; } LOCK (&priv->lock); { priv->read_value += op_ret; } UNLOCK (&priv->lock); vec.iov_base = iobuf->ptr; vec.iov_len = op_ret; iobref = iobref_new (); iobref_add (iobref, iobuf); /* * readv successful, and we need to get the stat of the file * we read from */ op_ret = posix_fdstat (this, _fd, &stbuf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "fstat failed on fd=%p: %s", fd, strerror (op_errno)); goto out; } /* Hack to notify higher layers of EOF. */ if (!stbuf.ia_size || (offset + vec.iov_len) >= stbuf.ia_size) op_errno = ENOENT; op_ret = vec.iov_len; out: STACK_UNWIND_STRICT (readv, frame, op_ret, op_errno, &vec, 1, &stbuf, iobref, NULL); if (iobref) iobref_unref (iobref); if (iobuf) iobuf_unref (iobuf); return 0; } int32_t __posix_pwritev (int fd, struct iovec *vector, int count, off_t offset) { int32_t op_ret = 0; int idx = 0; int retval = 0; off_t internal_off = 0; if (!vector) return -EFAULT; internal_off = offset; for (idx = 0; idx < count; idx++) { retval = pwrite (fd, vector[idx].iov_base, vector[idx].iov_len, internal_off); if (retval == -1) { op_ret = -errno; goto err; } op_ret += retval; internal_off += retval; } err: return op_ret; } int32_t __posix_writev (int fd, struct iovec *vector, int count, off_t startoff, int odirect) { int32_t op_ret = 0; int idx = 0; int max_buf_size = 0; int retval = 0; char *buf = NULL; char *alloc_buf = NULL; off_t internal_off = 0; /* Check for the O_DIRECT flag during open() */ if (!odirect) return __posix_pwritev (fd, vector, count, startoff); for (idx = 0; idx < count; idx++) { if (max_buf_size < vector[idx].iov_len) max_buf_size = vector[idx].iov_len; } alloc_buf = _page_aligned_alloc (max_buf_size, &buf); if (!alloc_buf) { op_ret = -errno; goto err; } internal_off = startoff; for (idx = 0; idx < count; idx++) { memcpy (buf, vector[idx].iov_base, vector[idx].iov_len); /* not sure whether writev works on O_DIRECT'd fd */ retval = pwrite (fd, buf, vector[idx].iov_len, internal_off); if (retval == -1) { op_ret = -errno; goto err; } op_ret += retval; internal_off += retval; } err: GF_FREE (alloc_buf); return op_ret; } dict_t* _fill_writev_xdata (fd_t *fd, dict_t *xdata, xlator_t *this, int is_append) { dict_t *rsp_xdata = NULL; int32_t ret = 0; inode_t *inode = NULL; if (fd) inode = fd->inode; if (!fd || !fd->inode || uuid_is_null (fd->inode->gfid)) { gf_log_callingfn (this->name, GF_LOG_ERROR, "Invalid Args: " "fd: %p inode: %p gfid:%s", fd, inode?inode:0, inode?uuid_utoa(inode->gfid):"N/A"); goto out; } if (!xdata || !dict_get (xdata, GLUSTERFS_OPEN_FD_COUNT)) goto out; rsp_xdata = dict_new(); if (!rsp_xdata) goto out; ret = dict_set_uint32 (rsp_xdata, GLUSTERFS_OPEN_FD_COUNT, fd->inode->fd_count); if (ret < 0) { gf_log (this->name, GF_LOG_WARNING, "%s: Failed to set " "dictionary value for %s", uuid_utoa (fd->inode->gfid), GLUSTERFS_OPEN_FD_COUNT); } ret = dict_set_uint32 (rsp_xdata, GLUSTERFS_WRITE_IS_APPEND, is_append); if (ret < 0) { gf_log (this->name, GF_LOG_WARNING, "%s: Failed to set " "dictionary value for %s", uuid_utoa (fd->inode->gfid), GLUSTERFS_WRITE_IS_APPEND); } out: return rsp_xdata; } int32_t posix_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) { int32_t op_ret = -1; int32_t op_errno = 0; int _fd = -1; struct posix_private * priv = NULL; struct posix_fd * pfd = NULL; struct iatt preop = {0,}; struct iatt postop = {0,}; int ret = -1; dict_t *rsp_xdata = NULL; int is_append = 0; gf_boolean_t locked = _gf_false; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (fd, out); VALIDATE_OR_GOTO (vector, out); VALIDATE_OR_GOTO (this->private, out); priv = this->private; VALIDATE_OR_GOTO (priv, out); ret = posix_fd_ctx_get (fd, this, &pfd); if (ret < 0) { gf_log (this->name, GF_LOG_WARNING, "pfd is NULL from fd=%p", fd); op_errno = -ret; goto out; } _fd = pfd->fd; if (xdata && dict_get (xdata, GLUSTERFS_WRITE_IS_APPEND)) { /* The write_is_append check and write must happen atomically. Else another write can overtake this write after the check and get written earlier. So lock before preop-stat and unlock after write. */ locked = _gf_true; LOCK(&fd->inode->lock); } op_ret = posix_fdstat (this, _fd, &preop); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "pre-operation fstat failed on fd=%p: %s", fd, strerror (op_errno)); goto out; } if (locked) { if (preop.ia_size == offset || (fd->flags & O_APPEND)) is_append = 1; } op_ret = __posix_writev (_fd, vector, count, offset, (pfd->flags & O_DIRECT)); if (locked) { UNLOCK (&fd->inode->lock); locked = _gf_false; } if (op_ret < 0) { op_errno = -op_ret; op_ret = -1; gf_log (this->name, GF_LOG_ERROR, "write failed: offset %"PRIu64 ", %s", offset, strerror (op_errno)); goto out; } LOCK (&priv->lock); { priv->write_value += op_ret; } UNLOCK (&priv->lock); if (op_ret >= 0) { rsp_xdata = _fill_writev_xdata (fd, xdata, this, is_append); /* wiretv successful, we also need to get the stat of * the file we wrote to */ if (flags & (O_SYNC|O_DSYNC)) { ret = fsync (_fd); if (ret) { gf_log (this->name, GF_LOG_ERROR, "fsync() in writev on fd %d failed: %s", _fd, strerror (errno)); op_ret = -1; op_errno = errno; goto out; } } ret = posix_fdstat (this, _fd, &postop); if (ret == -1) { op_ret = -1; op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "post-operation fstat failed on fd=%p: %s", fd, strerror (op_errno)); goto out; } } out: if (locked) { UNLOCK (&fd->inode->lock); locked = _gf_false; } STACK_UNWIND_STRICT (writev, frame, op_ret, op_errno, &preop, &postop, rsp_xdata); if (rsp_xdata) dict_unref (rsp_xdata); return 0; } int32_t posix_statfs (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *xdata) { char * real_path = NULL; int32_t op_ret = -1; int32_t op_errno = 0; struct statvfs buf = {0, }; struct posix_private * priv = NULL; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); VALIDATE_OR_GOTO (this->private, out); MAKE_INODE_HANDLE (real_path, this, loc, NULL); priv = this->private; op_ret = statvfs (real_path, &buf); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "statvfs failed on %s: %s", real_path, strerror (op_errno)); goto out; } if (!priv->export_statfs) { buf.f_blocks = 0; buf.f_bfree = 0; buf.f_bavail = 0; buf.f_files = 0; buf.f_ffree = 0; buf.f_favail = 0; } op_ret = 0; out: STACK_UNWIND_STRICT (statfs, frame, op_ret, op_errno, &buf, NULL); return 0; } int32_t posix_flush (call_frame_t *frame, xlator_t *this, fd_t *fd, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; int ret = -1; struct posix_fd *pfd = NULL; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (fd, out); ret = posix_fd_ctx_get (fd, this, &pfd); if (ret < 0) { op_errno = -ret; gf_log (this->name, GF_LOG_WARNING, "pfd is NULL on fd=%p", fd); goto out; } op_ret = 0; out: STACK_UNWIND_STRICT (flush, frame, op_ret, op_errno, NULL); return 0; } int32_t posix_release (xlator_t *this, fd_t *fd) { struct posix_private * priv = NULL; struct posix_fd * pfd = NULL; int ret = -1; uint64_t tmp_pfd = 0; VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (fd, out); priv = this->private; ret = fd_ctx_del (fd, this, &tmp_pfd); if (ret < 0) { gf_log (this->name, GF_LOG_WARNING, "pfd is NULL from fd=%p", fd); goto out; } pfd = (struct posix_fd *)(long)tmp_pfd; if (pfd->dir) { gf_log (this->name, GF_LOG_WARNING, "pfd->dir is %p (not NULL) for file fd=%p", pfd->dir, fd); } pthread_mutex_lock (&priv->janitor_lock); { INIT_LIST_HEAD (&pfd->list); list_add_tail (&pfd->list, &priv->janitor_fds); pthread_cond_signal (&priv->janitor_cond); } pthread_mutex_unlock (&priv->janitor_lock); LOCK (&priv->lock); { priv->nr_files--; } UNLOCK (&priv->lock); out: return 0; } int posix_batch_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int datasync, dict_t *xdata) { call_stub_t *stub = NULL; struct posix_private *priv = NULL; priv = this->private; stub = fop_fsync_stub (frame, default_fsync, fd, datasync, xdata); if (!stub) { STACK_UNWIND_STRICT (fsync, frame, -1, ENOMEM, 0, 0, 0); return 0; } pthread_mutex_lock (&priv->fsync_mutex); { list_add_tail (&stub->list, &priv->fsyncs); priv->fsync_queue_count++; pthread_cond_signal (&priv->fsync_cond); } pthread_mutex_unlock (&priv->fsync_mutex); return 0; } int32_t posix_fsync (call_frame_t *frame, xlator_t *this, fd_t *fd, int32_t datasync, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; int _fd = -1; struct posix_fd * pfd = NULL; int ret = -1; struct iatt preop = {0,}; struct iatt postop = {0,}; struct posix_private *priv = NULL; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (fd, out); SET_FS_ID (frame->root->uid, frame->root->gid); #ifdef GF_DARWIN_HOST_OS /* Always return success in case of fsync in MAC OS X */ op_ret = 0; goto out; #endif priv = this->private; if (priv->batch_fsync_mode && xdata && dict_get (xdata, "batch-fsync")) { posix_batch_fsync (frame, this, fd, datasync, xdata); return 0; } ret = posix_fd_ctx_get (fd, this, &pfd); if (ret < 0) { op_errno = -ret; gf_log (this->name, GF_LOG_WARNING, "pfd not found in fd's ctx"); goto out; } _fd = pfd->fd; op_ret = posix_fdstat (this, _fd, &preop); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_WARNING, "pre-operation fstat failed on fd=%p: %s", fd, strerror (op_errno)); goto out; } if (datasync) { op_ret = sys_fdatasync (_fd); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "fdatasync on fd=%p failed: %s", fd, strerror (errno)); goto out; } } else { op_ret = sys_fsync (_fd); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "fsync on fd=%p failed: %s", fd, strerror (op_errno)); goto out; } } op_ret = posix_fdstat (this, _fd, &postop); if (op_ret == -1) { op_errno = errno; gf_log (this->name, GF_LOG_WARNING, "post-operation fstat failed on fd=%p: %s", fd, strerror (op_errno)); goto out; } op_ret = 0; out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (fsync, frame, op_ret, op_errno, &preop, &postop, NULL); return 0; } static int gf_posix_xattr_enotsup_log; static int _handle_setxattr_keyvalue_pair (dict_t *d, char *k, data_t *v, void *tmp) { posix_xattr_filler_t *filler = NULL; filler = tmp; return posix_handle_pair (filler->this, filler->real_path, k, v, filler->flags); } #ifdef GF_DARWIN_HOST_OS static inline int map_xattr_flags(int flags) { /* DARWIN has different defines on XATTR_ flags. There do not seem to be a POSIX standard Parse any other flags over. */ int darwinflags = flags & ~(GF_XATTR_CREATE | GF_XATTR_REPLACE | XATTR_REPLACE); if (GF_XATTR_CREATE & flags) darwinflags |= XATTR_CREATE; if (GF_XATTR_REPLACE & flags) darwinflags |= XATTR_REPLACE; return darwinflags; } #endif int32_t posix_setxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, dict_t *dict, int flags, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = 0; char * real_path = NULL; posix_xattr_filler_t filler = {0,}; DECLARE_OLD_FS_ID_VAR; SET_FS_ID (frame->root->uid, frame->root->gid); VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); VALIDATE_OR_GOTO (dict, out); MAKE_INODE_HANDLE (real_path, this, loc, NULL); op_ret = -1; dict_del (dict, GFID_XATTR_KEY); dict_del (dict, GF_XATTR_VOL_ID_KEY); filler.real_path = real_path; filler.this = this; #ifdef GF_DARWIN_HOST_OS filler.flags = map_xattr_flags(flags); #else filler.flags = flags; #endif op_ret = dict_foreach (dict, _handle_setxattr_keyvalue_pair, &filler); if (op_ret < 0) { op_errno = -op_ret; op_ret = -1; } out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (setxattr, frame, op_ret, op_errno, NULL); return 0; } int posix_xattr_get_real_filename (call_frame_t *frame, xlator_t *this, loc_t *loc, const char *key, dict_t *dict, dict_t *xdata) { char *real_path = NULL; struct dirent *dirent = NULL; DIR *fd = NULL; const char *fname = NULL; char *found = NULL; int ret = -1; int op_ret = -1; MAKE_INODE_HANDLE (real_path, this, loc, NULL); fd = opendir (real_path); if (!fd) return -errno; fname = key + strlen (GF_XATTR_GET_REAL_FILENAME_KEY); while ((dirent = readdir (fd))) { if (strcasecmp (dirent->d_name, fname) == 0) { found = gf_strdup (dirent->d_name); if (!found) { closedir (fd); return -ENOMEM; } break; } } closedir (fd); if (!found) return -ENOENT; ret = dict_set_dynstr (dict, (char *)key, found); if (ret) { GF_FREE (found); return -ENOMEM; } ret = strlen (found) + 1; return ret; } int posix_get_ancestry_directory (xlator_t *this, inode_t *leaf_inode, gf_dirent_t *head, char **path, int type, int32_t *op_errno, dict_t *xdata) { ssize_t handle_size = 0; struct posix_private *priv = NULL; char dirpath[PATH_MAX+1] = {0,}; inode_t *inode = NULL; int ret = -1; priv = this->private; handle_size = POSIX_GFID_HANDLE_SIZE(priv->base_path_length); ret = posix_make_ancestryfromgfid (this, dirpath, PATH_MAX + 1, head, type | POSIX_ANCESTRY_PATH, leaf_inode->gfid, handle_size, priv->base_path, leaf_inode->table, &inode, xdata); if (ret < 0) goto out; /* there is already a reference in loc->inode */ inode_unref (inode); if ((type & POSIX_ANCESTRY_PATH) && (path != NULL)) { if (strcmp (dirpath, "/")) dirpath[strlen (dirpath) - 1] = '\0'; *path = gf_strdup (dirpath); } out: return ret; } int32_t posix_links_in_same_directory (char *dirpath, int count, inode_t *leaf_inode, inode_t *parent, uint64_t ino, gf_dirent_t *head, char **path, int type, dict_t *xdata, int32_t *op_errno) { DIR *dirp = NULL; int op_ret = -1; struct dirent *entry = NULL; struct dirent *result = NULL; inode_t *linked_inode = NULL; gf_dirent_t *gf_entry = NULL; char temppath[PATH_MAX+1] = {0,}; xlator_t *this = NULL; struct posix_private *priv = NULL; char *tempv = NULL; this = THIS; priv = this->private; dirp = opendir (dirpath); if (!dirp) { *op_errno = errno; gf_log (this->name, GF_LOG_WARNING, "could not opendir %s: %s", dirpath, strerror (*op_errno)); goto out; } entry = alloca (offsetof(struct dirent, d_name) + NAME_MAX + 1); if (entry == NULL) goto out; while (count > 0) { *op_errno = readdir_r (dirp, entry, &result); if ((result == NULL) || *op_errno) break; if (entry->d_ino != ino) continue; linked_inode = inode_link (leaf_inode, parent, entry->d_name, NULL); GF_ASSERT (linked_inode == leaf_inode); inode_unref (linked_inode); if (type & POSIX_ANCESTRY_DENTRY) { loc_t loc = {0, }; loc.inode = inode_ref (leaf_inode); uuid_copy (loc.gfid, leaf_inode->gfid); strcpy (temppath, dirpath); strcat (temppath, "/"); strcat (temppath, entry->d_name); gf_entry = gf_dirent_for_name (entry->d_name); gf_entry->inode = inode_ref (leaf_inode); gf_entry->dict = posix_lookup_xattr_fill (this, temppath, &loc, xdata, NULL); list_add_tail (&gf_entry->list, &head->list); loc_wipe (&loc); } if (type & POSIX_ANCESTRY_PATH) { strcpy (temppath, &dirpath[priv->base_path_length]); strcat (temppath, "/"); strcat (temppath, entry->d_name); if (!*path) { *path = gf_strdup (temppath); } else { /* creating a colon separated */ /* list of hard links */ tempv = GF_REALLOC (*path, strlen (*path) + 1 // ':' + strlen (temppath) + 1 ); if (!tempv) { gf_log (this->name, GF_LOG_WARNING, "realloc failed on path"); GF_FREE (*path); op_ret = -1; *op_errno = ENOMEM; goto out; } *path = tempv; strcat (*path, ":"); strcat (*path, temppath); } } count--; } out: if (dirp) { op_ret = closedir (dirp); if (op_ret == -1) { *op_errno = errno; gf_log (this->name, GF_LOG_WARNING, "closedir failed: %s", strerror (*op_errno)); } } return op_ret; } int posix_get_ancestry_non_directory (xlator_t *this, inode_t *leaf_inode, gf_dirent_t *head, char **path, int type, int32_t *op_errno, dict_t *xdata) { size_t remaining_size = 0; char dirpath[PATH_MAX+1] = {0,}, *leaf_path = NULL; int op_ret = -1, pathlen = -1; ssize_t handle_size = 0; char pgfidstr[UUID_CANONICAL_FORM_LEN+1] = {0,}; uuid_t pgfid = {0, }; int nlink_samepgfid = 0; struct stat stbuf = {0,}; char *list = NULL; int32_t list_offset = 0; char key[4096] = {0,}; struct posix_private *priv = NULL; ssize_t size = 0; inode_t *parent = NULL; loc_t *loc = NULL; priv = this->private; loc = GF_CALLOC (1, sizeof (*loc), gf_posix_mt_char); if (loc == NULL) { op_ret = -1; *op_errno = ENOMEM; goto out; } uuid_copy (loc->gfid, leaf_inode->gfid); MAKE_INODE_HANDLE (leaf_path, this, loc, NULL); GF_FREE (loc); size = sys_llistxattr (leaf_path, NULL, 0); if (size == -1) { *op_errno = errno; if ((errno == ENOTSUP) || (errno == ENOSYS)) { GF_LOG_OCCASIONALLY (gf_posix_xattr_enotsup_log, this->name, GF_LOG_WARNING, "Extended attributes not " "supported (try remounting brick" " with 'user_xattr' flag)"); } else { gf_log (this->name, GF_LOG_WARNING, "listxattr failed on %s: %s", leaf_path, strerror (*op_errno)); } goto out; } if (size == 0) { op_ret = 0; goto out; } list = alloca (size); if (!list) { *op_errno = errno; goto out; } size = sys_llistxattr (leaf_path, list, size); if (size < 0) { op_ret = -1; *op_errno = errno; goto out; } remaining_size = size; list_offset = 0; op_ret = sys_lstat (leaf_path, &stbuf); if (op_ret == -1) { *op_errno = errno; gf_log (this->name, GF_LOG_WARNING, "lstat failed" " on %s: %s", leaf_path, strerror (*op_errno)); goto out; } while (remaining_size > 0) { strcpy (key, list + list_offset); if (strncmp (key, PGFID_XATTR_KEY_PREFIX, strlen (PGFID_XATTR_KEY_PREFIX)) != 0) goto next; op_ret = sys_lgetxattr (leaf_path, key, &nlink_samepgfid, sizeof(nlink_samepgfid)); if (op_ret == -1) { *op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "getxattr failed on " "%s: key = %s (%s)", leaf_path, key, strerror (*op_errno)); goto out; } nlink_samepgfid = ntoh32 (nlink_samepgfid); strcpy (pgfidstr, key + strlen(PGFID_XATTR_KEY_PREFIX)); uuid_parse (pgfidstr, pgfid); handle_size = POSIX_GFID_HANDLE_SIZE(priv->base_path_length); /* constructing the absolute real path of parent dir */ strcpy (dirpath, priv->base_path); pathlen = PATH_MAX + 1 - priv->base_path_length; op_ret = posix_make_ancestryfromgfid (this, dirpath + priv->base_path_length, pathlen, head, type | POSIX_ANCESTRY_PATH, pgfid, handle_size, priv->base_path, leaf_inode->table, &parent, xdata); if (op_ret < 0) { goto next; } dirpath[strlen (dirpath) - 1] = '\0'; posix_links_in_same_directory (dirpath, nlink_samepgfid, leaf_inode, parent, stbuf.st_ino, head, path, type, xdata, op_errno); if (parent != NULL) { inode_unref (parent); parent = NULL; } next: remaining_size -= strlen (key) + 1; list_offset += strlen (key) + 1; } /* while (remaining_size > 0) */ op_ret = 0; out: return op_ret; } int posix_get_ancestry (xlator_t *this, inode_t *leaf_inode, gf_dirent_t *head, char **path, int type, int32_t *op_errno, dict_t *xdata) { int ret = -1; struct posix_private *priv = NULL; priv = this->private; if (!priv->update_pgfid_nlinks) goto out; if (IA_ISDIR (leaf_inode->ia_type)) { ret = posix_get_ancestry_directory (this, leaf_inode, head, path, type, op_errno, xdata); } else { ret = posix_get_ancestry_non_directory (this, leaf_inode, head, path, type, op_errno, xdata); } out: return ret; } /** * posix_getxattr - this function returns a dictionary with all the * key:value pair present as xattr. used for * both 'listxattr' and 'getxattr'. */ int32_t posix_getxattr (call_frame_t *frame, xlator_t *this, loc_t *loc, const char *name, dict_t *xdata) { struct posix_private *priv = NULL; int32_t op_ret = -1; int32_t op_errno = 0; char host_buf[1024] = {0,}; char *value = NULL; char *real_path = NULL; dict_t *dict = NULL; char *file_contents = NULL; int ret = -1; char *path = NULL; char *rpath = NULL; char *dyn_rpath = NULL; ssize_t size = 0; char *list = NULL; int32_t list_offset = 0; size_t remaining_size = 0; char keybuffer[4096] = {0,}; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (loc, out); SET_FS_ID (frame->root->uid, frame->root->gid); MAKE_INODE_HANDLE (real_path, this, loc, NULL); op_ret = -1; priv = this->private; if (loc->inode && IA_ISDIR(loc->inode->ia_type) && name && ZR_FILE_CONTENT_REQUEST(name)) { ret = posix_get_file_contents (this, loc->gfid, &name[15], &file_contents); if (ret < 0) { op_errno = -ret; gf_log (this->name, GF_LOG_ERROR, "getting file contents failed: %s", strerror (op_errno)); goto out; } } dict = dict_new (); if (!dict) { op_errno = ENOMEM; goto out; } if (loc->inode && name && (strncmp (name, GF_XATTR_GET_REAL_FILENAME_KEY, strlen (GF_XATTR_GET_REAL_FILENAME_KEY)) == 0)) { ret = posix_xattr_get_real_filename (frame, this, loc, name, dict, xdata); if (ret < 0) { op_ret = -1; op_errno = -ret; gf_log (this->name, (op_errno == ENOENT) ? GF_LOG_DEBUG : GF_LOG_WARNING, "Failed to get real filename (%s, %s): %s", loc->path, name, strerror (op_errno)); goto out; } size = ret; goto done; } if (loc->inode && name && !strcmp (name, GLUSTERFS_OPEN_FD_COUNT)) { if (!list_empty (&loc->inode->fd_list)) { ret = dict_set_uint32 (dict, (char *)name, 1); if (ret < 0) gf_log (this->name, GF_LOG_WARNING, "Failed to set dictionary value for %s", name); } else { ret = dict_set_uint32 (dict, (char *)name, 0); if (ret < 0) gf_log (this->name, GF_LOG_WARNING, "Failed to set dictionary value for %s", name); } goto done; } if (loc->inode && name && (XATTR_IS_PATHINFO (name))) { if (LOC_HAS_ABSPATH (loc)) MAKE_REAL_PATH (rpath, this, loc->path); else rpath = real_path; (void) snprintf (host_buf, 1024, "<POSIX(%s):%s:%s>", priv->base_path, ((priv->node_uuid_pathinfo && !uuid_is_null(priv->glusterd_uuid)) ? uuid_utoa (priv->glusterd_uuid) : priv->hostname), rpath); dyn_rpath = gf_strdup (host_buf); if (!dyn_rpath) { ret = -1; goto done; } size = strlen (dyn_rpath) + 1; ret = dict_set_dynstr (dict, (char *)name, dyn_rpath); if (ret < 0) { gf_log (this->name, GF_LOG_WARNING, "could not set value (%s) in dictionary", dyn_rpath); GF_FREE (dyn_rpath); } goto done; } if (loc->inode && name && (strcmp (name, GF_XATTR_NODE_UUID_KEY) == 0) && !uuid_is_null (priv->glusterd_uuid)) { (void) snprintf (host_buf, 1024, "%s", uuid_utoa (priv->glusterd_uuid)); dyn_rpath = gf_strdup (host_buf); if (!dyn_rpath) { ret = -1; goto done; } size = strlen (dyn_rpath) + 1; ret = dict_set_dynstr (dict, GF_XATTR_NODE_UUID_KEY, dyn_rpath); if (ret < 0) { gf_log (this->name, GF_LOG_WARNING, "could not set value (%s) in dictionary", dyn_rpath); GF_FREE (dyn_rpath); } goto done; } if (loc->inode && name && (strcmp (name, GFID_TO_PATH_KEY) == 0)) { ret = inode_path (loc->inode, NULL, &path); if (ret < 0) { gf_log (this->name, GF_LOG_WARNING, "%s: could not get " "inode path", uuid_utoa (loc->inode->gfid)); goto done; } ret = dict_set_dynstr (dict, GFID_TO_PATH_KEY, path); if (ret < 0) { gf_log (this->name, GF_LOG_WARNING, "could not set value (%s) in dictionary", host_buf); GF_FREE (path); } goto done; } if (loc->inode && name && (strcmp (name, GET_ANCESTRY_PATH_KEY) == 0)) { int type = POSIX_ANCESTRY_PATH; op_ret = posix_get_ancestry (this, loc->inode, NULL, &path, type, &op_errno, xdata); if (op_ret < 0) { op_ret = -1; op_errno = ENODATA; goto out; } op_ret = dict_set_dynstr (dict, GET_ANCESTRY_PATH_KEY, path); if (op_ret < 0) { gf_log (this->name, GF_LOG_WARNING, "could not get " "value for key (%s)", GET_ANCESTRY_PATH_KEY); GF_FREE (path); op_errno = -op_ret; op_ret = -1; } goto done; } if (name) { strcpy (keybuffer, name); char *key = keybuffer; #if defined(GF_DARWIN_HOST_OS_DISABLED) if (priv->xattr_user_namespace == XATTR_STRIP) { if (strncmp(key, "user.",5) == 0) { key += 5; gf_log (this->name, GF_LOG_DEBUG, "getxattr for file %s" " stripping user key: %s -> %s", real_path, keybuffer, key); } } #endif size = sys_lgetxattr (real_path, key, NULL, 0); if (size == -1) { op_errno = errno; if ((op_errno == ENOTSUP) || (op_errno == ENOSYS)) { GF_LOG_OCCASIONALLY (gf_posix_xattr_enotsup_log, this->name, GF_LOG_WARNING, "Extended attributes not " "supported (try remounting" " brick with 'user_xattr' " "flag)"); } else if (op_errno == ENOATTR || op_errno == ENODATA) { gf_log (this->name, GF_LOG_DEBUG, "No such attribute:%s for file %s", key, real_path); } else { gf_log (this->name, GF_LOG_ERROR, "getxattr failed on %s: %s (%s)", real_path, key, strerror (op_errno)); } goto done; } value = GF_CALLOC (size + 1, sizeof(char), gf_posix_mt_char); if (!value) { op_ret = -1; op_errno = ENOMEM; goto out; } size = sys_lgetxattr (real_path, key, value, size); if (size == -1) { op_ret = -1; op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "getxattr failed on " "%s: key = %s (%s)", real_path, key, strerror (op_errno)); GF_FREE (value); goto out; } value [size] = '\0'; op_ret = dict_set_dynptr (dict, key, value, size); if (op_ret < 0) { op_errno = -op_ret; gf_log (this->name, GF_LOG_ERROR, "dict set operation " "on %s for the key %s failed.", real_path, key); GF_FREE (value); goto out; } goto done; } size = sys_llistxattr (real_path, NULL, 0); if (size == -1) { op_errno = errno; if ((errno == ENOTSUP) || (errno == ENOSYS)) { GF_LOG_OCCASIONALLY (gf_posix_xattr_enotsup_log, this->name, GF_LOG_WARNING, "Extended attributes not " "supported (try remounting" " brick with 'user_xattr' " "flag)"); } else { gf_log (this->name, GF_LOG_ERROR, "listxattr failed on %s: %s", real_path, strerror (op_errno)); } goto out; } if (size == 0) goto done; list = alloca (size); if (!list) { op_errno = errno; goto out; } size = sys_llistxattr (real_path, list, size); if (size < 0) { op_ret = -1; op_errno = errno; goto out; } remaining_size = size; list_offset = 0; while (remaining_size > 0) { strcpy (keybuffer, list + list_offset); size = sys_lgetxattr (real_path, keybuffer, NULL, 0); if (size == -1) { op_ret = -1; op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "getxattr failed on " "%s: key = %s (%s)", real_path, keybuffer, strerror (op_errno)); break; } value = GF_CALLOC (size + 1, sizeof(char), gf_posix_mt_char); if (!value) { op_errno = errno; goto out; } size = sys_lgetxattr (real_path, keybuffer, value, size); if (size == -1) { op_ret = -1; op_errno = errno; gf_log (this->name, GF_LOG_ERROR, "getxattr failed on " "%s: key = %s (%s)", real_path, keybuffer, strerror (op_errno)); GF_FREE (value); break; } value [size] = '\0'; #ifdef GF_DARWIN_HOST_OS /* The protocol expect namespace for now */ char *newkey = NULL; gf_add_prefix (XATTR_USER_PREFIX, keybuffer, &newkey); strcpy (keybuffer, newkey); GF_FREE (newkey); #endif op_ret = dict_set_dynptr (dict, keybuffer, value, size); if (op_ret < 0) { op_errno = -op_ret; gf_log (this->name, GF_LOG_ERROR, "dict set operation " "on %s for the key %s failed.", real_path, keybuffer); GF_FREE (value); goto out; } remaining_size -= strlen (keybuffer) + 1; list_offset += strlen (keybuffer) + 1; } /* while (remaining_size > 0) */ done: op_ret = size; if (dict) { dict_del (dict, GFID_XATTR_KEY); dict_del (dict, GF_XATTR_VOL_ID_KEY); } out: SET_TO_OLD_FS_ID (); STACK_UNWIND_STRICT (getxattr, frame, op_ret, op_errno, dict, NULL); if (dict) { dict_unref (dict); } return 0; } int32_t posix_fgetxattr (call_frame_t *frame, xlator_t *this, fd_t *fd, const char *name, dict_t *xdata) { int32_t op_ret = -1; int32_t op_errno = ENOENT; struct posix_fd * pfd = NULL; int _fd = -1; int32_t list_offset = 0; ssize_t size = 0; size_t remaining_size = 0; char key[4096] = {0,}; char * value = NULL; char * list = NULL; dict_t * dict = NULL; int ret = -1; DECLARE_OLD_FS_ID_VAR; VALIDATE_OR_GOTO (frame, out); VALIDATE_OR_GOTO (this, out); VALIDATE_OR_GOTO (fd, out); SET_FS_ID (frame->root->uid, frame->root->gid); ret = posix_fd_ctx_get (fd, this, &pfd); if (ret < 0) { op_errno = -ret; gf_log (this->name, GF_LOG_WARNING, "pfd is NULL from fd=%p", fd); goto out; } _fd = pfd->fd; /* Get the total size */ dict = get_new_dict (); if (!dict) { goto out; } if (name && !strcmp (name, GLUSTERFS_OPEN_FD_COUNT)) { ret = dict_set_uint32 (dict, (ch