[PATCH] Add fallocate_keep_size option and functionality

[PATCH] Add fallocate_keep_size option and functionality

[Eric Gouriou]

Linux offers fallocate() and the FALLOC_FL_KEEP_SIZE option as
an alternative to posix_fallocate(). When FALLOC_FL_KEEP_SIZE is
specified for an falloc request going beyond the end of the file,
the requested blocks get preallocated without changing the apparent
size of the file. This is is a commonly recommended use of fallocate()
for workloads performing append writes.

On systems where FALLOC_FL_KEEP_SIZE is available (i.e., Linux at this
time), this patch add a fallocate_keep_size option, which is off by
default. When *both* the options fallocate and fallocate_keep_size are
set, then fallocate() will be used with FALLOC_FL_KEEP_SIZE set,
instead of the default posix_fallocate().

Signed-off-by: Eric Gouriou <egouriou@google.com>
---
I tried to follow the existing style and practices. I am wondering
whether introducing 'fallocate_keep_size' is the best way, or whether
I should have changed the existing 'fallocate' option from a boolean
option to a string option. Let me know what you think.

Regards - Eric
---
 HOWTO         |   12 +++++++++---
 filesetup.c   |   36 +++++++++++++++++++++++++++++-------
 fio.1         |   14 +++++++++++---
 fio.h         |    1 +
 helpers.c     |    5 +++++
 options.c     |   11 ++++++++++-
 os/os-linux.h |    1 +
 7 files changed, 66 insertions(+), 14 deletions(-)

diff --git a/HOWTO b/HOWTO
index 69b8cc6..eb3bb9c 100644
--- a/HOWTO
+++ b/HOWTO
@@ -354,12 +354,18 @@ use_os_rand=bool Fio can either use the random generator supplied by the OS
 		internal generator, which is often of better quality and
 		faster.
 
-fallocate=bool	By default, fio will use fallocate() to advise the system
-		of the size of the file we are going to write. This can be
-		turned off with fallocate=0. May not be available on all
+fallocate=bool	By default, fio will use posix_fallocate() to advise the
+		system of the size of the file we are going to write. This can
+		be turned off with fallocate=0. May not be available on all
 		supported platforms.  If using ZFS on Solaris this must be
 		set to 0 because ZFS doesn't support it.
 
+fallocate_keep_size=bool	If this option and the fallocate option are
+		both set, fio will invoke the Linux-specific fallocate()
+		system call with the option FALLOC_FL_KEEP_SIZE, rather than
+		posix_fallocate(). This is only available on Linux.
+		Default: false.
+
 fadvise_hint=bool By default, fio will use fadvise() to advise the kernel
 		on what IO patterns it is likely to issue. Sometimes you
 		want to test specific IO patterns without telling the
diff --git a/filesetup.c b/filesetup.c
index 799202f..ac49237 100644
--- a/filesetup.c
+++ b/filesetup.c
@@ -13,6 +13,10 @@
 #include "filehash.h"
 #include "os/os.h"
 
+#ifdef FIO_HAVE_LINUX_FALLOCATE
+#include <linux/falloc.h>
+#endif
+
 static int root_warn;
 
 static inline void clear_error(struct thread_data *td)
@@ -68,16 +72,34 @@ static int extend_file(struct thread_data *td, struct fio_file *f)
 
 #ifdef FIO_HAVE_FALLOCATE
 	if (td->o.fallocate && !td->o.fill_device) {
-		dprint(FD_FILE, "fallocate file %s size %llu\n", f->file_name,
-							f->real_file_size);
-
-		r = posix_fallocate(f->fd, 0, f->real_file_size);
-		if (r > 0) {
-			log_err("fio: posix_fallocate fails: %s\n",
-					strerror(r));
+		int use_posix_fallocate = 1;
+#ifdef FIO_HAVE_LINUX_FALLOCATE
+		if (td->o.fallocate_keep_size) {
+			use_posix_fallocate = 0;
+			dprint(FD_FILE,
+				"fallocate(FALLOC_FL_KEEP_SIZE) "
+				"file %s size %llu\n",
+				f->file_name, f->real_file_size);
+
+			r = fallocate(f->fd, FALLOC_FL_KEEP_SIZE, 0,
+					f->real_file_size);
+			if (r != 0) {
+				td_verror(td, errno, "fallocate");
+			}
+		}
+#endif /* FIO_HAVE_LINUX_FALLOCATE */
+		if (use_posix_fallocate) {
+			dprint(FD_FILE, "fallocate file %s size %llu\n",
+				 f->file_name, f->real_file_size);
+
+			r = posix_fallocate(f->fd, 0, f->real_file_size);
+			if (r > 0) {
+				log_err("fio: posix_fallocate fails: %s\n",
+						strerror(r));
+			}
 		}
 	}
-#endif
+#endif /* FIO_HAVE_FALLOCATE */
 
 	if (!new_layout)
 		goto done;
diff --git a/fio.1 b/fio.1
index 0ced604..5d55e05 100644
--- a/fio.1
+++ b/fio.1
@@ -221,9 +221,17 @@ Default is to use the internal generator, which is often of better quality and
 faster. Default: false.
 .TP
 .BI fallocate \fR=\fPbool
-By default, fio will use fallocate() to advise the system of the size of the
-file we are going to write. This can be turned off with fallocate=0. May not
-be available on all supported platforms.
+By default, fio will use posix_fallocate() to advise the
+system of the size of the file we are going to write. This can
+be turned off with fallocate=0. May not be available on all
+supported platforms.  If using ZFS on Solaris this must be
+set to 0 because ZFS doesn't support it.
+.TP
+.BI fallocate_keep_size \fR=\fPbool
+If this option and the fallocate option are
+both set, fio will invoke the Linux-specific fallocate()
+system call with the option FALLOC_FL_KEEP_SIZE, rather than
+posix_fallocate(). This is only available on Linux. Default: false.
 .TP
 .BI fadvise_hint \fR=\fPbool
 Disable use of \fIposix_fadvise\fR\|(2) to advise the kernel what I/O patterns
diff --git a/fio.h b/fio.h
index 6ad186f..5ee3961 100644
--- a/fio.h
+++ b/fio.h
@@ -249,6 +249,7 @@ struct thread_options {
 	unsigned int group_reporting;
 	unsigned int fadvise_hint;
 	unsigned int fallocate;
+	unsigned int fallocate_keep_size;
 	unsigned int zero_buffers;
 	unsigned int refill_buffers;
 	unsigned int time_based;
diff --git a/helpers.c b/helpers.c
index 377dd02..0da2fd7 100644
--- a/helpers.c
+++ b/helpers.c
@@ -14,6 +14,11 @@ int __weak posix_fallocate(int fd, off_t offset, off_t len)
 {
 	return 0;
 }
+
+int __weak fallocate(int fd, int mode, off_t offset, off_t len)
+{
+	return 0;
+}
 #endif
 
 int __weak inet_aton(const char *cp, struct in_addr *inp)
diff --git a/options.c b/options.c
index a9b0534..b340477 100644
--- a/options.c
+++ b/options.c
@@ -1180,10 +1180,19 @@ static struct fio_option options[FIO_MAX_OPTS] = {
 		.name	= "fallocate",
 		.type	= FIO_OPT_BOOL,
 		.off1	= td_var_offset(fallocate),
-		.help	= "Use fallocate() when laying out files",
+		.help	= "Use posix_fallocate() or fallocate() when laying out files",
 		.def	= "1",
 	},
 #endif
+#ifdef FIO_HAVE_LINUX_FALLOCATE
+	{
+		.name	= "fallocate_keep_size",
+		.type	= FIO_OPT_BOOL,
+		.off1	= td_var_offset(fallocate_keep_size),
+		.help	= "Use the FALLOC_FL_KEEP_SIZE mode if fallocate() is invoked",
+		.def	= "0",
+	},
+#endif
 	{
 		.name	= "fadvise_hint",
 		.type	= FIO_OPT_BOOL,
diff --git a/os/os-linux.h b/os/os-linux.h
index 70c993b..024ef89 100644
--- a/os/os-linux.h
+++ b/os/os-linux.h
@@ -32,6 +32,7 @@
 #define FIO_HAVE_BLKTRACE
 #define FIO_HAVE_STRSEP
 #define FIO_HAVE_FALLOCATE
+#define FIO_HAVE_LINUX_FALLOCATE
 #define FIO_HAVE_POSIXAIO_FSYNC
 #define FIO_HAVE_PSHARED_MUTEX
 #define FIO_HAVE_CL_SIZE
-- 
1.7.3.1

Re: [PATCH] Add fallocate_keep_size option and functionality

[Jens Axboe]

On 2011-06-14 21:40, Eric Gouriou wrote:
> Linux offers fallocate() and the FALLOC_FL_KEEP_SIZE option as
> an alternative to posix_fallocate(). When FALLOC_FL_KEEP_SIZE is
> specified for an falloc request going beyond the end of the file,
> the requested blocks get preallocated without changing the apparent
> size of the file. This is is a commonly recommended use of fallocate()
> for workloads performing append writes.
> 
> On systems where FALLOC_FL_KEEP_SIZE is available (i.e., Linux at this
> time), this patch add a fallocate_keep_size option, which is off by
> default. When *both* the options fallocate and fallocate_keep_size are
> set, then fallocate() will be used with FALLOC_FL_KEEP_SIZE set,
> instead of the default posix_fallocate().
> 
> Signed-off-by: Eric Gouriou <egouriou@google.com>
> ---
> I tried to follow the existing style and practices. I am wondering
> whether introducing 'fallocate_keep_size' is the best way, or whether
> I should have changed the existing 'fallocate' option from a boolean
> option to a string option. Let me know what you think.

Perhaps we could use just the one option, and have 0/1 retain they
meaning and add "keep" or something as the new variant. Other than that,
just one comment:

> diff --git a/helpers.c b/helpers.c
> index 377dd02..0da2fd7 100644
> --- a/helpers.c
> +++ b/helpers.c
> @@ -14,6 +14,11 @@ int __weak posix_fallocate(int fd, off_t offset, off_t len)
>  {
>  	return 0;
>  }
> +
> +int __weak fallocate(int fd, int mode, off_t offset, off_t len)
> +{
> +	return 0;
> +}
>  #endif

Say we have posix_fallocate() and not fallocate(), have it call
posix_fallocate()?

-- 
Jens Axboe

Re: [PATCH] Add fallocate_keep_size option and functionality

[Eric Gouriou]

Hi Jens,

On Tue, Jun 14, 2011 at 12:58 PM, Jens Axboe <axboe@kernel.dk> wrote:
> On 2011-06-14 21:40, Eric Gouriou wrote:
>> Linux offers fallocate() and the FALLOC_FL_KEEP_SIZE option as
>> an alternative to posix_fallocate(). When FALLOC_FL_KEEP_SIZE is
>> specified for an falloc request going beyond the end of the file,
>> the requested blocks get preallocated without changing the apparent
>> size of the file. This is is a commonly recommended use of fallocate()
>> for workloads performing append writes.
>>
>> On systems where FALLOC_FL_KEEP_SIZE is available (i.e., Linux at this
>> time), this patch add a fallocate_keep_size option, which is off by
>> default. When *both* the options fallocate and fallocate_keep_size are
>> set, then fallocate() will be used with FALLOC_FL_KEEP_SIZE set,
>> instead of the default posix_fallocate().
>>
>> Signed-off-by: Eric Gouriou <egouriou@google.com>
>> ---
>> I tried to follow the existing style and practices. I am wondering
>> whether introducing 'fallocate_keep_size' is the best way, or whether
>> I should have changed the existing 'fallocate' option from a boolean
>> option to a string option. Let me know what you think.
>
> Perhaps we could use just the one option, and have 0/1 retain they
> meaning and add "keep" or something as the new variant.

Certainly. Please check my assumptions: the suggestion is to change
"fallocate" to use FIO_OPT_STR with .posval values of "0", "1",
and "keep".

If so, do you suggest that all options should be presented to all platforms,
or have "keep" only show up when FIO_HAVE_LINUX_FALLOCATE is present?
- if I always have "keep" available, what do you suggest we do when
 FIO_HAVE_LINUX_FALLOCATE is not defined? Fail in a verify_xxx()
 callback?
- if we only have "keep" available on when FIO_HAVE_LINUX_FALLOCATE
  is defined, then other platforms have, in effect, a boolean flag which does
  not behave as the other boolean flags when given invalid values.

There is nothing major here, I'm mostly looking for stylistic/idiom preferences.

> Other than that, just one comment:
>
>> diff --git a/helpers.c b/helpers.c
>> index 377dd02..0da2fd7 100644
>> --- a/helpers.c
>> +++ b/helpers.c
>> @@ -14,6 +14,11 @@ int __weak posix_fallocate(int fd, off_t offset, off_t len)
>>  {
>>       return 0;
>>  }
>> +
>> +int __weak fallocate(int fd, int mode, off_t offset, off_t len)
>> +{
>> +     return 0;
>> +}
>>  #endif
>
> Say we have posix_fallocate() and not fallocate(), have it call
> posix_fallocate()?

Thanks for highlighting this part of the code. While adding this, I was unsure
about whether it was at all useful. Currently the only use of the linux-specific
fallocate() is with the FALLOC_FL_KEEP_SIZE flag, Since this flag is defined
in the same header file that defines fallocate(), I'm not really
seeing the point
of the weak definition. I mostly followed what had been done for
posix_fallocate().

I'm unclear whether there is a point in shimming fallocate() calls towards
posix_fallocate(). Currently the only use of fallocate() has
significant semantic
differences compared to what posix_fallocate() offers. Would we want to warn
users if the shimming is ever used? (if so, what's the custom?)

The shimming would also involve writing to errno as posix_fallocate() follows
the more recent POSIX convention of returning error values directly while
fallocate() follows the Unix tradition of returning 0/-1 and error values in
errno.

I'm open to add such logic. I'd appreciate further feedback regarding its
appropriateness and the wisdom of even defining this weak version.

 Thanks - Eric

>
> --
> Jens Axboe
>
> --
> To unsubscribe from this list: send the line "unsubscribe fio" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>

[PATCH v2] Add ability to invoke fallocate() FALLOC_FL_KEEP_SIZE.

[Eric Gouriou]

Linux offers fallocate() and the FALLOC_FL_KEEP_SIZE option as
an alternative to posix_fallocate(). When FALLOC_FL_KEEP_SIZE is
specified for an falloc request going beyond the end of the file,
the requested blocks get preallocated without changing the apparent
size of the file. This is is a commonly recommended use of fallocate()
for workloads performing append writes.

This patch modifies the fallocate option from a boolean option
to a string option accepting none/posix/keep/0/1. 'keep' is only
made available on systems where FALLOC_FL_KEEP_SIZE is available
(i.e., Linux at this time). If specified, fallocate() is used
with FALLOC_FL_KEEP_SIZE set. 'none' disables pre-allocation while
'posix' uses posix_fallocate(). The default behavior remains unchaned,
i.e., invoking posix_fallocate. The settings '0'/'1' are there to
provide backward compatibility for users who had explicitly set the
boolean option.
---
Hi Jens, all,

This is version 2 of the patch submitted earlier this week. Compared
to the initial version I removed the "fallocate_keep_size" option and,
as suggested, changed "fallocate" to be a string option. I elected
to provide both descriptive and numeric compatibility values for the
old boolean values. Let me know if you disagree with that choice.

I removed the weak version of fallocate(). It is not required at this
point and not having it removed the problem of figuring what semantics
it should have if invoked.

As always, feedback is appreciated.

 Regards - Eric
---
 HOWTO         |   18 +++++++++++++-----
 file.h        |   10 ++++++++++
 filesetup.c   |   44 ++++++++++++++++++++++++++++++++++++--------
 fio.1         |   30 ++++++++++++++++++++++++++----
 fio.h         |    2 +-
 options.c     |   35 ++++++++++++++++++++++++++++++-----
 os/os-linux.h |    1 +
 7 files changed, 117 insertions(+), 23 deletions(-)

diff --git a/HOWTO b/HOWTO
index 69b8cc6..ee899b8 100644
--- a/HOWTO
+++ b/HOWTO
@@ -354,11 +354,19 @@ use_os_rand=bool Fio can either use the random generator supplied by the OS
 		internal generator, which is often of better quality and
 		faster.
 
-fallocate=bool	By default, fio will use fallocate() to advise the system
-		of the size of the file we are going to write. This can be
-		turned off with fallocate=0. May not be available on all
-		supported platforms.  If using ZFS on Solaris this must be
-		set to 0 because ZFS doesn't support it.
+fallocate=str	Whether pre-allocation is performed when laying down files.
+		Accepted values are:
+
+			none		Do not pre-allocate space
+			posix		Pre-allocate via posix_fallocate()
+			keep		Pre-allocate via fallocate() with
+					FALLOC_FL_KEEP_SIZE set
+			0		Backward-compatible alias for 'none'
+			1		Backward-compatible alias for 'posix'
+
+		May not be available on all supported platforms. 'keep' is only
+		available on Linux.If using ZFS on Solaris this must be set to
+		'none' because ZFS doesn't support it. Default: 'posix'.
 
 fadvise_hint=bool By default, fio will use fadvise() to advise the kernel
 		on what IO patterns it is likely to issue. Sometimes you
diff --git a/file.h b/file.h
index 04c0d45..b3ff051 100644
--- a/file.h
+++ b/file.h
@@ -43,6 +43,16 @@ enum {
 };
 
 /*
+ * No pre-allocation when laying down files, or call posix_fallocate(), or
+ * call fallocate() with FALLOC_FL_KEEP_SIZE set.
+ */
+enum fio_fallocate_mode {
+	FIO_FALLOCATE_NONE	= 1,
+	FIO_FALLOCATE_POSIX	= 2,
+	FIO_FALLOCATE_KEEP_SIZE	= 3,
+};
+
+/*
  * Each thread_data structure has a number of files associated with it,
  * this structure holds state information for a single file.
  */
diff --git a/filesetup.c b/filesetup.c
index 799202f..6d8aa7a 100644
--- a/filesetup.c
+++ b/filesetup.c
@@ -13,6 +13,10 @@
 #include "filehash.h"
 #include "os/os.h"
 
+#ifdef FIO_HAVE_LINUX_FALLOCATE
+#include <linux/falloc.h>
+#endif
+
 static int root_warn;
 
 static inline void clear_error(struct thread_data *td)
@@ -67,17 +71,41 @@ static int extend_file(struct thread_data *td, struct fio_file *f)
 	}
 
 #ifdef FIO_HAVE_FALLOCATE
-	if (td->o.fallocate && !td->o.fill_device) {
-		dprint(FD_FILE, "fallocate file %s size %llu\n", f->file_name,
-							f->real_file_size);
-
-		r = posix_fallocate(f->fd, 0, f->real_file_size);
-		if (r > 0) {
-			log_err("fio: posix_fallocate fails: %s\n",
-					strerror(r));
+	if (!td->o.fill_device) {
+		switch (td->o.fallocate_mode) {
+		case FIO_FALLOCATE_NONE:
+			break;
+		case FIO_FALLOCATE_POSIX:
+			dprint(FD_FILE, "posix_fallocate file %s size %llu\n",
+				 f->file_name, f->real_file_size);
+
+			r = posix_fallocate(f->fd, 0, f->real_file_size);
+			if (r > 0) {
+				log_err("fio: posix_fallocate fails: %s\n",
+						strerror(r));
+			}
+			break;
+#ifdef FIO_HAVE_LINUX_FALLOCATE
+		case FIO_FALLOCATE_KEEP_SIZE:
+			dprint(FD_FILE,
+				"fallocate(FALLOC_FL_KEEP_SIZE) "
+				"file %s size %llu\n",
+				f->file_name, f->real_file_size);
+
+			r = fallocate(f->fd, FALLOC_FL_KEEP_SIZE, 0,
+					f->real_file_size);
+			if (r != 0) {
+				td_verror(td, errno, "fallocate");
+			}
+			break;
+#endif /* FIO_HAVE_LINUX_FALLOCATE */
+		default:
+			log_err("fio: unknown fallocate mode: %d\n",
+				td->o.fallocate_mode);
+			assert(0);
 		}
 	}
-#endif
+#endif /* FIO_HAVE_FALLOCATE */
 
 	if (!new_layout)
 		goto done;
diff --git a/fio.1 b/fio.1
index 0ced604..ad5040b 100644
--- a/fio.1
+++ b/fio.1
@@ -220,10 +220,32 @@ offsets, or it can use it's own internal generator (based on Tausworthe).
 Default is to use the internal generator, which is often of better quality and
 faster. Default: false.
 .TP
-.BI fallocate \fR=\fPbool
-By default, fio will use fallocate() to advise the system of the size of the
-file we are going to write. This can be turned off with fallocate=0. May not
-be available on all supported platforms.
+.BI fallocate \fR=\fPstr
+Whether pre-allocation is performed when laying down files. Accepted values
+are:
+.RS
+.RS
+.TP
+.B none
+Do not pre-allocate space.
+.TP
+.B posix
+Pre-allocate via posix_fallocate().
+.TP
+.B keep
+Pre-allocate via fallocate() with FALLOC_FL_KEEP_SIZE set.
+.TP
+.B 0
+Backward-compatible alias for 'none'.
+.TP
+.B 1
+Backward-compatible alias for 'posix'.
+.RE
+.P
+May not be available on all supported platforms. 'keep' is only
+available on Linux. If using ZFS on Solaris this must be set to 'none'
+because ZFS doesn't support it. Default: 'posix'.
+.RE
 .TP
 .BI fadvise_hint \fR=\fPbool
 Disable use of \fIposix_fadvise\fR\|(2) to advise the kernel what I/O patterns
diff --git a/fio.h b/fio.h
index 6ad186f..16866dd 100644
--- a/fio.h
+++ b/fio.h
@@ -248,7 +248,7 @@ struct thread_options {
 	unsigned int file_service_type;
 	unsigned int group_reporting;
 	unsigned int fadvise_hint;
-	unsigned int fallocate;
+	enum fio_fallocate_mode fallocate_mode;
 	unsigned int zero_buffers;
 	unsigned int refill_buffers;
 	unsigned int time_based;
diff --git a/options.c b/options.c
index a9b0534..bd7dc99 100644
--- a/options.c
+++ b/options.c
@@ -1178,12 +1178,37 @@ static struct fio_option options[FIO_MAX_OPTS] = {
 #ifdef FIO_HAVE_FALLOCATE
 	{
 		.name	= "fallocate",
-		.type	= FIO_OPT_BOOL,
-		.off1	= td_var_offset(fallocate),
-		.help	= "Use fallocate() when laying out files",
-		.def	= "1",
-	},
+		.type	= FIO_OPT_STR,
+		.off1	= td_var_offset(fallocate_mode),
+		.help	= "Whether pre-allocation is performed when laying out files",
+		.def	= "posix",
+		.posval	= {
+			  { .ival = "none",
+			    .oval = FIO_FALLOCATE_NONE,
+			    .help = "Do not pre-allocate space",
+			  },
+			  { .ival = "posix",
+			    .oval = FIO_FALLOCATE_POSIX,
+			    .help = "Use posix_fallocate()",
+			  },
+#ifdef FIO_HAVE_LINUX_FALLOCATE
+			  { .ival = "keep",
+			    .oval = FIO_FALLOCATE_KEEP_SIZE,
+			    .help = "Use fallocate(..., FALLOC_FL_KEEP_SIZE, ...)",
+			  },
 #endif
+			  /* Compatibility with former boolean values */
+			  { .ival = "0",
+			    .oval = FIO_FALLOCATE_NONE,
+			    .help = "Alias for 'none'",
+			  },
+			  { .ival = "1",
+			    .oval = FIO_FALLOCATE_POSIX,
+			    .help = "Alias for 'posix'",
+			  },
+		},
+	},
+#endif	/* FIO_HAVE_FALLOCATE */
 	{
 		.name	= "fadvise_hint",
 		.type	= FIO_OPT_BOOL,
diff --git a/os/os-linux.h b/os/os-linux.h
index 70c993b..024ef89 100644
--- a/os/os-linux.h
+++ b/os/os-linux.h
@@ -32,6 +32,7 @@
 #define FIO_HAVE_BLKTRACE
 #define FIO_HAVE_STRSEP
 #define FIO_HAVE_FALLOCATE
+#define FIO_HAVE_LINUX_FALLOCATE
 #define FIO_HAVE_POSIXAIO_FSYNC
 #define FIO_HAVE_PSHARED_MUTEX
 #define FIO_HAVE_CL_SIZE
-- 
1.7.3.1

Re: [PATCH v2] Add ability to invoke fallocate() FALLOC_FL_KEEP_SIZE.

[Jens Axboe]

On 2011-06-16 22:57, Eric Gouriou wrote:
> Hi Jens, all,
> 
> This is version 2 of the patch submitted earlier this week. Compared
> to the initial version I removed the "fallocate_keep_size" option and,
> as suggested, changed "fallocate" to be a string option. I elected
> to provide both descriptive and numeric compatibility values for the
> old boolean values. Let me know if you disagree with that choice.
> 
> I removed the weak version of fallocate(). It is not required at this
> point and not having it removed the problem of figuring what semantics
> it should have if invoked.
> 
> As always, feedback is appreciated.

Thanks Eric, this looks good! Applied.

-- 
Jens Axboe

Re: [PATCH v2] Add ability to invoke fallocate() FALLOC_FL_KEEP_SIZE.

[Eric Gouriou]

For the mailing-list record, v2 was also
Signed-off-by: Eric Gouriou <egouriou@google.com>

I had forgotten to re-insert in my local commit.

 Eric

On Fri, Jun 17, 2011 at 12:14 AM, Jens Axboe <axboe@kernel.dk> wrote:
> On 2011-06-16 22:57, Eric Gouriou wrote:
>> Hi Jens, all,
>>
>> This is version 2 of the patch submitted earlier this week. Compared
>> to the initial version I removed the "fallocate_keep_size" option and,
>> as suggested, changed "fallocate" to be a string option. I elected
>> to provide both descriptive and numeric compatibility values for the
>> old boolean values. Let me know if you disagree with that choice.
>>
>> I removed the weak version of fallocate(). It is not required at this
>> point and not having it removed the problem of figuring what semantics
>> it should have if invoked.
>>
>> As always, feedback is appreciated.
>
> Thanks Eric, this looks good! Applied.
>
> --
> Jens Axboe
>
> --
> To unsubscribe from this list: send the line "unsubscribe fio" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>