commit 7b4ee73e28052e53aac2fef1c91029666d8b2d70 · tjh.dev/kernel

tjh.dev / kernel

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

[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 20 years ago 7b4ee73e 59af7038

+64 -55

5 changed files

expand all

unified split

ufs

balloc.c

ialloc.c

inode.c

super.c

util.h

+10 -9

fs/ufs/balloc.c

··· 49 49 50 50 sb = inode->i_sb; 51 51 uspi = UFS_SB(sb)->s_uspi; 52 - usb1 = ubh_get_usb_first(USPI_UBH); 52 + usb1 = ubh_get_usb_first(uspi); 53 53 54 54 UFSD(("ENTER, fragment %u, count %u\n", fragment, count)) 55 55 ··· 81 81 for (i = bit; i < end_bit; i++) { 82 82 if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, i)) 83 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); 84 + else 85 + ufs_error (sb, "ufs_free_fragments", 86 + "bit already cleared for fragment %u", i); 86 87 } 87 88 88 89 DQUOT_FREE_BLOCK (inode, count); ··· 144 143 145 144 sb = inode->i_sb; 146 145 uspi = UFS_SB(sb)->s_uspi; 147 - usb1 = ubh_get_usb_first(USPI_UBH); 146 + usb1 = ubh_get_usb_first(uspi); 148 147 149 148 UFSD(("ENTER, fragment %u, count %u\n", fragment, count)) 150 149 ··· 248 247 249 248 sb = inode->i_sb; 250 249 uspi = UFS_SB(sb)->s_uspi; 251 - usb1 = ubh_get_usb_first(USPI_UBH); 250 + usb1 = ubh_get_usb_first(uspi); 252 251 *err = -ENOSPC; 253 252 254 253 lock_super (sb); ··· 408 407 409 408 sb = inode->i_sb; 410 409 uspi = UFS_SB(sb)->s_uspi; 411 - usb1 = ubh_get_usb_first (USPI_UBH); 410 + usb1 = ubh_get_usb_first (uspi); 412 411 count = newcount - oldcount; 413 412 414 413 cgno = ufs_dtog(fragment); ··· 491 490 492 491 sb = inode->i_sb; 493 492 uspi = UFS_SB(sb)->s_uspi; 494 - usb1 = ubh_get_usb_first(USPI_UBH); 493 + usb1 = ubh_get_usb_first(uspi); 495 494 oldcg = cgno; 496 495 497 496 /* ··· 607 606 608 607 sb = inode->i_sb; 609 608 uspi = UFS_SB(sb)->s_uspi; 610 - usb1 = ubh_get_usb_first(USPI_UBH); 609 + usb1 = ubh_get_usb_first(uspi); 611 610 ucg = ubh_get_ucg(UCPI_UBH); 612 611 613 612 if (goal == 0) { ··· 664 663 UFSD(("ENTER, cg %u, goal %u, count %u\n", ucpi->c_cgx, goal, count)) 665 664 666 665 uspi = UFS_SB(sb)->s_uspi; 667 - usb1 = ubh_get_usb_first (USPI_UBH); 666 + usb1 = ubh_get_usb_first (uspi); 668 667 ucg = ubh_get_ucg(UCPI_UBH); 669 668 670 669 if (goal)

+2 -2

fs/ufs/ialloc.c

··· 72 72 73 73 sb = inode->i_sb; 74 74 uspi = UFS_SB(sb)->s_uspi; 75 - usb1 = ubh_get_usb_first(USPI_UBH); 75 + usb1 = ubh_get_usb_first(uspi); 76 76 77 77 ino = inode->i_ino; 78 78 ··· 167 167 ufsi = UFS_I(inode); 168 168 sbi = UFS_SB(sb); 169 169 uspi = sbi->s_uspi; 170 - usb1 = ubh_get_usb_first(USPI_UBH); 170 + usb1 = ubh_get_usb_first(uspi); 171 171 172 172 lock_super (sb); 173 173

+6 -5

fs/ufs/inode.c

··· 61 61 int n = 0; 62 62 63 63 64 - UFSD(("ptrs=uspi->s_apb = %d,double_blocks=%d \n",ptrs,double_blocks)); 64 + UFSD(("ptrs=uspi->s_apb = %d,double_blocks=%ld \n",ptrs,double_blocks)); 65 65 if (i_block < 0) { 66 66 ufs_warning(inode->i_sb, "ufs_block_to_path", "block < 0"); 67 67 } else if (i_block < direct_blocks) { ··· 104 104 unsigned flags = UFS_SB(sb)->s_flags; 105 105 u64 temp = 0L; 106 106 107 - UFSD((": frag = %lu depth = %d\n",frag,depth)); 107 + UFSD((": frag = %llu depth = %d\n", (unsigned long long)frag, depth)); 108 108 UFSD((": uspi->s_fpbshift = %d ,uspi->s_apbmask = %x, mask=%llx\n",uspi->s_fpbshift,uspi->s_apbmask,mask)); 109 109 110 110 if (depth == 0) ··· 365 365 sync_dirty_buffer(bh); 366 366 inode->i_ctime = CURRENT_TIME_SEC; 367 367 mark_inode_dirty(inode); 368 + UFSD(("result %u\n", tmp + blockoff)); 368 369 out: 369 370 brelse (bh); 370 - UFSD(("EXIT, result %u\n", tmp + blockoff)) 371 + UFSD(("EXIT\n")); 371 372 return result; 372 373 } 373 374 ··· 387 386 388 387 if (!create) { 389 388 phys64 = ufs_frag_map(inode, fragment); 390 - UFSD(("phys64 = %lu \n",phys64)); 389 + UFSD(("phys64 = %llu \n",phys64)); 391 390 if (phys64) 392 391 map_bh(bh_result, sb, phys64); 393 392 return 0; ··· 402 401 403 402 lock_kernel(); 404 403 405 - UFSD(("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment)) 404 + UFSD(("ENTER, ino %lu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment)) 406 405 if (fragment < 0) 407 406 goto abort_negative; 408 407 if (fragment >

+27 -30

fs/ufs/super.c

··· 221 221 va_list args; 222 222 223 223 uspi = UFS_SB(sb)->s_uspi; 224 - usb1 = ubh_get_usb_first(USPI_UBH); 224 + usb1 = ubh_get_usb_first(uspi); 225 225 226 226 if (!(sb->s_flags & MS_RDONLY)) { 227 227 usb1->fs_clean = UFS_FSBAD; ··· 253 253 va_list args; 254 254 255 255 uspi = UFS_SB(sb)->s_uspi; 256 - usb1 = ubh_get_usb_first(USPI_UBH); 256 + usb1 = ubh_get_usb_first(uspi); 257 257 258 258 if (!(sb->s_flags & MS_RDONLY)) { 259 259 usb1->fs_clean = UFS_FSBAD; ··· 420 420 if (i + uspi->s_fpb > blks) 421 421 size = (blks - i) * uspi->s_fsize; 422 422 423 - if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) { 423 + if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) 424 424 ubh = ubh_bread(sb, 425 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 { 426 + else 432 427 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 - } 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 + 438 435 space += size; 439 436 ubh_brelse (ubh); 440 437 ubh = NULL; ··· 536 539 struct inode *inode; 537 540 unsigned block_size, super_block_size; 538 541 unsigned flags; 542 + unsigned super_block_offset; 539 543 540 544 uspi = NULL; 541 545 ubh = NULL; ··· 584 586 if (!uspi) 585 587 goto failed; 586 588 589 + super_block_offset=UFS_SBLOCK; 590 + 587 591 /* Keep 2Gig file limit. Some UFS variants need to override 588 592 this but as I don't know which I'll let those in the know loosen 589 593 the rules */ 590 - 591 594 switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) { 592 595 case UFS_MOUNT_UFSTYPE_44BSD: 593 596 UFSD(("ufstype=44bsd\n")) ··· 600 601 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD; 601 602 break; 602 603 case UFS_MOUNT_UFSTYPE_UFS2: 603 - UFSD(("ufstype=ufs2\n")) 604 + UFSD(("ufstype=ufs2\n")); 605 + super_block_offset=SBLOCK_UFS2; 604 606 uspi->s_fsize = block_size = 512; 605 607 uspi->s_fmask = ~(512 - 1); 606 608 uspi->s_fshift = 9; ··· 725 725 /* 726 726 * read ufs super block from device 727 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 - } 728 + 729 + ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size); 730 + 734 731 if (!ubh) 735 732 goto failed; 736 733 737 734 738 - usb1 = ubh_get_usb_first(USPI_UBH); 739 - usb2 = ubh_get_usb_second(USPI_UBH); 740 - usb3 = ubh_get_usb_third(USPI_UBH); 735 + usb1 = ubh_get_usb_first(uspi); 736 + usb2 = ubh_get_usb_second(uspi); 737 + usb3 = ubh_get_usb_third(uspi); 741 738 usb = (struct ufs_super_block *) 742 739 ((struct ufs_buffer_head *)uspi)->bh[0]->b_data ; 743 740 ··· 1003 1006 UFSD(("ENTER\n")) 1004 1007 flags = UFS_SB(sb)->s_flags; 1005 1008 uspi = UFS_SB(sb)->s_uspi; 1006 - usb1 = ubh_get_usb_first(USPI_UBH); 1007 - usb3 = ubh_get_usb_third(USPI_UBH); 1009 + usb1 = ubh_get_usb_first(uspi); 1010 + usb3 = ubh_get_usb_third(uspi); 1008 1011 1009 1012 if (!(sb->s_flags & MS_RDONLY)) { 1010 1013 usb1->fs_time = cpu_to_fs32(sb, get_seconds()); ··· 1046 1049 1047 1050 uspi = UFS_SB(sb)->s_uspi; 1048 1051 flags = UFS_SB(sb)->s_flags; 1049 - usb1 = ubh_get_usb_first(USPI_UBH); 1050 - usb3 = ubh_get_usb_third(USPI_UBH); 1052 + usb1 = ubh_get_usb_first(uspi); 1053 + usb3 = ubh_get_usb_third(uspi); 1051 1054 1052 1055 /* 1053 1056 * Allow the "check" option to be passed as a remount option. ··· 1121 1124 lock_kernel(); 1122 1125 1123 1126 uspi = UFS_SB(sb)->s_uspi; 1124 - usb1 = ubh_get_usb_first (USPI_UBH); 1127 + usb1 = ubh_get_usb_first (uspi); 1125 1128 usb = (struct ufs_super_block *) 1126 1129 ((struct ufs_buffer_head *)uspi)->bh[0]->b_data ; 1127 1130

+19 -9

fs/ufs/util.h

··· 249 249 250 250 251 251 /* 252 - * macros to get important structures from ufs_buffer_head 252 + * macros and inline function to get important structures from ufs_sb_private_info 253 253 */ 254 - #define ubh_get_usb_first(ubh) \ 255 - ((struct ufs_super_block_first *)((ubh)->bh[0]->b_data)) 256 254 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))) 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 + } 260 264 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))) 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 + 264 274 265 275 #define ubh_get_ucg(ubh) \ 266 276 ((struct ufs_cylinder_group *)((ubh)->bh[0]->b_data))