1 /* 2 * dir.c - NILFS directory entry operations 3 * 4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 19 * 20 * Modified for NILFS by Amagai Yoshiji <amagai@osrg.net> 21 */ 22 /* 23 * linux/fs/ext2/dir.c 24 * 25 * Copyright (C) 1992, 1993, 1994, 1995 26 * Remy Card (card@masi.ibp.fr) 27 * Laboratoire MASI - Institut Blaise Pascal 28 * Universite Pierre et Marie Curie (Paris VI) 29 * 30 * from 31 * 32 * linux/fs/minix/dir.c 33 * 34 * Copyright (C) 1991, 1992 Linus Torvalds 35 * 36 * ext2 directory handling functions 37 * 38 * Big-endian to little-endian byte-swapping/bitmaps by 39 * David S. Miller (davem@caip.rutgers.edu), 1995 40 * 41 * All code that works with directory layout had been switched to pagecache 42 * and moved here. AV 43 */ 44 45 #include <linux/pagemap.h> 46 #include "nilfs.h" 47 #include "page.h" 48 49 /* 50 * nilfs uses block-sized chunks. Arguably, sector-sized ones would be 51 * more robust, but we have what we have 52 */ 53 static inline unsigned nilfs_chunk_size(struct inode *inode) 54 { 55 return inode->i_sb->s_blocksize; 56 } 57 58 static inline void nilfs_put_page(struct page *page) 59 { 60 kunmap(page); 61 page_cache_release(page); 62 } 63 64 static inline unsigned long dir_pages(struct inode *inode) 65 { 66 return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT; 67 } 68 69 /* 70 * Return the offset into page `page_nr' of the last valid 71 * byte in that page, plus one. 72 */ 73 static unsigned nilfs_last_byte(struct inode *inode, unsigned long page_nr) 74 { 75 unsigned last_byte = inode->i_size; 76 77 last_byte -= page_nr << PAGE_CACHE_SHIFT; 78 if (last_byte > PAGE_CACHE_SIZE) 79 last_byte = PAGE_CACHE_SIZE; 80 return last_byte; 81 } 82 83 static int nilfs_prepare_chunk(struct page *page, unsigned from, unsigned to) 84 { 85 loff_t pos = page_offset(page) + from; 86 return __block_write_begin(page, pos, to - from, nilfs_get_block); 87 } 88 89 static void nilfs_commit_chunk(struct page *page, 90 struct address_space *mapping, 91 unsigned from, unsigned to) 92 { 93 struct inode *dir = mapping->host; 94 struct nilfs_sb_info *sbi = NILFS_SB(dir->i_sb); 95 loff_t pos = page_offset(page) + from; 96 unsigned len = to - from; 97 unsigned nr_dirty, copied; 98 int err; 99 100 nr_dirty = nilfs_page_count_clean_buffers(page, from, to); 101 copied = block_write_end(NULL, mapping, pos, len, len, page, NULL); 102 if (pos + copied > dir->i_size) 103 i_size_write(dir, pos + copied); 104 if (IS_DIRSYNC(dir)) 105 nilfs_set_transaction_flag(NILFS_TI_SYNC); 106 err = nilfs_set_file_dirty(sbi, dir, nr_dirty); 107 WARN_ON(err); /* do not happen */ 108 unlock_page(page); 109 } 110 111 static void nilfs_check_page(struct page *page) 112 { 113 struct inode *dir = page->mapping->host; 114 struct super_block *sb = dir->i_sb; 115 unsigned chunk_size = nilfs_chunk_size(dir); 116 char *kaddr = page_address(page); 117 unsigned offs, rec_len; 118 unsigned limit = PAGE_CACHE_SIZE; 119 struct nilfs_dir_entry *p; 120 char *error; 121 122 if ((dir->i_size >> PAGE_CACHE_SHIFT) == page->index) { 123 limit = dir->i_size & ~PAGE_CACHE_MASK; 124 if (limit & (chunk_size - 1)) 125 goto Ebadsize; 126 if (!limit) 127 goto out; 128 } 129 for (offs = 0; offs <= limit - NILFS_DIR_REC_LEN(1); offs += rec_len) { 130 p = (struct nilfs_dir_entry *)(kaddr + offs); 131 rec_len = nilfs_rec_len_from_disk(p->rec_len); 132 133 if (rec_len < NILFS_DIR_REC_LEN(1)) 134 goto Eshort; 135 if (rec_len & 3) 136 goto Ealign; 137 if (rec_len < NILFS_DIR_REC_LEN(p->name_len)) 138 goto Enamelen; 139 if (((offs + rec_len - 1) ^ offs) & ~(chunk_size-1)) 140 goto Espan; 141 } 142 if (offs != limit) 143 goto Eend; 144 out: 145 SetPageChecked(page); 146 return; 147 148 /* Too bad, we had an error */ 149 150 Ebadsize: 151 nilfs_error(sb, "nilfs_check_page", 152 "size of directory #%lu is not a multiple of chunk size", 153 dir->i_ino 154 ); 155 goto fail; 156 Eshort: 157 error = "rec_len is smaller than minimal"; 158 goto bad_entry; 159 Ealign: 160 error = "unaligned directory entry"; 161 goto bad_entry; 162 Enamelen: 163 error = "rec_len is too small for name_len"; 164 goto bad_entry; 165 Espan: 166 error = "directory entry across blocks"; 167 bad_entry: 168 nilfs_error(sb, "nilfs_check_page", "bad entry in directory #%lu: %s - " 169 "offset=%lu, inode=%lu, rec_len=%d, name_len=%d", 170 dir->i_ino, error, (page->index<<PAGE_CACHE_SHIFT)+offs, 171 (unsigned long) le64_to_cpu(p->inode), 172 rec_len, p->name_len); 173 goto fail; 174 Eend: 175 p = (struct nilfs_dir_entry *)(kaddr + offs); 176 nilfs_error(sb, "nilfs_check_page", 177 "entry in directory #%lu spans the page boundary" 178 "offset=%lu, inode=%lu", 179 dir->i_ino, (page->index<<PAGE_CACHE_SHIFT)+offs, 180 (unsigned long) le64_to_cpu(p->inode)); 181 fail: 182 SetPageChecked(page); 183 SetPageError(page); 184 } 185 186 static struct page *nilfs_get_page(struct inode *dir, unsigned long n) 187 { 188 struct address_space *mapping = dir->i_mapping; 189 struct page *page = read_mapping_page(mapping, n, NULL); 190 191 if (!IS_ERR(page)) { 192 kmap(page); 193 if (!PageChecked(page)) 194 nilfs_check_page(page); 195 if (PageError(page)) 196 goto fail; 197 } 198 return page; 199 200 fail: 201 nilfs_put_page(page); 202 return ERR_PTR(-EIO); 203 } 204 205 /* 206 * NOTE! unlike strncmp, nilfs_match returns 1 for success, 0 for failure. 207 * 208 * len <= NILFS_NAME_LEN and de != NULL are guaranteed by caller. 209 */ 210 static int 211 nilfs_match(int len, const unsigned char *name, struct nilfs_dir_entry *de) 212 { 213 if (len != de->name_len) 214 return 0; 215 if (!de->inode) 216 return 0; 217 return !memcmp(name, de->name, len); 218 } 219 220 /* 221 * p is at least 6 bytes before the end of page 222 */ 223 static struct nilfs_dir_entry *nilfs_next_entry(struct nilfs_dir_entry *p) 224 { 225 return (struct nilfs_dir_entry *)((char *)p + 226 nilfs_rec_len_from_disk(p->rec_len)); 227 } 228 229 static unsigned char 230 nilfs_filetype_table[NILFS_FT_MAX] = { 231 [NILFS_FT_UNKNOWN] = DT_UNKNOWN, 232 [NILFS_FT_REG_FILE] = DT_REG, 233 [NILFS_FT_DIR] = DT_DIR, 234 [NILFS_FT_CHRDEV] = DT_CHR, 235 [NILFS_FT_BLKDEV] = DT_BLK, 236 [NILFS_FT_FIFO] = DT_FIFO, 237 [NILFS_FT_SOCK] = DT_SOCK, 238 [NILFS_FT_SYMLINK] = DT_LNK, 239 }; 240 241 #define S_SHIFT 12 242 static unsigned char 243 nilfs_type_by_mode[S_IFMT >> S_SHIFT] = { 244 [S_IFREG >> S_SHIFT] = NILFS_FT_REG_FILE, 245 [S_IFDIR >> S_SHIFT] = NILFS_FT_DIR, 246 [S_IFCHR >> S_SHIFT] = NILFS_FT_CHRDEV, 247 [S_IFBLK >> S_SHIFT] = NILFS_FT_BLKDEV, 248 [S_IFIFO >> S_SHIFT] = NILFS_FT_FIFO, 249 [S_IFSOCK >> S_SHIFT] = NILFS_FT_SOCK, 250 [S_IFLNK >> S_SHIFT] = NILFS_FT_SYMLINK, 251 }; 252 253 static void nilfs_set_de_type(struct nilfs_dir_entry *de, struct inode *inode) 254 { 255 mode_t mode = inode->i_mode; 256 257 de->file_type = nilfs_type_by_mode[(mode & S_IFMT)>>S_SHIFT]; 258 } 259 260 static int nilfs_readdir(struct file *filp, void *dirent, filldir_t filldir) 261 { 262 loff_t pos = filp->f_pos; 263 struct inode *inode = filp->f_dentry->d_inode; 264 struct super_block *sb = inode->i_sb; 265 unsigned int offset = pos & ~PAGE_CACHE_MASK; 266 unsigned long n = pos >> PAGE_CACHE_SHIFT; 267 unsigned long npages = dir_pages(inode); 268 /* unsigned chunk_mask = ~(nilfs_chunk_size(inode)-1); */ 269 unsigned char *types = NULL; 270 int ret; 271 272 if (pos > inode->i_size - NILFS_DIR_REC_LEN(1)) 273 goto success; 274 275 types = nilfs_filetype_table; 276 277 for ( ; n < npages; n++, offset = 0) { 278 char *kaddr, *limit; 279 struct nilfs_dir_entry *de; 280 struct page *page = nilfs_get_page(inode, n); 281 282 if (IS_ERR(page)) { 283 nilfs_error(sb, __func__, "bad page in #%lu", 284 inode->i_ino); 285 filp->f_pos += PAGE_CACHE_SIZE - offset; 286 ret = -EIO; 287 goto done; 288 } 289 kaddr = page_address(page); 290 de = (struct nilfs_dir_entry *)(kaddr + offset); 291 limit = kaddr + nilfs_last_byte(inode, n) - 292 NILFS_DIR_REC_LEN(1); 293 for ( ; (char *)de <= limit; de = nilfs_next_entry(de)) { 294 if (de->rec_len == 0) { 295 nilfs_error(sb, __func__, 296 "zero-length directory entry"); 297 ret = -EIO; 298 nilfs_put_page(page); 299 goto done; 300 } 301 if (de->inode) { 302 int over; 303 unsigned char d_type = DT_UNKNOWN; 304 305 if (types && de->file_type < NILFS_FT_MAX) 306 d_type = types[de->file_type]; 307 308 offset = (char *)de - kaddr; 309 over = filldir(dirent, de->name, de->name_len, 310 (n<<PAGE_CACHE_SHIFT) | offset, 311 le64_to_cpu(de->inode), d_type); 312 if (over) { 313 nilfs_put_page(page); 314 goto success; 315 } 316 } 317 filp->f_pos += nilfs_rec_len_from_disk(de->rec_len); 318 } 319 nilfs_put_page(page); 320 } 321 322 success: 323 ret = 0; 324 done: 325 return ret; 326 } 327 328 /* 329 * nilfs_find_entry() 330 * 331 * finds an entry in the specified directory with the wanted name. It 332 * returns the page in which the entry was found, and the entry itself 333 * (as a parameter - res_dir). Page is returned mapped and unlocked. 334 * Entry is guaranteed to be valid. 335 */ 336 struct nilfs_dir_entry * 337 nilfs_find_entry(struct inode *dir, const struct qstr *qstr, 338 struct page **res_page) 339 { 340 const unsigned char *name = qstr->name; 341 int namelen = qstr->len; 342 unsigned reclen = NILFS_DIR_REC_LEN(namelen); 343 unsigned long start, n; 344 unsigned long npages = dir_pages(dir); 345 struct page *page = NULL; 346 struct nilfs_inode_info *ei = NILFS_I(dir); 347 struct nilfs_dir_entry *de; 348 349 if (npages == 0) 350 goto out; 351 352 /* OFFSET_CACHE */ 353 *res_page = NULL; 354 355 start = ei->i_dir_start_lookup; 356 if (start >= npages) 357 start = 0; 358 n = start; 359 do { 360 char *kaddr; 361 page = nilfs_get_page(dir, n); 362 if (!IS_ERR(page)) { 363 kaddr = page_address(page); 364 de = (struct nilfs_dir_entry *)kaddr; 365 kaddr += nilfs_last_byte(dir, n) - reclen; 366 while ((char *) de <= kaddr) { 367 if (de->rec_len == 0) { 368 nilfs_error(dir->i_sb, __func__, 369 "zero-length directory entry"); 370 nilfs_put_page(page); 371 goto out; 372 } 373 if (nilfs_match(namelen, name, de)) 374 goto found; 375 de = nilfs_next_entry(de); 376 } 377 nilfs_put_page(page); 378 } 379 if (++n >= npages) 380 n = 0; 381 /* next page is past the blocks we've got */ 382 if (unlikely(n > (dir->i_blocks >> (PAGE_CACHE_SHIFT - 9)))) { 383 nilfs_error(dir->i_sb, __func__, 384 "dir %lu size %lld exceeds block count %llu", 385 dir->i_ino, dir->i_size, 386 (unsigned long long)dir->i_blocks); 387 goto out; 388 } 389 } while (n != start); 390 out: 391 return NULL; 392 393 found: 394 *res_page = page; 395 ei->i_dir_start_lookup = n; 396 return de; 397 } 398 399 struct nilfs_dir_entry *nilfs_dotdot(struct inode *dir, struct page **p) 400 { 401 struct page *page = nilfs_get_page(dir, 0); 402 struct nilfs_dir_entry *de = NULL; 403 404 if (!IS_ERR(page)) { 405 de = nilfs_next_entry( 406 (struct nilfs_dir_entry *)page_address(page)); 407 *p = page; 408 } 409 return de; 410 } 411 412 ino_t nilfs_inode_by_name(struct inode *dir, const struct qstr *qstr) 413 { 414 ino_t res = 0; 415 struct nilfs_dir_entry *de; 416 struct page *page; 417 418 de = nilfs_find_entry(dir, qstr, &page); 419 if (de) { 420 res = le64_to_cpu(de->inode); 421 kunmap(page); 422 page_cache_release(page); 423 } 424 return res; 425 } 426 427 /* Releases the page */ 428 void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de, 429 struct page *page, struct inode *inode) 430 { 431 unsigned from = (char *) de - (char *) page_address(page); 432 unsigned to = from + nilfs_rec_len_from_disk(de->rec_len); 433 struct address_space *mapping = page->mapping; 434 int err; 435 436 lock_page(page); 437 err = nilfs_prepare_chunk(page, from, to); 438 BUG_ON(err); 439 de->inode = cpu_to_le64(inode->i_ino); 440 nilfs_set_de_type(de, inode); 441 nilfs_commit_chunk(page, mapping, from, to); 442 nilfs_put_page(page); 443 dir->i_mtime = dir->i_ctime = CURRENT_TIME; 444 /* NILFS_I(dir)->i_flags &= ~NILFS_BTREE_FL; */ 445 } 446 447 /* 448 * Parent is locked. 449 */ 450 int nilfs_add_link(struct dentry *dentry, struct inode *inode) 451 { 452 struct inode *dir = dentry->d_parent->d_inode; 453 const unsigned char *name = dentry->d_name.name; 454 int namelen = dentry->d_name.len; 455 unsigned chunk_size = nilfs_chunk_size(dir); 456 unsigned reclen = NILFS_DIR_REC_LEN(namelen); 457 unsigned short rec_len, name_len; 458 struct page *page = NULL; 459 struct nilfs_dir_entry *de; 460 unsigned long npages = dir_pages(dir); 461 unsigned long n; 462 char *kaddr; 463 unsigned from, to; 464 int err; 465 466 /* 467 * We take care of directory expansion in the same loop. 468 * This code plays outside i_size, so it locks the page 469 * to protect that region. 470 */ 471 for (n = 0; n <= npages; n++) { 472 char *dir_end; 473 474 page = nilfs_get_page(dir, n); 475 err = PTR_ERR(page); 476 if (IS_ERR(page)) 477 goto out; 478 lock_page(page); 479 kaddr = page_address(page); 480 dir_end = kaddr + nilfs_last_byte(dir, n); 481 de = (struct nilfs_dir_entry *)kaddr; 482 kaddr += PAGE_CACHE_SIZE - reclen; 483 while ((char *)de <= kaddr) { 484 if ((char *)de == dir_end) { 485 /* We hit i_size */ 486 name_len = 0; 487 rec_len = chunk_size; 488 de->rec_len = nilfs_rec_len_to_disk(chunk_size); 489 de->inode = 0; 490 goto got_it; 491 } 492 if (de->rec_len == 0) { 493 nilfs_error(dir->i_sb, __func__, 494 "zero-length directory entry"); 495 err = -EIO; 496 goto out_unlock; 497 } 498 err = -EEXIST; 499 if (nilfs_match(namelen, name, de)) 500 goto out_unlock; 501 name_len = NILFS_DIR_REC_LEN(de->name_len); 502 rec_len = nilfs_rec_len_from_disk(de->rec_len); 503 if (!de->inode && rec_len >= reclen) 504 goto got_it; 505 if (rec_len >= name_len + reclen) 506 goto got_it; 507 de = (struct nilfs_dir_entry *)((char *)de + rec_len); 508 } 509 unlock_page(page); 510 nilfs_put_page(page); 511 } 512 BUG(); 513 return -EINVAL; 514 515 got_it: 516 from = (char *)de - (char *)page_address(page); 517 to = from + rec_len; 518 err = nilfs_prepare_chunk(page, from, to); 519 if (err) 520 goto out_unlock; 521 if (de->inode) { 522 struct nilfs_dir_entry *de1; 523 524 de1 = (struct nilfs_dir_entry *)((char *)de + name_len); 525 de1->rec_len = nilfs_rec_len_to_disk(rec_len - name_len); 526 de->rec_len = nilfs_rec_len_to_disk(name_len); 527 de = de1; 528 } 529 de->name_len = namelen; 530 memcpy(de->name, name, namelen); 531 de->inode = cpu_to_le64(inode->i_ino); 532 nilfs_set_de_type(de, inode); 533 nilfs_commit_chunk(page, page->mapping, from, to); 534 dir->i_mtime = dir->i_ctime = CURRENT_TIME; 535 /* NILFS_I(dir)->i_flags &= ~NILFS_BTREE_FL; */ 536 nilfs_mark_inode_dirty(dir); 537 /* OFFSET_CACHE */ 538 out_put: 539 nilfs_put_page(page); 540 out: 541 return err; 542 out_unlock: 543 unlock_page(page); 544 goto out_put; 545 } 546 547 /* 548 * nilfs_delete_entry deletes a directory entry by merging it with the 549 * previous entry. Page is up-to-date. Releases the page. 550 */ 551 int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page) 552 { 553 struct address_space *mapping = page->mapping; 554 struct inode *inode = mapping->host; 555 char *kaddr = page_address(page); 556 unsigned from = ((char *)dir - kaddr) & ~(nilfs_chunk_size(inode) - 1); 557 unsigned to = ((char *)dir - kaddr) + 558 nilfs_rec_len_from_disk(dir->rec_len); 559 struct nilfs_dir_entry *pde = NULL; 560 struct nilfs_dir_entry *de = (struct nilfs_dir_entry *)(kaddr + from); 561 int err; 562 563 while ((char *)de < (char *)dir) { 564 if (de->rec_len == 0) { 565 nilfs_error(inode->i_sb, __func__, 566 "zero-length directory entry"); 567 err = -EIO; 568 goto out; 569 } 570 pde = de; 571 de = nilfs_next_entry(de); 572 } 573 if (pde) 574 from = (char *)pde - (char *)page_address(page); 575 lock_page(page); 576 err = nilfs_prepare_chunk(page, from, to); 577 BUG_ON(err); 578 if (pde) 579 pde->rec_len = nilfs_rec_len_to_disk(to - from); 580 dir->inode = 0; 581 nilfs_commit_chunk(page, mapping, from, to); 582 inode->i_ctime = inode->i_mtime = CURRENT_TIME; 583 /* NILFS_I(inode)->i_flags &= ~NILFS_BTREE_FL; */ 584 out: 585 nilfs_put_page(page); 586 return err; 587 } 588 589 /* 590 * Set the first fragment of directory. 591 */ 592 int nilfs_make_empty(struct inode *inode, struct inode *parent) 593 { 594 struct address_space *mapping = inode->i_mapping; 595 struct page *page = grab_cache_page(mapping, 0); 596 unsigned chunk_size = nilfs_chunk_size(inode); 597 struct nilfs_dir_entry *de; 598 int err; 599 void *kaddr; 600 601 if (!page) 602 return -ENOMEM; 603 604 err = nilfs_prepare_chunk(page, 0, chunk_size); 605 if (unlikely(err)) { 606 unlock_page(page); 607 goto fail; 608 } 609 kaddr = kmap_atomic(page, KM_USER0); 610 memset(kaddr, 0, chunk_size); 611 de = (struct nilfs_dir_entry *)kaddr; 612 de->name_len = 1; 613 de->rec_len = nilfs_rec_len_to_disk(NILFS_DIR_REC_LEN(1)); 614 memcpy(de->name, ".\0\0", 4); 615 de->inode = cpu_to_le64(inode->i_ino); 616 nilfs_set_de_type(de, inode); 617 618 de = (struct nilfs_dir_entry *)(kaddr + NILFS_DIR_REC_LEN(1)); 619 de->name_len = 2; 620 de->rec_len = nilfs_rec_len_to_disk(chunk_size - NILFS_DIR_REC_LEN(1)); 621 de->inode = cpu_to_le64(parent->i_ino); 622 memcpy(de->name, "..\0", 4); 623 nilfs_set_de_type(de, inode); 624 kunmap_atomic(kaddr, KM_USER0); 625 nilfs_commit_chunk(page, mapping, 0, chunk_size); 626 fail: 627 page_cache_release(page); 628 return err; 629 } 630 631 /* 632 * routine to check that the specified directory is empty (for rmdir) 633 */ 634 int nilfs_empty_dir(struct inode *inode) 635 { 636 struct page *page = NULL; 637 unsigned long i, npages = dir_pages(inode); 638 639 for (i = 0; i < npages; i++) { 640 char *kaddr; 641 struct nilfs_dir_entry *de; 642 643 page = nilfs_get_page(inode, i); 644 if (IS_ERR(page)) 645 continue; 646 647 kaddr = page_address(page); 648 de = (struct nilfs_dir_entry *)kaddr; 649 kaddr += nilfs_last_byte(inode, i) - NILFS_DIR_REC_LEN(1); 650 651 while ((char *)de <= kaddr) { 652 if (de->rec_len == 0) { 653 nilfs_error(inode->i_sb, __func__, 654 "zero-length directory entry " 655 "(kaddr=%p, de=%p)\n", kaddr, de); 656 goto not_empty; 657 } 658 if (de->inode != 0) { 659 /* check for . and .. */ 660 if (de->name[0] != '.') 661 goto not_empty; 662 if (de->name_len > 2) 663 goto not_empty; 664 if (de->name_len < 2) { 665 if (de->inode != 666 cpu_to_le64(inode->i_ino)) 667 goto not_empty; 668 } else if (de->name[1] != '.') 669 goto not_empty; 670 } 671 de = nilfs_next_entry(de); 672 } 673 nilfs_put_page(page); 674 } 675 return 1; 676 677 not_empty: 678 nilfs_put_page(page); 679 return 0; 680 } 681 682 const struct file_operations nilfs_dir_operations = { 683 .llseek = generic_file_llseek, 684 .read = generic_read_dir, 685 .readdir = nilfs_readdir, 686 .unlocked_ioctl = nilfs_ioctl, 687 #ifdef CONFIG_COMPAT 688 .compat_ioctl = nilfs_ioctl, 689 #endif /* CONFIG_COMPAT */ 690 .fsync = nilfs_sync_file, 691 692 }; 693