block/raw-posix: avoid bogus fixup for cylinders on DASD disks

[qemu.git] / block / nfs.c

diff --git a/block/nfs.c b/block/nfs.c
index c026ff6883311f2a9b16a4326ad1da97c6c3d4f4..fd79f89945e52e72cd9096c55f7714d25591d725 100644 (file)
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -43,6 +43,7 @@ typedef struct NFSClient {
     int events;
     bool has_zero_init;
     AioContext *aio_context;
     int events;
     bool has_zero_init;
     AioContext *aio_context;

+    blkcnt_t st_blocks;

 } NFSClient;
 
 typedef struct NFSRPC {
 } NFSClient;
 
 typedef struct NFSRPC {


@@ -62,11 +63,10 @@ static void nfs_set_events(NFSClient *client)
 {
     int ev = nfs_which_events(client->context);
     if (ev != client->events) {
 {
     int ev = nfs_which_events(client->context);
     if (ev != client->events) {

-        aio_set_fd_handler(client->aio_context,
-                           nfs_get_fd(client->context),
+        aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
+                           false,

                            (ev & POLLIN) ? nfs_process_read : NULL,
                            (ev & POLLIN) ? nfs_process_read : NULL,

-                           (ev & POLLOUT) ? nfs_process_write : NULL,
-                           client);
+                           (ev & POLLOUT) ? nfs_process_write : NULL, client);

 
     }
     client->events = ev;
 
     }
     client->events = ev;


@@ -241,9 +241,8 @@ static void nfs_detach_aio_context(BlockDriverState *bs)
 {
     NFSClient *client = bs->opaque;
 
 {
     NFSClient *client = bs->opaque;
 

-    aio_set_fd_handler(client->aio_context,
-                       nfs_get_fd(client->context),
-                       NULL, NULL, NULL);
+    aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
+                       false, NULL, NULL, NULL);

     client->events = 0;
 }
 
     client->events = 0;
 }
 


@@ -262,9 +261,8 @@ static void nfs_client_close(NFSClient *client)
         if (client->fh) {
             nfs_close(client->context, client->fh);
         }
         if (client->fh) {
             nfs_close(client->context, client->fh);
         }

-        aio_set_fd_handler(client->aio_context,
-                           nfs_get_fd(client->context),
-                           NULL, NULL, NULL);
+        aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
+                           false, NULL, NULL, NULL);

         nfs_destroy_context(client->context);
     }
     memset(client, 0, sizeof(NFSClient));
         nfs_destroy_context(client->context);
     }
     memset(client, 0, sizeof(NFSClient));


@@ -374,6 +372,7 @@ static int64_t nfs_client_open(NFSClient *client, const char *filename,
     }
 
     ret = DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE);
     }
 
     ret = DIV_ROUND_UP(st.st_size, BDRV_SECTOR_SIZE);

+    client->st_blocks = st.st_blocks;

     client->has_zero_init = S_ISREG(st.st_mode);
     goto out;
 fail:
     client->has_zero_init = S_ISREG(st.st_mode);
     goto out;
 fail:


@@ -464,6 +463,11 @@ static int64_t nfs_get_allocated_file_size(BlockDriverState *bs)
     NFSRPC task = {0};
     struct stat st;
 
     NFSRPC task = {0};
     struct stat st;
 

+    if (bdrv_is_read_only(bs) &&
+        !(bs->open_flags & BDRV_O_NOCACHE)) {
+        return client->st_blocks * 512;
+    }
+

     task.st = &st;
     if (nfs_fstat_async(client->context, client->fh, nfs_co_generic_cb,
                         &task) != 0) {
     task.st = &st;
     if (nfs_fstat_async(client->context, client->fh, nfs_co_generic_cb,
                         &task) != 0) {


@@ -475,7 +479,7 @@ static int64_t nfs_get_allocated_file_size(BlockDriverState *bs)
         aio_poll(client->aio_context, true);
     }
 
         aio_poll(client->aio_context, true);
     }
 

-    return (task.ret < 0 ? task.ret : st.st_blocks * st.st_blksize);
+    return (task.ret < 0 ? task.ret : st.st_blocks * 512);

 }
 
 static int nfs_file_truncate(BlockDriverState *bs, int64_t offset)
 }
 
 static int nfs_file_truncate(BlockDriverState *bs, int64_t offset)


@@ -484,6 +488,34 @@ static int nfs_file_truncate(BlockDriverState *bs, int64_t offset)
     return nfs_ftruncate(client->context, client->fh, offset);
 }
 
     return nfs_ftruncate(client->context, client->fh, offset);
 }
 

+/* Note that this will not re-establish a connection with the NFS server
+ * - it is effectively a NOP.  */
+static int nfs_reopen_prepare(BDRVReopenState *state,
+                              BlockReopenQueue *queue, Error **errp)
+{
+    NFSClient *client = state->bs->opaque;
+    struct stat st;
+    int ret = 0;
+
+    if (state->flags & BDRV_O_RDWR && bdrv_is_read_only(state->bs)) {
+        error_setg(errp, "Cannot open a read-only mount as read-write");
+        return -EACCES;
+    }
+
+    /* Update cache for read-only reopens */
+    if (!(state->flags & BDRV_O_RDWR)) {
+        ret = nfs_fstat(client->context, client->fh, &st);
+        if (ret < 0) {
+            error_setg(errp, "Failed to fstat file: %s",
+                       nfs_get_error(client->context));
+            return ret;
+        }
+        client->st_blocks = st.st_blocks;
+    }
+
+    return 0;
+}
+

 static BlockDriver bdrv_nfs = {
     .format_name                    = "nfs",
     .protocol_name                  = "nfs",
 static BlockDriver bdrv_nfs = {
     .format_name                    = "nfs",
     .protocol_name                  = "nfs",


@@ -499,6 +531,7 @@ static BlockDriver bdrv_nfs = {
     .bdrv_file_open                 = nfs_file_open,
     .bdrv_close                     = nfs_file_close,
     .bdrv_create                    = nfs_file_create,
     .bdrv_file_open                 = nfs_file_open,
     .bdrv_close                     = nfs_file_close,
     .bdrv_create                    = nfs_file_create,

+    .bdrv_reopen_prepare            = nfs_reopen_prepare,

 
     .bdrv_co_readv                  = nfs_co_readv,
     .bdrv_co_writev                 = nfs_co_writev,
 
     .bdrv_co_readv                  = nfs_co_readv,
     .bdrv_co_writev                 = nfs_co_writev,