![[BACK]](/icons/back.gif){kind=icon}
Return to ramfs_vnops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / usr / server / fs / ramfs|
Return to ramfs_vnops.c CVS log | Up to [local] / prex-old / usr / server / fs / ramfs |
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: #include <prex/prex.h>
31:
32: #include <sys/stat.h>
33: #include <sys/vnode.h>
34: #include <sys/file.h>
35: #include <sys/mount.h>
36: #include <sys/dirent.h>
37: #include <sys/param.h>
38:
39: #include <errno.h>
40: #include <string.h>
41: #include <stdlib.h>
42: #include <fcntl.h>
43:
44: #include "ramfs.h"
45:
46: #define ramfs_open ((vnop_open_t)vop_nullop)
47: #define ramfs_close ((vnop_close_t)vop_nullop)
48: static int ramfs_read(vnode_t, file_t, void *, size_t, size_t *);
49: static int ramfs_write(vnode_t, file_t, void *, size_t, size_t *);
50: #define ramfs_seek ((vnop_seek_t)vop_nullop)
51: #define ramfs_ioctl ((vnop_ioctl_t)vop_einval)
52: #define ramfs_fsync ((vnop_fsync_t)vop_nullop)
53: static int ramfs_readdir(vnode_t, file_t, struct dirent *);
54: static int ramfs_lookup(vnode_t, char *, vnode_t);
55: static int ramfs_create(vnode_t, char *, mode_t);
56: static int ramfs_remove(vnode_t, vnode_t, char *);
57: static int ramfs_rename(vnode_t, vnode_t, char *, vnode_t, vnode_t, char *);
58: static int ramfs_mkdir(vnode_t, char *, mode_t);
59: static int ramfs_rmdir(vnode_t, vnode_t, char *);
60: #define ramfs_getattr ((vnop_getattr_t)vop_nullop)
61: #define ramfs_setattr ((vnop_setattr_t)vop_nullop)
62: #define ramfs_inactive ((vnop_inactive_t)vop_nullop)
63: static int ramfs_truncate(vnode_t);
64:
65:
66: #if CONFIG_FS_THREADS > 1
67: static mutex_t ramfs_lock = MUTEX_INITIALIZER;
68: #endif
69:
70: /*
71: * vnode operations
72: */
73: struct vnops ramfs_vnops = {
74: ramfs_open, /* open */
75: ramfs_close, /* close */
76: ramfs_read, /* read */
77: ramfs_write, /* write */
78: ramfs_seek, /* seek */
79: ramfs_ioctl, /* ioctl */
80: ramfs_fsync, /* fsync */
81: ramfs_readdir, /* readdir */
82: ramfs_lookup, /* lookup */
83: ramfs_create, /* create */
84: ramfs_remove, /* remove */
85: ramfs_rename, /* remame */
86: ramfs_mkdir, /* mkdir */
87: ramfs_rmdir, /* rmdir */
88: ramfs_getattr, /* getattr */
89: ramfs_setattr, /* setattr */
90: ramfs_inactive, /* inactive */
91: ramfs_truncate, /* truncate */
92: };
93:
94: struct ramfs_node *
95: ramfs_allocate_node(char *name, int type)
96: {
97: struct ramfs_node *node;
98:
99: node = malloc(sizeof(struct ramfs_node));
100: if (node == NULL)
101: return NULL;
102: memset(node, 0, sizeof(struct ramfs_node));
103:
104: node->namelen = strlen(name);
105: node->name = malloc(node->namelen + 1);
106: if (node->name == NULL) {
107: free(node);
108: return NULL;
109: }
110: strcpy(node->name, name);
111: node->type = type;
112: return node;
113: }
114:
115: void
116: ramfs_free_node(struct ramfs_node *node)
117: {
118:
119: free(node->name);
120: free(node);
121: }
122:
123: static struct ramfs_node *
124: ramfs_add_node(struct ramfs_node *dir_node, char *name, int type)
125: {
126: struct ramfs_node *node, *prev;
127:
128: node = ramfs_allocate_node(name, type);
129: if (node == NULL)
130: return NULL;
131:
132: mutex_lock(&ramfs_lock);
133:
134: /* Link to the directory list */
135: if (dir_node->child == NULL) {
136: dir_node->child = node;
137: } else {
138: prev = dir_node->child;
139: while (prev->next != NULL)
140: prev = prev->next;
141: prev->next = node;
142: }
143: mutex_unlock(&ramfs_lock);
144: return node;
145: }
146:
147: static int
148: ramfs_remove_node(struct ramfs_node *dir_node, struct ramfs_node *node)
149: {
150: struct ramfs_node *prev;
151:
152: if (dir_node->child == NULL)
153: return EBUSY;
154:
155: mutex_lock(&ramfs_lock);
156:
157: /* Unlink from the directory list */
158: if (dir_node->child == node) {
159: dir_node->child = node->next;
160: } else {
161: for (prev = dir_node->child; prev->next != node;
162: prev = prev->next) {
163: if (prev->next == NULL) {
164: mutex_unlock(&ramfs_lock);
165: return ENOENT;
166: }
167: }
168: prev->next = node->next;
169: }
170: ramfs_free_node(node);
171:
172: mutex_unlock(&ramfs_lock);
173: return 0;
174: }
175:
176: static int
177: ramfs_rename_node(struct ramfs_node *node, char *name)
178: {
179: size_t len;
180: char *tmp;
181:
182: len = strlen(name);
183: if (len <= node->namelen) {
184: /* Reuse current name buffer */
185: strcpy(node->name, name);
186: } else {
187: /* Expand name buffer */
188: tmp = malloc(len + 1);
189: if (tmp == NULL)
190: return ENOMEM;
191: strcpy(tmp, name);
192: free(node->name);
193: node->name = tmp;
194: }
195: node->namelen = len;
196: return 0;
197: }
198:
199: static int
200: ramfs_lookup(vnode_t dvp, char *name, vnode_t vp)
201: {
202: struct ramfs_node *node, *dir_node;
203: size_t len;
204:
205: if (*name == '\0')
206: return ENOENT;
207:
208: mutex_lock(&ramfs_lock);
209:
210: len = strlen(name);
211: dir_node = dvp->v_data;
212: for (node = dir_node->child; node != NULL; node = node->next) {
213: if (node->namelen == len &&
214: memcmp(name, node->name, len) == 0)
215: break;
216: }
217: if (node == NULL) {
218: mutex_unlock(&ramfs_lock);
219: return ENOENT;
220: }
221: vp->v_data = node;
222: vp->v_mode = ALLPERMS;
223: vp->v_type = node->type;
224: vp->v_size = node->size;
225:
226: mutex_unlock(&ramfs_lock);
227: return 0;
228: }
229:
230: static int
231: ramfs_mkdir(vnode_t dvp, char *name, mode_t mode)
232: {
233: struct ramfs_node *node;
234:
235: dprintf("mkdir %s\n", name);
236: if (!S_ISDIR(mode))
237: return EINVAL;
238:
239: node = ramfs_add_node(dvp->v_data, name, VDIR);
240: if (node == NULL)
241: return ENOMEM;
242: node->size = 0;
243: return 0;
244: }
245:
246: /* Remove a directory */
247: static int
248: ramfs_rmdir(vnode_t dvp, vnode_t vp, char *name)
249: {
250:
251: return ramfs_remove_node(dvp->v_data, vp->v_data);
252: }
253:
254: /* Remove a file */
255: static int
256: ramfs_remove(vnode_t dvp, vnode_t vp, char *name)
257: {
258: struct ramfs_node *node;
259: int err;
260:
261: dprintf("remove %s in %s\n", name, dvp->v_path);
262: err = ramfs_remove_node(dvp->v_data, vp->v_data);
263: if (err)
264: return err;
265:
266: node = vp->v_data;
267: if (node->buf != NULL)
268: vm_free(task_self(), node->buf);
269: return 0;
270: }
271:
272: /* Truncate file */
273: static int
274: ramfs_truncate(vnode_t vp)
275: {
276: struct ramfs_node *node;
277:
278: dprintf("truncate %s\n", vp->v_path);
279: node = vp->v_data;
280: if (node->buf != NULL) {
281: vm_free(task_self(), node->buf);
282: node->buf = NULL;
283: node->bufsize = 0;
284: }
285: vp->v_size = 0;
286: return 0;
287: }
288:
289: /*
290: * Create empty file.
291: */
292: static int
293: ramfs_create(vnode_t dvp, char *name, mode_t mode)
294: {
295: struct ramfs_node *node;
296:
297: dprintf("create %s in %s\n", name, dvp->v_path);
298: if (!S_ISREG(mode))
299: return EINVAL;
300:
301: node = ramfs_add_node(dvp->v_data, name, VREG);
302: if (node == NULL)
303: return ENOMEM;
304: return 0;
305: }
306:
307: static int
308: ramfs_read(vnode_t vp, file_t fp, void *buf, size_t size, size_t *result)
309: {
310: struct ramfs_node *node;
311: off_t off;
312:
313: *result = 0;
314: if (vp->v_type == VDIR)
315: return EISDIR;
316: if (vp->v_type != VREG)
317: return EINVAL;
318:
319: off = fp->f_offset;
320: if (off >= (off_t)vp->v_size)
321: return 0;
322:
323: if (vp->v_size - off < size)
324: size = vp->v_size - off;
325:
326: node = vp->v_data;
327: memcpy(buf, node->buf + off, size);
328:
329: fp->f_offset += size;
330: *result = size;
331: return 0;
332: }
333:
334: static int
335: ramfs_write(vnode_t vp, file_t fp, void *buf, size_t size, size_t *result)
336: {
337: struct ramfs_node *node;
338: off_t file_pos, end_pos;
339: void *new_buf;
340: size_t new_size;
341: task_t task;
342:
343: *result = 0;
344: if (vp->v_type == VDIR)
345: return EISDIR;
346: if (vp->v_type != VREG)
347: return EINVAL;
348:
349: node = vp->v_data;
350: /* Check if the file position exceeds the end of file. */
351: end_pos = vp->v_size;
352: file_pos = (fp->f_flags & O_APPEND) ? end_pos : fp->f_offset;
353: if (file_pos + size > (size_t)end_pos) {
354: /* Expand the file size before writing to it */
355: end_pos = file_pos + size;
356: if (end_pos > (off_t)node->bufsize) {
357: task = task_self();
358: /*
359: * We allocate the data buffer in page boundary.
360: * So that we can reduce the memory allocation unless
361: * the file size exceeds next page boundary.
362: * This will prevent the memory fragmentation by
363: * many malloc/free calls.
364: */
365: new_size = PAGE_ALIGN(end_pos);
366: if (vm_allocate(task, &new_buf, new_size, 1))
367: return EIO;
368: if (node->size != 0) {
369: memcpy(new_buf, node->buf, vp->v_size);
370: vm_free(task, node->buf);
371: }
372: node->buf = new_buf;
373: node->bufsize = new_size;
374: }
375: node->size = end_pos;
376: vp->v_size = end_pos;
377: }
378: memcpy(node->buf + file_pos, buf, size);
379: fp->f_offset += size;
380: *result = size;
381: return 0;
382: }
383:
384: static int
385: ramfs_rename(vnode_t dvp1, vnode_t vp1, char *name1,
386: vnode_t dvp2, vnode_t vp2, char *name2)
387: {
388: struct ramfs_node *node, *old_node;
389: int err;
390:
391: if (vp2) {
392: /* Remove destination file, first */
393: err = ramfs_remove_node(dvp2->v_data, vp2->v_data);
394: if (err)
395: return err;
396: }
397: /* Same directory ? */
398: if (dvp1 == dvp2) {
399: /* Change the name of existing file */
400: err = ramfs_rename_node(vp1->v_data, name2);
401: if (err)
402: return err;
403: } else {
404: /* Create new file or directory */
405: old_node = vp1->v_data;
406: node = ramfs_add_node(dvp2->v_data, name2, VREG);
407: if (node == NULL)
408: return ENOMEM;
409:
410: if (vp1->v_type == VREG) {
411: /* Copy file data */
412: node->buf = old_node->buf;
413: node->size = old_node->size;
414: node->bufsize = old_node->bufsize;
415: }
416: /* Remove source file */
417: ramfs_remove_node(dvp1->v_data, vp1->v_data);
418: }
419: return 0;
420: }
421:
422: /*
423: * @vp: vnode of the directory.
424: */
425: static int
426: ramfs_readdir(vnode_t vp, file_t fp, struct dirent *dir)
427: {
428: struct ramfs_node *node, *dir_node;
429: int i;
430:
431: mutex_lock(&ramfs_lock);
432:
433: if (fp->f_offset == 0) {
434: dir->d_type = DT_DIR;
435: strcpy((char *)&dir->d_name, ".");
436: } else if (fp->f_offset == 1) {
437: dir->d_type = DT_DIR;
438: strcpy((char *)&dir->d_name, "..");
439: } else {
440: dir_node = vp->v_data;
441: node = dir_node->child;
442: if (node == NULL) {
443: mutex_unlock(&ramfs_lock);
444: return ENOENT;
445: }
446:
447: for (i = 0; i != (fp->f_offset - 2); i++) {
448: node = node->next;
449: if (node == NULL) {
450: mutex_unlock(&ramfs_lock);
451: return ENOENT;
452: }
453: }
454: if (node->type == VDIR)
455: dir->d_type = DT_DIR;
456: else
457: dir->d_type = DT_REG;
458: strcpy((char *)&dir->d_name, node->name);
459: }
460: dir->d_fileno = fp->f_offset;
461: dir->d_namlen = strlen(dir->d_name);
462:
463: fp->f_offset++;
464:
465: mutex_unlock(&ramfs_lock);
466: return 0;
467: }
468:
469: int
470: ramfs_init(void)
471: {
472: return 0;
473: }