Skip to contentSkip to conversation

9p: init_in_iov_from_pdu can truncate the size

PATCH Superseded Stefano Stabellini 3 participants 8 messages Dec 19, 2019 – Jan 6, 2020

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 9p: init_in_iov_from_pdu can truncate the size

From: Stefano Stabellini <[email protected]>

init_in_iov_from_pdu might not be able to allocate the full buffer size requested, which comes from the client and could be larger than the transport has available at the time of the request. Specifically, this can happen with read operations, with the client requesting a read up to the max allowed, which might be more than the transport has available at the time.

Today the implementation of init_in_iov_from_pdu throws an error, both Xen and Virtio.

Instead, change the V9fsTransport interface so that the size becomes a pointer and can be limited by the implementation of init_in_iov_from_pdu.

Change both the Xen and Virtio implementations to set the size to the size of the buffer they managed to allocate, instead of throwing an error.

---
 hw/9pfs/9p.c               | 22 +++++++++++++++-------
 hw/9pfs/9p.h               |  2 +-
 hw/9pfs/virtio-9p-device.c | 10 +++-------
 hw/9pfs/xen-9p-backend.c   | 12 ++++--------
 4 files changed, 23 insertions(+), 23 deletions(-)
hw/9pfs/9p.c +15 -7
index bdf7919abf..d6c89ce608 100644
@@ -1682,22 +1682,30 @@ out_nofid:
  * with qemu_iovec_destroy().
  */
 static void v9fs_init_qiov_from_pdu(QEMUIOVector *qiov, V9fsPDU *pdu,
-                                    size_t skip, size_t size,
+                                    size_t skip, size_t *size,
                                     bool is_write)
 {
     QEMUIOVector elem;
     struct iovec *iov;
     unsigned int niov;
+    size_t alloc_size = *size + skip;
 
     if (is_write) {
-        pdu->s->transport->init_out_iov_from_pdu(pdu, &iov, &niov, size + skip);
+        pdu->s->transport->init_out_iov_from_pdu(pdu, &iov, &niov, alloc_size);
     } else {
-        pdu->s->transport->init_in_iov_from_pdu(pdu, &iov, &niov, size + skip);
+        pdu->s->transport->init_in_iov_from_pdu(pdu, &iov, &niov, &alloc_size);
+    }
+
+    if (alloc_size < skip)
+    {
+        *size = 0;
+    } else {
+        *size = alloc_size - skip;
     }
 
     qemu_iovec_init_external(&elem, iov, niov);
     qemu_iovec_init(qiov, niov);
-    qemu_iovec_concat(qiov, &elem, skip, size);
+    qemu_iovec_concat(qiov, &elem, skip, *size);
 }
 
 static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
@@ -1722,7 +1730,7 @@ static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
     }
     offset += err;
 
-    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, read_count, false);
+    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, &read_count, false);
     err = v9fs_pack(qiov_full.iov, qiov_full.niov, 0,
                     ((char *)fidp->fs.xattr.value) + off,
                     read_count);
@@ -1852,7 +1860,7 @@ static void coroutine_fn v9fs_read(void *opaque)
         QEMUIOVector qiov;
         int32_t len;
 
-        v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4, max_count, false);
+        v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4, &max_count, false);
         qemu_iovec_init(&qiov, qiov_full.niov);
         do {
             qemu_iovec_reset(&qiov);
@@ -2085,7 +2093,7 @@ static void coroutine_fn v9fs_write(void *opaque)
         return;
     }
     offset += err;
-    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, count, true);
+    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, &count, true);
     trace_v9fs_write(pdu->tag, pdu->id, fid, off, count, qiov_full.niov);
 
     fidp = get_fid(pdu, fid);
hw/9pfs/9p.h +1 -1
index 8883761b2c..50f7e21da6 100644
@@ -365,7 +365,7 @@ struct V9fsTransport {
     ssize_t     (*pdu_vunmarshal)(V9fsPDU *pdu, size_t offset, const char *fmt,
                                   va_list ap);
     void        (*init_in_iov_from_pdu)(V9fsPDU *pdu, struct iovec **piov,
-                                        unsigned int *pniov, size_t size);
+                                        unsigned int *pniov, size_t *size);
     void        (*init_out_iov_from_pdu)(V9fsPDU *pdu, struct iovec **piov,
                                          unsigned int *pniov, size_t size);
     void        (*push_and_notify)(V9fsPDU *pdu);
hw/9pfs/virtio-9p-device.c +3 -7
index 775e8ff766..68873c3f5f 100644
@@ -145,19 +145,15 @@ static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, size_t offset,
 }
 
 static void virtio_init_in_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov,
-                                        unsigned int *pniov, size_t size)
+                                        unsigned int *pniov, size_t *size)
 {
     V9fsState *s = pdu->s;
     V9fsVirtioState *v = container_of(s, V9fsVirtioState, state);
     VirtQueueElement *elem = v->elems[pdu->idx];
     size_t buf_size = iov_size(elem->in_sg, elem->in_num);
 
-    if (buf_size < size) {
-        VirtIODevice *vdev = VIRTIO_DEVICE(v);
-
-        virtio_error(vdev,
-                     "VirtFS reply type %d needs %zu bytes, buffer has %zu",
-                     pdu->id + 1, size, buf_size);
+    if (buf_size < *size) {
+        *size = buf_size;
     }
 
     *piov = elem->in_sg;
hw/9pfs/xen-9p-backend.c +4 -8
index 3f54a21c76..3994a356d4 100644
@@ -187,7 +187,7 @@ static void xen_9pfs_init_out_iov_from_pdu(V9fsPDU *pdu,
 static void xen_9pfs_init_in_iov_from_pdu(V9fsPDU *pdu,
                                           struct iovec **piov,
                                           unsigned int *pniov,
-                                          size_t size)
+                                          size_t *size)
 {
     Xen9pfsDev *xen_9pfs = container_of(pdu->s, Xen9pfsDev, state);
     Xen9pfsRing *ring = &xen_9pfs->rings[pdu->tag % xen_9pfs->num_rings];
@@ -197,15 +197,11 @@ static void xen_9pfs_init_in_iov_from_pdu(V9fsPDU *pdu,
     g_free(ring->sg);
 
     ring->sg = g_malloc0(sizeof(*ring->sg) * 2);
-    xen_9pfs_in_sg(ring, ring->sg, &num, pdu->idx, size);
+    xen_9pfs_in_sg(ring, ring->sg, &num, pdu->idx, *size);
 
     buf_size = iov_size(ring->sg, num);
-    if (buf_size  < size) {
-        xen_pv_printf(&xen_9pfs->xendev, 0, "Xen 9pfs request type %d"
-                "needs %zu bytes, buffer has %zu\n", pdu->id, size,
-                buf_size);
-        xen_be_set_state(&xen_9pfs->xendev, XenbusStateClosing);
-        xen_9pfs_disconnect(&xen_9pfs->xendev);
+    if (buf_size  < *size) {
+        *size = buf_size;
     }
 
     *piov = ring->sg;
Signature · 1 line
2.17.1
#1 lore raw
Quoted 8 lines · On Donnerstag, 19. Dezember 2019 01:42:51 CET Stefano Stabellini wrote:

From: Stefano Stabellini <[email protected]>

init_in_iov_from_pdu might not be able to allocate the full buffer size requested, which comes from the client and could be larger than the transport has available at the time of the request. Specifically, this can happen with read operations, with the client requesting a read up to the max allowed, which might be more than the transport has available at the time.

I haven't looked thoroughly at this yet, but that's about addressing a temporary, not a permanent transport buffer size limitation, right? Because if it was a permanent one, then probably an adjusted (lowered) msize should be returned on R_version response to client as well.

I wonder why I never triggered this issue, because I was experimenting with huge msize values for 9pfs performance checks. Was there anything specific to trigger this issue?

Quoted 43 lines

Today the implementation of init_in_iov_from_pdu throws an error, both Xen and Virtio.

Instead, change the V9fsTransport interface so that the size becomes a pointer and can be limited by the implementation of init_in_iov_from_pdu.

Change both the Xen and Virtio implementations to set the size to the size of the buffer they managed to allocate, instead of throwing an error.

---
 hw/9pfs/9p.c               | 22 +++++++++++++++-------
 hw/9pfs/9p.h               |  2 +-
 hw/9pfs/virtio-9p-device.c | 10 +++-------
 hw/9pfs/xen-9p-backend.c   | 12 ++++--------
 4 files changed, 23 insertions(+), 23 deletions(-)
hw/9pfs/9p.c +2 -3
index bdf7919abf..d6c89ce608 100644
@@ -1682,22 +1682,30 @@ out_nofid:
  * with qemu_iovec_destroy().
  */
 static void v9fs_init_qiov_from_pdu(QEMUIOVector *qiov, V9fsPDU *pdu,
-                                    size_t skip, size_t size,
+                                    size_t skip, size_t *size,
                                     bool is_write)
 {
     QEMUIOVector elem;
     struct iovec *iov;
     unsigned int niov;
+    size_t alloc_size = *size + skip;
 
     if (is_write) {
-        pdu->s->transport->init_out_iov_from_pdu(pdu, &iov, &niov, size +
 skip); +        pdu->s->transport->init_out_iov_from_pdu(pdu, &iov, &niov,
 alloc_size); } else {
-        pdu->s->transport->init_in_iov_from_pdu(pdu, &iov, &niov, size +

hw/9pfs/9p.c out_nofid: · line 1705

Quoted 10 lines
hw/9pfs/9p.c +6 -0
 skip); +        pdu->s->transport->init_in_iov_from_pdu(pdu, &iov, &niov,
 &alloc_size); +    }
+
+    if (alloc_size < skip)
+    {
+        *size = 0;
+    } else {
+        *size = alloc_size - skip;
     }
 

Code style nitpicking:

ERROR: that open brace { should be on the previous line #56: FILE: hw/9pfs/9p.c:1699:
+ if (alloc_size < skip)
+ {

Quoted 91 lines
hw/9pfs/9p.c +2 -3
 static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
@@ -1722,7 +1730,7 @@ static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu,
 V9fsFidState *fidp, }
     offset += err;
 
-    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, read_count, false);
+    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, &read_count, false);
     err = v9fs_pack(qiov_full.iov, qiov_full.niov, 0,
                     ((char *)fidp->fs.xattr.value) + off,
                     read_count);
@@ -1852,7 +1860,7 @@ static void coroutine_fn v9fs_read(void *opaque)
         QEMUIOVector qiov;
         int32_t len;
 
-        v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4, max_count,
 false); +        v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4,
 &max_count, false); qemu_iovec_init(&qiov, qiov_full.niov);
         do {
             qemu_iovec_reset(&qiov);
@@ -2085,7 +2093,7 @@ static void coroutine_fn v9fs_write(void *opaque)
         return;
     }
     offset += err;
-    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, count, true);
+    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, &count, true);
     trace_v9fs_write(pdu->tag, pdu->id, fid, off, count, qiov_full.niov);
 
     fidp = get_fid(pdu, fid);
hw/9pfs/9p.h +1 -1
index 8883761b2c..50f7e21da6 100644
@@ -365,7 +365,7 @@ struct V9fsTransport {
     ssize_t     (*pdu_vunmarshal)(V9fsPDU *pdu, size_t offset, const char
 *fmt, va_list ap);
     void        (*init_in_iov_from_pdu)(V9fsPDU *pdu, struct iovec **piov,
-                                        unsigned int *pniov, size_t size);
+                                        unsigned int *pniov, size_t *size);
 void        (*init_out_iov_from_pdu)(V9fsPDU *pdu, struct iovec **piov,

unsigned int *pniov, size_t size); void (*push_and_notify)(V9fsPDU
*pdu);

hw/9pfs/virtio-9p-device.c +3 -6
index 775e8ff766..68873c3f5f 100644
@@ -145,19 +145,15 @@ static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu,
 size_t offset, }
 
 static void virtio_init_in_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov,
-                                        unsigned int *pniov, size_t size)
+                                        unsigned int *pniov, size_t *size)
 {
     V9fsState *s = pdu->s;
     V9fsVirtioState *v = container_of(s, V9fsVirtioState, state);
     VirtQueueElement *elem = v->elems[pdu->idx];
     size_t buf_size = iov_size(elem->in_sg, elem->in_num);
 
-    if (buf_size < size) {
-        VirtIODevice *vdev = VIRTIO_DEVICE(v);
-
-        virtio_error(vdev,
-                     "VirtFS reply type %d needs %zu bytes, buffer has
 %zu", -                     pdu->id + 1, size, buf_size);
+    if (buf_size < *size) {
+        *size = buf_size;
     }
 
     *piov = elem->in_sg;
hw/9pfs/xen-9p-backend.c +2 -3
index 3f54a21c76..3994a356d4 100644
@@ -187,7 +187,7 @@ static void xen_9pfs_init_out_iov_from_pdu(V9fsPDU *pdu,
 static void xen_9pfs_init_in_iov_from_pdu(V9fsPDU *pdu,
                                           struct iovec **piov,
                                           unsigned int *pniov,
-                                          size_t size)
+                                          size_t *size)
 {
     Xen9pfsDev *xen_9pfs = container_of(pdu->s, Xen9pfsDev, state);
     Xen9pfsRing *ring = &xen_9pfs->rings[pdu->tag % xen_9pfs->num_rings];
@@ -197,15 +197,11 @@ static void xen_9pfs_init_in_iov_from_pdu(V9fsPDU
 *pdu, g_free(ring->sg);
 
     ring->sg = g_malloc0(sizeof(*ring->sg) * 2);
-    xen_9pfs_in_sg(ring, ring->sg, &num, pdu->idx, size);
+    xen_9pfs_in_sg(ring, ring->sg, &num, pdu->idx, *size);
 
     buf_size = iov_size(ring->sg, num);
-    if (buf_size  < size) {

hw/9pfs/xen-9p-backend.c static void xen_9pfs_init_in_iov_from_pdu(V9fsPDU · line 207

Quoted 10 lines
hw/9pfs/xen-9p-backend.c +2 -5
-        xen_pv_printf(&xen_9pfs->xendev, 0, "Xen 9pfs request type %d"
-                "needs %zu bytes, buffer has %zu\n", pdu->id, size,
-                buf_size);
-        xen_be_set_state(&xen_9pfs->xendev, XenbusStateClosing);
-        xen_9pfs_disconnect(&xen_9pfs->xendev);
+    if (buf_size  < *size) {
+        *size = buf_size;
     }
 
     *piov = ring->sg;

Best regards,
Christian Schoenebeck

#2 lore raw
Quoted 10 lines · Christian Schoenebeck
Quoted 8 lines · On Donnerstag, 19. Dezember 2019 01:42:51 CET Stefano Stabellini wrote:

From: Stefano Stabellini <[email protected]>

init_in_iov_from_pdu might not be able to allocate the full buffer size requested, which comes from the client and could be larger than the transport has available at the time of the request. Specifically, this can happen with read operations, with the client requesting a read up to the max allowed, which might be more than the transport has available at the time.

Quoted 2 lines

I haven't looked thoroughly at this yet, but that's about addressing a temporary, not a permanent transport buffer size limitation, right?

Yes, that is correct.

Quoted 6 lines

Because if it was a permanent one, then probably an adjusted (lowered) msize should be returned on R_version response to client as well.

I wonder why I never triggered this issue, because I was experimenting with huge msize values for 9pfs performance checks. Was there anything specific to trigger this issue?

Lots of heavy usage by a Java application booting. Nothing like Java to stress the system :-)

Quoted 58 lines
Quoted 43 lines

Today the implementation of init_in_iov_from_pdu throws an error, both Xen and Virtio.

Instead, change the V9fsTransport interface so that the size becomes a pointer and can be limited by the implementation of init_in_iov_from_pdu.

Change both the Xen and Virtio implementations to set the size to the size of the buffer they managed to allocate, instead of throwing an error.

---
 hw/9pfs/9p.c               | 22 +++++++++++++++-------
 hw/9pfs/9p.h               |  2 +-
 hw/9pfs/virtio-9p-device.c | 10 +++-------
 hw/9pfs/xen-9p-backend.c   | 12 ++++--------
 4 files changed, 23 insertions(+), 23 deletions(-)
hw/9pfs/9p.c +2 -3
index bdf7919abf..d6c89ce608 100644
@@ -1682,22 +1682,30 @@ out_nofid:
  * with qemu_iovec_destroy().
  */
 static void v9fs_init_qiov_from_pdu(QEMUIOVector *qiov, V9fsPDU *pdu,
-                                    size_t skip, size_t size,
+                                    size_t skip, size_t *size,
                                     bool is_write)
 {
     QEMUIOVector elem;
     struct iovec *iov;
     unsigned int niov;
+    size_t alloc_size = *size + skip;
 
     if (is_write) {
-        pdu->s->transport->init_out_iov_from_pdu(pdu, &iov, &niov, size +
 skip); +        pdu->s->transport->init_out_iov_from_pdu(pdu, &iov, &niov,
 alloc_size); } else {
-        pdu->s->transport->init_in_iov_from_pdu(pdu, &iov, &niov, size +

hw/9pfs/9p.c out_nofid: · line 1705

Quoted 10 lines
hw/9pfs/9p.c +6 -0
 skip); +        pdu->s->transport->init_in_iov_from_pdu(pdu, &iov, &niov,
 &alloc_size); +    }
+
+    if (alloc_size < skip)
+    {
+        *size = 0;
+    } else {
+        *size = alloc_size - skip;
     }
 

Code style nitpicking:

ERROR: that open brace { should be on the previous line #56: FILE: hw/9pfs/9p.c:1699:

hw/9pfs/9p.c out_nofid: · line 1700

Quoted 2 lines
hw/9pfs/9p.c +2 -0
+    if (alloc_size < skip)
+    {

Oops, sorry! I can fix that.

Quoted 107 lines
Quoted 91 lines
hw/9pfs/9p.c +2 -3
 static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
@@ -1722,7 +1730,7 @@ static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu,
 V9fsFidState *fidp, }
     offset += err;
 
-    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, read_count, false);
+    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, &read_count, false);
     err = v9fs_pack(qiov_full.iov, qiov_full.niov, 0,
                     ((char *)fidp->fs.xattr.value) + off,
                     read_count);
@@ -1852,7 +1860,7 @@ static void coroutine_fn v9fs_read(void *opaque)
         QEMUIOVector qiov;
         int32_t len;
 
-        v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4, max_count,
 false); +        v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4,
 &max_count, false); qemu_iovec_init(&qiov, qiov_full.niov);
         do {
             qemu_iovec_reset(&qiov);
@@ -2085,7 +2093,7 @@ static void coroutine_fn v9fs_write(void *opaque)
         return;
     }
     offset += err;
-    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, count, true);
+    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, &count, true);
     trace_v9fs_write(pdu->tag, pdu->id, fid, off, count, qiov_full.niov);
 
     fidp = get_fid(pdu, fid);
hw/9pfs/9p.h +1 -1
index 8883761b2c..50f7e21da6 100644
@@ -365,7 +365,7 @@ struct V9fsTransport {
     ssize_t     (*pdu_vunmarshal)(V9fsPDU *pdu, size_t offset, const char
 *fmt, va_list ap);
     void        (*init_in_iov_from_pdu)(V9fsPDU *pdu, struct iovec **piov,
-                                        unsigned int *pniov, size_t size);
+                                        unsigned int *pniov, size_t *size);
 void        (*init_out_iov_from_pdu)(V9fsPDU *pdu, struct iovec **piov,

unsigned int *pniov, size_t size); void (*push_and_notify)(V9fsPDU
*pdu);

hw/9pfs/virtio-9p-device.c +3 -6
index 775e8ff766..68873c3f5f 100644
@@ -145,19 +145,15 @@ static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu,
 size_t offset, }
 
 static void virtio_init_in_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov,
-                                        unsigned int *pniov, size_t size)
+                                        unsigned int *pniov, size_t *size)
 {
     V9fsState *s = pdu->s;
     V9fsVirtioState *v = container_of(s, V9fsVirtioState, state);
     VirtQueueElement *elem = v->elems[pdu->idx];
     size_t buf_size = iov_size(elem->in_sg, elem->in_num);
 
-    if (buf_size < size) {
-        VirtIODevice *vdev = VIRTIO_DEVICE(v);
-
-        virtio_error(vdev,
-                     "VirtFS reply type %d needs %zu bytes, buffer has
 %zu", -                     pdu->id + 1, size, buf_size);
+    if (buf_size < *size) {
+        *size = buf_size;
     }
 
     *piov = elem->in_sg;
hw/9pfs/xen-9p-backend.c +2 -3
index 3f54a21c76..3994a356d4 100644
@@ -187,7 +187,7 @@ static void xen_9pfs_init_out_iov_from_pdu(V9fsPDU *pdu,
 static void xen_9pfs_init_in_iov_from_pdu(V9fsPDU *pdu,
                                           struct iovec **piov,
                                           unsigned int *pniov,
-                                          size_t size)
+                                          size_t *size)
 {
     Xen9pfsDev *xen_9pfs = container_of(pdu->s, Xen9pfsDev, state);
     Xen9pfsRing *ring = &xen_9pfs->rings[pdu->tag % xen_9pfs->num_rings];
@@ -197,15 +197,11 @@ static void xen_9pfs_init_in_iov_from_pdu(V9fsPDU
 *pdu, g_free(ring->sg);
 
     ring->sg = g_malloc0(sizeof(*ring->sg) * 2);
-    xen_9pfs_in_sg(ring, ring->sg, &num, pdu->idx, size);
+    xen_9pfs_in_sg(ring, ring->sg, &num, pdu->idx, *size);
 
     buf_size = iov_size(ring->sg, num);
-    if (buf_size  < size) {

hw/9pfs/xen-9p-backend.c static void xen_9pfs_init_in_iov_from_pdu(V9fsPDU · line 207

Quoted 10 lines
hw/9pfs/xen-9p-backend.c +2 -5
-        xen_pv_printf(&xen_9pfs->xendev, 0, "Xen 9pfs request type %d"
-                "needs %zu bytes, buffer has %zu\n", pdu->id, size,
-                buf_size);
-        xen_be_set_state(&xen_9pfs->xendev, XenbusStateClosing);
-        xen_9pfs_disconnect(&xen_9pfs->xendev);
+    if (buf_size  < *size) {
+        *size = buf_size;
     }
 
     *piov = ring->sg;

Best regards,
Christian Schoenebeck

#3 lore raw
Quoted 11 lines · On Donnerstag, 19. Dezember 2019 23:36:07 CET Stefano Stabellini wrote:
Quoted 10 lines · Christian Schoenebeck
Quoted 8 lines · On Donnerstag, 19. Dezember 2019 01:42:51 CET Stefano Stabellini wrote:

From: Stefano Stabellini <[email protected]>

init_in_iov_from_pdu might not be able to allocate the full buffer size requested, which comes from the client and could be larger than the transport has available at the time of the request. Specifically, this can happen with read operations, with the client requesting a read up to the max allowed, which might be more than the transport has available at the time.

Quoted 4 lines
Quoted 2 lines

I haven't looked thoroughly at this yet, but that's about addressing a temporary, not a permanent transport buffer size limitation, right?

Yes, that is correct.

One more thing ...

Quoted 17 lines
hw/9pfs/virtio-9p-device.c +1 -2
index 775e8ff766..68873c3f5f 100644
@@ -145,19 +145,15 @@ static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu,
 size_t offset, }
 
 static void virtio_init_in_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov,
-                                        unsigned int *pniov, size_t size)
+                                        unsigned int *pniov, size_t *size)
 {
     V9fsState *s = pdu->s;
     V9fsVirtioState *v = container_of(s, V9fsVirtioState, state);
     VirtQueueElement *elem = v->elems[pdu->idx];
     size_t buf_size = iov_size(elem->in_sg, elem->in_num);
 
-    if (buf_size < size) {

hw/9pfs/virtio-9p-device.c static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, · line 159

Quoted 10 lines
hw/9pfs/virtio-9p-device.c +2 -4
-        VirtIODevice *vdev = VIRTIO_DEVICE(v);
-
-        virtio_error(vdev,
-                     "VirtFS reply type %d needs %zu bytes, buffer has
 %zu", -                     pdu->id + 1, size, buf_size);
+    if (buf_size < *size) {
+        *size = buf_size;
     }
 
     *piov = elem->in_sg;

Here could be a problem: what happens if the currently available transport buffer size is extremely small, i.e. less than P9_IOHDRSZ? I am not sure that would be handled safely everywhere. So maybe it would make sense to make transport buffer size < P9_IOHDRSZ an error case here?

Best regards,
Christian Schoenebeck

#4 lore raw
In reply to Stefano Stabellini
Quoted 80 lines · On Wed, 18 Dec 2019 16:42:51 -0800 Stefano Stabellini <[email protected]>…

From: Stefano Stabellini <[email protected]>

init_in_iov_from_pdu might not be able to allocate the full buffer size requested, which comes from the client and could be larger than the transport has available at the time of the request. Specifically, this can happen with read operations, with the client requesting a read up to the max allowed, which might be more than the transport has available at the time.

Today the implementation of init_in_iov_from_pdu throws an error, both Xen and Virtio.

Instead, change the V9fsTransport interface so that the size becomes a pointer and can be limited by the implementation of init_in_iov_from_pdu.

Change both the Xen and Virtio implementations to set the size to the size of the buffer they managed to allocate, instead of throwing an error.

---
 hw/9pfs/9p.c               | 22 +++++++++++++++-------
 hw/9pfs/9p.h               |  2 +-
 hw/9pfs/virtio-9p-device.c | 10 +++-------
 hw/9pfs/xen-9p-backend.c   | 12 ++++--------
 4 files changed, 23 insertions(+), 23 deletions(-)
hw/9pfs/9p.c +13 -5
index bdf7919abf..d6c89ce608 100644
@@ -1682,22 +1682,30 @@ out_nofid:
  * with qemu_iovec_destroy().
  */
 static void v9fs_init_qiov_from_pdu(QEMUIOVector *qiov, V9fsPDU *pdu,
-                                    size_t skip, size_t size,
+                                    size_t skip, size_t *size,
                                     bool is_write)
 {
     QEMUIOVector elem;
     struct iovec *iov;
     unsigned int niov;
+    size_t alloc_size = *size + skip;
 
     if (is_write) {
-        pdu->s->transport->init_out_iov_from_pdu(pdu, &iov, &niov, size + skip);
+        pdu->s->transport->init_out_iov_from_pdu(pdu, &iov, &niov, alloc_size);
     } else {
-        pdu->s->transport->init_in_iov_from_pdu(pdu, &iov, &niov, size + skip);
+        pdu->s->transport->init_in_iov_from_pdu(pdu, &iov, &niov, &alloc_size);
+    }
+
+    if (alloc_size < skip)
+    {
+        *size = 0;
+    } else {
+        *size = alloc_size - skip;
     }
     qemu_iovec_init_external(&elem, iov, niov);
     qemu_iovec_init(qiov, niov);
-    qemu_iovec_concat(qiov, &elem, skip, size);
+    qemu_iovec_concat(qiov, &elem, skip, *size);
 }
 
 static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
@@ -1722,7 +1730,7 @@ static int v9fs_xattr_read(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp,
     }
     offset += err;
 
-    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, read_count, false);
+    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, &read_count, false);
 
 
     err = v9fs_pack(qiov_full.iov, qiov_full.niov, 0,
                     ((char *)fidp->fs.xattr.value) + off,
                     read_count);

hw/9pfs/9p.c static void coroutine_fn v9fs_read(void *opaque) · line 1863

Quoted 5 lines
hw/9pfs/9p.c +1 -1
@@ -1852,7 +1860,7 @@ static void coroutine_fn v9fs_read(void *opaque)
         QEMUIOVector qiov;
         int32_t len;
 
-        v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4, max_count, false);
+        v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4, &max_count, false);

This doesn't build:

hw/9pfs/9p.c: In function ‘v9fs_read’:
hw/9pfs/9p.c:2271:62: error: passing argument 4 of ‘v9fs_init_qiov_from_pdu’ from incompatible pointer type [-Werror=incompatible-pointer-types]

 2271 |         v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset + 4, &max_count, false);
      |                                                              ^~~~~~~~~~
      |                                                              |
      |                                                              uint32_t * {aka unsigned int *}

hw/9pfs/9p.c:2093:58: note: expected ‘size_t *’ {aka ‘long unsigned int *’} but argument is of type ‘uint32_t *’ {aka ‘unsigned int *’}
2093 | size_t skip, size_t *size,
| ~~~~~~~~^~~~

hw/9pfs/9p.c static void coroutine_fn v9fs_write(void *opaque) · line 2096

Quoted 9 lines
hw/9pfs/9p.c +1 -1
         qemu_iovec_init(&qiov, qiov_full.niov);
         do {
             qemu_iovec_reset(&qiov);
@@ -2085,7 +2093,7 @@ static void coroutine_fn v9fs_write(void *opaque)
         return;
     }
     offset += err;
-    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, count, true);
+    v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, &count, true);

Same here.

hw/9pfs/9p.c: In function ‘v9fs_write’:
hw/9pfs/9p.c:2527:54: error: passing argument 4 of ‘v9fs_init_qiov_from_pdu’ from incompatible pointer type [-Werror=incompatible-pointer-types]

 2527 |     v9fs_init_qiov_from_pdu(&qiov_full, pdu, offset, &count, true);
      |                                                      ^~~~~~
      |                                                      |
      |                                                      uint32_t * {aka unsigned int *}

hw/9pfs/9p.c:2093:58: note: expected ‘size_t *’ {aka ‘long unsigned int *’} but argument is of type ‘uint32_t *’ {aka ‘unsigned int *’}
2093 | size_t skip, size_t *size,
| ~~~~~~~~^~~~

Quoted 31 lines
hw/9pfs/9p.c +0 -0
     trace_v9fs_write(pdu->tag, pdu->id, fid, off, count, qiov_full.niov);
 
     fidp = get_fid(pdu, fid);
hw/9pfs/9p.h +1 -1
index 8883761b2c..50f7e21da6 100644
@@ -365,7 +365,7 @@ struct V9fsTransport {
     ssize_t     (*pdu_vunmarshal)(V9fsPDU *pdu, size_t offset, const char *fmt,
                                   va_list ap);
     void        (*init_in_iov_from_pdu)(V9fsPDU *pdu, struct iovec **piov,
-                                        unsigned int *pniov, size_t size);
+                                        unsigned int *pniov, size_t *size);
     void        (*init_out_iov_from_pdu)(V9fsPDU *pdu, struct iovec **piov,
                                          unsigned int *pniov, size_t size);
     void        (*push_and_notify)(V9fsPDU *pdu);
hw/9pfs/virtio-9p-device.c +1 -1
index 775e8ff766..68873c3f5f 100644
@@ -145,19 +145,15 @@ static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, size_t offset,
 }
 
 static void virtio_init_in_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov,
-                                        unsigned int *pniov, size_t size)
+                                        unsigned int *pniov, size_t *size)
 {
     V9fsState *s = pdu->s;
     V9fsVirtioState *v = container_of(s, V9fsVirtioState, state);
     VirtQueueElement *elem = v->elems[pdu->idx];
     size_t buf_size = iov_size(elem->in_sg, elem->in_num);

hw/9pfs/virtio-9p-device.c static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, size_t offset, · line 157

Quoted 10 lines
hw/9pfs/virtio-9p-device.c +2 -6
 
-    if (buf_size < size) {
-        VirtIODevice *vdev = VIRTIO_DEVICE(v);
-
-        virtio_error(vdev,
-                     "VirtFS reply type %d needs %zu bytes, buffer has %zu",
-                     pdu->id + 1, size, buf_size);
+    if (buf_size < *size) {
+        *size = buf_size;
     }

As suggested by Christian in some other mail, it could still make sense to raise the error if there isn't even enough space to pack a 9p message header.

Quoted 17 lines
hw/9pfs/virtio-9p-device.c +0 -0
     *piov = elem->in_sg;
hw/9pfs/xen-9p-backend.c +1 -1
index 3f54a21c76..3994a356d4 100644
@@ -187,7 +187,7 @@ static void xen_9pfs_init_out_iov_from_pdu(V9fsPDU *pdu,
 static void xen_9pfs_init_in_iov_from_pdu(V9fsPDU *pdu,
                                           struct iovec **piov,
                                           unsigned int *pniov,
-                                          size_t size)
+                                          size_t *size)
 {
     Xen9pfsDev *xen_9pfs = container_of(pdu->s, Xen9pfsDev, state);
     Xen9pfsRing *ring = &xen_9pfs->rings[pdu->tag % xen_9pfs->num_rings];

hw/9pfs/xen-9p-backend.c static void xen_9pfs_init_in_iov_from_pdu(V9fsPDU *pdu, · line 201

Quoted 6 lines
hw/9pfs/xen-9p-backend.c +1 -1
@@ -197,15 +197,11 @@ static void xen_9pfs_init_in_iov_from_pdu(V9fsPDU *pdu,
     g_free(ring->sg);
 
     ring->sg = g_malloc0(sizeof(*ring->sg) * 2);
-    xen_9pfs_in_sg(ring, ring->sg, &num, pdu->idx, size);
+    xen_9pfs_in_sg(ring, ring->sg, &num, pdu->idx, *size);
 

This chunk doesn't apply on master:

<<<<<<<

    ring->sg = g_new0(struct iovec, 2);
    xen_9pfs_in_sg(ring, ring->sg, &num, pdu->idx, size);
=======
    ring->sg = g_malloc0(sizeof(*ring->sg) * 2);
    xen_9pfs_in_sg(ring, ring->sg, &num, pdu->idx, *size);
Quoted 15 lines
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
Quoted 1 line
     buf_size = iov_size(ring->sg, num);
hw/9pfs/xen-9p-backend.c +2 -6
-    if (buf_size  < size) {
-        xen_pv_printf(&xen_9pfs->xendev, 0, "Xen 9pfs request type %d"
-                "needs %zu bytes, buffer has %zu\n", pdu->id, size,
-                buf_size);
-        xen_be_set_state(&xen_9pfs->xendev, XenbusStateClosing);
-        xen_9pfs_disconnect(&xen_9pfs->xendev);
+    if (buf_size  < *size) {
+        *size = buf_size;
     }
 
     *piov = ring->sg;
#5 lore raw
Quoted 31 lines · On Montag, 6. Januar 2020 14:42:54 CET Greg Kurz wrote:
Quoted 31 lines
hw/9pfs/virtio-9p-device.c +0 -0
index 775e8ff766..68873c3f5f 100644
@@ -145,19 +145,15 @@ static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu,

size_t offset,>
}

static void virtio_init_in_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov,

hw/9pfs/virtio-9p-device.c +1 -1
-                                        unsigned int *pniov, size_t size)
+                                        unsigned int *pniov, size_t

*size)

{

     V9fsState *s = pdu->s;
     V9fsVirtioState *v = container_of(s, V9fsVirtioState, state);
     VirtQueueElement *elem = v->elems[pdu->idx];
     size_t buf_size = iov_size(elem->in_sg, elem->in_num);
hw/9pfs/virtio-9p-device.c +0 -5
-    if (buf_size < size) {
-        VirtIODevice *vdev = VIRTIO_DEVICE(v);
-
-        virtio_error(vdev,
-                     "VirtFS reply type %d needs %zu bytes, buffer has

%zu", - pdu->id + 1, size, buf_size);

hw/9pfs/virtio-9p-device.c +2 -0
+    if (buf_size < *size) {
+        *size = buf_size;
Quoted 5 lines
Quoted 1 line
     }

As suggested by Christian in some other mail, it could still make sense to raise the error if there isn't even enough space to pack a 9p message header.

Another option: Instead of handling this as a hard error (which they probably try to avoid in their use case): putting the handler asleep for a while by calling qemu_co_sleep_ns_wakeable() in this case. Then a bit later transport would eventually have the required buffer size and handler could continue the request without an error.

But this would require more care. For instance subsequent request handlers would need to check if there was already an event handler asleep, and if so it would either need to wake it up or put itself asleep as well to prevent the request order being processed by server being messed up.

Best regards,
Christian Schoenebeck

#6 lore raw
Quoted 38 lines · On Mon, 06 Jan 2020 16:24:18 +0100 Christian Schoenebeck…
Quoted 31 lines · On Montag, 6. Januar 2020 14:42:54 CET Greg Kurz wrote:
Quoted 31 lines
hw/9pfs/virtio-9p-device.c +0 -0
index 775e8ff766..68873c3f5f 100644
@@ -145,19 +145,15 @@ static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu,

size_t offset,>
}

static void virtio_init_in_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov,

hw/9pfs/virtio-9p-device.c +1 -1
-                                        unsigned int *pniov, size_t size)
+                                        unsigned int *pniov, size_t

*size)

{

     V9fsState *s = pdu->s;
     V9fsVirtioState *v = container_of(s, V9fsVirtioState, state);
     VirtQueueElement *elem = v->elems[pdu->idx];
     size_t buf_size = iov_size(elem->in_sg, elem->in_num);
hw/9pfs/virtio-9p-device.c +0 -5
-    if (buf_size < size) {
-        VirtIODevice *vdev = VIRTIO_DEVICE(v);
-
-        virtio_error(vdev,
-                     "VirtFS reply type %d needs %zu bytes, buffer has

%zu", - pdu->id + 1, size, buf_size);

hw/9pfs/virtio-9p-device.c +2 -0
+    if (buf_size < *size) {
+        *size = buf_size;
Quoted 5 lines
Quoted 1 line
     }

As suggested by Christian in some other mail, it could still make sense to raise the error if there isn't even enough space to pack a 9p message header.

Quoted 6 lines

Another option: Instead of handling this as a hard error (which they probably try to avoid in their use case): putting the handler asleep for a while by calling qemu_co_sleep_ns_wakeable() in this case. Then a bit later transport would eventually have the required buffer size and handler could continue the request without an error.

Waiting for an arbitrary amount of time (how much?) and retrying doesn't give any guarantee either that things will go smoothly. If anything, I'd rather have the transport to wake up the request when more buffer space gets available.

Quoted 5 lines

But this would require more care. For instance subsequent request handlers would need to check if there was already an event handler asleep, and if so it would either need to wake it up or put itself asleep as well to prevent the request order being processed by server being messed up.

And so on... ie. we would need to handle a queue of sleeping requests IIUC. Not really fan to go this way to address what looks like a corner case.

Quoted 4 lines

Best regards,
Christian Schoenebeck

#7 lore raw
Quoted 52 lines · Greg Kurz
Quoted 38 lines · On Mon, 06 Jan 2020 16:24:18 +0100 Christian Schoenebeck…
Quoted 31 lines · On Montag, 6. Januar 2020 14:42:54 CET Greg Kurz wrote:
Quoted 31 lines
hw/9pfs/virtio-9p-device.c +0 -0
index 775e8ff766..68873c3f5f 100644
@@ -145,19 +145,15 @@ static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu,

size_t offset,>
}

static void virtio_init_in_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov,

hw/9pfs/virtio-9p-device.c +1 -1
-                                        unsigned int *pniov, size_t size)
+                                        unsigned int *pniov, size_t

*size)

{

     V9fsState *s = pdu->s;
     V9fsVirtioState *v = container_of(s, V9fsVirtioState, state);
     VirtQueueElement *elem = v->elems[pdu->idx];
     size_t buf_size = iov_size(elem->in_sg, elem->in_num);
hw/9pfs/virtio-9p-device.c +0 -5
-    if (buf_size < size) {
-        VirtIODevice *vdev = VIRTIO_DEVICE(v);
-
-        virtio_error(vdev,
-                     "VirtFS reply type %d needs %zu bytes, buffer has

%zu", - pdu->id + 1, size, buf_size);

hw/9pfs/virtio-9p-device.c +2 -0
+    if (buf_size < *size) {
+        *size = buf_size;
Quoted 5 lines
Quoted 1 line
     }

As suggested by Christian in some other mail, it could still make sense to raise the error if there isn't even enough space to pack a 9p message header.

Quoted 6 lines

Another option: Instead of handling this as a hard error (which they probably try to avoid in their use case): putting the handler asleep for a while by calling qemu_co_sleep_ns_wakeable() in this case. Then a bit later transport would eventually have the required buffer size and handler could continue the request without an error.

Waiting for an arbitrary amount of time (how much?) and retrying doesn't give any guarantee either that things will go smoothly. If anything, I'd rather have the transport to wake up the request when more buffer space gets available.

Quoted 8 lines
Quoted 5 lines

But this would require more care. For instance subsequent request handlers would need to check if there was already an event handler asleep, and if so it would either need to wake it up or put itself asleep as well to prevent the request order being processed by server being messed up.

And so on... ie. we would need to handle a queue of sleeping requests IIUC. Not really fan to go this way to address what looks like a corner case.

I agree with you that handling requests queuing is complex and overkill for this. As I don't have a better suggestion, I am going to go with retaining the error if the allocated buf_size is less than P9_IOHDRSZ.