Prex Home / Browse Source - Prex Version: 0.9.0

root/usr/server/fs/arfs/arfs_vnops.c

DEFINITIONS

1. arfs_readblk
2. arfs_lookup
3. arfs_read
4. arfs_seek
5. arfs_readdir
6. arfs_init

   1 /*
   2  * Copyright (c) 2006-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  * arfs_vnops.c - vnode operations for archive file system.
  32  */
  34 /**
  35  * General design:
  36  *
  37  * ARFS (ARchive File System) is the read-only file system which
  38  * handles the generic archive (*.a) file as a file system image.
  39  * The file system is typically used for the boot time file system,
  40  * and it's mounted to the ram disk device mapped to the pre-loaded
  41  * archive file image. All files are placed in one single directory.
  42  */
  44 #include <sys/prex.h>
  45 #include <sys/stat.h>
  46 #include <sys/vnode.h>
  47 #include <sys/file.h>
  48 #include <sys/mount.h>
  49 #include <sys/param.h>
  50 #include <sys/dirent.h>
  51 #include <sys/buf.h>
  53 #include <ctype.h>
  54 #include <unistd.h>
  55 #include <errno.h>
  56 #include <string.h>
  57 #include <stdlib.h>
  58 #include <limits.h>
  59 #include <fcntl.h>
  60 #include <ar.h>
  62 #include "arfs.h"
  64 #define arfs_open       ((vnop_open_t)vop_nullop)
  65 #define arfs_close      ((vnop_close_t)vop_nullop)
  66 static int arfs_read    (vnode_t, file_t, void *, size_t, size_t *);
  67 #define arfs_write      ((vnop_write_t)vop_nullop)
  68 static int arfs_seek    (vnode_t, file_t, off_t, off_t);
  69 #define arfs_ioctl      ((vnop_ioctl_t)vop_einval)
  70 #define arfs_fsync      ((vnop_fsync_t)vop_nullop)
  71 static int arfs_readdir (vnode_t, file_t, struct dirent *);
  72 static int arfs_lookup  (vnode_t, char *, vnode_t);
  73 #define arfs_create     ((vnop_create_t)vop_einval)
  74 #define arfs_remove     ((vnop_remove_t)vop_einval)
  75 #define arfs_rename     ((vnop_rename_t)vop_einval)
  76 #define arfs_mkdir      ((vnop_mkdir_t)vop_einval)
  77 #define arfs_rmdir      ((vnop_rmdir_t)vop_einval)
  78 #define arfs_getattr    ((vnop_getattr_t)vop_nullop)
  79 #define arfs_setattr    ((vnop_setattr_t)vop_nullop)
  80 #define arfs_inactive   ((vnop_inactive_t)vop_nullop)
  81 #define arfs_truncate   ((vnop_truncate_t)vop_nullop)
  83 static char iobuf[BSIZE*2];
  85 #if CONFIG_FS_THREADS > 1
  86 static mutex_t arfs_lock = MUTEX_INITIALIZER;
  87 #endif
  89 /*
  90  * vnode operations
  91  */
  92 const struct vnops arfs_vnops = {
arfs_open,              /* open */
arfs_close,             /* close */
arfs_read,              /* read */
arfs_write,             /* write */
arfs_seek,              /* seek */
arfs_ioctl,             /* ioctl */
arfs_fsync,             /* fsync */
arfs_readdir,           /* readdir */
arfs_lookup,            /* lookup */
arfs_create,            /* create */
arfs_remove,            /* remove */
arfs_rename,            /* remame */
arfs_mkdir,             /* mkdir */
arfs_rmdir,             /* rmdir */
arfs_getattr,           /* getattr */
arfs_setattr,           /* setattr */
arfs_inactive,          /* inactive */
arfs_truncate,          /* truncate */
 111 };
 113 /*
 114  * Read blocks.
 115  * iobuf is filled by read data.
 116  */
 117 static int
arfs_readblk(mount_t mp, int blkno)
 119 {
 120         struct buf *bp;
 121         int error;
 123         /*
 124          * Read two blocks for archive header
 125          */
 126         if ((error = bread(mp->m_dev, blkno, &bp)) != 0)
 127                 return error;
memcpy(iobuf, bp->b_data, BSIZE);
brelse(bp);
 131         if ((error = bread(mp->m_dev, blkno + 1, &bp)) != 0)
 132                 return error;
memcpy(iobuf + BSIZE, bp->b_data, BSIZE);
brelse(bp);
 136         return 0;
 137 }
 139 /*
 140  * Lookup vnode for the specified file/directory.
 141  * The vnode is filled properly.
 142  */
 143 static int
arfs_lookup(vnode_t dvp, char *name, vnode_t vp)
 145 {
 146         struct ar_hdr *hdr;
 147         int blkno, error;
off_t off;
size_t size;
mount_t mp;
 151         char *p;
DPRINTF(("arfs_lookup: name=%s\n", name));
 154         if (*name == '\0')
 155                 return ENOENT;
mutex_lock(&arfs_lock);
error = ENOENT;
mp = vp->v_mount;
blkno = 0;
off = SARMAG;   /* offset in archive image */
 163         for (;;) {
 164                 /* Read two blocks for archive header */
 165                 if (arfs_readblk(mp, blkno) != 0)
 166                         goto out;
 168                 /* Check file header */
hdr = (struct ar_hdr *)(iobuf + (off % BSIZE));
 170                 if (strncmp(hdr->ar_fmag, ARFMAG, sizeof(ARFMAG) - 1))
 171                         goto out;
 173                 /* Get file size */
size = (size_t)atol((char *)&hdr->ar_size);
 175                 if (size == 0)
 176                         goto out;
 178                 /* Convert archive name */
 179                 if ((p = memchr(&hdr->ar_name, '/', 16)) != NULL)
 180                         *p = '\0';
 182                 if (strncmp(name, (char *)&hdr->ar_name, 16) == 0)
 183                         break;
 185                 /* Proceed to next archive header */
off += (sizeof(struct ar_hdr) + size);
off += (off % 2); /* Pad to even boundary */
blkno = (int)(off / BSIZE);
 190         }
vp->v_type = VREG;
 193         /* No write access */
vp->v_mode = (mode_t)(S_IRUSR | S_IXUSR);
vp->v_size = size;
vp->v_blkno = blkno;
vp->v_data = (void *)(off + sizeof(struct ar_hdr));
error = 0;
out:
mutex_unlock(&arfs_lock);
DPRINTF(("arfs_lookup: error=%d\n\n", error));
 202         return error;
 203 }
 205 static int
arfs_read(vnode_t vp, file_t fp, void *buf, size_t size, size_t *result)
 207 {
off_t off, file_pos, buf_pos;
 209         int blkno, error;
size_t nr_read, nr_copy;
mount_t mp;
 212         struct buf *bp;
DPRINTF(("arfs_read: start size=%d\n", size));
mutex_lock(&arfs_lock);
 217         *result = 0;
mp = vp->v_mount;
 220         /* Check if current file position is already end of file. */
file_pos = fp->f_offset;
 222         if (file_pos >= (off_t)vp->v_size) {
error = 0;
 224                 goto out;
 225         }
 226         /* Get the actual read size. */
 227         if (vp->v_size - file_pos < size)
size = vp->v_size - file_pos;
 230         /* Read and copy data */
off = (off_t)vp->v_data;
nr_read = 0;
 233         for (;;) {
DPRINTF(("arfs_read: file_pos=%d buf=%x size=%d\n",
file_pos, buf, size));
blkno = (off + file_pos) / BSIZE;
buf_pos = (off + file_pos) % BSIZE;
 239                 if ((error = bread(mp->m_dev, blkno, &bp)) != 0)
 240                         goto out;
nr_copy = BSIZE;
 242                 if (buf_pos > 0)
nr_copy -= buf_pos;
 244                 if (buf_pos + size < BSIZE)
nr_copy = size;
ASSERT(nr_copy > 0);
memcpy(buf, bp->b_data + buf_pos, nr_copy);
brelse(bp);
file_pos += nr_copy;
DPRINTF(("arfs_read: file_pos=%d nr_copy=%d\n",
file_pos, nr_copy));
nr_read += nr_copy;
size -= nr_copy;
 256                 if (size <= 0)
 257                         break;
buf = (void *)((u_long)buf + nr_copy);
buf_pos = 0;
 260         }
fp->f_offset = file_pos;
 262         *result = nr_read;
error = 0;
out:
mutex_unlock(&arfs_lock);
DPRINTF(("arfs_read: error=%d\n\n", error));
 267         return error;
 268 }
 270 /*
 271  * Check if the seek offset is valid.
 272  */
 273 static int
arfs_seek(vnode_t vp, file_t fp, off_t oldoff, off_t newoff)
 275 {
 277         if (newoff > (off_t)vp->v_size)
 278                 return -1;
 280         return 0;
 281 }
 283 static int
arfs_readdir(vnode_t vp, file_t fp, struct dirent *dir)
 285 {
 286         struct ar_hdr *hdr;
 287         int blkno, i, error;
off_t off;
size_t size;
mount_t mp;
 291         char *p;
DPRINTF(("arfs_readdir: start\n"));
mutex_lock(&arfs_lock);
i = 0;
mp = vp->v_mount;
blkno = 0;
off = SARMAG;   /* offset in archive image */
 300         for (;;) {
 301                 /* Read two blocks for archive header */
 302                 if ((error = arfs_readblk(mp, blkno)) != 0)
 303                         goto out;
hdr = (struct ar_hdr *)(iobuf + (off % BSIZE));
 307                 /* Get file size */
size = (size_t)atol((char *)&hdr->ar_size);
 309                 if (size == 0) {
error = ENOENT;
 311                         goto out;
 312                 }
 313                 if (i == fp->f_offset)
 314                         break;
 316                 /* Proceed to next archive header */
off += (sizeof(struct ar_hdr) + size);
off += (off % 2); /* Pad to even boundary */
blkno = off / BSIZE;
i++;
 322         }
 324         /* Convert archive name */
 325         if ((p = memchr(&hdr->ar_name, '/', 16)) != NULL)
 326                 *p = '\0';
strlcpy((char *)&dir->d_name, (char *)&hdr->ar_name,
 329                 sizeof(dir->d_name));
dir->d_namlen = (uint16_t)strlen(dir->d_name);
dir->d_fileno = (uint32_t)fp->f_offset;
dir->d_type = DT_REG;
fp->f_offset++;
error = 0;
out:
mutex_unlock(&arfs_lock);
 338         return error;
 339 }
 342 int
arfs_init(void)
 344 {
 345         return 0;
 346 }