![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to virtio-9p-handle.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / hw / 9pfs|
Return to virtio-9p-handle.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / hw / 9pfs |
1.1 root 1: /*
2: * Virtio 9p handle callback
3: *
4: * Copyright IBM, Corp. 2011
5: *
6: * Authors:
7: * Aneesh Kumar K.V <[email protected]>
8: *
9: * This work is licensed under the terms of the GNU GPL, version 2. See
10: * the COPYING file in the top-level directory.
11: *
12: */
13:
14: #include "hw/virtio.h"
15: #include "virtio-9p.h"
16: #include "virtio-9p-xattr.h"
17: #include <arpa/inet.h>
18: #include <pwd.h>
19: #include <grp.h>
20: #include <sys/socket.h>
21: #include <sys/un.h>
22: #include "qemu-xattr.h"
23: #include <unistd.h>
24: #include <linux/fs.h>
25: #ifdef CONFIG_LINUX_MAGIC_H
26: #include <linux/magic.h>
27: #endif
28: #include <sys/ioctl.h>
29:
30: #ifndef XFS_SUPER_MAGIC
31: #define XFS_SUPER_MAGIC 0x58465342
32: #endif
33: #ifndef EXT2_SUPER_MAGIC
34: #define EXT2_SUPER_MAGIC 0xEF53
35: #endif
36: #ifndef REISERFS_SUPER_MAGIC
37: #define REISERFS_SUPER_MAGIC 0x52654973
38: #endif
39: #ifndef BTRFS_SUPER_MAGIC
40: #define BTRFS_SUPER_MAGIC 0x9123683E
41: #endif
42:
43: struct handle_data {
44: int mountfd;
45: int handle_bytes;
46: };
47:
48: static inline int name_to_handle(int dirfd, const char *name,
49: struct file_handle *fh, int *mnt_id, int flags)
50: {
51: return name_to_handle_at(dirfd, name, fh, mnt_id, flags);
52: }
53:
54: static inline int open_by_handle(int mountfd, const char *fh, int flags)
55: {
56: return open_by_handle_at(mountfd, (struct file_handle *)fh, flags);
57: }
58:
59: static int handle_update_file_cred(int dirfd, const char *name, FsCred *credp)
60: {
61: int fd, ret;
62: fd = openat(dirfd, name, O_NONBLOCK | O_NOFOLLOW);;
63: if (fd < 0) {
64: return fd;
65: }
66: ret = fchmod(fd, credp->fc_mode & 07777);
67: if (ret < 0) {
68: goto err_out;
69: }
70: ret = fchownat(fd, "", credp->fc_uid, credp->fc_gid, AT_EMPTY_PATH);
71: err_out:
72: close(fd);
73: return ret;
74: }
75:
76:
77: static int handle_lstat(FsContext *fs_ctx, V9fsPath *fs_path,
78: struct stat *stbuf)
79: {
80: int fd, ret;
81: struct handle_data *data = (struct handle_data *)fs_ctx->private;
82:
83: fd = open_by_handle(data->mountfd, fs_path->data, O_PATH);
84: if (fd < 0) {
85: return fd;
86: }
87: ret = fstatat(fd, "", stbuf, AT_EMPTY_PATH);
88: close(fd);
89: return ret;
90: }
91:
92: static ssize_t handle_readlink(FsContext *fs_ctx, V9fsPath *fs_path,
93: char *buf, size_t bufsz)
94: {
95: int fd, ret;
96: struct handle_data *data = (struct handle_data *)fs_ctx->private;
97:
98: fd = open_by_handle(data->mountfd, fs_path->data, O_PATH);
99: if (fd < 0) {
100: return fd;
101: }
102: ret = readlinkat(fd, "", buf, bufsz);
103: close(fd);
104: return ret;
105: }
106:
107: static int handle_close(FsContext *ctx, V9fsFidOpenState *fs)
108: {
109: return close(fs->fd);
110: }
111:
112: static int handle_closedir(FsContext *ctx, V9fsFidOpenState *fs)
113: {
114: return closedir(fs->dir);
115: }
116:
117: static int handle_open(FsContext *ctx, V9fsPath *fs_path,
118: int flags, V9fsFidOpenState *fs)
119: {
120: struct handle_data *data = (struct handle_data *)ctx->private;
121:
122: fs->fd = open_by_handle(data->mountfd, fs_path->data, flags);
123: return fs->fd;
124: }
125:
126: static int handle_opendir(FsContext *ctx,
127: V9fsPath *fs_path, V9fsFidOpenState *fs)
128: {
129: int ret;
130: ret = handle_open(ctx, fs_path, O_DIRECTORY, fs);
131: if (ret < 0) {
132: return -1;
133: }
134: fs->dir = fdopendir(ret);
135: if (!fs->dir) {
136: return -1;
137: }
138: return 0;
139: }
140:
141: static void handle_rewinddir(FsContext *ctx, V9fsFidOpenState *fs)
142: {
143: return rewinddir(fs->dir);
144: }
145:
146: static off_t handle_telldir(FsContext *ctx, V9fsFidOpenState *fs)
147: {
148: return telldir(fs->dir);
149: }
150:
151: static int handle_readdir_r(FsContext *ctx, V9fsFidOpenState *fs,
152: struct dirent *entry,
153: struct dirent **result)
154: {
155: return readdir_r(fs->dir, entry, result);
156: }
157:
158: static void handle_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
159: {
160: return seekdir(fs->dir, off);
161: }
162:
163: static ssize_t handle_preadv(FsContext *ctx, V9fsFidOpenState *fs,
164: const struct iovec *iov,
165: int iovcnt, off_t offset)
166: {
167: #ifdef CONFIG_PREADV
168: return preadv(fs->fd, iov, iovcnt, offset);
169: #else
170: int err = lseek(fs->fd, offset, SEEK_SET);
171: if (err == -1) {
172: return err;
173: } else {
174: return readv(fs->fd, iov, iovcnt);
175: }
176: #endif
177: }
178:
179: static ssize_t handle_pwritev(FsContext *ctx, V9fsFidOpenState *fs,
180: const struct iovec *iov,
181: int iovcnt, off_t offset)
182: {
183: ssize_t ret;
184: #ifdef CONFIG_PREADV
185: ret = pwritev(fs->fd, iov, iovcnt, offset);
186: #else
187: int err = lseek(fs->fd, offset, SEEK_SET);
188: if (err == -1) {
189: return err;
190: } else {
191: ret = writev(fs->fd, iov, iovcnt);
192: }
193: #endif
194: #ifdef CONFIG_SYNC_FILE_RANGE
195: if (ret > 0 && ctx->export_flags & V9FS_IMMEDIATE_WRITEOUT) {
196: /*
197: * Initiate a writeback. This is not a data integrity sync.
198: * We want to ensure that we don't leave dirty pages in the cache
199: * after write when writeout=immediate is sepcified.
200: */
201: sync_file_range(fs->fd, offset, ret,
202: SYNC_FILE_RANGE_WAIT_BEFORE | SYNC_FILE_RANGE_WRITE);
203: }
204: #endif
205: return ret;
206: }
207:
208: static int handle_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
209: {
210: int fd, ret;
211: struct handle_data *data = (struct handle_data *)fs_ctx->private;
212:
213: fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
214: if (fd < 0) {
215: return fd;
216: }
217: ret = fchmod(fd, credp->fc_mode);
218: close(fd);
219: return ret;
220: }
221:
222: static int handle_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
223: const char *name, FsCred *credp)
224: {
225: int dirfd, ret;
226: struct handle_data *data = (struct handle_data *)fs_ctx->private;
227:
228: dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
229: if (dirfd < 0) {
230: return dirfd;
231: }
232: ret = mknodat(dirfd, name, credp->fc_mode, credp->fc_rdev);
233: if (!ret) {
234: ret = handle_update_file_cred(dirfd, name, credp);
235: }
236: close(dirfd);
237: return ret;
238: }
239:
240: static int handle_mkdir(FsContext *fs_ctx, V9fsPath *dir_path,
241: const char *name, FsCred *credp)
242: {
243: int dirfd, ret;
244: struct handle_data *data = (struct handle_data *)fs_ctx->private;
245:
246: dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
247: if (dirfd < 0) {
248: return dirfd;
249: }
250: ret = mkdirat(dirfd, name, credp->fc_mode);
251: if (!ret) {
252: ret = handle_update_file_cred(dirfd, name, credp);
253: }
254: close(dirfd);
255: return ret;
256: }
257:
258: static int handle_fstat(FsContext *fs_ctx, int fid_type,
259: V9fsFidOpenState *fs, struct stat *stbuf)
260: {
261: int fd;
262:
263: if (fid_type == P9_FID_DIR) {
264: fd = dirfd(fs->dir);
265: } else {
266: fd = fs->fd;
267: }
268: return fstat(fd, stbuf);
269: }
270:
271: static int handle_open2(FsContext *fs_ctx, V9fsPath *dir_path, const char *name,
272: int flags, FsCred *credp, V9fsFidOpenState *fs)
273: {
274: int ret;
275: int dirfd, fd;
276: struct handle_data *data = (struct handle_data *)fs_ctx->private;
277:
278: dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
279: if (dirfd < 0) {
280: return dirfd;
281: }
282: fd = openat(dirfd, name, flags | O_NOFOLLOW, credp->fc_mode);
283: if (fd >= 0) {
284: ret = handle_update_file_cred(dirfd, name, credp);
285: if (ret < 0) {
286: close(fd);
287: fd = ret;
288: } else {
289: fs->fd = fd;
290: }
291: }
292: close(dirfd);
293: return fd;
294: }
295:
296:
297: static int handle_symlink(FsContext *fs_ctx, const char *oldpath,
298: V9fsPath *dir_path, const char *name, FsCred *credp)
299: {
300: int fd, dirfd, ret;
301: struct handle_data *data = (struct handle_data *)fs_ctx->private;
302:
303: dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
304: if (dirfd < 0) {
305: return dirfd;
306: }
307: ret = symlinkat(oldpath, dirfd, name);
308: if (!ret) {
309: fd = openat(dirfd, name, O_PATH | O_NOFOLLOW);
310: if (fd < 0) {
311: ret = fd;
312: goto err_out;
313: }
314: ret = fchownat(fd, "", credp->fc_uid, credp->fc_gid, AT_EMPTY_PATH);
315: close(fd);
316: }
317: err_out:
318: close(dirfd);
319: return ret;
320: }
321:
322: static int handle_link(FsContext *ctx, V9fsPath *oldpath,
323: V9fsPath *dirpath, const char *name)
324: {
325: int oldfd, newdirfd, ret;
326: struct handle_data *data = (struct handle_data *)ctx->private;
327:
328: oldfd = open_by_handle(data->mountfd, oldpath->data, O_PATH);
329: if (oldfd < 0) {
330: return oldfd;
331: }
332: newdirfd = open_by_handle(data->mountfd, dirpath->data, O_PATH);
333: if (newdirfd < 0) {
334: close(oldfd);
335: return newdirfd;
336: }
337: ret = linkat(oldfd, "", newdirfd, name, AT_EMPTY_PATH);
338: close(newdirfd);
339: close(oldfd);
340: return ret;
341: }
342:
343: static int handle_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size)
344: {
345: int fd, ret;
346: struct handle_data *data = (struct handle_data *)ctx->private;
347:
348: fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK | O_WRONLY);
349: if (fd < 0) {
350: return fd;
351: }
352: ret = ftruncate(fd, size);
353: close(fd);
354: return ret;
355: }
356:
357: static int handle_rename(FsContext *ctx, const char *oldpath,
358: const char *newpath)
359: {
360: errno = EOPNOTSUPP;
361: return -1;
362: }
363:
364: static int handle_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp)
365: {
366: int fd, ret;
367: struct handle_data *data = (struct handle_data *)fs_ctx->private;
368:
369: fd = open_by_handle(data->mountfd, fs_path->data, O_PATH);
370: if (fd < 0) {
371: return fd;
372: }
373: ret = fchownat(fd, "", credp->fc_uid, credp->fc_gid, AT_EMPTY_PATH);
374: close(fd);
375: return ret;
376: }
377:
378: static int handle_utimensat(FsContext *ctx, V9fsPath *fs_path,
379: const struct timespec *buf)
380: {
381: int ret;
382: #ifdef CONFIG_UTIMENSAT
383: int fd;
384: struct handle_data *data = (struct handle_data *)ctx->private;
385:
386: fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
387: if (fd < 0) {
388: return fd;
389: }
390: ret = futimens(fd, buf);
391: close(fd);
392: #else
393: ret = -1;
394: errno = ENOSYS;
395: #endif
396: return ret;
397: }
398:
399: static int handle_remove(FsContext *ctx, const char *path)
400: {
401: errno = EOPNOTSUPP;
402: return -1;
403: }
404:
405: static int handle_fsync(FsContext *ctx, int fid_type,
406: V9fsFidOpenState *fs, int datasync)
407: {
408: int fd;
409:
410: if (fid_type == P9_FID_DIR) {
411: fd = dirfd(fs->dir);
412: } else {
413: fd = fs->fd;
414: }
415:
416: if (datasync) {
417: return qemu_fdatasync(fd);
418: } else {
419: return fsync(fd);
420: }
421: }
422:
423: static int handle_statfs(FsContext *ctx, V9fsPath *fs_path,
424: struct statfs *stbuf)
425: {
426: int fd, ret;
427: struct handle_data *data = (struct handle_data *)ctx->private;
428:
429: fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
430: if (fd < 0) {
431: return fd;
432: }
433: ret = fstatfs(fd, stbuf);
434: close(fd);
435: return ret;
436: }
437:
438: static ssize_t handle_lgetxattr(FsContext *ctx, V9fsPath *fs_path,
439: const char *name, void *value, size_t size)
440: {
441: int fd, ret;
442: struct handle_data *data = (struct handle_data *)ctx->private;
443:
444: fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
445: if (fd < 0) {
446: return fd;
447: }
448: ret = fgetxattr(fd, name, value, size);
449: close(fd);
450: return ret;
451: }
452:
453: static ssize_t handle_llistxattr(FsContext *ctx, V9fsPath *fs_path,
454: void *value, size_t size)
455: {
456: int fd, ret;
457: struct handle_data *data = (struct handle_data *)ctx->private;
458:
459: fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
460: if (fd < 0) {
461: return fd;
462: }
463: ret = flistxattr(fd, value, size);
464: close(fd);
465: return ret;
466: }
467:
468: static int handle_lsetxattr(FsContext *ctx, V9fsPath *fs_path, const char *name,
469: void *value, size_t size, int flags)
470: {
471: int fd, ret;
472: struct handle_data *data = (struct handle_data *)ctx->private;
473:
474: fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
475: if (fd < 0) {
476: return fd;
477: }
478: ret = fsetxattr(fd, name, value, size, flags);
479: close(fd);
480: return ret;
481: }
482:
483: static int handle_lremovexattr(FsContext *ctx, V9fsPath *fs_path,
484: const char *name)
485: {
486: int fd, ret;
487: struct handle_data *data = (struct handle_data *)ctx->private;
488:
489: fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
490: if (fd < 0) {
491: return fd;
492: }
493: ret = fremovexattr(fd, name);
494: close(fd);
495: return ret;
496: }
497:
498: static int handle_name_to_path(FsContext *ctx, V9fsPath *dir_path,
499: const char *name, V9fsPath *target)
500: {
501: char buffer[PATH_MAX];
502: struct file_handle *fh;
503: int dirfd, ret, mnt_id;
504: struct handle_data *data = (struct handle_data *)ctx->private;
505:
506: /* "." and ".." are not allowed */
507: if (!strcmp(name, ".") || !strcmp(name, "..")) {
508: errno = EINVAL;
509: return -1;
510:
511: }
512: if (dir_path) {
513: dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH);
514: } else {
515: /* relative to export root */
516: dirfd = open(rpath(ctx, ".", buffer), O_DIRECTORY);
517: }
518: if (dirfd < 0) {
519: return dirfd;
520: }
521: fh = g_malloc(sizeof(struct file_handle) + data->handle_bytes);
522: fh->handle_bytes = data->handle_bytes;
523: /* add a "./" at the begining of the path */
524: snprintf(buffer, PATH_MAX, "./%s", name);
525: /* flag = 0 imply don't follow symlink */
526: ret = name_to_handle(dirfd, buffer, fh, &mnt_id, 0);
527: if (!ret) {
528: target->data = (char *)fh;
529: target->size = sizeof(struct file_handle) + data->handle_bytes;
530: } else {
531: g_free(fh);
532: }
533: close(dirfd);
534: return ret;
535: }
536:
537: static int handle_renameat(FsContext *ctx, V9fsPath *olddir,
538: const char *old_name, V9fsPath *newdir,
539: const char *new_name)
540: {
541: int olddirfd, newdirfd, ret;
542: struct handle_data *data = (struct handle_data *)ctx->private;
543:
544: olddirfd = open_by_handle(data->mountfd, olddir->data, O_PATH);
545: if (olddirfd < 0) {
546: return olddirfd;
547: }
548: newdirfd = open_by_handle(data->mountfd, newdir->data, O_PATH);
549: if (newdirfd < 0) {
550: close(olddirfd);
551: return newdirfd;
552: }
553: ret = renameat(olddirfd, old_name, newdirfd, new_name);
554: close(newdirfd);
555: close(olddirfd);
556: return ret;
557: }
558:
559: static int handle_unlinkat(FsContext *ctx, V9fsPath *dir,
560: const char *name, int flags)
561: {
562: int dirfd, ret;
563: struct handle_data *data = (struct handle_data *)ctx->private;
564: int rflags;
565:
566: dirfd = open_by_handle(data->mountfd, dir->data, O_PATH);
567: if (dirfd < 0) {
568: return dirfd;
569: }
570:
571: rflags = 0;
572: if (flags & P9_DOTL_AT_REMOVEDIR) {
573: rflags |= AT_REMOVEDIR;
574: }
575:
576: ret = unlinkat(dirfd, name, rflags);
577:
578: close(dirfd);
579: return ret;
580: }
581:
582: static int handle_ioc_getversion(FsContext *ctx, V9fsPath *path,
583: mode_t st_mode, uint64_t *st_gen)
584: {
585: int err;
586: V9fsFidOpenState fid_open;
587:
588: /*
589: * Do not try to open special files like device nodes, fifos etc
590: * We can get fd for regular files and directories only
591: */
592: if (!S_ISREG(st_mode) && !S_ISDIR(st_mode)) {
593: return 0;
594: }
595: err = handle_open(ctx, path, O_RDONLY, &fid_open);
596: if (err < 0) {
597: return err;
598: }
599: err = ioctl(fid_open.fd, FS_IOC_GETVERSION, st_gen);
600: handle_close(ctx, &fid_open);
601: return err;
602: }
603:
604: static int handle_init(FsContext *ctx)
605: {
606: int ret, mnt_id;
607: struct statfs stbuf;
608: struct file_handle fh;
609: struct handle_data *data = g_malloc(sizeof(struct handle_data));
610:
611: data->mountfd = open(ctx->fs_root, O_DIRECTORY);
612: if (data->mountfd < 0) {
613: ret = data->mountfd;
614: goto err_out;
615: }
616: ret = statfs(ctx->fs_root, &stbuf);
617: if (!ret) {
618: switch (stbuf.f_type) {
619: case EXT2_SUPER_MAGIC:
620: case BTRFS_SUPER_MAGIC:
621: case REISERFS_SUPER_MAGIC:
622: case XFS_SUPER_MAGIC:
623: ctx->exops.get_st_gen = handle_ioc_getversion;
624: break;
625: }
626: }
627: memset(&fh, 0, sizeof(struct file_handle));
628: ret = name_to_handle(data->mountfd, ".", &fh, &mnt_id, 0);
629: if (ret && errno == EOVERFLOW) {
630: data->handle_bytes = fh.handle_bytes;
631: ctx->private = data;
632: ret = 0;
633: goto out;
634: }
635: /* we got 0 byte handle ? */
636: ret = -1;
637: close(data->mountfd);
638: err_out:
639: g_free(data);
640: out:
641: return ret;
642: }
643:
644: FileOperations handle_ops = {
645: .init = handle_init,
646: .lstat = handle_lstat,
647: .readlink = handle_readlink,
648: .close = handle_close,
649: .closedir = handle_closedir,
650: .open = handle_open,
651: .opendir = handle_opendir,
652: .rewinddir = handle_rewinddir,
653: .telldir = handle_telldir,
654: .readdir_r = handle_readdir_r,
655: .seekdir = handle_seekdir,
656: .preadv = handle_preadv,
657: .pwritev = handle_pwritev,
658: .chmod = handle_chmod,
659: .mknod = handle_mknod,
660: .mkdir = handle_mkdir,
661: .fstat = handle_fstat,
662: .open2 = handle_open2,
663: .symlink = handle_symlink,
664: .link = handle_link,
665: .truncate = handle_truncate,
666: .rename = handle_rename,
667: .chown = handle_chown,
668: .utimensat = handle_utimensat,
669: .remove = handle_remove,
670: .fsync = handle_fsync,
671: .statfs = handle_statfs,
672: .lgetxattr = handle_lgetxattr,
673: .llistxattr = handle_llistxattr,
674: .lsetxattr = handle_lsetxattr,
675: .lremovexattr = handle_lremovexattr,
676: .name_to_path = handle_name_to_path,
677: .renameat = handle_renameat,
678: .unlinkat = handle_unlinkat,
679: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.