fs: add fcntl() interface for setting/getting write life time hints

Define a set of write life time hints:

RWH_WRITE_LIFE_NOT_SET	No hint information set
RWH_WRITE_LIFE_NONE	No hints about write life time
RWH_WRITE_LIFE_SHORT	Data written has a short life time
RWH_WRITE_LIFE_MEDIUM	Data written has a medium life time
RWH_WRITE_LIFE_LONG	Data written has a long life time
RWH_WRITE_LIFE_EXTREME	Data written has an extremely long life time

The intent is for these values to be relative to each other, no
absolute meaning should be attached to these flag names.

Add an fcntl interface for querying these flags, and also for
setting them as well:

F_GET_RW_HINT		Returns the read/write hint set on the
			underlying inode.

F_SET_RW_HINT		Set one of the above write hints on the
			underlying inode.

F_GET_FILE_RW_HINT	Returns the read/write hint set on the
			file descriptor.

F_SET_FILE_RW_HINT	Set one of the above write hints on the
			file descriptor.

The user passes in a 64-bit pointer to get/set these values, and
the interface returns 0/-1 on success/error.

Sample program testing/implementing basic setting/getting of write
hints is below.

Add support for storing the write life time hint in the inode flags
and in struct file as well, and pass them to the kiocb flags. If
both a file and its corresponding inode has a write hint, then we
use the one in the file, if available. The file hint can be used
for sync/direct IO, for buffered writeback only the inode hint
is available.

This is in preparation for utilizing these hints in the block layer,
to guide on-media data placement.

/*
 * writehint.c: get or set an inode write hint
 */
 #include <stdio.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <stdbool.h>
 #include <inttypes.h>

 #ifndef F_GET_RW_HINT
 #define F_LINUX_SPECIFIC_BASE	1024
 #define F_GET_RW_HINT		(F_LINUX_SPECIFIC_BASE + 11)
 #define F_SET_RW_HINT		(F_LINUX_SPECIFIC_BASE + 12)
 #endif

static char *str[] = { "RWF_WRITE_LIFE_NOT_SET", "RWH_WRITE_LIFE_NONE",
			"RWH_WRITE_LIFE_SHORT", "RWH_WRITE_LIFE_MEDIUM",
			"RWH_WRITE_LIFE_LONG", "RWH_WRITE_LIFE_EXTREME" };

int main(int argc, char *argv[])
{
	uint64_t hint;
	int fd, ret;

	if (argc < 2) {
		fprintf(stderr, "%s: file <hint>\n", argv[0]);
		return 1;
	}

	fd = open(argv[1], O_RDONLY);
	if (fd < 0) {
		perror("open");
		return 2;
	}

	if (argc > 2) {
		hint = atoi(argv[2]);
		ret = fcntl(fd, F_SET_RW_HINT, &hint);
		if (ret < 0) {
			perror("fcntl: F_SET_RW_HINT");
			return 4;
		}
	}

	ret = fcntl(fd, F_GET_RW_HINT, &hint);
	if (ret < 0) {
		perror("fcntl: F_GET_RW_HINT");
		return 3;
	}

	printf("%s: hint %s\n", argv[1], str[hint]);
	close(fd);
	return 0;
}

Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

1 files changed, 62 insertions, 0 deletions

diff --git a/fs/fcntl.c b/fs/fcntl.c
index f4e7267d117f..67bdc6e8ccad 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -243,6 +243,62 @@ static int f_getowner_uids(struct file *filp, unsigned long arg)
 }
 #endif
 
+static bool rw_hint_valid(enum rw_hint hint)
+{
+        switch (hint) {
+        case RWF_WRITE_LIFE_NOT_SET:
+        case RWH_WRITE_LIFE_NONE:
+        case RWH_WRITE_LIFE_SHORT:
+        case RWH_WRITE_LIFE_MEDIUM:
+        case RWH_WRITE_LIFE_LONG:
+        case RWH_WRITE_LIFE_EXTREME:
+                return true;
+        default:
+                return false;
+        }
+}
+
+static long fcntl_rw_hint(struct file *file, unsigned int cmd,
+                          unsigned long arg)
+{
+        struct inode *inode = file_inode(file);
+        u64 *argp = (u64 __user *)arg;
+        enum rw_hint hint;
+
+        switch (cmd) {
+        case F_GET_FILE_RW_HINT:
+                if (put_user(file_write_hint(file), argp))
+                        return -EFAULT;
+                return 0;
+        case F_SET_FILE_RW_HINT:
+                if (get_user(hint, argp))
+                        return -EFAULT;
+                if (!rw_hint_valid(hint))
+                        return -EINVAL;
+
+                spin_lock(&file->f_lock);
+                file->f_write_hint = hint;
+                spin_unlock(&file->f_lock);
+                return 0;
+        case F_GET_RW_HINT:
+                if (put_user(inode->i_write_hint, argp))
+                        return -EFAULT;
+                return 0;
+        case F_SET_RW_HINT:
+                if (get_user(hint, argp))
+                        return -EFAULT;
+                if (!rw_hint_valid(hint))
+                        return -EINVAL;
+
+                inode_lock(inode);
+                inode->i_write_hint = hint;
+                inode_unlock(inode);
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
 static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
                 struct file *filp)
 {
@@ -337,6 +393,12 @@ static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
         case F_GET_SEALS:
                 err = shmem_fcntl(filp, cmd, arg);
                 break;
+        case F_GET_RW_HINT:
+        case F_SET_RW_HINT:
+        case F_GET_FILE_RW_HINT:
+        case F_SET_FILE_RW_HINT:
+                err = fcntl_rw_hint(filp, cmd, arg);
+                break;
         default:
                 break;
         }