From 8d55c25f158921b508bff0e7f25158991913f922 Mon Sep 17 00:00:00 2001 From: Pranith Kumar K Date: Wed, 11 Dec 2013 09:33:53 +0530 Subject: syncop: Change return value of syncop Problem: We found a day-1 bug when syncop_xxx() infra is used inside a synctask with compilation optimization (CFLAGS -O2). Detailed explanation of the Root cause: We found the bug in 'gf_defrag_migrate_data' in rebalance operation: Lets look at interesting parts of the function: int gf_defrag_migrate_data (xlator_t *this, gf_defrag_info_t *defrag, loc_t *loc, dict_t *migrate_data) { ..... code section - [ Loop ] while ((ret = syncop_readdirp (this, fd, 131072, offset, NULL, &entries)) != 0) { ..... code section - [ ERRNO-1 ] (errno of readdirp is stored in readdir_operrno by a thread) /* Need to keep track of ENOENT errno, that means, there is no need to send more readdirp() */ readdir_operrno = errno; ..... code section - [ SYNCOP-1 ] (syncop_getxattr is called by a thread) ret = syncop_getxattr (this, &entry_loc, &dict, GF_XATTR_LINKINFO_KEY); code section - [ ERRNO-2] (checking for failures of syncop_getxattr(). This may not always be executed in same thread which executed [SYNCOP-1]) if (ret < 0) { if (errno != ENODATA) { loglevel = GF_LOG_ERROR; defrag->total_failures += 1; ..... } the function above could be executed by thread(t1) till [SYNCOP-1] and code from [ERRNO-2] can be executed by a different thread(t2) because of the way syncop-infra schedules the tasks. when the code is compiled with -O2 optimization this is the assembly code that is generated: [ERRNO-1] 1165 readdir_operrno = errno; <<---- errno gets expanded as *(__errno_location()) 0x00007fd149d48b60 <+496>: callq 0x7fd149d410c0 0x00007fd149d48b72 <+514>: mov %rax,0x50(%rsp) <<------ Address returned by __errno_location() is stored in a special location in stack for later use. 0x00007fd149d48b77 <+519>: mov (%rax),%eax 0x00007fd149d48b79 <+521>: mov %eax,0x78(%rsp) .... [ERRNO-2] 1281 if (errno != ENODATA) { 0x00007fd149d492ae <+2366>: mov 0x50(%rsp),%rax <<----- Because it already stored the address returned by __errno_location(), it just dereferences the address to get the errno value. BUT THIS CODE NEED NOT BE EXECUTED BY SAME THREAD!!! 0x00007fd149d492b3 <+2371>: mov $0x9,%ebp 0x00007fd149d492b8 <+2376>: mov (%rax),%edi 0x00007fd149d492ba <+2378>: cmp $0x3d,%edi The problem is that __errno_location() value of t1 and t2 are different. So [ERRNO-2] ends up reading errno of t1 instead of errno of t2 even though t2 is executing [ERRNO-2] code section. When code is compiled without any optimization for [ERRNO-2]: 1281 if (errno != ENODATA) { 0x00007fd58e7a326f <+2237>: callq 0x7fd58e797300 <<--- As it is calling __errno_location() again it gets the location from t2 so it works as intended. 0x00007fd58e7a3274 <+2242>: mov (%rax),%eax 0x00007fd58e7a3276 <+2244>: cmp $0x3d,%eax 0x00007fd58e7a3279 <+2247>: je 0x7fd58e7a32a1 Fix: Make syncop_xxx() return (-errno) value as the return value in case of errors and all the functions which make syncop_xxx() will need to use (-ret) to figure out the reason for failure in case of syncop_xxx() failures. Change-Id: I314d20dabe55d3e62ff66f3b4adb1cac2eaebb57 BUG: 1040356 Signed-off-by: Pranith Kumar K Reviewed-on: http://review.gluster.org/6475 Tested-by: Gluster Build System Reviewed-by: Anand Avati --- api/src/glfs-handleops.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'api/src/glfs-handleops.c') diff --git a/api/src/glfs-handleops.c b/api/src/glfs-handleops.c index 0f996d3a2..5bba38b5f 100644 --- a/api/src/glfs-handleops.c +++ b/api/src/glfs-handleops.c @@ -152,6 +152,7 @@ glfs_h_stat (struct glfs *fs, struct glfs_object *object, struct stat *stat) /* fop/op */ ret = syncop_stat (subvol, &loc, &iatt); + DECODE_SYNCOP_ERR (ret); /* populate out args */ if (!ret && stat) { @@ -258,6 +259,7 @@ glfs_h_setattrs (struct glfs *fs, struct glfs_object *object, struct stat *stat, /* fop/op */ ret = syncop_setattr (subvol, &loc, &iatt, glvalid, 0, 0); + DECODE_SYNCOP_ERR (ret); out: loc_wipe (&loc); @@ -331,6 +333,7 @@ glfs_h_open (struct glfs *fs, struct glfs_object *object, int flags) /* fop/op */ ret = syncop_open (subvol, &loc, flags, glfd->fd); + DECODE_SYNCOP_ERR (ret); out: loc_wipe (&loc); @@ -420,6 +423,7 @@ glfs_h_creat (struct glfs *fs, struct glfs_object *parent, const char *path, /* fop/op */ ret = syncop_create (subvol, &loc, flags, mode, glfd->fd, xattr_req, &iatt); + DECODE_SYNCOP_ERR (ret); /* populate out args */ if (ret == 0) { @@ -518,6 +522,7 @@ glfs_h_mkdir (struct glfs *fs, struct glfs_object *parent, const char *path, /* fop/op */ ret = syncop_mkdir (subvol, &loc, mode, xattr_req, &iatt); + DECODE_SYNCOP_ERR (ret); /* populate out args */ if ( ret == 0 ) { @@ -606,6 +611,7 @@ glfs_h_mknod (struct glfs *fs, struct glfs_object *parent, const char *path, /* fop/op */ ret = syncop_mknod (subvol, &loc, mode, dev, xattr_req, &iatt); + DECODE_SYNCOP_ERR (ret); /* populate out args */ if (ret == 0) { @@ -676,11 +682,13 @@ glfs_h_unlink (struct glfs *fs, struct glfs_object *parent, const char *path) if (!IA_ISDIR(loc.inode->ia_type)) { ret = syncop_unlink (subvol, &loc); + DECODE_SYNCOP_ERR (ret); if (ret != 0) { goto out; } } else { ret = syncop_rmdir (subvol, &loc, 0); + DECODE_SYNCOP_ERR (ret); if (ret != 0) { goto out; } @@ -755,6 +763,7 @@ glfs_h_opendir (struct glfs *fs, struct glfs_object *object) /* fop/op */ ret = syncop_opendir (subvol, &loc, glfd->fd); + DECODE_SYNCOP_ERR (ret); out: loc_wipe (&loc); @@ -846,6 +855,7 @@ glfs_h_create_from_handle (struct glfs *fs, unsigned char *handle, int len, } ret = syncop_lookup (subvol, &loc, 0, &iatt, 0, 0); + DECODE_SYNCOP_ERR (ret); if (ret) { gf_log (subvol->name, GF_LOG_WARNING, "inode refresh of %s failed: %s", @@ -934,6 +944,7 @@ glfs_h_truncate (struct glfs *fs, struct glfs_object *object, off_t offset) /* fop/op */ ret = syncop_truncate (subvol, &loc, (off_t)offset); + DECODE_SYNCOP_ERR (ret); /* populate out args */ if (ret == 0) @@ -1006,6 +1017,7 @@ glfs_h_symlink (struct glfs *fs, struct glfs_object *parent, const char *name, /* fop/op */ ret = syncop_symlink (subvol, &loc, data, xattr_req, &iatt); + DECODE_SYNCOP_ERR (ret); /* populate out args */ if (ret == 0) { @@ -1081,6 +1093,7 @@ glfs_h_readlink (struct glfs *fs, struct glfs_object *object, char *buf, /* fop/op */ ret = syncop_readlink (subvol, &loc, &linkval, bufsiz); + DECODE_SYNCOP_ERR (ret); /* populate out args */ if (ret > 0) @@ -1166,6 +1179,7 @@ glfs_h_link (struct glfs *fs, struct glfs_object *linksrc, /* fop/op */ ret = syncop_link (subvol, &oldloc, &newloc); + DECODE_SYNCOP_ERR (ret); if (ret == 0) /* TODO: No iatt to pass as there has been no lookup */ @@ -1256,6 +1270,7 @@ glfs_h_rename (struct glfs *fs, struct glfs_object *olddir, const char *oldname, /* TODO: check if new or old is a prefix of the other, and fail EINVAL */ ret = syncop_rename (subvol, &oldloc, &newloc); + DECODE_SYNCOP_ERR (ret); if (ret == 0) inode_rename (oldloc.parent->table, oldloc.parent, oldloc.name, -- cgit