diff options
Diffstat (limited to 'fs/ufs/dir.c')
-rw-r--r-- | fs/ufs/dir.c | 627 |
1 files changed, 627 insertions, 0 deletions
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c new file mode 100644 index 000000000000..d0915fba155a --- /dev/null +++ b/fs/ufs/dir.c | |||
@@ -0,0 +1,627 @@ | |||
1 | /* | ||
2 | * linux/fs/ufs/ufs_dir.c | ||
3 | * | ||
4 | * Copyright (C) 1996 | ||
5 | * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu) | ||
6 | * Laboratory for Computer Science Research Computing Facility | ||
7 | * Rutgers, The State University of New Jersey | ||
8 | * | ||
9 | * swab support by Francois-Rene Rideau <fare@tunes.org> 19970406 | ||
10 | * | ||
11 | * 4.4BSD (FreeBSD) support added on February 1st 1998 by | ||
12 | * Niels Kristian Bech Jensen <nkbj@image.dk> partially based | ||
13 | * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>. | ||
14 | */ | ||
15 | |||
16 | #include <linux/time.h> | ||
17 | #include <linux/fs.h> | ||
18 | #include <linux/ufs_fs.h> | ||
19 | #include <linux/smp_lock.h> | ||
20 | #include <linux/buffer_head.h> | ||
21 | #include <linux/sched.h> | ||
22 | |||
23 | #include "swab.h" | ||
24 | #include "util.h" | ||
25 | |||
26 | #undef UFS_DIR_DEBUG | ||
27 | |||
28 | #ifdef UFS_DIR_DEBUG | ||
29 | #define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x; | ||
30 | #else | ||
31 | #define UFSD(x) | ||
32 | #endif | ||
33 | |||
34 | static int | ||
35 | ufs_check_dir_entry (const char *, struct inode *, struct ufs_dir_entry *, | ||
36 | struct buffer_head *, unsigned long); | ||
37 | |||
38 | |||
39 | /* | ||
40 | * NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure. | ||
41 | * | ||
42 | * len <= UFS_MAXNAMLEN and de != NULL are guaranteed by caller. | ||
43 | */ | ||
44 | static inline int ufs_match(struct super_block *sb, int len, | ||
45 | const char * const name, struct ufs_dir_entry * de) | ||
46 | { | ||
47 | if (len != ufs_get_de_namlen(sb, de)) | ||
48 | return 0; | ||
49 | if (!de->d_ino) | ||
50 | return 0; | ||
51 | return !memcmp(name, de->d_name, len); | ||
52 | } | ||
53 | |||
54 | /* | ||
55 | * This is blatantly stolen from ext2fs | ||
56 | */ | ||
57 | static int | ||
58 | ufs_readdir (struct file * filp, void * dirent, filldir_t filldir) | ||
59 | { | ||
60 | struct inode *inode = filp->f_dentry->d_inode; | ||
61 | int error = 0; | ||
62 | unsigned long offset, lblk; | ||
63 | int i, stored; | ||
64 | struct buffer_head * bh; | ||
65 | struct ufs_dir_entry * de; | ||
66 | struct super_block * sb; | ||
67 | int de_reclen; | ||
68 | unsigned flags; | ||
69 | u64 blk= 0L; | ||
70 | |||
71 | lock_kernel(); | ||
72 | |||
73 | sb = inode->i_sb; | ||
74 | flags = UFS_SB(sb)->s_flags; | ||
75 | |||
76 | UFSD(("ENTER, ino %lu f_pos %lu\n", inode->i_ino, (unsigned long) filp->f_pos)) | ||
77 | |||
78 | stored = 0; | ||
79 | bh = NULL; | ||
80 | offset = filp->f_pos & (sb->s_blocksize - 1); | ||
81 | |||
82 | while (!error && !stored && filp->f_pos < inode->i_size) { | ||
83 | lblk = (filp->f_pos) >> sb->s_blocksize_bits; | ||
84 | blk = ufs_frag_map(inode, lblk); | ||
85 | if (!blk || !(bh = sb_bread(sb, blk))) { | ||
86 | /* XXX - error - skip to the next block */ | ||
87 | printk("ufs_readdir: " | ||
88 | "dir inode %lu has a hole at offset %lu\n", | ||
89 | inode->i_ino, (unsigned long int)filp->f_pos); | ||
90 | filp->f_pos += sb->s_blocksize - offset; | ||
91 | continue; | ||
92 | } | ||
93 | |||
94 | revalidate: | ||
95 | /* If the dir block has changed since the last call to | ||
96 | * readdir(2), then we might be pointing to an invalid | ||
97 | * dirent right now. Scan from the start of the block | ||
98 | * to make sure. */ | ||
99 | if (filp->f_version != inode->i_version) { | ||
100 | for (i = 0; i < sb->s_blocksize && i < offset; ) { | ||
101 | de = (struct ufs_dir_entry *)(bh->b_data + i); | ||
102 | /* It's too expensive to do a full | ||
103 | * dirent test each time round this | ||
104 | * loop, but we do have to test at | ||
105 | * least that it is non-zero. A | ||
106 | * failure will be detected in the | ||
107 | * dirent test below. */ | ||
108 | de_reclen = fs16_to_cpu(sb, de->d_reclen); | ||
109 | if (de_reclen < 1) | ||
110 | break; | ||
111 | i += de_reclen; | ||
112 | } | ||
113 | offset = i; | ||
114 | filp->f_pos = (filp->f_pos & ~(sb->s_blocksize - 1)) | ||
115 | | offset; | ||
116 | filp->f_version = inode->i_version; | ||
117 | } | ||
118 | |||
119 | while (!error && filp->f_pos < inode->i_size | ||
120 | && offset < sb->s_blocksize) { | ||
121 | de = (struct ufs_dir_entry *) (bh->b_data + offset); | ||
122 | /* XXX - put in a real ufs_check_dir_entry() */ | ||
123 | if ((de->d_reclen == 0) || (ufs_get_de_namlen(sb, de) == 0)) { | ||
124 | filp->f_pos = (filp->f_pos & | ||
125 | (sb->s_blocksize - 1)) + | ||
126 | sb->s_blocksize; | ||
127 | brelse(bh); | ||
128 | unlock_kernel(); | ||
129 | return stored; | ||
130 | } | ||
131 | if (!ufs_check_dir_entry ("ufs_readdir", inode, de, | ||
132 | bh, offset)) { | ||
133 | /* On error, skip the f_pos to the | ||
134 | next block. */ | ||
135 | filp->f_pos = (filp->f_pos | | ||
136 | (sb->s_blocksize - 1)) + | ||
137 | 1; | ||
138 | brelse (bh); | ||
139 | unlock_kernel(); | ||
140 | return stored; | ||
141 | } | ||
142 | offset += fs16_to_cpu(sb, de->d_reclen); | ||
143 | if (de->d_ino) { | ||
144 | /* We might block in the next section | ||
145 | * if the data destination is | ||
146 | * currently swapped out. So, use a | ||
147 | * version stamp to detect whether or | ||
148 | * not the directory has been modified | ||
149 | * during the copy operation. */ | ||
150 | unsigned long version = filp->f_version; | ||
151 | unsigned char d_type = DT_UNKNOWN; | ||
152 | |||
153 | UFSD(("filldir(%s,%u)\n", de->d_name, | ||
154 | fs32_to_cpu(sb, de->d_ino))) | ||
155 | UFSD(("namlen %u\n", ufs_get_de_namlen(sb, de))) | ||
156 | |||
157 | if ((flags & UFS_DE_MASK) == UFS_DE_44BSD) | ||
158 | d_type = de->d_u.d_44.d_type; | ||
159 | error = filldir(dirent, de->d_name, | ||
160 | ufs_get_de_namlen(sb, de), filp->f_pos, | ||
161 | fs32_to_cpu(sb, de->d_ino), d_type); | ||
162 | if (error) | ||
163 | break; | ||
164 | if (version != filp->f_version) | ||
165 | goto revalidate; | ||
166 | stored ++; | ||
167 | } | ||
168 | filp->f_pos += fs16_to_cpu(sb, de->d_reclen); | ||
169 | } | ||
170 | offset = 0; | ||
171 | brelse (bh); | ||
172 | } | ||
173 | unlock_kernel(); | ||
174 | return 0; | ||
175 | } | ||
176 | |||
177 | /* | ||
178 | * define how far ahead to read directories while searching them. | ||
179 | */ | ||
180 | #define NAMEI_RA_CHUNKS 2 | ||
181 | #define NAMEI_RA_BLOCKS 4 | ||
182 | #define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS) | ||
183 | #define NAMEI_RA_INDEX(c,b) (((c) * NAMEI_RA_BLOCKS) + (b)) | ||
184 | |||
185 | /* | ||
186 | * ufs_find_entry() | ||
187 | * | ||
188 | * finds an entry in the specified directory with the wanted name. It | ||
189 | * returns the cache buffer in which the entry was found, and the entry | ||
190 | * itself (as a parameter - res_bh). It does NOT read the inode of the | ||
191 | * entry - you'll have to do that yourself if you want to. | ||
192 | */ | ||
193 | struct ufs_dir_entry * ufs_find_entry (struct dentry *dentry, | ||
194 | struct buffer_head ** res_bh) | ||
195 | { | ||
196 | struct super_block * sb; | ||
197 | struct buffer_head * bh_use[NAMEI_RA_SIZE]; | ||
198 | struct buffer_head * bh_read[NAMEI_RA_SIZE]; | ||
199 | unsigned long offset; | ||
200 | int block, toread, i, err; | ||
201 | struct inode *dir = dentry->d_parent->d_inode; | ||
202 | const char *name = dentry->d_name.name; | ||
203 | int namelen = dentry->d_name.len; | ||
204 | |||
205 | UFSD(("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen)) | ||
206 | |||
207 | *res_bh = NULL; | ||
208 | |||
209 | sb = dir->i_sb; | ||
210 | |||
211 | if (namelen > UFS_MAXNAMLEN) | ||
212 | return NULL; | ||
213 | |||
214 | memset (bh_use, 0, sizeof (bh_use)); | ||
215 | toread = 0; | ||
216 | for (block = 0; block < NAMEI_RA_SIZE; ++block) { | ||
217 | struct buffer_head * bh; | ||
218 | |||
219 | if ((block << sb->s_blocksize_bits) >= dir->i_size) | ||
220 | break; | ||
221 | bh = ufs_getfrag (dir, block, 0, &err); | ||
222 | bh_use[block] = bh; | ||
223 | if (bh && !buffer_uptodate(bh)) | ||
224 | bh_read[toread++] = bh; | ||
225 | } | ||
226 | |||
227 | for (block = 0, offset = 0; offset < dir->i_size; block++) { | ||
228 | struct buffer_head * bh; | ||
229 | struct ufs_dir_entry * de; | ||
230 | char * dlimit; | ||
231 | |||
232 | if ((block % NAMEI_RA_BLOCKS) == 0 && toread) { | ||
233 | ll_rw_block (READ, toread, bh_read); | ||
234 | toread = 0; | ||
235 | } | ||
236 | bh = bh_use[block % NAMEI_RA_SIZE]; | ||
237 | if (!bh) { | ||
238 | ufs_error (sb, "ufs_find_entry", | ||
239 | "directory #%lu contains a hole at offset %lu", | ||
240 | dir->i_ino, offset); | ||
241 | offset += sb->s_blocksize; | ||
242 | continue; | ||
243 | } | ||
244 | wait_on_buffer (bh); | ||
245 | if (!buffer_uptodate(bh)) { | ||
246 | /* | ||
247 | * read error: all bets are off | ||
248 | */ | ||
249 | break; | ||
250 | } | ||
251 | |||
252 | de = (struct ufs_dir_entry *) bh->b_data; | ||
253 | dlimit = bh->b_data + sb->s_blocksize; | ||
254 | while ((char *) de < dlimit && offset < dir->i_size) { | ||
255 | /* this code is executed quadratically often */ | ||
256 | /* do minimal checking by hand */ | ||
257 | int de_len; | ||
258 | |||
259 | if ((char *) de + namelen <= dlimit && | ||
260 | ufs_match(sb, namelen, name, de)) { | ||
261 | /* found a match - | ||
262 | just to be sure, do a full check */ | ||
263 | if (!ufs_check_dir_entry("ufs_find_entry", | ||
264 | dir, de, bh, offset)) | ||
265 | goto failed; | ||
266 | for (i = 0; i < NAMEI_RA_SIZE; ++i) { | ||
267 | if (bh_use[i] != bh) | ||
268 | brelse (bh_use[i]); | ||
269 | } | ||
270 | *res_bh = bh; | ||
271 | return de; | ||
272 | } | ||
273 | /* prevent looping on a bad block */ | ||
274 | de_len = fs16_to_cpu(sb, de->d_reclen); | ||
275 | if (de_len <= 0) | ||
276 | goto failed; | ||
277 | offset += de_len; | ||
278 | de = (struct ufs_dir_entry *) ((char *) de + de_len); | ||
279 | } | ||
280 | |||
281 | brelse (bh); | ||
282 | if (((block + NAMEI_RA_SIZE) << sb->s_blocksize_bits ) >= | ||
283 | dir->i_size) | ||
284 | bh = NULL; | ||
285 | else | ||
286 | bh = ufs_getfrag (dir, block + NAMEI_RA_SIZE, 0, &err); | ||
287 | bh_use[block % NAMEI_RA_SIZE] = bh; | ||
288 | if (bh && !buffer_uptodate(bh)) | ||
289 | bh_read[toread++] = bh; | ||
290 | } | ||
291 | |||
292 | failed: | ||
293 | for (i = 0; i < NAMEI_RA_SIZE; ++i) brelse (bh_use[i]); | ||
294 | UFSD(("EXIT\n")) | ||
295 | return NULL; | ||
296 | } | ||
297 | |||
298 | static int | ||
299 | ufs_check_dir_entry (const char *function, struct inode *dir, | ||
300 | struct ufs_dir_entry *de, struct buffer_head *bh, | ||
301 | unsigned long offset) | ||
302 | { | ||
303 | struct super_block *sb = dir->i_sb; | ||
304 | const char *error_msg = NULL; | ||
305 | int rlen = fs16_to_cpu(sb, de->d_reclen); | ||
306 | |||
307 | if (rlen < UFS_DIR_REC_LEN(1)) | ||
308 | error_msg = "reclen is smaller than minimal"; | ||
309 | else if (rlen % 4 != 0) | ||
310 | error_msg = "reclen % 4 != 0"; | ||
311 | else if (rlen < UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de))) | ||
312 | error_msg = "reclen is too small for namlen"; | ||
313 | else if (((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize) | ||
314 | error_msg = "directory entry across blocks"; | ||
315 | else if (fs32_to_cpu(sb, de->d_ino) > (UFS_SB(sb)->s_uspi->s_ipg * | ||
316 | UFS_SB(sb)->s_uspi->s_ncg)) | ||
317 | error_msg = "inode out of bounds"; | ||
318 | |||
319 | if (error_msg != NULL) | ||
320 | ufs_error (sb, function, "bad entry in directory #%lu, size %Lu: %s - " | ||
321 | "offset=%lu, inode=%lu, reclen=%d, namlen=%d", | ||
322 | dir->i_ino, dir->i_size, error_msg, offset, | ||
323 | (unsigned long)fs32_to_cpu(sb, de->d_ino), | ||
324 | rlen, ufs_get_de_namlen(sb, de)); | ||
325 | |||
326 | return (error_msg == NULL ? 1 : 0); | ||
327 | } | ||
328 | |||
329 | struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct buffer_head **p) | ||
330 | { | ||
331 | int err; | ||
332 | struct buffer_head *bh = ufs_bread (dir, 0, 0, &err); | ||
333 | struct ufs_dir_entry *res = NULL; | ||
334 | |||
335 | if (bh) { | ||
336 | res = (struct ufs_dir_entry *) bh->b_data; | ||
337 | res = (struct ufs_dir_entry *)((char *)res + | ||
338 | fs16_to_cpu(dir->i_sb, res->d_reclen)); | ||
339 | } | ||
340 | *p = bh; | ||
341 | return res; | ||
342 | } | ||
343 | ino_t ufs_inode_by_name(struct inode * dir, struct dentry *dentry) | ||
344 | { | ||
345 | ino_t res = 0; | ||
346 | struct ufs_dir_entry * de; | ||
347 | struct buffer_head *bh; | ||
348 | |||
349 | de = ufs_find_entry (dentry, &bh); | ||
350 | if (de) { | ||
351 | res = fs32_to_cpu(dir->i_sb, de->d_ino); | ||
352 | brelse(bh); | ||
353 | } | ||
354 | return res; | ||
355 | } | ||
356 | |||
357 | void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de, | ||
358 | struct buffer_head *bh, struct inode *inode) | ||
359 | { | ||
360 | dir->i_version++; | ||
361 | de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino); | ||
362 | mark_buffer_dirty(bh); | ||
363 | if (IS_DIRSYNC(dir)) | ||
364 | sync_dirty_buffer(bh); | ||
365 | brelse (bh); | ||
366 | } | ||
367 | |||
368 | /* | ||
369 | * ufs_add_entry() | ||
370 | * | ||
371 | * adds a file entry to the specified directory, using the same | ||
372 | * semantics as ufs_find_entry(). It returns NULL if it failed. | ||
373 | */ | ||
374 | int ufs_add_link(struct dentry *dentry, struct inode *inode) | ||
375 | { | ||
376 | struct super_block * sb; | ||
377 | struct ufs_sb_private_info * uspi; | ||
378 | unsigned long offset; | ||
379 | unsigned fragoff; | ||
380 | unsigned short rec_len; | ||
381 | struct buffer_head * bh; | ||
382 | struct ufs_dir_entry * de, * de1; | ||
383 | struct inode *dir = dentry->d_parent->d_inode; | ||
384 | const char *name = dentry->d_name.name; | ||
385 | int namelen = dentry->d_name.len; | ||
386 | int err; | ||
387 | |||
388 | UFSD(("ENTER, name %s, namelen %u\n", name, namelen)) | ||
389 | |||
390 | sb = dir->i_sb; | ||
391 | uspi = UFS_SB(sb)->s_uspi; | ||
392 | |||
393 | if (!namelen) | ||
394 | return -EINVAL; | ||
395 | bh = ufs_bread (dir, 0, 0, &err); | ||
396 | if (!bh) | ||
397 | return err; | ||
398 | rec_len = UFS_DIR_REC_LEN(namelen); | ||
399 | offset = 0; | ||
400 | de = (struct ufs_dir_entry *) bh->b_data; | ||
401 | while (1) { | ||
402 | if ((char *)de >= UFS_SECTOR_SIZE + bh->b_data) { | ||
403 | fragoff = offset & ~uspi->s_fmask; | ||
404 | if (fragoff != 0 && fragoff != UFS_SECTOR_SIZE) | ||
405 | ufs_error (sb, "ufs_add_entry", "internal error" | ||
406 | " fragoff %u", fragoff); | ||
407 | if (!fragoff) { | ||
408 | brelse (bh); | ||
409 | bh = ufs_bread (dir, offset >> sb->s_blocksize_bits, 1, &err); | ||
410 | if (!bh) | ||
411 | return err; | ||
412 | } | ||
413 | if (dir->i_size <= offset) { | ||
414 | if (dir->i_size == 0) { | ||
415 | brelse(bh); | ||
416 | return -ENOENT; | ||
417 | } | ||
418 | de = (struct ufs_dir_entry *) (bh->b_data + fragoff); | ||
419 | de->d_ino = 0; | ||
420 | de->d_reclen = cpu_to_fs16(sb, UFS_SECTOR_SIZE); | ||
421 | ufs_set_de_namlen(sb, de, 0); | ||
422 | dir->i_size = offset + UFS_SECTOR_SIZE; | ||
423 | mark_inode_dirty(dir); | ||
424 | } else { | ||
425 | de = (struct ufs_dir_entry *) bh->b_data; | ||
426 | } | ||
427 | } | ||
428 | if (!ufs_check_dir_entry ("ufs_add_entry", dir, de, bh, offset)) { | ||
429 | brelse (bh); | ||
430 | return -ENOENT; | ||
431 | } | ||
432 | if (ufs_match(sb, namelen, name, de)) { | ||
433 | brelse (bh); | ||
434 | return -EEXIST; | ||
435 | } | ||
436 | if (de->d_ino == 0 && fs16_to_cpu(sb, de->d_reclen) >= rec_len) | ||
437 | break; | ||
438 | |||
439 | if (fs16_to_cpu(sb, de->d_reclen) >= | ||
440 | UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)) + rec_len) | ||
441 | break; | ||
442 | offset += fs16_to_cpu(sb, de->d_reclen); | ||
443 | de = (struct ufs_dir_entry *) ((char *) de + fs16_to_cpu(sb, de->d_reclen)); | ||
444 | } | ||
445 | |||
446 | if (de->d_ino) { | ||
447 | de1 = (struct ufs_dir_entry *) ((char *) de + | ||
448 | UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de))); | ||
449 | de1->d_reclen = | ||
450 | cpu_to_fs16(sb, fs16_to_cpu(sb, de->d_reclen) - | ||
451 | UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de))); | ||
452 | de->d_reclen = | ||
453 | cpu_to_fs16(sb, UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de))); | ||
454 | de = de1; | ||
455 | } | ||
456 | de->d_ino = 0; | ||
457 | ufs_set_de_namlen(sb, de, namelen); | ||
458 | memcpy (de->d_name, name, namelen + 1); | ||
459 | de->d_ino = cpu_to_fs32(sb, inode->i_ino); | ||
460 | ufs_set_de_type(sb, de, inode->i_mode); | ||
461 | mark_buffer_dirty(bh); | ||
462 | if (IS_DIRSYNC(dir)) | ||
463 | sync_dirty_buffer(bh); | ||
464 | brelse (bh); | ||
465 | dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; | ||
466 | dir->i_version++; | ||
467 | mark_inode_dirty(dir); | ||
468 | |||
469 | UFSD(("EXIT\n")) | ||
470 | return 0; | ||
471 | } | ||
472 | |||
473 | /* | ||
474 | * ufs_delete_entry deletes a directory entry by merging it with the | ||
475 | * previous entry. | ||
476 | */ | ||
477 | int ufs_delete_entry (struct inode * inode, struct ufs_dir_entry * dir, | ||
478 | struct buffer_head * bh ) | ||
479 | |||
480 | { | ||
481 | struct super_block * sb; | ||
482 | struct ufs_dir_entry * de, * pde; | ||
483 | unsigned i; | ||
484 | |||
485 | UFSD(("ENTER\n")) | ||
486 | |||
487 | sb = inode->i_sb; | ||
488 | i = 0; | ||
489 | pde = NULL; | ||
490 | de = (struct ufs_dir_entry *) bh->b_data; | ||
491 | |||
492 | UFSD(("ino %u, reclen %u, namlen %u, name %s\n", | ||
493 | fs32_to_cpu(sb, de->d_ino), | ||
494 | fs16to_cpu(sb, de->d_reclen), | ||
495 | ufs_get_de_namlen(sb, de), de->d_name)) | ||
496 | |||
497 | while (i < bh->b_size) { | ||
498 | if (!ufs_check_dir_entry ("ufs_delete_entry", inode, de, bh, i)) { | ||
499 | brelse(bh); | ||
500 | return -EIO; | ||
501 | } | ||
502 | if (de == dir) { | ||
503 | if (pde) | ||
504 | fs16_add(sb, &pde->d_reclen, | ||
505 | fs16_to_cpu(sb, dir->d_reclen)); | ||
506 | dir->d_ino = 0; | ||
507 | inode->i_version++; | ||
508 | inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; | ||
509 | mark_inode_dirty(inode); | ||
510 | mark_buffer_dirty(bh); | ||
511 | if (IS_DIRSYNC(inode)) | ||
512 | sync_dirty_buffer(bh); | ||
513 | brelse(bh); | ||
514 | UFSD(("EXIT\n")) | ||
515 | return 0; | ||
516 | } | ||
517 | i += fs16_to_cpu(sb, de->d_reclen); | ||
518 | if (i == UFS_SECTOR_SIZE) pde = NULL; | ||
519 | else pde = de; | ||
520 | de = (struct ufs_dir_entry *) | ||
521 | ((char *) de + fs16_to_cpu(sb, de->d_reclen)); | ||
522 | if (i == UFS_SECTOR_SIZE && de->d_reclen == 0) | ||
523 | break; | ||
524 | } | ||
525 | UFSD(("EXIT\n")) | ||
526 | brelse(bh); | ||
527 | return -ENOENT; | ||
528 | } | ||
529 | |||
530 | int ufs_make_empty(struct inode * inode, struct inode *dir) | ||
531 | { | ||
532 | struct super_block * sb = dir->i_sb; | ||
533 | struct buffer_head * dir_block; | ||
534 | struct ufs_dir_entry * de; | ||
535 | int err; | ||
536 | |||
537 | dir_block = ufs_bread (inode, 0, 1, &err); | ||
538 | if (!dir_block) | ||
539 | return err; | ||
540 | |||
541 | inode->i_blocks = sb->s_blocksize / UFS_SECTOR_SIZE; | ||
542 | de = (struct ufs_dir_entry *) dir_block->b_data; | ||
543 | de->d_ino = cpu_to_fs32(sb, inode->i_ino); | ||
544 | ufs_set_de_type(sb, de, inode->i_mode); | ||
545 | ufs_set_de_namlen(sb, de, 1); | ||
546 | de->d_reclen = cpu_to_fs16(sb, UFS_DIR_REC_LEN(1)); | ||
547 | strcpy (de->d_name, "."); | ||
548 | de = (struct ufs_dir_entry *) | ||
549 | ((char *)de + fs16_to_cpu(sb, de->d_reclen)); | ||
550 | de->d_ino = cpu_to_fs32(sb, dir->i_ino); | ||
551 | ufs_set_de_type(sb, de, dir->i_mode); | ||
552 | de->d_reclen = cpu_to_fs16(sb, UFS_SECTOR_SIZE - UFS_DIR_REC_LEN(1)); | ||
553 | ufs_set_de_namlen(sb, de, 2); | ||
554 | strcpy (de->d_name, ".."); | ||
555 | mark_buffer_dirty(dir_block); | ||
556 | brelse (dir_block); | ||
557 | mark_inode_dirty(inode); | ||
558 | return 0; | ||
559 | } | ||
560 | |||
561 | /* | ||
562 | * routine to check that the specified directory is empty (for rmdir) | ||
563 | */ | ||
564 | int ufs_empty_dir (struct inode * inode) | ||
565 | { | ||
566 | struct super_block * sb; | ||
567 | unsigned long offset; | ||
568 | struct buffer_head * bh; | ||
569 | struct ufs_dir_entry * de, * de1; | ||
570 | int err; | ||
571 | |||
572 | sb = inode->i_sb; | ||
573 | |||
574 | if (inode->i_size < UFS_DIR_REC_LEN(1) + UFS_DIR_REC_LEN(2) || | ||
575 | !(bh = ufs_bread (inode, 0, 0, &err))) { | ||
576 | ufs_warning (inode->i_sb, "empty_dir", | ||
577 | "bad directory (dir #%lu) - no data block", | ||
578 | inode->i_ino); | ||
579 | return 1; | ||
580 | } | ||
581 | de = (struct ufs_dir_entry *) bh->b_data; | ||
582 | de1 = (struct ufs_dir_entry *) | ||
583 | ((char *)de + fs16_to_cpu(sb, de->d_reclen)); | ||
584 | if (fs32_to_cpu(sb, de->d_ino) != inode->i_ino || de1->d_ino == 0 || | ||
585 | strcmp (".", de->d_name) || strcmp ("..", de1->d_name)) { | ||
586 | ufs_warning (inode->i_sb, "empty_dir", | ||
587 | "bad directory (dir #%lu) - no `.' or `..'", | ||
588 | inode->i_ino); | ||
589 | return 1; | ||
590 | } | ||
591 | offset = fs16_to_cpu(sb, de->d_reclen) + fs16_to_cpu(sb, de1->d_reclen); | ||
592 | de = (struct ufs_dir_entry *) | ||
593 | ((char *)de1 + fs16_to_cpu(sb, de1->d_reclen)); | ||
594 | while (offset < inode->i_size ) { | ||
595 | if (!bh || (void *) de >= (void *) (bh->b_data + sb->s_blocksize)) { | ||
596 | brelse (bh); | ||
597 | bh = ufs_bread (inode, offset >> sb->s_blocksize_bits, 1, &err); | ||
598 | if (!bh) { | ||
599 | ufs_error (sb, "empty_dir", | ||
600 | "directory #%lu contains a hole at offset %lu", | ||
601 | inode->i_ino, offset); | ||
602 | offset += sb->s_blocksize; | ||
603 | continue; | ||
604 | } | ||
605 | de = (struct ufs_dir_entry *) bh->b_data; | ||
606 | } | ||
607 | if (!ufs_check_dir_entry ("empty_dir", inode, de, bh, offset)) { | ||
608 | brelse (bh); | ||
609 | return 1; | ||
610 | } | ||
611 | if (de->d_ino) { | ||
612 | brelse (bh); | ||
613 | return 0; | ||
614 | } | ||
615 | offset += fs16_to_cpu(sb, de->d_reclen); | ||
616 | de = (struct ufs_dir_entry *) | ||
617 | ((char *)de + fs16_to_cpu(sb, de->d_reclen)); | ||
618 | } | ||
619 | brelse (bh); | ||
620 | return 1; | ||
621 | } | ||
622 | |||
623 | struct file_operations ufs_dir_operations = { | ||
624 | .read = generic_read_dir, | ||
625 | .readdir = ufs_readdir, | ||
626 | .fsync = file_fsync, | ||
627 | }; | ||