2 * linux/fs/ufs/ufs_dir.c
5 * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
6 * Laboratory for Computer Science Research Computing Facility
7 * Rutgers, The State University of New Jersey
9 * swab support by Francois-Rene Rideau <fare@tunes.org> 19970406
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>.
15 * Migration to usage of "page cache" on May 2006 by
16 * Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base.
19 #include <linux/time.h>
21 #include <linux/ufs_fs.h>
22 #include <linux/smp_lock.h>
23 #include <linux/sched.h>
29 * NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure.
31 * len <= UFS_MAXNAMLEN and de != NULL are guaranteed by caller.
33 static inline int ufs_match(struct super_block *sb, int len,
34 const char * const name, struct ufs_dir_entry * de)
36 if (len != ufs_get_de_namlen(sb, de))
40 return !memcmp(name, de->d_name, len);
43 static int ufs_commit_chunk(struct page *page, unsigned from, unsigned to)
45 struct inode *dir = page->mapping->host;
48 page->mapping->a_ops->commit_write(NULL, page, from, to);
50 err = write_one_page(page, 1);
56 static inline void ufs_put_page(struct page *page)
59 page_cache_release(page);
62 static inline unsigned long ufs_dir_pages(struct inode *inode)
64 return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
67 ino_t ufs_inode_by_name(struct inode *dir, struct dentry *dentry)
70 struct ufs_dir_entry *de;
73 de = ufs_find_entry(dir, dentry, &page);
75 res = fs32_to_cpu(dir->i_sb, de->d_ino);
82 /* Releases the page */
83 void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
84 struct page *page, struct inode *inode)
86 unsigned from = (char *) de - (char *) page_address(page);
87 unsigned to = from + fs16_to_cpu(dir->i_sb, de->d_reclen);
91 err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
93 de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino);
94 ufs_set_de_type(dir->i_sb, de, inode->i_mode);
95 err = ufs_commit_chunk(page, from, to);
97 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
98 mark_inode_dirty(dir);
102 static void ufs_check_page(struct page *page)
104 struct inode *dir = page->mapping->host;
105 struct super_block *sb = dir->i_sb;
106 char *kaddr = page_address(page);
107 unsigned offs, rec_len;
108 unsigned limit = PAGE_CACHE_SIZE;
109 struct ufs_dir_entry *p;
112 if ((dir->i_size >> PAGE_CACHE_SHIFT) == page->index) {
113 limit = dir->i_size & ~PAGE_CACHE_MASK;
114 if (limit & (UFS_SECTOR_SIZE - 1))
119 for (offs = 0; offs <= limit - UFS_DIR_REC_LEN(1); offs += rec_len) {
120 p = (struct ufs_dir_entry *)(kaddr + offs);
121 rec_len = fs16_to_cpu(sb, p->d_reclen);
123 if (rec_len < UFS_DIR_REC_LEN(1))
127 if (rec_len < UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, p)))
129 if (((offs + rec_len - 1) ^ offs) & ~(UFS_SECTOR_SIZE-1))
131 if (fs32_to_cpu(sb, p->d_ino) > (UFS_SB(sb)->s_uspi->s_ipg *
132 UFS_SB(sb)->s_uspi->s_ncg))
138 SetPageChecked(page);
141 /* Too bad, we had an error */
144 ufs_error(sb, "ufs_check_page",
145 "size of directory #%lu is not a multiple of chunk size",
150 error = "rec_len is smaller than minimal";
153 error = "unaligned directory entry";
156 error = "rec_len is too small for name_len";
159 error = "directory entry across blocks";
162 error = "inode out of bounds";
164 ufs_error (sb, "ufs_check_page", "bad entry in directory #%lu: %s - "
165 "offset=%lu, rec_len=%d, name_len=%d",
166 dir->i_ino, error, (page->index<<PAGE_CACHE_SHIFT)+offs,
167 rec_len, ufs_get_de_namlen(sb, p));
170 p = (struct ufs_dir_entry *)(kaddr + offs);
171 ufs_error (sb, "ext2_check_page",
172 "entry in directory #%lu spans the page boundary"
174 dir->i_ino, (page->index<<PAGE_CACHE_SHIFT)+offs);
176 SetPageChecked(page);
180 static struct page *ufs_get_page(struct inode *dir, unsigned long n)
182 struct address_space *mapping = dir->i_mapping;
183 struct page *page = read_cache_page(mapping, n,
184 (filler_t*)mapping->a_ops->readpage, NULL);
186 wait_on_page_locked(page);
188 if (!PageUptodate(page))
190 if (!PageChecked(page))
191 ufs_check_page(page);
199 return ERR_PTR(-EIO);
203 * Return the offset into page `page_nr' of the last valid
204 * byte in that page, plus one.
207 ufs_last_byte(struct inode *inode, unsigned long page_nr)
209 unsigned last_byte = inode->i_size;
211 last_byte -= page_nr << PAGE_CACHE_SHIFT;
212 if (last_byte > PAGE_CACHE_SIZE)
213 last_byte = PAGE_CACHE_SIZE;
217 static inline struct ufs_dir_entry *
218 ufs_next_entry(struct super_block *sb, struct ufs_dir_entry *p)
220 return (struct ufs_dir_entry *)((char *)p +
221 fs16_to_cpu(sb, p->d_reclen));
224 struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct page **p)
226 struct page *page = ufs_get_page(dir, 0);
227 struct ufs_dir_entry *de = NULL;
230 de = ufs_next_entry(dir->i_sb,
231 (struct ufs_dir_entry *)page_address(page));
240 * finds an entry in the specified directory with the wanted name. It
241 * returns the page in which the entry was found, and the entry itself
242 * (as a parameter - res_dir). Page is returned mapped and unlocked.
243 * Entry is guaranteed to be valid.
245 struct ufs_dir_entry *ufs_find_entry(struct inode *dir, struct dentry *dentry,
246 struct page **res_page)
248 struct super_block *sb = dir->i_sb;
249 const char *name = dentry->d_name.name;
250 int namelen = dentry->d_name.len;
251 unsigned reclen = UFS_DIR_REC_LEN(namelen);
252 unsigned long start, n;
253 unsigned long npages = ufs_dir_pages(dir);
254 struct page *page = NULL;
255 struct ufs_dir_entry *de;
257 UFSD("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen);
259 if (npages == 0 || namelen > UFS_MAXNAMLEN)
265 /* start = ei->i_dir_start_lookup; */
272 page = ufs_get_page(dir, n);
274 kaddr = page_address(page);
275 de = (struct ufs_dir_entry *) kaddr;
276 kaddr += ufs_last_byte(dir, n) - reclen;
277 while ((char *) de <= kaddr) {
278 if (de->d_reclen == 0) {
279 ufs_error(dir->i_sb, __FUNCTION__,
280 "zero-length directory entry");
284 if (ufs_match(sb, namelen, name, de))
286 de = ufs_next_entry(sb, de);
292 } while (n != start);
298 /* ei->i_dir_start_lookup = n; */
305 int ufs_add_link(struct dentry *dentry, struct inode *inode)
307 struct inode *dir = dentry->d_parent->d_inode;
308 const char *name = dentry->d_name.name;
309 int namelen = dentry->d_name.len;
310 struct super_block *sb = dir->i_sb;
311 unsigned reclen = UFS_DIR_REC_LEN(namelen);
312 unsigned short rec_len, name_len;
313 struct page *page = NULL;
314 struct ufs_dir_entry *de;
315 unsigned long npages = ufs_dir_pages(dir);
321 UFSD("ENTER, name %s, namelen %u\n", name, namelen);
324 * We take care of directory expansion in the same loop.
325 * This code plays outside i_size, so it locks the page
326 * to protect that region.
328 for (n = 0; n <= npages; n++) {
331 page = ufs_get_page(dir, n);
336 kaddr = page_address(page);
337 dir_end = kaddr + ufs_last_byte(dir, n);
338 de = (struct ufs_dir_entry *)kaddr;
339 kaddr += PAGE_CACHE_SIZE - reclen;
340 while ((char *)de <= kaddr) {
341 if ((char *)de == dir_end) {
344 rec_len = UFS_SECTOR_SIZE;
345 de->d_reclen = cpu_to_fs16(sb, UFS_SECTOR_SIZE);
349 if (de->d_reclen == 0) {
350 ufs_error(dir->i_sb, __FUNCTION__,
351 "zero-length directory entry");
356 if (ufs_match(sb, namelen, name, de))
358 name_len = UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de));
359 rec_len = fs16_to_cpu(sb, de->d_reclen);
360 if (!de->d_ino && rec_len >= reclen)
362 if (rec_len >= name_len + reclen)
364 de = (struct ufs_dir_entry *) ((char *) de + rec_len);
373 from = (char*)de - (char*)page_address(page);
375 err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
379 struct ufs_dir_entry *de1 =
380 (struct ufs_dir_entry *) ((char *) de + name_len);
381 de1->d_reclen = cpu_to_fs16(sb, rec_len - name_len);
382 de->d_reclen = cpu_to_fs16(sb, name_len);
387 ufs_set_de_namlen(sb, de, namelen);
388 memcpy(de->d_name, name, namelen + 1);
389 de->d_ino = cpu_to_fs32(sb, inode->i_ino);
390 ufs_set_de_type(sb, de, inode->i_mode);
392 err = ufs_commit_chunk(page, from, to);
393 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
395 mark_inode_dirty(dir);
406 static inline unsigned
407 ufs_validate_entry(struct super_block *sb, char *base,
408 unsigned offset, unsigned mask)
410 struct ufs_dir_entry *de = (struct ufs_dir_entry*)(base + offset);
411 struct ufs_dir_entry *p = (struct ufs_dir_entry*)(base + (offset&mask));
412 while ((char*)p < (char*)de) {
413 if (p->d_reclen == 0)
415 p = ufs_next_entry(sb, p);
417 return (char *)p - base;
422 * This is blatantly stolen from ext2fs
425 ufs_readdir(struct file *filp, void *dirent, filldir_t filldir)
427 loff_t pos = filp->f_pos;
428 struct inode *inode = filp->f_dentry->d_inode;
429 struct super_block *sb = inode->i_sb;
430 unsigned int offset = pos & ~PAGE_CACHE_MASK;
431 unsigned long n = pos >> PAGE_CACHE_SHIFT;
432 unsigned long npages = ufs_dir_pages(inode);
433 unsigned chunk_mask = ~(UFS_SECTOR_SIZE - 1);
434 int need_revalidate = filp->f_version != inode->i_version;
435 unsigned flags = UFS_SB(sb)->s_flags;
439 if (pos > inode->i_size - UFS_DIR_REC_LEN(1))
442 for ( ; n < npages; n++, offset = 0) {
444 struct ufs_dir_entry *de;
446 struct page *page = ufs_get_page(inode, n);
449 ufs_error(sb, __FUNCTION__,
452 filp->f_pos += PAGE_CACHE_SIZE - offset;
455 kaddr = page_address(page);
456 if (unlikely(need_revalidate)) {
458 offset = ufs_validate_entry(sb, kaddr, offset, chunk_mask);
459 filp->f_pos = (n<<PAGE_CACHE_SHIFT) + offset;
461 filp->f_version = inode->i_version;
464 de = (struct ufs_dir_entry *)(kaddr+offset);
465 limit = kaddr + ufs_last_byte(inode, n) - UFS_DIR_REC_LEN(1);
466 for ( ;(char*)de <= limit; de = ufs_next_entry(sb, de)) {
467 if (de->d_reclen == 0) {
468 ufs_error(sb, __FUNCTION__,
469 "zero-length directory entry");
475 unsigned char d_type = DT_UNKNOWN;
477 offset = (char *)de - kaddr;
479 UFSD("filldir(%s,%u)\n", de->d_name,
480 fs32_to_cpu(sb, de->d_ino));
481 UFSD("namlen %u\n", ufs_get_de_namlen(sb, de));
483 if ((flags & UFS_DE_MASK) == UFS_DE_44BSD)
484 d_type = de->d_u.d_44.d_type;
486 over = filldir(dirent, de->d_name,
487 ufs_get_de_namlen(sb, de),
488 (n<<PAGE_CACHE_SHIFT) | offset,
489 fs32_to_cpu(sb, de->d_ino), d_type);
495 filp->f_pos += fs16_to_cpu(sb, de->d_reclen);
504 * ufs_delete_entry deletes a directory entry by merging it with the
507 int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir,
510 struct super_block *sb = inode->i_sb;
511 struct address_space *mapping = page->mapping;
512 char *kaddr = page_address(page);
513 unsigned from = ((char*)dir - kaddr) & ~(UFS_SECTOR_SIZE - 1);
514 unsigned to = ((char*)dir - kaddr) + fs16_to_cpu(sb, dir->d_reclen);
515 struct ufs_dir_entry *pde = NULL;
516 struct ufs_dir_entry *de = (struct ufs_dir_entry *) (kaddr + from);
521 UFSD("ino %u, reclen %u, namlen %u, name %s\n",
522 fs32_to_cpu(sb, de->d_ino),
523 fs16_to_cpu(sb, de->d_reclen),
524 ufs_get_de_namlen(sb, de), de->d_name);
526 while ((char*)de < (char*)dir) {
527 if (de->d_reclen == 0) {
528 ufs_error(inode->i_sb, __FUNCTION__,
529 "zero-length directory entry");
534 de = ufs_next_entry(sb, de);
537 from = (char*)pde - (char*)page_address(page);
539 err = mapping->a_ops->prepare_write(NULL, page, from, to);
542 pde->d_reclen = cpu_to_fs16(sb, to-from);
544 err = ufs_commit_chunk(page, from, to);
545 inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
546 mark_inode_dirty(inode);
553 int ufs_make_empty(struct inode * inode, struct inode *dir)
555 struct super_block * sb = dir->i_sb;
556 struct address_space *mapping = inode->i_mapping;
557 struct page *page = grab_cache_page(mapping, 0);
558 struct ufs_dir_entry * de;
565 err = mapping->a_ops->prepare_write(NULL, page, 0, UFS_SECTOR_SIZE);
572 base = (char*)page_address(page);
573 memset(base, 0, PAGE_CACHE_SIZE);
575 de = (struct ufs_dir_entry *) base;
577 de->d_ino = cpu_to_fs32(sb, inode->i_ino);
578 ufs_set_de_type(sb, de, inode->i_mode);
579 ufs_set_de_namlen(sb, de, 1);
580 de->d_reclen = cpu_to_fs16(sb, UFS_DIR_REC_LEN(1));
581 strcpy (de->d_name, ".");
582 de = (struct ufs_dir_entry *)
583 ((char *)de + fs16_to_cpu(sb, de->d_reclen));
584 de->d_ino = cpu_to_fs32(sb, dir->i_ino);
585 ufs_set_de_type(sb, de, dir->i_mode);
586 de->d_reclen = cpu_to_fs16(sb, UFS_SECTOR_SIZE - UFS_DIR_REC_LEN(1));
587 ufs_set_de_namlen(sb, de, 2);
588 strcpy (de->d_name, "..");
590 err = ufs_commit_chunk(page, 0, UFS_SECTOR_SIZE);
593 page_cache_release(page);
598 * routine to check that the specified directory is empty (for rmdir)
600 int ufs_empty_dir(struct inode * inode)
602 struct super_block *sb = inode->i_sb;
603 struct page *page = NULL;
604 unsigned long i, npages = ufs_dir_pages(inode);
606 for (i = 0; i < npages; i++) {
608 struct ufs_dir_entry *de;
609 page = ufs_get_page(inode, i);
614 kaddr = page_address(page);
615 de = (struct ufs_dir_entry *)kaddr;
616 kaddr += ufs_last_byte(inode, i) - UFS_DIR_REC_LEN(1);
618 while ((char *)de <= kaddr) {
619 if (de->d_reclen == 0) {
620 ufs_error(inode->i_sb, __FUNCTION__,
621 "zero-length directory entry: "
622 "kaddr=%p, de=%p\n", kaddr, de);
626 u16 namelen=ufs_get_de_namlen(sb, de);
627 /* check for . and .. */
628 if (de->d_name[0] != '.')
634 fs32_to_cpu(sb, de->d_ino))
636 } else if (de->d_name[1] != '.')
639 de = ufs_next_entry(sb, de);
650 const struct file_operations ufs_dir_operations = {
651 .read = generic_read_dir,
652 .readdir = ufs_readdir,