At runtime (that is, during a future ssh_truncate()), the SSH session is
non-blocking.  However, ssh_truncate() (or rather, bdrv_truncate() in
general) is not a coroutine, so this resize operation needs to block.

For ssh_create(), that is fine, too; the session is never set to
non-blocking anyway.

Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/ssh.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/block/ssh.c b/block/ssh.c
index 964e55f7fe..ff8576f21e 100644
--- a/block/ssh.c
+++ b/block/ssh.c
@@ -803,17 +803,24 @@ static int ssh_file_open(BlockDriverState *bs, QDict *options, int bdrv_flags,
     return ret;
 }
 
+/* Note: This is a blocking operation */
 static int ssh_grow_file(BDRVSSHState *s, int64_t offset, Error **errp)
 {
     ssize_t ret;
     char c[1] = { '\0' };
+    int was_blocking = libssh2_session_get_blocking(s->session);
 
     /* offset must be strictly greater than the current size so we do
      * not overwrite anything */
     assert(offset > 0 && offset > s->attrs.filesize);
 
+    libssh2_session_set_blocking(s->session, 1);
+
     libssh2_sftp_seek64(s->sftp_handle, offset - 1);
     ret = libssh2_sftp_write(s->sftp_handle, c, 1);
+
+    libssh2_session_set_blocking(s->session, was_blocking);
+
     if (ret < 0) {
         sftp_error_setg(errp, s, "Failed to grow file");
         return -EIO;
-- 
2.14.3

On 02/14/2018 02:49 PM, Max Reitz wrote:
> At runtime (that is, during a future ssh_truncate()), the SSH session is
> non-blocking.  However, ssh_truncate() (or rather, bdrv_truncate() in
> general) is not a coroutine, so this resize operation needs to block.
> 
> For ssh_create(), that is fine, too; the session is never set to
> non-blocking anyway.
> 
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> ---
>   block/ssh.c | 7 +++++++
>   1 file changed, 7 insertions(+)
> 
> diff --git a/block/ssh.c b/block/ssh.c
> index 964e55f7fe..ff8576f21e 100644
> --- a/block/ssh.c
> +++ b/block/ssh.c
> @@ -803,17 +803,24 @@ static int ssh_file_open(BlockDriverState *bs, QDict *options, int bdrv_flags,
>       return ret;
>   }
>   
> +/* Note: This is a blocking operation */
>   static int ssh_grow_file(BDRVSSHState *s, int64_t offset, Error **errp)
>   {
>       ssize_t ret;
>       char c[1] = { '\0' };
> +    int was_blocking = libssh2_session_get_blocking(s->session);
>   
>       /* offset must be strictly greater than the current size so we do
>        * not overwrite anything */
>       assert(offset > 0 && offset > s->attrs.filesize);
>   
> +    libssh2_session_set_blocking(s->session, 1);
> +
>       libssh2_sftp_seek64(s->sftp_handle, offset - 1);
>       ret = libssh2_sftp_write(s->sftp_handle, c, 1);
> +
> +    libssh2_session_set_blocking(s->session, was_blocking);

Is it worth skipping the two libssh2_session_set_blocking() calls if 
was_blocking is 1?  But that's a micro-optimization that probably won't 
be noticeable, so I'm also fine with unconditional.

Reviewed-by: Eric Blake <eblake@redhat.com>

-- 
Eric Blake, Principal Software Engineer
Red Hat, Inc.           +1-919-301-3266
Virtualization:  qemu.org | libvirt.org

On 2018-02-14 22:11, Eric Blake wrote:
> On 02/14/2018 02:49 PM, Max Reitz wrote:
>> At runtime (that is, during a future ssh_truncate()), the SSH session is
>> non-blocking.  However, ssh_truncate() (or rather, bdrv_truncate() in
>> general) is not a coroutine, so this resize operation needs to block.
>>
>> For ssh_create(), that is fine, too; the session is never set to
>> non-blocking anyway.
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> ---
>>   block/ssh.c | 7 +++++++
>>   1 file changed, 7 insertions(+)
>>
>> diff --git a/block/ssh.c b/block/ssh.c
>> index 964e55f7fe..ff8576f21e 100644
>> --- a/block/ssh.c
>> +++ b/block/ssh.c
>> @@ -803,17 +803,24 @@ static int ssh_file_open(BlockDriverState *bs,
>> QDict *options, int bdrv_flags,
>>       return ret;
>>   }
>>   +/* Note: This is a blocking operation */
>>   static int ssh_grow_file(BDRVSSHState *s, int64_t offset, Error **errp)
>>   {
>>       ssize_t ret;
>>       char c[1] = { '\0' };
>> +    int was_blocking = libssh2_session_get_blocking(s->session);
>>         /* offset must be strictly greater than the current size so we do
>>        * not overwrite anything */
>>       assert(offset > 0 && offset > s->attrs.filesize);
>>   +    libssh2_session_set_blocking(s->session, 1);
>> +
>>       libssh2_sftp_seek64(s->sftp_handle, offset - 1);
>>       ret = libssh2_sftp_write(s->sftp_handle, c, 1);
>> +
>> +    libssh2_session_set_blocking(s->session, was_blocking);
> 
> Is it worth skipping the two libssh2_session_set_blocking() calls if
> was_blocking is 1?  But that's a micro-optimization that probably won't
> be noticeable, so I'm also fine with unconditional.

I was hoping libssh2 is clever enough for that itself. :-)

> Reviewed-by: Eric Blake <eblake@redhat.com>

Thanks!

Max