![[BACK]](/icons/back.gif){kind=icon}
Return to vfs_mount.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / usr / server / fs / vfs|
Return to vfs_mount.c CVS log | Up to [local] / prex-old / usr / server / fs / vfs |
1.1 nbrk 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: */
29:
30: /*
31: * mount.c - mount operations
32: */
33:
34: #include <prex/prex.h>
35:
36: #include <sys/stat.h>
37: #include <sys/vnode.h>
38: #include <sys/file.h>
39: #include <sys/mount.h>
40: #include <sys/dirent.h>
41: #include <sys/list.h>
42: #include <sys/buf.h>
43:
44: #include <limits.h>
45: #include <unistd.h>
46: #include <stdlib.h>
47: #include <string.h>
48: #include <stdio.h>
49: #include <errno.h>
50: #include <fcntl.h>
51:
52: #include "vfs.h"
53:
54: /*
55: * List for VFS mount points.
56: */
57: static struct list mount_list = LIST_INIT(mount_list);
58:
59: /*
60: * Global lock to access mount point.
61: */
62: #if CONFIG_FS_THREADS > 1
63: static mutex_t mount_lock = MUTEX_INITIALIZER;
64: #define MOUNT_LOCK() mutex_lock(&mount_lock)
65: #define MOUNT_UNLOCK() mutex_unlock(&mount_lock)
66: #else
67: #define MOUNT_LOCK()
68: #define MOUNT_UNLOCK()
69: #endif
70:
71: static const struct vfssw *
72: fs_lookup(char *name)
73: {
74: const struct vfssw *fs;
75:
76: for (fs = vfssw_table; fs->vs_name; fs++) {
77: if (!strncmp(name, fs->vs_name, FSMAXNAMES))
78: break;
79: }
80: if (!fs->vs_name)
81: return NULL;
82: return fs;
83: }
84:
85: int
86: sys_mount(char *dev, char *dir, char *fsname, int flags, void *data)
87: {
88: const struct vfssw *fs;
89: mount_t mp;
90: list_t head, n;
91: device_t device;
92: vnode_t vp, vp_covered;
93: int err;
94:
95: dprintf("VFS: Mounting %s dev=%s dir=%s\n", fsname, dev, dir);
96:
97: if (!dir || *dir == '\0')
98: return ENOENT;
99:
100: /* Find a file system. */
101: if (!(fs = fs_lookup(fsname)))
102: return ENODEV; /* No such file system */
103:
104: /* Open device. NULL can be specified as a device. */
105: device = 0;
106: if (*dev != '\0') {
107: if (strncmp(dev, "/dev/", 5))
108: return ENOTBLK;
109: if ((err = device_open(dev + 5, DO_RDWR, &device)) != 0)
110: return err;
111: }
112:
113: MOUNT_LOCK();
114:
115: /* Check if device or directory has already been mounted. */
116: head = &mount_list;
117: for (n = list_first(head); n != head; n = list_next(n)) {
118: mp = list_entry(n, struct mount, m_link);
119: if (!strcmp(mp->m_path, dir) ||
120: (device && mp->m_dev == (dev_t)device)) {
121: err = EBUSY; /* Already mounted */
122: goto err1;
123: }
124: }
125: /*
126: * Create VFS mount entry
127: */
128: if (!(mp = malloc(sizeof(struct mount)))) {
129: err = ENOMEM;
130: goto err1;
131: }
132: mp->m_count = 0;
133: mp->m_op = fs->vs_op;
134: mp->m_flags = flags;
135: mp->m_dev = (dev_t)device;
136: strlcpy(mp->m_path, dir, PATH_MAX);
137: mp->m_path[PATH_MAX - 1] = '\0';
138:
139: /*
140: * Get vnode to be covered in the upper file system.
141: */
142: if (*dir == '/' && *(dir + 1) == '\0') {
143: /* Ignore if it mounts to global root directory. */
144: vp_covered = NULL;
145: } else {
146: if ((err = namei(dir, &vp_covered)) != 0) {
147: err = ENOENT;
148: goto err2;
149: }
150: if (vp_covered->v_type != VDIR) {
151: err = ENOTDIR;
152: goto err3;
153: }
154: }
155: mp->m_covered = vp_covered;
156:
157: /*
158: * Create a root vnode for this file system.
159: */
160: if ((vp = vget(mp, "/")) == NULL) {
161: err = ENOMEM;
162: goto err3;
163: }
164: vp->v_type = VDIR;
165: vp->v_flags = VROOT;
166: vp->v_mode = S_IFDIR | S_IRUSR | S_IRGRP | S_IROTH;
167: mp->m_root = vp;
168:
169: /*
170: * Call a file system specific routine to mount.
171: */
172: if ((err = VFS_MOUNT(mp, dev, flags, data)) != 0)
173: goto err4;
174:
175: /*
176: * Keep reference count for root/covered vnode.
177: */
178: vn_unlock(vp);
179: if (vp_covered)
180: vn_unlock(vp_covered);
181:
182: /*
183: * Insert to mount list
184: */
185: list_insert(&mount_list, &mp->m_link);
186: MOUNT_UNLOCK();
187: return 0;
188: err4:
189: vput(vp);
190: err3:
191: if (vp_covered)
192: vput(vp_covered);
193: err2:
194: free(mp);
195: err1:
196: device_close(device);
197: MOUNT_UNLOCK();
198: return err;
199: }
200:
201: int
202: sys_umount(char *path)
203: {
204: mount_t mp;
205: list_t head, n;
206: int err;
207:
208: dprintf("sys_umount: path=%s\n", path);
209:
210: MOUNT_LOCK();
211:
212: /* Get mount entry */
213: head = &mount_list;
214: for (n = list_first(head); n != head; n = list_next(n)) {
215: mp = list_entry(n, struct mount, m_link);
216: if (!strcmp(path, mp->m_path))
217: break;
218: }
219: if (n == head) {
220: err = EINVAL;
221: goto out;
222: }
223: /*
224: * Root fs can not be unmounted.
225: */
226: if (mp->m_covered == NULL) {
227: err = EINVAL;
228: goto out;
229: }
230: if ((err = VFS_UNMOUNT(mp)) != 0)
231: goto out;
232: list_remove(&mp->m_link);
233:
234: /* Decrement referece count of root vnode */
235: vrele(mp->m_covered);
236:
237: /* Release all vnodes */
238: vflush(mp);
239:
240: /* Flush all buffers */
241: binval(mp->m_dev);
242:
243: if (mp->m_dev)
244: device_close((device_t)mp->m_dev);
245: free(mp);
246: out:
247: MOUNT_UNLOCK();
248: return err;
249: }
250:
251: int
252: sys_sync(void)
253: {
254: mount_t mp;
255: list_t head, n;
256:
257: /* Call each mounted file system. */
258: MOUNT_LOCK();
259: head = &mount_list;
260: for (n = list_first(head); n != head; n = list_next(n)) {
261: mp = list_entry(n, struct mount, m_link);
262: VFS_SYNC(mp);
263: }
264: MOUNT_UNLOCK();
265: bio_sync();
266: return 0;
267: }
268:
269: /*
270: * Compare two path strings. Return matched length.
271: * @path: target path.
272: * @root: vfs root path as mount point.
273: */
274: static size_t
275: count_match(char *path, char *mount_root)
276: {
277: size_t len = 0;
278:
279: while (*path && *mount_root) {
280: if (*path++ != *mount_root++)
281: break;
282: len++;
283: }
284: if (*mount_root != '\0')
285: return 0;
286:
287: if (len == 1 && *(path - 1) == '/')
288: return 1;
289:
290: if (*path == '\0' || *path == '/')
291: return len;
292: return 0;
293: }
294:
295: /*
296: * Get the root directory and mount point for specified path.
297: * @path: full path.
298: * @mp: mount point to return.
299: * @root: pointer to root directory in path.
300: */
301: int
302: vfs_findroot(char *path, mount_t *mp, char **root)
303: {
304: mount_t m, tmp;
305: list_t head, n;
306: size_t len, max_len = 0;
307:
308: if (!path)
309: return -1;
310:
311: /* Find mount point from nearest path */
312: MOUNT_LOCK();
313: m = NULL;
314: head = &mount_list;
315: for (n = list_first(head); n != head; n = list_next(n)) {
316: tmp = list_entry(n, struct mount, m_link);
317: len = count_match(path, tmp->m_path);
318: if (len > max_len) {
319: max_len = len;
320: m = tmp;
321: }
322: }
323: MOUNT_UNLOCK();
324: if (m == NULL)
325: return -1;
326: *root = (char *)(path + max_len);
327: if (**root == '/')
328: (*root)++;
329: *mp = m;
330: return 0;
331: }
332:
333: /*
334: * Mark a mount point as busy.
335: */
336: void
337: vfs_busy(mount_t mp)
338: {
339:
340: MOUNT_LOCK();
341: mp->m_count++;
342: MOUNT_UNLOCK();
343: }
344:
345:
346: /*
347: * Mark a mount point as busy.
348: */
349: void
350: vfs_unbusy(mount_t mp)
351: {
352:
353: MOUNT_LOCK();
354: mp->m_count--;
355: MOUNT_UNLOCK();
356: }
357:
358: int
359: vfs_nullop(void)
360: {
361: return 0;
362: }
363:
364: int
365: vfs_einval(void)
366: {
367: return EINVAL;
368: }
369:
370: #ifdef DEBUG
371: void
372: mount_dump(void)
373: {
374: list_t head, n;
375: mount_t mp;
376:
377: MOUNT_LOCK();
378:
379: printf("mount_dump\n");
380: printf("dev count root\n");
381: printf("-------- ----- --------\n");
382: head = &mount_list;
383: for (n = list_first(head); n != head; n = list_next(n)) {
384: mp = list_entry(n, struct mount, m_link);
385: printf("%8x %5d %s\n", mp->m_dev, mp->m_count, mp->m_path);
386: }
387: MOUNT_UNLOCK();
388: }
389: #endif