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