Annotation of prex-old/usr/server/fs/arfs/arfs_vnops.c, Revision 1.1.1.1
1.1 nbrk 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: */
29:
30: /*
31: * arfs_vnops.c - vnode operations for archive file system.
32: */
33:
34: #include <prex/prex.h>
35: #include <sys/stat.h>
36: #include <sys/vnode.h>
37: #include <sys/file.h>
38: #include <sys/mount.h>
39: #include <sys/param.h>
40: #include <sys/dirent.h>
41: #include <sys/buf.h>
42:
43: #include <ctype.h>
44: #include <unistd.h>
45: #include <errno.h>
46: #include <string.h>
47: #include <stdlib.h>
48: #include <limits.h>
49: #include <fcntl.h>
50: #include <ar.h>
51:
52: #include "arfs.h"
53:
54: #define arfs_open ((vnop_open_t)vop_nullop)
55: #define arfs_close ((vnop_close_t)vop_nullop)
56: static int arfs_read(vnode_t, file_t, void *, size_t, size_t *);
57: #define arfs_write ((vnop_write_t)vop_nullop)
58: static int arfs_seek(vnode_t, file_t, off_t, off_t);
59: #define arfs_ioctl ((vnop_ioctl_t)vop_einval)
60: #define arfs_fsync ((vnop_fsync_t)vop_nullop)
61: static int arfs_readdir(vnode_t, file_t, struct dirent *);
62: static int arfs_lookup(vnode_t, char *, vnode_t);
63: #define arfs_create ((vnop_create_t)vop_einval)
64: #define arfs_remove ((vnop_remove_t)vop_einval)
65: #define arfs_rename ((vnop_rename_t)vop_einval)
66: #define arfs_mkdir ((vnop_mkdir_t)vop_einval)
67: #define arfs_rmdir ((vnop_rmdir_t)vop_einval)
68: #define arfs_getattr ((vnop_getattr_t)vop_nullop)
69: #define arfs_setattr ((vnop_setattr_t)vop_nullop)
70: #define arfs_inactive ((vnop_inactive_t)vop_nullop)
71: #define arfs_truncate ((vnop_truncate_t)vop_nullop)
72:
73: static char iobuf[BSIZE*2];
74:
75: #if CONFIG_FS_THREADS > 1
76: static mutex_t arfs_lock = MUTEX_INITIALIZER;
77: #endif
78:
79: /*
80: * vnode operations
81: */
82: const struct vnops arfs_vnops = {
83: arfs_open, /* open */
84: arfs_close, /* close */
85: arfs_read, /* read */
86: arfs_write, /* write */
87: arfs_seek, /* seek */
88: arfs_ioctl, /* ioctl */
89: arfs_fsync, /* fsync */
90: arfs_readdir, /* readdir */
91: arfs_lookup, /* lookup */
92: arfs_create, /* create */
93: arfs_remove, /* remove */
94: arfs_rename, /* remame */
95: arfs_mkdir, /* mkdir */
96: arfs_rmdir, /* rmdir */
97: arfs_getattr, /* getattr */
98: arfs_setattr, /* setattr */
99: arfs_inactive, /* inactive */
100: arfs_truncate, /* truncate */
101: };
102:
103: /*
104: * Read two blocks.
105: * iobuf is filled by read data.
106: */
107: static int
108: arfs_readblk(mount_t mp, int blkno)
109: {
110: struct buf *bp;
111: int err;
112:
113: /* Read two blocks for archive header */
114: if ((err = bread(mp->m_dev, blkno, &bp)) != 0)
115: return err;
116: memcpy(iobuf, bp->b_data, BSIZE);
117: brelse(bp);
118:
119: if ((err = bread(mp->m_dev, blkno + 1, &bp)) != 0)
120: return err;
121: memcpy(iobuf + BSIZE, bp->b_data, BSIZE);
122: brelse(bp);
123: return 0;
124: }
125:
126: /*
127: * Lookup vnode for the specified file/directory.
128: * The vnode is filled properly.
129: */
130: static int
131: arfs_lookup(vnode_t dvp, char *name, vnode_t vp)
132: {
133: struct ar_hdr *hdr;
134: int blkno, err;
135: off_t off;
136: size_t size;
137: mount_t mp;
138: char *p;
139:
140: dprintf("lookup: name=%s\n", name);
141: if (*name == '\0')
142: return ENOENT;
143:
144: mutex_lock(&arfs_lock);
145:
146: err = ENOENT;
147: mp = vp->v_mount;
148: blkno = 0;
149: off = SARMAG; /* offset in archive image */
150: for (;;) {
151: /* Read two blocks for archive header */
152: if (arfs_readblk(mp, blkno) != 0)
153: goto out;
154:
155: /* Check file header */
156: hdr = (struct ar_hdr *)(iobuf + (off % BSIZE));
157: if (strncmp(hdr->ar_fmag, ARFMAG, sizeof(ARFMAG) - 1))
158: goto out;
159:
160: /* Get file size */
161: size = (size_t)atol((char *)&hdr->ar_size);
162: if (size == 0)
163: goto out;
164:
165: /* Convert archive name */
166: if ((p = memchr(&hdr->ar_name, '/', 16)) != NULL)
167: *p = '\0';
168:
169: if (strncmp(name, (char *)&hdr->ar_name, 16) == 0)
170: break;
171:
172: /* Proceed to next archive header */
173: off += (sizeof(struct ar_hdr) + size);
174: off += (off % 2); /* Pad to even boundary */
175:
176: blkno = (int)(off / BSIZE);
177: }
178: vp->v_type = VREG;
179:
180: /* No write access */
181: vp->v_mode = S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP
182: | S_IROTH | S_IXOTH;
183: vp->v_size = size;
184: vp->v_blkno = blkno;
185: vp->v_data = (void *)(off + sizeof(struct ar_hdr));
186: err = 0;
187: out:
188: mutex_unlock(&arfs_lock);
189: dprintf("lookup: err=%d\n\n", err);
190: return err;
191: }
192:
193: static int
194: arfs_read(vnode_t vp, file_t fp, void *buf, size_t size, size_t *result)
195: {
196: off_t off, file_pos, buf_pos;
197: int blkno, err;
198: size_t nr_read, nr_copy;
199: mount_t mp;
200: struct buf *bp;
201:
202: dprintf("****read: start size=%d\n", size);
203: mutex_lock(&arfs_lock);
204:
205: *result = 0;
206: mp = vp->v_mount;
207:
208: /* Check if current file position is already end of file. */
209: file_pos = fp->f_offset;
210: if (file_pos >= (off_t)vp->v_size) {
211: err = 0;
212: goto out;
213: }
214: /* Get the actual read size. */
215: if (vp->v_size - file_pos < size)
216: size = vp->v_size - file_pos;
217:
218: /* Read and copy data */
219: off = (off_t)vp->v_data;
220: nr_read = 0;
221: for (;;) {
222: dprintf("file_pos=%d buf=%x size=%d\n", file_pos, buf, size);
223:
224: blkno = (off + file_pos) / BSIZE;
225: buf_pos = (off + file_pos) % BSIZE;
226: if ((err = bread(mp->m_dev, blkno, &bp)) != 0)
227: goto out;
228: nr_copy = BSIZE;
229: if (buf_pos > 0)
230: nr_copy -= buf_pos;
231: if (buf_pos + size < BSIZE)
232: nr_copy = size;
233: ASSERT(nr_copy > 0);
234: memcpy(buf, bp->b_data + buf_pos, nr_copy);
235: brelse(bp);
236:
237: file_pos += nr_copy;
238: dprintf("file_pos=%d nr_copy=%d\n", file_pos, nr_copy);
239:
240: nr_read += nr_copy;
241: size -= nr_copy;
242: if (size <= 0)
243: break;
244: buf = (void *)((u_long)buf + nr_copy);
245: buf_pos = 0;
246: }
247: fp->f_offset = file_pos;
248: *result = nr_read;
249: err = 0;
250: out:
251: mutex_unlock(&arfs_lock);
252: dprintf("read: err=%d\n\n", err);
253: return err;
254: }
255:
256: /*
257: * Check if the seek offset is valid.
258: */
259: static int
260: arfs_seek(vnode_t vp, file_t fp, off_t oldoff, off_t newoff)
261: {
262:
263: if (newoff > (off_t)vp->v_size)
264: return -1;
265:
266: return 0;
267: }
268:
269: static int
270: arfs_readdir(vnode_t vp, file_t fp, struct dirent *dir)
271: {
272: struct ar_hdr *hdr;
273: int blkno, i, err;
274: off_t off;
275: size_t size;
276: mount_t mp;
277: char *p;
278:
279: dprintf("readdir: start\n");
280: mutex_lock(&arfs_lock);
281:
282: i = 0;
283: mp = vp->v_mount;
284: blkno = 0;
285: off = SARMAG; /* offset in archive image */
286: for (;;) {
287: /* Read two blocks for archive header */
288: if ((err = arfs_readblk(mp, blkno)) != 0)
289: goto out;
290:
291: hdr = (struct ar_hdr *)(iobuf + (off % BSIZE));
292:
293: /* Get file size */
294: size = (size_t)atol((char *)&hdr->ar_size);
295: if (size == 0) {
296: err = ENOENT;
297: goto out;
298: }
299: if (i == fp->f_offset)
300: break;
301:
302: /* Proceed to next archive header */
303: off += (sizeof(struct ar_hdr) + size);
304: off += (off % 2); /* Pad to even boundary */
305:
306: blkno = off / BSIZE;
307: i++;
308: }
309:
310: /* Convert archive name */
311: if ((p = memchr(&hdr->ar_name, '/', 16)) != NULL)
312: *p = '\0';
313:
314: strcpy((char *)&dir->d_name, (char *)&hdr->ar_name);
315: dir->d_namlen = strlen(dir->d_name);
316: dir->d_fileno = fp->f_offset;
317: dir->d_type = DT_REG;
318:
319: fp->f_offset++;
320: err = 0;
321: out:
322: mutex_unlock(&arfs_lock);
323: return err;
324: }
325:
326:
327: int
328: arfs_init(void)
329: {
330: return 0;
331: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to arfs_vnops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / usr / server / fs / arfs