![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to virtio-9p-local.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-local.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / hw / 9pfs |
1.1 root 1: /*
2: * Virtio 9p Posix callback
3: *
4: * Copyright IBM, Corp. 2010
5: *
6: * Authors:
7: * Anthony Liguori <[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 <attr/xattr.h>
23:
24:
25: static int local_lstat(FsContext *fs_ctx, const char *path, struct stat *stbuf)
26: {
27: int err;
28: char buffer[PATH_MAX];
29: err = lstat(rpath(fs_ctx, path, buffer), stbuf);
30: if (err) {
31: return err;
32: }
33: if (fs_ctx->fs_sm == SM_MAPPED) {
34: /* Actual credentials are part of extended attrs */
35: uid_t tmp_uid;
36: gid_t tmp_gid;
37: mode_t tmp_mode;
38: dev_t tmp_dev;
39: if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.uid", &tmp_uid,
40: sizeof(uid_t)) > 0) {
41: stbuf->st_uid = tmp_uid;
42: }
43: if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.gid", &tmp_gid,
44: sizeof(gid_t)) > 0) {
45: stbuf->st_gid = tmp_gid;
46: }
47: if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.mode",
48: &tmp_mode, sizeof(mode_t)) > 0) {
49: stbuf->st_mode = tmp_mode;
50: }
51: if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.rdev", &tmp_dev,
52: sizeof(dev_t)) > 0) {
53: stbuf->st_rdev = tmp_dev;
54: }
55: }
56: return err;
57: }
58:
59: static int local_set_xattr(const char *path, FsCred *credp)
60: {
61: int err;
62: if (credp->fc_uid != -1) {
63: err = setxattr(path, "user.virtfs.uid", &credp->fc_uid, sizeof(uid_t),
64: 0);
65: if (err) {
66: return err;
67: }
68: }
69: if (credp->fc_gid != -1) {
70: err = setxattr(path, "user.virtfs.gid", &credp->fc_gid, sizeof(gid_t),
71: 0);
72: if (err) {
73: return err;
74: }
75: }
76: if (credp->fc_mode != -1) {
77: err = setxattr(path, "user.virtfs.mode", &credp->fc_mode,
78: sizeof(mode_t), 0);
79: if (err) {
80: return err;
81: }
82: }
83: if (credp->fc_rdev != -1) {
84: err = setxattr(path, "user.virtfs.rdev", &credp->fc_rdev,
85: sizeof(dev_t), 0);
86: if (err) {
87: return err;
88: }
89: }
90: return 0;
91: }
92:
93: static int local_post_create_passthrough(FsContext *fs_ctx, const char *path,
94: FsCred *credp)
95: {
96: char buffer[PATH_MAX];
97: if (chmod(rpath(fs_ctx, path, buffer), credp->fc_mode & 07777) < 0) {
98: return -1;
99: }
100: if (lchown(rpath(fs_ctx, path, buffer), credp->fc_uid,
101: credp->fc_gid) < 0) {
102: /*
103: * If we fail to change ownership and if we are
104: * using security model none. Ignore the error
105: */
106: if (fs_ctx->fs_sm != SM_NONE) {
107: return -1;
108: }
109: }
110: return 0;
111: }
112:
113: static ssize_t local_readlink(FsContext *fs_ctx, const char *path,
114: char *buf, size_t bufsz)
115: {
116: ssize_t tsize = -1;
117: char buffer[PATH_MAX];
118: if (fs_ctx->fs_sm == SM_MAPPED) {
119: int fd;
120: fd = open(rpath(fs_ctx, path, buffer), O_RDONLY);
121: if (fd == -1) {
122: return -1;
123: }
124: do {
125: tsize = read(fd, (void *)buf, bufsz);
126: } while (tsize == -1 && errno == EINTR);
127: close(fd);
128: return tsize;
129: } else if ((fs_ctx->fs_sm == SM_PASSTHROUGH) ||
130: (fs_ctx->fs_sm == SM_NONE)) {
131: tsize = readlink(rpath(fs_ctx, path, buffer), buf, bufsz);
132: }
133: return tsize;
134: }
135:
136: static int local_close(FsContext *ctx, int fd)
137: {
138: return close(fd);
139: }
140:
141: static int local_closedir(FsContext *ctx, DIR *dir)
142: {
143: return closedir(dir);
144: }
145:
146: static int local_open(FsContext *ctx, const char *path, int flags)
147: {
148: char buffer[PATH_MAX];
149: return open(rpath(ctx, path, buffer), flags);
150: }
151:
152: static DIR *local_opendir(FsContext *ctx, const char *path)
153: {
154: char buffer[PATH_MAX];
155: return opendir(rpath(ctx, path, buffer));
156: }
157:
158: static void local_rewinddir(FsContext *ctx, DIR *dir)
159: {
160: return rewinddir(dir);
161: }
162:
163: static off_t local_telldir(FsContext *ctx, DIR *dir)
164: {
165: return telldir(dir);
166: }
167:
168: static struct dirent *local_readdir(FsContext *ctx, DIR *dir)
169: {
170: return readdir(dir);
171: }
172:
173: static void local_seekdir(FsContext *ctx, DIR *dir, off_t off)
174: {
175: return seekdir(dir, off);
176: }
177:
178: static ssize_t local_preadv(FsContext *ctx, int fd, const struct iovec *iov,
179: int iovcnt, off_t offset)
180: {
181: #ifdef CONFIG_PREADV
182: return preadv(fd, iov, iovcnt, offset);
183: #else
184: int err = lseek(fd, offset, SEEK_SET);
185: if (err == -1) {
186: return err;
187: } else {
188: return readv(fd, iov, iovcnt);
189: }
190: #endif
191: }
192:
193: static ssize_t local_pwritev(FsContext *ctx, int fd, const struct iovec *iov,
194: int iovcnt, off_t offset)
195: {
196: #ifdef CONFIG_PREADV
197: return pwritev(fd, iov, iovcnt, offset);
198: #else
199: int err = lseek(fd, offset, SEEK_SET);
200: if (err == -1) {
201: return err;
202: } else {
203: return writev(fd, iov, iovcnt);
204: }
205: #endif
206: }
207:
208: static int local_chmod(FsContext *fs_ctx, const char *path, FsCred *credp)
209: {
210: char buffer[PATH_MAX];
211: if (fs_ctx->fs_sm == SM_MAPPED) {
212: return local_set_xattr(rpath(fs_ctx, path, buffer), credp);
213: } else if ((fs_ctx->fs_sm == SM_PASSTHROUGH) ||
214: (fs_ctx->fs_sm == SM_NONE)) {
215: return chmod(rpath(fs_ctx, path, buffer), credp->fc_mode);
216: }
217: return -1;
218: }
219:
220: static int local_mknod(FsContext *fs_ctx, const char *path, FsCred *credp)
221: {
222: int err = -1;
223: int serrno = 0;
224: char buffer[PATH_MAX];
225:
226: /* Determine the security model */
227: if (fs_ctx->fs_sm == SM_MAPPED) {
228: err = mknod(rpath(fs_ctx, path, buffer),
229: SM_LOCAL_MODE_BITS|S_IFREG, 0);
230: if (err == -1) {
231: return err;
232: }
233: local_set_xattr(rpath(fs_ctx, path, buffer), credp);
234: if (err == -1) {
235: serrno = errno;
236: goto err_end;
237: }
238: } else if ((fs_ctx->fs_sm == SM_PASSTHROUGH) ||
239: (fs_ctx->fs_sm == SM_NONE)) {
240: err = mknod(rpath(fs_ctx, path, buffer), credp->fc_mode,
241: credp->fc_rdev);
242: if (err == -1) {
243: return err;
244: }
245: err = local_post_create_passthrough(fs_ctx, path, credp);
246: if (err == -1) {
247: serrno = errno;
248: goto err_end;
249: }
250: }
251: return err;
252:
253: err_end:
254: remove(rpath(fs_ctx, path, buffer));
255: errno = serrno;
256: return err;
257: }
258:
259: static int local_mkdir(FsContext *fs_ctx, const char *path, FsCred *credp)
260: {
261: int err = -1;
262: int serrno = 0;
263: char buffer[PATH_MAX];
264:
265: /* Determine the security model */
266: if (fs_ctx->fs_sm == SM_MAPPED) {
267: err = mkdir(rpath(fs_ctx, path, buffer), SM_LOCAL_DIR_MODE_BITS);
268: if (err == -1) {
269: return err;
270: }
271: credp->fc_mode = credp->fc_mode|S_IFDIR;
272: err = local_set_xattr(rpath(fs_ctx, path, buffer), credp);
273: if (err == -1) {
274: serrno = errno;
275: goto err_end;
276: }
277: } else if ((fs_ctx->fs_sm == SM_PASSTHROUGH) ||
278: (fs_ctx->fs_sm == SM_NONE)) {
279: err = mkdir(rpath(fs_ctx, path, buffer), credp->fc_mode);
280: if (err == -1) {
281: return err;
282: }
283: err = local_post_create_passthrough(fs_ctx, path, credp);
284: if (err == -1) {
285: serrno = errno;
286: goto err_end;
287: }
288: }
289: return err;
290:
291: err_end:
292: remove(rpath(fs_ctx, path, buffer));
293: errno = serrno;
294: return err;
295: }
296:
297: static int local_fstat(FsContext *fs_ctx, int fd, struct stat *stbuf)
298: {
299: int err;
300: err = fstat(fd, stbuf);
301: if (err) {
302: return err;
303: }
304: if (fs_ctx->fs_sm == SM_MAPPED) {
305: /* Actual credentials are part of extended attrs */
306: uid_t tmp_uid;
307: gid_t tmp_gid;
308: mode_t tmp_mode;
309: dev_t tmp_dev;
310:
311: if (fgetxattr(fd, "user.virtfs.uid", &tmp_uid, sizeof(uid_t)) > 0) {
312: stbuf->st_uid = tmp_uid;
313: }
314: if (fgetxattr(fd, "user.virtfs.gid", &tmp_gid, sizeof(gid_t)) > 0) {
315: stbuf->st_gid = tmp_gid;
316: }
317: if (fgetxattr(fd, "user.virtfs.mode", &tmp_mode, sizeof(mode_t)) > 0) {
318: stbuf->st_mode = tmp_mode;
319: }
320: if (fgetxattr(fd, "user.virtfs.rdev", &tmp_dev, sizeof(dev_t)) > 0) {
321: stbuf->st_rdev = tmp_dev;
322: }
323: }
324: return err;
325: }
326:
327: static int local_open2(FsContext *fs_ctx, const char *path, int flags,
328: FsCred *credp)
329: {
330: int fd = -1;
331: int err = -1;
332: int serrno = 0;
333: char buffer[PATH_MAX];
334:
335: /* Determine the security model */
336: if (fs_ctx->fs_sm == SM_MAPPED) {
337: fd = open(rpath(fs_ctx, path, buffer), flags, SM_LOCAL_MODE_BITS);
338: if (fd == -1) {
339: return fd;
340: }
341: credp->fc_mode = credp->fc_mode|S_IFREG;
342: /* Set cleint credentials in xattr */
343: err = local_set_xattr(rpath(fs_ctx, path, buffer), credp);
344: if (err == -1) {
345: serrno = errno;
346: goto err_end;
347: }
348: } else if ((fs_ctx->fs_sm == SM_PASSTHROUGH) ||
349: (fs_ctx->fs_sm == SM_NONE)) {
350: fd = open(rpath(fs_ctx, path, buffer), flags, credp->fc_mode);
351: if (fd == -1) {
352: return fd;
353: }
354: err = local_post_create_passthrough(fs_ctx, path, credp);
355: if (err == -1) {
356: serrno = errno;
357: goto err_end;
358: }
359: }
360: return fd;
361:
362: err_end:
363: close(fd);
364: remove(rpath(fs_ctx, path, buffer));
365: errno = serrno;
366: return err;
367: }
368:
369:
370: static int local_symlink(FsContext *fs_ctx, const char *oldpath,
371: const char *newpath, FsCred *credp)
372: {
373: int err = -1;
374: int serrno = 0;
375: char buffer[PATH_MAX];
376:
377: /* Determine the security model */
378: if (fs_ctx->fs_sm == SM_MAPPED) {
379: int fd;
380: ssize_t oldpath_size, write_size;
381: fd = open(rpath(fs_ctx, newpath, buffer), O_CREAT|O_EXCL|O_RDWR,
382: SM_LOCAL_MODE_BITS);
383: if (fd == -1) {
384: return fd;
385: }
386: /* Write the oldpath (target) to the file. */
387: oldpath_size = strlen(oldpath);
388: do {
389: write_size = write(fd, (void *)oldpath, oldpath_size);
390: } while (write_size == -1 && errno == EINTR);
391:
392: if (write_size != oldpath_size) {
393: serrno = errno;
394: close(fd);
395: err = -1;
396: goto err_end;
397: }
398: close(fd);
399: /* Set cleint credentials in symlink's xattr */
400: credp->fc_mode = credp->fc_mode|S_IFLNK;
401: err = local_set_xattr(rpath(fs_ctx, newpath, buffer), credp);
402: if (err == -1) {
403: serrno = errno;
404: goto err_end;
405: }
406: } else if ((fs_ctx->fs_sm == SM_PASSTHROUGH) ||
407: (fs_ctx->fs_sm == SM_NONE)) {
408: err = symlink(oldpath, rpath(fs_ctx, newpath, buffer));
409: if (err) {
410: return err;
411: }
412: err = lchown(rpath(fs_ctx, newpath, buffer), credp->fc_uid,
413: credp->fc_gid);
414: if (err == -1) {
415: /*
416: * If we fail to change ownership and if we are
417: * using security model none. Ignore the error
418: */
419: if (fs_ctx->fs_sm != SM_NONE) {
420: serrno = errno;
421: goto err_end;
422: } else
423: err = 0;
424: }
425: }
426: return err;
427:
428: err_end:
429: remove(rpath(fs_ctx, newpath, buffer));
430: errno = serrno;
431: return err;
432: }
433:
434: static int local_link(FsContext *ctx, const char *oldpath, const char *newpath)
435: {
436: char buffer[PATH_MAX], buffer1[PATH_MAX];
437:
438: return link(rpath(ctx, oldpath, buffer), rpath(ctx, newpath, buffer1));
439: }
440:
441: static int local_truncate(FsContext *ctx, const char *path, off_t size)
442: {
443: char buffer[PATH_MAX];
444: return truncate(rpath(ctx, path, buffer), size);
445: }
446:
447: static int local_rename(FsContext *ctx, const char *oldpath,
448: const char *newpath)
449: {
450: char buffer[PATH_MAX], buffer1[PATH_MAX];
451:
452: return rename(rpath(ctx, oldpath, buffer), rpath(ctx, newpath, buffer1));
453: }
454:
455: static int local_chown(FsContext *fs_ctx, const char *path, FsCred *credp)
456: {
457: char buffer[PATH_MAX];
458: if ((credp->fc_uid == -1 && credp->fc_gid == -1) ||
459: (fs_ctx->fs_sm == SM_PASSTHROUGH)) {
460: return lchown(rpath(fs_ctx, path, buffer), credp->fc_uid,
461: credp->fc_gid);
462: } else if (fs_ctx->fs_sm == SM_MAPPED) {
463: return local_set_xattr(rpath(fs_ctx, path, buffer), credp);
464: } else if ((fs_ctx->fs_sm == SM_PASSTHROUGH) ||
465: (fs_ctx->fs_sm == SM_NONE)) {
466: return lchown(rpath(fs_ctx, path, buffer), credp->fc_uid,
467: credp->fc_gid);
468: }
469: return -1;
470: }
471:
472: static int local_utimensat(FsContext *s, const char *path,
473: const struct timespec *buf)
474: {
475: char buffer[PATH_MAX];
476: return qemu_utimensat(AT_FDCWD, rpath(s, path, buffer), buf,
477: AT_SYMLINK_NOFOLLOW);
478: }
479:
480: static int local_remove(FsContext *ctx, const char *path)
481: {
482: char buffer[PATH_MAX];
483: return remove(rpath(ctx, path, buffer));
484: }
485:
486: static int local_fsync(FsContext *ctx, int fd, int datasync)
487: {
488: if (datasync) {
489: return qemu_fdatasync(fd);
490: } else {
491: return fsync(fd);
492: }
493: }
494:
495: static int local_statfs(FsContext *s, const char *path, struct statfs *stbuf)
496: {
497: char buffer[PATH_MAX];
498: return statfs(rpath(s, path, buffer), stbuf);
499: }
500:
501: static ssize_t local_lgetxattr(FsContext *ctx, const char *path,
502: const char *name, void *value, size_t size)
503: {
504: return v9fs_get_xattr(ctx, path, name, value, size);
505: }
506:
507: static ssize_t local_llistxattr(FsContext *ctx, const char *path,
508: void *value, size_t size)
509: {
510: return v9fs_list_xattr(ctx, path, value, size);
511: }
512:
513: static int local_lsetxattr(FsContext *ctx, const char *path, const char *name,
514: void *value, size_t size, int flags)
515: {
516: return v9fs_set_xattr(ctx, path, name, value, size, flags);
517: }
518:
519: static int local_lremovexattr(FsContext *ctx,
520: const char *path, const char *name)
521: {
522: return v9fs_remove_xattr(ctx, path, name);
523: }
524:
525:
526: FileOperations local_ops = {
527: .lstat = local_lstat,
528: .readlink = local_readlink,
529: .close = local_close,
530: .closedir = local_closedir,
531: .open = local_open,
532: .opendir = local_opendir,
533: .rewinddir = local_rewinddir,
534: .telldir = local_telldir,
535: .readdir = local_readdir,
536: .seekdir = local_seekdir,
537: .preadv = local_preadv,
538: .pwritev = local_pwritev,
539: .chmod = local_chmod,
540: .mknod = local_mknod,
541: .mkdir = local_mkdir,
542: .fstat = local_fstat,
543: .open2 = local_open2,
544: .symlink = local_symlink,
545: .link = local_link,
546: .truncate = local_truncate,
547: .rename = local_rename,
548: .chown = local_chown,
549: .utimensat = local_utimensat,
550: .remove = local_remove,
551: .fsync = local_fsync,
552: .statfs = local_statfs,
553: .lgetxattr = local_lgetxattr,
554: .llistxattr = local_llistxattr,
555: .lsetxattr = local_lsetxattr,
556: .lremovexattr = local_lremovexattr,
557: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.