glusterfs: zerofill support

Add support for a new ZEROFILL fop. Zerofill writes zeroes to a file in
the specified range. This fop will be useful when a whole file needs to
be initialized with zero (could be useful for zero filled VM disk image
provisioning or  during scrubbing of VM disk images).

Client/application can issue this FOP for zeroing out. Gluster server
will zero out required range of bytes ie server offloaded zeroing. In
the absence of this fop,  client/application has to repetitively issue
write (zero) fop to the server, which is very inefficient method because
of the overheads involved in RPC calls  and acknowledgements.

WRITESAME is a  SCSI T10 command that takes a block of data as input and
writes the same data to other blocks and this write is handled
completely within the storage and hence is known as offload . Linux ,now
has support for SCSI WRITESAME command which is exposed to the user in
the form of BLKZEROOUT ioctl.  BD Xlator can exploit BLKZEROOUT ioctl to
implement this fop. Thus zeroing out operations can be completely
offloaded to the storage device , making it highly efficient.

The fop takes two arguments offset and size. It zeroes out 'size' number
of bytes in an opened file starting from 'offset' position.

This patch adds zerofill support to the following areas:
	- libglusterfs
	- io-stats
	- performance/md-cache,open-behind
	- quota
	- cluster/afr,dht,stripe
	- rpc/xdr
	- protocol/client,server
	- io-threads
	- marker
	- storage/posix
	- libgfapi

Client applications can exloit this fop by using glfs_zerofill introduced in
libgfapi.FUSE support to this fop has not been added as there is no system call
for this fop.

Changes from previous version 3:
* Removed redundant memory failure log messages

Changes from previous version 2:
* Rebased and fixed build error

Changes from previous version 1:
* Rebased for latest master

TODO :
     * Add zerofill support to trace xlator
     * Expose zerofill capability as part of gluster volume info

Here is a performance comparison of server offloaded zeofill vs zeroing
out using repeated writes.

[root@llmvm02 remote]# time ./offloaded aakash-test log 20

real	3m34.155s
user	0m0.018s
sys	0m0.040s
[root@llmvm02 remote]# time ./manually aakash-test log 20

real	4m23.043s
user	0m2.197s
sys	0m14.457s
[root@llmvm02 remote]# time ./offloaded aakash-test log 25;

real	4m28.363s
user	0m0.021s
sys	0m0.025s
[root@llmvm02 remote]# time ./manually aakash-test log 25

real	5m34.278s
user	0m2.957s
sys	0m18.808s

The argument log is a file which we want to set for logging purpose and
the third argument is size in GB .

As we can see there is a performance improvement of around 20% with this
fop.

Change-Id: I081159f5f7edde0ddb78169fb4c21c776ec91a18
BUG: 1028673
Signed-off-by: Aakash Lal Das <aakash@linux.vnet.ibm.com>
Signed-off-by: M. Mohan Kumar <mohan@in.ibm.com>
Reviewed-on: http://review.gluster.org/5327
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Vijay Bellur <vbellur@redhat.com>

2 files changed, 186 insertions, 16 deletions

diff --git a/xlators/storage/posix/src/posix.c b/xlators/storage/posix/src/posix.c
index 93ece2474f9..fb45c7a6746 100644
--- a/xlators/storage/posix/src/posix.c
+++ b/xlators/storage/posix/src/posix.c
@@ -24,6 +24,7 @@
 #include <ftw.h>
 #include <sys/stat.h>
 #include <signal.h>
+#include <sys/uio.h>
 
 #ifndef GF_BSD_HOST_OS
 #include <alloca.h>
@@ -616,6 +617,166 @@ out:
         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, size_t len, int o_direct)
+{
+        size_t              num_vect            = 0;
+        int32_t             num_loop            = 1;
+        int32_t             idx                 = 0;
+        int32_t             op_ret              = -1;
+        int32_t             vect_size           = VECTOR_SIZE;
+        size_t              remain              = 0;
+        size_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;
+        }
+        lseek(fd, offset, SEEK_SET);
+        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, 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,
+                        "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 %ld %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)
@@ -664,6 +825,28 @@ err:
 
 }
 
+static int32_t
+posix_zerofill(call_frame_t *frame, xlator_t *this, fd_t *fd, off_t offset,
+                size_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)
@@ -2117,22 +2300,6 @@ err:
         return op_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;
-}
-
 int32_t
 __posix_writev (int fd, struct iovec *vector, int count, off_t startoff,
                 int odirect)
@@ -4938,6 +5105,7 @@ struct xlator_fops fops = {
         .fsetattr    = posix_fsetattr,
 	.fallocate   = _posix_fallocate,
 	.discard     = posix_discard,
+        .zerofill    = posix_zerofill,
 };
 
 struct xlator_cbks cbks = {
diff --git a/xlators/storage/posix/src/posix.h b/xlators/storage/posix/src/posix.h
index a957e18768c..3121db2717e 100644
--- a/xlators/storage/posix/src/posix.h
+++ b/xlators/storage/posix/src/posix.h
@@ -50,6 +50,8 @@
 #include "posix-aio.h"
 #endif
 
+#define VECTOR_SIZE 64 * 1024 /* vector size 64KB*/
+#define MAX_NO_VECT 1024
 /**
  * posix_fd - internal structure common to file and directory fd's
  */