Add discard support to the block_aio driver

This commit enables discard for images accessed using block_aio:
- For discard support, the image must be stored on a filesystem that supports
  hole punching. To determine this, there is a whitelist in
  util.c:is_hole_punching_supported_for_fd(), that filters based on the
  kernel version and filesystem.
- Discard request are handled as synchronous hole punches into the image.

This commit has been dev-tested using:
* v8 Windows PV drivers that include XenDisk and thereby implement discard
* Linux xen-blkfront that implements discard

Signed-off-by: Robert Breker <robert.breker@citrix.com>

Author: Robert Breker

drivers/block-aio.c

@@ -28,6 +28,7 @@
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <linux/fs.h>
+#include <linux/falloc.h>
 
 #include "tapdisk.h"
 #include "tapdisk-driver.h"
@@ -82,6 +83,11 @@ static int tdaio_get_image_info(int fd, td_disk_info_t *info)
 		/*Local file? try fstat instead*/
 		info->size = (stat.st_size >> SECTOR_SHIFT);
 		info->sector_size = DEFAULT_SECTOR_SIZE;
+
+		if(is_hole_punching_supported_for_fd(fd)) {
+			info->discard_supported = true;
+		}
+
 		DPRINTF("Image size: \n\tpre sector_shift  [%llu]\n\tpost "
 			"sector_shift [%llu]\n",
 			(long long unsigned)(info->size << SECTOR_SHIFT),
@@ -212,6 +218,33 @@ void tdaio_queue_write(td_driver_t *driver, td_request_t treq)
 	td_complete_request(treq, -EBUSY);
 }
 
+void tdaio_discard(td_driver_t *driver, td_request_t treq)
+{
+        int rc;
+        off64_t size;
+        off64_t offset;
+        struct tdaio_state *prv;
+
+        if (driver->info.discard_supported != true) {
+                td_complete_request(treq, -EOPNOTSUPP);
+                return;
+        }
+
+        prv     = (struct tdaio_state *)driver->data;
+        size    = treq.vreq->discard_nr_sectors * driver->info.sector_size;
+        offset  = treq.vreq->sec * driver->info.sector_size;
+
+        rc = fallocate64(prv->fd, (FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE), offset, size);
+        // Upper layers will retry on EINTR
+
+        // ToDo: Remove the following debug statement after feeling confident
+        DPRINTF("fallocate64(%d, %d, %" PRIu64 ", %" PRIu64 ") returned %d", prv->fd,
+                (FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE), offset, size, rc);
+
+        td_complete_request(treq, rc);
+        return;
+}
+
 int tdaio_close(td_driver_t *driver)
 {
 	struct tdaio_state *prv = (struct tdaio_state *)driver->data;
@@ -253,6 +286,7 @@ struct tap_disk tapdisk_aio = {
 	.td_close           = tdaio_close,
 	.td_queue_read      = tdaio_queue_read,
 	.td_queue_write     = tdaio_queue_write,
+	.td_queue_discard   = tdaio_discard,
 	.td_get_parent_id   = tdaio_get_parent_id,
 	.td_validate_parent = tdaio_validate_parent,
 	.td_debug           = NULL,

drivers/tapdisk-utils.c

@@ -25,11 +25,13 @@
 #include <string.h>
 #include <unistd.h>
 #include <linux/fs.h>
+#include <linux/magic.h>
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <sys/ioctl.h>
 #include <sys/resource.h>
 #include <sys/utsname.h>
+#include <sys/vfs.h>
 #include <arpa/inet.h>
 
 #ifdef __linux__
@@ -431,3 +433,39 @@ inline long long timeval_to_us(struct timeval *tv)
 {
 	return ((long long)tv->tv_sec * USEC_PER_SEC) + tv->tv_usec;
 }
+
+bool is_hole_punching_supported_for_fd(int fd) {
+        int rc;
+        int kernel_version;
+        struct statfs statfs_buf;
+
+        rc = fstatfs(fd, &statfs_buf);
+        if (rc)
+                return false;
+        kernel_version = tapdisk_linux_version();
+        if (-ENOSYS == kernel_version)
+                return false;
+
+        // Support matrix according to man fallocate(2)
+        switch (statfs_buf.f_type) {
+#ifdef BTRFS_SUPER_MAGIC
+                case BTRFS_SUPER_MAGIC:
+                        return (kernel_version >= KERNEL_VERSION(3, 7, 0));
+#endif
+#ifdef EXT4_SUPER_MAGIC
+                case EXT4_SUPER_MAGIC:
+                        return (kernel_version >= KERNEL_VERSION(3, 0, 0));
+#endif
+#ifdef TMPFS_SUPER_MAGIC
+                case TMPFS_SUPER_MAGIC:
+                        return (kernel_version >= KERNEL_VERSION(3, 5, 0));
+#endif
+#ifdef XFS_SUPER_MAGIC
+                case XFS_SUPER_MAGIC:
+                        return (kernel_version >= KERNEL_VERSION(2, 6, 38));
+#endif
+                default:
+                        break;
+        }
+        return false;
+}

drivers/tapdisk-utils.h

@@ -19,6 +19,7 @@
 #define _TAPDISK_UTILS_H_
 
 #include <inttypes.h>
+#include <stdbool.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -89,4 +90,10 @@ shm_destroy(struct shm *shm);
 
 inline long long timeval_to_us(struct timeval *tv);
 
+/**
+ * Returns true if the filesystem that hosts the specified path is known to
+ * allow hole punching and thereby discard.
+ */
+bool is_hole_punching_supported_for_fd(int fd);
+
 #endif