[mirror_qemu.git] / hw / 9pfs / 9p.h

#ifndef QEMU_9P_H
#define QEMU_9P_H

#include <dirent.h>
#include <utime.h>
#include <sys/resource.h>
#include "fsdev/file-op-9p.h"
#include "fsdev/9p-iov-marshal.h"
#include "qemu/thread.h"
#include "qemu/coroutine.h"

enum {
    P9_TLERROR = 6,
    P9_RLERROR,
    P9_TSTATFS = 8,
    P9_RSTATFS,
    P9_TLOPEN = 12,
    P9_RLOPEN,
    P9_TLCREATE = 14,
    P9_RLCREATE,
    P9_TSYMLINK = 16,
    P9_RSYMLINK,
    P9_TMKNOD = 18,
    P9_RMKNOD,
    P9_TRENAME = 20,
    P9_RRENAME,
    P9_TREADLINK = 22,
    P9_RREADLINK,
    P9_TGETATTR = 24,
    P9_RGETATTR,
    P9_TSETATTR = 26,
    P9_RSETATTR,
    P9_TXATTRWALK = 30,
    P9_RXATTRWALK,
    P9_TXATTRCREATE = 32,
    P9_RXATTRCREATE,
    P9_TREADDIR = 40,
    P9_RREADDIR,
    P9_TFSYNC = 50,
    P9_RFSYNC,
    P9_TLOCK = 52,
    P9_RLOCK,
    P9_TGETLOCK = 54,
    P9_RGETLOCK,
    P9_TLINK = 70,
    P9_RLINK,
    P9_TMKDIR = 72,
    P9_RMKDIR,
    P9_TRENAMEAT = 74,
    P9_RRENAMEAT,
    P9_TUNLINKAT = 76,
    P9_RUNLINKAT,
    P9_TVERSION = 100,
    P9_RVERSION,
    P9_TAUTH = 102,
    P9_RAUTH,
    P9_TATTACH = 104,
    P9_RATTACH,
    P9_TERROR = 106,
    P9_RERROR,
    P9_TFLUSH = 108,
    P9_RFLUSH,
    P9_TWALK = 110,
    P9_RWALK,
    P9_TOPEN = 112,
    P9_ROPEN,
    P9_TCREATE = 114,
    P9_RCREATE,
    P9_TREAD = 116,
    P9_RREAD,
    P9_TWRITE = 118,
    P9_RWRITE,
    P9_TCLUNK = 120,
    P9_RCLUNK,
    P9_TREMOVE = 122,
    P9_RREMOVE,
    P9_TSTAT = 124,
    P9_RSTAT,
    P9_TWSTAT = 126,
    P9_RWSTAT,
};


/* qid.types */
enum {
    P9_QTDIR = 0x80,
    P9_QTAPPEND = 0x40,
    P9_QTEXCL = 0x20,
    P9_QTMOUNT = 0x10,
    P9_QTAUTH = 0x08,
    P9_QTTMP = 0x04,
    P9_QTSYMLINK = 0x02,
    P9_QTLINK = 0x01,
    P9_QTFILE = 0x00,
};

enum p9_proto_version {
    V9FS_PROTO_2000U = 0x01,
    V9FS_PROTO_2000L = 0x02,
};

#define P9_NOTAG    (u16)(~0)
#define P9_NOFID    (u32)(~0)
#define P9_MAXWELEM 16

#define FID_REFERENCED          0x1
#define FID_NON_RECLAIMABLE     0x2
static inline char *rpath(FsContext *ctx, const char *path)
{
    return g_strdup_printf("%s/%s", ctx->fs_root, path);
}

/*
 * ample room for Twrite/Rread header
 * size[4] Tread/Twrite tag[2] fid[4] offset[8] count[4]
 */
#define P9_IOHDRSZ 24

typedef struct V9fsPDU V9fsPDU;
struct V9fsState;

struct V9fsPDU
{
    uint32_t size;
    uint16_t tag;
    uint8_t id;
    uint8_t cancelled;
    CoQueue complete;
    struct V9fsState *s;
    QLIST_ENTRY(V9fsPDU) next;
    uint32_t idx;
};


/* FIXME
 * 1) change user needs to set groups and stuff
 */

#define MAX_REQ         128
#define MAX_TAG_LEN     32

#define BUG_ON(cond) assert(!(cond))

typedef struct V9fsFidState V9fsFidState;

enum {
    P9_FID_NONE = 0,
    P9_FID_FILE,
    P9_FID_DIR,
    P9_FID_XATTR,
};

typedef struct V9fsConf
{
    /* tag name for the device */
    char *tag;
    char *fsdev_id;
} V9fsConf;

typedef struct V9fsXattr
{
    uint64_t copied_len;
    uint64_t len;
    void *value;
    V9fsString name;
    int flags;
    bool xattrwalk_fid;
} V9fsXattr;

typedef struct V9fsDir {
    DIR *stream;
    QemuMutex readdir_mutex;
} V9fsDir;

static inline void v9fs_readdir_lock(V9fsDir *dir)
{
    qemu_mutex_lock(&dir->readdir_mutex);
}

static inline void v9fs_readdir_unlock(V9fsDir *dir)
{
    qemu_mutex_unlock(&dir->readdir_mutex);
}

static inline void v9fs_readdir_init(V9fsDir *dir)
{
    qemu_mutex_init(&dir->readdir_mutex);
}

/*
 * Filled by fs driver on open and other
 * calls.
 */
union V9fsFidOpenState {
    int fd;
    V9fsDir dir;
    V9fsXattr xattr;
    /*
     * private pointer for fs drivers, that
     * have its own internal representation of
     * open files.
     */
    void *private;
};

struct V9fsFidState
{
    int fid_type;
    int32_t fid;
    V9fsPath path;
    V9fsFidOpenState fs;
    V9fsFidOpenState fs_reclaim;
    int flags;
    int open_flags;
    uid_t uid;
    int ref;
    int clunked;
    V9fsFidState *next;
    V9fsFidState *rclm_lst;
};

typedef struct V9fsState
{
    QLIST_HEAD(, V9fsPDU) free_list;
    QLIST_HEAD(, V9fsPDU) active_list;
    V9fsFidState *fid_list;
    FileOperations *ops;
    FsContext ctx;
    char *tag;
    enum p9_proto_version proto_version;
    int32_t msize;
    V9fsPDU pdus[MAX_REQ];
    const struct V9fsTransport *transport;
    /*
     * lock ensuring atomic path update
     * on rename.
     */
    CoRwlock rename_lock;
    int32_t root_fid;
    Error *migration_blocker;
    V9fsConf fsconf;
    V9fsQID root_qid;
} V9fsState;

/* 9p2000.L open flags */
#define P9_DOTL_RDONLY        00000000
#define P9_DOTL_WRONLY        00000001
#define P9_DOTL_RDWR          00000002
#define P9_DOTL_NOACCESS      00000003
#define P9_DOTL_CREATE        00000100
#define P9_DOTL_EXCL          00000200
#define P9_DOTL_NOCTTY        00000400
#define P9_DOTL_TRUNC         00001000
#define P9_DOTL_APPEND        00002000
#define P9_DOTL_NONBLOCK      00004000
#define P9_DOTL_DSYNC         00010000
#define P9_DOTL_FASYNC        00020000
#define P9_DOTL_DIRECT        00040000
#define P9_DOTL_LARGEFILE     00100000
#define P9_DOTL_DIRECTORY     00200000
#define P9_DOTL_NOFOLLOW      00400000
#define P9_DOTL_NOATIME       01000000
#define P9_DOTL_CLOEXEC       02000000
#define P9_DOTL_SYNC          04000000

/* 9p2000.L at flags */
#define P9_DOTL_AT_REMOVEDIR         0x200

/* 9P2000.L lock type */
#define P9_LOCK_TYPE_RDLCK 0
#define P9_LOCK_TYPE_WRLCK 1
#define P9_LOCK_TYPE_UNLCK 2

#define P9_LOCK_SUCCESS 0
#define P9_LOCK_BLOCKED 1
#define P9_LOCK_ERROR 2
#define P9_LOCK_GRACE 3

#define P9_LOCK_FLAGS_BLOCK 1
#define P9_LOCK_FLAGS_RECLAIM 2

typedef struct V9fsFlock
{
    uint8_t type;
    uint32_t flags;
    uint64_t start; /* absolute offset */
    uint64_t length;
    uint32_t proc_id;
    V9fsString client_id;
} V9fsFlock;

typedef struct V9fsGetlock
{
    uint8_t type;
    uint64_t start; /* absolute offset */
    uint64_t length;
    uint32_t proc_id;
    V9fsString client_id;
} V9fsGetlock;

extern int open_fd_hw;
extern int total_open_fd;

static inline void v9fs_path_write_lock(V9fsState *s)
{
    if (s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT) {
        qemu_co_rwlock_wrlock(&s->rename_lock);
    }
}

static inline void v9fs_path_read_lock(V9fsState *s)
{
    if (s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT) {
        qemu_co_rwlock_rdlock(&s->rename_lock);
    }
}

static inline void v9fs_path_unlock(V9fsState *s)
{
    if (s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT) {
        qemu_co_rwlock_unlock(&s->rename_lock);
    }
}

static inline uint8_t v9fs_request_cancelled(V9fsPDU *pdu)
{
    return pdu->cancelled;
}

void coroutine_fn v9fs_reclaim_fd(V9fsPDU *pdu);
void v9fs_path_init(V9fsPath *path);
void v9fs_path_free(V9fsPath *path);
void v9fs_path_sprintf(V9fsPath *path, const char *fmt, ...);
void v9fs_path_copy(V9fsPath *lhs, V9fsPath *rhs);
int v9fs_name_to_path(V9fsState *s, V9fsPath *dirpath,
                      const char *name, V9fsPath *path);
int v9fs_device_realize_common(V9fsState *s, Error **errp);
void v9fs_device_unrealize_common(V9fsState *s, Error **errp);

ssize_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...);
ssize_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...);
V9fsPDU *pdu_alloc(V9fsState *s);
void pdu_free(V9fsPDU *pdu);
void pdu_submit(V9fsPDU *pdu);
void v9fs_reset(V9fsState *s);

struct V9fsTransport {
    ssize_t     (*pdu_vmarshal)(V9fsPDU *pdu, size_t offset, const char *fmt,
                                va_list ap);
    ssize_t     (*pdu_vunmarshal)(V9fsPDU *pdu, size_t offset, const char *fmt,
                                  va_list ap);
    void        (*init_in_iov_from_pdu)(V9fsPDU *pdu, struct iovec **piov,
                                        unsigned int *pniov, size_t size);
    void        (*init_out_iov_from_pdu)(V9fsPDU *pdu, struct iovec **piov,
                                         unsigned int *pniov);
    void        (*push_and_notify)(V9fsPDU *pdu);
};

static inline int v9fs_register_transport(V9fsState *s,
        const struct V9fsTransport *t)
{
    assert(!s->transport);
    s->transport = t;
    return 0;
}

#endif
Commit	Line	Data
2a6a4076 MA	1	#ifndef QEMU_9P_H
2a6a4076 MA	2	#define QEMU_9P_H
ebe74f8b	3
ebe74f8b	4	#include <dirent.h>
ebe74f8b WL	5	#include <utime.h>
ebe74f8b WL	6	#include <sys/resource.h>
ebe74f8b WL	7	#include "fsdev/file-op-9p.h"
	8	#include "fsdev/9p-iov-marshal.h"
	9	#include "qemu/thread.h"
	10	#include "qemu/coroutine.h"
	11
	12	enum {
	13	P9_TLERROR = 6,
	14	P9_RLERROR,
	15	P9_TSTATFS = 8,
	16	P9_RSTATFS,
	17	P9_TLOPEN = 12,
	18	P9_RLOPEN,
	19	P9_TLCREATE = 14,
	20	P9_RLCREATE,
	21	P9_TSYMLINK = 16,
	22	P9_RSYMLINK,
	23	P9_TMKNOD = 18,
	24	P9_RMKNOD,
	25	P9_TRENAME = 20,
	26	P9_RRENAME,
	27	P9_TREADLINK = 22,
	28	P9_RREADLINK,
	29	P9_TGETATTR = 24,
	30	P9_RGETATTR,
	31	P9_TSETATTR = 26,
	32	P9_RSETATTR,
	33	P9_TXATTRWALK = 30,
	34	P9_RXATTRWALK,
	35	P9_TXATTRCREATE = 32,
	36	P9_RXATTRCREATE,
	37	P9_TREADDIR = 40,
	38	P9_RREADDIR,
	39	P9_TFSYNC = 50,
	40	P9_RFSYNC,
	41	P9_TLOCK = 52,
	42	P9_RLOCK,
	43	P9_TGETLOCK = 54,
	44	P9_RGETLOCK,
	45	P9_TLINK = 70,
	46	P9_RLINK,
	47	P9_TMKDIR = 72,
	48	P9_RMKDIR,
	49	P9_TRENAMEAT = 74,
	50	P9_RRENAMEAT,
	51	P9_TUNLINKAT = 76,
	52	P9_RUNLINKAT,
	53	P9_TVERSION = 100,
	54	P9_RVERSION,
	55	P9_TAUTH = 102,
	56	P9_RAUTH,
	57	P9_TATTACH = 104,
	58	P9_RATTACH,
	59	P9_TERROR = 106,
	60	P9_RERROR,
	61	P9_TFLUSH = 108,
	62	P9_RFLUSH,
	63	P9_TWALK = 110,
	64	P9_RWALK,
	65	P9_TOPEN = 112,
	66	P9_ROPEN,
	67	P9_TCREATE = 114,
	68	P9_RCREATE,
	69	P9_TREAD = 116,
	70	P9_RREAD,
71	P9_TWRITE = 118,
72	P9_RWRITE,
73	P9_TCLUNK = 120,
74	P9_RCLUNK,
75	P9_TREMOVE = 122,
76	P9_RREMOVE,
77	P9_TSTAT = 124,
78	P9_RSTAT,
79	P9_TWSTAT = 126,
80	P9_RWSTAT,
81	};
82
83
84	/* qid.types */
85	enum {
86	P9_QTDIR = 0x80,
87	P9_QTAPPEND = 0x40,
88	P9_QTEXCL = 0x20,
89	P9_QTMOUNT = 0x10,
90	P9_QTAUTH = 0x08,
91	P9_QTTMP = 0x04,
92	P9_QTSYMLINK = 0x02,
93	P9_QTLINK = 0x01,
94	P9_QTFILE = 0x00,
95	};
96
97	enum p9_proto_version {
98	V9FS_PROTO_2000U = 0x01,
99	V9FS_PROTO_2000L = 0x02,
100	};
101
102	#define P9_NOTAG (u16)(~0)
103	#define P9_NOFID (u32)(~0)
104	#define P9_MAXWELEM 16
105
106	#define FID_REFERENCED 0x1
107	#define FID_NON_RECLAIMABLE 0x2
108	static inline char rpath(FsContext ctx, const char *path)
109	{
110	return g_strdup_printf("%s/%s", ctx->fs_root, path);
111	}
112
113	/*
114	* ample room for Twrite/Rread header
115	* size[4] Tread/Twrite tag[2] fid[4] offset[8] count[4]
116	*/
117	#define P9_IOHDRSZ 24
118
119	typedef struct V9fsPDU V9fsPDU;
120	struct V9fsState;
121
122	struct V9fsPDU
123	{
124	uint32_t size;
125	uint16_t tag;
126	uint8_t id;
127	uint8_t cancelled;
128	CoQueue complete;
ebe74f8b WL	129	struct V9fsState *s;
ebe74f8b WL	130	QLIST_ENTRY(V9fsPDU) next;
00588a0a	131	uint32_t idx;
ebe74f8b WL	132	};
	133
	134
	135	/* FIXME
	136	* 1) change user needs to set groups and stuff
	137	*/
	138
	139	#define MAX_REQ 128
	140	#define MAX_TAG_LEN 32
	141
	142	#define BUG_ON(cond) assert(!(cond))
	143
	144	typedef struct V9fsFidState V9fsFidState;
	145
	146	enum {
	147	P9_FID_NONE = 0,
	148	P9_FID_FILE,
	149	P9_FID_DIR,
	150	P9_FID_XATTR,
	151	};
	152
	153	typedef struct V9fsConf
	154	{
	155	/* tag name for the device */
	156	char *tag;
	157	char *fsdev_id;
	158	} V9fsConf;
	159
	160	typedef struct V9fsXattr
	161	{
8495f9ad LQ	162	uint64_t copied_len;
8495f9ad LQ	163	uint64_t len;
ebe74f8b WL	164	void *value;
	165	V9fsString name;
	166	int flags;
dd28fbbc	167	bool xattrwalk_fid;
ebe74f8b WL	168	} V9fsXattr;
ebe74f8b WL	169
f314ea4e GK	170	typedef struct V9fsDir {
f314ea4e GK	171	DIR *stream;
7cde47d4	172	QemuMutex readdir_mutex;
f314ea4e GK	173	} V9fsDir;
f314ea4e GK	174
7cde47d4 GK	175	static inline void v9fs_readdir_lock(V9fsDir *dir)
	176	{
	177	qemu_mutex_lock(&dir->readdir_mutex);
	178	}
	179
	180	static inline void v9fs_readdir_unlock(V9fsDir *dir)
	181	{
	182	qemu_mutex_unlock(&dir->readdir_mutex);
	183	}
	184
	185	static inline void v9fs_readdir_init(V9fsDir *dir)
	186	{
	187	qemu_mutex_init(&dir->readdir_mutex);
	188	}
	189
ebe74f8b WL	190	/*
	191	* Filled by fs driver on open and other
	192	* calls.
	193	*/
	194	union V9fsFidOpenState {
	195	int fd;
f314ea4e	196	V9fsDir dir;
ebe74f8b WL	197	V9fsXattr xattr;
	198	/*
	199	* private pointer for fs drivers, that
	200	* have its own internal representation of
	201	* open files.
	202	*/
	203	void *private;
	204	};
	205
	206	struct V9fsFidState
	207	{
	208	int fid_type;
	209	int32_t fid;
	210	V9fsPath path;
	211	V9fsFidOpenState fs;
	212	V9fsFidOpenState fs_reclaim;
	213	int flags;
	214	int open_flags;
	215	uid_t uid;
	216	int ref;
	217	int clunked;
	218	V9fsFidState *next;
	219	V9fsFidState *rclm_lst;
	220	};
	221
	222	typedef struct V9fsState
	223	{
ebe74f8b WL	224	QLIST_HEAD(, V9fsPDU) free_list;
	225	QLIST_HEAD(, V9fsPDU) active_list;
	226	V9fsFidState *fid_list;
	227	FileOperations *ops;
	228	FsContext ctx;
	229	char *tag;
ebe74f8b WL	230	enum p9_proto_version proto_version;
ebe74f8b WL	231	int32_t msize;
583f21f8	232	V9fsPDU pdus[MAX_REQ];
ea83441c	233	const struct V9fsTransport *transport;
ebe74f8b WL	234	/*
	235	* lock ensuring atomic path update
	236	* on rename.
	237	*/
	238	CoRwlock rename_lock;
	239	int32_t root_fid;
	240	Error *migration_blocker;
	241	V9fsConf fsconf;
56f101ec	242	V9fsQID root_qid;
ebe74f8b WL	243	} V9fsState;
	244
	245	/* 9p2000.L open flags */
	246	#define P9_DOTL_RDONLY 00000000
	247	#define P9_DOTL_WRONLY 00000001
	248	#define P9_DOTL_RDWR 00000002
	249	#define P9_DOTL_NOACCESS 00000003
	250	#define P9_DOTL_CREATE 00000100
	251	#define P9_DOTL_EXCL 00000200
	252	#define P9_DOTL_NOCTTY 00000400
	253	#define P9_DOTL_TRUNC 00001000
	254	#define P9_DOTL_APPEND 00002000
	255	#define P9_DOTL_NONBLOCK 00004000
	256	#define P9_DOTL_DSYNC 00010000
	257	#define P9_DOTL_FASYNC 00020000
	258	#define P9_DOTL_DIRECT 00040000
	259	#define P9_DOTL_LARGEFILE 00100000
	260	#define P9_DOTL_DIRECTORY 00200000
	261	#define P9_DOTL_NOFOLLOW 00400000
	262	#define P9_DOTL_NOATIME 01000000
	263	#define P9_DOTL_CLOEXEC 02000000
	264	#define P9_DOTL_SYNC 04000000
	265
	266	/* 9p2000.L at flags */
	267	#define P9_DOTL_AT_REMOVEDIR 0x200
	268
	269	/* 9P2000.L lock type */
	270	#define P9_LOCK_TYPE_RDLCK 0
	271	#define P9_LOCK_TYPE_WRLCK 1
	272	#define P9_LOCK_TYPE_UNLCK 2
	273
	274	#define P9_LOCK_SUCCESS 0
	275	#define P9_LOCK_BLOCKED 1
	276	#define P9_LOCK_ERROR 2
	277	#define P9_LOCK_GRACE 3
	278
	279	#define P9_LOCK_FLAGS_BLOCK 1
	280	#define P9_LOCK_FLAGS_RECLAIM 2
	281
	282	typedef struct V9fsFlock
	283	{
	284	uint8_t type;
	285	uint32_t flags;
	286	uint64_t start; /* absolute offset */
	287	uint64_t length;
	288	uint32_t proc_id;
	289	V9fsString client_id;
	290	} V9fsFlock;
	291
	292	typedef struct V9fsGetlock
	293	{
	294	uint8_t type;
	295	uint64_t start; /* absolute offset */
	296	uint64_t length;
	297	uint32_t proc_id;
	298	V9fsString client_id;
	299	} V9fsGetlock;
	300
	301	extern int open_fd_hw;
	302	extern int total_open_fd;
	303
	304	static inline void v9fs_path_write_lock(V9fsState *s)
	305	{
	306	if (s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT) {
307	qemu_co_rwlock_wrlock(&s->rename_lock);
308	}
309	}
310
311	static inline void v9fs_path_read_lock(V9fsState *s)
312	{
313	if (s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT) {
314	qemu_co_rwlock_rdlock(&s->rename_lock);
315	}
316	}
317
318	static inline void v9fs_path_unlock(V9fsState *s)
319	{
320	if (s->ctx.export_flags & V9FS_PATHNAME_FSCONTEXT) {
321	qemu_co_rwlock_unlock(&s->rename_lock);
322	}
323	}
324
325	static inline uint8_t v9fs_request_cancelled(V9fsPDU *pdu)
326	{
327	return pdu->cancelled;
328	}
329
8440e22e	330	void coroutine_fn v9fs_reclaim_fd(V9fsPDU *pdu);
bc70a592 GK	331	void v9fs_path_init(V9fsPath *path);
	332	void v9fs_path_free(V9fsPath *path);
	333	void v9fs_path_sprintf(V9fsPath path, const char fmt, ...);
	334	void v9fs_path_copy(V9fsPath lhs, V9fsPath rhs);
	335	int v9fs_name_to_path(V9fsState s, V9fsPath dirpath,
	336	const char name, V9fsPath path);
	337	int v9fs_device_realize_common(V9fsState s, Error *errp);
	338	void v9fs_device_unrealize_common(V9fsState s, Error *errp);
ebe74f8b WL	339
	340	ssize_t pdu_marshal(V9fsPDU pdu, size_t offset, const char fmt, ...);
	341	ssize_t pdu_unmarshal(V9fsPDU pdu, size_t offset, const char fmt, ...);
4b311c5f WL	342	V9fsPDU pdu_alloc(V9fsState s);
	343	void pdu_free(V9fsPDU *pdu);
	344	void pdu_submit(V9fsPDU *pdu);
0e44a0fd	345	void v9fs_reset(V9fsState *s);
ebe74f8b	346
ea83441c SS	347	struct V9fsTransport {
	348	ssize_t (pdu_vmarshal)(V9fsPDU pdu, size_t offset, const char *fmt,
	349	va_list ap);
	350	ssize_t (pdu_vunmarshal)(V9fsPDU pdu, size_t offset, const char *fmt,
	351	va_list ap);
88da0b03 SS	352	void (init_in_iov_from_pdu)(V9fsPDU pdu, struct iovec **piov,
	353	unsigned int *pniov, size_t size);
	354	void (init_out_iov_from_pdu)(V9fsPDU pdu, struct iovec **piov,
	355	unsigned int *pniov);
ea83441c SS	356	void (push_and_notify)(V9fsPDU pdu);
	357	};
	358
	359	static inline int v9fs_register_transport(V9fsState *s,
	360	const struct V9fsTransport *t)
	361	{
	362	assert(!s->transport);
	363	s->transport = t;
	364	return 0;
	365	}
	366
ebe74f8b	367	#endif