19 #include <linux/time.h>
36 if (len != ufs_get_de_namlen(sb, de))
43 static int ufs_commit_chunk(
struct page *
page, loff_t
pos,
unsigned len)
51 if (pos+len > dir->
i_size) {
52 i_size_write(dir, pos+len);
53 mark_inode_dirty(dir);
62 static inline void ufs_put_page(
struct page *page)
68 static inline unsigned long ufs_dir_pages(
struct inode *
inode)
90 struct page *page,
struct inode *inode)
102 ufs_set_de_type(dir->
i_sb, de, inode->
i_mode);
104 err = ufs_commit_chunk(page, pos, len);
107 mark_inode_dirty(dir);
111 static void ufs_check_page(
struct page *page)
113 struct inode *dir = page->
mapping->host;
118 const unsigned chunk_mask = UFS_SB(sb)->s_uspi->s_dirblksize - 1;
124 if (limit & chunk_mask)
131 rec_len = fs16_to_cpu(sb, p->
d_reclen);
139 if (((offs + rec_len - 1) ^ offs) & ~chunk_mask)
141 if (fs32_to_cpu(sb, p->
d_ino) > (UFS_SB(sb)->s_uspi->s_ipg *
142 UFS_SB(sb)->s_uspi->s_ncg))
148 SetPageChecked(page);
155 "size of directory #%lu is not a multiple of chunk size",
160 error =
"rec_len is smaller than minimal";
163 error =
"unaligned directory entry";
166 error =
"rec_len is too small for name_len";
169 error =
"directory entry across blocks";
172 error =
"inode out of bounds";
174 ufs_error (sb,
"ufs_check_page",
"bad entry in directory #%lu: %s - "
175 "offset=%lu, rec_len=%d, name_len=%d",
177 rec_len, ufs_get_de_namlen(sb, p));
182 "entry in directory #%lu spans the page boundary"
186 SetPageChecked(page);
190 static struct page *ufs_get_page(
struct inode *dir,
unsigned long n)
193 struct page *page = read_mapping_page(mapping, n,
NULL);
196 if (!PageChecked(page))
197 ufs_check_page(page);
205 return ERR_PTR(-
EIO);
213 ufs_last_byte(
struct inode *inode,
unsigned long page_nr)
215 unsigned last_byte = inode->
i_size;
232 struct page *page = ufs_get_page(dir, 0);
236 de = ufs_next_entry(dir->
i_sb,
252 struct page **res_page)
255 const unsigned char *name = qstr->
name;
259 unsigned long npages = ufs_dir_pages(dir);
260 struct page *page =
NULL;
264 UFSD(
"ENTER, dir_ino %lu, name %s, namlen %u\n", dir->
i_ino, name, namelen);
279 page = ufs_get_page(dir, n);
283 kaddr += ufs_last_byte(dir, n) - reclen;
284 while ((
char *) de <= kaddr) {
287 "zero-length directory entry");
291 if (ufs_match(sb, namelen, name, de))
293 de = ufs_next_entry(sb, de);
299 }
while (n != start);
314 struct inode *dir = dentry->
d_parent->d_inode;
315 const unsigned char *name = dentry->
d_name.name;
319 const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize;
321 struct page *page =
NULL;
323 unsigned long npages = ufs_dir_pages(dir);
329 UFSD(
"ENTER, name %s, namelen %u\n", name, namelen);
336 for (n = 0; n <= npages; n++) {
339 page = ufs_get_page(dir, n);
345 dir_end = kaddr + ufs_last_byte(dir, n);
348 while ((
char *)de <= kaddr) {
349 if ((
char *)de == dir_end) {
352 rec_len = chunk_size;
353 de->
d_reclen = cpu_to_fs16(sb, chunk_size);
359 "zero-length directory entry");
364 if (ufs_match(sb, namelen, name, de))
367 rec_len = fs16_to_cpu(sb, de->
d_reclen);
368 if (!de->
d_ino && rec_len >= reclen)
370 if (rec_len >= name_len + reclen)
389 de1->
d_reclen = cpu_to_fs16(sb, rec_len - name_len);
390 de->
d_reclen = cpu_to_fs16(sb, name_len);
395 ufs_set_de_namlen(sb, de, namelen);
398 ufs_set_de_type(sb, de, inode->
i_mode);
400 err = ufs_commit_chunk(page, pos, rec_len);
403 mark_inode_dirty(dir);
414 static inline unsigned
415 ufs_validate_entry(
struct super_block *sb,
char *base,
420 while ((
char*)p < (
char*)de) {
423 p = ufs_next_entry(sb, p);
425 return (
char *)p - base;
435 loff_t pos = filp->
f_pos;
436 struct inode *inode = filp->
f_path.dentry->d_inode;
440 unsigned long npages = ufs_dir_pages(inode);
441 unsigned chunk_mask = ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
443 unsigned flags = UFS_SB(sb)->s_flags;
450 for ( ; n < npages; n++, offset = 0) {
454 struct page *page = ufs_get_page(inode, n);
466 offset = ufs_validate_entry(sb, kaddr, offset, chunk_mask);
474 for ( ;(
char*)de <= limit; de = ufs_next_entry(sb, de)) {
477 "zero-length directory entry");
485 offset = (
char *)de - kaddr;
488 fs32_to_cpu(sb, de->
d_ino));
489 UFSD(
"namlen %u\n", ufs_get_de_namlen(sb, de));
494 over = filldir(dirent, de->
d_name,
495 ufs_get_de_namlen(sb, de),
496 (n<<PAGE_CACHE_SHIFT) | offset,
497 fs32_to_cpu(sb, de->
d_ino), d_type);
520 unsigned from = ((
char*)dir - kaddr) & ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
521 unsigned to = ((
char*)dir - kaddr) + fs16_to_cpu(sb, dir->
d_reclen);
529 UFSD(
"ino %u, reclen %u, namlen %u, name %s\n",
530 fs32_to_cpu(sb, de->
d_ino),
532 ufs_get_de_namlen(sb, de), de->
d_name);
534 while ((
char*)de < (
char*)dir) {
537 "zero-length directory entry");
542 de = ufs_next_entry(sb, de);
552 pde->
d_reclen = cpu_to_fs16(sb, to - from);
554 err = ufs_commit_chunk(page, pos, to - from);
556 mark_inode_dirty(inode);
567 struct page *page = grab_cache_page(mapping, 0);
568 const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize;
589 ufs_set_de_type(sb, de, inode->
i_mode);
590 ufs_set_de_namlen(sb, de, 1);
594 ((
char *)de + fs16_to_cpu(sb, de->
d_reclen));
596 ufs_set_de_type(sb, de, dir->
i_mode);
598 ufs_set_de_namlen(sb, de, 2);
602 err = ufs_commit_chunk(page, 0, chunk_size);
614 struct page *page =
NULL;
615 unsigned long i, npages = ufs_dir_pages(inode);
617 for (i = 0; i < npages; i++) {
620 page = ufs_get_page(inode, i);
629 while ((
char *)de <= kaddr) {
632 "zero-length directory entry: "
633 "kaddr=%p, de=%p\n", kaddr, de);
645 fs32_to_cpu(sb, de->
d_ino))
647 }
else if (de->
d_name[1] !=
'.')
650 de = ufs_next_entry(sb, de);
663 .readdir = ufs_readdir,