This patch attempts to add splice writes support. In essence, it just
calls generic_file_splice_write() after doing a little sanity check.
This would allow LTTng users that are using NFS to store trace data.
There could be more applications that could be benefitted too.
I have tested this using the Jens' test program and have found no
real issues. The test program is inlined below:
/*
* splice-out.c: Splice stdout to file
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#define SPLICE_SIZE (64*1024)
int main(int argc, char *argv[])
{
int fd;
if (argc < 2) {
printf("%s: outfile\n", argv[0]);
return 1;
}
fd = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd < 0) {
perror("open");
return 1;
}
do {
int ret = splice(STDIN_FILENO, NULL, fd, NULL, SPLICE_SIZE, 0);
if (ret < 0) {
perror("splice");
break;
} else if (ret < SPLICE_SIZE)
break;
} while (1);
close(fd);
return 0;
}
Compile with -D _GNU_SOURCE and do something like:
echo "some stuff" | ./splice-out <outfile>
Signed-off-by: Suresh Jayaraman <[email protected]>
---
fs/nfs/file.c | 24 ++++++++++++++++++++++++
1 files changed, 24 insertions(+), 0 deletions(-)
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 90f292b..13d6a00 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -47,6 +47,9 @@ static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
size_t count, unsigned int flags);
static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
unsigned long nr_segs, loff_t pos);
+static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
+ struct file *filp, loff_t *ppos,
+ size_t count, unsigned int flags);
static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
unsigned long nr_segs, loff_t pos);
static int nfs_file_flush(struct file *, fl_owner_t id);
@@ -76,6 +79,7 @@ const struct file_operations nfs_file_operations = {
.lock = nfs_lock,
.flock = nfs_flock,
.splice_read = nfs_file_splice_read,
+ .splice_write = nfs_file_splice_write,
.check_flags = nfs_check_flags,
.setlease = nfs_setlease,
};
@@ -550,6 +554,26 @@ out_swapfile:
goto out;
}
+static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
+ struct file *filp, loff_t *ppos,
+ size_t count, unsigned int flags)
+{
+ struct dentry *dentry = filp->f_path.dentry;
+ struct inode *inode = dentry->d_inode;
+
+ dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
+ dentry->d_parent->d_name.name, dentry->d_name.name,
+ (unsigned long) count, (unsigned long long) *ppos);
+
+ if (IS_SWAPFILE(inode)) {
+ printk(KERN_INFO "NFS: attempt to write to active swap"
+ "file!\n");
+ return -EBUSY;
+ }
+
+ return generic_file_splice_write(pipe, filp, ppos, count, flags);
+}
+
static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
{
struct inode *inode = filp->f_mapping->host;
* Suresh Jayaraman ([email protected]) wrote:
> This patch attempts to add splice writes support. In essence, it just
> calls generic_file_splice_write() after doing a little sanity check.
> This would allow LTTng users that are using NFS to store trace data.
> There could be more applications that could be benefitted too.
>
> I have tested this using the Jens' test program and have found no
> real issues. The test program is inlined below:
>
That's great ! I'll pull it in the LTTng tree so my users can try it.
They currently cannot write LTTng traces to NFS mounts anyway.
Thanks !
Mathieu
> /*
> * splice-out.c: Splice stdout to file
> */
> #include <stdio.h>
> #include <stdlib.h>
> #include <unistd.h>
> #include <fcntl.h>
>
> #define SPLICE_SIZE (64*1024)
>
> int main(int argc, char *argv[])
> {
> int fd;
>
> if (argc < 2) {
> printf("%s: outfile\n", argv[0]);
> return 1;
> }
>
> fd = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0644);
> if (fd < 0) {
> perror("open");
> return 1;
> }
>
> do {
> int ret = splice(STDIN_FILENO, NULL, fd, NULL, SPLICE_SIZE, 0);
>
> if (ret < 0) {
> perror("splice");
> break;
> } else if (ret < SPLICE_SIZE)
> break;
> } while (1);
>
> close(fd);
> return 0;
> }
>
> Compile with -D _GNU_SOURCE and do something like:
> echo "some stuff" | ./splice-out <outfile>
>
> Signed-off-by: Suresh Jayaraman <[email protected]>
> ---
> fs/nfs/file.c | 24 ++++++++++++++++++++++++
> 1 files changed, 24 insertions(+), 0 deletions(-)
>
> diff --git a/fs/nfs/file.c b/fs/nfs/file.c
> index 90f292b..13d6a00 100644
> --- a/fs/nfs/file.c
> +++ b/fs/nfs/file.c
> @@ -47,6 +47,9 @@ static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
> size_t count, unsigned int flags);
> static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
> unsigned long nr_segs, loff_t pos);
> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
> + struct file *filp, loff_t *ppos,
> + size_t count, unsigned int flags);
> static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
> unsigned long nr_segs, loff_t pos);
> static int nfs_file_flush(struct file *, fl_owner_t id);
> @@ -76,6 +79,7 @@ const struct file_operations nfs_file_operations = {
> .lock = nfs_lock,
> .flock = nfs_flock,
> .splice_read = nfs_file_splice_read,
> + .splice_write = nfs_file_splice_write,
> .check_flags = nfs_check_flags,
> .setlease = nfs_setlease,
> };
> @@ -550,6 +554,26 @@ out_swapfile:
> goto out;
> }
>
> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
> + struct file *filp, loff_t *ppos,
> + size_t count, unsigned int flags)
> +{
> + struct dentry *dentry = filp->f_path.dentry;
> + struct inode *inode = dentry->d_inode;
> +
> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
> + dentry->d_parent->d_name.name, dentry->d_name.name,
> + (unsigned long) count, (unsigned long long) *ppos);
> +
> + if (IS_SWAPFILE(inode)) {
> + printk(KERN_INFO "NFS: attempt to write to active swap"
> + "file!\n");
> + return -EBUSY;
> + }
> +
> + return generic_file_splice_write(pipe, filp, ppos, count, flags);
> +}
> +
> static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
> {
> struct inode *inode = filp->f_mapping->host;
>
--
Mathieu Desnoyers
OpenPGP key fingerprint: 8CD5 52C3 8E3C 4140 715F BA06 3F25 A8FE 3BAE 9A68
* Suresh Jayaraman ([email protected]) wrote:
> This patch attempts to add splice writes support. In essence, it just
> calls generic_file_splice_write() after doing a little sanity check.
> This would allow LTTng users that are using NFS to store trace data.
> There could be more applications that could be benefitted too.
>
> I have tested this using the Jens' test program and have found no
> real issues. The test program is inlined below:
>
There is just a small checkpatch nit that I'll fix directly in place in
the LTTng tree.
WARNING: %Ld/%Lu are not-standard C, use %lld/%llu
#93: FILE: fs/nfs/file.c:564:
+ dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
total: 0 errors, 1 warnings, 42 lines checked
Mathieu
> /*
> * splice-out.c: Splice stdout to file
> */
> #include <stdio.h>
> #include <stdlib.h>
> #include <unistd.h>
> #include <fcntl.h>
>
> #define SPLICE_SIZE (64*1024)
>
> int main(int argc, char *argv[])
> {
> int fd;
>
> if (argc < 2) {
> printf("%s: outfile\n", argv[0]);
> return 1;
> }
>
> fd = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0644);
> if (fd < 0) {
> perror("open");
> return 1;
> }
>
> do {
> int ret = splice(STDIN_FILENO, NULL, fd, NULL, SPLICE_SIZE, 0);
>
> if (ret < 0) {
> perror("splice");
> break;
> } else if (ret < SPLICE_SIZE)
> break;
> } while (1);
>
> close(fd);
> return 0;
> }
>
> Compile with -D _GNU_SOURCE and do something like:
> echo "some stuff" | ./splice-out <outfile>
>
> Signed-off-by: Suresh Jayaraman <[email protected]>
> ---
> fs/nfs/file.c | 24 ++++++++++++++++++++++++
> 1 files changed, 24 insertions(+), 0 deletions(-)
>
> diff --git a/fs/nfs/file.c b/fs/nfs/file.c
> index 90f292b..13d6a00 100644
> --- a/fs/nfs/file.c
> +++ b/fs/nfs/file.c
> @@ -47,6 +47,9 @@ static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
> size_t count, unsigned int flags);
> static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
> unsigned long nr_segs, loff_t pos);
> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
> + struct file *filp, loff_t *ppos,
> + size_t count, unsigned int flags);
> static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
> unsigned long nr_segs, loff_t pos);
> static int nfs_file_flush(struct file *, fl_owner_t id);
> @@ -76,6 +79,7 @@ const struct file_operations nfs_file_operations = {
> .lock = nfs_lock,
> .flock = nfs_flock,
> .splice_read = nfs_file_splice_read,
> + .splice_write = nfs_file_splice_write,
> .check_flags = nfs_check_flags,
> .setlease = nfs_setlease,
> };
> @@ -550,6 +554,26 @@ out_swapfile:
> goto out;
> }
>
> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
> + struct file *filp, loff_t *ppos,
> + size_t count, unsigned int flags)
> +{
> + struct dentry *dentry = filp->f_path.dentry;
> + struct inode *inode = dentry->d_inode;
> +
> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
> + dentry->d_parent->d_name.name, dentry->d_name.name,
> + (unsigned long) count, (unsigned long long) *ppos);
> +
> + if (IS_SWAPFILE(inode)) {
> + printk(KERN_INFO "NFS: attempt to write to active swap"
> + "file!\n");
> + return -EBUSY;
> + }
> +
> + return generic_file_splice_write(pipe, filp, ppos, count, flags);
> +}
> +
> static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
> {
> struct inode *inode = filp->f_mapping->host;
>
--
Mathieu Desnoyers
OpenPGP key fingerprint: 8CD5 52C3 8E3C 4140 715F BA06 3F25 A8FE 3BAE 9A68
Mathieu Desnoyers wrote:
> * Suresh Jayaraman ([email protected]) wrote:
>> This patch attempts to add splice writes support. In essence, it just
>> calls generic_file_splice_write() after doing a little sanity check.
>> This would allow LTTng users that are using NFS to store trace data.
>> There could be more applications that could be benefitted too.
>>
>> I have tested this using the Jens' test program and have found no
>> real issues. The test program is inlined below:
>>
>
> There is just a small checkpatch nit that I'll fix directly in place in
> the LTTng tree.
>
> WARNING: %Ld/%Lu are not-standard C, use %lld/%llu
> #93: FILE: fs/nfs/file.c:564:
> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
>
> total: 0 errors, 1 warnings, 42 lines checked
>
Yes, I noticed it. There are quite a few places in nfs code where we
happened to use that (that doesn't imply that it shouldn't be fixed), so
I thought it's OK.
> That's great ! I'll pull it in the LTTng tree so my users can try it.
> They currently cannot write LTTng traces to NFS mounts anyway.
Yes, please report the test results. Would appreciate it very much.
Thanks,
>>
>> diff --git a/fs/nfs/file.c b/fs/nfs/file.c
>> index 90f292b..13d6a00 100644
>> --- a/fs/nfs/file.c
>> +++ b/fs/nfs/file.c
>> @@ -47,6 +47,9 @@ static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
>> size_t count, unsigned int flags);
>> static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
>> unsigned long nr_segs, loff_t pos);
>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
>> + struct file *filp, loff_t *ppos,
>> + size_t count, unsigned int flags);
>> static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
>> unsigned long nr_segs, loff_t pos);
>> static int nfs_file_flush(struct file *, fl_owner_t id);
>> @@ -76,6 +79,7 @@ const struct file_operations nfs_file_operations = {
>> .lock = nfs_lock,
>> .flock = nfs_flock,
>> .splice_read = nfs_file_splice_read,
>> + .splice_write = nfs_file_splice_write,
>> .check_flags = nfs_check_flags,
>> .setlease = nfs_setlease,
>> };
>> @@ -550,6 +554,26 @@ out_swapfile:
>> goto out;
>> }
>>
>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
>> + struct file *filp, loff_t *ppos,
>> + size_t count, unsigned int flags)
>> +{
>> + struct dentry *dentry = filp->f_path.dentry;
>> + struct inode *inode = dentry->d_inode;
>> +
>> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
>> + dentry->d_parent->d_name.name, dentry->d_name.name,
>> + (unsigned long) count, (unsigned long long) *ppos);
>> +
>> + if (IS_SWAPFILE(inode)) {
>> + printk(KERN_INFO "NFS: attempt to write to active swap"
>> + "file!\n");
>> + return -EBUSY;
>> + }
>> +
>> + return generic_file_splice_write(pipe, filp, ppos, count, flags);
>> +}
>> +
>> static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
>> {
>> struct inode *inode = filp->f_mapping->host;
>>
>
--
Suresh Jayaraman
Hello Suresh and Mathieu,
2009/4/2 Suresh Jayaraman <[email protected]>:
> Mathieu Desnoyers wrote:
>> * Suresh Jayaraman ([email protected]) wrote:
>>> This patch attempts to add splice writes support. In essence, it just
>>> calls generic_file_splice_write() after doing a little sanity check.
>>> This would allow LTTng users that are using NFS to store trace data.
>>> There could be more applications that could be benefitted too.
>>>
>>> I have tested this using the Jens' test program and have found no
>>> real issues. The test program is inlined below:
>>>
>>
>> There is just a small checkpatch nit that I'll fix directly in place in
>> the LTTng tree.
>>
>> WARNING: %Ld/%Lu are not-standard C, use %lld/%llu
>> #93: FILE: fs/nfs/file.c:564:
>> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
>>
>> total: 0 errors, 1 warnings, 42 lines checked
>>
>
> Yes, I noticed it. There are quite a few places in nfs code where we
> happened to use that (that doesn't imply that it shouldn't be fixed), so
> I thought it's OK.
>
>> That's great ! I'll pull it in the LTTng tree so my users can try it.
>> They currently cannot write LTTng traces to NFS mounts anyway.
>
> Yes, please report the test results. Would appreciate it very much.
>
>
> Thanks,
Thank you for creating a patch !!
I tested it, and it works fine.
My environment is following,
LTTV 0.12.10
LTTng 0.100
LTT Control 0.65
Kernles 2.6.29
LTTng version is old now, but the test is passed on ARM11 target.
Furthermore, I run the splice test and the test is passed too.
The test code is copied from
http://kzk9.net/blog/2007/05/splice2.html
(Japanese page)
Thanks all people who commented this issue.
Best regards,
Masahiro Tamori
>
>>>
>>> diff --git a/fs/nfs/file.c b/fs/nfs/file.c
>>> index 90f292b..13d6a00 100644
>>> --- a/fs/nfs/file.c
>>> +++ b/fs/nfs/file.c
>>> @@ -47,6 +47,9 @@ static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
>>> size_t count, unsigned int flags);
>>> static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
>>> unsigned long nr_segs, loff_t pos);
>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
>>> + struct file *filp, loff_t *ppos,
>>> + size_t count, unsigned int flags);
>>> static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
>>> unsigned long nr_segs, loff_t pos);
>>> static int nfs_file_flush(struct file *, fl_owner_t id);
>>> @@ -76,6 +79,7 @@ const struct file_operations nfs_file_operations = {
>>> .lock = nfs_lock,
>>> .flock = nfs_flock,
>>> .splice_read = nfs_file_splice_read,
>>> + .splice_write = nfs_file_splice_write,
>>> .check_flags = nfs_check_flags,
>>> .setlease = nfs_setlease,
>>> };
>>> @@ -550,6 +554,26 @@ out_swapfile:
>>> goto out;
>>> }
>>>
>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
>>> + struct file *filp, loff_t *ppos,
>>> + size_t count, unsigned int flags)
>>> +{
>>> + struct dentry *dentry = filp->f_path.dentry;
>>> + struct inode *inode = dentry->d_inode;
>>> +
>>> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
>>> + dentry->d_parent->d_name.name, dentry->d_name.name,
>>> + (unsigned long) count, (unsigned long long) *ppos);
>>> +
>>> + if (IS_SWAPFILE(inode)) {
>>> + printk(KERN_INFO "NFS: attempt to write to active swap"
>>> + "file!\n");
>>> + return -EBUSY;
>>> + }
>>> +
>>> + return generic_file_splice_write(pipe, filp, ppos, count, flags);
>>> +}
>>> +
>>> static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
>>> {
>>> struct inode *inode = filp->f_mapping->host;
>>>
>>
>
>
> --
> Suresh Jayaraman
>
> _______________________________________________
> ltt-dev mailing list
> [email protected]
> http://lists.casi.polymtl.ca/cgi-bin/mailman/listinfo/ltt-dev
>
Hi Trond,
Do you think this patch is OK? Can this be considered for merging?
Thanks,
Masahiro Tamori wrote:
> Hello Suresh and Mathieu,
>
> 2009/4/2 Suresh Jayaraman <[email protected]>:
>> Mathieu Desnoyers wrote:
>>> * Suresh Jayaraman ([email protected]) wrote:
>>>> This patch attempts to add splice writes support. In essence, it just
>>>> calls generic_file_splice_write() after doing a little sanity check.
>>>> This would allow LTTng users that are using NFS to store trace data.
>>>> There could be more applications that could be benefitted too.
>>>>
>>>> I have tested this using the Jens' test program and have found no
>>>> real issues. The test program is inlined below:
>>>>
>>> There is just a small checkpatch nit that I'll fix directly in place in
>>> the LTTng tree.
>>>
>>> WARNING: %Ld/%Lu are not-standard C, use %lld/%llu
>>> #93: FILE: fs/nfs/file.c:564:
>>> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
>>>
>>> total: 0 errors, 1 warnings, 42 lines checked
>>>
>> Yes, I noticed it. There are quite a few places in nfs code where we
>> happened to use that (that doesn't imply that it shouldn't be fixed), so
>> I thought it's OK.
>>
>>> That's great ! I'll pull it in the LTTng tree so my users can try it.
>>> They currently cannot write LTTng traces to NFS mounts anyway.
>> Yes, please report the test results. Would appreciate it very much.
>>
>>
>> Thanks,
>
> Thank you for creating a patch !!
>
> I tested it, and it works fine.
>
> My environment is following,
> LTTV 0.12.10
> LTTng 0.100
> LTT Control 0.65
> Kernles 2.6.29
>
> LTTng version is old now, but the test is passed on ARM11 target.
>
> Furthermore, I run the splice test and the test is passed too.
> The test code is copied from
> http://kzk9.net/blog/2007/05/splice2.html
> (Japanese page)
>
> Thanks all people who commented this issue.
>
> Best regards,
> Masahiro Tamori
>
>>>> diff --git a/fs/nfs/file.c b/fs/nfs/file.c
>>>> index 90f292b..13d6a00 100644
>>>> --- a/fs/nfs/file.c
>>>> +++ b/fs/nfs/file.c
>>>> @@ -47,6 +47,9 @@ static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
>>>> size_t count, unsigned int flags);
>>>> static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
>>>> unsigned long nr_segs, loff_t pos);
>>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
>>>> + struct file *filp, loff_t *ppos,
>>>> + size_t count, unsigned int flags);
>>>> static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
>>>> unsigned long nr_segs, loff_t pos);
>>>> static int nfs_file_flush(struct file *, fl_owner_t id);
>>>> @@ -76,6 +79,7 @@ const struct file_operations nfs_file_operations = {
>>>> .lock = nfs_lock,
>>>> .flock = nfs_flock,
>>>> .splice_read = nfs_file_splice_read,
>>>> + .splice_write = nfs_file_splice_write,
>>>> .check_flags = nfs_check_flags,
>>>> .setlease = nfs_setlease,
>>>> };
>>>> @@ -550,6 +554,26 @@ out_swapfile:
>>>> goto out;
>>>> }
>>>>
>>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
>>>> + struct file *filp, loff_t *ppos,
>>>> + size_t count, unsigned int flags)
>>>> +{
>>>> + struct dentry *dentry = filp->f_path.dentry;
>>>> + struct inode *inode = dentry->d_inode;
>>>> +
>>>> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
>>>> + dentry->d_parent->d_name.name, dentry->d_name.name,
>>>> + (unsigned long) count, (unsigned long long) *ppos);
>>>> +
>>>> + if (IS_SWAPFILE(inode)) {
>>>> + printk(KERN_INFO "NFS: attempt to write to active swap"
>>>> + "file!\n");
>>>> + return -EBUSY;
>>>> + }
>>>> +
>>>> + return generic_file_splice_write(pipe, filp, ppos, count, flags);
>>>> +}
>>>> +
>>>> static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
>>>> {
>>>> struct inode *inode = filp->f_mapping->host;
>>>>
>>
>> --
>> Suresh Jayaraman
>>
>> _______________________________________________
>> ltt-dev mailing list
>> [email protected]
>> http://lists.casi.polymtl.ca/cgi-bin/mailman/listinfo/ltt-dev
>>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
> the body of a message to [email protected]
> More majordomo info at http://vger.kernel.org/majordomo-info.html
--
Suresh Jayaraman
On Mon, 2009-04-20 at 11:09 +0530, Suresh Jayaraman wrote:
> Hi Trond,
>
> Do you think this patch is OK? Can this be considered for merging?
>
> Thanks,
>
> Masahiro Tamori wrote:
> > Hello Suresh and Mathieu,
> >
> > 2009/4/2 Suresh Jayaraman <[email protected]>:
> >> Mathieu Desnoyers wrote:
> >>> * Suresh Jayaraman ([email protected]) wrote:
> >>>> This patch attempts to add splice writes support. In essence, it just
> >>>> calls generic_file_splice_write() after doing a little sanity check.
> >>>> This would allow LTTng users that are using NFS to store trace data.
> >>>> There could be more applications that could be benefitted too.
> >>>>
> >>>> I have tested this using the Jens' test program and have found no
> >>>> real issues. The test program is inlined below:
> >>>>
> >>> There is just a small checkpatch nit that I'll fix directly in place in
> >>> the LTTng tree.
> >>>
> >>> WARNING: %Ld/%Lu are not-standard C, use %lld/%llu
> >>> #93: FILE: fs/nfs/file.c:564:
> >>> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
> >>>
> >>> total: 0 errors, 1 warnings, 42 lines checked
> >>>
> >> Yes, I noticed it. There are quite a few places in nfs code where we
> >> happened to use that (that doesn't imply that it shouldn't be fixed), so
> >> I thought it's OK.
> >>
> >>> That's great ! I'll pull it in the LTTng tree so my users can try it.
> >>> They currently cannot write LTTng traces to NFS mounts anyway.
> >> Yes, please report the test results. Would appreciate it very much.
> >>
> >>
> >> Thanks,
> >
> > Thank you for creating a patch !!
> >
> > I tested it, and it works fine.
> >
> > My environment is following,
> > LTTV 0.12.10
> > LTTng 0.100
> > LTT Control 0.65
> > Kernles 2.6.29
> >
> > LTTng version is old now, but the test is passed on ARM11 target.
> >
> > Furthermore, I run the splice test and the test is passed too.
> > The test code is copied from
> > http://kzk9.net/blog/2007/05/splice2.html
> > (Japanese page)
> >
> > Thanks all people who commented this issue.
> >
> > Best regards,
> > Masahiro Tamori
> >
> >>>> diff --git a/fs/nfs/file.c b/fs/nfs/file.c
> >>>> index 90f292b..13d6a00 100644
> >>>> --- a/fs/nfs/file.c
> >>>> +++ b/fs/nfs/file.c
> >>>> @@ -47,6 +47,9 @@ static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
> >>>> size_t count, unsigned int flags);
> >>>> static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
> >>>> unsigned long nr_segs, loff_t pos);
> >>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
> >>>> + struct file *filp, loff_t *ppos,
> >>>> + size_t count, unsigned int flags);
> >>>> static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
> >>>> unsigned long nr_segs, loff_t pos);
> >>>> static int nfs_file_flush(struct file *, fl_owner_t id);
> >>>> @@ -76,6 +79,7 @@ const struct file_operations nfs_file_operations = {
> >>>> .lock = nfs_lock,
> >>>> .flock = nfs_flock,
> >>>> .splice_read = nfs_file_splice_read,
> >>>> + .splice_write = nfs_file_splice_write,
> >>>> .check_flags = nfs_check_flags,
> >>>> .setlease = nfs_setlease,
> >>>> };
> >>>> @@ -550,6 +554,26 @@ out_swapfile:
> >>>> goto out;
> >>>> }
> >>>>
> >>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
> >>>> + struct file *filp, loff_t *ppos,
> >>>> + size_t count, unsigned int flags)
> >>>> +{
> >>>> + struct dentry *dentry = filp->f_path.dentry;
> >>>> + struct inode *inode = dentry->d_inode;
> >>>> +
> >>>> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
> >>>> + dentry->d_parent->d_name.name, dentry->d_name.name,
> >>>> + (unsigned long) count, (unsigned long long) *ppos);
> >>>> +
> >>>> + if (IS_SWAPFILE(inode)) {
> >>>> + printk(KERN_INFO "NFS: attempt to write to active swap"
> >>>> + "file!\n");
> >>>> + return -EBUSY;
> >>>> + }
I don't know that we really need this. We should sweep through the NFS
code and kill all those IS_SWAPFILE() thingys. Or at least #define
IS_SWAPFILE(a) (0)
...
> >>>> +
> >>>> + return generic_file_splice_write(pipe, filp, ppos, count, flags);
> >>>> +}
> >>>> +
> >>>> static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
> >>>> {
> >>>> struct inode *inode = filp->f_mapping->host;
> >>>>
Otherwise it looks fine...
Trond Myklebust wrote:
> On Mon, 2009-04-20 at 11:09 +0530, Suresh Jayaraman wrote:
>> Hi Trond,
>>
>> Do you think this patch is OK? Can this be considered for merging?
>>
>> Thanks,
>>
>>>>>> diff --git a/fs/nfs/file.c b/fs/nfs/file.c
>>>>>> index 90f292b..13d6a00 100644
>>>>>> --- a/fs/nfs/file.c
>>>>>> +++ b/fs/nfs/file.c
>>>>>> @@ -47,6 +47,9 @@ static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
>>>>>> size_t count, unsigned int flags);
>>>>>> static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
>>>>>> unsigned long nr_segs, loff_t pos);
>>>>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
>>>>>> + struct file *filp, loff_t *ppos,
>>>>>> + size_t count, unsigned int flags);
>>>>>> static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
>>>>>> unsigned long nr_segs, loff_t pos);
>>>>>> static int nfs_file_flush(struct file *, fl_owner_t id);
>>>>>> @@ -76,6 +79,7 @@ const struct file_operations nfs_file_operations = {
>>>>>> .lock = nfs_lock,
>>>>>> .flock = nfs_flock,
>>>>>> .splice_read = nfs_file_splice_read,
>>>>>> + .splice_write = nfs_file_splice_write,
>>>>>> .check_flags = nfs_check_flags,
>>>>>> .setlease = nfs_setlease,
>>>>>> };
>>>>>> @@ -550,6 +554,26 @@ out_swapfile:
>>>>>> goto out;
>>>>>> }
>>>>>>
>>>>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
>>>>>> + struct file *filp, loff_t *ppos,
>>>>>> + size_t count, unsigned int flags)
>>>>>> +{
>>>>>> + struct dentry *dentry = filp->f_path.dentry;
>>>>>> + struct inode *inode = dentry->d_inode;
>>>>>> +
>>>>>> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
>>>>>> + dentry->d_parent->d_name.name, dentry->d_name.name,
>>>>>> + (unsigned long) count, (unsigned long long) *ppos);
>>>>>> +
>>>>>> + if (IS_SWAPFILE(inode)) {
>>>>>> + printk(KERN_INFO "NFS: attempt to write to active swap"
>>>>>> + "file!\n");
>>>>>> + return -EBUSY;
>>>>>> + }
>
> I don't know that we really need this. We should sweep through the NFS
> code and kill all those IS_SWAPFILE() thingys. Or at least #define
> IS_SWAPFILE(a) (0)
> ...
Hmm.. I'm not sure whether we should kill them now. I think originally,
these were added keeping in mind the future NFS swap support. Given that
the recent work from Peterz Zilstra on "Swap over NFS" and multiple
iterations/review on the same, I think those patches will eventually get
merged sooner or later. Perhaps, it's a good idea to #define
IS_SWAPFILE(a) 0 than killing them entirely..?
Thanks,
>>>>>> +
>>>>>> + return generic_file_splice_write(pipe, filp, ppos, count, flags);
>>>>>> +}
>>>>>> +
>>>>>> static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
>>>>>> {
>>>>>> struct inode *inode = filp->f_mapping->host;
>>>>>>
>
> Otherwise it looks fine...
>
>
>
--
Suresh Jayaraman
On Mon, 2009-04-20 at 18:08 +0530, Suresh Jayaraman wrote:
> Trond Myklebust wrote:
> > On Mon, 2009-04-20 at 11:09 +0530, Suresh Jayaraman wrote:
> >> Hi Trond,
> >>
> >> Do you think this patch is OK? Can this be considered for merging?
> >>
> >> Thanks,
> >>
> >>>>>> diff --git a/fs/nfs/file.c b/fs/nfs/file.c
> >>>>>> index 90f292b..13d6a00 100644
> >>>>>> --- a/fs/nfs/file.c
> >>>>>> +++ b/fs/nfs/file.c
> >>>>>> @@ -47,6 +47,9 @@ static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
> >>>>>> size_t count, unsigned int flags);
> >>>>>> static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
> >>>>>> unsigned long nr_segs, loff_t pos);
> >>>>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
> >>>>>> + struct file *filp, loff_t *ppos,
> >>>>>> + size_t count, unsigned int flags);
> >>>>>> static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
> >>>>>> unsigned long nr_segs, loff_t pos);
> >>>>>> static int nfs_file_flush(struct file *, fl_owner_t id);
> >>>>>> @@ -76,6 +79,7 @@ const struct file_operations nfs_file_operations = {
> >>>>>> .lock = nfs_lock,
> >>>>>> .flock = nfs_flock,
> >>>>>> .splice_read = nfs_file_splice_read,
> >>>>>> + .splice_write = nfs_file_splice_write,
> >>>>>> .check_flags = nfs_check_flags,
> >>>>>> .setlease = nfs_setlease,
> >>>>>> };
> >>>>>> @@ -550,6 +554,26 @@ out_swapfile:
> >>>>>> goto out;
> >>>>>> }
> >>>>>>
> >>>>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
> >>>>>> + struct file *filp, loff_t *ppos,
> >>>>>> + size_t count, unsigned int flags)
> >>>>>> +{
> >>>>>> + struct dentry *dentry = filp->f_path.dentry;
> >>>>>> + struct inode *inode = dentry->d_inode;
> >>>>>> +
> >>>>>> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
> >>>>>> + dentry->d_parent->d_name.name, dentry->d_name.name,
> >>>>>> + (unsigned long) count, (unsigned long long) *ppos);
> >>>>>> +
> >>>>>> + if (IS_SWAPFILE(inode)) {
> >>>>>> + printk(KERN_INFO "NFS: attempt to write to active swap"
> >>>>>> + "file!\n");
> >>>>>> + return -EBUSY;
> >>>>>> + }
> >
> > I don't know that we really need this. We should sweep through the NFS
> > code and kill all those IS_SWAPFILE() thingys. Or at least #define
> > IS_SWAPFILE(a) (0)
> > ...
>
> Hmm.. I'm not sure whether we should kill them now. I think originally,
> these were added keeping in mind the future NFS swap support. Given that
> the recent work from Peterz Zilstra on "Swap over NFS" and multiple
> iterations/review on the same, I think those patches will eventually get
> merged sooner or later. Perhaps, it's a good idea to #define
> IS_SWAPFILE(a) 0 than killing them entirely..?
Why are they needed at all? AFAICS, other filesystems check IS_SWAPFILE
when truncating a file, but don't litter their code with all these weird
checks for writing, reading, etc.
It's not as if these checks can stop a determined privileged person from
writing to the swapfile anyway. All they have to do is go to another
client or write directly to the file on the server...
Trond
Trond Myklebust wrote:
> On Mon, 2009-04-20 at 18:08 +0530, Suresh Jayaraman wrote:
>> Trond Myklebust wrote:
>>> On Mon, 2009-04-20 at 11:09 +0530, Suresh Jayaraman wrote:
>>>> Hi Trond,
>>>>
>>>> Do you think this patch is OK? Can this be considered for merging?
>>>>>>>> +
>>>>>>>> + if (IS_SWAPFILE(inode)) {
>>>>>>>> + printk(KERN_INFO "NFS: attempt to write to active swap"
>>>>>>>> + "file!\n");
>>>>>>>> + return -EBUSY;
>>>>>>>> + }
>>> I don't know that we really need this. We should sweep through the NFS
>>> code and kill all those IS_SWAPFILE() thingys. Or at least #define
>>> IS_SWAPFILE(a) (0)
>>> ...
>> Hmm.. I'm not sure whether we should kill them now. I think originally,
>> these were added keeping in mind the future NFS swap support. Given that
>> the recent work from Peterz Zilstra on "Swap over NFS" and multiple
>> iterations/review on the same, I think those patches will eventually get
>> merged sooner or later. Perhaps, it's a good idea to #define
>> IS_SWAPFILE(a) 0 than killing them entirely..?
>
> Why are they needed at all? AFAICS, other filesystems check IS_SWAPFILE
> when truncating a file, but don't litter their code with all these weird
> checks for writing, reading, etc.
Yes, except for afs other filesystems seem to check only during
truncation.
> It's not as if these checks can stop a determined privileged person from
> writing to the swapfile anyway. All they have to do is go to another
> client or write directly to the file on the server...
>
Make sense.
Here is the trimmed version. I think the dprink could be retained
for debugging issues, if any.
Signed-off-by: Suresh Jayaraman <[email protected]>
---
fs/nfs/file.c | 17 +++++++++++++++++
1 files changed, 17 insertions(+), 0 deletions(-)
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 5a97bcf..6dfe7df 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -48,6 +48,9 @@ static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
size_t count, unsigned int flags);
static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
unsigned long nr_segs, loff_t pos);
+static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
+ struct file *filp, loff_t *ppos,
+ size_t count, unsigned int flags);
static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
unsigned long nr_segs, loff_t pos);
static int nfs_file_flush(struct file *, fl_owner_t id);
@@ -73,6 +76,7 @@ const struct file_operations nfs_file_operations = {
.lock = nfs_lock,
.flock = nfs_flock,
.splice_read = nfs_file_splice_read,
+ .splice_write = nfs_file_splice_write,
.check_flags = nfs_check_flags,
.setlease = nfs_setlease,
};
@@ -587,6 +591,19 @@ out_swapfile:
goto out;
}
+static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
+ struct file *filp, loff_t *ppos,
+ size_t count, unsigned int flags)
+{
+ struct dentry *dentry = filp->f_path.dentry;
+
+ dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
+ dentry->d_parent->d_name.name, dentry->d_name.name,
+ (unsigned long) count, (unsigned long long) *ppos);
+
+ return generic_file_splice_write(pipe, filp, ppos, count, flags);
+}
+
static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
{
struct inode *inode = filp->f_mapping->host;
On Mon, Apr 20, 2009 at 09:17:23PM +0530, Suresh Jayaraman wrote:
> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
> + struct file *filp, loff_t *ppos,
> + size_t count, unsigned int flags)
> +{
> + struct dentry *dentry = filp->f_path.dentry;
> +
> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
> + dentry->d_parent->d_name.name, dentry->d_name.name,
> + (unsigned long) count, (unsigned long long) *ppos);
> +
> + return generic_file_splice_write(pipe, filp, ppos, count, flags);
> +}
> +
You need all calls from nfs_file_write, too:
- most importantly the nfs_revalidate_file_size for O_APPEND
- the nfs_do_fsync for sync writes
- probably the stats increment
On Tue, 2009-04-21 at 10:48 -0400, Christoph Hellwig wrote:
> On Mon, Apr 20, 2009 at 09:17:23PM +0530, Suresh Jayaraman wrote:
> > +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
> > + struct file *filp, loff_t *ppos,
> > + size_t count, unsigned int flags)
> > +{
> > + struct dentry *dentry = filp->f_path.dentry;
> > +
> > + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
> > + dentry->d_parent->d_name.name, dentry->d_name.name,
> > + (unsigned long) count, (unsigned long long) *ppos);
> > +
> > + return generic_file_splice_write(pipe, filp, ppos, count, flags);
> > +}
> > +
>
> You need all calls from nfs_file_write, too:
>
> - most importantly the nfs_revalidate_file_size for O_APPEND
Isn't O_APPEND illegal for splice_write()? It looks like it is from a
quick perusal of do_splice_from().
> - the nfs_do_fsync for sync writes
generic_file_splice_write() calls generic_osync_inode(), which should
ensure sync writes even with NFS.
The one thing it won't do is propagate NFS write errors back to the
caller. If we do care about this, then we should certainly test for
nfs_need_sync_write() and then call nfs_do_fsync() (see
nfs_file_write()).
> - probably the stats increment
We should talk to Chuck about this.
Cheers
Trond
On Apr 21, 2009, at 1:35 PM, Trond Myklebust wrote:
> On Tue, 2009-04-21 at 10:48 -0400, Christoph Hellwig wrote:
>> On Mon, Apr 20, 2009 at 09:17:23PM +0530, Suresh Jayaraman wrote:
>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
>>> + struct file *filp, loff_t *ppos,
>>> + size_t count, unsigned int flags)
>>> +{
>>> + struct dentry *dentry = filp->f_path.dentry;
>>> +
>>> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
>>> + dentry->d_parent->d_name.name, dentry->d_name.name,
>>> + (unsigned long) count, (unsigned long long) *ppos);
>>> +
>>> + return generic_file_splice_write(pipe, filp, ppos, count, flags);
>>> +}
>>> +
>>
>> You need all calls from nfs_file_write, too:
>>
>> - most importantly the nfs_revalidate_file_size for O_APPEND
>
> Isn't O_APPEND illegal for splice_write()? It looks like it is from a
> quick perusal of do_splice_from().
>
>> - the nfs_do_fsync for sync writes
>
> generic_file_splice_write() calls generic_osync_inode(), which should
> ensure sync writes even with NFS.
> The one thing it won't do is propagate NFS write errors back to the
> caller. If we do care about this, then we should certainly test for
> nfs_need_sync_write() and then call nfs_do_fsync() (see
> nfs_file_write()).
>
>> - probably the stats increment
>
> We should talk to Chuck about this.
I don't know much about the characteristics of splice writes, so you
can do one of two things:
1. Create a separate BYTESWRITTEN counter for these
2. Lump them into NORMALBYTESWRITTEN if these are effectively cached
writes.
--
Chuck Lever
chuck[dot]lever[at]oracle[dot]com
Trond Myklebust wrote:
> On Tue, 2009-04-21 at 10:48 -0400, Christoph Hellwig wrote:
>> On Mon, Apr 20, 2009 at 09:17:23PM +0530, Suresh Jayaraman wrote:
>>> +static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
>>> + struct file *filp, loff_t *ppos,
>>> + size_t count, unsigned int flags)
>>> +{
>>> + struct dentry *dentry = filp->f_path.dentry;
>>> +
>>> + dprintk("NFS splice_write(%s/%s, %lu@%Lu)\n",
>>> + dentry->d_parent->d_name.name, dentry->d_name.name,
>>> + (unsigned long) count, (unsigned long long) *ppos);
>>> +
>>> + return generic_file_splice_write(pipe, filp, ppos, count, flags);
>>> +}
>>> +
>> You need all calls from nfs_file_write, too:
>>
>> - most importantly the nfs_revalidate_file_size for O_APPEND
>
> Isn't O_APPEND illegal for splice_write()? It looks like it is from a
> quick perusal of do_splice_from().
Yes, I would also think so and also from upstream commit
efc968d450e013049a662d22727cf132618dcb2f.
I've added a little comment to make his clear.
>> - the nfs_do_fsync for sync writes
>
> generic_file_splice_write() calls generic_osync_inode(), which should
> ensure sync writes even with NFS.
> The one thing it won't do is propagate NFS write errors back to the
> caller. If we do care about this, then we should certainly test for
> nfs_need_sync_write() and then call nfs_do_fsync() (see
> nfs_file_write()).
I think it makes sense to propagate NFS write errors back.
>> - probably the stats increment
>
> We should talk to Chuck about this.
>
Have added it to NORMALBYTESWRITTEN based on Chuck's suggestion.
Here is the updated patch. Does this look OK?
Signed-off-by: Suresh Jayaraman <[email protected]>
---
fs/nfs/file.c | 32 ++++++++++++++++++++++++++++++++
1 files changed, 32 insertions(+), 0 deletions(-)
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 5a97bcf..6f2cd67 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -48,6 +48,9 @@ static ssize_t nfs_file_splice_read(struct file *filp, loff_t *ppos,
size_t count, unsigned int flags);
static ssize_t nfs_file_read(struct kiocb *, const struct iovec *iov,
unsigned long nr_segs, loff_t pos);
+static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
+ struct file *filp, loff_t *ppos,
+ size_t count, unsigned int flags);
static ssize_t nfs_file_write(struct kiocb *, const struct iovec *iov,
unsigned long nr_segs, loff_t pos);
static int nfs_file_flush(struct file *, fl_owner_t id);
@@ -73,6 +76,7 @@ const struct file_operations nfs_file_operations = {
.lock = nfs_lock,
.flock = nfs_flock,
.splice_read = nfs_file_splice_read,
+ .splice_write = nfs_file_splice_write,
.check_flags = nfs_check_flags,
.setlease = nfs_setlease,
};
@@ -587,6 +591,34 @@ out_swapfile:
goto out;
}
+static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
+ struct file *filp, loff_t *ppos,
+ size_t count, unsigned int flags)
+{
+ struct dentry *dentry = filp->f_path.dentry;
+ struct inode *inode = dentry->d_inode;
+ ssize_t ret;
+
+ dprintk("NFS splice_write(%s/%s, %lu@%llu)\n",
+ dentry->d_parent->d_name.name, dentry->d_name.name,
+ (unsigned long) count, (unsigned long long) *ppos);
+
+ /*
+ * We don't need to worry about O_APPEND as the combination of splice
+ * and an O_APPEND destination is disallowed.
+ */
+
+ nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, count);
+
+ ret = generic_file_splice_write(pipe, filp, ppos, count, flags);
+ if (ret >= 0 && nfs_need_sync_write(filp, inode)) {
+ int err = nfs_do_fsync(nfs_file_open_context(filp), inode);
+ if (err < 0)
+ ret = err;
+ }
+ return ret;
+}
+
static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
{
struct inode *inode = filp->f_mapping->host;