![[BACK]](/icons/back.gif){kind=icon}
Return to fatfs_node.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex / usr / server / fs / fatfs|
Return to fatfs_node.c CVS log | Up to [local] / prex / usr / server / fs / fatfs |
1.1 nbrk 1: /*
2: * Copyright (c) 2005-2008, 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: #include <sys/buf.h>
32:
33: #include <ctype.h>
34: #include <string.h>
35: #include <unistd.h>
36: #include <errno.h>
37: #include <stdlib.h>
38:
39: #include "fatfs.h"
40:
41: /*
42: * Read directory entry to buffer, with cache.
43: */
44: static int
45: fat_read_dirent(struct fatfsmount *fmp, u_long sec)
46: {
47: struct buf *bp;
48: int err;
49:
50: if ((err = bread(fmp->dev, sec, &bp)) != 0)
51: return err;
52: memcpy(fmp->dir_buf, bp->b_data, SEC_SIZE);
53: brelse(bp);
54: return 0;
55: }
56:
57: /*
58: * Write directory entry from buffer.
59: */
60: static int
61: fat_write_dirent(struct fatfsmount *fmp, u_long sec)
62: {
63: struct buf *bp;
64:
65: bp = getblk(fmp->dev, sec);
66: memcpy(bp->b_data, fmp->dir_buf, SEC_SIZE);
67: return bwrite(bp);
68: }
69:
70: /*
71: * Find directory entry in specified sector.
72: * The fat vnode data is filled if success.
73: *
74: * @fmp: fatfs mount point
75: * @sec: sector#
76: * @name: file name
77: * @node: pointer to fat node
78: */
79: static int
80: fat_lookup_dirent(struct fatfsmount *fmp, u_long sec, char *name,
81: struct fatfs_node *np)
82: {
83: struct fat_dirent *de;
84: int err, i;
85:
86: err = fat_read_dirent(fmp, sec);
87: if (err)
88: return err;
89:
90: de = (struct fat_dirent *)fmp->dir_buf;
91:
92: for (i = 0; i < DIR_PER_SEC; i++) {
93: /* Find specific file or directory name */
94: if (IS_EMPTY(de))
95: return ENOENT;
96: if (!IS_VOL(de) &&
97: !fat_compare_name((char *)de->name, name)) {
98: /* Found. Fill the fat vnode data. */
99: *(&np->dirent) = *de;
100: np->sector = sec;
101: np->offset = sizeof(struct fat_dirent) * i;
102: DPRINTF(("fat_lookup_dirent: found sec=%d\n", sec));
103: return 0;
104: }
105: if (!IS_DELETED(de))
106: DPRINTF(("fat_lookup_dirent: %s\n", de->name));
107: de++;
108: }
109: return EAGAIN;
110: }
111:
112: /*
113: * Find directory entry for specified name in directory.
114: * The fat vnode data is filled if success.
115: *
116: * @dvp: vnode for directory.
117: * @name: file name
118: * @np: pointer to fat node
119: */
120: int
121: fatfs_lookup_node(vnode_t dvp, char *name, struct fatfs_node *np)
122: {
123: struct fatfsmount *fmp;
124: char fat_name[12];
125: u_long cl, sec;
126: int i, err;
127:
128: if (name == NULL)
129: return ENOENT;
130:
131: DPRINTF(("fat_lookup_denode: cl=%d name=%s\n", dvp->v_blkno, name));
132:
133: fat_convert_name(name, fat_name);
134: *(fat_name + 11) = '\0';
135:
136: fmp = (struct fatfsmount *)dvp->v_mount->m_data;
137: cl = dvp->v_blkno;
138: if (cl == CL_ROOT) {
139: /* Search entry in root directory */
140: for (sec = fmp->root_start; sec < fmp->data_start; sec++) {
141: err = fat_lookup_dirent(fmp, sec, fat_name, np);
142: if (err != EAGAIN)
143: return err;
144: }
145: } else {
146: /* Search entry in sub directory */
147: while (!IS_EOFCL(fmp, cl)) {
148: sec = cl_to_sec(fmp, cl);
149: for (i = 0; i < fmp->sec_per_cl; i++) {
150: err = fat_lookup_dirent(fmp, sec, fat_name,
151: np);
152: if (err != EAGAIN)
153: return err;
154: sec++;
155: }
156: err = fat_next_cluster(fmp, cl, &cl);
157: if (err)
158: return err;
159: }
160: }
161: return ENOENT;
162: }
163:
164: /*
165: * Get directory entry for specified index in sector.
166: * The directory entry is filled if success.
167: *
168: * @fmp: fatfs mount point
169: * @sec: sector#
170: * @target: target index
171: * @index: current index
172: * @np: pointer to fat node
173: */
174: static int
175: fat_get_dirent(struct fatfsmount *fmp, u_long sec, int target, int *index,
176: struct fatfs_node *np)
177: {
178: struct fat_dirent *de;
179: int err, i;
180:
181: err = fat_read_dirent(fmp, sec);
182: if (err)
183: return err;
184:
185: de = (struct fat_dirent *)fmp->dir_buf;
186: for (i = 0; i < DIR_PER_SEC; i++) {
187: if (IS_EMPTY(de))
188: return ENOENT;
189: if (!IS_DELETED(de) && !IS_VOL(de)) {
190: /* valid file */
191: if (*index == target) {
192: *(&np->dirent) = *de;
193: np->sector = sec;
194: np->offset = sizeof(struct fat_dirent) * i;
195: DPRINTF(("fat_get_dirent: found index=%d\n", *index));
196: return 0;
197: }
198: (*index)++;
199: }
200: DPRINTF(("fat_get_dirent: %s\n", de->name));
201: de++;
202: }
203: return EAGAIN;
204: }
205:
206: /*
207: * Get directory entry for specified index.
208: *
209: * @dvp: vnode for directory.
210: * @index: index of the entry
211: * @np: pointer to fat node
212: */
213: int
214: fatfs_get_node(vnode_t dvp, int index, struct fatfs_node *np)
215: {
216: struct fatfsmount *fmp;
217: u_long cl, sec;
218: int i, cur_index, err;
219:
220: fmp = (struct fatfsmount *)dvp->v_mount->m_data;
221: cl = dvp->v_blkno;
222: cur_index = 0;
223:
224: DPRINTF(("fatfs_get_node: index=%d\n", index));
225:
226: if (cl == CL_ROOT) {
227: /* Get entry from the root directory */
228: for (sec = fmp->root_start; sec < fmp->data_start; sec++) {
229: err = fat_get_dirent(fmp, sec, index, &cur_index, np);
230: if (err != EAGAIN)
231: return err;
232: }
233: } else {
234: /* Get entry from the sub directory */
235: while (!IS_EOFCL(fmp, cl)) {
236: sec = cl_to_sec(fmp, cl);
237: for (i = 0; i < fmp->sec_per_cl; i++) {
238: err = fat_get_dirent(fmp, sec, index,
239: &cur_index, np);
240: if (err != EAGAIN)
241: return err;
242: sec++;
243: }
244: err = fat_next_cluster(fmp, cl, &cl);
245: if (err)
246: return err;
247: }
248: }
249: return ENOENT;
250: }
251:
252: /*
253: * Find empty directory entry and put new entry on it.
254: *
255: * @fmp: fatfs mount point
256: * @sec: sector#
257: * @np: pointer to fat node
258: */
259: static int
260: fat_add_dirent(struct fatfsmount *fmp, u_long sec, struct fatfs_node *np)
261: {
262: struct fat_dirent *de;
263: int err, i;
264:
265: err = fat_read_dirent(fmp, sec);
266: if (err)
267: return err;
268:
269: de = (struct fat_dirent *)fmp->dir_buf;
270: for (i = 0; i < DIR_PER_SEC; i++) {
271: if (IS_DELETED(de) || IS_EMPTY(de))
272: goto found;
273: DPRINTF(("fat_add_dirent: scan %s\n", de->name));
274: de++;
275: }
276: return ENOENT;
277:
278: found:
279: DPRINTF(("fat_add_dirent: found. sec=%d\n", sec));
280: memcpy(de, &np->dirent, sizeof(struct fat_dirent));
281: err = fat_write_dirent(fmp, sec);
282: return err;
283: }
284:
285: /*
286: * Find empty directory entry and put new entry on it.
287: * This search is done only in directory of specified cluster.
288: * @dvp: vnode for directory.
289: * @np: pointer to fat node
290: */
291: int
292: fatfs_add_node(vnode_t dvp, struct fatfs_node *np)
293: {
294: struct fatfsmount *fmp;
295: u_long cl, sec;
296: int i, err;
297: u_long next;
298:
299: fmp = (struct fatfsmount *)dvp->v_mount->m_data;
300: cl = dvp->v_blkno;
301:
302: DPRINTF(("fatfs_add_node: cl=%d\n", cl));
303:
304: if (cl == CL_ROOT) {
305: /* Add entry in root directory */
306: for (sec = fmp->root_start; sec < fmp->data_start; sec++) {
307: err = fat_add_dirent(fmp, sec, np);
308: if (err != ENOENT)
309: return err;
310: }
311: } else {
312: /* Search entry in sub directory */
313: while (!IS_EOFCL(fmp, cl)) {
314: sec = cl_to_sec(fmp, cl);
315: for (i = 0; i < fmp->sec_per_cl; i++) {
316: err = fat_add_dirent(fmp, sec, np);
317: if (err != ENOENT)
318: return err;
319: sec++;
320: }
321: err = fat_next_cluster(fmp, cl, &next);
322: if (err)
323: return err;
324: cl = next;
325: }
326: /* No entry found, add one more free cluster for directory */
327: DPRINTF(("fatfs_add_node: expand dir\n"));
328: err = fat_expand_dir(fmp, cl, &next);
329: if (err)
330: return err;
331:
332: /* Initialize free cluster. */
333: memset(fmp->dir_buf, 0, SEC_SIZE);
334: sec = cl_to_sec(fmp, next);
335: for (i = 0; i < fmp->sec_per_cl; i++) {
336: err = fat_write_dirent(fmp, sec);
337: if (err)
338: return err;
339: sec++;
340: }
341: /* Try again */
342: sec = cl_to_sec(fmp, next);
343: err = fat_add_dirent(fmp, sec, np);
344: return err;
345: }
346: return ENOENT;
347: }
348:
349: /*
350: * Put directory entry.
351: * @fmp: fat mount data
352: * @np: pointer to fat node
353: */
354: int
355: fatfs_put_node(struct fatfsmount *fmp, struct fatfs_node *np)
356: {
357: int err;
358:
359: err = fat_read_dirent(fmp, np->sector);
360: if (err)
361: return err;
362:
363: memcpy(fmp->dir_buf + np->offset, &np->dirent,
364: sizeof(struct fat_dirent));
365:
366: err = fat_write_dirent(fmp, np->sector);
367: return err;
368: }
369: