return s->ops->closedir(&s->ctx, dir);
}
+static int v9fs_do_open(V9fsState *s, V9fsString *path, int flags)
+{
+ return s->ops->open(&s->ctx, path->data, flags);
+}
+
+static DIR *v9fs_do_opendir(V9fsState *s, V9fsString *path)
+{
+ return s->ops->opendir(&s->ctx, path->data);
+}
+
+static void v9fs_do_rewinddir(V9fsState *s, DIR *dir)
+{
+ return s->ops->rewinddir(&s->ctx, dir);
+}
+
+static off_t v9fs_do_telldir(V9fsState *s, DIR *dir)
+{
+ return s->ops->telldir(&s->ctx, dir);
+}
+
+static struct dirent *v9fs_do_readdir(V9fsState *s, DIR *dir)
+{
+ return s->ops->readdir(&s->ctx, dir);
+}
+
+static void v9fs_do_seekdir(V9fsState *s, DIR *dir, off_t off)
+{
+ return s->ops->seekdir(&s->ctx, dir, off);
+}
+
+static int v9fs_do_readv(V9fsState *s, int fd, const struct iovec *iov,
+ int iovcnt)
+{
+ return s->ops->readv(&s->ctx, fd, iov, iovcnt);
+}
+
+static off_t v9fs_do_lseek(V9fsState *s, int fd, off_t offset, int whence)
+{
+ return s->ops->lseek(&s->ctx, fd, offset, whence);
+}
+
+static int v9fs_do_writev(V9fsState *s, int fd, const struct iovec *iov,
+ int iovcnt)
+{
+ return s->ops->writev(&s->ctx, fd, iov, iovcnt);
+}
+
+static int v9fs_do_chmod(V9fsState *s, V9fsString *path, mode_t mode)
+{
+ return s->ops->chmod(&s->ctx, path->data, mode);
+}
+
+static int v9fs_do_mknod(V9fsState *s, V9fsString *path, mode_t mode, dev_t dev)
+{
+ return s->ops->mknod(&s->ctx, path->data, mode, dev);
+}
+
+static int v9fs_do_mksock(V9fsState *s, V9fsString *path)
+{
+ return s->ops->mksock(&s->ctx, path->data);
+}
+
+static int v9fs_do_mkdir(V9fsState *s, V9fsString *path, mode_t mode)
+{
+ return s->ops->mkdir(&s->ctx, path->data, mode);
+}
+
+static int v9fs_do_fstat(V9fsState *s, int fd, struct stat *stbuf)
+{
+ return s->ops->fstat(&s->ctx, fd, stbuf);
+}
+
+static int v9fs_do_open2(V9fsState *s, V9fsString *path, int flags, mode_t mode)
+{
+ return s->ops->open2(&s->ctx, path->data, flags, mode);
+}
+
+static int v9fs_do_symlink(V9fsState *s, V9fsString *oldpath,
+ V9fsString *newpath)
+{
+ return s->ops->symlink(&s->ctx, oldpath->data, newpath->data);
+}
+
+static int v9fs_do_link(V9fsState *s, V9fsString *oldpath, V9fsString *newpath)
+{
+ return s->ops->link(&s->ctx, oldpath->data, newpath->data);
+}
+
+static int v9fs_do_truncate(V9fsState *s, V9fsString *path, off_t size)
+{
+ return s->ops->truncate(&s->ctx, path->data, size);
+}
+
+static int v9fs_do_rename(V9fsState *s, V9fsString *oldpath,
+ V9fsString *newpath)
+{
+ return s->ops->rename(&s->ctx, oldpath->data, newpath->data);
+}
+
+static int v9fs_do_chown(V9fsState *s, V9fsString *path, uid_t uid, gid_t gid)
+{
+ return s->ops->chown(&s->ctx, path->data, uid, gid);
+}
+
+static int v9fs_do_utime(V9fsState *s, V9fsString *path,
+ const struct utimbuf *buf)
+{
+ return s->ops->utime(&s->ctx, path->data, buf);
+}
+
+static int v9fs_do_remove(V9fsState *s, V9fsString *path)
+{
+ return s->ops->remove(&s->ctx, path->data);
+}
+
+static int v9fs_do_fsync(V9fsState *s, int fd)
+{
+ return s->ops->fsync(&s->ctx, fd);
+}
+
static void v9fs_string_init(V9fsString *str)
{
str->data = NULL;
printf("}\n");
}
-static void v9fs_dummy(V9fsState *s, V9fsPDU *pdu)
-{
- /* Note: The following have been added to prevent GCC from complaining
- * They will be removed in the subsequent patches */
- (void)pdu_unmarshal;
- (void) complete_pdu;
- (void) v9fs_string_init;
- (void) v9fs_string_free;
- (void) v9fs_string_null;
- (void) v9fs_string_sprintf;
- (void) v9fs_string_copy;
- (void) v9fs_string_size;
- (void) v9fs_do_lstat;
- (void) v9fs_do_setuid;
- (void) v9fs_do_readlink;
- (void) v9fs_do_close;
- (void) v9fs_do_closedir;
- (void) alloc_fid;
- (void) free_fid;
- (void) fid_to_qid;
- (void) v9mode_to_mode;
- (void) donttouch_stat;
- (void) v9fs_stat_free;
- (void) stat_to_v9stat;
- (void) adjust_sg;
- (void) cap_sg;
- (void) print_sg;
+static void v9fs_fix_path(V9fsString *dst, V9fsString *src, int len)
+{
+ V9fsString str;
+ v9fs_string_init(&str);
+ v9fs_string_copy(&str, dst);
+ v9fs_string_sprintf(dst, "%s%s", src->data, str.data+len);
+ v9fs_string_free(&str);
}
static void v9fs_version(V9fsState *s, V9fsPDU *pdu)
static void v9fs_attach(V9fsState *s, V9fsPDU *pdu)
{
- if (debug_9p_pdu) {
- pprint_pdu(pdu);
+ int32_t fid, afid, n_uname;
+ V9fsString uname, aname;
+ V9fsFidState *fidp;
+ V9fsQID qid;
+ size_t offset = 7;
+ ssize_t err;
+
+ pdu_unmarshal(pdu, offset, "ddssd", &fid, &afid, &uname, &aname, &n_uname);
+
+ fidp = alloc_fid(s, fid);
+ if (fidp == NULL) {
+ err = -EINVAL;
+ goto out;
+ }
+
+ fidp->uid = n_uname;
+
+ v9fs_string_sprintf(&fidp->path, "%s", "/");
+ err = fid_to_qid(s, fidp, &qid);
+ if (err) {
+ err = -EINVAL;
+ free_fid(s, fid);
+ goto out;
+ }
+
+ offset += pdu_marshal(pdu, offset, "Q", &qid);
+
+ err = offset;
+out:
+ complete_pdu(s, pdu, err);
+ v9fs_string_free(&uname);
+ v9fs_string_free(&aname);
+}
+
+typedef struct V9fsStatState {
+ V9fsPDU *pdu;
+ size_t offset;
+ V9fsStat v9stat;
+ V9fsFidState *fidp;
+ struct stat stbuf;
+} V9fsStatState;
+
+static void v9fs_stat_post_lstat(V9fsState *s, V9fsStatState *vs, int err)
+{
+ if (err == -1) {
+ err = -errno;
+ goto out;
+ }
+
+ err = stat_to_v9stat(s, &vs->fidp->path, &vs->stbuf, &vs->v9stat);
+ if (err) {
+ goto out;
}
+ vs->offset += pdu_marshal(vs->pdu, vs->offset, "wS", 0, &vs->v9stat);
+ err = vs->offset;
+
+out:
+ complete_pdu(s, vs->pdu, err);
+ v9fs_stat_free(&vs->v9stat);
+ qemu_free(vs);
}
static void v9fs_stat(V9fsState *s, V9fsPDU *pdu)
{
- if (debug_9p_pdu) {
- pprint_pdu(pdu);
+ int32_t fid;
+ V9fsStatState *vs;
+ ssize_t err = 0;
+
+ vs = qemu_malloc(sizeof(*vs));
+ vs->pdu = pdu;
+ vs->offset = 7;
+
+ memset(&vs->v9stat, 0, sizeof(vs->v9stat));
+
+ pdu_unmarshal(vs->pdu, vs->offset, "d", &fid);
+
+ vs->fidp = lookup_fid(s, fid);
+ if (vs->fidp == NULL) {
+ err = -ENOENT;
+ goto out;
+ }
+
+ err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
+ v9fs_stat_post_lstat(s, vs, err);
+ return;
+
+out:
+ complete_pdu(s, vs->pdu, err);
+ v9fs_stat_free(&vs->v9stat);
+ qemu_free(vs);
+}
+
+typedef struct V9fsWalkState {
+ V9fsPDU *pdu;
+ size_t offset;
+ int16_t nwnames;
+ int name_idx;
+ V9fsQID *qids;
+ V9fsFidState *fidp;
+ V9fsFidState *newfidp;
+ V9fsString path;
+ V9fsString *wnames;
+ struct stat stbuf;
+} V9fsWalkState;
+
+static void v9fs_walk_complete(V9fsState *s, V9fsWalkState *vs, int err)
+{
+ complete_pdu(s, vs->pdu, err);
+
+ if (vs->nwnames) {
+ for (vs->name_idx = 0; vs->name_idx < vs->nwnames; vs->name_idx++) {
+ v9fs_string_free(&vs->wnames[vs->name_idx]);
+ }
+
+ qemu_free(vs->wnames);
+ qemu_free(vs->qids);
}
}
+static void v9fs_walk_marshal(V9fsWalkState *vs)
+{
+ int i;
+ vs->offset = 7;
+ vs->offset += pdu_marshal(vs->pdu, vs->offset, "w", vs->nwnames);
+
+ for (i = 0; i < vs->nwnames; i++) {
+ vs->offset += pdu_marshal(vs->pdu, vs->offset, "Q", &vs->qids[i]);
+ }
+}
+
+static void v9fs_walk_post_newfid_lstat(V9fsState *s, V9fsWalkState *vs,
+ int err)
+{
+ if (err == -1) {
+ free_fid(s, vs->newfidp->fid);
+ v9fs_string_free(&vs->path);
+ err = -ENOENT;
+ goto out;
+ }
+
+ stat_to_qid(&vs->stbuf, &vs->qids[vs->name_idx]);
+
+ vs->name_idx++;
+ if (vs->name_idx < vs->nwnames) {
+ v9fs_string_sprintf(&vs->path, "%s/%s", vs->newfidp->path.data,
+ vs->wnames[vs->name_idx].data);
+ v9fs_string_copy(&vs->newfidp->path, &vs->path);
+
+ err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf);
+ v9fs_walk_post_newfid_lstat(s, vs, err);
+ return;
+ }
+
+ v9fs_string_free(&vs->path);
+ v9fs_walk_marshal(vs);
+ err = vs->offset;
+out:
+ v9fs_walk_complete(s, vs, err);
+}
+
+static void v9fs_walk_post_oldfid_lstat(V9fsState *s, V9fsWalkState *vs,
+ int err)
+{
+ if (err == -1) {
+ v9fs_string_free(&vs->path);
+ err = -ENOENT;
+ goto out;
+ }
+
+ stat_to_qid(&vs->stbuf, &vs->qids[vs->name_idx]);
+ vs->name_idx++;
+ if (vs->name_idx < vs->nwnames) {
+
+ v9fs_string_sprintf(&vs->path, "%s/%s",
+ vs->fidp->path.data, vs->wnames[vs->name_idx].data);
+ v9fs_string_copy(&vs->fidp->path, &vs->path);
+
+ err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
+ v9fs_walk_post_oldfid_lstat(s, vs, err);
+ return;
+ }
+
+ v9fs_string_free(&vs->path);
+ v9fs_walk_marshal(vs);
+ err = vs->offset;
+out:
+ v9fs_walk_complete(s, vs, err);
+}
+
static void v9fs_walk(V9fsState *s, V9fsPDU *pdu)
{
- if (debug_9p_pdu) {
- pprint_pdu(pdu);
+ int32_t fid, newfid;
+ V9fsWalkState *vs;
+ int err = 0;
+ int i;
+
+ vs = qemu_malloc(sizeof(*vs));
+ vs->pdu = pdu;
+ vs->wnames = NULL;
+ vs->qids = NULL;
+ vs->offset = 7;
+
+ vs->offset += pdu_unmarshal(vs->pdu, vs->offset, "ddw", &fid,
+ &newfid, &vs->nwnames);
+
+ if (vs->nwnames) {
+ vs->wnames = qemu_mallocz(sizeof(vs->wnames[0]) * vs->nwnames);
+
+ vs->qids = qemu_mallocz(sizeof(vs->qids[0]) * vs->nwnames);
+
+ for (i = 0; i < vs->nwnames; i++) {
+ vs->offset += pdu_unmarshal(vs->pdu, vs->offset, "s",
+ &vs->wnames[i]);
+ }
+ }
+
+ vs->fidp = lookup_fid(s, fid);
+ if (vs->fidp == NULL) {
+ err = -ENOENT;
+ goto out;
+ }
+
+ /* FIXME: is this really valid? */
+ if (fid == newfid) {
+
+ BUG_ON(vs->fidp->fd != -1);
+ BUG_ON(vs->fidp->dir);
+ v9fs_string_init(&vs->path);
+ vs->name_idx = 0;
+
+ if (vs->name_idx < vs->nwnames) {
+ v9fs_string_sprintf(&vs->path, "%s/%s",
+ vs->fidp->path.data, vs->wnames[vs->name_idx].data);
+ v9fs_string_copy(&vs->fidp->path, &vs->path);
+
+ err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
+ v9fs_walk_post_oldfid_lstat(s, vs, err);
+ return;
+ }
+ } else {
+ vs->newfidp = alloc_fid(s, newfid);
+ if (vs->newfidp == NULL) {
+ err = -EINVAL;
+ goto out;
+ }
+
+ vs->newfidp->uid = vs->fidp->uid;
+ v9fs_string_init(&vs->path);
+ vs->name_idx = 0;
+ v9fs_string_copy(&vs->newfidp->path, &vs->fidp->path);
+
+ if (vs->name_idx < vs->nwnames) {
+ v9fs_string_sprintf(&vs->path, "%s/%s", vs->newfidp->path.data,
+ vs->wnames[vs->name_idx].data);
+ v9fs_string_copy(&vs->newfidp->path, &vs->path);
+
+ err = v9fs_do_lstat(s, &vs->newfidp->path, &vs->stbuf);
+ v9fs_walk_post_newfid_lstat(s, vs, err);
+ return;
+ }
}
+
+ v9fs_walk_marshal(vs);
+ err = vs->offset;
+out:
+ v9fs_walk_complete(s, vs, err);
}
-static void v9fs_clunk(V9fsState *s, V9fsPDU *pdu)
+typedef struct V9fsOpenState {
+ V9fsPDU *pdu;
+ size_t offset;
+ int8_t mode;
+ V9fsFidState *fidp;
+ V9fsQID qid;
+ struct stat stbuf;
+
+} V9fsOpenState;
+
+enum {
+ Oread = 0x00,
+ Owrite = 0x01,
+ Ordwr = 0x02,
+ Oexec = 0x03,
+ Oexcl = 0x04,
+ Otrunc = 0x10,
+ Orexec = 0x20,
+ Orclose = 0x40,
+ Oappend = 0x80,
+};
+
+static int omode_to_uflags(int8_t mode)
{
- if (debug_9p_pdu) {
- pprint_pdu(pdu);
+ int ret = 0;
+
+ switch (mode & 3) {
+ case Oread:
+ ret = O_RDONLY;
+ break;
+ case Ordwr:
+ ret = O_RDWR;
+ break;
+ case Owrite:
+ ret = O_WRONLY;
+ break;
+ case Oexec:
+ ret = O_RDONLY;
+ break;
+ }
+
+ if (mode & Otrunc) {
+ ret |= O_TRUNC;
+ }
+
+ if (mode & Oappend) {
+ ret |= O_APPEND;
+ }
+
+ if (mode & Oexcl) {
+ ret |= O_EXCL;
+ }
+
+ return ret;
+}
+
+static void v9fs_open_post_opendir(V9fsState *s, V9fsOpenState *vs, int err)
+{
+ if (vs->fidp->dir == NULL) {
+ err = -errno;
+ goto out;
+ }
+
+ vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, 0);
+ err = vs->offset;
+out:
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+
+}
+
+static void v9fs_open_post_open(V9fsState *s, V9fsOpenState *vs, int err)
+{
+ if (vs->fidp->fd == -1) {
+ err = -errno;
+ goto out;
+ }
+
+ vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, 0);
+ err = vs->offset;
+out:
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+}
+
+static void v9fs_open_post_lstat(V9fsState *s, V9fsOpenState *vs, int err)
+{
+ if (err) {
+ err = -errno;
+ goto out;
+ }
+
+ stat_to_qid(&vs->stbuf, &vs->qid);
+
+ if (S_ISDIR(vs->stbuf.st_mode)) {
+ vs->fidp->dir = v9fs_do_opendir(s, &vs->fidp->path);
+ v9fs_open_post_opendir(s, vs, err);
+ } else {
+ vs->fidp->fd = v9fs_do_open(s, &vs->fidp->path,
+ omode_to_uflags(vs->mode));
+ v9fs_open_post_open(s, vs, err);
}
+ return;
+out:
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
}
static void v9fs_open(V9fsState *s, V9fsPDU *pdu)
-{ if (debug_9p_pdu) {
- pprint_pdu(pdu);
- }
+{
+ int32_t fid;
+ V9fsOpenState *vs;
+ ssize_t err = 0;
+
+
+ vs = qemu_malloc(sizeof(*vs));
+ vs->pdu = pdu;
+ vs->offset = 7;
+
+ pdu_unmarshal(vs->pdu, vs->offset, "db", &fid, &vs->mode);
+
+ vs->fidp = lookup_fid(s, fid);
+ if (vs->fidp == NULL) {
+ err = -ENOENT;
+ goto out;
+ }
+
+ BUG_ON(vs->fidp->fd != -1);
+ BUG_ON(vs->fidp->dir);
+
+ err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
+
+ v9fs_open_post_lstat(s, vs, err);
+ return;
+out:
+ complete_pdu(s, pdu, err);
+ qemu_free(vs);
+}
+
+static void v9fs_clunk(V9fsState *s, V9fsPDU *pdu)
+{
+ int32_t fid;
+ size_t offset = 7;
+ int err;
+
+ pdu_unmarshal(pdu, offset, "d", &fid);
+
+ err = free_fid(s, fid);
+ if (err < 0) {
+ goto out;
+ }
+
+ offset = 7;
+ err = offset;
+out:
+ complete_pdu(s, pdu, err);
+}
+
+typedef struct V9fsReadState {
+ V9fsPDU *pdu;
+ size_t offset;
+ int32_t count;
+ int32_t total;
+ int64_t off;
+ V9fsFidState *fidp;
+ struct iovec iov[128]; /* FIXME: bad, bad, bad */
+ struct iovec *sg;
+ off_t dir_pos;
+ struct dirent *dent;
+ struct stat stbuf;
+ V9fsString name;
+ V9fsStat v9stat;
+ int32_t len;
+ int32_t cnt;
+ int32_t max_count;
+} V9fsReadState;
+
+static void v9fs_read_post_readdir(V9fsState *, V9fsReadState *, ssize_t);
+
+static void v9fs_read_post_seekdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
+{
+ if (err) {
+ goto out;
+ }
+ v9fs_stat_free(&vs->v9stat);
+ v9fs_string_free(&vs->name);
+ vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
+ vs->offset += vs->count;
+ err = vs->offset;
+out:
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+ return;
+}
+
+static void v9fs_read_post_dir_lstat(V9fsState *s, V9fsReadState *vs,
+ ssize_t err)
+{
+ if (err) {
+ err = -errno;
+ goto out;
+ }
+ err = stat_to_v9stat(s, &vs->name, &vs->stbuf, &vs->v9stat);
+ if (err) {
+ goto out;
+ }
+
+ vs->len = pdu_marshal(vs->pdu, vs->offset + 4 + vs->count, "S",
+ &vs->v9stat);
+ if ((vs->len != (vs->v9stat.size + 2)) ||
+ ((vs->count + vs->len) > vs->max_count)) {
+ v9fs_do_seekdir(s, vs->fidp->dir, vs->dir_pos);
+ v9fs_read_post_seekdir(s, vs, err);
+ return;
+ }
+ vs->count += vs->len;
+ v9fs_stat_free(&vs->v9stat);
+ v9fs_string_free(&vs->name);
+ vs->dir_pos = vs->dent->d_off;
+ vs->dent = v9fs_do_readdir(s, vs->fidp->dir);
+ v9fs_read_post_readdir(s, vs, err);
+ return;
+out:
+ v9fs_do_seekdir(s, vs->fidp->dir, vs->dir_pos);
+ v9fs_read_post_seekdir(s, vs, err);
+ return;
+
+}
+
+static void v9fs_read_post_readdir(V9fsState *s, V9fsReadState *vs, ssize_t err)
+{
+ if (vs->dent) {
+ memset(&vs->v9stat, 0, sizeof(vs->v9stat));
+ v9fs_string_init(&vs->name);
+ v9fs_string_sprintf(&vs->name, "%s/%s", vs->fidp->path.data,
+ vs->dent->d_name);
+ err = v9fs_do_lstat(s, &vs->name, &vs->stbuf);
+ v9fs_read_post_dir_lstat(s, vs, err);
+ return;
+ }
+
+ vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->count);
+ vs->offset += vs->count;
+ err = vs->offset;
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+ return;
+}
+
+static void v9fs_read_post_telldir(V9fsState *s, V9fsReadState *vs, ssize_t err)
+{
+ vs->dent = v9fs_do_readdir(s, vs->fidp->dir);
+ v9fs_read_post_readdir(s, vs, err);
+ return;
+}
+
+static void v9fs_read_post_rewinddir(V9fsState *s, V9fsReadState *vs,
+ ssize_t err)
+{
+ vs->dir_pos = v9fs_do_telldir(s, vs->fidp->dir);
+ v9fs_read_post_telldir(s, vs, err);
+ return;
+}
+
+static void v9fs_read_post_readv(V9fsState *s, V9fsReadState *vs, ssize_t err)
+{
+ if (err < 0) {
+ /* IO error return the error */
+ err = -errno;
+ goto out;
+ }
+ vs->total += vs->len;
+ vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
+ if (vs->total < vs->count && vs->len > 0) {
+ do {
+ if (0) {
+ print_sg(vs->sg, vs->cnt);
+ }
+ vs->len = v9fs_do_readv(s, vs->fidp->fd, vs->sg, vs->cnt);
+ } while (vs->len == -1 && errno == EINTR);
+ if (vs->len == -1) {
+ err = -errno;
+ }
+ v9fs_read_post_readv(s, vs, err);
+ return;
+ }
+ vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
+ vs->offset += vs->count;
+ err = vs->offset;
+
+out:
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+}
+
+static void v9fs_read_post_lseek(V9fsState *s, V9fsReadState *vs, ssize_t err)
+{
+ if (err == -1) {
+ err = -errno;
+ goto out;
+ }
+ vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
+
+ if (vs->total < vs->count) {
+ do {
+ if (0) {
+ print_sg(vs->sg, vs->cnt);
+ }
+ vs->len = v9fs_do_readv(s, vs->fidp->fd, vs->sg, vs->cnt);
+ } while (vs->len == -1 && errno == EINTR);
+ if (vs->len == -1) {
+ err = -errno;
+ }
+ v9fs_read_post_readv(s, vs, err);
+ return;
+ }
+out:
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
}
static void v9fs_read(V9fsState *s, V9fsPDU *pdu)
{
- if (debug_9p_pdu) {
- pprint_pdu(pdu);
+ int32_t fid;
+ V9fsReadState *vs;
+ ssize_t err = 0;
+
+ vs = qemu_malloc(sizeof(*vs));
+ vs->pdu = pdu;
+ vs->offset = 7;
+ vs->total = 0;
+ vs->len = 0;
+ vs->count = 0;
+
+ pdu_unmarshal(vs->pdu, vs->offset, "dqd", &fid, &vs->off, &vs->count);
+
+ vs->fidp = lookup_fid(s, fid);
+ if (vs->fidp == NULL) {
+ err = -EINVAL;
+ goto out;
}
+
+ if (vs->fidp->dir) {
+ vs->max_count = vs->count;
+ vs->count = 0;
+ if (vs->off == 0) {
+ v9fs_do_rewinddir(s, vs->fidp->dir);
+ }
+ v9fs_read_post_rewinddir(s, vs, err);
+ return;
+ } else if (vs->fidp->fd != -1) {
+ vs->sg = vs->iov;
+ pdu_marshal(vs->pdu, vs->offset + 4, "v", vs->sg, &vs->cnt);
+ err = v9fs_do_lseek(s, vs->fidp->fd, vs->off, SEEK_SET);
+ v9fs_read_post_lseek(s, vs, err);
+ return;
+ } else {
+ err = -EINVAL;
+ }
+out:
+ complete_pdu(s, pdu, err);
+ qemu_free(vs);
+}
+
+typedef struct V9fsWriteState {
+ V9fsPDU *pdu;
+ size_t offset;
+ int32_t len;
+ int32_t count;
+ int32_t total;
+ int64_t off;
+ V9fsFidState *fidp;
+ struct iovec iov[128]; /* FIXME: bad, bad, bad */
+ struct iovec *sg;
+ int cnt;
+} V9fsWriteState;
+
+static void v9fs_write_post_writev(V9fsState *s, V9fsWriteState *vs,
+ ssize_t err)
+{
+ if (err < 0) {
+ /* IO error return the error */
+ err = -errno;
+ goto out;
+ }
+ vs->total += vs->len;
+ vs->sg = adjust_sg(vs->sg, vs->len, &vs->cnt);
+ if (vs->total < vs->count && vs->len > 0) {
+ do {
+ if (0) {
+ print_sg(vs->sg, vs->cnt);
+ }
+ vs->len = v9fs_do_writev(s, vs->fidp->fd, vs->sg, vs->cnt);
+ } while (vs->len == -1 && errno == EINTR);
+ if (vs->len == -1) {
+ err = -errno;
+ }
+ v9fs_write_post_writev(s, vs, err);
+ return;
+ }
+ vs->offset += pdu_marshal(vs->pdu, vs->offset, "d", vs->total);
+
+ err = vs->offset;
+out:
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+}
+
+static void v9fs_write_post_lseek(V9fsState *s, V9fsWriteState *vs, ssize_t err)
+{
+ if (err == -1) {
+ err = -errno;
+ goto out;
+ }
+ vs->sg = cap_sg(vs->sg, vs->count, &vs->cnt);
+
+ if (vs->total < vs->count) {
+ do {
+ if (0) {
+ print_sg(vs->sg, vs->cnt);
+ }
+ vs->len = v9fs_do_writev(s, vs->fidp->fd, vs->sg, vs->cnt);
+ } while (vs->len == -1 && errno == EINTR);
+ if (vs->len == -1) {
+ err = -errno;
+ }
+ v9fs_write_post_writev(s, vs, err);
+ return;
+ }
+
+out:
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
}
static void v9fs_write(V9fsState *s, V9fsPDU *pdu)
{
- if (debug_9p_pdu) {
- pprint_pdu(pdu);
+ int32_t fid;
+ V9fsWriteState *vs;
+ ssize_t err;
+
+ vs = qemu_malloc(sizeof(*vs));
+
+ vs->pdu = pdu;
+ vs->offset = 7;
+ vs->sg = vs->iov;
+ vs->total = 0;
+ vs->len = 0;
+
+ pdu_unmarshal(vs->pdu, vs->offset, "dqdv", &fid, &vs->off, &vs->count,
+ vs->sg, &vs->cnt);
+
+ vs->fidp = lookup_fid(s, fid);
+ if (vs->fidp == NULL) {
+ err = -EINVAL;
+ goto out;
+ }
+
+ if (vs->fidp->fd == -1) {
+ err = -EINVAL;
+ goto out;
}
+
+ err = v9fs_do_lseek(s, vs->fidp->fd, vs->off, SEEK_SET);
+
+ v9fs_write_post_lseek(s, vs, err);
+ return;
+
+out:
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+}
+
+typedef struct V9fsCreateState {
+ V9fsPDU *pdu;
+ size_t offset;
+ V9fsFidState *fidp;
+ V9fsQID qid;
+ int32_t perm;
+ int8_t mode;
+ struct stat stbuf;
+ V9fsString name;
+ V9fsString extension;
+ V9fsString fullname;
+} V9fsCreateState;
+
+static void v9fs_post_create(V9fsState *s, V9fsCreateState *vs, int err)
+{
+ if (err == 0) {
+ v9fs_string_copy(&vs->fidp->path, &vs->fullname);
+ stat_to_qid(&vs->stbuf, &vs->qid);
+
+ vs->offset += pdu_marshal(vs->pdu, vs->offset, "Qd", &vs->qid, 0);
+
+ err = vs->offset;
+ }
+
+ complete_pdu(s, vs->pdu, err);
+ v9fs_string_free(&vs->name);
+ v9fs_string_free(&vs->extension);
+ v9fs_string_free(&vs->fullname);
+ qemu_free(vs);
+}
+
+static void v9fs_create_post_perms(V9fsState *s, V9fsCreateState *vs, int err)
+{
+ if (err) {
+ err = -errno;
+ }
+ v9fs_post_create(s, vs, err);
+}
+
+static void v9fs_create_post_opendir(V9fsState *s, V9fsCreateState *vs,
+ int err)
+{
+ if (!vs->fidp->dir) {
+ err = -errno;
+ }
+ v9fs_post_create(s, vs, err);
+}
+
+static void v9fs_create_post_dir_lstat(V9fsState *s, V9fsCreateState *vs,
+ int err)
+{
+ if (err) {
+ err = -errno;
+ goto out;
+ }
+
+ vs->fidp->dir = v9fs_do_opendir(s, &vs->fullname);
+ v9fs_create_post_opendir(s, vs, err);
+ return;
+
+out:
+ v9fs_post_create(s, vs, err);
+}
+
+static void v9fs_create_post_mkdir(V9fsState *s, V9fsCreateState *vs, int err)
+{
+ if (err) {
+ err = -errno;
+ goto out;
+ }
+
+ err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
+ v9fs_create_post_dir_lstat(s, vs, err);
+ return;
+
+out:
+ v9fs_post_create(s, vs, err);
+}
+
+static void v9fs_create_post_mksock(V9fsState *s, V9fsCreateState *vs,
+ int err)
+{
+ if (err) {
+ err = -errno;
+ goto out;
+ }
+
+ err = v9fs_do_chmod(s, &vs->fullname, vs->perm & 0777);
+ v9fs_create_post_perms(s, vs, err);
+ return;
+
+out:
+ v9fs_post_create(s, vs, err);
+}
+
+static void v9fs_create_post_fstat(V9fsState *s, V9fsCreateState *vs, int err)
+{
+ if (err) {
+ vs->fidp->fd = -1;
+ err = -errno;
+ }
+
+ v9fs_post_create(s, vs, err);
+ return;
+}
+
+static void v9fs_create_post_open2(V9fsState *s, V9fsCreateState *vs, int err)
+{
+ if (vs->fidp->fd == -1) {
+ err = -errno;
+ goto out;
+ }
+
+ err = v9fs_do_fstat(s, vs->fidp->fd, &vs->stbuf);
+ v9fs_create_post_fstat(s, vs, err);
+
+ return;
+
+out:
+ v9fs_post_create(s, vs, err);
+
+}
+
+static void v9fs_create_post_lstat(V9fsState *s, V9fsCreateState *vs, int err)
+{
+
+ if (err == 0 || errno != ENOENT) {
+ err = -errno;
+ goto out;
+ }
+
+ if (vs->perm & P9_STAT_MODE_DIR) {
+ err = v9fs_do_mkdir(s, &vs->fullname, vs->perm & 0777);
+ v9fs_create_post_mkdir(s, vs, err);
+ } else if (vs->perm & P9_STAT_MODE_SYMLINK) {
+ err = v9fs_do_symlink(s, &vs->extension, &vs->fullname);
+ v9fs_create_post_perms(s, vs, err);
+ } else if (vs->perm & P9_STAT_MODE_LINK) {
+ int32_t nfid = atoi(vs->extension.data);
+ V9fsFidState *nfidp = lookup_fid(s, nfid);
+ if (nfidp == NULL) {
+ err = -errno;
+ v9fs_post_create(s, vs, err);
+ }
+ err = v9fs_do_link(s, &nfidp->path, &vs->fullname);
+ v9fs_create_post_perms(s, vs, err);
+ } else if (vs->perm & P9_STAT_MODE_DEVICE) {
+ char ctype;
+ uint32_t major, minor;
+ mode_t nmode = 0;
+
+ if (sscanf(vs->extension.data, "%c %u %u", &ctype, &major,
+ &minor) != 3) {
+ err = -errno;
+ v9fs_post_create(s, vs, err);
+ }
+
+ switch (ctype) {
+ case 'c':
+ nmode = S_IFCHR;
+ break;
+ case 'b':
+ nmode = S_IFBLK;
+ break;
+ default:
+ err = -EIO;
+ v9fs_post_create(s, vs, err);
+ }
+
+ nmode |= vs->perm & 0777;
+ err = v9fs_do_mknod(s, &vs->fullname, nmode, makedev(major, minor));
+ v9fs_create_post_perms(s, vs, err);
+ } else if (vs->perm & P9_STAT_MODE_NAMED_PIPE) {
+ err = v9fs_do_mknod(s, &vs->fullname, S_IFIFO | (vs->mode & 0777), 0);
+ v9fs_post_create(s, vs, err);
+ } else if (vs->perm & P9_STAT_MODE_SOCKET) {
+ err = v9fs_do_mksock(s, &vs->fullname);
+ v9fs_create_post_mksock(s, vs, err);
+ } else {
+ vs->fidp->fd = v9fs_do_open2(s, &vs->fullname,
+ omode_to_uflags(vs->mode) | O_CREAT,
+ vs->perm & 0777);
+ v9fs_create_post_open2(s, vs, err);
+ }
+
+ return;
+
+out:
+ v9fs_post_create(s, vs, err);
}
static void v9fs_create(V9fsState *s, V9fsPDU *pdu)
{
- if (debug_9p_pdu) {
- pprint_pdu(pdu);
+ int32_t fid;
+ V9fsCreateState *vs;
+ int err = 0;
+
+ vs = qemu_malloc(sizeof(*vs));
+ vs->pdu = pdu;
+ vs->offset = 7;
+
+ v9fs_string_init(&vs->fullname);
+
+ pdu_unmarshal(vs->pdu, vs->offset, "dsdbs", &fid, &vs->name,
+ &vs->perm, &vs->mode, &vs->extension);
+
+ vs->fidp = lookup_fid(s, fid);
+ if (vs->fidp == NULL) {
+ err = -EINVAL;
+ goto out;
}
+
+ v9fs_string_sprintf(&vs->fullname, "%s/%s", vs->fidp->path.data,
+ vs->name.data);
+
+ err = v9fs_do_lstat(s, &vs->fullname, &vs->stbuf);
+ v9fs_create_post_lstat(s, vs, err);
+ return;
+
+out:
+ complete_pdu(s, vs->pdu, err);
+ v9fs_string_free(&vs->name);
+ v9fs_string_free(&vs->extension);
+ qemu_free(vs);
}
static void v9fs_flush(V9fsState *s, V9fsPDU *pdu)
{
- v9fs_dummy(s, pdu);
- if (debug_9p_pdu) {
- pprint_pdu(pdu);
+ /* A nop call with no return */
+ complete_pdu(s, pdu, 7);
+}
+
+typedef struct V9fsRemoveState {
+ V9fsPDU *pdu;
+ size_t offset;
+ V9fsFidState *fidp;
+} V9fsRemoveState;
+
+static void v9fs_remove_post_remove(V9fsState *s, V9fsRemoveState *vs,
+ int err)
+{
+ /* For TREMOVE we need to clunk the fid even on failed remove */
+ err = free_fid(s, vs->fidp->fid);
+ if (err < 0) {
+ goto out;
}
+
+ err = vs->offset;
+out:
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
}
static void v9fs_remove(V9fsState *s, V9fsPDU *pdu)
{
- if (debug_9p_pdu) {
- pprint_pdu(pdu);
+ int32_t fid;
+ V9fsRemoveState *vs;
+ int err = 0;
+
+ vs = qemu_malloc(sizeof(*vs));
+ vs->pdu = pdu;
+ vs->offset = 7;
+
+ pdu_unmarshal(vs->pdu, vs->offset, "d", &fid);
+
+ vs->fidp = lookup_fid(s, fid);
+ if (vs->fidp == NULL) {
+ err = -EINVAL;
+ goto out;
+ }
+
+ err = v9fs_do_remove(s, &vs->fidp->path);
+ v9fs_remove_post_remove(s, vs, err);
+ return;
+
+out:
+ complete_pdu(s, pdu, err);
+ qemu_free(vs);
+}
+
+typedef struct V9fsWstatState
+{
+ V9fsPDU *pdu;
+ size_t offset;
+ int16_t unused;
+ V9fsStat v9stat;
+ V9fsFidState *fidp;
+ struct stat stbuf;
+ V9fsString nname;
+} V9fsWstatState;
+
+static void v9fs_wstat_post_truncate(V9fsState *s, V9fsWstatState *vs, int err)
+{
+ if (err < 0) {
+ goto out;
+ }
+
+ err = vs->offset;
+
+out:
+ v9fs_stat_free(&vs->v9stat);
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+}
+
+static void v9fs_wstat_post_rename(V9fsState *s, V9fsWstatState *vs, int err)
+{
+ if (err < 0) {
+ goto out;
+ }
+
+ if (vs->v9stat.name.size != 0) {
+ v9fs_string_free(&vs->nname);
+ }
+
+ if (vs->v9stat.length != -1) {
+ if (v9fs_do_truncate(s, &vs->fidp->path, vs->v9stat.length) < 0) {
+ err = -errno;
+ }
+ }
+ v9fs_wstat_post_truncate(s, vs, err);
+ return;
+
+out:
+ v9fs_stat_free(&vs->v9stat);
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+}
+
+static void v9fs_wstat_post_chown(V9fsState *s, V9fsWstatState *vs, int err)
+{
+ V9fsFidState *fidp;
+ if (err < 0) {
+ goto out;
+ }
+
+ if (vs->v9stat.name.size != 0) {
+ char *old_name, *new_name;
+ char *end;
+
+ old_name = vs->fidp->path.data;
+ end = strrchr(old_name, '/');
+ if (end) {
+ end++;
+ } else {
+ end = old_name;
+ }
+
+ new_name = qemu_malloc(end - old_name + vs->v9stat.name.size + 1);
+
+ memset(new_name, 0, end - old_name + vs->v9stat.name.size + 1);
+ memcpy(new_name, old_name, end - old_name);
+ memcpy(new_name + (end - old_name), vs->v9stat.name.data,
+ vs->v9stat.name.size);
+ vs->nname.data = new_name;
+ vs->nname.size = strlen(new_name);
+
+ if (strcmp(new_name, vs->fidp->path.data) != 0) {
+ if (v9fs_do_rename(s, &vs->fidp->path, &vs->nname)) {
+ err = -errno;
+ } else {
+ /*
+ * Fixup fid's pointing to the old name to
+ * start pointing to the new name
+ */
+ for (fidp = s->fid_list; fidp; fidp = fidp->next) {
+
+ if (vs->fidp == fidp) {
+ /*
+ * we replace name of this fid towards the end
+ * so that our below strcmp will work
+ */
+ continue;
+ }
+ if (!strncmp(vs->fidp->path.data, fidp->path.data,
+ strlen(vs->fidp->path.data))) {
+ /* replace the name */
+ v9fs_fix_path(&fidp->path, &vs->nname,
+ strlen(vs->fidp->path.data));
+ }
+ }
+ v9fs_string_copy(&vs->fidp->path, &vs->nname);
+ }
+ }
+ }
+ v9fs_wstat_post_rename(s, vs, err);
+ return;
+
+out:
+ v9fs_stat_free(&vs->v9stat);
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+}
+
+static void v9fs_wstat_post_utime(V9fsState *s, V9fsWstatState *vs, int err)
+{
+ if (err < 0) {
+ goto out;
+ }
+
+ if (vs->v9stat.n_gid != -1) {
+ if (v9fs_do_chown(s, &vs->fidp->path, vs->v9stat.n_uid,
+ vs->v9stat.n_gid)) {
+ err = -errno;
+ }
+ }
+ v9fs_wstat_post_chown(s, vs, err);
+ return;
+
+out:
+ v9fs_stat_free(&vs->v9stat);
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+}
+
+static void v9fs_wstat_post_chmod(V9fsState *s, V9fsWstatState *vs, int err)
+{
+ if (err < 0) {
+ goto out;
+ }
+
+ if (vs->v9stat.mtime != -1) {
+ struct utimbuf tb;
+ tb.actime = 0;
+ tb.modtime = vs->v9stat.mtime;
+ if (v9fs_do_utime(s, &vs->fidp->path, &tb)) {
+ err = -errno;
+ }
+ }
+
+ v9fs_wstat_post_utime(s, vs, err);
+ return;
+
+out:
+ v9fs_stat_free(&vs->v9stat);
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+}
+
+static void v9fs_wstat_post_fsync(V9fsState *s, V9fsWstatState *vs, int err)
+{
+ if (err == -1) {
+ err = -errno;
+ }
+ v9fs_stat_free(&vs->v9stat);
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
+}
+
+static void v9fs_wstat_post_lstat(V9fsState *s, V9fsWstatState *vs, int err)
+{
+ uint32_t v9_mode;
+
+ if (err == -1) {
+ err = -errno;
+ goto out;
+ }
+
+ v9_mode = stat_to_v9mode(&vs->stbuf);
+
+ if ((vs->v9stat.mode & P9_STAT_MODE_TYPE_BITS) !=
+ (v9_mode & P9_STAT_MODE_TYPE_BITS)) {
+ /* Attempting to change the type */
+ err = -EIO;
+ goto out;
}
+
+ if (v9fs_do_chmod(s, &vs->fidp->path, v9mode_to_mode(vs->v9stat.mode,
+ &vs->v9stat.extension))) {
+ err = -errno;
+ }
+ v9fs_wstat_post_chmod(s, vs, err);
+ return;
+
+out:
+ v9fs_stat_free(&vs->v9stat);
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
}
static void v9fs_wstat(V9fsState *s, V9fsPDU *pdu)
{
- if (debug_9p_pdu) {
- pprint_pdu(pdu);
+ int32_t fid;
+ V9fsWstatState *vs;
+ int err = 0;
+
+ vs = qemu_malloc(sizeof(*vs));
+ vs->pdu = pdu;
+ vs->offset = 7;
+
+ pdu_unmarshal(pdu, vs->offset, "dwS", &fid, &vs->unused, &vs->v9stat);
+
+ vs->fidp = lookup_fid(s, fid);
+ if (vs->fidp == NULL) {
+ err = -EINVAL;
+ goto out;
+ }
+
+ /* do we need to sync the file? */
+ if (donttouch_stat(&vs->v9stat)) {
+ err = v9fs_do_fsync(s, vs->fidp->fd);
+ v9fs_wstat_post_fsync(s, vs, err);
+ return;
}
+
+ if (vs->v9stat.mode != -1) {
+ err = v9fs_do_lstat(s, &vs->fidp->path, &vs->stbuf);
+ v9fs_wstat_post_lstat(s, vs, err);
+ return;
+ }
+
+ v9fs_wstat_post_chmod(s, vs, err);
+ return;
+
+out:
+ v9fs_stat_free(&vs->v9stat);
+ complete_pdu(s, vs->pdu, err);
+ qemu_free(vs);
}
typedef void (pdu_handler_t)(V9fsState *s, V9fsPDU *pdu);
projects / mirror_qemu.git / blobdiff