9p queue 2022-10-24
[PULL 03/23] 9pfs: use GHashTable for fid table
In reply to Christian SchoenebeckFrom: Linus Heckemann <[email protected]>
The previous implementation would iterate over the fid table for lookup operations, resulting in an operation with O(n) complexity on the number of open files and poor cache locality -- for every open, stat, read, write, etc operation.
This change uses a hashtable for this instead, significantly improving the performance of the 9p filesystem. The runtime of NixOS's simple installer test, which copies ~122k files totalling ~1.8GiB from 9p, decreased by a factor of about 10.
[CS: - Retain BUG_ON(f->clunked) in get_fid().
- Add TODO comment in clunk_fid(). ]
Message-Id: <[email protected]>
--- hw/9pfs/9p.c | 196 +++++++++++++++++++++++++++++---------------------- hw/9pfs/9p.h | 2 +- 2 files changed, 113 insertions(+), 85 deletions(-)
hw/9pfs/9p.c +112 -84
@@ -256,7 +256,8 @@ static size_t v9fs_string_size(V9fsString *str) }/* -* returns 0 if fid got re-opened, 1 if not, < 0 on error */ +* returns 0 if fid got re-opened, 1 if not, < 0 on error +*/ static int coroutine_fn v9fs_reopen_fid(V9fsPDU *pdu, V9fsFidState *f) {int err =1 ;
@@ -282,33 +283,32 @@ static V9fsFidState *coroutine_fn get_fid(V9fsPDU *pdu, int32_t fid)V9fsFidState *f;V9fsState *s = pdu->s; - QSIMPLEQ_FOREACH(f, &s->fid_list, next) { + f =g_hash_table_lookup (s->fids,GINT_TO_POINTER (fid)); +if (f) {BUG_ON (f->clunked); -if (f->fid == fid) { -/* -* Update the fid ref upfront so that -* we don't get reclaimed when we yield -* in open later. -*/ - f->ref++; -/* -* check whether we need to reopen the -* file. We might have closed the fd -* while trying to free up some file -* descriptors. -*/ - err =v9fs_reopen_fid (pdu, f); -if (err <0 ) { - f->ref--; -return NULL ; - } -/* -* Mark the fid as referenced so that the LRU -* reclaim won't close the file descriptor -*/ - f->flags |=FID_REFERENCED ; -return f; +/* +* Update the fid ref upfront so that +* we don't get reclaimed when we yield +* in open later. +*/ + f->ref++; +/* +* check whether we need to reopen the +* file. We might have closed the fd +* while trying to free up some file +* descriptors. +*/ + err =v9fs_reopen_fid (pdu, f); +if (err <0 ) { + f->ref--; +return NULL ; } +/* +* Mark the fid as referenced so that the LRU +* reclaim won't close the file descriptor +*/ + f->flags |=FID_REFERENCED ; +return f; }return NULL ; }
@@ -317,12 +317,11 @@ static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid) {V9fsFidState *f; - QSIMPLEQ_FOREACH(f, &s->fid_list, next) { + f =g_hash_table_lookup (s->fids,GINT_TO_POINTER (fid)); +if (f) {/* If fid is already there return NULL */ BUG_ON (f->clunked); -if (f->fid == fid) { -return NULL ; - } +return NULL ; } f =g_new0 (V9fsFidState,1 ); f->fid = fid;
@@ -333,7 +332,7 @@ static V9fsFidState *alloc_fid(V9fsState *s, int32_t fid)* reclaim won't close the file descriptor */ f->flags |=FID_REFERENCED ; -QSIMPLEQ_INSERT_TAIL (&s->fid_list, f, next); +g_hash_table_insert (s->fids,GINT_TO_POINTER (fid), f);v9fs_readdir_init (s->proto_version, &f->fs.dir);v9fs_readdir_init (s->proto_version, &f->fs_reclaim.dir);
@@ -424,12 +423,12 @@ static V9fsFidState *clunk_fid(V9fsState *s, int32_t fid) {V9fsFidState *fidp; - QSIMPLEQ_FOREACH(fidp, &s->fid_list, next) { -if (fidp->fid == fid) { -QSIMPLEQ_REMOVE (&s->fid_list, fidp, V9fsFidState, next); - fidp->clunked = true; -return fidp; - } +/* TODO: Use g_hash_table_steal_extended() instead? */ + fidp =g_hash_table_lookup (s->fids,GINT_TO_POINTER (fid)); +if (fidp) { +g_hash_table_remove (s->fids,GINT_TO_POINTER (fid)); + fidp->clunked = true; +return fidp; }return NULL ; }
@@ -439,10 +438,15 @@ void coroutine_fn v9fs_reclaim_fd(V9fsPDU *pdu)int reclaim_count =0 ;V9fsState *s = pdu->s;V9fsFidState *f; +GHashTableIter iter; +gpointer fid; + +g_hash_table_iter_init (&iter, s->fids); + QSLIST_HEAD(, V9fsFidState) reclaim_list =QSLIST_HEAD_INITIALIZER (reclaim_list); - QSIMPLEQ_FOREACH(f, &s->fid_list, next) { +while (g_hash_table_iter_next (&iter, &fid, (gpointer *) &f)) {/* * Unlink fids cannot be reclaimed. Check * for them and skip them. Also skip fids
@@ -514,72 +518,85 @@ void coroutine_fn v9fs_reclaim_fd(V9fsPDU *pdu) } } +/* +* This is used when a path is removed from the directory tree. Any +* fids that still reference it must not be closed from then on, since +* they cannot be reopened. +*/ static int coroutine_fn v9fs_mark_fids_unreclaim(V9fsPDU *pdu, V9fsPath *path) { -int err; +int err =0 ;V9fsState *s = pdu->s; -V9fsFidState *fidp, *fidp_next; +V9fsFidState *fidp; +gpointer fid; +GHashTableIter iter; +/* +* The most common case is probably that we have exactly one +* fid for the given path, so preallocate exactly one. +*/ +g_autoptr (GArray) to_reopen =g_array_sized_new (FALSE, FALSE, +sizeof (V9fsFidState *),1 ); +gint i; - fidp =QSIMPLEQ_FIRST (&s->fid_list); -if (!fidp) { -return 0 ; - } +g_hash_table_iter_init (&iter, s->fids);/* -* v9fs_reopen_fid() can yield : a reference on the fid must be held -* to ensure its pointer remains valid and we can safely pass it to -* QSIMPLEQ_NEXT(). The corresponding put_fid() can also yield so -* we must keep a reference on the next fid as well. So the logic here -* is to get a reference on a fid and only put it back during the next -* iteration after we could get a reference on the next fid. Start with -* the first one. +* We iterate over the fid table looking for the entries we need +* to reopen, and store them in to_reopen. This is because +* v9fs_reopen_fid() and put_fid() yield. This allows the fid table +* to be modified in the meantime, invalidating our iterator. */ -for (fidp->ref++; fidp; fidp = fidp_next) { +while (g_hash_table_iter_next (&iter, &fid, (gpointer *) &fidp)) {if (fidp->path.size == path->size && !memcmp (fidp->path.data, path->data, path->size)) { -/* Mark the fid non reclaimable. */ - fidp->flags |=FID_NON_RECLAIMABLE ; - -/* reopen the file/dir if already closed */ - err =v9fs_reopen_fid (pdu, fidp); -if (err <0 ) { -put_fid (pdu, fidp); -return err; - } - } - - fidp_next =QSIMPLEQ_NEXT (fidp, next); - -if (fidp_next) {/* -* Ensure the next fid survives a potential clunk request during -* put_fid() below and v9fs_reopen_fid() in the next iteration. +* Ensure the fid survives a potential clunk request during +* v9fs_reopen_fid or put_fid. */ - fidp_next->ref++; + fidp->ref++; + fidp->flags |=FID_NON_RECLAIMABLE ; +g_array_append_val (to_reopen, fidp); } - -/* We're done with this fid */ -put_fid (pdu, fidp); } -return 0 ; +for (i =0 ; i < to_reopen->len; i++) { + fidp = g_array_index(to_reopen, V9fsFidState*, i); +/* reopen the file/dir if already closed */ + err =v9fs_reopen_fid (pdu, fidp); +if (err <0 ) { +break ; + } + } + +for (i =0 ; i < to_reopen->len; i++) { + put_fid(pdu, g_array_index(to_reopen, V9fsFidState*, i)); + } +return err; } static void coroutine_fn virtfs_reset(V9fsPDU *pdu) {V9fsState *s = pdu->s;V9fsFidState *fidp; +GList *freeing; +/* +* Get a list of all the values (fid states) in the table, which +* we then... +*/ +g_autoptr (GList) fids =g_hash_table_get_values (s->fids); -/* Free all fids */ -while (!QSIMPLEQ_EMPTY (&s->fid_list)) { -/* Get fid */ - fidp =QSIMPLEQ_FIRST (&s->fid_list); +/* ... remove from the table, taking over ownership. */ +g_hash_table_steal_all (s->fids); + +/* +* This allows us to release our references to them asynchronously without +* iterating over the hash table and risking iterator invalidation +* through concurrent modifications. +*/ +for (freeing = fids; freeing; freeing = freeing->next) { + fidp = freeing->data; fidp->ref++; - -/* Clunk fid */ -QSIMPLEQ_REMOVE (&s->fid_list, fidp, V9fsFidState, next); fidp->clunked = true; -put_fid (pdu, fidp); } }
@@ -3205,6 +3222,8 @@ static int coroutine_fn v9fs_complete_rename(V9fsPDU *pdu, V9fsFidState *fidp,V9fsFidState *tfidp;V9fsState *s = pdu->s;V9fsFidState *dirfidp =NULL ; +GHashTableIter iter; +gpointer fid;v9fs_path_init (&new_path);if (newdirfid !=-1 ) {
@@ -3238,11 +3257,13 @@ static int coroutine_fn v9fs_complete_rename(V9fsPDU *pdu, V9fsFidState *fidp,if (err <0 ) { goto out; } +/* * Fixup fid's pointing to the old name to * start pointing to the new name */ - QSIMPLEQ_FOREACH(tfidp, &s->fid_list, next) { +g_hash_table_iter_init (&iter, s->fids); +while (g_hash_table_iter_next (&iter, &fid, (gpointer *) &tfidp)) {if (v9fs_path_is_ancestor (&fidp->path, &tfidp->path)) {/* replace the name */ v9fs_fix_path (&tfidp->path, &new_path,strlen (fidp->path.data));
@@ -3320,6 +3341,8 @@ static int coroutine_fn v9fs_fix_fid_paths(V9fsPDU *pdu, V9fsPath *olddir,V9fsPath oldpath, newpath;V9fsState *s = pdu->s;int err; +GHashTableIter iter; +gpointer fid;v9fs_path_init (&oldpath);v9fs_path_init (&newpath);
@@ -3336,7 +3359,8 @@ static int coroutine_fn v9fs_fix_fid_paths(V9fsPDU *pdu, V9fsPath *olddir,* Fixup fid's pointing to the old name to * start pointing to the new name */ - QSIMPLEQ_FOREACH(tfidp, &s->fid_list, next) { +g_hash_table_iter_init (&iter, s->fids); +while (g_hash_table_iter_next (&iter, &fid, (gpointer *) &tfidp)) {if (v9fs_path_is_ancestor (&oldpath, &tfidp->path)) {/* replace the name */ v9fs_fix_path (&tfidp->path, &newpath,strlen (oldpath.data));
@@ -4226,7 +4250,7 @@ int v9fs_device_realize_common(V9fsState *s, const V9fsTransport *t, s->ctx.fmode = fse->fmode; s->ctx.dmode = fse->dmode; -QSIMPLEQ_INIT (&s->fid_list); + s->fids =g_hash_table_new (NULL ,NULL );qemu_co_rwlock_init (&s->rename_lock);if (s->ops->init (&s->ctx, errp) <0 ) {
@@ -4286,6 +4310,10 @@ void v9fs_device_unrealize_common(V9fsState *s)if (s->ctx.fst) {fsdev_throttle_cleanup (s->ctx.fst); } +if (s->fids) { +g_hash_table_destroy (s->fids); + s->fids =NULL ; + }g_free (s->tag);qp_table_destroy (&s->qpd_table);qp_table_destroy (&s->qpp_table);
hw/9pfs/9p.h +1 -1
@@ -339,7 +339,7 @@ typedef struct {struct V9fsState { QLIST_HEAD(, V9fsPDU) free_list; QLIST_HEAD(, V9fsPDU) active_list; - QSIMPLEQ_HEAD(, V9fsFidState) fid_list; +GHashTable *fids;FileOperations *ops;FsContext ctx;char *tag;
Signature · 1 line
2.30.2
[PULL 12/23] tests/9p: simplify callers of treaddir()
In reply to Christian SchoenebeckNow as treaddir() is using a declarative approach, simplify the code of callers of this function.
Message-Id: <7cec6f2c7011a481806c34908893b7282702a7a6.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/virtio-9p-test.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-)
tests/qtest/virtio-9p-test.c +11 -10
@@ -120,12 +120,12 @@ static void fs_readdir(void *obj, void *data, QGuestAllocator *t_alloc)/* * submit count = msize - 11, because 11 is the header size of Rreaddir */ - req =treaddir ({ +treaddir ({ .client = v9p, .fid = 1, .offset = 0, .count = P9_MAX_SIZE - 11, - .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rreaddir (req, &count, &nentries, &entries); + .rreaddir = { + .count = &count, .nentries = &nentries, .entries = &entries + } + });/* * Assuming msize (P9_MAX_SIZE) is large enough so we can retrieve all
@@ -190,12 +190,13 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t count) npartialentries =0 ; partialentries =NULL ; - req =treaddir ({ +treaddir ({ .client = v9p, .fid = fid, .offset = offset, .count = count, - .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rreaddir (req, &count, &npartialentries, &partialentries); + .rreaddir = { + .count = &count, .nentries = &npartialentries, + .entries = &partialentries + } + });if (npartialentries >0 && partialentries) {if (!entries) { entries = partialentries;
Signature · 1 line
2.30.2
[PULL 02/23] tests/9p: split virtio-9p-test.c into tests and 9p client part
In reply to Christian SchoenebeckThis patch is pure refactoring, it does not change behaviour.
virtio-9p-test.c grew to 1657 lines. Let's split this file up between actual 9p test cases vs. 9p test client, to make it easier to concentrate on the actual 9p tests.
Move the 9p test client code to a new unit virtio-9p-client.c, which are basically all functions and types prefixed with v9fs_* already.
Note that some client wrapper functions (do_*) are preserved in virtio-9p-test.c, simply because these wrapper functions are going to be wiped with subsequent patches anyway.
As the global QGuestAllocator variable is moved to virtio-9p-client.c, add a new function v9fs_set_allocator() to be used by virtio-9p-test.c instead of fiddling with a global variable across units and libraries.
Message-Id: <[email protected]>
--- tests/qtest/libqos/meson.build | 1 + tests/qtest/libqos/virtio-9p-client.c | 684 +++++++++++++++++++++++ tests/qtest/libqos/virtio-9p-client.h | 138 +++++ tests/qtest/virtio-9p-test.c | 770 +------------------------- 4 files changed, 849 insertions(+), 744 deletions(-) create mode 100644 tests/qtest/libqos/virtio-9p-client.c create mode 100644 tests/qtest/libqos/virtio-9p-client.h
tests/qtest/libqos/meson.build +1 -0
@@ -34,6 +34,7 @@ libqos_srcs = files( 'tpci200.c', 'virtio.c', 'virtio-9p.c', + 'virtio-9p-client.c', 'virtio-balloon.c', 'virtio-blk.c', 'vhost-user-blk.c',
tests/qtest/libqos/virtio-9p-client.c new file +684 -0
684 lines not on this page · raw message
tests/qtest/libqos/virtio-9p-client.h new file +138 -0
138 lines not on this page · raw message
tests/qtest/virtio-9p-test.c +26 -744
943 lines not on this page · raw message
Signature · 1 line
2.30.2
[PULL 15/23] tests/9p: convert v9fs_twrite() to declarative arguments
In reply to Christian SchoenebeckUse declarative function arguments for function v9fs_twrite().
Message-Id: <be0326e2d9ab66f68c06b1766ddf103849d570b4.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 38 ++++++++++++++++++++------- tests/qtest/libqos/virtio-9p-client.h | 31 ++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 18 ++++++++++--- 3 files changed, 72 insertions(+), 15 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +28 -10
@@ -687,21 +687,39 @@ void v9fs_rlopen(P9Req *req, v9fs_qid *qid, uint32_t *iounit) }/* size[4] Twrite tag[2] fid[4] offset[8] count[4] data[count] */ -P9Req *v9fs_twrite (QVirtio9P *v9p,uint32_t fid,uint64_t offset, -uint32_t count,const void *data,uint16_t tag) +TWriteRes v9fs_twrite (TWriteOpt opt) {P9Req *req; +uint32_t err;uint32_t body_size =4 +8 +4 ; +uint32_t written =0 ; - g_assert_cmpint(body_size, <=, UINT32_MAX - count); - body_size += count; - req =v9fs_req_init (v9p, body_size,P9_TWRITE , tag); -v9fs_uint32_write (req, fid); -v9fs_uint64_write (req, offset); -v9fs_uint32_write (req, count); -v9fs_memwrite (req, data, count); +g_assert (opt.client); + + g_assert_cmpint(body_size, <=, UINT32_MAX - opt.count); + body_size += opt.count; + req =v9fs_req_init (opt.client, body_size,P9_TWRITE , opt.tag); +v9fs_uint32_write (req, opt.fid); +v9fs_uint64_write (req, opt.offset); +v9fs_uint32_write (req, opt.count); +v9fs_memwrite (req, opt.data, opt.count);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rwrite (req, &written); + } + req =NULL ;/* request was freed */ + } + +return (TWriteRes ) { + .req = req, + .count = written + }; }/* size[4] Rwrite tag[2] count[4] */
tests/qtest/libqos/virtio-9p-client.h +29 -2
@@ -239,6 +239,34 @@ typedef struct TLOpenRes {P9Req *req; } TLOpenRes; +/* options for 'Twrite' 9p request */ +typedef struct TWriteOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* file ID of file to write to (required) */ +uint32_t fid; +/* start position of write from beginning of file (optional) */ +uint64_t offset; +/* how many bytes to write */ +uint32_t count; +/* data to be written */ +const void *data; +/* only send Twrite request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TWriteOpt ; + +/* result of 'Twrite' 9p request */ +typedef struct TWriteRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +/* amount of bytes written */ +uint32_t count; +}TWriteRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -274,8 +302,7 @@ void v9fs_rreaddir(P9Req *req, uint32_t *count, uint32_t *nentries,void v9fs_free_dirents (struct V9fsDirent *e);TLOpenRes v9fs_tlopen (TLOpenOpt );void v9fs_rlopen (P9Req *req,v9fs_qid *qid,uint32_t *iounit); -P9Req *v9fs_twrite (QVirtio9P *v9p,uint32_t fid,uint64_t offset, -uint32_t count,const void *data,uint16_t tag); +TWriteRes v9fs_twrite (TWriteOpt );void v9fs_rwrite (P9Req *req,uint32_t *count);P9Req *v9fs_tflush (QVirtio9P *v9p,uint16_t oldtag,uint16_t tag);void v9fs_rflush (P9Req *req);
tests/qtest/virtio-9p-test.c +15 -3
@@ -22,6 +22,7 @@#define tgetattr (...) v9fs_tgetattr((TGetAttrOpt) __VA_ARGS__)#define treaddir (...) v9fs_treaddir((TReadDirOpt) __VA_ARGS__)#define tlopen (...) v9fs_tlopen((TLOpenOpt) __VA_ARGS__) +#define twrite (...) v9fs_twrite((TWriteOpt) __VA_ARGS__)static void pci_config (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -385,7 +386,10 @@ static void fs_write(void *obj, void *data, QGuestAllocator *t_alloc) tlopen({ .client = v9p, .fid = 1, .flags = O_WRONLY }); - req =v9fs_twrite (v9p,1 ,0 , write_count, buf,0 ); + req =twrite ({ + .client = v9p, .fid = 1, .offset = 0, .count = write_count, + .data = buf, .requestOnly = true + }).req;v9fs_req_wait_for_reply (req,NULL );v9fs_rwrite (req, &count); g_assert_cmpint(count, ==, write_count);
@@ -413,7 +417,11 @@ static void fs_flush_success(void *obj, void *data, QGuestAllocator *t_alloc)* until the write request gets cancelled. */ should_block =1 ; - req =v9fs_twrite (v9p,1 ,0 ,sizeof (should_block), &should_block,0 ); + req =twrite ({ + .client = v9p, .fid = 1, .offset = 0, + .count = sizeof(should_block), .data = &should_block, + .requestOnly = true + }).req; flush_req =v9fs_tflush (v9p, req->tag,1 );
@@ -448,7 +456,11 @@ static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc)* could be actually cancelled. */ should_block =0 ; - req =v9fs_twrite (v9p,1 ,0 ,sizeof (should_block), &should_block,0 ); + req =twrite ({ + .client = v9p, .fid = 1, .offset = 0, + .count = sizeof(should_block), .data = &should_block, + .requestOnly = true + }).req; flush_req =v9fs_tflush (v9p, req->tag,1 );
Signature · 1 line
2.30.2
[PULL 14/23] tests/9p: simplify callers of tlopen()
In reply to Christian SchoenebeckNow as tlopen() is using a declarative approach, simplify the code of callers of this function.
Message-Id: <f74b6153e079fc7a340e5cb575ee32e0fe1e0ae6.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/virtio-9p-test.c | 43 +++++++++--------------------------- 1 file changed, 10 insertions(+), 33 deletions(-)
tests/qtest/virtio-9p-test.c +10 -33
@@ -105,7 +105,6 @@ static void fs_readdir(void *obj, void *data, QGuestAllocator *t_alloc)v9fs_qid qid;uint32_t count, nentries;struct V9fsDirent *entries =NULL ; -P9Req *req; tattach({ .client = v9p }); twalk({
@@ -114,11 +113,9 @@ static void fs_readdir(void *obj, void *data, QGuestAllocator *t_alloc) }); g_assert_cmpint(nqid, ==, 1); - req =tlopen ({ - .client = v9p, .fid = 1, .flags = O_DIRECTORY, .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rlopen (req, &qid,NULL ); +tlopen ({ + .client = v9p, .fid = 1, .flags = O_DIRECTORY, .rlopen.qid = &qid + });/* * submit count = msize - 11, because 11 is the header size of Rreaddir
@@ -163,7 +160,6 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t count)v9fs_qid qid;uint32_t nentries, npartialentries;struct V9fsDirent *entries, *tail, *partialentries; -P9Req *req;int fid;uint64_t offset;
@@ -181,11 +177,9 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t count) }); g_assert_cmpint(nqid, ==, 1); - req =tlopen ({ - .client = v9p, .fid = fid, .flags = O_DIRECTORY, .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rlopen (req, &qid,NULL ); +tlopen ({ + .client = v9p, .fid = fid, .flags = O_DIRECTORY, .rlopen.qid = &qid + });/* * send as many Treaddir requests as required to get all directory
@@ -363,18 +357,13 @@ static void fs_lopen(void *obj, void *data, QGuestAllocator *t_alloc)QVirtio9P *v9p = obj;v9fs_set_allocator (t_alloc);char *wnames[] = {g_strdup (QTEST_V9FS_SYNTH_LOPEN_FILE ) }; -P9Req *req; tattach({ .client = v9p });twalk ({ .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames }); - req =tlopen ({ - .client = v9p, .fid = 1, .flags = O_WRONLY, .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rlopen (req,NULL ,NULL ); + tlopen({ .client = v9p, .fid = 1, .flags = O_WRONLY });g_free (wnames[0 ]); }
@@ -394,11 +383,7 @@ static void fs_write(void *obj, void *data, QGuestAllocator *t_alloc) .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames }); - req =tlopen ({ - .client = v9p, .fid = 1, .flags = O_WRONLY, .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rlopen (req,NULL ,NULL ); + tlopen({ .client = v9p, .fid = 1, .flags = O_WRONLY }); req =v9fs_twrite (v9p,1 ,0 , write_count, buf,0 );v9fs_req_wait_for_reply (req,NULL );
@@ -422,11 +407,7 @@ static void fs_flush_success(void *obj, void *data, QGuestAllocator *t_alloc) .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames }); - req =tlopen ({ - .client = v9p, .fid = 1, .flags = O_WRONLY, .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rlopen (req,NULL ,NULL ); + tlopen({ .client = v9p, .fid = 1, .flags = O_WRONLY });/* This will cause the 9p server to try to write data to the backend, * until the write request gets cancelled.
@@ -461,11 +442,7 @@ static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc) .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames }); - req =tlopen ({ - .client = v9p, .fid = 1, .flags = O_WRONLY, .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rlopen (req,NULL ,NULL ); + tlopen({ .client = v9p, .fid = 1, .flags = O_WRONLY });/* This will cause the write request to complete right away, before it * could be actually cancelled.
Signature · 1 line
2.30.2
[PULL 21/23] tests/9p: merge v9fs_tlink() and do_hardlink()
In reply to Christian SchoenebeckAs with previous patches, unify those 2 functions into a single function v9fs_tlink() by using a declarative function arguments approach.
Message-Id: <cb4d42203e1e4e6027df4924bbe4bdbc002f668b.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 43 ++++++++++++++++++++++----- tests/qtest/libqos/virtio-9p-client.h | 31 +++++++++++++++++-- tests/qtest/virtio-9p-test.c | 26 ++++++---------- 3 files changed, 73 insertions(+), 27 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +35 -8
@@ -950,23 +950,50 @@ void v9fs_rsymlink(P9Req *req, v9fs_qid *qid) }/* size[4] Tlink tag[2] dfid[4] fid[4] name[s] */ -P9Req *v9fs_tlink (QVirtio9P *v9p,uint32_t dfid,uint32_t fid, -const char *name,uint16_t tag) +TlinkRes v9fs_tlink (TlinkOpt opt) {P9Req *req; +uint32_t err; + +g_assert (opt.client); +/* expecting either hi-level atPath or low-level dfid, but not both */ +g_assert (!opt.atPath || !opt.dfid); +/* expecting either hi-level toPath or low-level fid, but not both */ +g_assert (!opt.toPath || !opt.fid); + +if (opt.atPath) { + opt.dfid =v9fs_twalk ((TWalkOpt ) { .client = opt.client, + .path = opt.atPath }).newfid; + } +if (opt.toPath) { + opt.fid =v9fs_twalk ((TWalkOpt ) { .client = opt.client, + .path = opt.toPath }).newfid; + }uint32_t body_size =4 +4 ; -uint16_t string_size =v9fs_string_size (name); +uint16_t string_size =v9fs_string_size (opt.name); g_assert_cmpint(body_size, <=, UINT32_MAX - string_size); body_size += string_size; - req =v9fs_req_init (v9p, body_size,P9_TLINK , tag); -v9fs_uint32_write (req, dfid); -v9fs_uint32_write (req, fid); -v9fs_string_write (req, name); + req =v9fs_req_init (opt.client, body_size,P9_TLINK , opt.tag); +v9fs_uint32_write (req, opt.dfid); +v9fs_uint32_write (req, opt.fid); +v9fs_string_write (req, opt.name);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rlink (req); + } + req =NULL ;/* request was freed */ + } + +return (TlinkRes ) { .req = req }; }/* size[4] Rlink tag[2] */
tests/qtest/libqos/virtio-9p-client.h +29 -2
@@ -387,6 +387,34 @@ typedef struct TsymlinkRes {P9Req *req; } TsymlinkRes; +/* options for 'Tlink' 9p request */ +typedef struct TlinkOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* low-level variant of directory where hard link shall be created */ +uint32_t dfid; +/* high-level variant of directory where hard link shall be created */ +const char *atPath; +/* low-level variant of target referenced by new hard link */ +uint32_t fid; +/* high-level variant of target referenced by new hard link */ +const char *toPath; +/* name of hard link (required) */ +const char *name; +/* only send Tlink request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TlinkOpt ; + +/* result of 'Tlink' 9p request */ +typedef struct TlinkRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TlinkRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -432,8 +460,7 @@ TlcreateRes v9fs_tlcreate(TlcreateOpt);void v9fs_rlcreate (P9Req *req,v9fs_qid *qid,uint32_t *iounit);TsymlinkRes v9fs_tsymlink (TsymlinkOpt );void v9fs_rsymlink (P9Req *req,v9fs_qid *qid); -P9Req *v9fs_tlink (QVirtio9P *v9p,uint32_t dfid,uint32_t fid, -const char *name,uint16_t tag); +TlinkRes v9fs_tlink (TlinkOpt );void v9fs_rlink (P9Req *req);P9Req *v9fs_tunlinkat (QVirtio9P *v9p,uint32_t dirfd,const char *name,uint32_t flags,uint16_t tag);
tests/qtest/virtio-9p-test.c +9 -17
@@ -27,6 +27,7 @@#define tmkdir (...) v9fs_tmkdir((TMkdirOpt) __VA_ARGS__)#define tlcreate (...) v9fs_tlcreate((TlcreateOpt) __VA_ARGS__)#define tsymlink (...) v9fs_tsymlink((TsymlinkOpt) __VA_ARGS__) +#define tlink (...) v9fs_tlink((TlinkOpt) __VA_ARGS__)static void pci_config (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -480,21 +481,6 @@ static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc)g_free (wnames[0 ]); } -/* create a hard link named @a clink in directory @a path pointing to @a to */ -static void do_hardlink (QVirtio9P *v9p,const char *path,const char *clink, -const char *to) -{ -uint32_t dfid, fid; -P9Req *req; - - dfid = twalk({ .client = v9p, .path = path }).newfid; - fid = twalk({ .client = v9p, .path = to }).newfid; - - req =v9fs_tlink (v9p, dfid, fid, clink,0 ); -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rlink (req); -} -static void do_unlinkat (QVirtio9P *v9p,const char *atpath,const char *rpath,uint32_t flags) {
@@ -676,7 +662,10 @@ static void fs_hardlink_file(void *obj, void *data, QGuestAllocator *t_alloc)g_assert (stat (real_file, &st_real) ==0 );g_assert ((st_real.st_mode &S_IFMT ) ==S_IFREG ); -do_hardlink (v9p,"07" ,"hardlink_file" ,"07/real_file" ); +tlink ({ + .client = v9p, .atPath = "07", .name = "hardlink_file", + .toPath = "07/real_file" + });/* check if link exists now ... */ g_assert (stat (hardlink_file, &st_link) ==0 );
@@ -701,7 +690,10 @@ static void fs_unlinkat_hardlink(void *obj, void *data,g_assert (stat (real_file, &st_real) ==0 );g_assert ((st_real.st_mode &S_IFMT ) ==S_IFREG ); -do_hardlink (v9p,"08" ,"hardlink_file" ,"08/real_file" ); +tlink ({ + .client = v9p, .atPath = "08", .name = "hardlink_file", + .toPath = "08/real_file" + });g_assert (stat (hardlink_file, &st_link) ==0 );do_unlinkat (v9p,"08" ,"hardlink_file" ,0 );
Signature · 1 line
2.30.2
[PULL 22/23] tests/9p: merge v9fs_tunlinkat() and do_unlinkat()
In reply to Christian SchoenebeckAs with previous patches, unify those 2 functions into a single function v9fs_tunlinkat() by using a declarative function arguments approach.
Message-Id: <1dea593edd464908d92501933c068388c01f1744.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 37 +++++++++++++++++++++------ tests/qtest/libqos/virtio-9p-client.h | 29 +++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 26 ++++++------------- 3 files changed, 64 insertions(+), 28 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +29 -8
@@ -1004,23 +1004,44 @@ void v9fs_rlink(P9Req *req) }/* size[4] Tunlinkat tag[2] dirfd[4] name[s] flags[4] */ -P9Req *v9fs_tunlinkat (QVirtio9P *v9p,uint32_t dirfd,const char *name, -uint32_t flags,uint16_t tag) +TunlinkatRes v9fs_tunlinkat (TunlinkatOpt opt) {P9Req *req; +uint32_t err; + +g_assert (opt.client); +/* expecting either hi-level atPath or low-level dirfd, but not both */ +g_assert (!opt.atPath || !opt.dirfd); + +if (opt.atPath) { + opt.dirfd =v9fs_twalk ((TWalkOpt ) { .client = opt.client, + .path = opt.atPath }).newfid; + }uint32_t body_size =4 +4 ; -uint16_t string_size =v9fs_string_size (name); +uint16_t string_size =v9fs_string_size (opt.name); g_assert_cmpint(body_size, <=, UINT32_MAX - string_size); body_size += string_size; - req =v9fs_req_init (v9p, body_size,P9_TUNLINKAT , tag); -v9fs_uint32_write (req, dirfd); -v9fs_string_write (req, name); -v9fs_uint32_write (req, flags); + req =v9fs_req_init (opt.client, body_size,P9_TUNLINKAT , opt.tag); +v9fs_uint32_write (req, opt.dirfd); +v9fs_string_write (req, opt.name); +v9fs_uint32_write (req, opt.flags);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_runlinkat (req); + } + req =NULL ;/* request was freed */ + } + +return (TunlinkatRes ) { .req = req }; }/* size[4] Runlinkat tag[2] */
tests/qtest/libqos/virtio-9p-client.h +27 -2
@@ -415,6 +415,32 @@ typedef struct TlinkRes {P9Req *req; } TlinkRes; +/* options for 'Tunlinkat' 9p request */ +typedef struct TunlinkatOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* low-level variant of directory where name shall be unlinked */ +uint32_t dirfd; +/* high-level variant of directory where name shall be unlinked */ +const char *atPath; +/* name of directory entry to be unlinked (required) */ +const char *name; +/* Linux unlinkat(2) flags */ +uint32_t flags; +/* only send Tunlinkat request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TunlinkatOpt ; + +/* result of 'Tunlinkat' 9p request */ +typedef struct TunlinkatRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TunlinkatRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -462,8 +488,7 @@ TsymlinkRes v9fs_tsymlink(TsymlinkOpt);void v9fs_rsymlink (P9Req *req,v9fs_qid *qid);TlinkRes v9fs_tlink (TlinkOpt );void v9fs_rlink (P9Req *req); -P9Req *v9fs_tunlinkat (QVirtio9P *v9p,uint32_t dirfd,const char *name, -uint32_t flags,uint16_t tag); +TunlinkatRes v9fs_tunlinkat (TunlinkatOpt );void v9fs_runlinkat (P9Req *req);#endif
tests/qtest/virtio-9p-test.c +8 -18
@@ -28,6 +28,7 @@#define tlcreate (...) v9fs_tlcreate((TlcreateOpt) __VA_ARGS__)#define tsymlink (...) v9fs_tsymlink((TsymlinkOpt) __VA_ARGS__)#define tlink (...) v9fs_tlink((TlinkOpt) __VA_ARGS__) +#define tunlinkat (...) v9fs_tunlinkat((TunlinkatOpt) __VA_ARGS__)static void pci_config (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -481,20 +482,6 @@ static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc)g_free (wnames[0 ]); } -static void do_unlinkat (QVirtio9P *v9p,const char *atpath,const char *rpath, -uint32_t flags) -{ - g_autofree char *name = g_strdup(rpath); -uint32_t fid; -P9Req *req; - - fid = twalk({ .client = v9p, .path = atpath }).newfid; - - req =v9fs_tunlinkat (v9p, fid, name, flags,0 ); -v9fs_req_wait_for_reply (req,NULL ); -v9fs_runlinkat (req); -} -static void fs_readdir_split_128 (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -556,7 +543,10 @@ static void fs_unlinkat_dir(void *obj, void *data, QGuestAllocator *t_alloc)/* ... and is actually a directory */ g_assert ((st.st_mode &S_IFMT ) ==S_IFDIR ); -do_unlinkat (v9p,"/" ,"02" ,P9_DOTL_AT_REMOVEDIR ); +tunlinkat ({ + .client = v9p, .atPath = "/", .name = "02", + .flags = P9_DOTL_AT_REMOVEDIR + });/* directory should be gone now */ g_assert (stat (new_dir, &st) !=0 ); }
@@ -594,7 +584,7 @@ static void fs_unlinkat_file(void *obj, void *data, QGuestAllocator *t_alloc)/* ... and is a regular file */ g_assert ((st.st_mode &S_IFMT ) ==S_IFREG ); -do_unlinkat (v9p,"04" ,"doa_file" ,0 ); + tunlinkat({ .client = v9p, .atPath = "04", .name = "doa_file" });/* file should be gone now */ g_assert (stat (new_file, &st) !=0 ); }
@@ -643,7 +633,7 @@ static void fs_unlinkat_symlink(void *obj, void *data, });g_assert (stat (symlink_file, &st) ==0 ); -do_unlinkat (v9p,"06" ,"symlink_file" ,0 ); + tunlinkat({ .client = v9p, .atPath = "06", .name = "symlink_file" });/* symlink should be gone now */ g_assert (stat (symlink_file, &st) !=0 ); }
@@ -696,7 +686,7 @@ static void fs_unlinkat_hardlink(void *obj, void *data, });g_assert (stat (hardlink_file, &st_link) ==0 ); -do_unlinkat (v9p,"08" ,"hardlink_file" ,0 ); + tunlinkat({ .client = v9p, .atPath = "08", .name = "hardlink_file" });/* symlink should be gone now */ g_assert (stat (hardlink_file, &st_link) !=0 );/* and old file should still exist */
Signature · 1 line
2.30.2
[PULL 07/23] tests/9p: merge v9fs_tattach(), do_attach(), do_attach_rqid()
In reply to Christian SchoenebeckAs with previous patches, unify those 3 functions into a single function v9fs_tattach() by using a declarative function arguments approach.
Message-Id: <a6756b30bf2a1b25729c5bbabd1c9534a8f20d6f.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 40 ++++++++++++++--- tests/qtest/libqos/virtio-9p-client.h | 30 ++++++++++++- tests/qtest/virtio-9p-test.c | 62 +++++++++++---------------- 3 files changed, 88 insertions(+), 44 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +34 -6
@@ -359,20 +359,48 @@ void v9fs_rversion(P9Req *req, uint16_t *len, char **version) }/* size[4] Tattach tag[2] fid[4] afid[4] uname[s] aname[s] n_uname[4] */ -P9Req *v9fs_tattach (QVirtio9P *v9p,uint32_t fid,uint32_t n_uname, -uint16_t tag) +TAttachRes v9fs_tattach (TAttachOpt opt) { +uint32_t err;const char *uname ="" ;/* ignored by QEMU */ const char *aname ="" ;/* ignored by QEMU */ -P9Req *req =v9fs_req_init (v9p,4 +4 +2 +2 +4 ,P9_TATTACH , tag); -v9fs_uint32_write (req, fid); +g_assert (opt.client); +/* expecting either Rattach or Rlerror, but obviously not both */ +g_assert (!opt.expectErr || !opt.rattach.qid); + +if (!opt.requestOnly) { +v9fs_tversion ((TVersionOpt ) { .client = opt.client }); + } + +if (!opt.n_uname) { + opt.n_uname =getuid (); + } + +P9Req *req =v9fs_req_init (opt.client,4 +4 +2 +2 +4 ,P9_TATTACH , + opt.tag); + +v9fs_uint32_write (req, opt.fid);v9fs_uint32_write (req,P9_NOFID );v9fs_string_write (req, uname);v9fs_string_write (req, aname); -v9fs_uint32_write (req, n_uname); +v9fs_uint32_write (req, opt.n_uname);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rattach (req, opt.rattach.qid); + } + req =NULL ;/* request was freed */ + } + +return (TAttachRes ) { + .req = req, + }; }/* size[4] Rattach tag[2] qid[13] */
tests/qtest/libqos/virtio-9p-client.h +28 -2
@@ -128,6 +128,33 @@ typedef struct TVersionRes {P9Req *req; } TVersionRes; +/* options for 'Tattach' 9p request */ +typedef struct TAttachOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* file ID to be associated with root of file tree (optional) */ +uint32_t fid; +/* numerical uid of user being introduced to server (optional) */ +uint32_t n_uname; +/* data being received from 9p server as 'Rattach' response (optional) */ +struct { +/* server's idea of the root of the file tree */ +v9fs_qid *qid; + } rattach; +/* only send Tattach request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TAttachOpt ; + +/* result of 'Tattach' 9p request */ +typedef struct TAttachRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TAttachRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -151,8 +178,7 @@ void v9fs_req_free(P9Req *req);void v9fs_rlerror (P9Req *req,uint32_t *err);TVersionRes v9fs_tversion (TVersionOpt );void v9fs_rversion (P9Req *req,uint16_t *len,char **version); -P9Req *v9fs_tattach (QVirtio9P *v9p,uint32_t fid,uint32_t n_uname, -uint16_t tag); +TAttachRes v9fs_tattach (TAttachOpt );void v9fs_rattach (P9Req *req,v9fs_qid *qid);TWalkRes v9fs_twalk (TWalkOpt opt);void v9fs_rwalk (P9Req *req,uint16_t *nwqid,v9fs_qid **wqid);
tests/qtest/virtio-9p-test.c +26 -36
197 lines not on this page · raw message
Signature · 1 line
2.30.2
[PULL 05/23] tests/9p: simplify callers of twalk()
In reply to Christian SchoenebeckNow as twalk() is using a declarative approach, simplify the code of callers of this function.
Message-Id: <8b9d3c656ad43b6c953d6bdacd8d9f4c8e599b2a.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/virtio-9p-test.c | 92 +++++++++++++----------------------- 1 file changed, 32 insertions(+), 60 deletions(-)
tests/qtest/virtio-9p-test.c +32 -60
@@ -90,19 +90,17 @@ static void fs_walk(void *obj, void *data, QGuestAllocator *t_alloc)uint16_t nwqid; g_autofree v9fs_qid *wqid = NULL;int i; -P9Req *req;for (i =0 ; i <P9_MAXWELEM ; i++) { wnames[i] =g_strdup_printf (QTEST_V9FS_SYNTH_WALK_FILE , i); }do_attach (v9p); - req =twalk ({ +twalk ({ .client = v9p, .fid = 0, .newfid = 1, - .nwname = P9_MAXWELEM, .wnames = wnames, .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rwalk (req, &nwqid, &wqid); + .nwname = P9_MAXWELEM, .wnames = wnames, + .rwalk = { .nwqid = &nwqid, .wqid = &wqid } + }); g_assert_cmpint(nwqid, ==, P9_MAXWELEM);
@@ -134,12 +132,10 @@ static void fs_readdir(void *obj, void *data, QGuestAllocator *t_alloc)P9Req *req;do_attach (v9p); - req =twalk ({ +twalk ({ .client = v9p, .fid = 0, .newfid = 1, - .nwname = 1, .wnames = wnames, .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rwalk (req, &nqid,NULL ); + .nwname = 1, .wnames = wnames, .rwalk.nwqid = &nqid + }); g_assert_cmpint(nqid, ==, 1); req =v9fs_tlopen (v9p,1 ,O_DIRECTORY ,0 );
@@ -198,12 +194,10 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t count) nentries =0 ; tail =NULL ; - req =twalk ({ +twalk ({ .client = v9p, .fid = 0, .newfid = fid, - .nwname = 1, .wnames = wnames, .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rwalk (req, &nqid,NULL ); + .nwname = 1, .wnames = wnames, .rwalk.nwqid = &nqid + }); g_assert_cmpint(nqid, ==, 1); req =v9fs_tlopen (v9p, fid,O_DIRECTORY ,0 );
@@ -266,18 +260,12 @@ static void fs_walk_no_slash(void *obj, void *data, QGuestAllocator *t_alloc)QVirtio9P *v9p = obj;v9fs_set_allocator (t_alloc);char *wnames[] = {g_strdup (" /" ) }; -P9Req *req; -uint32_t err;do_attach (v9p); - req =twalk ({ +twalk ({ .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames, - .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rlerror (req, &err); - - g_assert_cmpint(err, ==, ENOENT); + .expectErr = ENOENT + });g_free (wnames[0 ]); }
@@ -312,7 +300,7 @@ static void fs_walk_2nd_nonexistent(void *obj, void *data,do_attach_rqid (v9p, &root_qid); fid =twalk ({ .client = v9p, .path = path, - .rwalk.nwqid = &nwqid, .rwalk.wqid = &wqid + .rwalk = { .nwqid = &nwqid, .wqid = &wqid } }).newfid;/* * The 9p2000 protocol spec says: "nwqid is therefore either nwname or the
@@ -345,12 +333,10 @@ static void fs_walk_none(void *obj, void *data, QGuestAllocator *t_alloc)v9fs_req_wait_for_reply (req,NULL );v9fs_rattach (req, &root_qid); - req =twalk ({ +twalk ({ .client = v9p, .fid = 0, .newfid = 1, .nwname = 0, .wnames = NULL, - .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rwalk (req,NULL , &wqid); + .rwalk.wqid = &wqid + });/* special case: no QID is returned if nwname=0 was sent */ g_assert (wqid ==NULL );
@@ -376,12 +362,10 @@ static void fs_walk_dotdot(void *obj, void *data, QGuestAllocator *t_alloc)v9fs_req_wait_for_reply (req,NULL );v9fs_rattach (req, &root_qid); - req =twalk ({ +twalk ({ .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames, - .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rwalk (req,NULL , &wqid);/* We now we'll get one qid */ + .rwalk.wqid = &wqid /* We now we'll get one qid */ + });g_assert_cmpmem (&root_qid,13 , wqid[0 ],13 );
@@ -396,12 +380,9 @@ static void fs_lopen(void *obj, void *data, QGuestAllocator *t_alloc)P9Req *req;do_attach (v9p); - req =twalk ({ - .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames, - .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rwalk (req,NULL ,NULL ); +twalk ({ + .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames + }); req =v9fs_tlopen (v9p,1 ,O_WRONLY ,0 );v9fs_req_wait_for_reply (req,NULL );
@@ -421,12 +402,9 @@ static void fs_write(void *obj, void *data, QGuestAllocator *t_alloc)P9Req *req;do_attach (v9p); - req =twalk ({ - .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames, - .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rwalk (req,NULL ,NULL ); +twalk ({ + .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames + }); req =v9fs_tlopen (v9p,1 ,O_WRONLY ,0 );v9fs_req_wait_for_reply (req,NULL );
@@ -450,12 +428,9 @@ static void fs_flush_success(void *obj, void *data, QGuestAllocator *t_alloc)uint8_t should_block;do_attach (v9p); - req =twalk ({ - .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames, - .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rwalk (req,NULL ,NULL ); +twalk ({ + .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames + }); req =v9fs_tlopen (v9p,1 ,O_WRONLY ,0 );v9fs_req_wait_for_reply (req,NULL );
@@ -490,12 +465,9 @@ static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc)uint8_t should_block;do_attach (v9p); - req =twalk ({ - .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames, - .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rwalk (req,NULL ,NULL ); +twalk ({ + .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames + }); req =v9fs_tlopen (v9p,1 ,O_WRONLY ,0 );v9fs_req_wait_for_reply (req,NULL );
Signature · 1 line
2.30.2
[PULL 04/23] tests/9p: merge *walk*() functions
In reply to Christian SchoenebeckIntroduce declarative function calls.
There are currently 4 different functions for sending a 9p 'Twalk'
request: v9fs_twalk(), do_walk(), do_walk_rqids() and do_walk_expect_error(). They are all doing the same thing, just in a slightly different way and with slightly different function arguments.
Merge those 4 functions into a single function by using a struct for function call arguments and use designated initializers when calling this function to turn usage into a declarative approach, which is better readable and easier to maintain.
Also move private functions genfid(), split() and split_free() from virtio-9p-test.c to virtio-9p-client.c.
Based-on: <[email protected]>
Message-Id: <607969dbfbc63c1be008df9131133711b046e979.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 114 ++++++++++++++-- tests/qtest/libqos/virtio-9p-client.h | 37 ++++- tests/qtest/virtio-9p-test.c | 187 +++++++++----------------- 3 files changed, 198 insertions(+), 140 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +103 -11
@@ -23,6 +23,65 @@ void v9fs_set_allocator(QGuestAllocator *t_alloc) alloc = t_alloc; } +/* +* Used to auto generate new fids. Start with arbitrary high value to avoid +* collision with hard coded fids in basic test code. +*/ +static uint32_t fid_generator =1000 ; + +static uint32_t genfid (void ) +{ +return fid_generator++; +} + +/** +* Splits the @a in string by @a delim into individual (non empty) strings +* and outputs them to @a out. The output array @a out is NULL terminated. +* +* Output array @a out must be freed by calling split_free(). +* +* @returns number of individual elements in output array @a out (without the +* final NULL terminating element) +*/ +static int split (const char *in,const char *delim,char ***out) +{ +int n =0 , i =0 ; +char *tmp, *p; + + tmp =g_strdup (in); +for (p =strtok (tmp, delim); p !=NULL ; p =strtok (NULL , delim)) { +if (strlen (p) >0 ) { + ++n; + } + } +g_free (tmp); + + *out = g_new0(char *, n + 1); /* last element NULL delimiter */ + + tmp =g_strdup (in); +for (p =strtok (tmp, delim); p !=NULL ; p =strtok (NULL , delim)) { +if (strlen (p) >0 ) { + (*out)[i++] =g_strdup (p); + } + } +g_free (tmp); + +return n; +} + +static void split_free (char ***out) +{ +int i; +if (!*out) { +return ; + } +for (i =0 ; (*out)[i]; ++i) { +g_free ((*out)[i]); + } +g_free (*out); + *out =NULL ; +} +void v9fs_memwrite (P9Req *req,const void *addr,size_t len) {qtest_memwrite (req->qts, req->t_msg + req->t_off, addr, len);
@@ -294,28 +353,61 @@ void v9fs_rattach(P9Req *req, v9fs_qid *qid) }/* size[4] Twalk tag[2] fid[4] newfid[4] nwname[2] nwname*(wname[s]) */ -P9Req *v9fs_twalk (QVirtio9P *v9p,uint32_t fid,uint32_t newfid, -uint16_t nwname,char *const wnames[],uint16_t tag) +TWalkRes v9fs_twalk (TWalkOpt opt) {P9Req *req;int i;uint32_t body_size =4 +4 +2 ; +uint32_t err; +char **wnames =NULL ; -for (i =0 ; i < nwname; i++) { -uint16_t wname_size =v9fs_string_size (wnames[i]); +g_assert (opt.client); +/* expecting either high- or low-level path, both not both */ +g_assert (!opt.path || !(opt.nwname || opt.wnames)); +/* expecting either Rwalk or Rlerror, but obviously not both */ +g_assert (!opt.expectErr || !(opt.rwalk.nwqid || opt.rwalk.wqid)); + +if (!opt.newfid) { + opt.newfid =genfid (); + } + +if (opt.path) { + opt.nwname =split (opt.path,"/" , &wnames); + opt.wnames = wnames; + } + +for (i =0 ; i < opt.nwname; i++) { +uint16_t wname_size =v9fs_string_size (opt.wnames[i]); g_assert_cmpint(body_size, <=, UINT32_MAX - wname_size); body_size += wname_size; } - req =v9fs_req_init (v9p, body_size,P9_TWALK , tag); -v9fs_uint32_write (req, fid); -v9fs_uint32_write (req, newfid); -v9fs_uint16_write (req, nwname); -for (i =0 ; i < nwname; i++) { -v9fs_string_write (req, wnames[i]); + req =v9fs_req_init (opt.client, body_size,P9_TWALK , opt.tag); +v9fs_uint32_write (req, opt.fid); +v9fs_uint32_write (req, opt.newfid); +v9fs_uint16_write (req, opt.nwname); +for (i =0 ; i < opt.nwname; i++) { +v9fs_string_write (req, opt.wnames[i]); }v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rwalk (req, opt.rwalk.nwqid, opt.rwalk.wqid); + } + req =NULL ;/* request was freed */ + } + +split_free (&wnames); + +return (TWalkRes ) { + .newfid = opt.newfid, + .req = req, + }; }/* size[4] Rwalk tag[2] nwqid[2] nwqid*(wqid[13]) */
tests/qtest/libqos/virtio-9p-client.h +35 -2
@@ -72,6 +72,40 @@ struct V9fsDirent {struct V9fsDirent *next; }; +/* options for 'Twalk' 9p request */ +typedef struct TWalkOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* file ID of directory from where walk should start (optional) */ +uint32_t fid; +/* file ID for target directory being walked to (optional) */ +uint32_t newfid; +/* low level variant of path to walk to (optional) */ +uint16_t nwname; +char **wnames; +/* high level variant of path to walk to (optional) */ +const char *path; +/* data being received from 9p server as 'Rwalk' response (optional) */ +struct { +uint16_t *nwqid; +v9fs_qid **wqid; + } rwalk; +/* only send Twalk request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TWalkOpt ; + +/* result of 'Twalk' 9p request */ +typedef struct TWalkRes { +/* file ID of target directory been walked to */ +uint32_t newfid; +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TWalkRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -99,8 +133,7 @@ void v9fs_rversion(P9Req *req, uint16_t *len, char **version);P9Req *v9fs_tattach (QVirtio9P *v9p,uint32_t fid,uint32_t n_uname,uint16_t tag);void v9fs_rattach (P9Req *req,v9fs_qid *qid); -P9Req *v9fs_twalk (QVirtio9P *v9p,uint32_t fid,uint32_t newfid, -uint16_t nwname,char *const wnames[],uint16_t tag); +TWalkRes v9fs_twalk (TWalkOpt opt);void v9fs_rwalk (P9Req *req,uint16_t *nwqid,v9fs_qid **wqid);P9Req *v9fs_tgetattr (QVirtio9P *v9p,uint32_t fid,uint64_t request_mask,uint16_t tag);
tests/qtest/virtio-9p-test.c +60 -127
341 lines not on this page · raw message
Signature · 1 line
2.30.2
[PULL 09/23] tests/9p: convert v9fs_tgetattr() to declarative arguments
In reply to Christian SchoenebeckUse declarative function arguments for function v9fs_tgetattr().
Message-Id: <d340a91be96fbfecfb8dacdd7558223b3c0d0e2c.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 32 ++++++++++++++++++++++----- tests/qtest/libqos/virtio-9p-client.h | 30 +++++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 11 +++++++-- 3 files changed, 63 insertions(+), 10 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +26 -6
@@ -489,16 +489,36 @@ void v9fs_rwalk(P9Req *req, uint16_t *nwqid, v9fs_qid **wqid) }/* size[4] Tgetattr tag[2] fid[4] request_mask[8] */ -P9Req *v9fs_tgetattr (QVirtio9P *v9p,uint32_t fid,uint64_t request_mask, -uint16_t tag) +TGetAttrRes v9fs_tgetattr (TGetAttrOpt opt) {P9Req *req; +uint32_t err; - req =v9fs_req_init (v9p,4 +8 ,P9_TGETATTR , tag); -v9fs_uint32_write (req, fid); -v9fs_uint64_write (req, request_mask); +g_assert (opt.client); +/* expecting either Rgetattr or Rlerror, but obviously not both */ +g_assert (!opt.expectErr || !opt.rgetattr.attr); + +if (!opt.request_mask) { + opt.request_mask =P9_GETATTR_ALL ; + } + + req =v9fs_req_init (opt.client,4 +8 ,P9_TGETATTR , opt.tag); +v9fs_uint32_write (req, opt.fid); +v9fs_uint64_write (req, opt.request_mask);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rgetattr (req, opt.rgetattr.attr); + } + req =NULL ;/* request was freed */ + } + +return (TGetAttrRes ) { .req = req }; }/*
tests/qtest/libqos/virtio-9p-client.h +28 -2
@@ -63,6 +63,7 @@ typedef struct v9fs_attr { } v9fs_attr;#define P9_GETATTR_BASIC 0x000007ffULL/* Mask for fields up to BLOCKS */ +#define P9_GETATTR_ALL 0x00003fffULL/* Mask for ALL fields */ struct V9fsDirent {v9fs_qid qid;
@@ -155,6 +156,32 @@ typedef struct TAttachRes {P9Req *req; } TAttachRes; +/* options for 'Tgetattr' 9p request */ +typedef struct TGetAttrOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* file ID of file/dir whose attributes shall be retrieved (required) */ +uint32_t fid; +/* bitmask indicating attribute fields to be retrieved (optional) */ +uint64_t request_mask; +/* data being received from 9p server as 'Rgetattr' response (optional) */ +struct { +v9fs_attr *attr; + } rgetattr; +/* only send Tgetattr request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TGetAttrOpt ; + +/* result of 'Tgetattr' 9p request */ +typedef struct TGetAttrRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TGetAttrRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -182,8 +209,7 @@ TAttachRes v9fs_tattach(TAttachOpt);void v9fs_rattach (P9Req *req,v9fs_qid *qid);TWalkRes v9fs_twalk (TWalkOpt opt);void v9fs_rwalk (P9Req *req,uint16_t *nwqid,v9fs_qid **wqid); -P9Req *v9fs_tgetattr (QVirtio9P *v9p,uint32_t fid,uint64_t request_mask, -uint16_t tag); +TGetAttrRes v9fs_tgetattr (TGetAttrOpt );void v9fs_rgetattr (P9Req *req,v9fs_attr *attr);P9Req *v9fs_treaddir (QVirtio9P *v9p,uint32_t fid,uint64_t offset,uint32_t count,uint16_t tag);
tests/qtest/virtio-9p-test.c +9 -2
@@ -19,6 +19,7 @@#define twalk (...) v9fs_twalk((TWalkOpt) __VA_ARGS__)#define tversion (...) v9fs_tversion((TVersionOpt) __VA_ARGS__)#define tattach (...) v9fs_tattach((TAttachOpt) __VA_ARGS__) +#define tgetattr (...) v9fs_tgetattr((TGetAttrOpt) __VA_ARGS__)static void pci_config (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -285,7 +286,10 @@ static void fs_walk_2nd_nonexistent(void *obj, void *data,g_assert (wqid && wqid[0 ] && !is_same_qid (root_qid, wqid[0 ]));/* expect fid being unaffected by walk above */ - req =v9fs_tgetattr (v9p, fid,P9_GETATTR_BASIC ,0 ); + req =tgetattr ({ + .client = v9p, .fid = fid, .request_mask = P9_GETATTR_BASIC, + .requestOnly = true + }).req;v9fs_req_wait_for_reply (req,NULL );v9fs_rlerror (req, &err);
@@ -315,7 +319,10 @@ static void fs_walk_none(void *obj, void *data, QGuestAllocator *t_alloc)/* special case: no QID is returned if nwname=0 was sent */ g_assert (wqid ==NULL ); - req =v9fs_tgetattr (v9p,1 ,P9_GETATTR_BASIC ,0 ); + req =tgetattr ({ + .client = v9p, .fid = 1, .request_mask = P9_GETATTR_BASIC, + .requestOnly = true + }).req;v9fs_req_wait_for_reply (req,NULL );v9fs_rgetattr (req, &attr);
Signature · 1 line
2.30.2
[PULL 19/23] tests/9p: merge v9fs_tlcreate() and do_lcreate()
In reply to Christian SchoenebeckAs with previous patches, unify those 2 functions into a single function v9fs_tlcreate() by using a declarative function arguments approach.
Message-Id: <4c01b2caa5f5b54a2020fc92701deadd2abf0571.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 45 +++++++++++++++++++++------ tests/qtest/libqos/virtio-9p-client.h | 39 +++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 30 +++++------------- 3 files changed, 79 insertions(+), 35 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +36 -9
@@ -827,11 +827,26 @@ void v9fs_rmkdir(P9Req *req, v9fs_qid *qid) }/* size[4] Tlcreate tag[2] fid[4] name[s] flags[4] mode[4] gid[4] */ -P9Req *v9fs_tlcreate (QVirtio9P *v9p,uint32_t fid,const char *name, -uint32_t flags,uint32_t mode,uint32_t gid, -uint16_t tag) +TlcreateRes v9fs_tlcreate (TlcreateOpt opt) {P9Req *req; +uint32_t err; + g_autofree char *name = g_strdup(opt.name); + +g_assert (opt.client); +/* expecting either hi-level atPath or low-level fid, but not both */ +g_assert (!opt.atPath || !opt.fid); +/* expecting either Rlcreate or Rlerror, but obviously not both */ +g_assert (!opt.expectErr || !(opt.rlcreate.qid || opt.rlcreate.iounit)); + +if (opt.atPath) { + opt.fid =v9fs_twalk ((TWalkOpt ) { .client = opt.client, + .path = opt.atPath }).newfid; + } + +if (!opt.mode) { + opt.mode =0750 ; + }uint32_t body_size =4 +4 +4 +4 ;uint16_t string_size =v9fs_string_size (name);
@@ -839,14 +854,26 @@ P9Req *v9fs_tlcreate(QVirtio9P *v9p, uint32_t fid, const char *name, g_assert_cmpint(body_size, <=, UINT32_MAX - string_size); body_size += string_size; - req =v9fs_req_init (v9p, body_size,P9_TLCREATE , tag); -v9fs_uint32_write (req, fid); + req =v9fs_req_init (opt.client, body_size,P9_TLCREATE , opt.tag); +v9fs_uint32_write (req, opt.fid);v9fs_string_write (req, name); -v9fs_uint32_write (req, flags); -v9fs_uint32_write (req, mode); -v9fs_uint32_write (req, gid); +v9fs_uint32_write (req, opt.flags); +v9fs_uint32_write (req, opt.mode); +v9fs_uint32_write (req, opt.gid);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rlcreate (req, opt.rlcreate.qid, opt.rlcreate.iounit); + } + req =NULL ;/* request was freed */ + } + +return (TlcreateRes ) { .req = req }; }/* size[4] Rlcreate tag[2] qid[13] iounit[4] */
tests/qtest/libqos/virtio-9p-client.h +36 -3
@@ -320,6 +320,41 @@ typedef struct TMkdirRes {P9Req *req; } TMkdirRes; +/* options for 'Tlcreate' 9p request */ +typedef struct TlcreateOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* low-level variant of directory where new file shall be created */ +uint32_t fid; +/* high-level variant of directory where new file shall be created */ +const char *atPath; +/* name of new file (required) */ +const char *name; +/* Linux kernel intent bits */ +uint32_t flags; +/* Linux create(2) mode bits */ +uint32_t mode; +/* effective group ID of caller */ +uint32_t gid; +/* data being received from 9p server as 'Rlcreate' response (optional) */ +struct { +v9fs_qid *qid; +uint32_t *iounit; + } rlcreate; +/* only send Tlcreate request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TlcreateOpt ; + +/* result of 'Tlcreate' 9p request */ +typedef struct TlcreateRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TlcreateRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -361,9 +396,7 @@ TFlushRes v9fs_tflush(TFlushOpt);void v9fs_rflush (P9Req *req);TMkdirRes v9fs_tmkdir (TMkdirOpt );void v9fs_rmkdir (P9Req *req,v9fs_qid *qid); -P9Req *v9fs_tlcreate (QVirtio9P *v9p,uint32_t fid,const char *name, -uint32_t flags,uint32_t mode,uint32_t gid, -uint16_t tag); +TlcreateRes v9fs_tlcreate (TlcreateOpt );void v9fs_rlcreate (P9Req *req,v9fs_qid *qid,uint32_t *iounit);P9Req *v9fs_tsymlink (QVirtio9P *v9p,uint32_t fid,const char *name,const char *symtgt,uint32_t gid,uint16_t tag);
tests/qtest/virtio-9p-test.c +7 -23
@@ -25,6 +25,7 @@#define twrite (...) v9fs_twrite((TWriteOpt) __VA_ARGS__)#define tflush (...) v9fs_tflush((TFlushOpt) __VA_ARGS__)#define tmkdir (...) v9fs_tmkdir((TMkdirOpt) __VA_ARGS__) +#define tlcreate (...) v9fs_tlcreate((TlcreateOpt) __VA_ARGS__)static void pci_config (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -478,23 +479,6 @@ static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc)g_free (wnames[0 ]); } -/* create a regular file with Tlcreate and return file's fid */ -static uint32_t do_lcreate (QVirtio9P *v9p,const char *path, -const char *cname) -{ - g_autofree char *name = g_strdup(cname); -uint32_t fid; -P9Req *req; - - fid = twalk({ .client = v9p, .path = path }).newfid; - - req =v9fs_tlcreate (v9p, fid, name,0 ,0750 ,0 ,0 ); -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rlcreate (req,NULL ,NULL ); - -return fid; -} -/* create symlink named @a clink in directory @a path pointing to @a to */ static void do_symlink (QVirtio9P *v9p,const char *path,const char *clink,const char *to)
@@ -615,7 +599,7 @@ static void fs_create_file(void *obj, void *data, QGuestAllocator *t_alloc) tattach({ .client = v9p }); tmkdir({ .client = v9p, .atPath = "/", .name = "03" }); -do_lcreate (v9p,"03" ,"1st_file" ); + tlcreate({ .client = v9p, .atPath = "03", .name = "1st_file" });/* check if created file exists now ... */ g_assert (stat (new_file, &st) ==0 );
@@ -632,7 +616,7 @@ static void fs_unlinkat_file(void *obj, void *data, QGuestAllocator *t_alloc) tattach({ .client = v9p }); tmkdir({ .client = v9p, .atPath = "/", .name = "04" }); -do_lcreate (v9p,"04" ,"doa_file" ); + tlcreate({ .client = v9p, .atPath = "04", .name = "doa_file" });/* check if created file exists now ... */ g_assert (stat (new_file, &st) ==0 );
@@ -654,7 +638,7 @@ static void fs_symlink_file(void *obj, void *data, QGuestAllocator *t_alloc) tattach({ .client = v9p }); tmkdir({ .client = v9p, .atPath = "/", .name = "05" }); -do_lcreate (v9p,"05" ,"real_file" ); + tlcreate({ .client = v9p, .atPath = "05", .name = "real_file" });g_assert (stat (real_file, &st) ==0 );g_assert ((st.st_mode &S_IFMT ) ==S_IFREG );
@@ -675,7 +659,7 @@ static void fs_unlinkat_symlink(void *obj, void *data, tattach({ .client = v9p }); tmkdir({ .client = v9p, .atPath = "/", .name = "06" }); -do_lcreate (v9p,"06" ,"real_file" ); + tlcreate({ .client = v9p, .atPath = "06", .name = "real_file" });g_assert (stat (real_file, &st) ==0 );g_assert ((st.st_mode &S_IFMT ) ==S_IFREG );
@@ -697,7 +681,7 @@ static void fs_hardlink_file(void *obj, void *data, QGuestAllocator *t_alloc) tattach({ .client = v9p }); tmkdir({ .client = v9p, .atPath = "/", .name = "07" }); -do_lcreate (v9p,"07" ,"real_file" ); + tlcreate({ .client = v9p, .atPath = "07", .name = "real_file" });g_assert (stat (real_file, &st_real) ==0 );g_assert ((st_real.st_mode &S_IFMT ) ==S_IFREG );
@@ -722,7 +706,7 @@ static void fs_unlinkat_hardlink(void *obj, void *data, tattach({ .client = v9p }); tmkdir({ .client = v9p, .atPath = "/", .name = "08" }); -do_lcreate (v9p,"08" ,"real_file" ); + tlcreate({ .client = v9p, .atPath = "08", .name = "real_file" });g_assert (stat (real_file, &st_real) ==0 );g_assert ((st_real.st_mode &S_IFMT ) ==S_IFREG );
Signature · 1 line
2.30.2
[PULL 13/23] tests/9p: convert v9fs_tlopen() to declarative arguments
In reply to Christian SchoenebeckUse declarative function arguments for function v9fs_tlopen().
Message-Id: <765ab515353c56f88f0a163631f626a44e9565d6.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 28 +++++++++++++++++++------ tests/qtest/libqos/virtio-9p-client.h | 30 +++++++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 25 ++++++++++++++++------ 3 files changed, 69 insertions(+), 14 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +22 -6
@@ -643,16 +643,32 @@ void v9fs_free_dirents(struct V9fsDirent *e) }/* size[4] Tlopen tag[2] fid[4] flags[4] */ -P9Req *v9fs_tlopen (QVirtio9P *v9p,uint32_t fid,uint32_t flags, -uint16_t tag) +TLOpenRes v9fs_tlopen (TLOpenOpt opt) {P9Req *req; +uint32_t err; - req =v9fs_req_init (v9p,4 +4 ,P9_TLOPEN , tag); -v9fs_uint32_write (req, fid); -v9fs_uint32_write (req, flags); +g_assert (opt.client); +/* expecting either Rlopen or Rlerror, but obviously not both */ +g_assert (!opt.expectErr || !(opt.rlopen.qid || opt.rlopen.iounit)); + + req =v9fs_req_init (opt.client,4 +4 ,P9_TLOPEN , opt.tag); +v9fs_uint32_write (req, opt.fid); +v9fs_uint32_write (req, opt.flags);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rlopen (req, opt.rlopen.qid, opt.rlopen.iounit); + } + req =NULL ;/* request was freed */ + } + +return (TLOpenRes ) { .req = req }; }/* size[4] Rlopen tag[2] qid[13] iounit[4] */
tests/qtest/libqos/virtio-9p-client.h +28 -2
@@ -212,6 +212,33 @@ typedef struct TReadDirRes {P9Req *req; } TReadDirRes; +/* options for 'Tlopen' 9p request */ +typedef struct TLOpenOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* file ID of file / directory to be opened (required) */ +uint32_t fid; +/* Linux open(2) flags such as O_RDONLY, O_RDWR, O_WRONLY (optional) */ +uint32_t flags; +/* data being received from 9p server as 'Rlopen' response (optional) */ +struct { +v9fs_qid *qid; +uint32_t *iounit; + } rlopen; +/* only send Tlopen request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TLOpenOpt ; + +/* result of 'Tlopen' 9p request */ +typedef struct TLOpenRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TLOpenRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -245,8 +272,7 @@ TReadDirRes v9fs_treaddir(TReadDirOpt);void v9fs_rreaddir (P9Req *req,uint32_t *count,uint32_t *nentries,struct V9fsDirent **entries);void v9fs_free_dirents (struct V9fsDirent *e); -P9Req *v9fs_tlopen (QVirtio9P *v9p,uint32_t fid,uint32_t flags, -uint16_t tag); +TLOpenRes v9fs_tlopen (TLOpenOpt );void v9fs_rlopen (P9Req *req,v9fs_qid *qid,uint32_t *iounit);P9Req *v9fs_twrite (QVirtio9P *v9p,uint32_t fid,uint64_t offset,uint32_t count,const void *data,uint16_t tag);
tests/qtest/virtio-9p-test.c +19 -6
@@ -21,6 +21,7 @@#define tattach (...) v9fs_tattach((TAttachOpt) __VA_ARGS__)#define tgetattr (...) v9fs_tgetattr((TGetAttrOpt) __VA_ARGS__)#define treaddir (...) v9fs_treaddir((TReadDirOpt) __VA_ARGS__) +#define tlopen (...) v9fs_tlopen((TLOpenOpt) __VA_ARGS__)static void pci_config (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -113,7 +114,9 @@ static void fs_readdir(void *obj, void *data, QGuestAllocator *t_alloc) }); g_assert_cmpint(nqid, ==, 1); - req =v9fs_tlopen (v9p,1 ,O_DIRECTORY ,0 ); + req =tlopen ({ + .client = v9p, .fid = 1, .flags = O_DIRECTORY, .requestOnly = true + }).req;v9fs_req_wait_for_reply (req,NULL );v9fs_rlopen (req, &qid,NULL );
@@ -178,7 +181,9 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t count) }); g_assert_cmpint(nqid, ==, 1); - req =v9fs_tlopen (v9p, fid,O_DIRECTORY ,0 ); + req =tlopen ({ + .client = v9p, .fid = fid, .flags = O_DIRECTORY, .requestOnly = true + }).req;v9fs_req_wait_for_reply (req,NULL );v9fs_rlopen (req, &qid,NULL );
@@ -365,7 +370,9 @@ static void fs_lopen(void *obj, void *data, QGuestAllocator *t_alloc) .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames }); - req =v9fs_tlopen (v9p,1 ,O_WRONLY ,0 ); + req =tlopen ({ + .client = v9p, .fid = 1, .flags = O_WRONLY, .requestOnly = true + }).req;v9fs_req_wait_for_reply (req,NULL );v9fs_rlopen (req,NULL ,NULL );
@@ -387,7 +394,9 @@ static void fs_write(void *obj, void *data, QGuestAllocator *t_alloc) .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames }); - req =v9fs_tlopen (v9p,1 ,O_WRONLY ,0 ); + req =tlopen ({ + .client = v9p, .fid = 1, .flags = O_WRONLY, .requestOnly = true + }).req;v9fs_req_wait_for_reply (req,NULL );v9fs_rlopen (req,NULL ,NULL );
@@ -413,7 +422,9 @@ static void fs_flush_success(void *obj, void *data, QGuestAllocator *t_alloc) .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames }); - req =v9fs_tlopen (v9p,1 ,O_WRONLY ,0 ); + req =tlopen ({ + .client = v9p, .fid = 1, .flags = O_WRONLY, .requestOnly = true + }).req;v9fs_req_wait_for_reply (req,NULL );v9fs_rlopen (req,NULL ,NULL );
@@ -450,7 +461,9 @@ static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc) .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames }); - req =v9fs_tlopen (v9p,1 ,O_WRONLY ,0 ); + req =tlopen ({ + .client = v9p, .fid = 1, .flags = O_WRONLY, .requestOnly = true + }).req;v9fs_req_wait_for_reply (req,NULL );v9fs_rlopen (req,NULL ,NULL );
Signature · 1 line
2.30.2
[PULL 20/23] tests/9p: merge v9fs_tsymlink() and do_symlink()
In reply to Christian SchoenebeckAs with previous patches, unify those 2 functions into a single function v9fs_tsymlink() by using a declarative function arguments approach.
Message-Id: <563f3ad04fe596ce0ae1e2654d1d08237f18c830.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 37 ++++++++++++++++++++++----- tests/qtest/libqos/virtio-9p-client.h | 35 +++++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 27 +++++++------------ 3 files changed, 73 insertions(+), 26 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +31 -6
@@ -892,10 +892,23 @@ void v9fs_rlcreate(P9Req *req, v9fs_qid *qid, uint32_t *iounit) }/* size[4] Tsymlink tag[2] fid[4] name[s] symtgt[s] gid[4] */ -P9Req *v9fs_tsymlink (QVirtio9P *v9p,uint32_t fid,const char *name, -const char *symtgt,uint32_t gid,uint16_t tag) +TsymlinkRes v9fs_tsymlink (TsymlinkOpt opt) {P9Req *req; +uint32_t err; + g_autofree char *name = g_strdup(opt.name); + g_autofree char *symtgt = g_strdup(opt.symtgt); + +g_assert (opt.client); +/* expecting either hi-level atPath or low-level fid, but not both */ +g_assert (!opt.atPath || !opt.fid); +/* expecting either Rsymlink or Rlerror, but obviously not both */ +g_assert (!opt.expectErr || !opt.rsymlink.qid); + +if (opt.atPath) { + opt.fid =v9fs_twalk ((TWalkOpt ) { .client = opt.client, + .path = opt.atPath }).newfid; + }uint32_t body_size =4 +4 ;uint16_t string_size =v9fs_string_size (name) +v9fs_string_size (symtgt);
@@ -903,13 +916,25 @@ P9Req *v9fs_tsymlink(QVirtio9P *v9p, uint32_t fid, const char *name, g_assert_cmpint(body_size, <=, UINT32_MAX - string_size); body_size += string_size; - req =v9fs_req_init (v9p, body_size,P9_TSYMLINK , tag); -v9fs_uint32_write (req, fid); + req =v9fs_req_init (opt.client, body_size,P9_TSYMLINK , opt.tag); +v9fs_uint32_write (req, opt.fid);v9fs_string_write (req, name);v9fs_string_write (req, symtgt); -v9fs_uint32_write (req, gid); +v9fs_uint32_write (req, opt.gid);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rsymlink (req, opt.rsymlink.qid); + } + req =NULL ;/* request was freed */ + } + +return (TsymlinkRes ) { .req = req }; }/* size[4] Rsymlink tag[2] qid[13] */
tests/qtest/libqos/virtio-9p-client.h +33 -2
@@ -355,6 +355,38 @@ typedef struct TlcreateRes {P9Req *req; } TlcreateRes; +/* options for 'Tsymlink' 9p request */ +typedef struct TsymlinkOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* low-level variant of directory where symlink shall be created */ +uint32_t fid; +/* high-level variant of directory where symlink shall be created */ +const char *atPath; +/* name of symlink (required) */ +const char *name; +/* where symlink will point to (required) */ +const char *symtgt; +/* effective group ID of caller */ +uint32_t gid; +/* data being received from 9p server as 'Rsymlink' response (optional) */ +struct { +v9fs_qid *qid; + } rsymlink; +/* only send Tsymlink request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TsymlinkOpt ; + +/* result of 'Tsymlink' 9p request */ +typedef struct TsymlinkRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TsymlinkRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -398,8 +430,7 @@ TMkdirRes v9fs_tmkdir(TMkdirOpt);void v9fs_rmkdir (P9Req *req,v9fs_qid *qid);TlcreateRes v9fs_tlcreate (TlcreateOpt );void v9fs_rlcreate (P9Req *req,v9fs_qid *qid,uint32_t *iounit); -P9Req *v9fs_tsymlink (QVirtio9P *v9p,uint32_t fid,const char *name, -const char *symtgt,uint32_t gid,uint16_t tag); +TsymlinkRes v9fs_tsymlink (TsymlinkOpt );void v9fs_rsymlink (P9Req *req,v9fs_qid *qid);P9Req *v9fs_tlink (QVirtio9P *v9p,uint32_t dfid,uint32_t fid,const char *name,uint16_t tag);
tests/qtest/virtio-9p-test.c +9 -18
@@ -26,6 +26,7 @@#define tflush (...) v9fs_tflush((TFlushOpt) __VA_ARGS__)#define tmkdir (...) v9fs_tmkdir((TMkdirOpt) __VA_ARGS__)#define tlcreate (...) v9fs_tlcreate((TlcreateOpt) __VA_ARGS__) +#define tsymlink (...) v9fs_tsymlink((TsymlinkOpt) __VA_ARGS__)static void pci_config (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -479,22 +480,6 @@ static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc)g_free (wnames[0 ]); } -/* create symlink named @a clink in directory @a path pointing to @a to */ -static void do_symlink (QVirtio9P *v9p,const char *path,const char *clink, -const char *to) -{ - g_autofree char *name = g_strdup(clink); - g_autofree char *dst = g_strdup(to); -uint32_t fid; -P9Req *req; - - fid = twalk({ .client = v9p, .path = path }).newfid; - - req =v9fs_tsymlink (v9p, fid, name, dst,0 ,0 ); -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rsymlink (req,NULL ); -} -/* create a hard link named @a clink in directory @a path pointing to @a to */ static void do_hardlink (QVirtio9P *v9p,const char *path,const char *clink,const char *to)
@@ -642,7 +627,10 @@ static void fs_symlink_file(void *obj, void *data, QGuestAllocator *t_alloc)g_assert (stat (real_file, &st) ==0 );g_assert ((st.st_mode &S_IFMT ) ==S_IFREG ); -do_symlink (v9p,"05" ,"symlink_file" ,"real_file" ); +tsymlink ({ + .client = v9p, .atPath = "05", .name = "symlink_file", + .symtgt = "real_file" + });/* check if created link exists now */ g_assert (stat (symlink_file, &st) ==0 );
@@ -663,7 +651,10 @@ static void fs_unlinkat_symlink(void *obj, void *data,g_assert (stat (real_file, &st) ==0 );g_assert ((st.st_mode &S_IFMT ) ==S_IFREG ); -do_symlink (v9p,"06" ,"symlink_file" ,"real_file" ); +tsymlink ({ + .client = v9p, .atPath = "06", .name = "symlink_file", + .symtgt = "real_file" + });g_assert (stat (symlink_file, &st) ==0 );do_unlinkat (v9p,"06" ,"symlink_file" ,0 );
Signature · 1 line
2.30.2
[PULL 08/23] tests/9p: simplify callers of tattach()
In reply to Christian SchoenebeckNow as tattach() is using a declarative approach, simplify the code of callers of this function.
Message-Id: <9b50e5b89a0072e84a9191d18c19a53546a28bba.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/virtio-9p-test.c | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-)
tests/qtest/virtio-9p-test.c +8 -11
@@ -302,11 +302,10 @@ static void fs_walk_none(void *obj, void *data, QGuestAllocator *t_alloc)struct v9fs_attr attr; tversion({ .client = v9p }); - req =tattach ({ - .client = v9p, .fid = 0, .n_uname = getuid(), .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rattach (req, &root_qid); +tattach ({ + .client = v9p, .fid = 0, .n_uname = getuid(), + .rattach.qid = &root_qid + }); twalk({ .client = v9p, .fid = 0, .newfid = 1, .nwname = 0, .wnames = NULL,
@@ -330,14 +329,12 @@ static void fs_walk_dotdot(void *obj, void *data, QGuestAllocator *t_alloc)char *wnames[] = {g_strdup (".." ) };v9fs_qid root_qid; g_autofree v9fs_qid *wqid = NULL; -P9Req *req; tversion({ .client = v9p }); - req =tattach ((TAttachOpt ) { - .client = v9p, .fid =0 , .n_uname =getuid (), .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rattach (req, &root_qid); +tattach ({ + .client = v9p, .fid = 0, .n_uname = getuid(), + .rattach.qid = &root_qid + }); twalk({ .client = v9p, .fid = 0, .newfid = 1, .nwname = 1, .wnames = wnames,
Signature · 1 line
2.30.2
[PULL 10/23] tests/9p: simplify callers of tgetattr()
In reply to Christian SchoenebeckNow as tgetattr() is using a declarative approach, simplify the code of callers of this function.
Message-Id: <60c6a083f320b86f3172951445df7bbc895932e2.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/virtio-9p-test.c | 22 +++++++--------------- 1 file changed, 7 insertions(+), 15 deletions(-)
tests/qtest/virtio-9p-test.c +7 -15
@@ -264,8 +264,7 @@ static void fs_walk_2nd_nonexistent(void *obj, void *data,v9fs_set_allocator (t_alloc);v9fs_qid root_qid;uint16_t nwqid; -uint32_t fid, err; -P9Req *req; +uint32_t fid; g_autofree v9fs_qid *wqid = NULL; g_autofree char *path = g_strdup_printf( QTEST_V9FS_SYNTH_WALK_FILE "/non-existent", 0
@@ -286,14 +285,10 @@ static void fs_walk_2nd_nonexistent(void *obj, void *data,g_assert (wqid && wqid[0 ] && !is_same_qid (root_qid, wqid[0 ]));/* expect fid being unaffected by walk above */ - req =tgetattr ({ +tgetattr ({ .client = v9p, .fid = fid, .request_mask = P9_GETATTR_BASIC, - .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rlerror (req, &err); - - g_assert_cmpint(err, ==, ENOENT); + .expectErr = ENOENT + }); }static void fs_walk_none (void *obj,void *data,QGuestAllocator *t_alloc)
@@ -302,7 +297,6 @@ static void fs_walk_none(void *obj, void *data, QGuestAllocator *t_alloc)v9fs_set_allocator (t_alloc);v9fs_qid root_qid; g_autofree v9fs_qid *wqid = NULL; -P9Req *req;struct v9fs_attr attr; tversion({ .client = v9p });
@@ -319,12 +313,10 @@ static void fs_walk_none(void *obj, void *data, QGuestAllocator *t_alloc)/* special case: no QID is returned if nwname=0 was sent */ g_assert (wqid ==NULL ); - req =tgetattr ({ +tgetattr ({ .client = v9p, .fid = 1, .request_mask = P9_GETATTR_BASIC, - .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rgetattr (req, &attr); + .rgetattr.attr = &attr + });g_assert (is_same_qid (root_qid, attr.qid)); }
Signature · 1 line
2.30.2
Quoted 19 lines · CEST Christian Schoenebeck
The following changes since commit
0529245488865038344d64fff7ee05864d3d17f6:Merge tag 'pull-target-arm-20221020' of https://git.linaro.org/people/pmaydell/qemu-arm into staging (2022-10-20 14:36:12 -0400)
are available in the Git repository at:
https://github.com/cschoenebeck/qemu.git tags/pull-9p-20221024
for you to fetch changes up to
3ce77865bf813f313cf79c00fd951bfc95a50165:tests/9p: remove unnecessary
g_strdup()calls (2022-10-24 12:24:32 +0200)----------------------------------------------------------------
9pfs: performance, Windows host prep, tests restructure* Highlight of this PR is Linus Heckemann's GHashTable patch which brings massive general performance improvements of 9p server somewhere between factor 6 .. 12.
Quoted 6 lines
* Bin Meng's
g_mkdirpatch is a preparatory patch for upcoming Windows host support of 9p server.* The rest of the patches in this PR are 9p test code restructuring and refactoring changes to improve readability and to ease maintenance of 9p test code on the long-term.
Unfortunately I haven't found any reviewer of my patches 04 .. 23. :/ I decided to queue them anyway, as they are just restructuring and refactoring of 9p test code:
https://lore.kernel.org/all/[email protected]
If anybody finds some time at least for a glimpse on them, very much appreciated!
Best regards,
Christian Schoenebeck
Quoted 42 lines
----------------------------------------------------------------
Bin Meng (1):
fsdev/virtfs-proxy-helper: Useg_mkdir()Christian Schoenebeck (21):
tests/9p: splitvirtio-9p-test.cinto tests and 9p client part tests/9p: merge *walk*() functions
tests/9p: simplify callers oftwalk()
tests/9p: mergev9fs_tversion()anddo_version()tests/9p: mergev9fs_tattach(),do_attach(),do_attach_rqid()tests/9p: simplify callers oftattach()
tests/9p: convertv9fs_tgetattr()to declarative arguments tests/9p: simplify callers oftgetattr()
tests/9p: convertv9fs_treaddir()to declarative arguments tests/9p: simplify callers oftreaddir()
tests/9p: convertv9fs_tlopen()to declarative arguments tests/9p: simplify callers oftlopen()
tests/9p: convertv9fs_twrite()to declarative arguments tests/9p: simplify callers oftwrite()
tests/9p: convertv9fs_tflush()to declarative arguments tests/9p: mergev9fs_tmkdir()anddo_mkdir()tests/9p: mergev9fs_tlcreate()anddo_lcreate()tests/9p: mergev9fs_tsymlink()anddo_symlink()tests/9p: mergev9fs_tlink()anddo_hardlink()tests/9p: mergev9fs_tunlinkat()anddo_unlinkat()tests/9p: remove unnecessaryg_strdup()callsLinus Heckemann (1):
9pfs: use GHashTable for fid tablefsdev/virtfs-proxy-helper.c | 3 +- hw/9pfs/9p.c | 196 ++--- hw/9pfs/9p.h | 2 +- tests/qtest/libqos/meson.build | 1 + tests/qtest/libqos/virtio-9p-client.c | 1049 ++++++++++++++++++++++++++ tests/qtest/libqos/virtio-9p-client.h | 494 +++++++++++++ tests/qtest/virtio-9p-test.c | 1299 ++++++--------------------------- 7 files changed, 1867 insertions(+), 1177 deletions(-) create mode 100644 tests/qtest/libqos/virtio-9p-client.c create mode 100644 tests/qtest/libqos/virtio-9p-client.h
[PULL 18/23] tests/9p: merge v9fs_tmkdir() and do_mkdir()
In reply to Christian SchoenebeckAs with previous patches, unify those 2 functions into a single function v9fs_tmkdir() by using a declarative function arguments approach.
Message-Id: <b87b2c972921df980440ff5b2d3e6bb8163d6551.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 42 ++++++++++++++++++++++----- tests/qtest/libqos/virtio-9p-client.h | 36 +++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 30 ++++++------------- 3 files changed, 78 insertions(+), 30 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +35 -7
@@ -766,10 +766,26 @@ void v9fs_rflush(P9Req *req) }/* size[4] Tmkdir tag[2] dfid[4] name[s] mode[4] gid[4] */ -P9Req *v9fs_tmkdir (QVirtio9P *v9p,uint32_t dfid,const char *name, -uint32_t mode,uint32_t gid,uint16_t tag) +TMkdirRes v9fs_tmkdir (TMkdirOpt opt) {P9Req *req; +uint32_t err; + g_autofree char *name = g_strdup(opt.name); + +g_assert (opt.client); +/* expecting either hi-level atPath or low-level dfid, but not both */ +g_assert (!opt.atPath || !opt.dfid); +/* expecting either Rmkdir or Rlerror, but obviously not both */ +g_assert (!opt.expectErr || !opt.rmkdir.qid); + +if (opt.atPath) { + opt.dfid =v9fs_twalk ((TWalkOpt ) { .client = opt.client, + .path = opt.atPath }).newfid; + } + +if (!opt.mode) { + opt.mode =0750 ; + }uint32_t body_size =4 +4 +4 ;uint16_t string_size =v9fs_string_size (name);
@@ -777,13 +793,25 @@ P9Req *v9fs_tmkdir(QVirtio9P *v9p, uint32_t dfid, const char *name, g_assert_cmpint(body_size, <=, UINT32_MAX - string_size); body_size += string_size; - req =v9fs_req_init (v9p, body_size,P9_TMKDIR , tag); -v9fs_uint32_write (req, dfid); + req =v9fs_req_init (opt.client, body_size,P9_TMKDIR , opt.tag); +v9fs_uint32_write (req, opt.dfid);v9fs_string_write (req, name); -v9fs_uint32_write (req, mode); -v9fs_uint32_write (req, gid); +v9fs_uint32_write (req, opt.mode); +v9fs_uint32_write (req, opt.gid);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rmkdir (req, opt.rmkdir.qid); + } + req =NULL ;/* request was freed */ + } + +return (TMkdirRes ) { .req = req }; }/* size[4] Rmkdir tag[2] qid[13] */
tests/qtest/libqos/virtio-9p-client.h +34 -2
@@ -287,6 +287,39 @@ typedef struct TFlushRes {P9Req *req; } TFlushRes; +/* options for 'Tmkdir' 9p request */ +typedef struct TMkdirOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* low level variant of directory where new one shall be created */ +uint32_t dfid; +/* high-level variant of directory where new one shall be created */ +const char *atPath; +/* New directory's name (required) */ +const char *name; +/* Linux mkdir(2) mode bits (optional) */ +uint32_t mode; +/* effective group ID of caller */ +uint32_t gid; +/* data being received from 9p server as 'Rmkdir' response (optional) */ +struct { +/* QID of newly created directory */ +v9fs_qid *qid; + } rmkdir; +/* only send Tmkdir request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TMkdirOpt ; + +/* result of 'TMkdir' 9p request */ +typedef struct TMkdirRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TMkdirRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -326,8 +359,7 @@ TWriteRes v9fs_twrite(TWriteOpt);void v9fs_rwrite (P9Req *req,uint32_t *count);TFlushRes v9fs_tflush (TFlushOpt );void v9fs_rflush (P9Req *req); -P9Req *v9fs_tmkdir (QVirtio9P *v9p,uint32_t dfid,const char *name, -uint32_t mode,uint32_t gid,uint16_t tag); +TMkdirRes v9fs_tmkdir (TMkdirOpt );void v9fs_rmkdir (P9Req *req,v9fs_qid *qid); P9Req *v9fs_tlcreate(QVirtio9P *v9p, uint32_t fid, const char *name, uint32_t flags, uint32_t mode, uint32_t gid,
tests/qtest/virtio-9p-test.c +9 -21
@@ -24,6 +24,7 @@#define tlopen (...) v9fs_tlopen((TLOpenOpt) __VA_ARGS__)#define twrite (...) v9fs_twrite((TWriteOpt) __VA_ARGS__)#define tflush (...) v9fs_tflush((TFlushOpt) __VA_ARGS__) +#define tmkdir (...) v9fs_tmkdir((TMkdirOpt) __VA_ARGS__)static void pci_config (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -477,19 +478,6 @@ static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc)g_free (wnames[0 ]); } -static void do_mkdir (QVirtio9P *v9p,const char *path,const char *cname) -{ - g_autofree char *name = g_strdup(cname); -uint32_t fid; -P9Req *req; - - fid = twalk({ .client = v9p, .path = path }).newfid; - - req =v9fs_tmkdir (v9p, fid, name,0750 ,0 ,0 ); -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rmkdir (req,NULL ); -} -/* create a regular file with Tlcreate and return file's fid */ static uint32_t do_lcreate (QVirtio9P *v9p,const char *path,const char *cname)
@@ -587,7 +575,7 @@ static void fs_create_dir(void *obj, void *data, QGuestAllocator *t_alloc)g_assert (root_path !=NULL ); tattach({ .client = v9p }); -do_mkdir (v9p,"/" ,"01" ); + tmkdir({ .client = v9p, .atPath = "/", .name = "01" });/* check if created directory really exists now ... */ g_assert (stat (new_dir, &st) ==0 );
@@ -606,7 +594,7 @@ static void fs_unlinkat_dir(void *obj, void *data, QGuestAllocator *t_alloc)g_assert (root_path !=NULL ); tattach({ .client = v9p }); -do_mkdir (v9p,"/" ,"02" ); + tmkdir({ .client = v9p, .atPath = "/", .name = "02" });/* check if created directory really exists now ... */ g_assert (stat (new_dir, &st) ==0 );
@@ -626,7 +614,7 @@ static void fs_create_file(void *obj, void *data, QGuestAllocator *t_alloc) g_autofree char *new_file = virtio_9p_test_path("03/1st_file"); tattach({ .client = v9p }); -do_mkdir (v9p,"/" ,"03" ); + tmkdir({ .client = v9p, .atPath = "/", .name = "03" });do_lcreate (v9p,"03" ,"1st_file" );/* check if created file exists now ... */
@@ -643,7 +631,7 @@ static void fs_unlinkat_file(void *obj, void *data, QGuestAllocator *t_alloc) g_autofree char *new_file = virtio_9p_test_path("04/doa_file"); tattach({ .client = v9p }); -do_mkdir (v9p,"/" ,"04" ); + tmkdir({ .client = v9p, .atPath = "/", .name = "04" });do_lcreate (v9p,"04" ,"doa_file" );/* check if created file exists now ... */
@@ -665,7 +653,7 @@ static void fs_symlink_file(void *obj, void *data, QGuestAllocator *t_alloc) g_autofree char *symlink_file = virtio_9p_test_path("05/symlink_file"); tattach({ .client = v9p }); -do_mkdir (v9p,"/" ,"05" ); + tmkdir({ .client = v9p, .atPath = "/", .name = "05" });do_lcreate (v9p,"05" ,"real_file" );g_assert (stat (real_file, &st) ==0 );g_assert ((st.st_mode &S_IFMT ) ==S_IFREG );
@@ -686,7 +674,7 @@ static void fs_unlinkat_symlink(void *obj, void *data, g_autofree char *symlink_file = virtio_9p_test_path("06/symlink_file"); tattach({ .client = v9p }); -do_mkdir (v9p,"/" ,"06" ); + tmkdir({ .client = v9p, .atPath = "/", .name = "06" });do_lcreate (v9p,"06" ,"real_file" );g_assert (stat (real_file, &st) ==0 );g_assert ((st.st_mode &S_IFMT ) ==S_IFREG );
@@ -708,7 +696,7 @@ static void fs_hardlink_file(void *obj, void *data, QGuestAllocator *t_alloc) g_autofree char *hardlink_file = virtio_9p_test_path("07/hardlink_file"); tattach({ .client = v9p }); -do_mkdir (v9p,"/" ,"07" ); + tmkdir({ .client = v9p, .atPath = "/", .name = "07" });do_lcreate (v9p,"07" ,"real_file" );g_assert (stat (real_file, &st_real) ==0 );g_assert ((st_real.st_mode &S_IFMT ) ==S_IFREG );
@@ -733,7 +721,7 @@ static void fs_unlinkat_hardlink(void *obj, void *data, g_autofree char *hardlink_file = virtio_9p_test_path("08/hardlink_file"); tattach({ .client = v9p }); -do_mkdir (v9p,"/" ,"08" ); + tmkdir({ .client = v9p, .atPath = "/", .name = "08" });do_lcreate (v9p,"08" ,"real_file" );g_assert (stat (real_file, &st_real) ==0 );g_assert ((st_real.st_mode &S_IFMT ) ==S_IFREG );
Signature · 1 line
2.30.2
[PULL 17/23] tests/9p: convert v9fs_tflush() to declarative arguments
In reply to Christian SchoenebeckUse declarative function arguments for function v9fs_tflush().
Message-Id: <91b7b154298c500d100b05137146c2905c3acdec.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 23 +++++++++++++++++++---- tests/qtest/libqos/virtio-9p-client.h | 22 +++++++++++++++++++++- tests/qtest/virtio-9p-test.c | 9 +++++++-- 3 files changed, 47 insertions(+), 7 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +19 -4
@@ -733,14 +733,29 @@ void v9fs_rwrite(P9Req *req, uint32_t *count) }/* size[4] Tflush tag[2] oldtag[2] */ -P9Req *v9fs_tflush (QVirtio9P *v9p,uint16_t oldtag,uint16_t tag) +TFlushRes v9fs_tflush (TFlushOpt opt) {P9Req *req; +uint32_t err; - req =v9fs_req_init (v9p,2 ,P9_TFLUSH , tag); -v9fs_uint32_write (req, oldtag); +g_assert (opt.client); + + req =v9fs_req_init (opt.client,2 ,P9_TFLUSH , opt.tag); +v9fs_uint32_write (req, opt.oldtag);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rflush (req); + } + req =NULL ;/* request was freed */ + } + +return (TFlushRes ) { .req = req }; }/* size[4] Rflush tag[2] */
tests/qtest/libqos/virtio-9p-client.h +21 -1
@@ -267,6 +267,26 @@ typedef struct TWriteRes {uint32_t count; } TWriteRes; +/* options for 'Tflush' 9p request */ +typedef struct TFlushOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* message to flush (required) */ +uint16_t oldtag; +/* only send Tflush request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TFlushOpt ; + +/* result of 'Tflush' 9p request */ +typedef struct TFlushRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TFlushRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -304,7 +324,7 @@ TLOpenRes v9fs_tlopen(TLOpenOpt);void v9fs_rlopen (P9Req *req,v9fs_qid *qid,uint32_t *iounit);TWriteRes v9fs_twrite (TWriteOpt );void v9fs_rwrite (P9Req *req,uint32_t *count); -P9Req *v9fs_tflush (QVirtio9P *v9p,uint16_t oldtag,uint16_t tag); +TFlushRes v9fs_tflush (TFlushOpt );void v9fs_rflush (P9Req *req);P9Req *v9fs_tmkdir (QVirtio9P *v9p,uint32_t dfid,const char *name,uint32_t mode,uint32_t gid,uint16_t tag);
tests/qtest/virtio-9p-test.c +7 -2
@@ -23,6 +23,7 @@#define treaddir (...) v9fs_treaddir((TReadDirOpt) __VA_ARGS__)#define tlopen (...) v9fs_tlopen((TLOpenOpt) __VA_ARGS__)#define twrite (...) v9fs_twrite((TWriteOpt) __VA_ARGS__) +#define tflush (...) v9fs_tflush((TFlushOpt) __VA_ARGS__)static void pci_config (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -420,7 +421,9 @@ static void fs_flush_success(void *obj, void *data, QGuestAllocator *t_alloc) .requestOnly = true }).req; - flush_req =v9fs_tflush (v9p, req->tag,1 ); + flush_req =tflush ({ + .client = v9p, .oldtag = req->tag, .tag = 1, .requestOnly = true + }).req;/* The write request is supposed to be flushed: the server should just * mark the write request as used and reply to the flush request.
@@ -459,7 +462,9 @@ static void fs_flush_ignored(void *obj, void *data, QGuestAllocator *t_alloc) .requestOnly = true }).req; - flush_req =v9fs_tflush (v9p, req->tag,1 ); + flush_req =tflush ({ + .client = v9p, .oldtag = req->tag, .tag = 1, .requestOnly = true + }).req;/* The write request is supposed to complete. The server should * reply to the write request and the flush request.
Signature · 1 line
2.30.2
[PULL 01/23] fsdev/virtfs-proxy-helper: Use g_mkdir()
In reply to Christian SchoenebeckFrom: Bin Meng <[email protected]>
Use g_mkdir() to create a directory on all platforms.
Message-Id: <[email protected]>
--- fsdev/virtfs-proxy-helper.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fsdev/virtfs-proxy-helper.c +2 -1
@@ -10,6 +10,7 @@*/ #include "qemu/osdep.h" +#include <glib/gstdio.h> #include <sys/resource.h> #include <getopt.h> #include <syslog.h>
@@ -639,7 +640,7 @@ static int do_create_others(int type, struct iovec *iovec)if (retval <0 ) { goto err_out; } - retval =mkdir (path.data, mode); + retval =g_mkdir (path.data, mode);break ;case T_SYMLINK : retval =proxy_unmarshal (iovec, offset,"ss" , &oldpath, &path);
Signature · 1 line
2.30.2
[PULL 06/23] tests/9p: merge v9fs_tversion() and do_version()
In reply to Christian SchoenebeckAs with previous patches, unify functions v9fs_tversion() and do_version() into a single function v9fs_tversion() by using a declarative function arguments approach.
Message-Id: <2d253491aaffd267ec295f056dda47456692cd0c.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 47 +++++++++++++++++++++++---- tests/qtest/libqos/virtio-9p-client.h | 25 ++++++++++++-- tests/qtest/virtio-9p-test.c | 23 +++---------- 3 files changed, 68 insertions(+), 27 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +40 -7
@@ -291,21 +291,54 @@ void v9fs_rlerror(P9Req *req, uint32_t *err) }/* size[4] Tversion tag[2] msize[4] version[s] */ -P9Req *v9fs_tversion (QVirtio9P *v9p,uint32_t msize,const char *version, -uint16_t tag) +TVersionRes v9fs_tversion (TVersionOpt opt) {P9Req *req; +uint32_t err;uint32_t body_size =4 ; -uint16_t string_size =v9fs_string_size (version); +uint16_t string_size; +uint16_t server_len; + g_autofree char *server_version = NULL; +g_assert (opt.client); + +if (!opt.msize) { + opt.msize =P9_MAX_SIZE ; + } + +if (!opt.tag) { + opt.tag =P9_NOTAG ; + } + +if (!opt.version) { + opt.version ="9P2000.L" ; + } + + string_size =v9fs_string_size (opt.version); g_assert_cmpint(body_size, <=, UINT32_MAX - string_size); body_size += string_size; - req =v9fs_req_init (v9p, body_size,P9_TVERSION , tag); + req =v9fs_req_init (opt.client, body_size,P9_TVERSION , opt.tag); -v9fs_uint32_write (req, msize); -v9fs_string_write (req, version); +v9fs_uint32_write (req, opt.msize); +v9fs_string_write (req, opt.version);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rversion (req, &server_len, &server_version); +g_assert_cmpmem (server_version, server_len, + opt.version,strlen (opt.version)); + } + req =NULL ;/* request was freed */ + } + +return (TVersionRes ) { + .req = req, + }; }/* size[4] Rversion tag[2] msize[4] version[s] */
tests/qtest/libqos/virtio-9p-client.h +23 -2
@@ -106,6 +106,28 @@ typedef struct TWalkRes {P9Req *req; } TWalkRes; +/* options for 'Tversion' 9p request */ +typedef struct TVersionOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* maximum message size that can be handled by client (optional) */ +uint32_t msize; +/* protocol version (optional) */ +const char *version; +/* only send Tversion request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TVersionOpt ; + +/* result of 'Tversion' 9p request */ +typedef struct TVersionRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TVersionRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -127,8 +149,7 @@ void v9fs_req_wait_for_reply(P9Req *req, uint32_t *len);void v9fs_req_recv (P9Req *req,uint8_t id);void v9fs_req_free (P9Req *req);void v9fs_rlerror (P9Req *req,uint32_t *err); -P9Req *v9fs_tversion (QVirtio9P *v9p,uint32_t msize,const char *version, -uint16_t tag); +TVersionRes v9fs_tversion (TVersionOpt );void v9fs_rversion (P9Req *req,uint16_t *len,char **version);P9Req *v9fs_tattach (QVirtio9P *v9p,uint32_t fid,uint32_t n_uname,uint16_t tag);
tests/qtest/virtio-9p-test.c +5 -18
@@ -17,6 +17,7 @@#include "libqos/virtio-9p-client.h" #define twalk (...) v9fs_twalk((TWalkOpt) __VA_ARGS__) +#define tversion (...) v9fs_tversion((TVersionOpt) __VA_ARGS__)static void pci_config (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -41,31 +42,17 @@ static inline bool is_same_qid(v9fs_qid a, v9fs_qid b)return a[0 ] == b[0 ] &&memcmp (&a[5 ], &b[5 ],8 ) ==0 ; } -static void do_version (QVirtio9P *v9p) -{ -const char *version ="9P2000.L" ; -uint16_t server_len; - g_autofree char *server_version = NULL; -P9Req *req; - - req =v9fs_tversion (v9p,P9_MAX_SIZE , version,P9_NOTAG ); -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rversion (req, &server_len, &server_version); - -g_assert_cmpmem (server_version, server_len, version,strlen (version)); -} -static void fs_version (void *obj,void *data,QGuestAllocator *t_alloc) {v9fs_set_allocator (t_alloc); -do_version (obj); + tversion({ .client = obj }); }static void do_attach_rqid (QVirtio9P *v9p,v9fs_qid *qid) {P9Req *req; -do_version (v9p); + tversion({ .client = v9p }); req =v9fs_tattach (v9p,0 ,getuid (),0 );v9fs_req_wait_for_reply (req,NULL );v9fs_rattach (req, qid);
@@ -328,7 +315,7 @@ static void fs_walk_none(void *obj, void *data, QGuestAllocator *t_alloc)P9Req *req;struct v9fs_attr attr; -do_version (v9p); + tversion({ .client = v9p }); req =v9fs_tattach (v9p,0 ,getuid (),0 );v9fs_req_wait_for_reply (req,NULL );v9fs_rattach (req, &root_qid);
@@ -357,7 +344,7 @@ static void fs_walk_dotdot(void *obj, void *data, QGuestAllocator *t_alloc) g_autofree v9fs_qid *wqid = NULL;P9Req *req; -do_version (v9p); + tversion({ .client = v9p }); req =v9fs_tattach (v9p,0 ,getuid (),0 );v9fs_req_wait_for_reply (req,NULL );v9fs_rattach (req, &root_qid);
Signature · 1 line
2.30.2
The following changes since commit 0529245488865038344d64fff7ee05864d3d17f6:
Merge tag 'pull-target-arm-20221020' of https://git.linaro.org/people/pmaydell/qemu-arm into staging (2022-10-20 14:36:12 -0400)
are available in the Git repository at:
https://github.com/cschoenebeck/qemu.git tags/pull-9p-20221024
for you to fetch changes up to 3ce77865bf813f313cf79c00fd951bfc95a50165:
tests/9p: remove unnecessary g_strdup() calls (2022-10-24 12:24:32 +0200)
----------------------------------------------------------------
9pfs: performance, Windows host prep, tests restructure
* Highlight of this PR is Linus Heckemann's GHashTable patch which brings massive general performance improvements of 9p server somewhere between factor 6 .. 12.
* Bin Meng's g_mkdir patch is a preparatory patch for upcoming Windows host support of 9p server.
* The rest of the patches in this PR are 9p test code restructuring and refactoring changes to improve readability and to ease maintenance of 9p test code on the long-term.
----------------------------------------------------------------
Bin Meng (1):
fsdev/virtfs-proxy-helper: Use g_mkdir()
Christian Schoenebeck (21):
tests/9p: split virtio-9p-test.c into tests and 9p client part tests/9p: merge *walk*() functions
tests/9p: simplify callers of twalk()
tests/9p: merge v9fs_tversion() and do_version() tests/9p: merge v9fs_tattach(), do_attach(), do_attach_rqid() tests/9p: simplify callers of tattach()
tests/9p: convert v9fs_tgetattr() to declarative arguments tests/9p: simplify callers of tgetattr()
tests/9p: convert v9fs_treaddir() to declarative arguments tests/9p: simplify callers of treaddir()
tests/9p: convert v9fs_tlopen() to declarative arguments tests/9p: simplify callers of tlopen()
tests/9p: convert v9fs_twrite() to declarative arguments tests/9p: simplify callers of twrite()
tests/9p: convert v9fs_tflush() to declarative arguments tests/9p: merge v9fs_tmkdir() and do_mkdir() tests/9p: merge v9fs_tlcreate() and do_lcreate() tests/9p: merge v9fs_tsymlink() and do_symlink() tests/9p: merge v9fs_tlink() and do_hardlink() tests/9p: merge v9fs_tunlinkat() and do_unlinkat() tests/9p: remove unnecessary g_strdup() calls
Linus Heckemann (1):
9pfs: use GHashTable for fid table
fsdev/virtfs-proxy-helper.c | 3 +- hw/9pfs/9p.c | 196 ++--- hw/9pfs/9p.h | 2 +- tests/qtest/libqos/meson.build | 1 + tests/qtest/libqos/virtio-9p-client.c | 1049 ++++++++++++++++++++++++++ tests/qtest/libqos/virtio-9p-client.h | 494 +++++++++++++ tests/qtest/virtio-9p-test.c | 1299 ++++++--------------------------- 7 files changed, 1867 insertions(+), 1177 deletions(-) create mode 100644 tests/qtest/libqos/virtio-9p-client.c create mode 100644 tests/qtest/libqos/virtio-9p-client.h
[PULL 11/23] tests/9p: convert v9fs_treaddir() to declarative arguments
Use declarative function arguments for function v9fs_treaddir().
Message-Id: <a66aae4ceb19ec12d245b8c7f33a639584c8e272.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 32 ++++++++++++++++++++------ tests/qtest/libqos/virtio-9p-client.h | 33 +++++++++++++++++++++++++-- tests/qtest/virtio-9p-test.c | 11 +++++++-- 3 files changed, 65 insertions(+), 11 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +25 -7
@@ -557,17 +557,35 @@ void v9fs_rgetattr(P9Req *req, v9fs_attr *attr) }/* size[4] Treaddir tag[2] fid[4] offset[8] count[4] */ -P9Req *v9fs_treaddir (QVirtio9P *v9p,uint32_t fid,uint64_t offset, -uint32_t count,uint16_t tag) +TReadDirRes v9fs_treaddir (TReadDirOpt opt) {P9Req *req; +uint32_t err; - req =v9fs_req_init (v9p,4 +8 +4 ,P9_TREADDIR , tag); -v9fs_uint32_write (req, fid); -v9fs_uint64_write (req, offset); -v9fs_uint32_write (req, count); +g_assert (opt.client); +/* expecting either Rreaddir or Rlerror, but obviously not both */ +g_assert (!opt.expectErr || !(opt.rreaddir.count || + opt.rreaddir.nentries || opt.rreaddir.entries)); + + req =v9fs_req_init (opt.client,4 +8 +4 ,P9_TREADDIR , opt.tag); +v9fs_uint32_write (req, opt.fid); +v9fs_uint64_write (req, opt.offset); +v9fs_uint32_write (req, opt.count);v9fs_req_send (req); -return req; + +if (!opt.requestOnly) { +v9fs_req_wait_for_reply (req,NULL ); +if (opt.expectErr) { +v9fs_rlerror (req, &err); + g_assert_cmpint(err, ==, opt.expectErr); + }else { +v9fs_rreaddir (req, opt.rreaddir.count, opt.rreaddir.nentries, + opt.rreaddir.entries); + } + req =NULL ;/* request was freed */ + } + +return (TReadDirRes ) { .req = req }; }/* size[4] Rreaddir tag[2] count[4] data[count] */
tests/qtest/libqos/virtio-9p-client.h +31 -2
@@ -182,6 +182,36 @@ typedef struct TGetAttrRes {P9Req *req; } TGetAttrRes; +/* options for 'Treaddir' 9p request */ +typedef struct TReadDirOpt { +/* 9P client being used (mandatory) */ +QVirtio9P *client; +/* user supplied tag number being returned with response (optional) */ +uint16_t tag; +/* file ID of directory whose entries shall be retrieved (required) */ +uint32_t fid; +/* offset in entries stream, i.e. for multiple requests (optional) */ +uint64_t offset; +/* maximum bytes to be returned by server (required) */ +uint32_t count; +/* data being received from 9p server as 'Rreaddir' response (optional) */ +struct { +uint32_t *count; +uint32_t *nentries; +struct V9fsDirent **entries; + } rreaddir; +/* only send Treaddir request but not wait for a reply? (optional) */ +bool requestOnly; +/* do we expect an Rlerror response, if yes which error code? (optional) */ +uint32_t expectErr; +}TReadDirOpt ; + +/* result of 'Treaddir' 9p request */ +typedef struct TReadDirRes { +/* if requestOnly was set: request object for further processing */ +P9Req *req; +}TReadDirRes ; +void v9fs_set_allocator (QGuestAllocator *t_alloc);void v9fs_memwrite (P9Req *req,const void *addr,size_t len);void v9fs_memskip (P9Req *req,size_t len);
@@ -211,8 +241,7 @@ TWalkRes v9fs_twalk(TWalkOpt opt);void v9fs_rwalk (P9Req *req,uint16_t *nwqid,v9fs_qid **wqid);TGetAttrRes v9fs_tgetattr (TGetAttrOpt );void v9fs_rgetattr (P9Req *req,v9fs_attr *attr); -P9Req *v9fs_treaddir (QVirtio9P *v9p,uint32_t fid,uint64_t offset, -uint32_t count,uint16_t tag); +TReadDirRes v9fs_treaddir (TReadDirOpt );void v9fs_rreaddir (P9Req *req,uint32_t *count,uint32_t *nentries,struct V9fsDirent **entries);void v9fs_free_dirents (struct V9fsDirent *e);
tests/qtest/virtio-9p-test.c +9 -2
@@ -20,6 +20,7 @@#define tversion (...) v9fs_tversion((TVersionOpt) __VA_ARGS__)#define tattach (...) v9fs_tattach((TAttachOpt) __VA_ARGS__)#define tgetattr (...) v9fs_tgetattr((TGetAttrOpt) __VA_ARGS__) +#define treaddir (...) v9fs_treaddir((TReadDirOpt) __VA_ARGS__)static void pci_config (void *obj,void *data,QGuestAllocator *t_alloc) {
@@ -119,7 +120,10 @@ static void fs_readdir(void *obj, void *data, QGuestAllocator *t_alloc)/* * submit count = msize - 11, because 11 is the header size of Rreaddir */ - req =v9fs_treaddir (v9p,1 ,0 ,P9_MAX_SIZE -11 ,0 ); + req =treaddir ({ + .client = v9p, .fid = 1, .offset = 0, .count = P9_MAX_SIZE - 11, + .requestOnly = true + }).req;v9fs_req_wait_for_reply (req,NULL );v9fs_rreaddir (req, &count, &nentries, &entries);
@@ -186,7 +190,10 @@ static void do_readdir_split(QVirtio9P *v9p, uint32_t count) npartialentries =0 ; partialentries =NULL ; - req =v9fs_treaddir (v9p, fid, offset, count,0 ); + req =treaddir ({ + .client = v9p, .fid = fid, .offset = offset, .count = count, + .requestOnly = true + }).req;v9fs_req_wait_for_reply (req,NULL );v9fs_rreaddir (req, &count, &npartialentries, &partialentries);if (npartialentries >0 && partialentries) {
Signature · 1 line
2.30.2
[PULL 23/23] tests/9p: remove unnecessary g_strdup() calls
In reply to Christian SchoenebeckThis is a leftover from before the recent function merge and refactoring patches:
As these functions do not return control to the caller in between, it is not necessary to duplicate strings passed to them.
Message-Id: <0f80141cde3904ed0591354059da49d1d60bcdbc.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/libqos/virtio-9p-client.c | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-)
tests/qtest/libqos/virtio-9p-client.c +8 -11
@@ -770,7 +770,6 @@ TMkdirRes v9fs_tmkdir(TMkdirOpt opt) {P9Req *req;uint32_t err; - g_autofree char *name = g_strdup(opt.name);g_assert (opt.client);/* expecting either hi-level atPath or low-level dfid, but not both */
@@ -788,14 +787,14 @@ TMkdirRes v9fs_tmkdir(TMkdirOpt opt) }uint32_t body_size =4 +4 +4 ; -uint16_t string_size =v9fs_string_size (name); +uint16_t string_size =v9fs_string_size (opt.name); g_assert_cmpint(body_size, <=, UINT32_MAX - string_size); body_size += string_size; req =v9fs_req_init (opt.client, body_size,P9_TMKDIR , opt.tag);v9fs_uint32_write (req, opt.dfid); -v9fs_string_write (req, name); +v9fs_string_write (req, opt.name);v9fs_uint32_write (req, opt.mode);v9fs_uint32_write (req, opt.gid);v9fs_req_send (req);
@@ -831,7 +830,6 @@ TlcreateRes v9fs_tlcreate(TlcreateOpt opt) {P9Req *req;uint32_t err; - g_autofree char *name = g_strdup(opt.name);g_assert (opt.client);/* expecting either hi-level atPath or low-level fid, but not both */
@@ -849,14 +847,14 @@ TlcreateRes v9fs_tlcreate(TlcreateOpt opt) }uint32_t body_size =4 +4 +4 +4 ; -uint16_t string_size =v9fs_string_size (name); +uint16_t string_size =v9fs_string_size (opt.name); g_assert_cmpint(body_size, <=, UINT32_MAX - string_size); body_size += string_size; req =v9fs_req_init (opt.client, body_size,P9_TLCREATE , opt.tag);v9fs_uint32_write (req, opt.fid); -v9fs_string_write (req, name); +v9fs_string_write (req, opt.name);v9fs_uint32_write (req, opt.flags);v9fs_uint32_write (req, opt.mode);v9fs_uint32_write (req, opt.gid);
@@ -896,8 +894,6 @@ TsymlinkRes v9fs_tsymlink(TsymlinkOpt opt) {P9Req *req;uint32_t err; - g_autofree char *name = g_strdup(opt.name); - g_autofree char *symtgt = g_strdup(opt.symtgt);g_assert (opt.client);/* expecting either hi-level atPath or low-level fid, but not both */
@@ -911,15 +907,16 @@ TsymlinkRes v9fs_tsymlink(TsymlinkOpt opt) }uint32_t body_size =4 +4 ; -uint16_t string_size =v9fs_string_size (name) +v9fs_string_size (symtgt); +uint16_t string_size =v9fs_string_size (opt.name) + +v9fs_string_size (opt.symtgt); g_assert_cmpint(body_size, <=, UINT32_MAX - string_size); body_size += string_size; req =v9fs_req_init (opt.client, body_size,P9_TSYMLINK , opt.tag);v9fs_uint32_write (req, opt.fid); -v9fs_string_write (req, name); -v9fs_string_write (req, symtgt); +v9fs_string_write (req, opt.name); +v9fs_string_write (req, opt.symtgt);v9fs_uint32_write (req, opt.gid);v9fs_req_send (req);
Signature · 1 line
2.30.2
[PULL 16/23] tests/9p: simplify callers of twrite()
In reply to Christian SchoenebeckNow as twrite() is using a declarative approach, simplify the code of callers of this function.
Message-Id: <7f280ec6a1f9d8afed46567a796562c4dc28afa9.1664917004.git.qemu_oss@crudebyte.com>
--- tests/qtest/virtio-9p-test.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)
tests/qtest/virtio-9p-test.c +3 -6
@@ -377,7 +377,6 @@ static void fs_write(void *obj, void *data, QGuestAllocator *t_alloc)char *wnames[] = {g_strdup (QTEST_V9FS_SYNTH_WRITE_FILE ) }; g_autofree char *buf = g_malloc0(write_count);uint32_t count; -P9Req *req; tattach({ .client = v9p }); twalk({
@@ -386,12 +385,10 @@ static void fs_write(void *obj, void *data, QGuestAllocator *t_alloc) tlopen({ .client = v9p, .fid = 1, .flags = O_WRONLY }); - req =twrite ({ + count =twrite ({ .client = v9p, .fid = 1, .offset = 0, .count = write_count, - .data = buf, .requestOnly = true - }).req; -v9fs_req_wait_for_reply (req,NULL ); -v9fs_rwrite (req, &count); + .data = buf + }).count; g_assert_cmpint(count, ==, write_count);g_free (wnames[0 ]);
Signature · 1 line
2.30.2
Stefan Hajnoczi
AppliedApplied, thanks.
Please update the changelog at https://wiki.qemu.org/ChangeLog/7.2 for any user-visible changes.
Quoted 19 lines · Christian Schoenebeck
The following changes since commit
0529245488865038344d64fff7ee05864d3d17f6:Merge tag 'pull-target-arm-20221020' of https://git.linaro.org/people/pmaydell/qemu-arm into staging (2022-10-20 14:36:12 -0400)are available in the Git repository at:
https://github.com/cschoenebeck/qemu.git tags/pull-9p-20221024for you to fetch changes up to
3ce77865bf813f313cf79c00fd951bfc95a50165:tests/9p: remove unnecessary g_strdup() calls (2022-10-24 12:24:32 +0200)----------------------------------------------------------------
9pfs: performance, Windows host prep, tests restructure* Highlight of this PR is Linus Heckemann's GHashTable patch which brings massive general performance improvements of 9p server somewhere between factor 6 .. 12.
Quoted 6 lines
* Bin Meng's
g_mkdirpatch is a preparatory patch for upcoming Windows host support of 9p server.* The rest of the patches in this PR are 9p test code restructuring and refactoring changes to improve readability and to ease maintenance of 9p test code on the long-term.
Hi Christian,
I think this PR broke the FreeBSD CI jobs:
https://gitlab.com/qemu-project/qemu/-/jobs/3219611457#L3116
https://gitlab.com/qemu-project/qemu/-/jobs/3219611460#L3372
Could you please have a look?
Thanks!
Thomas
Quoted 31 lines · CEST Thomas Huth
Quoted 19 lines · Christian Schoenebeck
The following changes since commit
0529245488865038344d64fff7ee05864d3d17f6:Merge tag 'pull-target-arm-20221020' of https://git.linaro.org/people/pmaydell/qemu-arm into staging (2022-10-20 14:36:12 -0400)are available in the Git repository at:
https://github.com/cschoenebeck/qemu.git tags/pull-9p-20221024for you to fetch changes up to
3ce77865bf813f313cf79c00fd951bfc95a50165:tests/9p: remove unnecessary g_strdup() calls (2022-10-24 12:24:32 +0200)----------------------------------------------------------------
9pfs: performance, Windows host prep, tests restructure* Highlight of this PR is Linus Heckemann's GHashTable patch which brings massive general performance improvements of 9p server somewhere between factor 6 .. 12.
Quoted 6 lines
* Bin Meng's
g_mkdirpatch is a preparatory patch for upcoming Windows host support of 9p server.* The rest of the patches in this PR are 9p test code restructuring and refactoring changes to improve readability and to ease maintenance of 9p test code on the long-term.
Hi Christian,
I think this PR broke the FreeBSD CI jobs:
Quoted 8 lines
https://gitlab.com/qemu-project/qemu/-/jobs/3219611457#L3116
https://gitlab.com/qemu-project/qemu/-/jobs/3219611460#L3372
Could you please have a look?
Thanks!
Thomas
I try, but will certainly take some days, especially as I currently don't have a BSD installation at hand to try the changes.
Right now I don't see something obvious. I would expect statfs being defined in <sys/types.h> on BSD which is already included via "qemu/osdep.h" from virtio-9p-client.c.
Best regards,
Christian Schoenebeck
Quoted 37 lines · Christian Schoenebeck
Quoted 35 lines · CEST Thomas Huth
Quoted 19 lines · Christian Schoenebeck
The following changes since commit
0529245488865038344d64fff7ee05864d3d17f6:Merge tag 'pull-target-arm-20221020' of https://git.linaro.org/people/pmaydell/qemu-arm into staging (2022-10-20 14:36:12 -0400)are available in the Git repository at:
https://github.com/cschoenebeck/qemu.git tags/pull-9p-20221024for you to fetch changes up to
3ce77865bf813f313cf79c00fd951bfc95a50165:tests/9p: remove unnecessary g_strdup() calls (2022-10-24 12:24:32 +0200)----------------------------------------------------------------
9pfs: performance, Windows host prep, tests restructure* Highlight of this PR is Linus Heckemann's GHashTable patch which brings massive general performance improvements of 9p server somewhere between factor 6 .. 12.
Quoted 6 lines
* Bin Meng's
g_mkdirpatch is a preparatory patch for upcoming Windows host support of 9p server.* The rest of the patches in this PR are 9p test code restructuring and refactoring changes to improve readability and to ease maintenance of 9p test code on the long-term.
Hi Christian,
I think this PR broke the FreeBSD CI jobs:
https://gitlab.com/qemu-project/qemu/-/jobs/3219611457#L3116
https://gitlab.com/qemu-project/qemu/-/jobs/3219611460#L3372
Quoted 7 lines
Quoted 4 lines
Could you please have a look?
Thanks!
ThomasI try, but will certainly take some days, especially as I currently don't have a BSD installation at hand to try the changes.
QEMU has the automation to run FreeBSD builds locally (in a VM):
$ make vm-build-freebsd
Not sure if that FreeBSD environment matches the one in Cirrus CI though. If they are different then maybe it won't reproduce locally.
Stefan
Quoted 44 lines · CEST Stefan Hajnoczi
Quoted 42 lines · Christian Schoenebeck
Quoted 39 lines · CEST Thomas Huth
Quoted 19 lines · Christian Schoenebeck
The following changes since commit
0529245488865038344d64fff7ee05864d3d17f6:Merge tag 'pull-target-arm-20221020' of https://git.linaro.org/people/pmaydell/qemu-arm into staging (2022-10-20 14:36:12 -0400)are available in the Git repository at:
https://github.com/cschoenebeck/qemu.git tags/pull-9p-20221024for you to fetch changes up to
3ce77865bf813f313cf79c00fd951bfc95a50165:tests/9p: remove unnecessary g_strdup() calls (2022-10-24 12:24:32 +0200)----------------------------------------------------------------
9pfs: performance, Windows host prep, tests restructure* Highlight of this PR is Linus Heckemann's GHashTable patch which brings massive general performance improvements of 9p server somewhere between factor 6 .. 12.
Quoted 6 lines
* Bin Meng's
g_mkdirpatch is a preparatory patch for upcoming Windows host support of 9p server.* The rest of the patches in this PR are 9p test code restructuring and refactoring changes to improve readability and to ease maintenance of 9p test code on the long-term.
Hi Christian,
I think this PR broke the FreeBSD CI jobs:
https://gitlab.com/qemu-project/qemu/-/jobs/3219611457#L3116
https://gitlab.com/qemu-project/qemu/-/jobs/3219611460#L3372
Could you please have a look?
Thanks!
Thomas
Quoted 8 lines
Quoted 2 lines
I try, but will certainly take some days, especially as I currently don't have a BSD installation at hand to try the changes.
QEMU has the automation to run FreeBSD builds locally (in a VM):
$ make vm-build-freebsdNot sure if that FreeBSD environment matches the one in Cirrus CI though. If they are different then maybe it won't reproduce locally.
Something must be different, because e750a7ace492f0b450653d4ad368a77d6f660fb8 compiles fine locally with make vm-build-freebsd and all tests pass, too.
Ideas?
Best regards,
Christian Schoenebeck
Quoted 57 lines · Christian Schoenebeck
Quoted 6 lines · CEST Stefan Hajnoczi
Quoted 4 lines · Christian Schoenebeck
Quoted 2 lines · CEST Thomas Huth
Quoted 1 line · Christian Schoenebeck
The following changes since commit
0529245488865038344d64fff7ee05864d3d17f6:Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Merge tag 'pull-target-arm-20221020' ofhttps://git.linaro.org/people/pmaydell/qemu-arm into staging (2022-10-20 14:36:12 -0400)
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
are available in the Git repository at:
https://github.com/cschoenebeck/qemu.git tags/pull-9p-20221024for you to fetch changes up to
3ce77865bf813f313cf79c00fd951bfc95a50165:Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
tests/9p: remove unnecessary g_strdup() calls (2022-10-2412:24:32 +0200)
Quoted 21 lines
Quoted 21 lines
Quoted 21 lines
Quoted 8 lines
----------------------------------------------------------------
9pfs: performance, Windows host prep, tests restructure* Highlight of this PR is Linus Heckemann's GHashTable patch which brings massive general performance improvements of 9p server somewhere between factor 6 .. 12.
Quoted 6 lines
* Bin Meng's
g_mkdirpatch is a preparatory patch for upcoming Windows host support of 9p server.* The rest of the patches in this PR are 9p test code restructuring and refactoring changes to improve readability and to ease maintenance of 9p test code on the long-term.
Hi Christian,
I think this PR broke the FreeBSD CI jobs:
https://gitlab.com/qemu-project/qemu/-/jobs/3219611457#L3116
Quoted 8 lines
Quoted 8 lines
Quoted 6 lines
https://gitlab.com/qemu-project/qemu/-/jobs/3219611460#L3372
Could you please have a look?
Thanks!
ThomasI try, but will certainly take some days, especially as I currently
don't have
Quoted 5 lines
Quoted 1 line
a BSD installation at hand to try the changes.
QEMU has the automation to run FreeBSD builds locally (in a VM):
$ make vm-build-freebsd
Quoted 7 lines
Quoted 2 lines
Not sure if that FreeBSD environment matches the one in Cirrus CI though. If they are different then maybe it won't reproduce locally.
Something must be different, because
e750a7ace492f0b450653d4ad368a77d6f660fb8
compiles fine locally withmake vm-build-freebsdand all tests pass, too.
I have a pull request I'm sending tomorrow that fixes a build issue on FreeBSD for about 6 or so months on FreeBSD current. If it's hitting that... but I didn't think our normal CI hit that... I'd submit it today, but I'm traveling and there is an issue getting to my machines at home, but I'll be home tomorrow.
Warner
Ideas?
Quoted 7 lines
Best regards,
Christian Schoenebeck
Quoted 51 lines · Christian Schoenebeck
Quoted 50 lines · CEST Stefan Hajnoczi
Quoted 37 lines · Christian Schoenebeck
Quoted 35 lines · CEST Thomas Huth
Quoted 19 lines · Christian Schoenebeck
The following changes since commit
0529245488865038344d64fff7ee05864d3d17f6:Merge tag 'pull-target-arm-20221020' of https://git.linaro.org/people/pmaydell/qemu-arm into staging (2022-10-20 14:36:12 -0400)are available in the Git repository at:
https://github.com/cschoenebeck/qemu.git tags/pull-9p-20221024for you to fetch changes up to
3ce77865bf813f313cf79c00fd951bfc95a50165:tests/9p: remove unnecessary g_strdup() calls (2022-10-24 12:24:32 +0200)----------------------------------------------------------------
9pfs: performance, Windows host prep, tests restructure* Highlight of this PR is Linus Heckemann's GHashTable patch which brings massive general performance improvements of 9p server somewhere between factor 6 .. 12.
Quoted 6 lines
* Bin Meng's
g_mkdirpatch is a preparatory patch for upcoming Windows host support of 9p server.* The rest of the patches in this PR are 9p test code restructuring and refactoring changes to improve readability and to ease maintenance of 9p test code on the long-term.
Hi Christian,
I think this PR broke the FreeBSD CI jobs:
https://gitlab.com/qemu-project/qemu/-/jobs/3219611457#L3116 https://gitlab.com/qemu-project/qemu/-/jobs/3219611460#L3372Quoted 7 lines
Quoted 4 lines
Could you please have a look?
Thanks!
ThomasI try, but will certainly take some days, especially as I currently don't have a BSD installation at hand to try the changes.
QEMU has the automation to run FreeBSD builds locally (in a VM):
$ make vm-build-freebsd
Quoted 7 lines
Quoted 2 lines
Not sure if that FreeBSD environment matches the one in Cirrus CI though. If they are different then maybe it won't reproduce locally.
Something must be different, because
e750a7ace492f0b450653d4ad368a77d6f660fb8compiles fine locally withmake vm-build-freebsdand all tests pass, too.Ideas?
You've got to --enable-werror to make it fail, try something like this:
make vm-build-freebsd J=8 TARGET_LIST=x86_64-softmmu \
BUILD_TARGET=check-build DEBUG=1 \
EXTRA_CONFIGURE_OPTS="--enable-werror" HTH,
Thomas
Quoted 58 lines · CEST Thomas Huth
Quoted 57 lines · Christian Schoenebeck
Quoted 44 lines · CEST Stefan Hajnoczi
Quoted 42 lines · Christian Schoenebeck
Quoted 39 lines · CEST Thomas Huth
Quoted 19 lines · Christian Schoenebeck
The following changes since commit
0529245488865038344d64fff7ee05864d3d17f6:Merge tag 'pull-target-arm-20221020' of https://git.linaro.org/people/pmaydell/qemu-arm into staging (2022-10-20 14:36:12 -0400)are available in the Git repository at:
https://github.com/cschoenebeck/qemu.git tags/pull-9p-20221024for you to fetch changes up to
3ce77865bf813f313cf79c00fd951bfc95a50165:tests/9p: remove unnecessary g_strdup() calls (2022-10-24 12:24:32 +0200)----------------------------------------------------------------
9pfs: performance, Windows host prep, tests restructure* Highlight of this PR is Linus Heckemann's GHashTable patch which brings massive general performance improvements of 9p server somewhere between factor 6 .. 12.
Quoted 6 lines
* Bin Meng's
g_mkdirpatch is a preparatory patch for upcoming Windows host support of 9p server.* The rest of the patches in this PR are 9p test code restructuring and refactoring changes to improve readability and to ease maintenance of 9p test code on the long-term.
Hi Christian,
I think this PR broke the FreeBSD CI jobs:
https://gitlab.com/qemu-project/qemu/-/jobs/3219611457#L3116 https://gitlab.com/qemu-project/qemu/-/jobs/3219611460#L3372Could you please have a look?
Thanks!
ThomasQuoted 8 lines
Quoted 2 lines
I try, but will certainly take some days, especially as I currently don't have a BSD installation at hand to try the changes.
QEMU has the automation to run FreeBSD builds locally (in a VM):
$ make vm-build-freebsdNot sure if that FreeBSD environment matches the one in Cirrus CI though. If they are different then maybe it won't reproduce locally.
Something must be different, because
e750a7ace492f0b450653d4ad368a77d6f660fb8compiles fine locally withmake vm-build-freebsdand all tests pass, too.
Quoted 7 lines
Quoted 1 line
Ideas?
You've got to --enable-werror to make it fail, try something like this:
make vm-build-freebsd J=8 TARGET_LIST=x86_64-softmmu \ BUILD_TARGET=check-build DEBUG=1 \ EXTRA_CONFIGURE_OPTS="--enable-werror"
That was it, reproduced. Thanks Thomas!
statfs is defined in <sys/mount.h>. I prepare a patch.
Best regards,
Christian Schoenebeck