Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/fs/ext3/namei.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* 2 * linux/fs/ext3/namei.c 3 * 4 * Copyright (C) 1992, 1993, 1994, 1995 5 * Remy Card (card@masi.ibp.fr) 6 * Laboratoire MASI - Institut Blaise Pascal 7 * Universite Pierre et Marie Curie (Paris VI) 8 * 9 * from 10 * 11 * linux/fs/minix/namei.c 12 * 13 * Copyright (C) 1991, 1992 Linus Torvalds 14 * 15 * Big-endian to little-endian byte-swapping/bitmaps by 16 * David S. Miller (davem@caip.rutgers.edu), 1995 17 * Directory entry file type support and forward compatibility hooks 18 * for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998 19 */ 20 21 #include <linux/fs.h> 22 #include <linux/jbd.h> 23 #include <linux/sched.h> 24 #include <linux/ext3_fs.h> 25 #include <linux/ext3_jbd.h> 26 #include <linux/fcntl.h> 27 #include <linux/stat.h> 28 #include <linux/string.h> 29 #include <linux/locks.h> 30 #include <linux/quotaops.h> 31 32 33 /* 34 * define how far ahead to read directories while searching them. 35 */ 36 #define NAMEI_RA_CHUNKS 2 37 #define NAMEI_RA_BLOCKS 4 38 #define NAMEI_RA_SIZE (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS) 39 #define NAMEI_RA_INDEX(c,b) (((c) * NAMEI_RA_BLOCKS) + (b)) 40 41 /* 42 * NOTE! unlike strncmp, ext3_match returns 1 for success, 0 for failure. 43 * 44 * `len <= EXT3_NAME_LEN' is guaranteed by caller. 45 * `de != NULL' is guaranteed by caller. 46 */ 47 static inline int ext3_match (int len, const char * const name, 48 struct ext3_dir_entry_2 * de) 49 { 50 if (len != de->name_len) 51 return 0; 52 if (!de->inode) 53 return 0; 54 return !memcmp(name, de->name, len); 55 } 56 57 /* 58 * Returns 0 if not found, -1 on failure, and 1 on success 59 */ 60 static int inline search_dirblock(struct buffer_head * bh, 61 struct inode *dir, 62 struct dentry *dentry, 63 unsigned long offset, 64 struct ext3_dir_entry_2 ** res_dir) 65 { 66 struct ext3_dir_entry_2 * de; 67 char * dlimit; 68 int de_len; 69 const char *name = dentry->d_name.name; 70 int namelen = dentry->d_name.len; 71 72 de = (struct ext3_dir_entry_2 *) bh->b_data; 73 dlimit = bh->b_data + dir->i_sb->s_blocksize; 74 while ((char *) de < dlimit) { 75 /* this code is executed quadratically often */ 76 /* do minimal checking `by hand' */ 77 78 if ((char *) de + namelen <= dlimit && 79 ext3_match (namelen, name, de)) { 80 /* found a match - just to be sure, do a full check */ 81 if (!ext3_check_dir_entry("ext3_find_entry", 82 dir, de, bh, offset)) 83 return -1; 84 *res_dir = de; 85 return 1; 86 } 87 /* prevent looping on a bad block */ 88 de_len = le16_to_cpu(de->rec_len); 89 if (de_len <= 0) 90 return -1; 91 offset += de_len; 92 de = (struct ext3_dir_entry_2 *) ((char *) de + de_len); 93 } 94 return 0; 95 } 96 97 /* 98 * ext3_find_entry() 99 * 100 * finds an entry in the specified directory with the wanted name. It 101 * returns the cache buffer in which the entry was found, and the entry 102 * itself (as a parameter - res_dir). It does NOT read the inode of the 103 * entry - you'll have to do that yourself if you want to. 104 * 105 * The returned buffer_head has ->b_count elevated. The caller is expected 106 * to brelse() it when appropriate. 107 */ 108 static struct buffer_head * ext3_find_entry (struct dentry *dentry, 109 struct ext3_dir_entry_2 ** res_dir) 110 { 111 struct super_block * sb; 112 struct buffer_head * bh_use[NAMEI_RA_SIZE]; 113 struct buffer_head * bh, *ret = NULL; 114 unsigned long start, block, b; 115 int ra_max = 0; /* Number of bh's in the readahead 116 buffer, bh_use[] */ 117 int ra_ptr = 0; /* Current index into readahead 118 buffer */ 119 int num = 0; 120 int nblocks, i, err; 121 struct inode *dir = dentry->d_parent->d_inode; 122 123 *res_dir = NULL; 124 sb = dir->i_sb; 125 126 nblocks = dir->i_size >> EXT3_BLOCK_SIZE_BITS(sb); 127 start = dir->u.ext3_i.i_dir_start_lookup; 128 if (start >= nblocks) 129 start = 0; 130 block = start; 131 restart: 132 do { 133 /* 134 * We deal with the read-ahead logic here. 135 */ 136 if (ra_ptr >= ra_max) { 137 /* Refill the readahead buffer */ 138 ra_ptr = 0; 139 b = block; 140 for (ra_max = 0; ra_max < NAMEI_RA_SIZE; ra_max++) { 141 /* 142 * Terminate if we reach the end of the 143 * directory and must wrap, or if our 144 * search has finished at this block. 145 */ 146 if (b >= nblocks || (num && block == start)) { 147 bh_use[ra_max] = NULL; 148 break; 149 } 150 num++; 151 bh = ext3_getblk(NULL, dir, b++, 0, &err); 152 bh_use[ra_max] = bh; 153 if (bh) 154 ll_rw_block(READ, 1, &bh); 155 } 156 } 157 if ((bh = bh_use[ra_ptr++]) == NULL) 158 goto next; 159 wait_on_buffer(bh); 160 if (!buffer_uptodate(bh)) { 161 /* read error, skip block & hope for the best */ 162 brelse(bh); 163 goto next; 164 } 165 i = search_dirblock(bh, dir, dentry, 166 block << EXT3_BLOCK_SIZE_BITS(sb), res_dir); 167 if (i == 1) { 168 dir->u.ext3_i.i_dir_start_lookup = block; 169 ret = bh; 170 goto cleanup_and_exit; 171 } else { 172 brelse(bh); 173 if (i < 0) 174 goto cleanup_and_exit; 175 } 176 next: 177 if (++block >= nblocks) 178 block = 0; 179 } while (block != start); 180 181 /* 182 * If the directory has grown while we were searching, then 183 * search the last part of the directory before giving up. 184 */ 185 block = nblocks; 186 nblocks = dir->i_size >> EXT3_BLOCK_SIZE_BITS(sb); 187 if (block < nblocks) { 188 start = 0; 189 goto restart; 190 } 191 192 cleanup_and_exit: 193 /* Clean up the read-ahead blocks */ 194 for (; ra_ptr < ra_max; ra_ptr++) 195 brelse (bh_use[ra_ptr]); 196 return ret; 197 } 198 199 static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry) 200 { 201 struct inode * inode; 202 struct ext3_dir_entry_2 * de; 203 struct buffer_head * bh; 204 205 if (dentry->d_name.len > EXT3_NAME_LEN) 206 return ERR_PTR(-ENAMETOOLONG); 207 208 bh = ext3_find_entry(dentry, &de); 209 inode = NULL; 210 if (bh) { 211 unsigned long ino = le32_to_cpu(de->inode); 212 brelse (bh); 213 inode = iget(dir->i_sb, ino); 214 215 if (!inode) 216 return ERR_PTR(-EACCES); 217 } 218 d_add(dentry, inode); 219 return NULL; 220 } 221 222 #define S_SHIFT 12 223 static unsigned char ext3_type_by_mode[S_IFMT >> S_SHIFT] = { 224 [S_IFREG >> S_SHIFT] EXT3_FT_REG_FILE, 225 [S_IFDIR >> S_SHIFT] EXT3_FT_DIR, 226 [S_IFCHR >> S_SHIFT] EXT3_FT_CHRDEV, 227 [S_IFBLK >> S_SHIFT] EXT3_FT_BLKDEV, 228 [S_IFIFO >> S_SHIFT] EXT3_FT_FIFO, 229 [S_IFSOCK >> S_SHIFT] EXT3_FT_SOCK, 230 [S_IFLNK >> S_SHIFT] EXT3_FT_SYMLINK, 231 }; 232 233 static inline void ext3_set_de_type(struct super_block *sb, 234 struct ext3_dir_entry_2 *de, 235 umode_t mode) { 236 if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_FILETYPE)) 237 de->file_type = ext3_type_by_mode[(mode & S_IFMT)>>S_SHIFT]; 238 } 239 240 /* 241 * ext3_add_entry() 242 * 243 * adds a file entry to the specified directory, using the same 244 * semantics as ext3_find_entry(). It returns NULL if it failed. 245 * 246 * NOTE!! The inode part of 'de' is left at 0 - which means you 247 * may not sleep between calling this and putting something into 248 * the entry, as someone else might have used it while you slept. 249 */ 250 251 /* 252 * AKPM: the journalling code here looks wrong on the error paths 253 */ 254 static int ext3_add_entry (handle_t *handle, struct dentry *dentry, 255 struct inode *inode) 256 { 257 struct inode *dir = dentry->d_parent->d_inode; 258 const char *name = dentry->d_name.name; 259 int namelen = dentry->d_name.len; 260 unsigned long offset; 261 unsigned short rec_len; 262 struct buffer_head * bh; 263 struct ext3_dir_entry_2 * de, * de1; 264 struct super_block * sb; 265 int retval; 266 267 sb = dir->i_sb; 268 269 if (!namelen) 270 return -EINVAL; 271 bh = ext3_bread (handle, dir, 0, 0, &retval); 272 if (!bh) 273 return retval; 274 rec_len = EXT3_DIR_REC_LEN(namelen); 275 offset = 0; 276 de = (struct ext3_dir_entry_2 *) bh->b_data; 277 while (1) { 278 if ((char *)de >= sb->s_blocksize + bh->b_data) { 279 brelse (bh); 280 bh = NULL; 281 bh = ext3_bread (handle, dir, 282 offset >> EXT3_BLOCK_SIZE_BITS(sb), 1, &retval); 283 if (!bh) 284 return retval; 285 if (dir->i_size <= offset) { 286 if (dir->i_size == 0) { 287 brelse(bh); 288 return -ENOENT; 289 } 290 291 ext3_debug ("creating next block\n"); 292 293 BUFFER_TRACE(bh, "get_write_access"); 294 ext3_journal_get_write_access(handle, bh); 295 de = (struct ext3_dir_entry_2 *) bh->b_data; 296 de->inode = 0; 297 de->rec_len = le16_to_cpu(sb->s_blocksize); 298 dir->u.ext3_i.i_disksize = 299 dir->i_size = offset + sb->s_blocksize; 300 dir->u.ext3_i.i_flags &= ~EXT3_INDEX_FL; 301 ext3_mark_inode_dirty(handle, dir); 302 } else { 303 304 ext3_debug ("skipping to next block\n"); 305 306 de = (struct ext3_dir_entry_2 *) bh->b_data; 307 } 308 } 309 if (!ext3_check_dir_entry ("ext3_add_entry", dir, de, bh, 310 offset)) { 311 brelse (bh); 312 return -ENOENT; 313 } 314 if (ext3_match (namelen, name, de)) { 315 brelse (bh); 316 return -EEXIST; 317 } 318 if ((le32_to_cpu(de->inode) == 0 && 319 le16_to_cpu(de->rec_len) >= rec_len) || 320 (le16_to_cpu(de->rec_len) >= 321 EXT3_DIR_REC_LEN(de->name_len) + rec_len)) { 322 BUFFER_TRACE(bh, "get_write_access"); 323 ext3_journal_get_write_access(handle, bh); 324 /* By now the buffer is marked for journaling */ 325 offset += le16_to_cpu(de->rec_len); 326 if (le32_to_cpu(de->inode)) { 327 de1 = (struct ext3_dir_entry_2 *) ((char *) de + 328 EXT3_DIR_REC_LEN(de->name_len)); 329 de1->rec_len = 330 cpu_to_le16(le16_to_cpu(de->rec_len) - 331 EXT3_DIR_REC_LEN(de->name_len)); 332 de->rec_len = cpu_to_le16( 333 EXT3_DIR_REC_LEN(de->name_len)); 334 de = de1; 335 } 336 de->file_type = EXT3_FT_UNKNOWN; 337 if (inode) { 338 de->inode = cpu_to_le32(inode->i_ino); 339 ext3_set_de_type(dir->i_sb, de, inode->i_mode); 340 } else 341 de->inode = 0; 342 de->name_len = namelen; 343 memcpy (de->name, name, namelen); 344 /* 345 * XXX shouldn't update any times until successful 346 * completion of syscall, but too many callers depend 347 * on this. 348 * 349 * XXX similarly, too many callers depend on 350 * ext3_new_inode() setting the times, but error 351 * recovery deletes the inode, so the worst that can 352 * happen is that the times are slightly out of date 353 * and/or different from the directory change time. 354 */ 355 dir->i_mtime = dir->i_ctime = CURRENT_TIME; 356 dir->u.ext3_i.i_flags &= ~EXT3_INDEX_FL; 357 dir->i_version = ++event; 358 ext3_mark_inode_dirty(handle, dir); 359 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata"); 360 ext3_journal_dirty_metadata(handle, bh); 361 brelse(bh); 362 return 0; 363 } 364 offset += le16_to_cpu(de->rec_len); 365 de = (struct ext3_dir_entry_2 *) 366 ((char *) de + le16_to_cpu(de->rec_len)); 367 } 368 brelse (bh); 369 return -ENOSPC; 370 } 371 372 /* 373 * ext3_delete_entry deletes a directory entry by merging it with the 374 * previous entry 375 */ 376 static int ext3_delete_entry (handle_t *handle, 377 struct inode * dir, 378 struct ext3_dir_entry_2 * de_del, 379 struct buffer_head * bh) 380 { 381 struct ext3_dir_entry_2 * de, * pde; 382 int i; 383 384 i = 0; 385 pde = NULL; 386 de = (struct ext3_dir_entry_2 *) bh->b_data; 387 while (i < bh->b_size) { 388 if (!ext3_check_dir_entry("ext3_delete_entry", dir, de, bh, i)) 389 return -EIO; 390 if (de == de_del) { 391 BUFFER_TRACE(bh, "get_write_access"); 392 ext3_journal_get_write_access(handle, bh); 393 if (pde) 394 pde->rec_len = 395 cpu_to_le16(le16_to_cpu(pde->rec_len) + 396 le16_to_cpu(de->rec_len)); 397 else 398 de->inode = 0; 399 dir->i_version = ++event; 400 BUFFER_TRACE(bh, "call ext3_journal_dirty_metadata"); 401 ext3_journal_dirty_metadata(handle, bh); 402 return 0; 403 } 404 i += le16_to_cpu(de->rec_len); 405 pde = de; 406 de = (struct ext3_dir_entry_2 *) 407 ((char *) de + le16_to_cpu(de->rec_len)); 408 } 409 return -ENOENT; 410 } 411 412 /* 413 * ext3_mark_inode_dirty is somewhat expensive, so unlike ext2 we 414 * do not perform it in these functions. We perform it at the call site, 415 * if it is needed. 416 */ 417 static inline void ext3_inc_count(handle_t *handle, struct inode *inode) 418 { 419 inode->i_nlink++; 420 } 421 422 static inline void ext3_dec_count(handle_t *handle, struct inode *inode) 423 { 424 inode->i_nlink--; 425 } 426 427 static int ext3_add_nondir(handle_t *handle, 428 struct dentry *dentry, struct inode *inode) 429 { 430 int err = ext3_add_entry(handle, dentry, inode); 431 if (!err) { 432 err = ext3_mark_inode_dirty(handle, inode); 433 if (err == 0) { 434 d_instantiate(dentry, inode); 435 return 0; 436 } 437 } 438 ext3_dec_count(handle, inode); 439 iput(inode); 440 return err; 441 } 442 443 /* 444 * By the time this is called, we already have created 445 * the directory cache entry for the new file, but it 446 * is so far negative - it has no inode. 447 * 448 * If the create succeeds, we fill in the inode information 449 * with d_instantiate(). 450 */ 451 static int ext3_create (struct inode * dir, struct dentry * dentry, int mode) 452 { 453 handle_t *handle; 454 struct inode * inode; 455 int err; 456 457 handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS + 3); 458 if (IS_ERR(handle)) 459 return PTR_ERR(handle); 460 461 if (IS_SYNC(dir)) 462 handle->h_sync = 1; 463 464 inode = ext3_new_inode (handle, dir, mode); 465 err = PTR_ERR(inode); 466 if (!IS_ERR(inode)) { 467 inode->i_op = &ext3_file_inode_operations; 468 inode->i_fop = &ext3_file_operations; 469 inode->i_mapping->a_ops = &ext3_aops; 470 err = ext3_add_nondir(handle, dentry, inode); 471 } 472 ext3_journal_stop(handle, dir); 473 return err; 474 } 475 476 static int ext3_mknod (struct inode * dir, struct dentry *dentry, 477 int mode, int rdev) 478 { 479 handle_t *handle; 480 struct inode *inode; 481 int err; 482 483 handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS + 3); 484 if (IS_ERR(handle)) 485 return PTR_ERR(handle); 486 487 if (IS_SYNC(dir)) 488 handle->h_sync = 1; 489 490 inode = ext3_new_inode (handle, dir, mode); 491 err = PTR_ERR(inode); 492 if (!IS_ERR(inode)) { 493 init_special_inode(inode, mode, rdev); 494 err = ext3_add_nondir(handle, dentry, inode); 495 } 496 ext3_journal_stop(handle, dir); 497 return err; 498 } 499 500 static int ext3_mkdir(struct inode * dir, struct dentry * dentry, int mode) 501 { 502 handle_t *handle; 503 struct inode * inode; 504 struct buffer_head * dir_block; 505 struct ext3_dir_entry_2 * de; 506 int err; 507 508 if (dir->i_nlink >= EXT3_LINK_MAX) 509 return -EMLINK; 510 511 handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS + 3); 512 if (IS_ERR(handle)) 513 return PTR_ERR(handle); 514 515 if (IS_SYNC(dir)) 516 handle->h_sync = 1; 517 518 inode = ext3_new_inode (handle, dir, S_IFDIR); 519 err = PTR_ERR(inode); 520 if (IS_ERR(inode)) 521 goto out_stop; 522 523 inode->i_op = &ext3_dir_inode_operations; 524 inode->i_fop = &ext3_dir_operations; 525 inode->i_size = inode->u.ext3_i.i_disksize = inode->i_sb->s_blocksize; 526 inode->i_blocks = 0; 527 dir_block = ext3_bread (handle, inode, 0, 1, &err); 528 if (!dir_block) { 529 inode->i_nlink--; /* is this nlink == 0? */ 530 ext3_mark_inode_dirty(handle, inode); 531 iput (inode); 532 goto out_stop; 533 } 534 BUFFER_TRACE(dir_block, "get_write_access"); 535 ext3_journal_get_write_access(handle, dir_block); 536 de = (struct ext3_dir_entry_2 *) dir_block->b_data; 537 de->inode = cpu_to_le32(inode->i_ino); 538 de->name_len = 1; 539 de->rec_len = cpu_to_le16(EXT3_DIR_REC_LEN(de->name_len)); 540 strcpy (de->name, "."); 541 ext3_set_de_type(dir->i_sb, de, S_IFDIR); 542 de = (struct ext3_dir_entry_2 *) 543 ((char *) de + le16_to_cpu(de->rec_len)); 544 de->inode = cpu_to_le32(dir->i_ino); 545 de->rec_len = cpu_to_le16(inode->i_sb->s_blocksize-EXT3_DIR_REC_LEN(1)); 546 de->name_len = 2; 547 strcpy (de->name, ".."); 548 ext3_set_de_type(dir->i_sb, de, S_IFDIR); 549 inode->i_nlink = 2; 550 BUFFER_TRACE(dir_block, "call ext3_journal_dirty_metadata"); 551 ext3_journal_dirty_metadata(handle, dir_block); 552 brelse (dir_block); 553 inode->i_mode = S_IFDIR | mode; 554 if (dir->i_mode & S_ISGID) 555 inode->i_mode |= S_ISGID; 556 ext3_mark_inode_dirty(handle, inode); 557 err = ext3_add_entry (handle, dentry, inode); 558 if (err) 559 goto out_no_entry; 560 dir->i_nlink++; 561 dir->u.ext3_i.i_flags &= ~EXT3_INDEX_FL; 562 ext3_mark_inode_dirty(handle, dir); 563 d_instantiate(dentry, inode); 564 out_stop: 565 ext3_journal_stop(handle, dir); 566 return err; 567 568 out_no_entry: 569 inode->i_nlink = 0; 570 ext3_mark_inode_dirty(handle, inode); 571 iput (inode); 572 goto out_stop; 573 } 574 575 /* 576 * routine to check that the specified directory is empty (for rmdir) 577 */ 578 static int empty_dir (struct inode * inode) 579 { 580 unsigned long offset; 581 struct buffer_head * bh; 582 struct ext3_dir_entry_2 * de, * de1; 583 struct super_block * sb; 584 int err; 585 586 sb = inode->i_sb; 587 if (inode->i_size < EXT3_DIR_REC_LEN(1) + EXT3_DIR_REC_LEN(2) || 588 !(bh = ext3_bread (NULL, inode, 0, 0, &err))) { 589 ext3_warning (inode->i_sb, "empty_dir", 590 "bad directory (dir #%lu) - no data block", 591 inode->i_ino); 592 return 1; 593 } 594 de = (struct ext3_dir_entry_2 *) bh->b_data; 595 de1 = (struct ext3_dir_entry_2 *) 596 ((char *) de + le16_to_cpu(de->rec_len)); 597 if (le32_to_cpu(de->inode) != inode->i_ino || 598 !le32_to_cpu(de1->inode) || 599 strcmp (".", de->name) || 600 strcmp ("..", de1->name)) { 601 ext3_warning (inode->i_sb, "empty_dir", 602 "bad directory (dir #%lu) - no `.' or `..'", 603 inode->i_ino); 604 brelse (bh); 605 return 1; 606 } 607 offset = le16_to_cpu(de->rec_len) + le16_to_cpu(de1->rec_len); 608 de = (struct ext3_dir_entry_2 *) 609 ((char *) de1 + le16_to_cpu(de1->rec_len)); 610 while (offset < inode->i_size ) { 611 if (!bh || 612 (void *) de >= (void *) (bh->b_data+sb->s_blocksize)) { 613 brelse (bh); 614 bh = ext3_bread (NULL, inode, 615 offset >> EXT3_BLOCK_SIZE_BITS(sb), 0, &err); 616 if (!bh) { 617 #if 0 618 ext3_error (sb, "empty_dir", 619 "directory #%lu contains a hole at offset %lu", 620 inode->i_ino, offset); 621 #endif 622 offset += sb->s_blocksize; 623 continue; 624 } 625 de = (struct ext3_dir_entry_2 *) bh->b_data; 626 } 627 if (!ext3_check_dir_entry ("empty_dir", inode, de, bh, 628 offset)) { 629 brelse (bh); 630 return 1; 631 } 632 if (le32_to_cpu(de->inode)) { 633 brelse (bh); 634 return 0; 635 } 636 offset += le16_to_cpu(de->rec_len); 637 de = (struct ext3_dir_entry_2 *) 638 ((char *) de + le16_to_cpu(de->rec_len)); 639 } 640 brelse (bh); 641 return 1; 642 } 643 644 /* ext3_orphan_add() links an unlinked or truncated inode into a list of 645 * such inodes, starting at the superblock, in case we crash before the 646 * file is closed/deleted, or in case the inode truncate spans multiple 647 * transactions and the last transaction is not recovered after a crash. 648 * 649 * At filesystem recovery time, we walk this list deleting unlinked 650 * inodes and truncating linked inodes in ext3_orphan_cleanup(). 651 */ 652 int ext3_orphan_add(handle_t *handle, struct inode *inode) 653 { 654 struct super_block *sb = inode->i_sb; 655 struct ext3_iloc iloc; 656 int err = 0, rc; 657 658 lock_super(sb); 659 if (!list_empty(&inode->u.ext3_i.i_orphan)) 660 goto out_unlock; 661 662 /* Orphan handling is only valid for files with data blocks 663 * being truncated, or files being unlinked. */ 664 665 /* @@@ FIXME: Observation from aviro: 666 * I think I can trigger J_ASSERT in ext3_orphan_add(). We block 667 * here (on lock_super()), so race with ext3_link() which might bump 668 * ->i_nlink. For, say it, character device. Not a regular file, 669 * not a directory, not a symlink and ->i_nlink > 0. 670 */ 671 J_ASSERT ((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 672 S_ISLNK(inode->i_mode)) || inode->i_nlink == 0); 673 674 BUFFER_TRACE(sb->u.ext3_sb.s_sbh, "get_write_access"); 675 err = ext3_journal_get_write_access(handle, sb->u.ext3_sb.s_sbh); 676 if (err) 677 goto out_unlock; 678 679 err = ext3_reserve_inode_write(handle, inode, &iloc); 680 if (err) 681 goto out_unlock; 682 683 /* Insert this inode at the head of the on-disk orphan list... */ 684 NEXT_ORPHAN(inode) = le32_to_cpu(EXT3_SB(sb)->s_es->s_last_orphan); 685 EXT3_SB(sb)->s_es->s_last_orphan = cpu_to_le32(inode->i_ino); 686 err = ext3_journal_dirty_metadata(handle, sb->u.ext3_sb.s_sbh); 687 rc = ext3_mark_iloc_dirty(handle, inode, &iloc); 688 if (!err) 689 err = rc; 690 691 /* Only add to the head of the in-memory list if all the 692 * previous operations succeeded. If the orphan_add is going to 693 * fail (possibly taking the journal offline), we can't risk 694 * leaving the inode on the orphan list: stray orphan-list 695 * entries can cause panics at unmount time. 696 * 697 * This is safe: on error we're going to ignore the orphan list 698 * anyway on the next recovery. */ 699 if (!err) 700 list_add(&inode->u.ext3_i.i_orphan, &EXT3_SB(sb)->s_orphan); 701 702 jbd_debug(4, "superblock will point to %ld\n", inode->i_ino); 703 jbd_debug(4, "orphan inode %ld will point to %d\n", 704 inode->i_ino, NEXT_ORPHAN(inode)); 705 out_unlock: 706 unlock_super(sb); 707 ext3_std_error(inode->i_sb, err); 708 return err; 709 } 710 711 /* 712 * ext3_orphan_del() removes an unlinked or truncated inode from the list 713 * of such inodes stored on disk, because it is finally being cleaned up. 714 */ 715 int ext3_orphan_del(handle_t *handle, struct inode *inode) 716 { 717 struct list_head *prev; 718 struct ext3_sb_info *sbi; 719 unsigned long ino_next; 720 struct ext3_iloc iloc; 721 int err = 0; 722 723 lock_super(inode->i_sb); 724 if (list_empty(&inode->u.ext3_i.i_orphan)) { 725 unlock_super(inode->i_sb); 726 return 0; 727 } 728 729 ino_next = NEXT_ORPHAN(inode); 730 prev = inode->u.ext3_i.i_orphan.prev; 731 sbi = EXT3_SB(inode->i_sb); 732 733 jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino); 734 735 list_del(&inode->u.ext3_i.i_orphan); 736 INIT_LIST_HEAD(&inode->u.ext3_i.i_orphan); 737 738 /* If we're on an error path, we may not have a valid 739 * transaction handle with which to update the orphan list on 740 * disk, but we still need to remove the inode from the linked 741 * list in memory. */ 742 if (!handle) 743 goto out; 744 745 err = ext3_reserve_inode_write(handle, inode, &iloc); 746 if (err) 747 goto out_err; 748 749 if (prev == &sbi->s_orphan) { 750 jbd_debug(4, "superblock will point to %lu\n", ino_next); 751 BUFFER_TRACE(sbi->s_sbh, "get_write_access"); 752 err = ext3_journal_get_write_access(handle, sbi->s_sbh); 753 if (err) 754 goto out_brelse; 755 sbi->s_es->s_last_orphan = cpu_to_le32(ino_next); 756 err = ext3_journal_dirty_metadata(handle, sbi->s_sbh); 757 } else { 758 struct ext3_iloc iloc2; 759 struct inode *i_prev = 760 list_entry(prev, struct inode, u.ext3_i.i_orphan); 761 762 jbd_debug(4, "orphan inode %lu will point to %lu\n", 763 i_prev->i_ino, ino_next); 764 err = ext3_reserve_inode_write(handle, i_prev, &iloc2); 765 if (err) 766 goto out_brelse; 767 NEXT_ORPHAN(i_prev) = ino_next; 768 err = ext3_mark_iloc_dirty(handle, i_prev, &iloc2); 769 } 770 if (err) 771 goto out_brelse; 772 NEXT_ORPHAN(inode) = 0; 773 err = ext3_mark_iloc_dirty(handle, inode, &iloc); 774 if (err) 775 goto out_brelse; 776 777 out_err: 778 ext3_std_error(inode->i_sb, err); 779 out: 780 unlock_super(inode->i_sb); 781 return err; 782 783 out_brelse: 784 brelse(iloc.bh); 785 goto out_err; 786 } 787 788 static int ext3_rmdir (struct inode * dir, struct dentry *dentry) 789 { 790 int retval; 791 struct inode * inode; 792 struct buffer_head * bh; 793 struct ext3_dir_entry_2 * de; 794 handle_t *handle; 795 796 handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS); 797 if (IS_ERR(handle)) 798 return PTR_ERR(handle); 799 800 retval = -ENOENT; 801 bh = ext3_find_entry (dentry, &de); 802 if (!bh) 803 goto end_rmdir; 804 805 if (IS_SYNC(dir)) 806 handle->h_sync = 1; 807 808 inode = dentry->d_inode; 809 DQUOT_INIT(inode); 810 811 retval = -EIO; 812 if (le32_to_cpu(de->inode) != inode->i_ino) 813 goto end_rmdir; 814 815 retval = -ENOTEMPTY; 816 if (!empty_dir (inode)) 817 goto end_rmdir; 818 819 retval = ext3_delete_entry(handle, dir, de, bh); 820 if (retval) 821 goto end_rmdir; 822 if (inode->i_nlink != 2) 823 ext3_warning (inode->i_sb, "ext3_rmdir", 824 "empty directory has nlink!=2 (%d)", 825 inode->i_nlink); 826 inode->i_version = ++event; 827 inode->i_nlink = 0; 828 /* There's no need to set i_disksize: the fact that i_nlink is 829 * zero will ensure that the right thing happens during any 830 * recovery. */ 831 inode->i_size = 0; 832 ext3_orphan_add(handle, inode); 833 dir->i_nlink--; 834 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 835 ext3_mark_inode_dirty(handle, inode); 836 dir->u.ext3_i.i_flags &= ~EXT3_INDEX_FL; 837 ext3_mark_inode_dirty(handle, dir); 838 839 end_rmdir: 840 ext3_journal_stop(handle, dir); 841 brelse (bh); 842 return retval; 843 } 844 845 static int ext3_unlink(struct inode * dir, struct dentry *dentry) 846 { 847 int retval; 848 struct inode * inode; 849 struct buffer_head * bh; 850 struct ext3_dir_entry_2 * de; 851 handle_t *handle; 852 853 handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS); 854 if (IS_ERR(handle)) 855 return PTR_ERR(handle); 856 857 if (IS_SYNC(dir)) 858 handle->h_sync = 1; 859 860 retval = -ENOENT; 861 bh = ext3_find_entry (dentry, &de); 862 if (!bh) 863 goto end_unlink; 864 865 inode = dentry->d_inode; 866 DQUOT_INIT(inode); 867 868 retval = -EIO; 869 if (le32_to_cpu(de->inode) != inode->i_ino) 870 goto end_unlink; 871 872 if (!inode->i_nlink) { 873 ext3_warning (inode->i_sb, "ext3_unlink", 874 "Deleting nonexistent file (%lu), %d", 875 inode->i_ino, inode->i_nlink); 876 inode->i_nlink = 1; 877 } 878 retval = ext3_delete_entry(handle, dir, de, bh); 879 if (retval) 880 goto end_unlink; 881 dir->i_ctime = dir->i_mtime = CURRENT_TIME; 882 dir->u.ext3_i.i_flags &= ~EXT3_INDEX_FL; 883 ext3_mark_inode_dirty(handle, dir); 884 inode->i_nlink--; 885 if (!inode->i_nlink) 886 ext3_orphan_add(handle, inode); 887 inode->i_ctime = dir->i_ctime; 888 ext3_mark_inode_dirty(handle, inode); 889 retval = 0; 890 891 end_unlink: 892 ext3_journal_stop(handle, dir); 893 brelse (bh); 894 return retval; 895 } 896 897 static int ext3_symlink (struct inode * dir, 898 struct dentry *dentry, const char * symname) 899 { 900 handle_t *handle; 901 struct inode * inode; 902 int l, err; 903 904 l = strlen(symname)+1; 905 if (l > dir->i_sb->s_blocksize) 906 return -ENAMETOOLONG; 907 908 handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS + 5); 909 if (IS_ERR(handle)) 910 return PTR_ERR(handle); 911 912 if (IS_SYNC(dir)) 913 handle->h_sync = 1; 914 915 inode = ext3_new_inode (handle, dir, S_IFLNK|S_IRWXUGO); 916 err = PTR_ERR(inode); 917 if (IS_ERR(inode)) 918 goto out_stop; 919 920 if (l > sizeof (inode->u.ext3_i.i_data)) { 921 inode->i_op = &page_symlink_inode_operations; 922 inode->i_mapping->a_ops = &ext3_aops; 923 /* 924 * block_symlink() calls back into ext3_prepare/commit_write. 925 * We have a transaction open. All is sweetness. It also sets 926 * i_size in generic_commit_write(). 927 */ 928 err = block_symlink(inode, symname, l); 929 if (err) 930 goto out_no_entry; 931 } else { 932 inode->i_op = &ext3_fast_symlink_inode_operations; 933 memcpy((char*)&inode->u.ext3_i.i_data,symname,l); 934 inode->i_size = l-1; 935 } 936 inode->u.ext3_i.i_disksize = inode->i_size; 937 err = ext3_add_nondir(handle, dentry, inode); 938 out_stop: 939 ext3_journal_stop(handle, dir); 940 return err; 941 942 out_no_entry: 943 ext3_dec_count(handle, inode); 944 ext3_mark_inode_dirty(handle, inode); 945 iput (inode); 946 goto out_stop; 947 } 948 949 static int ext3_link (struct dentry * old_dentry, 950 struct inode * dir, struct dentry *dentry) 951 { 952 handle_t *handle; 953 struct inode *inode = old_dentry->d_inode; 954 int err; 955 956 if (S_ISDIR(inode->i_mode)) 957 return -EPERM; 958 959 if (inode->i_nlink >= EXT3_LINK_MAX) 960 return -EMLINK; 961 962 handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS); 963 if (IS_ERR(handle)) 964 return PTR_ERR(handle); 965 966 if (IS_SYNC(dir)) 967 handle->h_sync = 1; 968 969 inode->i_ctime = CURRENT_TIME; 970 ext3_inc_count(handle, inode); 971 atomic_inc(&inode->i_count); 972 973 err = ext3_add_nondir(handle, dentry, inode); 974 ext3_journal_stop(handle, dir); 975 return err; 976 } 977 978 #define PARENT_INO(buffer) \ 979 ((struct ext3_dir_entry_2 *) ((char *) buffer + \ 980 le16_to_cpu(((struct ext3_dir_entry_2 *) buffer)->rec_len)))->inode 981 982 /* 983 * Anybody can rename anything with this: the permission checks are left to the 984 * higher-level routines. 985 */ 986 static int ext3_rename (struct inode * old_dir, struct dentry *old_dentry, 987 struct inode * new_dir,struct dentry *new_dentry) 988 { 989 handle_t *handle; 990 struct inode * old_inode, * new_inode; 991 struct buffer_head * old_bh, * new_bh, * dir_bh; 992 struct ext3_dir_entry_2 * old_de, * new_de; 993 int retval; 994 995 old_bh = new_bh = dir_bh = NULL; 996 997 handle = ext3_journal_start(old_dir, 2 * EXT3_DATA_TRANS_BLOCKS + 2); 998 if (IS_ERR(handle)) 999 return PTR_ERR(handle); 1000 1001 if (IS_SYNC(old_dir) || IS_SYNC(new_dir)) 1002 handle->h_sync = 1; 1003 1004 old_bh = ext3_find_entry (old_dentry, &old_de); 1005 /* 1006 * Check for inode number is _not_ due to possible IO errors. 1007 * We might rmdir the source, keep it as pwd of some process 1008 * and merrily kill the link to whatever was created under the 1009 * same name. Goodbye sticky bit ;-< 1010 */ 1011 old_inode = old_dentry->d_inode; 1012 retval = -ENOENT; 1013 if (!old_bh || le32_to_cpu(old_de->inode) != old_inode->i_ino) 1014 goto end_rename; 1015 1016 new_inode = new_dentry->d_inode; 1017 new_bh = ext3_find_entry (new_dentry, &new_de); 1018 if (new_bh) { 1019 if (!new_inode) { 1020 brelse (new_bh); 1021 new_bh = NULL; 1022 } else { 1023 DQUOT_INIT(new_inode); 1024 } 1025 } 1026 if (S_ISDIR(old_inode->i_mode)) { 1027 if (new_inode) { 1028 retval = -ENOTEMPTY; 1029 if (!empty_dir (new_inode)) 1030 goto end_rename; 1031 } 1032 retval = -EIO; 1033 dir_bh = ext3_bread (handle, old_inode, 0, 0, &retval); 1034 if (!dir_bh) 1035 goto end_rename; 1036 if (le32_to_cpu(PARENT_INO(dir_bh->b_data)) != old_dir->i_ino) 1037 goto end_rename; 1038 retval = -EMLINK; 1039 if (!new_inode && new_dir!=old_dir && 1040 new_dir->i_nlink >= EXT3_LINK_MAX) 1041 goto end_rename; 1042 } 1043 if (!new_bh) { 1044 retval = ext3_add_entry (handle, new_dentry, old_inode); 1045 if (retval) 1046 goto end_rename; 1047 } else { 1048 BUFFER_TRACE(new_bh, "get write access"); 1049 BUFFER_TRACE(new_bh, "get_write_access"); 1050 ext3_journal_get_write_access(handle, new_bh); 1051 new_de->inode = le32_to_cpu(old_inode->i_ino); 1052 if (EXT3_HAS_INCOMPAT_FEATURE(new_dir->i_sb, 1053 EXT3_FEATURE_INCOMPAT_FILETYPE)) 1054 new_de->file_type = old_de->file_type; 1055 new_dir->i_version = ++event; 1056 BUFFER_TRACE(new_bh, "call ext3_journal_dirty_metadata"); 1057 ext3_journal_dirty_metadata(handle, new_bh); 1058 brelse(new_bh); 1059 new_bh = NULL; 1060 } 1061 1062 /* 1063 * Like most other Unix systems, set the ctime for inodes on a 1064 * rename. 1065 */ 1066 old_inode->i_ctime = CURRENT_TIME; 1067 ext3_mark_inode_dirty(handle, old_inode); 1068 1069 /* 1070 * ok, that's it 1071 */ 1072 ext3_delete_entry(handle, old_dir, old_de, old_bh); 1073 1074 if (new_inode) { 1075 new_inode->i_nlink--; 1076 new_inode->i_ctime = CURRENT_TIME; 1077 } 1078 old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME; 1079 old_dir->u.ext3_i.i_flags &= ~EXT3_INDEX_FL; 1080 if (dir_bh) { 1081 BUFFER_TRACE(dir_bh, "get_write_access"); 1082 ext3_journal_get_write_access(handle, dir_bh); 1083 PARENT_INO(dir_bh->b_data) = le32_to_cpu(new_dir->i_ino); 1084 BUFFER_TRACE(dir_bh, "call ext3_journal_dirty_metadata"); 1085 ext3_journal_dirty_metadata(handle, dir_bh); 1086 old_dir->i_nlink--; 1087 if (new_inode) { 1088 new_inode->i_nlink--; 1089 } else { 1090 new_dir->i_nlink++; 1091 new_dir->u.ext3_i.i_flags &= ~EXT3_INDEX_FL; 1092 ext3_mark_inode_dirty(handle, new_dir); 1093 } 1094 } 1095 ext3_mark_inode_dirty(handle, old_dir); 1096 if (new_inode) { 1097 ext3_mark_inode_dirty(handle, new_inode); 1098 if (!new_inode->i_nlink) 1099 ext3_orphan_add(handle, new_inode); 1100 } 1101 retval = 0; 1102 1103 end_rename: 1104 brelse (dir_bh); 1105 brelse (old_bh); 1106 brelse (new_bh); 1107 ext3_journal_stop(handle, old_dir); 1108 return retval; 1109 } 1110 1111 /* 1112 * directories can handle most operations... 1113 */ 1114 struct inode_operations ext3_dir_inode_operations = { 1115 create: ext3_create, /* BKL held */ 1116 lookup: ext3_lookup, /* BKL held */ 1117 link: ext3_link, /* BKL held */ 1118 unlink: ext3_unlink, /* BKL held */ 1119 symlink: ext3_symlink, /* BKL held */ 1120 mkdir: ext3_mkdir, /* BKL held */ 1121 rmdir: ext3_rmdir, /* BKL held */ 1122 mknod: ext3_mknod, /* BKL held */ 1123 rename: ext3_rename, /* BKL held */ 1124 };
Cache object: 7253aa0489c078477bf3e072315ab0bf
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]