tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

[PATCH] ufs cleanup

Here is update of ufs cleanup patch, brought on by the recently fixed
ubh_get_usb_second() bug that made some ugly code rather painfully
obvious. It also includes

- fix compilation warnings which appears if debug mode turn on
- remove unnecessary duplication of code to support UFS2

I tested it on ufs1 and ufs2 file-systems.

Signed-off-by: Evgeniy Dushistov <dushistov@mail.ru>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

authored by Evgeniy and committed by Linus Torvalds 7b4ee73e 59af7038

+64 -55
unified split
+10 -9
fs/ufs/balloc.c
··· 49 50 sb = inode->i_sb; 51 uspi = UFS_SB(sb)->s_uspi; 52 - usb1 = ubh_get_usb_first(USPI_UBH); 53 54 UFSD(("ENTER, fragment %u, count %u\n", fragment, count)) 55 ··· 81 for (i = bit; i < end_bit; i++) { 82 if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, i)) 83 ubh_setbit (UCPI_UBH, ucpi->c_freeoff, i); 84 - else ufs_error (sb, "ufs_free_fragments", 85 - "bit already cleared for fragment %u", i); 86 } 87 88 DQUOT_FREE_BLOCK (inode, count); ··· 144 145 sb = inode->i_sb; 146 uspi = UFS_SB(sb)->s_uspi; 147 - usb1 = ubh_get_usb_first(USPI_UBH); 148 149 UFSD(("ENTER, fragment %u, count %u\n", fragment, count)) 150 ··· 248 249 sb = inode->i_sb; 250 uspi = UFS_SB(sb)->s_uspi; 251 - usb1 = ubh_get_usb_first(USPI_UBH); 252 *err = -ENOSPC; 253 254 lock_super (sb); ··· 408 409 sb = inode->i_sb; 410 uspi = UFS_SB(sb)->s_uspi; 411 - usb1 = ubh_get_usb_first (USPI_UBH); 412 count = newcount - oldcount; 413 414 cgno = ufs_dtog(fragment); ··· 491 492 sb = inode->i_sb; 493 uspi = UFS_SB(sb)->s_uspi; 494 - usb1 = ubh_get_usb_first(USPI_UBH); 495 oldcg = cgno; 496 497 /* ··· 607 608 sb = inode->i_sb; 609 uspi = UFS_SB(sb)->s_uspi; 610 - usb1 = ubh_get_usb_first(USPI_UBH); 611 ucg = ubh_get_ucg(UCPI_UBH); 612 613 if (goal == 0) { ··· 664 UFSD(("ENTER, cg %u, goal %u, count %u\n", ucpi->c_cgx, goal, count)) 665 666 uspi = UFS_SB(sb)->s_uspi; 667 - usb1 = ubh_get_usb_first (USPI_UBH); 668 ucg = ubh_get_ucg(UCPI_UBH); 669 670 if (goal)
··· 49 50 sb = inode->i_sb; 51 uspi = UFS_SB(sb)->s_uspi; 52 + usb1 = ubh_get_usb_first(uspi); 53 54 UFSD(("ENTER, fragment %u, count %u\n", fragment, count)) 55 ··· 81 for (i = bit; i < end_bit; i++) { 82 if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, i)) 83 ubh_setbit (UCPI_UBH, ucpi->c_freeoff, i); 84 + else 85 + ufs_error (sb, "ufs_free_fragments", 86 + "bit already cleared for fragment %u", i); 87 } 88 89 DQUOT_FREE_BLOCK (inode, count); ··· 143 144 sb = inode->i_sb; 145 uspi = UFS_SB(sb)->s_uspi; 146 + usb1 = ubh_get_usb_first(uspi); 147 148 UFSD(("ENTER, fragment %u, count %u\n", fragment, count)) 149 ··· 247 248 sb = inode->i_sb; 249 uspi = UFS_SB(sb)->s_uspi; 250 + usb1 = ubh_get_usb_first(uspi); 251 *err = -ENOSPC; 252 253 lock_super (sb); ··· 407 408 sb = inode->i_sb; 409 uspi = UFS_SB(sb)->s_uspi; 410 + usb1 = ubh_get_usb_first (uspi); 411 count = newcount - oldcount; 412 413 cgno = ufs_dtog(fragment); ··· 490 491 sb = inode->i_sb; 492 uspi = UFS_SB(sb)->s_uspi; 493 + usb1 = ubh_get_usb_first(uspi); 494 oldcg = cgno; 495 496 /* ··· 606 607 sb = inode->i_sb; 608 uspi = UFS_SB(sb)->s_uspi; 609 + usb1 = ubh_get_usb_first(uspi); 610 ucg = ubh_get_ucg(UCPI_UBH); 611 612 if (goal == 0) { ··· 663 UFSD(("ENTER, cg %u, goal %u, count %u\n", ucpi->c_cgx, goal, count)) 664 665 uspi = UFS_SB(sb)->s_uspi; 666 + usb1 = ubh_get_usb_first (uspi); 667 ucg = ubh_get_ucg(UCPI_UBH); 668 669 if (goal)
+2 -2
fs/ufs/ialloc.c
··· 72 73 sb = inode->i_sb; 74 uspi = UFS_SB(sb)->s_uspi; 75 - usb1 = ubh_get_usb_first(USPI_UBH); 76 77 ino = inode->i_ino; 78 ··· 167 ufsi = UFS_I(inode); 168 sbi = UFS_SB(sb); 169 uspi = sbi->s_uspi; 170 - usb1 = ubh_get_usb_first(USPI_UBH); 171 172 lock_super (sb); 173
··· 72 73 sb = inode->i_sb; 74 uspi = UFS_SB(sb)->s_uspi; 75 + usb1 = ubh_get_usb_first(uspi); 76 77 ino = inode->i_ino; 78 ··· 167 ufsi = UFS_I(inode); 168 sbi = UFS_SB(sb); 169 uspi = sbi->s_uspi; 170 + usb1 = ubh_get_usb_first(uspi); 171 172 lock_super (sb); 173
+6 -5
fs/ufs/inode.c
··· 61 int n = 0; 62 63 64 - UFSD(("ptrs=uspi->s_apb = %d,double_blocks=%d \n",ptrs,double_blocks)); 65 if (i_block < 0) { 66 ufs_warning(inode->i_sb, "ufs_block_to_path", "block < 0"); 67 } else if (i_block < direct_blocks) { ··· 104 unsigned flags = UFS_SB(sb)->s_flags; 105 u64 temp = 0L; 106 107 - UFSD((": frag = %lu depth = %d\n",frag,depth)); 108 UFSD((": uspi->s_fpbshift = %d ,uspi->s_apbmask = %x, mask=%llx\n",uspi->s_fpbshift,uspi->s_apbmask,mask)); 109 110 if (depth == 0) ··· 365 sync_dirty_buffer(bh); 366 inode->i_ctime = CURRENT_TIME_SEC; 367 mark_inode_dirty(inode); 368 out: 369 brelse (bh); 370 - UFSD(("EXIT, result %u\n", tmp + blockoff)) 371 return result; 372 } 373 ··· 387 388 if (!create) { 389 phys64 = ufs_frag_map(inode, fragment); 390 - UFSD(("phys64 = %lu \n",phys64)); 391 if (phys64) 392 map_bh(bh_result, sb, phys64); 393 return 0; ··· 402 403 lock_kernel(); 404 405 - UFSD(("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment)) 406 if (fragment < 0) 407 goto abort_negative; 408 if (fragment >
··· 61 int n = 0; 62 63 64 + UFSD(("ptrs=uspi->s_apb = %d,double_blocks=%ld \n",ptrs,double_blocks)); 65 if (i_block < 0) { 66 ufs_warning(inode->i_sb, "ufs_block_to_path", "block < 0"); 67 } else if (i_block < direct_blocks) { ··· 104 unsigned flags = UFS_SB(sb)->s_flags; 105 u64 temp = 0L; 106 107 + UFSD((": frag = %llu depth = %d\n", (unsigned long long)frag, depth)); 108 UFSD((": uspi->s_fpbshift = %d ,uspi->s_apbmask = %x, mask=%llx\n",uspi->s_fpbshift,uspi->s_apbmask,mask)); 109 110 if (depth == 0) ··· 365 sync_dirty_buffer(bh); 366 inode->i_ctime = CURRENT_TIME_SEC; 367 mark_inode_dirty(inode); 368 + UFSD(("result %u\n", tmp + blockoff)); 369 out: 370 brelse (bh); 371 + UFSD(("EXIT\n")); 372 return result; 373 } 374 ··· 386 387 if (!create) { 388 phys64 = ufs_frag_map(inode, fragment); 389 + UFSD(("phys64 = %llu \n",phys64)); 390 if (phys64) 391 map_bh(bh_result, sb, phys64); 392 return 0; ··· 401 402 lock_kernel(); 403 404 + UFSD(("ENTER, ino %lu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment)) 405 if (fragment < 0) 406 goto abort_negative; 407 if (fragment >
+27 -30
fs/ufs/super.c
··· 221 va_list args; 222 223 uspi = UFS_SB(sb)->s_uspi; 224 - usb1 = ubh_get_usb_first(USPI_UBH); 225 226 if (!(sb->s_flags & MS_RDONLY)) { 227 usb1->fs_clean = UFS_FSBAD; ··· 253 va_list args; 254 255 uspi = UFS_SB(sb)->s_uspi; 256 - usb1 = ubh_get_usb_first(USPI_UBH); 257 258 if (!(sb->s_flags & MS_RDONLY)) { 259 usb1->fs_clean = UFS_FSBAD; ··· 420 if (i + uspi->s_fpb > blks) 421 size = (blks - i) * uspi->s_fsize; 422 423 - if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) { 424 ubh = ubh_bread(sb, 425 fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_csaddr) + i, size); 426 - if (!ubh) 427 - goto failed; 428 - ubh_ubhcpymem (space, ubh, size); 429 - sbi->s_csp[ufs_fragstoblks(i)]=(struct ufs_csum *)space; 430 - } 431 - else { 432 ubh = ubh_bread(sb, uspi->s_csaddr + i, size); 433 - if (!ubh) 434 - goto failed; 435 - ubh_ubhcpymem(space, ubh, size); 436 - sbi->s_csp[ufs_fragstoblks(i)]=(struct ufs_csum *)space; 437 - } 438 space += size; 439 ubh_brelse (ubh); 440 ubh = NULL; ··· 536 struct inode *inode; 537 unsigned block_size, super_block_size; 538 unsigned flags; 539 540 uspi = NULL; 541 ubh = NULL; ··· 584 if (!uspi) 585 goto failed; 586 587 /* Keep 2Gig file limit. Some UFS variants need to override 588 this but as I don't know which I'll let those in the know loosen 589 the rules */ 590 - 591 switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) { 592 case UFS_MOUNT_UFSTYPE_44BSD: 593 UFSD(("ufstype=44bsd\n")) ··· 600 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD; 601 break; 602 case UFS_MOUNT_UFSTYPE_UFS2: 603 - UFSD(("ufstype=ufs2\n")) 604 uspi->s_fsize = block_size = 512; 605 uspi->s_fmask = ~(512 - 1); 606 uspi->s_fshift = 9; ··· 725 /* 726 * read ufs super block from device 727 */ 728 - if ( (flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) { 729 - ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + SBLOCK_UFS2/block_size, super_block_size); 730 - } 731 - else { 732 - ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + UFS_SBLOCK/block_size, super_block_size); 733 - } 734 if (!ubh) 735 goto failed; 736 737 738 - usb1 = ubh_get_usb_first(USPI_UBH); 739 - usb2 = ubh_get_usb_second(USPI_UBH); 740 - usb3 = ubh_get_usb_third(USPI_UBH); 741 usb = (struct ufs_super_block *) 742 ((struct ufs_buffer_head *)uspi)->bh[0]->b_data ; 743 ··· 1003 UFSD(("ENTER\n")) 1004 flags = UFS_SB(sb)->s_flags; 1005 uspi = UFS_SB(sb)->s_uspi; 1006 - usb1 = ubh_get_usb_first(USPI_UBH); 1007 - usb3 = ubh_get_usb_third(USPI_UBH); 1008 1009 if (!(sb->s_flags & MS_RDONLY)) { 1010 usb1->fs_time = cpu_to_fs32(sb, get_seconds()); ··· 1046 1047 uspi = UFS_SB(sb)->s_uspi; 1048 flags = UFS_SB(sb)->s_flags; 1049 - usb1 = ubh_get_usb_first(USPI_UBH); 1050 - usb3 = ubh_get_usb_third(USPI_UBH); 1051 1052 /* 1053 * Allow the "check" option to be passed as a remount option. ··· 1121 lock_kernel(); 1122 1123 uspi = UFS_SB(sb)->s_uspi; 1124 - usb1 = ubh_get_usb_first (USPI_UBH); 1125 usb = (struct ufs_super_block *) 1126 ((struct ufs_buffer_head *)uspi)->bh[0]->b_data ; 1127
··· 221 va_list args; 222 223 uspi = UFS_SB(sb)->s_uspi; 224 + usb1 = ubh_get_usb_first(uspi); 225 226 if (!(sb->s_flags & MS_RDONLY)) { 227 usb1->fs_clean = UFS_FSBAD; ··· 253 va_list args; 254 255 uspi = UFS_SB(sb)->s_uspi; 256 + usb1 = ubh_get_usb_first(uspi); 257 258 if (!(sb->s_flags & MS_RDONLY)) { 259 usb1->fs_clean = UFS_FSBAD; ··· 420 if (i + uspi->s_fpb > blks) 421 size = (blks - i) * uspi->s_fsize; 422 423 + if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) 424 ubh = ubh_bread(sb, 425 fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_csaddr) + i, size); 426 + else 427 ubh = ubh_bread(sb, uspi->s_csaddr + i, size); 428 + 429 + if (!ubh) 430 + goto failed; 431 + 432 + ubh_ubhcpymem (space, ubh, size); 433 + sbi->s_csp[ufs_fragstoblks(i)]=(struct ufs_csum *)space; 434 + 435 space += size; 436 ubh_brelse (ubh); 437 ubh = NULL; ··· 539 struct inode *inode; 540 unsigned block_size, super_block_size; 541 unsigned flags; 542 + unsigned super_block_offset; 543 544 uspi = NULL; 545 ubh = NULL; ··· 586 if (!uspi) 587 goto failed; 588 589 + super_block_offset=UFS_SBLOCK; 590 + 591 /* Keep 2Gig file limit. Some UFS variants need to override 592 this but as I don't know which I'll let those in the know loosen 593 the rules */ 594 switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) { 595 case UFS_MOUNT_UFSTYPE_44BSD: 596 UFSD(("ufstype=44bsd\n")) ··· 601 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD; 602 break; 603 case UFS_MOUNT_UFSTYPE_UFS2: 604 + UFSD(("ufstype=ufs2\n")); 605 + super_block_offset=SBLOCK_UFS2; 606 uspi->s_fsize = block_size = 512; 607 uspi->s_fmask = ~(512 - 1); 608 uspi->s_fshift = 9; ··· 725 /* 726 * read ufs super block from device 727 */ 728 + 729 + ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size); 730 + 731 if (!ubh) 732 goto failed; 733 734 735 + usb1 = ubh_get_usb_first(uspi); 736 + usb2 = ubh_get_usb_second(uspi); 737 + usb3 = ubh_get_usb_third(uspi); 738 usb = (struct ufs_super_block *) 739 ((struct ufs_buffer_head *)uspi)->bh[0]->b_data ; 740 ··· 1006 UFSD(("ENTER\n")) 1007 flags = UFS_SB(sb)->s_flags; 1008 uspi = UFS_SB(sb)->s_uspi; 1009 + usb1 = ubh_get_usb_first(uspi); 1010 + usb3 = ubh_get_usb_third(uspi); 1011 1012 if (!(sb->s_flags & MS_RDONLY)) { 1013 usb1->fs_time = cpu_to_fs32(sb, get_seconds()); ··· 1049 1050 uspi = UFS_SB(sb)->s_uspi; 1051 flags = UFS_SB(sb)->s_flags; 1052 + usb1 = ubh_get_usb_first(uspi); 1053 + usb3 = ubh_get_usb_third(uspi); 1054 1055 /* 1056 * Allow the "check" option to be passed as a remount option. ··· 1124 lock_kernel(); 1125 1126 uspi = UFS_SB(sb)->s_uspi; 1127 + usb1 = ubh_get_usb_first (uspi); 1128 usb = (struct ufs_super_block *) 1129 ((struct ufs_buffer_head *)uspi)->bh[0]->b_data ; 1130
+19 -9
fs/ufs/util.h
··· 249 250 251 /* 252 - * macros to get important structures from ufs_buffer_head 253 */ 254 - #define ubh_get_usb_first(ubh) \ 255 - ((struct ufs_super_block_first *)((ubh)->bh[0]->b_data)) 256 257 - #define ubh_get_usb_second(ubh) \ 258 - ((struct ufs_super_block_second *)((ubh)->\ 259 - bh[UFS_SECTOR_SIZE >> uspi->s_fshift]->b_data + (UFS_SECTOR_SIZE & ~uspi->s_fmask))) 260 261 - #define ubh_get_usb_third(ubh) \ 262 - ((struct ufs_super_block_third *)((ubh)-> \ 263 - bh[UFS_SECTOR_SIZE*2 >> uspi->s_fshift]->b_data + (UFS_SECTOR_SIZE*2 & ~uspi->s_fmask))) 264 265 #define ubh_get_ucg(ubh) \ 266 ((struct ufs_cylinder_group *)((ubh)->bh[0]->b_data))
··· 249 250 251 /* 252 + * macros and inline function to get important structures from ufs_sb_private_info 253 */ 254 255 + static inline void *get_usb_offset(struct ufs_sb_private_info *uspi, 256 + unsigned int offset) 257 + { 258 + unsigned int index; 259 + 260 + index = offset >> uspi->s_fshift; 261 + offset &= ~uspi->s_fmask; 262 + return uspi->s_ubh.bh[index]->b_data + offset; 263 + } 264 265 + #define ubh_get_usb_first(uspi) \ 266 + ((struct ufs_super_block_first *)get_usb_offset((uspi), 0)) 267 + 268 + #define ubh_get_usb_second(uspi) \ 269 + ((struct ufs_super_block_second *)get_usb_offset((uspi), UFS_SECTOR_SIZE)) 270 + 271 + #define ubh_get_usb_third(uspi) \ 272 + ((struct ufs_super_block_third *)get_usb_offset((uspi), 2*UFS_SECTOR_SIZE)) 273 + 274 275 #define ubh_get_ucg(ubh) \ 276 ((struct ufs_cylinder_group *)((ubh)->bh[0]->b_data))