Prex Home / Browse Source - Prex Version: 0.9.0

root/usr/server/fs/vfs/main.c

DEFINITIONS

1. fs_mount
2. fs_umount
3. fs_sync
4. fs_open
5. fs_close
6. fs_mknod
7. fs_lseek
8. fs_read
9. fs_write
10. fs_ioctl
11. fs_fsync
12. fs_fstat
13. fs_opendir
14. fs_closedir
15. fs_readdir
16. fs_rewinddir
17. fs_seekdir
18. fs_telldir
19. fs_mkdir
20. fs_rmdir
21. fs_rename
22. fs_chdir
23. fs_fchdir
24. fs_link
25. fs_unlink
26. fs_stat
27. fs_getcwd
28. fs_dup
29. fs_dup2
30. fs_fcntl
31. fs_access
32. fs_fork
33. fs_exec
34. fs_exit
35. fs_register
36. fs_pipe
37. fs_isatty
38. fs_truncate
39. fs_ftruncate
40. fs_boot
41. fs_shutdown
42. fs_noop
43. fs_debug
44. vfs_init
45. run_thread
46. exception_handler
47. fs_thread
48. main

   1 /*
   2  * Copyright (c) 2005-2007, Kohsuke Ohtani
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the author nor the names of any co-contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  30 /*
  31  * main.c - File system server
  32  */
  34 /*
  35  * All file systems work as a sub-modules under VFS (Virtual File System).
  36  * The routines in this file have the responsible to the following jobs.
  37  *
  38  *  - Interpret the IPC message and pass the request into VFS routines.
  39  *  - Validate the some of passed arguments in the message.
  40  *  - Mapping of the task ID and cwd/file pointers.
  41  *
  42  * Note: All path string is translated to the full path before passing
  43  * it to the sys_* routines.
  44  */
  46 #include <sys/prex.h>
  47 #include <sys/capability.h>
  48 #include <sys/param.h>
  49 #include <ipc/fs.h>
  50 #include <ipc/proc.h>
  51 #include <ipc/exec.h>
  52 #include <ipc/ipc.h>
  53 #include <sys/list.h>
  54 #include <sys/stat.h>
  55 #include <sys/vnode.h>
  56 #include <sys/mount.h>
  57 #include <sys/buf.h>
  58 #include <sys/file.h>
  60 #include <limits.h>
  61 #include <unistd.h>
  62 #include <stdio.h>
  63 #include <stdlib.h>
  64 #include <string.h>
  65 #include <errno.h>
  66 #include <fcntl.h>
  67 #include <signal.h>
  69 #include "vfs.h"
  71 #ifdef DEBUG_VFS
  72 int     vfs_debug = VFSDB_FLAGS;
  73 #endif
  75 /*
  76  * Message mapping
  77  */
  78 struct msg_map {
  79         int     code;
  80         int     (*func)(struct task *, struct msg *);
  81 };
  83 #define MSGMAP(code, fn) {code, (int (*)(struct task *, struct msg *))fn}
  85 /* object for file service */
  86 static object_t fsobj;
  88 static int
fs_mount(struct task *t, struct mount_msg *msg)
  90 {
  91         int error = 0;
  93         /* Check client's mount capability. */
  94         if (task_chkcap(t->t_taskid, CAP_DISKADMIN) != 0)
error = EPERM;
  97         if (error == 0) {
error = sys_mount(msg->dev, msg->dir, msg->fs, msg->flags,
  99                                 (void *)msg->data);
 100         }
 101 #ifdef DEBUG
 102         if (error)
dprintf("VFS: mount failed!\n");
 104 #endif
 105         return error;
 106 }
 108 static int
fs_umount(struct task *t, struct path_msg *msg)
 110 {
 112         /* Check mount capability. */
 113         if (task_chkcap(t->t_taskid, CAP_DISKADMIN) != 0)
 114                 return EPERM;
 116         return sys_umount(msg->path);
 117 }
 119 static int
fs_sync(struct task *t, struct msg *msg)
 121 {
 123         return sys_sync();
 124 }
 126 static int
fs_open(struct task *t, struct open_msg *msg)
 128 {
 129         char path[PATH_MAX];
file_t fp;
 131         int fd, error;
 132         int acc;
 134         /* Find empty slot for file descriptor. */
 135         if ((fd = task_newfd(t)) == -1)
 136                 return EMFILE;
acc = 0;
 139         switch (msg->flags & O_ACCMODE) {
 140         case O_RDONLY:
acc = VREAD;
 142                 break;
 143         case O_WRONLY:
acc = VWRITE;
 145                 break;
 146         case O_RDWR:
acc = VREAD | VWRITE;
 148                 break;
 149         }
 150         if ((error = task_conv(t, msg->path, acc, path)) != 0)
 151                 return error;
 153         if ((error = sys_open(path, msg->flags, msg->mode, &fp)) != 0)
 154                 return error;
t->t_ofile[fd] = fp;
t->t_nopens++;
msg->fd = fd;
 159         return 0;
 160 }
 162 static int
fs_close(struct task *t, struct msg *msg)
 164 {
file_t fp;
 166         int fd, error;
fd = msg->data[0];
 169         if (fd >= OPEN_MAX)
 170                 return EBADF;
fp = t->t_ofile[fd];
 173         if (fp == NULL)
 174                 return EBADF;
 176         if ((error = sys_close(fp)) != 0)
 177                 return error;
t->t_ofile[fd] = NULL;
t->t_nopens--;
 181         return 0;
 182 }
 184 static int
fs_mknod(struct task *t, struct open_msg *msg)
 186 {
 187         char path[PATH_MAX];
 188         int error;
 190         if ((error = task_conv(t, msg->path, VWRITE, path)) != 0)
 191                 return error;
 193         return sys_mknod(path, msg->mode);
 194 }
 196 static int
fs_lseek(struct task *t, struct msg *msg)
 198 {
file_t fp;
off_t offset, org;
 201         int error, type;
 203         if ((fp = task_getfp(t, msg->data[0])) == NULL)
 204                 return EBADF;
offset = (off_t)msg->data[1];
type = msg->data[2];
error = sys_lseek(fp, offset, type, &org);
msg->data[0] = (int)org;
 210         return error;
 211 }
 213 static int
fs_read(struct task *t, struct io_msg *msg)
 215 {
file_t fp;
 217         void *buf;
size_t size, bytes;
 219         int error;
 221         if ((fp = task_getfp(t, msg->fd)) == NULL)
 222                 return EBADF;
size = msg->size;
 224         if ((error = vm_map(msg->hdr.task, msg->buf, size, &buf)) != 0)
 225                 return EFAULT;
error = sys_read(fp, buf, size, &bytes);
msg->size = bytes;
vm_free(task_self(), buf);
 230         return error;
 231 }
 233 static int
fs_write(struct task *t, struct io_msg *msg)
 235 {
file_t fp;
 237         void *buf;
size_t size, bytes;
 239         int error;
 241         if ((fp = task_getfp(t, msg->fd)) == NULL)
 242                 return EBADF;
size = msg->size;
 244         if ((error = vm_map(msg->hdr.task, msg->buf, size, &buf)) != 0)
 245                 return EFAULT;
error = sys_write(fp, buf, size, &bytes);
msg->size = bytes;
vm_free(task_self(), buf);
 250         return error;
 251 }
 253 static int
fs_ioctl(struct task *t, struct ioctl_msg *msg)
 255 {
file_t fp;
 258         if ((fp = task_getfp(t, msg->fd)) == NULL)
 259                 return EBADF;
 261         return sys_ioctl(fp, msg->request, msg->buf);
 262 }
 264 static int
fs_fsync(struct task *t, struct msg *msg)
 266 {
file_t fp;
 269         if ((fp = task_getfp(t, msg->data[0])) == NULL)
 270                 return EBADF;
 272         return sys_fsync(fp);
 273 }
 275 static int
fs_fstat(struct task *t, struct stat_msg *msg)
 277 {
file_t fp;
 279         struct stat *st;
 280         int error;
 282         if ((fp = task_getfp(t, msg->fd)) == NULL)
 283                 return EBADF;
st = &msg->st;
error = sys_fstat(fp, st);
 287         return error;
 288 }
 290 static int
fs_opendir(struct task *t, struct open_msg *msg)
 292 {
 293         char path[PATH_MAX];
file_t fp;
 295         int fd, error;
 297         /* Find empty slot for file descriptor. */
 298         if ((fd = task_newfd(t)) == -1)
 299                 return EMFILE;
 301         /* Get the mounted file system and node */
 302         if ((error = task_conv(t, msg->path, VREAD, path)) != 0)
 303                 return error;
 305         if ((error = sys_opendir(path, &fp)) != 0)
 306                 return error;
t->t_ofile[fd] = fp;
msg->fd = fd;
 309         return 0;
 310 }
 312 static int
fs_closedir(struct task *t, struct msg *msg)
 314 {
file_t fp;
 316         int fd, error;
fd = msg->data[0];
 319         if (fd >= OPEN_MAX)
 320                 return EBADF;
fp = t->t_ofile[fd];
 322         if (fp == NULL)
 323                 return EBADF;
 325         if ((error = sys_closedir(fp)) != 0)
 326                 return error;
t->t_ofile[fd] = NULL;
 328         return 0;
 329 }
 331 static int
fs_readdir(struct task *t, struct dir_msg *msg)
 333 {
file_t fp;
 336         if ((fp = task_getfp(t, msg->fd)) == NULL)
 337                 return EBADF;
 339         return sys_readdir(fp, &msg->dirent);
 340 }
 342 static int
fs_rewinddir(struct task *t, struct msg *msg)
 344 {
file_t fp;
 347         if ((fp = task_getfp(t, msg->data[0])) == NULL)
 348                 return EBADF;
 350         return sys_rewinddir(fp);
 351 }
 353 static int
fs_seekdir(struct task *t, struct msg *msg)
 355 {
file_t fp;
 357         long loc;
 359         if ((fp = task_getfp(t, msg->data[0])) == NULL)
 360                 return EBADF;
loc = msg->data[1];
 363         return sys_seekdir(fp, loc);
 364 }
 366 static int
fs_telldir(struct task *t, struct msg *msg)
 368 {
file_t fp;
 370         long loc;
 371         int error;
 373         if ((fp = task_getfp(t, msg->data[0])) == NULL)
 374                 return EBADF;
loc = msg->data[1];
 377         if ((error = sys_telldir(fp, &loc)) != 0)
 378                 return error;
msg->data[0] = loc;
 380         return 0;
 381 }
 383 static int
fs_mkdir(struct task *t, struct open_msg *msg)
 385 {
 386         char path[PATH_MAX];
 387         int error;
 389         if ((error = task_conv(t, msg->path, VWRITE, path)) != 0)
 390                 return error;
 392         return sys_mkdir(path, msg->mode);
 393 }
 395 static int
fs_rmdir(struct task *t, struct path_msg *msg)
 397 {
 398         char path[PATH_MAX];
 399         int error;
 401         if (msg->path == NULL)
 402                 return ENOENT;
 403         if ((error = task_conv(t, msg->path, VWRITE, path)) != 0)
 404                 return error;
 406         return sys_rmdir(path);
 407 }
 409 static int
fs_rename(struct task *t, struct path_msg *msg)
 411 {
 412         char src[PATH_MAX];
 413         char dest[PATH_MAX];
 414         int error;
 416         if (msg->path == NULL || msg->path2 == NULL)
 417                 return ENOENT;
 419         if ((error = task_conv(t, msg->path, VREAD, src)) != 0)
 420                 return error;
 422         if ((error = task_conv(t, msg->path2, VWRITE, dest)) != 0)
 423                 return error;
 425         return sys_rename(src, dest);
 426 }
 428 static int
fs_chdir(struct task *t, struct path_msg *msg)
 430 {
 431         char path[PATH_MAX];
file_t fp;
 433         int error;
 435         if (msg->path == NULL)
 436                 return ENOENT;
 437         if ((error = task_conv(t, msg->path, VREAD, path)) != 0)
 438                 return error;
 440         /* Check if directory exits */
 441         if ((error = sys_opendir(path, &fp)) != 0)
 442                 return error;
 443         if (t->t_cwdfp)
sys_closedir(t->t_cwdfp);
t->t_cwdfp = fp;
strlcpy(t->t_cwd, path, sizeof(t->t_cwd));
 447         return 0;
 448 }
 450 static int
fs_fchdir(struct task *t, struct msg *msg)
 452 {
file_t fp;
 454         int fd;
fd = msg->data[0];
 457         if ((fp = task_getfp(t, fd)) == NULL)
 458                 return EBADF;
 460         if (t->t_cwdfp)
sys_closedir(t->t_cwdfp);
t->t_cwdfp = fp;
 463         return sys_fchdir(fp, t->t_cwd);
 464 }
 466 static int
fs_link(struct task *t, struct msg *msg)
 468 {
 469         /* XXX */
 470         return EPERM;
 471 }
 473 static int
fs_unlink(struct task *t, struct path_msg *msg)
 475 {
 476         char path[PATH_MAX];
 477         int error;
 479         if (msg->path == NULL)
 480                 return ENOENT;
 481         if ((error = task_conv(t, msg->path, VWRITE, path)) != 0)
 482                 return error;
 484         return sys_unlink(path);
 485 }
 487 static int
fs_stat(struct task *t, struct stat_msg *msg)
 489 {
 490         char path[PATH_MAX];
 491         struct stat *st;
 492         int error;
error = task_conv(t, msg->path, 0, path);
 495         if (error == 0) {
st = &msg->st;
error = sys_stat(path, st);
 498         }
 499         return error;
 500 }
 502 static int
fs_getcwd(struct task *t, struct path_msg *msg)
 504 {
strlcpy(msg->path, t->t_cwd, sizeof(msg->path));
 507         return 0;
 508 }
 510 /*
 511  * Duplicate a file descriptor
 512  */
 513 static int
fs_dup(struct task *t, struct msg *msg)
 515 {
file_t fp;
 517         int old_fd, new_fd;
old_fd = msg->data[0];
 520         if ((fp = task_getfp(t, old_fd)) == NULL)
 521                 return EBADF;
 523         /* Find smallest empty slot as new fd. */
 524         if ((new_fd = task_newfd(t)) == -1)
 525                 return EMFILE;
t->t_ofile[new_fd] = fp;
 529         /* Increment file reference */
vref(fp->f_vnode);
fp->f_count++;
msg->data[0] = new_fd;
 534         return 0;
 535 }
 537 /*
 538  * Duplicate a file descriptor to a particular value.
 539  */
 540 static int
fs_dup2(struct task *t, struct msg *msg)
 542 {
file_t fp, org;
 544         int old_fd, new_fd;
 545         int error;
old_fd = msg->data[0];
new_fd = msg->data[1];
 549         if (old_fd >= OPEN_MAX || new_fd >= OPEN_MAX)
 550                 return EBADF;
fp = t->t_ofile[old_fd];
 552         if (fp == NULL)
 553                 return EBADF;
org = t->t_ofile[new_fd];
 555         if (org != NULL) {
 556                 /* Close previous file if it's opened. */
error = sys_close(org);
 558         }
t->t_ofile[new_fd] = fp;
 561         /* Increment file reference */
vref(fp->f_vnode);
fp->f_count++;
msg->data[0] = new_fd;
 566         return 0;
 567 }
 569 /*
 570  * The file control system call.
 571  */
 572 static int
fs_fcntl(struct task *t, struct fcntl_msg *msg)
 574 {
file_t fp;
 576         int arg, new_fd;
 578         if ((fp = task_getfp(t, msg->fd)) == NULL)
 579                 return EBADF;
arg = msg->arg;
 582         switch (msg->cmd) {
 583         case F_DUPFD:
 584                 if (arg >= OPEN_MAX)
 585                         return EINVAL;
 586                 /* Find smallest empty slot as new fd. */
 587                 if ((new_fd = task_newfd(t)) == -1)
 588                         return EMFILE;
t->t_ofile[new_fd] = fp;
 591                 /* Increment file reference */
vref(fp->f_vnode);
fp->f_count++;
msg->arg = new_fd;
 595                 break;
 596         case F_GETFD:
msg->arg = fp->f_flags & FD_CLOEXEC;
 598                 break;
 599         case F_SETFD:
fp->f_flags = (fp->f_flags & ~FD_CLOEXEC) |
 601                         (msg->arg & FD_CLOEXEC);
msg->arg = 0;
 603                 break;
 604         case F_GETFL:
 605         case F_SETFL:
msg->arg = -1;
 607                 break;
 608         default:
msg->arg = -1;
 610                 break;
 611         }
 612         return 0;
 613 }
 615 /*
 616  * Check permission for file access
 617  */
 618 static int
fs_access(struct task *t, struct path_msg *msg)
 620 {
 621         char path[PATH_MAX];
 622         int acc, mode, error = 0;
mode = msg->data[0];
acc = 0;
 626         if (mode & R_OK)
acc |= VREAD;
 628         if (mode & W_OK)
acc |= VWRITE;
 631         if ((error = task_conv(t, msg->path, acc, path)) != 0)
 632                 return error;
 634         return sys_access(path, mode);
 635 }
 637 /*
 638  * Copy parent's cwd & file/directory descriptor to child's.
 639  */
 640 static int
fs_fork(struct task *t, struct msg *msg)
 642 {
 643         struct task *newtask;
file_t fp;
 645         int error, i;
DPRINTF(VFSDB_CORE, ("fs_fork\n"));
 649         if ((error = task_alloc((task_t)msg->data[0], &newtask)) != 0)
 650                 return error;
 652         /*
 653          * Copy task related data
 654          */
newtask->t_cwdfp = t->t_cwdfp;
strlcpy(newtask->t_cwd, t->t_cwd, sizeof(newtask->t_cwd));
 657         for (i = 0; i < OPEN_MAX; i++) {
fp = t->t_ofile[i];
newtask->t_ofile[i] = fp;
 660                 /*
 661                  * Increment file reference if it's
 662                  * already opened.
 663                  */
 664                 if (fp != NULL) {
vref(fp->f_vnode);
fp->f_count++;
 667                 }
 668         }
 669         if (newtask->t_cwdfp)
newtask->t_cwdfp->f_count++;
 671         /* Increment cwd's reference count */
 672         if (newtask->t_cwdfp)
vref(newtask->t_cwdfp->f_vnode);
DPRINTF(VFSDB_CORE, ("fs_fork-complete\n"));
 676         return 0;
 677 }
 679 /*
 680  * fs_exec() is called for POSIX exec().
 681  * It closes all directory stream.
 682  * File descriptor which is marked close-on-exec are also closed.
 683  */
 684 static int
fs_exec(struct task *t, struct msg *msg)
 686 {
task_t old_id, new_id;
 688         struct task *target;
file_t fp;
 690         int fd;
old_id = (task_t)msg->data[0];
new_id = (task_t)msg->data[1];
 695         if (!(target = task_lookup(old_id)))
 696                 return EINVAL;
 698         /* Update task id in the task. */
task_setid(target, new_id);
 701         /* Close all directory descriptor */
 702         for (fd = 0; fd < OPEN_MAX; fd++) {
fp = target->t_ofile[fd];
 704                 if (fp) {
 705                         if (fp->f_vnode->v_type == VDIR) {
sys_close(fp);
target->t_ofile[fd] = NULL;
 708                         }
 710                         /* XXX: need to check close-on-exec flag */
 711                 }
 712         }
task_unlock(target);
 714         return 0;
 715 }
 717 /*
 718  * fs_exit() cleans up data for task's termination.
 719  */
 720 static int
fs_exit(struct task *t, struct msg *msg)
 722 {
file_t fp;
 724         int fd;
DPRINTF(VFSDB_CORE, ("fs_exit\n"));
 728         /*
 729          * Close all files opened by task.
 730          */
 731         for (fd = 0; fd < OPEN_MAX; fd++) {
fp = t->t_ofile[fd];
 733                 if (fp != NULL)
sys_close(fp);
 735         }
 736         if (t->t_cwdfp)
sys_close(t->t_cwdfp);
task_free(t);
 739         return 0;
 740 }
 742 /*
 743  * fs_register() is called by boot tasks.
 744  * This can be called even when no fs is mounted.
 745  */
 746 static int
fs_register(struct task *t, struct msg *msg)
 748 {
 749         struct task *tmp;
 750         int error;
DPRINTF(VFSDB_CORE, ("fs_register\n"));
error = task_alloc(msg->hdr.task, &tmp);
 755         return error;
 756 }
 758 static int
fs_pipe(struct task *t, struct msg *msg)
 760 {
 761 #ifdef CONFIG_FIFOFS
 762         char path[PATH_MAX];
file_t rfp, wfp;
 764         int error, rfd, wfd;
DPRINTF(VFSDB_CORE, ("fs_pipe\n"));
 768         if ((rfd = task_newfd(t)) == -1)
 769                 return EMFILE;
t->t_ofile[rfd] = (file_t)1; /* temp */
 772         if ((wfd = task_newfd(t)) == -1) {
t->t_ofile[rfd] = NULL;
 774                 return EMFILE;
 775         }
sprintf(path, "/mnt/fifo/pipe-%x-%d", (u_int)t->t_taskid, rfd);
 778         if ((error = sys_mknod(path, S_IFIFO)) != 0)
 779                 goto out;
 780         if ((error = sys_open(path, O_RDONLY | O_NONBLOCK, 0, &rfp)) != 0) {
 781                 goto out;
 782         }
 783         if ((error = sys_open(path, O_WRONLY | O_NONBLOCK, 0, &wfp)) != 0) {
 784                 goto out;
 785         }
t->t_ofile[rfd] = rfp;
t->t_ofile[wfd] = wfp;
t->t_nopens += 2;
msg->data[0] = rfd;
msg->data[1] = wfd;
 791         return 0;
out:
t->t_ofile[rfd] = NULL;
t->t_ofile[wfd] = NULL;
 795         return error;
 796 #else
 797         return ENOSYS;
 798 #endif
 799 }
 801 /*
 802  * Return if specified file is a tty
 803  */
 804 static int
fs_isatty(struct task *t, struct msg *msg)
 806 {
file_t fp;
 808         int istty = 0;
 810         if ((fp = task_getfp(t, msg->data[0])) == NULL)
 811                 return EBADF;
 813         if (fp->f_vnode->v_flags & VISTTY)
istty = 1;
msg->data[0] = istty;
 816         return 0;
 817 }
 819 static int
fs_truncate(struct task *t, struct path_msg *msg)
 821 {
 822         char path[PATH_MAX];
 823         int error;
 825         if (msg->path == NULL)
 826                 return ENOENT;
 827         if ((error = task_conv(t, msg->path, VWRITE, path)) != 0)
 828                 return error;
 830         return sys_truncate(path, msg->data[0]);
 831 }
 833 static int
fs_ftruncate(struct task *t, struct msg *msg)
 835 {
file_t fp;
 838         if ((fp = task_getfp(t, msg->data[0])) == NULL)
 839                 return EBADF;
 841         return sys_ftruncate(fp, msg->data[1]);
 842 }
 844 /*
 845  * Prepare for boot
 846  */
 847 static int
fs_boot(struct task *t, struct msg *msg)
 849 {
object_t execobj, procobj;
 851         struct bind_msg bm;
 852         struct msg m;
 854         /* Check client's capability. */
 855         if (task_chkcap(msg->hdr.task, CAP_PROTSERV) != 0)
 856                 return EPERM;
 858         /*
 859          * Request exec server to bind an appropriate
 860          * capability for us.
 861          */
 862         if (object_lookup("!exec", &execobj) != 0)
sys_panic("fs: no exec found");
bm.hdr.code = EXEC_BINDCAP;
strlcpy(bm.path, "/boot/fs", sizeof(bm.path));
msg_send(execobj, &bm, sizeof(bm));
 868         /*
 869          * Notify to process server.
 870          */
 871         if (object_lookup("!proc", &procobj) != 0)
sys_panic("fs: no proc found");
m.hdr.code = PS_REGISTER;
msg_send(procobj, &m, sizeof(m));
 876         return 0;
 877 }
 879 /*
 880  * Prepare for shutdown
 881  */
 882 static int
fs_shutdown(struct task *t, struct msg *msg)
 884 {
DPRINTF(VFSDB_CORE, ("fs_shutdown\n"));
 887         return 0;
 888 }
 890 int
fs_noop(void)
 892 {
 893         return 0;
 894 }
 896 #ifdef DEBUG_VFS
 897 /*
 898  * Dump internal data.
 899  */
 900 static int
fs_debug(struct task *t, struct msg *msg)
 902 {
dprintf("<File System Server>\n");
task_dump();
vnode_dump();
mount_dump();
 908         return 0;
 909 }
 910 #endif
 912 static void
vfs_init(void)
 914 {
 915         const struct vfssw *fs;
 916         struct msg msg;
 918         /*
 919          * Initialize VFS core.
 920          */
task_init();
bio_init();
vnode_init();
 925         /*
 926          * Initialize each file system.
 927          */
 928         for (fs = vfssw; fs->vs_name; fs++) {
DPRINTF(VFSDB_CORE, ("VFS: initializing %s\n",
fs->vs_name));
fs->vs_init();
 932         }
 934         /*
 935          * Create task data for ourselves.
 936          */
msg.hdr.task = task_self();
fs_register(NULL, &msg);
 939 }
 941 /*
 942  * Run specified routine as a thread.
 943  */
 944 static int
run_thread(void (*entry)(void))
 946 {
task_t self;
thread_t t;
 949         void *stack, *sp;
 950         int error;
self = task_self();
 953         if ((error = thread_create(self, &t)) != 0)
 954                 return error;
 955         if ((error = vm_allocate(self, &stack, DFLSTKSZ, 1)) != 0)
 956                 return error;
sp = (void *)((u_long)stack + DFLSTKSZ - sizeof(u_long) * 3);
 959         if ((error = thread_load(t, entry, sp)) != 0)
 960                 return error;
 962         return thread_resume(t);
 963 }
 965 static void
exception_handler(int sig)
 967 {
exception_return();
 970 }
 972 /*
 973  * Message mapping
 974  */
 975 static const struct msg_map fsmsg_map[] = {
MSGMAP( FS_MOUNT,       fs_mount ),
MSGMAP( FS_UMOUNT,      fs_umount ),
MSGMAP( FS_SYNC,        fs_sync ),
MSGMAP( FS_OPEN,        fs_open ),
MSGMAP( FS_CLOSE,       fs_close ),
MSGMAP( FS_MKNOD,       fs_mknod ),
MSGMAP( FS_LSEEK,       fs_lseek ),
MSGMAP( FS_READ,        fs_read ),
MSGMAP( FS_WRITE,       fs_write ),
MSGMAP( FS_IOCTL,       fs_ioctl ),
MSGMAP( FS_FSYNC,       fs_fsync ),
MSGMAP( FS_FSTAT,       fs_fstat ),
MSGMAP( FS_OPENDIR,     fs_opendir ),
MSGMAP( FS_CLOSEDIR,    fs_closedir ),
MSGMAP( FS_READDIR,     fs_readdir ),
MSGMAP( FS_REWINDDIR,   fs_rewinddir ),
MSGMAP( FS_SEEKDIR,     fs_seekdir ),
MSGMAP( FS_TELLDIR,     fs_telldir ),
MSGMAP( FS_MKDIR,       fs_mkdir ),
MSGMAP( FS_RMDIR,       fs_rmdir ),
MSGMAP( FS_RENAME,      fs_rename ),
MSGMAP( FS_CHDIR,       fs_chdir ),
MSGMAP( FS_LINK,        fs_link ),
MSGMAP( FS_UNLINK,      fs_unlink ),
MSGMAP( FS_STAT,        fs_stat ),
MSGMAP( FS_GETCWD,      fs_getcwd ),
MSGMAP( FS_DUP,         fs_dup ),
MSGMAP( FS_DUP2,        fs_dup2 ),
MSGMAP( FS_FCNTL,       fs_fcntl ),
MSGMAP( FS_ACCESS,      fs_access ),
MSGMAP( FS_FORK,        fs_fork ),
MSGMAP( FS_EXEC,        fs_exec ),
MSGMAP( FS_EXIT,        fs_exit ),
MSGMAP( FS_REGISTER,    fs_register ),
MSGMAP( FS_PIPE,        fs_pipe ),
MSGMAP( FS_ISATTY,      fs_isatty ),
MSGMAP( FS_TRUNCATE,    fs_truncate ),
MSGMAP( FS_FTRUNCATE,   fs_ftruncate ),
MSGMAP( FS_FCHDIR,      fs_fchdir ),
MSGMAP( STD_BOOT,       fs_boot ),
MSGMAP( STD_SHUTDOWN,   fs_shutdown ),
1017 #ifdef DEBUG_VFS
MSGMAP( STD_DEBUG,      fs_debug ),
1019 #endif
MSGMAP( 0,              NULL ),
1021 };
1023 /*
1024  * File system thread.
1025  */
1026 static void
fs_thread(void)
1028 {
1029         struct msg *msg;
1030         const struct msg_map *map;
1031         struct task *t;
1032         int error;
msg = malloc(MAX_FSMSG);
1036         /*
1037          * Message loop
1038          */
1039         for (;;) {
1040                 /*
1041                  * Wait for an incoming request.
1042                  */
1043                 if ((error = msg_receive(fsobj, msg, MAX_FSMSG)) != 0)
1044                         continue;
error = EINVAL;
map = &fsmsg_map[0];
1048                 while (map->code != 0) {
1049                         if (map->code == msg->hdr.code) {
1050                                 /*
1051                                  * Handle messages by non-registerd tasks
1052                                  */
1053                                 if (map->code == STD_BOOT) {
error = fs_boot(NULL, msg);
1055                                         break;
1056                                 }
1057                                 if (map->code == FS_REGISTER) {
error = fs_register(NULL, msg);
1059                                         break;
1060                                 }
1062                                 /* Lookup and lock task */
t = task_lookup(msg->hdr.task);
1064                                 if (t == NULL)
1065                                         break;
1067                                 /* Dispatch request */
error = (*map->func)(t, msg);
1069                                 if (map->code != FS_EXIT)
task_unlock(t);
1071                                 break;
1072                         }
map++;
1074                 }
1075 #ifdef DEBUG_VFS
1076                 if (error)
dprintf("VFS: task=%x code=%x error=%d\n",
msg->hdr.task, map->code, error);
1079 #endif
1080                 /*
1081                  * Reply to the client.
1082                  */
msg->hdr.status = error;
msg_reply(fsobj, msg, MAX_FSMSG);
1085         }
1086 }
1088 /*
1089  * Main routine for file system service
1090  */
1091 int
main(int argc, char *argv[])
1093 {
1094         int i;
sys_log("Starting file system server\n");
DPRINTF(VFSDB_CORE, ("VFS: number of fs threads: %d\n",
CONFIG_FS_THREADS));
1101         /* Set thread priority. */
thread_setpri(thread_self(), PRI_FS);
1104         /* Setup exception handler */
exception_setup(exception_handler);
1107         /* Initialize the file systems. */
vfs_init();
1110         /* Create an object to expose our service. */
1111         if (object_create("!fs", &fsobj))
sys_panic("VFS: fail to create object");
1114         /*
1115          * Create new server threads.
1116          */
i = CONFIG_FS_THREADS;
1118         while (--i > 0) {
1119                 if (run_thread(fs_thread))
1120                         goto err;
1121         }
fs_thread();
sys_panic("VFS: exit!");
exit(0);
err:
sys_panic("VFS: failed to create thread");
1128         return 0;
1129 }