udf: improve code related to super_block, was: udf: convert super_block macros to functions
cover udf: improve code related to super_block, was: udf: convert super_block macros to functions
Hi
This patchset converts macros related to super_block into functions. Besides that it fixes some sparse warnings (6th), improves coding style (1st) and fixes error handling (4th).
Note that udf files has really long lines and these patches won't validate by checkpatch. I'm going to do more cleanups later.
First version of this patchset had 24 patches: http://lkml.org/lkml/2007/12/22/150
01 didn't change
02 was dropped
03-17,20,21 was combined into one (with changes asked by Christoph Hellwig)
18 was slightly changed - function udf_sb_alloc_partition_maps was moved from udf_sb.h to super.c 19 didn't change
22,23 was combined into one and functions moved from udf_sb.h to super.c
24 didn't change
Marcin Slusarz
PATCH 1/6 udf: fix coding style of super.c
fix coding style errors found by checkpatch:
- assignments in if conditions
- braces {} around single statement blocks
- no spaces after commas
- printks without KERN_*
- lines longer than 80 characters
before: total: 50 errors, 207 warnings, 1835 lines checked after: total: 0 errors, 164 warnings, 1872 lines checked
all 164 warnings left are lines longer than 80 characters; this file has too much indentation with really long expressions to break all those lines now
--- fs/udf/super.c | 295 +++++++++++++++++++++++++++++++------------------------ 1 files changed, 166 insertions(+), 129 deletions(-)
fs/udf/super.c +166 -129
@@ -33,8 +33,8 @@* 10/17/98 added freespace count for "df" * 11/11/98 gr added novrs option * 11/26/98 dgb added fileset,anchor mount options -* 12/06/98 blf really hosed things royally. vat/sparing support. sequenced vol descs -* rewrote option handling based on isofs +* 12/06/98 blf really hosed things royally. vat/sparing support. sequenced +* vol descs. rewrote option handling based on isofs * 12/20/98 find the free space bitmap (if it exists) */
@@ -116,7 +116,7 @@ static struct kmem_cache *udf_inode_cachep;static struct inode *udf_alloc_inode (struct super_block *sb) {struct udf_inode_info *ei; - ei = (struct udf_inode_info *)kmem_cache_alloc (udf_inode_cachep,GFP_KERNEL ); + ei =kmem_cache_alloc (udf_inode_cachep,GFP_KERNEL );if (!ei)return NULL ;
@@ -561,47 +561,52 @@ static int udf_vrs(struct super_block *sb, int silent)/* Look for ISO descriptors */ vsd = (struct volStructDesc *)(bh->b_data + - (sector & (sb->s_blocksize -1 ))); + (sector & (sb->s_blocksize -1 )));if (vsd->stdIdent[0 ] ==0 ) {brelse (bh);break ; - }else if (!strncmp (vsd->stdIdent,VSD_STD_ID_CD001 ,VSD_STD_ID_LEN )) { + }else if (!strncmp (vsd->stdIdent,VSD_STD_ID_CD001 , +VSD_STD_ID_LEN )) { iso9660 = sector;switch (vsd->structType) {case 0 :udf_debug ("ISO9660 Boot Record found\n" );break ;case 1 : -udf_debug - ("ISO9660 Primary Volume Descriptor found\n" ); +udf_debug ("ISO9660 Primary Volume Descriptor " +"found\n" );break ;case 2 : -udf_debug - ("ISO9660 Supplementary Volume Descriptor found\n" ); +udf_debug ("ISO9660 Supplementary Volume " +"Descriptor found\n" );break ;case 3 : -udf_debug - ("ISO9660 Volume Partition Descriptor found\n" ); +udf_debug ("ISO9660 Volume Partition Descriptor " +"found\n" );break ;case 255 : -udf_debug - ("ISO9660 Volume Descriptor Set Terminator found\n" ); +udf_debug ("ISO9660 Volume Descriptor Set " +"Terminator found\n" );break ;default :udf_debug ("ISO9660 VRS (%u) found\n" , vsd->structType);break ; } - }else if (!strncmp (vsd->stdIdent,VSD_STD_ID_BEA01 ,VSD_STD_ID_LEN )) { - }else if (!strncmp (vsd->stdIdent,VSD_STD_ID_TEA01 ,VSD_STD_ID_LEN )) { + }else if (!strncmp (vsd->stdIdent,VSD_STD_ID_BEA01 , +VSD_STD_ID_LEN )) + ;/* nothing */ +else if (!strncmp (vsd->stdIdent,VSD_STD_ID_TEA01 , +VSD_STD_ID_LEN )) {brelse (bh);break ; - }else if (!strncmp (vsd->stdIdent,VSD_STD_ID_NSR02 ,VSD_STD_ID_LEN )) { + }else if (!strncmp (vsd->stdIdent,VSD_STD_ID_NSR02 , +VSD_STD_ID_LEN )) nsr02 = sector; - }else if (!strncmp (vsd->stdIdent,VSD_STD_ID_NSR03 ,VSD_STD_ID_LEN )) { +else if (!strncmp (vsd->stdIdent,VSD_STD_ID_NSR03 , +VSD_STD_ID_LEN )) nsr03 = sector; - }brelse (bh); }
@@ -658,21 +663,26 @@ static void udf_find_anchor(struct super_block *sb)* however, if the disc isn't closed, it could be 512 */ for (i =0 ; !lastblock && i <ARRAY_SIZE (last); i++) { -if (last[i] <0 || !(bh =sb_bread (sb, last[i]))) { - ident = location =0 ; - }else { - ident =le16_to_cpu (((tag *)bh->b_data)->tagIdent); - location =le32_to_cpu (((tag *)bh->b_data)->tagLocation); -brelse (bh); + ident = location =0 ; +if (last[i] >=0 ) { + bh =sb_bread (sb, last[i]); +if (bh) { +tag *t = (tag *)bh->b_data; + ident =le16_to_cpu (t->tagIdent); + location =le32_to_cpu (t->tagLocation); +brelse (bh); + } }if (ident ==TAG_IDENT_AVDP ) {if (location == last[i] -UDF_SB_SESSION (sb)) { - lastblock =UDF_SB_ANCHOR (sb)[0 ] = last[i] -UDF_SB_SESSION (sb); -UDF_SB_ANCHOR (sb)[1 ] = last[i] -256 -UDF_SB_SESSION (sb); + lastblock = last[i] -UDF_SB_SESSION (sb); +UDF_SB_ANCHOR (sb)[0 ] = lastblock; +UDF_SB_ANCHOR (sb)[1 ] = lastblock -256 ; }else if (location ==udf_variable_to_fixed (last[i]) -UDF_SB_SESSION (sb)) {UDF_SET_FLAG (sb,UDF_FLAG_VARCONV ); - lastblock =UDF_SB_ANCHOR (sb)[0 ] =udf_variable_to_fixed (last[i]) -UDF_SB_SESSION (sb); + lastblock =udf_variable_to_fixed (last[i]) -UDF_SB_SESSION (sb); +UDF_SB_ANCHOR (sb)[0 ] = lastblock;UDF_SB_ANCHOR (sb)[1 ] = lastblock -256 -UDF_SB_SESSION (sb); }else { udf_debug("Anchor found at block %d, location mismatch %d.\n",
@@ -682,12 +692,15 @@ static void udf_find_anchor(struct super_block *sb) lastblock = last[i];UDF_SB_ANCHOR (sb)[3 ] =512 ; }else { -if (last[i] <256 || !(bh =sb_bread (sb, last[i] -256 ))) { - ident = location =0 ; - }else { - ident =le16_to_cpu (((tag *)bh->b_data)->tagIdent); - location =le32_to_cpu (((tag *)bh->b_data)->tagLocation); -brelse (bh); + ident = location =0 ; +if (last[i] >=256 ) { + bh =sb_bread (sb, last[i] -256 ); +if (bh) { +tag *t = (tag *)bh->b_data; + ident =le16_to_cpu (t->tagIdent); + location =le32_to_cpu (t->tagLocation); +brelse (bh); + } } if (ident == TAG_IDENT_AVDP &&
@@ -695,13 +708,15 @@ static void udf_find_anchor(struct super_block *sb) lastblock = last[i];UDF_SB_ANCHOR (sb)[1 ] = last[i] -256 ; }else { -if (last[i] <312 +UDF_SB_SESSION (sb) || - !(bh =sb_bread (sb, last[i] -312 -UDF_SB_SESSION (sb)))) { - ident = location =0 ; - }else { - ident =le16_to_cpu (((tag *)bh->b_data)->tagIdent); - location =le32_to_cpu (((tag *)bh->b_data)->tagLocation); -brelse (bh); + ident = location =0 ; +if (last[i] >=312 +UDF_SB_SESSION (sb)) { + bh =sb_bread (sb, last[i] -312 -UDF_SB_SESSION (sb)); +if (bh) { +tag *t = (tag *)bh->b_data; + ident =le16_to_cpu (t->tagIdent); + location =le32_to_cpu (t->tagLocation); +brelse (bh); + } } if (ident == TAG_IDENT_AVDP &&
@@ -716,10 +731,12 @@ static void udf_find_anchor(struct super_block *sb) }if (!lastblock) { -/* We havn't found the lastblock. check 312 */ -if ((bh =sb_bread (sb,312 +UDF_SB_SESSION (sb)))) { - ident =le16_to_cpu (((tag *)bh->b_data)->tagIdent); - location =le32_to_cpu (((tag *)bh->b_data)->tagLocation); +/* We haven't found the lastblock. check 312 */ + bh =sb_bread (sb,312 +UDF_SB_SESSION (sb)); +if (bh) { +tag *t = (tag *)bh->b_data; + ident =le16_to_cpu (t->tagIdent); + location =le32_to_cpu (t->tagLocation);brelse (bh);if (ident ==TAG_IDENT_AVDP && location ==256 )
@@ -729,15 +746,15 @@ static void udf_find_anchor(struct super_block *sb)for (i =0 ; i <ARRAY_SIZE (UDF_SB_ANCHOR (sb)); i++) {if (UDF_SB_ANCHOR (sb)[i]) { -if (!(bh =udf_read_tagged (sb,UDF_SB_ANCHOR (sb)[i], -UDF_SB_ANCHOR (sb)[i], &ident))) { + bh =udf_read_tagged (sb,UDF_SB_ANCHOR (sb)[i], +UDF_SB_ANCHOR (sb)[i], &ident); +if (!bh)UDF_SB_ANCHOR (sb)[i] =0 ; - }else { +else {brelse (bh);if ((ident !=TAG_IDENT_AVDP ) && - (i || (ident !=TAG_IDENT_FE && ident !=TAG_IDENT_EFE ))) { + (i || (ident !=TAG_IDENT_FE && ident !=TAG_IDENT_EFE )))UDF_SB_ANCHOR (sb)[i] =0 ; - } } } }
@@ -745,7 +762,9 @@ static void udf_find_anchor(struct super_block *sb)UDF_SB_LASTBLOCK (sb) = lastblock; } -static int udf_find_fileset (struct super_block *sb,kernel_lb_addr *fileset,kernel_lb_addr *root) +static int udf_find_fileset (struct super_block *sb, +kernel_lb_addr *fileset, +kernel_lb_addr *root) {struct buffer_head *bh =NULL ;long lastblock;
@@ -764,7 +783,8 @@ static int udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, ker } -if (!bh) {/* Search backwards through the partitions */ +if (!bh) { +/* Search backwards through the partitions */ kernel_lb_addr newfileset;/* --> cvg: FIXME - is it reasonable? */
@@ -775,11 +795,13 @@ static int udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, ker fileset->logicalBlockNum ==0xFFFFFFFF && fileset->partitionReferenceNum == 0xFFFF); newfileset.partitionReferenceNum--) { - lastblock =UDF_SB_PARTLEN (sb, newfileset.partitionReferenceNum); + lastblock =UDF_SB_PARTLEN (sb, + newfileset.partitionReferenceNum); newfileset.logicalBlockNum =0 ; do { - bh = udf_read_ptagged(sb, newfileset, 0, &ident); + bh = udf_read_ptagged(sb, newfileset, 0, + &ident); if (!bh) { newfileset.logicalBlockNum++; continue;
@@ -840,7 +862,8 @@ static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh) lets_to_cpu(pvoldesc->recordingDateAndTime))) {kernel_timestamp ts; ts =lets_to_cpu (pvoldesc->recordingDateAndTime); -udf_debug ("recording time %ld/%ld, %04u/%02u/%02u %02u:%02u (%x)\n" , +udf_debug ("recording time %ld/%ld, %04u/%02u/%02u" +" %02u:%02u (%x)\n" , recording, recording_usec, ts.year, ts.month, ts.day, ts.hour, ts.minute, ts.typeAndTimezone);
@@ -888,19 +911,21 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)udf_debug ("Searching map: (%d == %d)\n" ,UDF_SB_PARTMAPS (sb)[i].s_partition_num,le16_to_cpu (p->partitionNumber));if (UDF_SB_PARTMAPS (sb)[i].s_partition_num ==le16_to_cpu (p->partitionNumber)) { -UDF_SB_PARTLEN (sb,i) =le32_to_cpu (p->partitionLength);/* blocks */ -UDF_SB_PARTROOT (sb,i) =le32_to_cpu (p->partitionStartingLocation); +UDF_SB_PARTLEN (sb, i) =le32_to_cpu (p->partitionLength);/* blocks */ +UDF_SB_PARTROOT (sb, i) =le32_to_cpu (p->partitionStartingLocation);if (le32_to_cpu (p->accessType) ==PD_ACCESS_TYPE_READ_ONLY ) -UDF_SB_PARTFLAGS (sb,i) |=UDF_PART_FLAG_READ_ONLY ; +UDF_SB_PARTFLAGS (sb, i) |=UDF_PART_FLAG_READ_ONLY ;if (le32_to_cpu (p->accessType) ==PD_ACCESS_TYPE_WRITE_ONCE ) -UDF_SB_PARTFLAGS (sb,i) |=UDF_PART_FLAG_WRITE_ONCE ; +UDF_SB_PARTFLAGS (sb, i) |=UDF_PART_FLAG_WRITE_ONCE ;if (le32_to_cpu (p->accessType) ==PD_ACCESS_TYPE_REWRITABLE ) -UDF_SB_PARTFLAGS (sb,i) |=UDF_PART_FLAG_REWRITABLE ; +UDF_SB_PARTFLAGS (sb, i) |=UDF_PART_FLAG_REWRITABLE ;if (le32_to_cpu (p->accessType) ==PD_ACCESS_TYPE_OVERWRITABLE ) -UDF_SB_PARTFLAGS (sb,i) |=UDF_PART_FLAG_OVERWRITABLE ; +UDF_SB_PARTFLAGS (sb, i) |=UDF_PART_FLAG_OVERWRITABLE ; -if (!strcmp (p->partitionContents.ident,PD_PARTITION_CONTENTS_NSR02 ) || - !strcmp (p->partitionContents.ident,PD_PARTITION_CONTENTS_NSR03 )) { +if (!strcmp (p->partitionContents.ident, +PD_PARTITION_CONTENTS_NSR02 ) || + !strcmp (p->partitionContents.ident, +PD_PARTITION_CONTENTS_NSR03 )) {struct partitionHeaderDesc *phd; phd = (struct partitionHeaderDesc *)(p->partitionContentsUse);
@@ -916,7 +941,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)udf_debug ("cannot load unallocSpaceTable (part %d)\n" , i);return 1 ; } -UDF_SB_PARTFLAGS (sb,i) |=UDF_PART_FLAG_UNALLOC_TABLE ; +UDF_SB_PARTFLAGS (sb, i) |=UDF_PART_FLAG_UNALLOC_TABLE ;udf_debug ("unallocSpaceTable (part %d) @ %ld\n" , i,UDF_SB_PARTMAPS (sb)[i].s_uspace.s_table->i_ino); }
@@ -927,7 +952,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)le32_to_cpu (phd->unallocSpaceBitmap.extLength);UDF_SB_PARTMAPS (sb)[i].s_uspace.s_bitmap->s_extPosition =le32_to_cpu (phd->unallocSpaceBitmap.extPosition); -UDF_SB_PARTFLAGS (sb,i) |=UDF_PART_FLAG_UNALLOC_BITMAP ; +UDF_SB_PARTFLAGS (sb, i) |=UDF_PART_FLAG_UNALLOC_BITMAP ;udf_debug ("unallocSpaceBitmap (part %d) @ %d\n" , i,UDF_SB_PARTMAPS (sb)[i].s_uspace.s_bitmap->s_extPosition); }
@@ -946,7 +971,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)udf_debug ("cannot load freedSpaceTable (part %d)\n" , i);return 1 ; } -UDF_SB_PARTFLAGS (sb,i) |=UDF_PART_FLAG_FREED_TABLE ; +UDF_SB_PARTFLAGS (sb, i) |=UDF_PART_FLAG_FREED_TABLE ;udf_debug ("freedSpaceTable (part %d) @ %ld\n" , i,UDF_SB_PARTMAPS (sb)[i].s_fspace.s_table->i_ino); }
@@ -957,7 +982,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)le32_to_cpu (phd->freedSpaceBitmap.extLength);UDF_SB_PARTMAPS (sb)[i].s_fspace.s_bitmap->s_extPosition =le32_to_cpu (phd->freedSpaceBitmap.extPosition); -UDF_SB_PARTFLAGS (sb,i) |=UDF_PART_FLAG_FREED_BITMAP ; +UDF_SB_PARTFLAGS (sb, i) |=UDF_PART_FLAG_FREED_BITMAP ;udf_debug ("freedSpaceBitmap (part %d) @ %d\n" , i,UDF_SB_PARTMAPS (sb)[i].s_fspace.s_bitmap->s_extPosition); }
@@ -970,9 +995,11 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)udf_debug ("Partition (%d) not found in partition map\n" ,le16_to_cpu (p->partitionNumber)); }else { -udf_debug ("Partition (%d:%d type %x) starts at physical %d, block length %d\n" , -le16_to_cpu (p->partitionNumber), i,UDF_SB_PARTTYPE (sb,i), -UDF_SB_PARTROOT (sb,i),UDF_SB_PARTLEN (sb,i)); +udf_debug ("Partition (%d:%d type %x) starts at physical %d, " +"block length %d\n" , +le16_to_cpu (p->partitionNumber), i, +UDF_SB_PARTTYPE (sb, i),UDF_SB_PARTROOT (sb, i), +UDF_SB_PARTLEN (sb, i)); }return 0 ; }
@@ -994,19 +1021,19 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh, type = ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapType;if (type ==1 ) {struct genericPartitionMap1 *gpm1 = (struct genericPartitionMap1 *)&(lvd->partitionMaps[offset]); -UDF_SB_PARTTYPE (sb,i) =UDF_TYPE1_MAP15 ; -UDF_SB_PARTVSN (sb,i) =le16_to_cpu (gpm1->volSeqNum); -UDF_SB_PARTNUM (sb,i) =le16_to_cpu (gpm1->partitionNum); -UDF_SB_PARTFUNC (sb,i) =NULL ; +UDF_SB_PARTTYPE (sb, i) =UDF_TYPE1_MAP15 ; +UDF_SB_PARTVSN (sb, i) =le16_to_cpu (gpm1->volSeqNum); +UDF_SB_PARTNUM (sb, i) =le16_to_cpu (gpm1->partitionNum); +UDF_SB_PARTFUNC (sb, i) =NULL ; }else if (type ==2 ) {struct udfPartitionMap2 *upm2 = (struct udfPartitionMap2 *)&(lvd->partitionMaps[offset]);if (!strncmp (upm2->partIdent.ident,UDF_ID_VIRTUAL ,strlen (UDF_ID_VIRTUAL ))) {if (le16_to_cpu (((__le16 *)upm2->partIdent.identSuffix)[0 ]) ==0x0150 ) { -UDF_SB_PARTTYPE (sb,i) =UDF_VIRTUAL_MAP15 ; -UDF_SB_PARTFUNC (sb,i) = udf_get_pblock_virt15; +UDF_SB_PARTTYPE (sb, i) =UDF_VIRTUAL_MAP15 ; +UDF_SB_PARTFUNC (sb, i) = udf_get_pblock_virt15; }else if (le16_to_cpu (((__le16 *)upm2->partIdent.identSuffix)[0 ]) ==0x0200 ) { -UDF_SB_PARTTYPE (sb,i) =UDF_VIRTUAL_MAP20 ; -UDF_SB_PARTFUNC (sb,i) = udf_get_pblock_virt20; +UDF_SB_PARTTYPE (sb, i) =UDF_VIRTUAL_MAP20 ; +UDF_SB_PARTFUNC (sb, i) = udf_get_pblock_virt20; } }else if (!strncmp (upm2->partIdent.ident,UDF_ID_SPARABLE ,strlen (UDF_ID_SPARABLE ))) {uint32_t loc;
@@ -1014,39 +1041,41 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,struct sparingTable *st;struct sparablePartitionMap *spm = (struct sparablePartitionMap *)&(lvd->partitionMaps[offset]); -UDF_SB_PARTTYPE (sb,i) =UDF_SPARABLE_MAP15 ; -UDF_SB_TYPESPAR (sb,i).s_packet_len =le16_to_cpu (spm->packetLength); +UDF_SB_PARTTYPE (sb, i) =UDF_SPARABLE_MAP15 ; +UDF_SB_TYPESPAR (sb, i).s_packet_len =le16_to_cpu (spm->packetLength);for (j =0 ; j < spm->numSparingTables; j++) { loc =le32_to_cpu (spm->locSparingTable[j]); -UDF_SB_TYPESPAR (sb,i).s_spar_map[j] = +UDF_SB_TYPESPAR (sb, i).s_spar_map[j] =udf_read_tagged (sb, loc, loc, &ident); -if (UDF_SB_TYPESPAR (sb,i).s_spar_map[j] !=NULL ) { - st = (struct sparingTable *)UDF_SB_TYPESPAR (sb,i).s_spar_map[j]->b_data; +if (UDF_SB_TYPESPAR (sb, i).s_spar_map[j] !=NULL ) { + st = (struct sparingTable *)UDF_SB_TYPESPAR (sb, i).s_spar_map[j]->b_data;if (ident !=0 ||strncmp (st->sparingIdent.ident,UDF_ID_SPARING ,strlen (UDF_ID_SPARING ))) { -brelse (UDF_SB_TYPESPAR (sb,i).s_spar_map[j]); -UDF_SB_TYPESPAR (sb,i).s_spar_map[j] =NULL ; +brelse (UDF_SB_TYPESPAR (sb, i).s_spar_map[j]); +UDF_SB_TYPESPAR (sb, i).s_spar_map[j] =NULL ; } } } -UDF_SB_PARTFUNC (sb,i) = udf_get_pblock_spar15; +UDF_SB_PARTFUNC (sb, i) = udf_get_pblock_spar15; }else { -udf_debug ("Unknown ident: %s\n" , upm2->partIdent.ident); +udf_debug ("Unknown ident: %s\n" , + upm2->partIdent.ident);continue ; } -UDF_SB_PARTVSN (sb,i) =le16_to_cpu (upm2->volSeqNum); -UDF_SB_PARTNUM (sb,i) =le16_to_cpu (upm2->partitionNum); +UDF_SB_PARTVSN (sb, i) =le16_to_cpu (upm2->volSeqNum); +UDF_SB_PARTNUM (sb, i) =le16_to_cpu (upm2->partitionNum); }udf_debug ("Partition (%d:%d) type %d on volume %d\n" , - i,UDF_SB_PARTNUM (sb,i), type,UDF_SB_PARTVSN (sb,i)); + i,UDF_SB_PARTNUM (sb, i), type, +UDF_SB_PARTVSN (sb, i)); }if (fileset) {long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0 ]); *fileset =lelb_to_cpu (la->extLocation); -udf_debug ("FileSet found in LogicalVolDesc at block=%d, partition=%d\n" , - fileset->logicalBlockNum, +udf_debug ("FileSet found in LogicalVolDesc at block=%d, " +"partition=%d\n" , fileset->logicalBlockNum, fileset->partitionReferenceNum); }if (lvd->integritySeqExt.extLength)
@@ -1071,7 +1100,8 @@ static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)UDF_SB_LVIDBH (sb) = bh;if (UDF_SB_LVID (sb)->nextIntegrityExt.extLength) -udf_load_logicalvolint (sb,leea_to_cpu (UDF_SB_LVID (sb)->nextIntegrityExt)); +udf_load_logicalvolint (sb, +leea_to_cpu (UDF_SB_LVID (sb)->nextIntegrityExt));if (UDF_SB_LVIDBH (sb) != bh)brelse (bh);
@@ -1097,8 +1127,8 @@ static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)* July 1, 1997 - Andrew E. Mileski * Written, tested, and released. */ -static int udf_process_sequence (struct super_block *sb,long block,long lastblock, -kernel_lb_addr *fileset) +static int udf_process_sequence (struct super_block *sb,long block, +long lastblock,kernel_lb_addr *fileset) {struct buffer_head *bh =NULL ;struct udf_vds_record vds[VDS_POS_LENGTH ];
@@ -1178,7 +1208,8 @@ static int udf_process_sequence(struct super_block *sb, long block, long lastblo }for (i =0 ; i <VDS_POS_LENGTH ; i++) {if (vds[i].block) { - bh =udf_read_tagged (sb, vds[i].block, vds[i].block, &ident); + bh =udf_read_tagged (sb, vds[i].block, vds[i].block, + &ident);if (i ==VDS_POS_PRIMARY_VOL_DESC ) {udf_load_pvoldesc (sb, bh);
@@ -1190,11 +1221,14 @@ static int udf_process_sequence(struct super_block *sb, long block, long lastblobrelse (bh);return 1 ; } -for (j = vds[i].block +1 ; j < vds[VDS_POS_TERMINATING_DESC ].block; j++) { +for (j = vds[i].block +1 ; + j < vds[VDS_POS_TERMINATING_DESC ].block; + j++) { bh2 =udf_read_tagged (sb, j, j, &ident); gd = (struct generic_desc *)bh2->b_data;if (ident ==TAG_IDENT_PD ) -if (udf_load_partdesc (sb, bh2)) { +if (udf_load_partdesc (sb, + bh2)) {brelse (bh);brelse (bh2);return 1 ;
@@ -1222,14 +1256,16 @@ static int udf_check_valid(struct super_block *sb, int novrs, int silent) }/* Check that it is NSR02 compliant */ /* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */ -else if ((block =udf_vrs (sb, silent)) ==-1 ) { -udf_debug ("Failed to read byte 32768. Assuming open disc. " -"Skipping validity check\n" ); -if (!UDF_SB_LASTBLOCK (sb)) -UDF_SB_LASTBLOCK (sb) =udf_get_last_block (sb); -return 0 ; - }else { -return !block; +else { + block =udf_vrs (sb, silent); +if (block ==-1 ) { +udf_debug ("Failed to read byte 32768. Assuming open " +"disc. Skipping validity check\n" ); +if (!UDF_SB_LASTBLOCK (sb)) +UDF_SB_LASTBLOCK (sb) =udf_get_last_block (sb); +return 0 ; + }else +return !block; } }
@@ -1252,7 +1288,7 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)/* Locate the main sequence */ main_s =le32_to_cpu (anchor->mainVolDescSeqExt.extLocation); - main_e =le32_to_cpu (anchor->mainVolDescSeqExt.extLength ); + main_e =le32_to_cpu (anchor->mainVolDescSeqExt.extLength); main_e = main_e >> sb->s_blocksize_bits; main_e += main_s;
@@ -1267,9 +1303,8 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)/* Process the main & reserve sequences */ /* responsible for finding the PartitionDesc(s) */ if (!(udf_process_sequence (sb, main_s, main_e, fileset) && -udf_process_sequence (sb, reserve_s, reserve_e, fileset))) { +udf_process_sequence (sb, reserve_s, reserve_e, fileset)))break ; - } } }
@@ -1308,7 +1343,8 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)if (j ==UDF_SB_NUMPARTS (sb))return 1 ; -if (!(UDF_SB_VAT (sb) =udf_iget (sb, ino))) +UDF_SB_VAT (sb) =udf_iget (sb, ino); +if (!UDF_SB_VAT (sb))return 1 ;if (UDF_SB_PARTTYPE (sb, i) ==UDF_VIRTUAL_MAP15 ) {
@@ -1481,8 +1517,9 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)UDF_SB_ANCHOR (sb)[2 ] = uopt.anchor;UDF_SB_ANCHOR (sb)[3 ] =256 ; -if (udf_check_valid (sb, uopt.novrs, silent)) {/* read volume recognition sequences */ -printk ("UDF-fs: No VRS found\n" ); +if (udf_check_valid (sb, uopt.novrs, silent)) { +/* read volume recognition sequences */ +printk (KERN_WARNING "UDF-fs: No VRS found\n" ); goto error_out; }
@@ -1496,7 +1533,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) sb->s_time_gran =1000 ;if (udf_load_partition (sb, &fileset)) { -printk ("UDF-fs: No partition found (1)\n" ); +printk (KERN_WARNING "UDF-fs: No partition found (1)\n" ); goto error_out; }
@@ -1508,7 +1545,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)/* uint16_t maxUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev); */ if (minUDFReadRev >UDF_MAX_READ_VERSION ) { -printk ("UDF-fs: minUDFReadRev=%x (max is %x)\n" , +printk (KERN_ERR "UDF-fs: minUDFReadRev=%x (max is %x)\n" ,le16_to_cpu (UDF_SB_LVIDIU (sb)->minUDFReadRev),UDF_MAX_READ_VERSION ); goto error_out;
@@ -1525,17 +1562,17 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent) }if (!UDF_SB_NUMPARTS (sb)) { -printk ("UDF-fs: No partition found (2)\n" ); +printk (KERN_WARNING "UDF-fs: No partition found (2)\n" ); goto error_out; }if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_READ_ONLY ) { -printk ("UDF-fs: Partition marked readonly; forcing readonly mount\n" ); +printk (KERN_NOTICE "UDF-fs: Partition marked readonly; forcing readonly mount\n" ); sb->s_flags |=MS_RDONLY ; }if (udf_find_fileset (sb, &fileset, &rootdir)) { -printk ("UDF-fs: No fileset found\n" ); +printk (KERN_WARNING "UDF-fs: No fileset found\n" ); goto error_out; }
@@ -1556,7 +1593,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)/* perhaps it's not extensible enough, but for now ... */ inode =udf_iget (sb, rootdir);if (!inode) { -printk ("UDF-fs: Error in udf_iget, block=%d, partition=%d\n" , +printk (KERN_ERR "UDF-fs: Error in udf_iget, block=%d, partition=%d\n" , rootdir.logicalBlockNum, rootdir.partitionReferenceNum); goto error_out; }
@@ -1564,7 +1601,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)/* Allocate a dentry for the root inode */ sb->s_root =d_alloc_root (inode);if (!sb->s_root) { -printk ("UDF-fs: Couldn't allocate root dentry\n" ); +printk (KERN_ERR "UDF-fs: Couldn't allocate root dentry\n" );iput (inode); goto error_out; }
@@ -1580,9 +1617,9 @@ error_out:if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_FREED_TABLE )iput (UDF_SB_PARTMAPS (sb)[UDF_SB_PARTITION (sb)].s_fspace.s_table);if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_UNALLOC_BITMAP ) -UDF_SB_FREE_BITMAP (sb,UDF_SB_PARTITION (sb), s_uspace); +UDF_SB_FREE_BITMAP (sb,UDF_SB_PARTITION (sb), s_uspace);if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_FREED_BITMAP ) -UDF_SB_FREE_BITMAP (sb,UDF_SB_PARTITION (sb), s_fspace); +UDF_SB_FREE_BITMAP (sb,UDF_SB_PARTITION (sb), s_fspace);if (UDF_SB_PARTTYPE (sb,UDF_SB_PARTITION (sb)) ==UDF_SPARABLE_MAP15 ) {for (i =0 ; i <4 ; i++)brelse (UDF_SB_TYPESPAR (sb,UDF_SB_PARTITION (sb)).s_spar_map[i]);
@@ -1614,7 +1651,7 @@ void udf_error(struct super_block *sb, const char *function,va_start (args, fmt);vsnprintf (error_buf,sizeof (error_buf), fmt, args);va_end (args); -printk (KERN_CRIT "UDF-fs error (device %s): %s: %s\n" , +printk (KERN_CRIT "UDF-fs error (device %s): %s: %s\n" , sb->s_id, function, error_buf); }
@@ -1655,9 +1692,9 @@ static void udf_put_super(struct super_block *sb)if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_FREED_TABLE )iput (UDF_SB_PARTMAPS (sb)[UDF_SB_PARTITION (sb)].s_fspace.s_table);if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_UNALLOC_BITMAP ) -UDF_SB_FREE_BITMAP (sb,UDF_SB_PARTITION (sb), s_uspace); +UDF_SB_FREE_BITMAP (sb,UDF_SB_PARTITION (sb), s_uspace);if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_FREED_BITMAP ) -UDF_SB_FREE_BITMAP (sb,UDF_SB_PARTITION (sb), s_fspace); +UDF_SB_FREE_BITMAP (sb,UDF_SB_PARTITION (sb), s_fspace);if (UDF_SB_PARTTYPE (sb,UDF_SB_PARTITION (sb)) ==UDF_SPARABLE_MAP15 ) {for (i =0 ; i <4 ; i++)brelse (UDF_SB_TYPESPAR (sb,UDF_SB_PARTITION (sb)).s_spar_map[i]);
@@ -1786,9 +1823,9 @@ static unsigned int udf_count_free_table(struct super_block *sb, struct inode *t epos.offset =sizeof (struct unallocSpaceEntry ); epos.bh =NULL ; -while ((etype =udf_next_aext (table, &epos, &eloc, &elen,1 )) !=-1 ) { +while ((etype =udf_next_aext (table, &epos, &eloc, &elen,1 )) !=-1 ) accum += (elen >> table->i_sb->s_blocksize_bits); - } +brelse (epos.bh);unlock_kernel ();
@@ -1811,22 +1848,22 @@ static unsigned int udf_count_free(struct super_block *sb)if (accum)return accum; -if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_UNALLOC_BITMAP ) { +if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_UNALLOC_BITMAP ) { accum +=udf_count_free_bitmap (sb,UDF_SB_PARTMAPS (sb)[UDF_SB_PARTITION (sb)].s_uspace.s_bitmap); } -if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_FREED_BITMAP ) { +if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_FREED_BITMAP ) { accum +=udf_count_free_bitmap (sb,UDF_SB_PARTMAPS (sb)[UDF_SB_PARTITION (sb)].s_fspace.s_bitmap); }if (accum)return accum; -if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_UNALLOC_TABLE ) { +if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_UNALLOC_TABLE ) { accum +=udf_count_free_table (sb,UDF_SB_PARTMAPS (sb)[UDF_SB_PARTITION (sb)].s_uspace.s_table); } -if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_FREED_TABLE ) { +if (UDF_SB_PARTFLAGS (sb,UDF_SB_PARTITION (sb)) &UDF_PART_FLAG_FREED_TABLE ) { accum +=udf_count_free_table (sb,UDF_SB_PARTMAPS (sb)[UDF_SB_PARTITION (sb)].s_fspace.s_table); }
Signature · 1 line
1.5.3.4
PATCH 2/6 udf: remove some ugly macros
In reply to [email protected]remove macros:
- UDF_SB_PARTMAPS
- UDF_SB_PARTTYPE
- UDF_SB_PARTROOT
- UDF_SB_PARTLEN
- UDF_SB_PARTVSN
- UDF_SB_PARTNUM
- UDF_SB_TYPESPAR
- UDF_SB_TYPEVIRT
- UDF_SB_PARTFUNC
- UDF_SB_PARTFLAGS
- UDF_SB_VOLIDENT
- UDF_SB_NUMPARTS
- UDF_SB_PARTITION
- UDF_SB_SESSION
- UDF_SB_ANCHOR
- UDF_SB_LASTBLOCK
- UDF_SB_LVIDBH
- UDF_SB_LVID
- UDF_SB_UMASK
- UDF_SB_GID
- UDF_SB_UID
- UDF_SB_RECORDTIME
- UDF_SB_SERIALNUM
- UDF_SB_UDFREV
- UDF_SB_FLAGS
- UDF_SB_VAT
- UDF_UPDATE_UDFREV
- UDF_SB_FREE
and open code them
convert UDF_SB_LVIDIU macro to udf_sb_lvidiu function
rename some struct udf_sb_info fields:
- s_volident to s_volume_ident
- s_lastblock to s_last_block
- s_lvidbh to s_lvid_bh
- s_recordtime to s_record_time
- s_serialnum to s_serial_number;
- s_vat to s_vat_inode;
--- fs/udf/balloc.c | 136 ++++++----- fs/udf/file.c | 2 +- fs/udf/ialloc.c | 33 ++-- fs/udf/inode.c | 34 ++-- fs/udf/misc.c | 15 +- fs/udf/namei.c | 24 ++- fs/udf/partition.c | 67 ++++--- fs/udf/super.c | 548 +++++++++++++++++++++++++-------------------- fs/udf/truncate.c | 7 +- fs/udf/udf_sb.h | 75 ++----- include/linux/udf_fs_sb.h | 12 +- 11 files changed, 510 insertions(+), 443 deletions(-)
fs/udf/balloc.c +74 -62
@@ -88,7 +88,7 @@ static int read_block_bitmap(struct super_block *sb,kernel_lb_addr loc; loc.logicalBlockNum = bitmap->s_extPosition; - loc.partitionReferenceNum =UDF_SB_PARTITION (sb); + loc.partitionReferenceNum =UDF_SB (sb)->s_partition; bh =udf_tread (sb,udf_get_lb_pblock (sb, loc, block));if (!bh) {
@@ -155,10 +155,10 @@ static void udf_bitmap_free_blocks(struct super_block *sb,mutex_lock (&sbi->s_alloc_mutex);if (bloc.logicalBlockNum <0 || - (bloc.logicalBlockNum + count) >UDF_SB_PARTLEN (sb, bloc.partitionReferenceNum)) { + (bloc.logicalBlockNum + count) > sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len) {udf_debug ("%d < %d || %d + %d > %d\n" , bloc.logicalBlockNum,0 , bloc.logicalBlockNum, count, -UDF_SB_PARTLEN (sb, bloc.partitionReferenceNum)); + sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len); goto error_return; }
@@ -188,9 +188,10 @@ do_more: }else {if (inode)DQUOT_FREE_BLOCK (inode,1 ); -if (UDF_SB_LVIDBH (sb)) { -UDF_SB_LVID (sb)->freeSpaceTable[UDF_SB_PARTITION (sb)] = -cpu_to_le32 (le32_to_cpu (UDF_SB_LVID (sb)->freeSpaceTable[UDF_SB_PARTITION (sb)]) +1 ); +if (sbi->s_lvid_bh) { +struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data; + lvid->freeSpaceTable[sbi->s_partition] = +cpu_to_le32 (le32_to_cpu (lvid->freeSpaceTable[sbi->s_partition]) +1 ); } } }
@@ -202,8 +203,8 @@ do_more: } error_return: sb->s_dirt =1 ; -if (UDF_SB_LVIDBH (sb)) -mark_buffer_dirty (UDF_SB_LVIDBH (sb)); +if (sbi->s_lvid_bh) +mark_buffer_dirty (sbi->s_lvid_bh);mutex_unlock (&sbi->s_alloc_mutex);return ; }
@@ -219,16 +220,18 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,int bit, block, block_group, group_start;int nr_groups, bitmap_nr;struct buffer_head *bh; +__u32 part_len;mutex_lock (&sbi->s_alloc_mutex); -if (first_block <0 || first_block >=UDF_SB_PARTLEN (sb, partition)) + part_len = sbi->s_partmaps[partition].s_partition_len; +if (first_block <0 || first_block >= part_len) goto out; -if (first_block + block_count >UDF_SB_PARTLEN (sb, partition)) - block_count =UDF_SB_PARTLEN (sb, partition) - first_block; +if (first_block + block_count > part_len) + block_count = part_len - first_block; repeat: - nr_groups = (UDF_SB_PARTLEN (sb, partition) + + nr_groups = (sbi->s_partmaps[partition].s_partition_len + (sizeof (struct spaceBitmapDesc ) <<3 ) + (sb->s_blocksize *8 ) -1 ) / (sb->s_blocksize *8 ); block = first_block + (sizeof (struct spaceBitmapDesc ) <<3 );
@@ -261,10 +264,11 @@ repeat:if (block_count >0 ) goto repeat; out: -if (UDF_SB_LVIDBH (sb)) { -UDF_SB_LVID (sb)->freeSpaceTable[partition] = -cpu_to_le32 (le32_to_cpu (UDF_SB_LVID (sb)->freeSpaceTable[partition]) - alloc_count); -mark_buffer_dirty (UDF_SB_LVIDBH (sb)); +if (sbi->s_lvid_bh) { +struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data; + lvid->freeSpaceTable[partition] = +cpu_to_le32 (le32_to_cpu (lvid->freeSpaceTable[partition]) - alloc_count); +mark_buffer_dirty (sbi->s_lvid_bh); } sb->s_dirt =1 ;mutex_unlock (&sbi->s_alloc_mutex);
@@ -287,7 +291,7 @@ static int udf_bitmap_new_block(struct super_block *sb,mutex_lock (&sbi->s_alloc_mutex); repeat: -if (goal <0 || goal >=UDF_SB_PARTLEN (sb, partition)) +if (goal <0 || goal >= sbi->s_partmaps[partition].s_partition_len) goal =0 ; nr_groups = bitmap->s_nr_groups;
@@ -389,10 +393,11 @@ got_block:mark_buffer_dirty (bh); -if (UDF_SB_LVIDBH (sb)) { -UDF_SB_LVID (sb)->freeSpaceTable[partition] = -cpu_to_le32 (le32_to_cpu (UDF_SB_LVID (sb)->freeSpaceTable[partition]) -1 ); -mark_buffer_dirty (UDF_SB_LVIDBH (sb)); +if (sbi->s_lvid_bh) { +struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data; + lvid->freeSpaceTable[partition] = +cpu_to_le32 (le32_to_cpu (lvid->freeSpaceTable[partition]) -1 ); +mark_buffer_dirty (sbi->s_lvid_bh); } sb->s_dirt =1 ;mutex_unlock (&sbi->s_alloc_mutex);
@@ -421,10 +426,10 @@ static void udf_table_free_blocks(struct super_block *sb,mutex_lock (&sbi->s_alloc_mutex);if (bloc.logicalBlockNum <0 || - (bloc.logicalBlockNum + count) >UDF_SB_PARTLEN (sb, bloc.partitionReferenceNum)) { + (bloc.logicalBlockNum + count) > sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len) {udf_debug ("%d < %d || %d + %d > %d\n" , bloc.logicalBlockNum,0 , bloc.logicalBlockNum, count, -UDF_SB_PARTLEN (sb, bloc.partitionReferenceNum)); + sbi->s_partmaps[bloc.partitionReferenceNum]->s_partition_len); goto error_return; }
@@ -432,10 +437,11 @@ static void udf_table_free_blocks(struct super_block *sb,but.. oh well */ if (inode)DQUOT_FREE_BLOCK (inode, count); -if (UDF_SB_LVIDBH (sb)) { -UDF_SB_LVID (sb)->freeSpaceTable[UDF_SB_PARTITION (sb)] = -cpu_to_le32 (le32_to_cpu (UDF_SB_LVID (sb)->freeSpaceTable[UDF_SB_PARTITION (sb)]) + count); -mark_buffer_dirty (UDF_SB_LVIDBH (sb)); +if (sbi->s_lvid_bh) { +struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data; + lvid->freeSpaceTable[sbi->s_partition] = +cpu_to_le32 (le32_to_cpu (lvid->freeSpaceTable[sbi->s_partition]) + count); +mark_buffer_dirty (sbi->s_lvid_bh); } start = bloc.logicalBlockNum + offset;
@@ -559,7 +565,7 @@ static void udf_table_free_blocks(struct super_block *sb, } epos.offset =sizeof (struct allocExtDesc ); } -if (UDF_SB_UDFREV (sb) >=0x0200 ) +if (sbi->s_udfrev >=0x0200 )udf_new_tag (epos.bh->b_data,TAG_IDENT_AED ,3 ,1 , epos.block.logicalBlockNum,sizeof (tag));else
@@ -627,7 +633,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,struct extent_position epos;int8_t etype =-1 ; -if (first_block <0 || first_block >=UDF_SB_PARTLEN (sb, partition)) +if (first_block <0 || first_block >= sbi->s_partmaps[partition].s_partition_len)return 0 ;if (UDF_I_ALLOCTYPE (table) ==ICBTAG_FLAG_AD_SHORT )
@@ -670,10 +676,11 @@ static int udf_table_prealloc_blocks(struct super_block *sb,brelse (epos.bh); -if (alloc_count &&UDF_SB_LVIDBH (sb)) { -UDF_SB_LVID (sb)->freeSpaceTable[partition] = -cpu_to_le32 (le32_to_cpu (UDF_SB_LVID (sb)->freeSpaceTable[partition]) - alloc_count); -mark_buffer_dirty (UDF_SB_LVIDBH (sb)); +if (alloc_count && sbi->s_lvid_bh) { +struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data; + lvid->freeSpaceTable[partition] = +cpu_to_le32 (le32_to_cpu (lvid->freeSpaceTable[partition]) - alloc_count); +mark_buffer_dirty (sbi->s_lvid_bh); sb->s_dirt =1 ; }mutex_unlock (&sbi->s_alloc_mutex);
@@ -703,7 +710,7 @@ static int udf_table_new_block(struct super_block *sb,return newblock;mutex_lock (&sbi->s_alloc_mutex); -if (goal <0 || goal >=UDF_SB_PARTLEN (sb, partition)) +if (goal <0 || goal >= sbi->s_partmaps[partition].s_partition_len) goal =0 ;/* We search for the closest matching block to goal. If we find a exact hit,
@@ -771,10 +778,11 @@ static int udf_table_new_block(struct super_block *sb,udf_delete_aext (table, goal_epos, goal_eloc, goal_elen);brelse (goal_epos.bh); -if (UDF_SB_LVIDBH (sb)) { -UDF_SB_LVID (sb)->freeSpaceTable[partition] = -cpu_to_le32 (le32_to_cpu (UDF_SB_LVID (sb)->freeSpaceTable[partition]) -1 ); -mark_buffer_dirty (UDF_SB_LVIDBH (sb)); +if (sbi->s_lvid_bh) { +struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data; + lvid->freeSpaceTable[partition] = +cpu_to_le32 (le32_to_cpu (lvid->freeSpaceTable[partition]) -1 ); +mark_buffer_dirty (sbi->s_lvid_bh); } sb->s_dirt =1 ;
@@ -789,22 +797,23 @@ inline void udf_free_blocks(struct super_block *sb, uint32_t count) {uint16_t partition = bloc.partitionReferenceNum; +struct udf_part_map *map = &UDF_SB (sb)->s_partmaps[partition]; -if (UDF_SB_PARTFLAGS (sb, partition) &UDF_PART_FLAG_UNALLOC_BITMAP ) { +if (map->s_partition_flags &UDF_PART_FLAG_UNALLOC_BITMAP ) {return udf_bitmap_free_blocks (sb, inode, -UDF_SB_PARTMAPS (sb)[partition].s_uspace.s_bitmap, + map->s_uspace.s_bitmap, bloc, offset, count); - }else if (UDF_SB_PARTFLAGS (sb, partition) &UDF_PART_FLAG_UNALLOC_TABLE ) { + }else if (map->s_partition_flags &UDF_PART_FLAG_UNALLOC_TABLE ) {return udf_table_free_blocks (sb, inode, -UDF_SB_PARTMAPS (sb)[partition].s_uspace.s_table, + map->s_uspace.s_table, bloc, offset, count); - }else if (UDF_SB_PARTFLAGS (sb, partition) &UDF_PART_FLAG_FREED_BITMAP ) { + }else if (map->s_partition_flags &UDF_PART_FLAG_FREED_BITMAP ) {return udf_bitmap_free_blocks (sb, inode, -UDF_SB_PARTMAPS (sb)[partition].s_fspace.s_bitmap, + map->s_fspace.s_bitmap, bloc, offset, count); - }else if (UDF_SB_PARTFLAGS (sb, partition) &UDF_PART_FLAG_FREED_TABLE ) { + }else if (map->s_partition_flags &UDF_PART_FLAG_FREED_TABLE ) {return udf_table_free_blocks (sb, inode, -UDF_SB_PARTMAPS (sb)[partition].s_fspace.s_table, + map->s_fspace.s_table, bloc, offset, count); }else {return ;
@@ -816,21 +825,23 @@ inline int udf_prealloc_blocks(struct super_block *sb, uint16_t partition, uint32_t first_block, uint32_t block_count) { - if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) { + struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition]; + +if (map->s_partition_flags &UDF_PART_FLAG_UNALLOC_BITMAP ) {return udf_bitmap_prealloc_blocks (sb, inode, - UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap, + map->s_uspace.s_bitmap, partition, first_block, block_count); - } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) { + }else if (map->s_partition_flags &UDF_PART_FLAG_UNALLOC_TABLE ) {return udf_table_prealloc_blocks (sb, inode, -UDF_SB_PARTMAPS (sb)[partition].s_uspace.s_table, + map->s_uspace.s_table, partition, first_block, block_count); - }else if (UDF_SB_PARTFLAGS (sb, partition) &UDF_PART_FLAG_FREED_BITMAP ) { + }else if (map->s_partition_flags &UDF_PART_FLAG_FREED_BITMAP ) {return udf_bitmap_prealloc_blocks (sb, inode, -UDF_SB_PARTMAPS (sb)[partition].s_fspace.s_bitmap, + map->s_fspace.s_bitmap, partition, first_block, block_count); - }else if (UDF_SB_PARTFLAGS (sb, partition) &UDF_PART_FLAG_FREED_TABLE ) { + }else if (map->s_partition_flags &UDF_PART_FLAG_FREED_TABLE ) {return udf_table_prealloc_blocks (sb, inode, -UDF_SB_PARTMAPS (sb)[partition].s_fspace.s_table, + map->s_fspace.s_table, partition, first_block, block_count); }else {return 0 ;
@@ -842,23 +853,24 @@ inline int udf_new_block(struct super_block *sb, uint16_t partition, uint32_t goal, int *err) { int ret; +struct udf_part_map *map = &UDF_SB (sb)->s_partmaps[partition]; -if (UDF_SB_PARTFLAGS (sb, partition) &UDF_PART_FLAG_UNALLOC_BITMAP ) { +if (map->s_partition_flags &UDF_PART_FLAG_UNALLOC_BITMAP ) { ret =udf_bitmap_new_block (sb, inode, -UDF_SB_PARTMAPS (sb)[partition].s_uspace.s_bitmap, + map->s_uspace.s_bitmap, partition, goal, err);return ret; - }else if (UDF_SB_PARTFLAGS (sb, partition) &UDF_PART_FLAG_UNALLOC_TABLE ) { + }else if (map->s_partition_flags &UDF_PART_FLAG_UNALLOC_TABLE ) {return udf_table_new_block (sb, inode, -UDF_SB_PARTMAPS (sb)[partition].s_uspace.s_table, + map->s_uspace.s_table, partition, goal, err); - }else if (UDF_SB_PARTFLAGS (sb, partition) &UDF_PART_FLAG_FREED_BITMAP ) { + }else if (map->s_partition_flags &UDF_PART_FLAG_FREED_BITMAP ) {return udf_bitmap_new_block (sb, inode, -UDF_SB_PARTMAPS (sb)[partition].s_fspace.s_bitmap, + map->s_fspace.s_bitmap, partition, goal, err); - }else if (UDF_SB_PARTFLAGS (sb, partition) &UDF_PART_FLAG_FREED_TABLE ) { + }else if (map->s_partition_flags &UDF_PART_FLAG_FREED_TABLE ) {return udf_table_new_block (sb, inode, -UDF_SB_PARTMAPS (sb)[partition].s_fspace.s_table, + map->s_fspace.s_table, partition, goal, err); }else { *err = -EIO ;
fs/udf/file.c +1 -1
@@ -192,7 +192,7 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,switch (cmd) {case UDF_GETVOLIDENT :return copy_to_user ((char __user *)arg, -UDF_SB_VOLIDENT (inode->i_sb),32 ) ? -EFAULT :0 ; +UDF_SB (inode->i_sb)->s_volume_ident,32 ) ? -EFAULT :0 ;case UDF_RELOCATE_BLOCKS :if (!capable (CAP_SYS_ADMIN ))return -EACCES ;
fs/udf/ialloc.c +19 -14
@@ -43,15 +43,17 @@ void udf_free_inode(struct inode *inode)clear_inode (inode);mutex_lock (&sbi->s_alloc_mutex); -if (sbi->s_lvidbh) { +if (sbi->s_lvid_bh) { +struct logicalVolIntegrityDescImpUse *lvidiu = +udf_sb_lvidiu (sbi);if (S_ISDIR (inode->i_mode)) -UDF_SB_LVIDIU (sb)->numDirs = -cpu_to_le32 (le32_to_cpu (UDF_SB_LVIDIU (sb)->numDirs) -1 ); + lvidiu->numDirs = +cpu_to_le32 (le32_to_cpu (lvidiu->numDirs) -1 );else -UDF_SB_LVIDIU (sb)->numFiles = -cpu_to_le32 (le32_to_cpu (UDF_SB_LVIDIU (sb)->numFiles) -1 ); + lvidiu->numFiles = +cpu_to_le32 (le32_to_cpu (lvidiu->numFiles) -1 ); -mark_buffer_dirty (sbi->s_lvidbh); +mark_buffer_dirty (sbi->s_lvid_bh); }mutex_unlock (&sbi->s_alloc_mutex);
@@ -88,21 +90,23 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err) }mutex_lock (&sbi->s_alloc_mutex); -if (UDF_SB_LVIDBH (sb)) { +if (sbi->s_lvid_bh) { +struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data; +struct logicalVolIntegrityDescImpUse *lvidiu =udf_sb_lvidiu (sbi);struct logicalVolHeaderDesc *lvhd;uint64_t uniqueID; - lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID (sb)->logicalVolContentsUse); + lvhd = (struct logicalVolHeaderDesc *)(lvid->logicalVolContentsUse);if (S_ISDIR (mode)) -UDF_SB_LVIDIU (sb)->numDirs = -cpu_to_le32 (le32_to_cpu (UDF_SB_LVIDIU (sb)->numDirs) +1 ); + lvidiu->numDirs = +cpu_to_le32 (le32_to_cpu (lvidiu->numDirs) +1 );else -UDF_SB_LVIDIU (sb)->numFiles = -cpu_to_le32 (le32_to_cpu (UDF_SB_LVIDIU (sb)->numFiles) +1 ); + lvidiu->numFiles = +cpu_to_le32 (le32_to_cpu (lvidiu->numFiles) +1 );UDF_I_UNIQUE (inode) = uniqueID =le64_to_cpu (lvhd->uniqueID);if (!(++uniqueID &0x00000000FFFFFFFFUL )) uniqueID +=16 ; lvhd->uniqueID =cpu_to_le64 (uniqueID); -mark_buffer_dirty (UDF_SB_LVIDBH (sb)); +mark_buffer_dirty (sbi->s_lvid_bh); } inode->i_mode = mode; inode->i_uid = current->fsuid;
@@ -123,7 +127,8 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)UDF_I_USE (inode) =0 ;if (UDF_QUERY_FLAG (inode->i_sb,UDF_FLAG_USE_EXTENDED_FE )) {UDF_I_EFE (inode) =1 ; -UDF_UPDATE_UDFREV (inode->i_sb,UDF_VERS_USE_EXTENDED_FE ); +if (UDF_VERS_USE_EXTENDED_FE > sbi->s_udfrev) + sbi->s_udfrev =UDF_VERS_USE_EXTENDED_FE ;UDF_I_DATA (inode) =kzalloc (inode->i_sb->s_blocksize -sizeof (struct extendedFileEntry ),GFP_KERNEL ); }else {UDF_I_EFE (inode) =0 ;
fs/udf/inode.c +18 -16
@@ -1081,6 +1081,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)time_t convtime;long convtime_usec;int offset; +struct udf_sb_info *sbi =UDF_SB (inode->i_sb); fe = (struct fileEntry *)bh->b_data; efe = (struct extendedFileEntry *)bh->b_data;
@@ -1160,7 +1161,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) inode->i_atime.tv_sec = convtime; inode->i_atime.tv_nsec = convtime_usec *1000 ; }else { - inode->i_atime =UDF_SB_RECORDTIME (inode->i_sb); + inode->i_atime = sbi->s_record_time; } if (udf_stamp_to_time(&convtime, &convtime_usec,
@@ -1168,7 +1169,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) inode->i_mtime.tv_sec = convtime; inode->i_mtime.tv_nsec = convtime_usec *1000 ; }else { - inode->i_mtime =UDF_SB_RECORDTIME (inode->i_sb); + inode->i_mtime = sbi->s_record_time; } if (udf_stamp_to_time(&convtime, &convtime_usec,
@@ -1176,7 +1177,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) inode->i_ctime.tv_sec = convtime; inode->i_ctime.tv_nsec = convtime_usec *1000 ; }else { - inode->i_ctime =UDF_SB_RECORDTIME (inode->i_sb); + inode->i_ctime = sbi->s_record_time; }UDF_I_UNIQUE (inode) =le64_to_cpu (fe->uniqueID);
@@ -1192,7 +1193,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) inode->i_atime.tv_sec = convtime; inode->i_atime.tv_nsec = convtime_usec *1000 ; }else { - inode->i_atime =UDF_SB_RECORDTIME (inode->i_sb); + inode->i_atime = sbi->s_record_time; } if (udf_stamp_to_time(&convtime, &convtime_usec,
@@ -1200,7 +1201,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) inode->i_mtime.tv_sec = convtime; inode->i_mtime.tv_nsec = convtime_usec *1000 ; }else { - inode->i_mtime =UDF_SB_RECORDTIME (inode->i_sb); + inode->i_mtime = sbi->s_record_time; } if (udf_stamp_to_time(&convtime, &convtime_usec,
@@ -1208,7 +1209,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)UDF_I_CRTIME (inode).tv_sec = convtime;UDF_I_CRTIME (inode).tv_nsec = convtime_usec *1000 ; }else { -UDF_I_CRTIME (inode) =UDF_SB_RECORDTIME (inode->i_sb); +UDF_I_CRTIME (inode) = sbi->s_record_time; } if (udf_stamp_to_time(&convtime, &convtime_usec,
@@ -1216,7 +1217,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh) inode->i_ctime.tv_sec = convtime; inode->i_ctime.tv_nsec = convtime_usec *1000 ; }else { - inode->i_ctime =UDF_SB_RECORDTIME (inode->i_sb); + inode->i_ctime = sbi->s_record_time; }UDF_I_UNIQUE (inode) =le64_to_cpu (efe->uniqueID);
@@ -1353,6 +1354,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)int i;kernel_timestamp cpu_time;int err =0 ; +struct udf_sb_info *sbi =UDF_SB (inode->i_sb); bh =udf_tread (inode->i_sb,udf_get_lb_pblock (inode->i_sb,UDF_I_LOCATION (inode),0 ));if (!bh) {
@@ -1537,11 +1539,11 @@ static int udf_update_inode(struct inode *inode, int do_sync) ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY)); fe->icbTag.flags =cpu_to_le16 (icbflags); -if (UDF_SB_UDFREV (inode->i_sb) >=0x0200 ) +if (sbi->s_udfrev >=0x0200 ) fe->descTag.descVersion =cpu_to_le16 (3 );else fe->descTag.descVersion =cpu_to_le16 (2 ); - fe->descTag.tagSerialNum =cpu_to_le16 (UDF_SB_SERIALNUM (inode->i_sb)); + fe->descTag.tagSerialNum =cpu_to_le16 (sbi->s_serial_number); fe->descTag.tagLocation =cpu_to_le32 (UDF_I_LOCATION (inode).logicalBlockNum); crclen +=UDF_I_LENEATTR (inode) +UDF_I_LENALLOC (inode) -sizeof (tag); fe->descTag.descCRCLength =cpu_to_le16 (crclen);
@@ -1585,7 +1587,7 @@ struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)if (is_bad_inode (inode)) goto out_iput; -if (ino.logicalBlockNum >=UDF_SB_PARTLEN (sb, ino.partitionReferenceNum)) { +if (ino.logicalBlockNum >=UDF_SB (sb)->s_partmaps[ino.partitionReferenceNum].s_partition_len) {udf_debug ("block=%d, partition=%d out of range\n" , ino.logicalBlockNum, ino.partitionReferenceNum);make_bad_inode (inode);
@@ -1667,7 +1669,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,mark_inode_dirty (inode); } } -if (UDF_SB_UDFREV (inode->i_sb) >=0x0200 ) +if (UDF_SB (inode->i_sb)->s_udfrev >=0x0200 )udf_new_tag (nbh->b_data,TAG_IDENT_AED ,3 ,1 , epos->block.logicalBlockNum,sizeof (tag));else
@@ -1690,7 +1692,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos, }if (epos->bh) {if (!UDF_QUERY_FLAG (inode->i_sb,UDF_FLAG_STRICT ) || -UDF_SB_UDFREV (inode->i_sb) >=0x0201 ) +UDF_SB (inode->i_sb)->s_udfrev >=0x0201 )udf_update_tag (epos->bh->b_data, loffset);else udf_update_tag (epos->bh->b_data,sizeof (struct allocExtDesc ));
@@ -1711,7 +1713,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos, aed = (struct allocExtDesc *)epos->bh->b_data; aed->lengthAllocDescs =cpu_to_le32 (le32_to_cpu (aed->lengthAllocDescs) + adsize); -if (!UDF_QUERY_FLAG (inode->i_sb,UDF_FLAG_STRICT ) ||UDF_SB_UDFREV (inode->i_sb) >=0x0201 ) +if (!UDF_QUERY_FLAG (inode->i_sb,UDF_FLAG_STRICT ) ||UDF_SB (inode->i_sb)->s_udfrev >=0x0201 )udf_update_tag (epos->bh->b_data, epos->offset + (inc ?0 : adsize));else udf_update_tag (epos->bh->b_data,sizeof (struct allocExtDesc ));
@@ -1754,7 +1756,7 @@ int8_t udf_write_aext(struct inode * inode, struct extent_position * epos,if (epos->bh) {if (!UDF_QUERY_FLAG (inode->i_sb,UDF_FLAG_STRICT ) || -UDF_SB_UDFREV (inode->i_sb) >=0x0201 ) { +UDF_SB (inode->i_sb)->s_udfrev >=0x0201 ) {struct allocExtDesc *aed = (struct allocExtDesc *)epos->bh->b_data;udf_update_tag (epos->bh->b_data,le32_to_cpu (aed->lengthAllocDescs) +sizeof (struct allocExtDesc ));
@@ -1907,7 +1909,7 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos, aed->lengthAllocDescs =cpu_to_le32 (le32_to_cpu (aed->lengthAllocDescs) - (2 * adsize));if (!UDF_QUERY_FLAG (inode->i_sb,UDF_FLAG_STRICT ) || -UDF_SB_UDFREV (inode->i_sb) >=0x0201 ) +UDF_SB (inode->i_sb)->s_udfrev >=0x0201 )udf_update_tag (oepos.bh->b_data, oepos.offset - (2 * adsize));else udf_update_tag (oepos.bh->b_data,sizeof (struct allocExtDesc ));
@@ -1923,7 +1925,7 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos, aed->lengthAllocDescs =cpu_to_le32 (le32_to_cpu (aed->lengthAllocDescs) - adsize);if (!UDF_QUERY_FLAG (inode->i_sb,UDF_FLAG_STRICT ) || -UDF_SB_UDFREV (inode->i_sb) >=0x0201 ) +UDF_SB (inode->i_sb)->s_udfrev >=0x0201 )udf_update_tag (oepos.bh->b_data, epos.offset - adsize);else udf_update_tag (oepos.bh->b_data,sizeof (struct allocExtDesc ));
fs/udf/misc.c +9 -6
@@ -81,14 +81,16 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,return NULL ; } }else { +struct udf_sb_info *sbi =UDF_SB (inode->i_sb); + size -=sizeof (struct extendedAttrHeaderDesc );UDF_I_LENEATTR (inode) +=sizeof (struct extendedAttrHeaderDesc ); eahd->descTag.tagIdent =cpu_to_le16 (TAG_IDENT_EAHD ); -if (UDF_SB_UDFREV (inode->i_sb) >=0x0200 ) +if (sbi->s_udfrev >=0x0200 ) eahd->descTag.descVersion =cpu_to_le16 (3 );else eahd->descTag.descVersion =cpu_to_le16 (2 ); - eahd->descTag.tagSerialNum =cpu_to_le16 (UDF_SB_SERIALNUM (inode->i_sb)); + eahd->descTag.tagSerialNum =cpu_to_le16 (sbi->s_serial_number); eahd->descTag.tagLocation =cpu_to_le32 (UDF_I_LOCATION (inode).logicalBlockNum); eahd->impAttrLocation =cpu_to_le32 (0xFFFFFFFF ); eahd->appAttrLocation =cpu_to_le32 (0xFFFFFFFF );
@@ -192,15 +194,16 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,struct buffer_head *bh =NULL ; registeruint8_t checksum; registerint i; +struct udf_sb_info *sbi =UDF_SB (sb);/* Read the block */ if (block ==0xFFFFFFFF )return NULL ; - bh =udf_tread (sb, block +UDF_SB_SESSION (sb)); + bh =udf_tread (sb, block + sbi->s_session);if (!bh) {udf_debug ("block=%d, location=%d: read failed\n" , - block +UDF_SB_SESSION (sb), location); + block + sbi->s_session, location);return NULL ; }
@@ -210,7 +213,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,if (location !=le32_to_cpu (tag_p->tagLocation)) {udf_debug ("location mismatch block %u, tag %u != %u\n" , - block +UDF_SB_SESSION (sb),le32_to_cpu (tag_p->tagLocation), location); + block + sbi->s_session,le32_to_cpu (tag_p->tagLocation), location); goto error_out; }
@@ -240,7 +243,7 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,return bh; }udf_debug ("Crc failure block %d: crc = %d, crclen = %d\n" , - block +UDF_SB_SESSION (sb),le16_to_cpu (tag_p->descCRC), + block + sbi->s_session,le16_to_cpu (tag_p->descCRC),le16_to_cpu (tag_p->descCRCLength)); error_out:
fs/udf/namei.c +14 -10
@@ -325,7 +325,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,struct udf_fileident_bh *fibh, struct fileIdentDesc *cfi, int *err) { - struct super_block *sb; + struct super_block *sb = dir->i_sb;struct fileIdentDesc *fi =NULL ;char name[UDF_NAME_LEN ], fname[UDF_NAME_LEN ];int namelen;
@@ -342,8 +342,6 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,sector_t offset;struct extent_position epos = {}; - sb = dir->i_sb; -if (dentry) {if (!dentry->d_name.len) { *err = -EINVAL ;
@@ -535,7 +533,7 @@ add: }memset (cfi,0 ,sizeof (struct fileIdentDesc )); -if (UDF_SB_UDFREV (sb) >=0x0200 ) +if (UDF_SB (sb)->s_udfrev >=0x0200 )udf_new_tag ((char *)cfi,TAG_IDENT_FID ,3 ,1 , block,sizeof (tag));else udf_new_tag ((char *)cfi,TAG_IDENT_FID ,2 ,1 , block,sizeof (tag));
@@ -901,6 +899,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,int block;char name[UDF_NAME_LEN ];int namelen; +struct buffer_head *bh;lock_kernel ();if (!(inode =udf_new_inode (dir,S_IFLNK , &err)))
@@ -1014,17 +1013,19 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry, goto out_no_entry; cfi.icb.extLength =cpu_to_le32 (inode->i_sb->s_blocksize); cfi.icb.extLocation =cpu_to_lelb (UDF_I_LOCATION (inode)); -if (UDF_SB_LVIDBH (inode->i_sb)) { + bh =UDF_SB (inode->i_sb)->s_lvid_bh; +if (bh) { +struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)bh->b_data;struct logicalVolHeaderDesc *lvhd;uint64_t uniqueID; - lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID (inode->i_sb)->logicalVolContentsUse); + lvhd = (struct logicalVolHeaderDesc *)(lvid->logicalVolContentsUse); uniqueID =le64_to_cpu (lvhd->uniqueID); *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =cpu_to_le32 (uniqueID &0x00000000FFFFFFFFUL );if (!(++uniqueID &0x00000000FFFFFFFFUL )) uniqueID +=16 ; lvhd->uniqueID =cpu_to_le64 (uniqueID); -mark_buffer_dirty (UDF_SB_LVIDBH (inode->i_sb)); +mark_buffer_dirty (bh); }udf_write_fi (dir, &cfi, fi, &fibh,NULL ,NULL );if (UDF_I_ALLOCTYPE (dir) ==ICBTAG_FLAG_AD_IN_ICB ) {
@@ -1053,6 +1054,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,struct udf_fileident_bh fibh;struct fileIdentDesc cfi, *fi;int err; +struct buffer_head *bh;lock_kernel ();if (inode->i_nlink >= (256 <<sizeof (inode->i_nlink)) -1 ) {
@@ -1066,17 +1068,19 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir, } cfi.icb.extLength =cpu_to_le32 (inode->i_sb->s_blocksize); cfi.icb.extLocation =cpu_to_lelb (UDF_I_LOCATION (inode)); -if (UDF_SB_LVIDBH (inode->i_sb)) { + bh =UDF_SB (inode->i_sb)->s_lvid_bh; +if (bh) { +struct logicalVolIntegrityDesc *lvid = (struct logicalVolIntegrityDesc *)bh->b_data;struct logicalVolHeaderDesc *lvhd;uint64_t uniqueID; - lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID (inode->i_sb)->logicalVolContentsUse); + lvhd = (struct logicalVolHeaderDesc *)(lvid->logicalVolContentsUse); uniqueID =le64_to_cpu (lvhd->uniqueID); *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =cpu_to_le32 (uniqueID &0x00000000FFFFFFFFUL );if (!(++uniqueID &0x00000000FFFFFFFFUL )) uniqueID +=16 ; lvhd->uniqueID =cpu_to_le64 (uniqueID); -mark_buffer_dirty (UDF_SB_LVIDBH (inode->i_sb)); +mark_buffer_dirty (bh); }udf_write_fi (dir, &cfi, fi, &fibh,NULL ,NULL );if (UDF_I_ALLOCTYPE (dir) ==ICBTAG_FLAG_AD_IN_ICB ) {
fs/udf/partition.c +40 -27
160 lines not on this page · raw message
fs/udf/super.c +305 -243
1,022 lines not on this page · raw message
fs/udf/truncate.c +4 -3
@@ -163,7 +163,7 @@ void udf_discard_prealloc(struct inode *inode)cpu_to_le32 (epos.offset -sizeof (struct allocExtDesc ));if (!UDF_QUERY_FLAG (inode->i_sb,UDF_FLAG_STRICT ) || -UDF_SB_UDFREV (inode->i_sb) >=0x0201 ) +UDF_SB (inode->i_sb)->s_udfrev >=0x0201 )udf_update_tag (epos.bh->b_data, epos.offset);else udf_update_tag(epos.bh->b_data,
@@ -184,6 +184,7 @@ void udf_truncate_extents(struct inode *inode)uint32_t elen, nelen =0 , indirect_ext_len =0 , lenalloc;int8_t etype;struct super_block *sb = inode->i_sb; +struct udf_sb_info *sbi =UDF_SB (sb);sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset;loff_t byte_offset;int adsize;
@@ -232,7 +233,7 @@ void udf_truncate_extents(struct inode *inode) aed->lengthAllocDescs =cpu_to_le32 (lenalloc);if (!UDF_QUERY_FLAG (sb,UDF_FLAG_STRICT ) || -UDF_SB_UDFREV (sb) >=0x0201 ) + sbi->s_udfrev >=0x0201 )udf_update_tag (epos.bh->b_data, lenalloc +sizeof (struct allocExtDesc ));
@@ -271,7 +272,7 @@ void udf_truncate_extents(struct inode *inode) (struct allocExtDesc *)(epos.bh->b_data); aed->lengthAllocDescs =cpu_to_le32 (lenalloc);if (!UDF_QUERY_FLAG (sb,UDF_FLAG_STRICT ) || -UDF_SB_UDFREV (sb) >=0x0201 ) + sbi->s_udfrev >=0x0201 )udf_update_tag (epos.bh->b_data, lenalloc +sizeof (struct allocExtDesc ));else
fs/udf/udf_sb.h +20 -55
107 lines not on this page · raw message
include/linux/udf_fs_sb.h +6 -6
@@ -75,7 +75,7 @@ struct udf_part_mapstruct udf_sb_info {struct udf_part_map *s_partmaps; -__u8 s_volident[32 ]; +__u8 s_volume_ident[32 ];/* Overall info */ __u16 s_partitions;
@@ -84,9 +84,9 @@ struct udf_sb_info/* Sector headers */ __s32 s_session;__u32 s_anchor[4 ]; -__u32 s_lastblock; +__u32 s_last_block; -struct buffer_head *s_lvidbh; +struct buffer_head *s_lvid_bh;/* Default permissions */ mode_t s_umask;
@@ -94,10 +94,10 @@ struct udf_sb_infouid_t s_uid;/* Root Info */ -struct timespec s_recordtime; +struct timespec s_record_time;/* Fileset Info */ -__u16 s_serialnum; +__u16 s_serial_number;/* highest UDF revision we have recorded to this media */ __u16 s_udfrev;
@@ -109,7 +109,7 @@ struct udf_sb_infostruct nls_table *s_nls_map;/* VAT inode */ -struct inode *s_vat; +struct inode *s_vat_inode;struct mutex s_alloc_mutex; };
Signature · 1 line
1.5.3.4
Re: [PATCH 2/6] udf: remove some ugly macros
Looks generally good, but it would be nice if you could avoid introducing new overly long lines. Then again this really won't be noticed in udf anyway and it looks like you plan to clean it up later anyway.
(in case it wasn;'t clear count this as an ack from me)
Re: [PATCH 2/6] udf: remove some ugly macros
Quoted 4 lines · Christoph Hellwig
Looks generally good, but it would be nice if you could avoid introducing new overly long lines. Then again this really won't be noticed in udf anyway and it looks like you plan to clean it up later anyway.
Yes, that's what I'm going to do.
Quoted 2 lines
(in case it wasn;'t clear count this as an ack from me)
Thanks for review!
Marcin
PATCH 3/6 udf: convert UDF_SB_ALLOC_PARTMAPS macro to udf_sb_alloc_partition_maps function
In reply to [email protected]- convert UDF_SB_ALLOC_PARTMAPS macro to udf_sb_alloc_partition_maps function
- convert kmalloc + memset to kzalloc
- check if kzalloc failed (partially)
--- fs/udf/super.c | 20 ++++++++++++++++++-- fs/udf/udf_sb.h | 13 ------------- 2 files changed, 18 insertions(+), 15 deletions(-)
fs/udf/super.c +18 -2
@@ -53,6 +53,7 @@#include <linux/vfs.h> #include <linux/vmalloc.h> #include <asm/byteorder.h> +#include <linux/errno.h> #include <linux/udf_fs.h> #include "udf_sb.h"
@@ -226,6 +227,19 @@ static void __exit exit_udf_fs(void)module_init (init_udf_fs)module_exit (exit_udf_fs) +static int __must_check udf_sb_alloc_partition_maps(struct super_block *sb, __u32 count) +{ +struct udf_sb_info *sbi =UDF_SB (sb); + sbi->s_partmaps = kzalloc(sizeof(struct udf_part_map) * count, GFP_KERNEL); + if (sbi->s_partmaps != NULL) + sbi->s_partitions = count; + else { + sbi->s_partitions =0 ; +udf_error (sb, __FUNCTION__,"Unable to allocate space for %d partition maps" , count); + } +return sbi->s_partmaps !=NULL ?0 : -ENOMEM ; +} +/* * udf_parse_options *
@@ -1037,7 +1051,9 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh, lvd = (struct logicalVolDesc *)bh->b_data; -UDF_SB_ALLOC_PARTMAPS (sb,le32_to_cpu (lvd->numPartitionMaps)); + i =udf_sb_alloc_partition_maps (sb,le32_to_cpu (lvd->numPartitionMaps)); +if (i !=0 ) +return i; for (i = 0, offset = 0; i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength);
@@ -1242,7 +1258,7 @@ static int udf_process_sequence(struct super_block *sb, long block,if (i ==VDS_POS_PRIMARY_VOL_DESC ) {udf_load_pvoldesc (sb, bh); }else if (i ==VDS_POS_LOGICAL_VOL_DESC ) { -udf_load_logicalvol (sb, bh, fileset); +udf_load_logicalvol (sb, bh, fileset);/* TODO: check return value */ }else if (i ==VDS_POS_PARTITION_DESC ) {struct buffer_head *bh2 =NULL ;if (udf_load_partdesc (sb, bh)) {
fs/udf/udf_sb.h +0 -13
@@ -43,19 +43,6 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu (struct udf_sb_info *sbi); -#define UDF_SB_ALLOC_PARTMAPS (X ,Y )\ -{\ - struct udf_sb_info *sbi = UDF_SB(X);\ - sbi->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\ - if (sbi->s_partmaps != NULL) {\ - sbi->s_partitions = Y;\ - memset(sbi->s_partmaps, 0x00, sizeof(struct udf_part_map) * Y);\ - } else {\ - sbi->s_partitions = 0;\ - udf_error(X, __FUNCTION__, "Unable to allocate space for %d partition maps", Y);\ - }\ -} -#define UDF_SB_ALLOC_BITMAP (X ,Y ,Z )\ {\ struct udf_sb_info *sbi = UDF_SB(X);\
Signature · 1 line
1.5.3.4
Re: [PATCH 3/6] udf: convert UDF_SB_ALLOC_PARTMAPS macro to udf_sb_alloc_partition_maps function
fs/udf/super.c line 56
Quoted 5 lines · On Mon, Dec 24, 2007 at 01:10:19AM +0100, [email protected] wrote:
fs/udf/super.c +1
-0@@ -53,6 +53,7 @@#include <linux/vfs.h> #include <linux/vmalloc.h> #include <asm/byteorder.h> +#include <linux/errno.h>
linux/*.h always before asm/*.h
fs/udf/super.c static void __exit exit_udf_fs(void) · line 230
Quoted 1 line
fs/udf/super.c +1
-0+static int __must_check udf_sb_alloc_partition_maps (struct super_block *sb,__u32 count)
I think __must_check is primarily for public APIs. But if it really helps you here I won't complain.
Also please use u32 over __u32 (dito for the other similar types)
fs/udf/super.c static void __exit exit_udf_fs(void) · line 241
Quoted 11 lines
fs/udf/super.c +11
-0+{ +struct udf_sb_info *sbi =UDF_SB (sb); + sbi->s_partmaps =kzalloc (sizeof (struct udf_part_map ) * count,GFP_KERNEL ); +if (sbi->s_partmaps !=NULL ) + sbi->s_partitions = count; +else { + sbi->s_partitions =0 ; +udf_error (sb, __FUNCTION__,"Unable to allocate space for %d partition maps" , count); + } +return sbi->s_partmaps !=NULL ?0 : -ENOMEM ; +}
But please don't introduce new overlong lines in entirely new functions.
Also the code look rather odd, I'd rather write it as:
static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count)
{
struct udf_sb_info *sbi = UDF_SB(sb);
sbi->s_partmaps = kcalloc(count, sizeof(struct udf_part_map),
GFP_KERNEL);
if (!sbi->s_partmaps) {
udf_error(sb, __FUNCTION__,
"Unable to allocate space for %d partition maps",
count);
sbi->s_partitions = 0;
return -ENOMEM;
}
sbi->s_partitions = count;
return 0;
}Re: [PATCH 3/6] udf: convert UDF_SB_ALLOC_PARTMAPS macro to udf_sb_alloc_partition_maps function
Quoted 33 lines · Christoph Hellwig
Review line 56
Quoted 5 lines · On Mon, Dec 24, 2007 at 01:10:19AM +0100, [email protected] wrote:
(quoted diff) +1
-0@@ -53,6 +53,7 @@ #include <linux/vfs.h> #include <linux/vmalloc.h> #include <asm/byteorder.h> +#include <linux/errno.h>linux/*.h always before asm/*.h
Review line 57
Quoted 1 line
(quoted diff) +1
-0+static int __must_check udf_sb_alloc_partition_maps(struct super_block *sb, __u32 count)I think
__must_checkis primarily for public APIs. But if it really helps you here I won't complain.Also please use u32 over
__u32(dito for the other similar types)Review
Quoted 11 lines
(quoted diff) +11
-0+{ + struct udf_sb_info *sbi = UDF_SB(sb); + sbi->s_partmaps = kzalloc(sizeof(struct udf_part_map) * count, GFP_KERNEL); + if (sbi->s_partmaps != NULL) + sbi->s_partitions = count; + else { + sbi->s_partitions = 0; + udf_error(sb, __FUNCTION__, "Unable to allocate space for %d partition maps", count); + } + return sbi->s_partmaps != NULL ? 0 : -ENOMEM; +}But please don't introduce new overlong lines in entirely new functions.
Also the code look rather odd, I'd rather write it as:
static int
udf_sb_alloc_partition_maps(struct super_block *sb, u32 count)
Quoted 16 lines
{
struct udf_sb_info *sbi = UDF_SB(sb);
sbi->s_partmaps = kcalloc(count, sizeof(struct udf_part_map),
GFP_KERNEL);
if (!sbi->s_partmaps) {
udf_error(sb, __FUNCTION__,
"Unable to allocate space for %d partition maps",
count);
sbi->s_partitions = 0;
return -ENOMEM;
}
sbi->s_partitions = count;
return 0;
}Ok, updated batch below:
--
- convert UDF_SB_ALLOC_PARTMAPS macro to udf_sb_alloc_partition_maps function
- convert kmalloc + memset to kcalloc
- check if kcalloc failed (partially)
--- fs/udf/super.c | 25 +++++++++++++++++++++++-- fs/udf/udf_sb.h | 13 ------------- 2 files changed, 23 insertions(+), 15 deletions(-)
fs/udf/super.c +23 -2
@@ -52,6 +52,7 @@#include <linux/buffer_head.h> #include <linux/vfs.h> #include <linux/vmalloc.h> +#include <linux/errno.h> #include <asm/byteorder.h> #include <linux/udf_fs.h>
@@ -226,6 +227,24 @@ static void __exit exit_udf_fs(void)module_init (init_udf_fs)module_exit (exit_udf_fs) +static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count) +{ +struct udf_sb_info *sbi =UDF_SB (sb); + + sbi->s_partmaps = kcalloc(count, sizeof(struct udf_part_map), +GFP_KERNEL ); + if (!sbi->s_partmaps) { +udf_error (sb, __FUNCTION__, +"Unable to allocate space for %d partition maps" , + count); + sbi->s_partitions =0 ; +return -ENOMEM ; + } + + sbi->s_partitions = count; +return 0 ; +} +/* * udf_parse_options *
@@ -1037,7 +1056,9 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh, lvd = (struct logicalVolDesc *)bh->b_data; -UDF_SB_ALLOC_PARTMAPS (sb,le32_to_cpu (lvd->numPartitionMaps)); + i =udf_sb_alloc_partition_maps (sb,le32_to_cpu (lvd->numPartitionMaps)); +if (i !=0 ) +return i; for (i = 0, offset = 0; i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength);
@@ -1242,7 +1263,7 @@ static int udf_process_sequence(struct super_block *sb, long block,if (i ==VDS_POS_PRIMARY_VOL_DESC ) {udf_load_pvoldesc (sb, bh); }else if (i ==VDS_POS_LOGICAL_VOL_DESC ) { -udf_load_logicalvol (sb, bh, fileset); +udf_load_logicalvol (sb, bh, fileset);/* TODO: check return value */ }else if (i ==VDS_POS_PARTITION_DESC ) {struct buffer_head *bh2 =NULL ;if (udf_load_partdesc (sb, bh)) {
fs/udf/udf_sb.h +0 -13
@@ -43,19 +43,6 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu (struct udf_sb_info *sbi); -#define UDF_SB_ALLOC_PARTMAPS (X ,Y )\ -{\ - struct udf_sb_info *sbi = UDF_SB(X);\ - sbi->s_partmaps = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\ - if (sbi->s_partmaps != NULL) {\ - sbi->s_partitions = Y;\ - memset(sbi->s_partmaps, 0x00, sizeof(struct udf_part_map) * Y);\ - } else {\ - sbi->s_partitions = 0;\ - udf_error(X, __FUNCTION__, "Unable to allocate space for %d partition maps", Y);\ - }\ -} -#define UDF_SB_ALLOC_BITMAP (X ,Y ,Z )\ {\ struct udf_sb_info *sbi = UDF_SB(X);\
--
1.5.3.4
Re: [PATCH 3/6] udf: convert UDF_SB_ALLOC_PARTMAPS macro to udf_sb_alloc_partition_maps function
Looks good, thanks.
PATCH 4/6 udf: check if udf_load_logicalvol failed
In reply to [email protected]udf_load_logicalvol may fail eg in out of memory conditions - check it and propagate error further
--- fs/udf/super.c | 7 ++++++- 1 files changed, 6 insertions(+), 1 deletions(-)
fs/udf/super.c +6 -1
@@ -1183,6 +1183,7 @@ static int udf_process_sequence(struct super_block *sb, long block,uint32_t vdsn;uint16_t ident;long next_s =0 , next_e =0 ; +int ret;memset (vds,0 ,sizeof (struct udf_vds_record ) *VDS_POS_LENGTH );
@@ -1258,7 +1259,11 @@ static int udf_process_sequence(struct super_block *sb, long block,if (i ==VDS_POS_PRIMARY_VOL_DESC ) {udf_load_pvoldesc (sb, bh); }else if (i ==VDS_POS_LOGICAL_VOL_DESC ) { -udf_load_logicalvol (sb, bh, fileset);/* TODO: check return value */ + ret =udf_load_logicalvol (sb, bh, fileset); +if (ret !=0 ) { +brelse (bh); +return ret; + } }else if (i ==VDS_POS_PARTITION_DESC ) {struct buffer_head *bh2 =NULL ;if (udf_load_partdesc (sb, bh)) {
Signature · 1 line
1.5.3.4
PATCH 5/6 udf: convert some macros to functions
In reply to [email protected]convert UDF_SB_ALLOC_BITMAP macro to udf_sb_alloc_bitmap function convert UDF_SB_FREE_BITMAP macro to udf_sb_free_bitmap function
--- fs/udf/super.c | 49 +++++++++++++++++++++++++++++++++++++++++++------ fs/udf/udf_sb.h | 38 -------------------------------------- 2 files changed, 43 insertions(+), 44 deletions(-)
fs/udf/super.c +43 -6
@@ -932,6 +932,27 @@ static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh, root->logicalBlockNum, root->partitionReferenceNum); } +static struct udf_bitmap *udf_sb_alloc_bitmap (struct super_block *sb,__u32 index) +{ +struct udf_part_map *map = &UDF_SB (sb)->s_partmaps[index]; +int nr_groups = (map->s_partition_len + (sizeof (struct spaceBitmapDesc ) <<3 ) + + (sb->s_blocksize *8 ) -1 ) / (sb->s_blocksize *8 ); +int size =sizeof (struct udf_bitmap ) + (sizeof (struct buffer_head *) * nr_groups); +struct udf_bitmap *bitmap; + +if (size <=PAGE_SIZE ) + bitmap =kmalloc (size,GFP_KERNEL ); +else + bitmap =vmalloc (size); +if (bitmap !=NULL ) { +memset (bitmap,0x00 , size); + bitmap->s_block_bitmap = (struct buffer_head **)(bitmap +1 ); + bitmap->s_nr_groups = nr_groups; + }else +udf_error (sb, __FUNCTION__,"Unable to allocate space for bitmap and %d buffer_head pointers" , nr_groups); +return bitmap; +} +static int udf_load_partdesc (struct super_block *sb,struct buffer_head *bh) {struct partitionDesc *p;
@@ -982,7 +1003,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh) i, map->s_uspace.s_table->i_ino); }if (phd->unallocSpaceBitmap.extLength) { -UDF_SB_ALLOC_BITMAP (sb, i, s_uspace); + map->s_uspace.s_bitmap =udf_sb_alloc_bitmap (sb, i);if (map->s_uspace.s_bitmap !=NULL ) { map->s_uspace.s_bitmap->s_extLength =le32_to_cpu (phd->unallocSpaceBitmap.extLength);
@@ -1012,7 +1033,7 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh) i, map->s_fspace.s_table->i_ino); }if (phd->freedSpaceBitmap.extLength) { -UDF_SB_ALLOC_BITMAP (sb, i, s_fspace); + map->s_fspace.s_bitmap =udf_sb_alloc_bitmap (sb, i);if (map->s_fspace.s_bitmap !=NULL ) { map->s_fspace.s_bitmap->s_extLength =le32_to_cpu (phd->freedSpaceBitmap.extLength);
@@ -1501,6 +1522,22 @@ static void udf_close_lvid(struct super_block *sb) } } +static void udf_sb_free_bitmap (struct udf_bitmap *bitmap) +{ +int i; +int nr_groups = bitmap->s_nr_groups; +int size =sizeof (struct udf_bitmap ) + (sizeof (struct buffer_head *) * nr_groups); + +for (i =0 ; i < nr_groups; i++) +if (bitmap->s_block_bitmap[i]) +brelse (bitmap->s_block_bitmap[i]); + +if (size <=PAGE_SIZE ) +kfree (bitmap); +else +vfree (bitmap); +} +/* * udf_read_super *
@@ -1686,9 +1723,9 @@ error_out:if (map->s_partition_flags &UDF_PART_FLAG_FREED_TABLE )iput (map->s_fspace.s_table);if (map->s_partition_flags &UDF_PART_FLAG_UNALLOC_BITMAP ) -UDF_SB_FREE_BITMAP (sb, sbi->s_partition, s_uspace); +udf_sb_free_bitmap (map->s_uspace.s_bitmap);if (map->s_partition_flags &UDF_PART_FLAG_FREED_BITMAP ) -UDF_SB_FREE_BITMAP (sb, sbi->s_partition, s_fspace); +udf_sb_free_bitmap (map->s_fspace.s_bitmap);if (map->s_partition_type ==UDF_SPARABLE_MAP15 )for (i =0 ; i <4 ; i++)brelse (map->s_type_specific.s_sparing.s_spar_map[i]);
@@ -1764,9 +1801,9 @@ static void udf_put_super(struct super_block *sb)if (map->s_partition_flags &UDF_PART_FLAG_FREED_TABLE )iput (map->s_fspace.s_table);if (map->s_partition_flags &UDF_PART_FLAG_UNALLOC_BITMAP ) -UDF_SB_FREE_BITMAP (sb, sbi->s_partition, s_uspace); +udf_sb_free_bitmap (map->s_uspace.s_bitmap);if (map->s_partition_flags &UDF_PART_FLAG_FREED_BITMAP ) -UDF_SB_FREE_BITMAP (sb, sbi->s_partition, s_fspace); +udf_sb_free_bitmap (map->s_fspace.s_bitmap);if (map->s_partition_type ==UDF_SPARABLE_MAP15 )for (i =0 ; i <4 ; i++)brelse (map->s_type_specific.s_sparing.s_spar_map[i]);
fs/udf/udf_sb.h +0 -38
@@ -43,46 +43,8 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu (struct udf_sb_info *sbi); -#define UDF_SB_ALLOC_BITMAP (X ,Y ,Z )\ -{\ - struct udf_sb_info *sbi = UDF_SB(X);\ - int nr_groups = ((sbi->s_partmaps[(Y)].s_partition_len + (sizeof(struct spaceBitmapDesc) << 3) +\ - ((X)->s_blocksize * 8) - 1) / ((X)->s_blocksize * 8));\ - int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\ - if (size <= PAGE_SIZE)\ - sbi->s_partmaps[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\ - else\ - sbi->s_partmaps[(Y)].Z.s_bitmap = vmalloc(size);\ - if (sbi->s_partmaps[(Y)].Z.s_bitmap != NULL) {\ - memset(sbi->s_partmaps[(Y)].Z.s_bitmap, 0x00, size);\ - sbi->s_partmaps[(Y)].Z.s_bitmap->s_block_bitmap =\ - (struct buffer_head **)(sbi->s_partmaps[(Y)].Z.s_bitmap + 1);\ - sbi->s_partmaps[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\ - } else {\ - udf_error(X, __FUNCTION__, "Unable to allocate space for bitmap and %d buffer_head pointers", nr_groups);\ - }\ -} - -#define UDF_SB_FREE_BITMAP (X ,Y ,Z )\ -{\ - int i;\ - int nr_groups = UDF_SB_BITMAP_NR_GROUPS(X,Y,Z);\ - int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\ - for (i = 0; i < nr_groups; i++) {\ - if (UDF_SB_BITMAP(X,Y,Z,i))\ - brelse(UDF_SB_BITMAP(X,Y,Z,i));\ - }\ - if (size <= PAGE_SIZE)\ - kfree(UDF_SB(X)->s_partmaps[Y].Z.s_bitmap);\ - else\ - vfree(UDF_SB(X)->s_partmaps[Y].Z.s_bitmap);\ -} -#define UDF_QUERY_FLAG (X ,Y ) ( UDF_SB(X)->s_flags & ( 1 << (Y) ) )#define UDF_SET_FLAG (X ,Y ) ( UDF_SB(X)->s_flags |= ( 1 << (Y) ) )#define UDF_CLEAR_FLAG (X ,Y ) ( UDF_SB(X)->s_flags &= ~( 1 << (Y) ) ) -#define UDF_SB_BITMAP (X ,Y ,Z ,I ) ( UDF_SB(X)->s_partmaps[(Y)].Z.s_bitmap->s_block_bitmap[I] ) -#define UDF_SB_BITMAP_NR_GROUPS (X ,Y ,Z ) ( UDF_SB(X)->s_partmaps[(Y)].Z.s_bitmap->s_nr_groups ) -#endif /* __LINUX_UDF_SB_H */
Signature · 1 line
1.5.3.4
PATCH 6/6 udf: fix sparse warnings (shadowing & mismatch between declaration and definition)
In reply to [email protected]fix sparse warnings:fs/udf/super.c:1431:24: warning: symbol 'bh' shadows an earlier one fs/udf/super.c:1347:21: originally declared herefs/udf/super.c:472:6: warning: symbol 'udf_write_super' was not declared. Should it be static?
--- fs/udf/super.c | 3 +-- 1 files changed, 1 insertions(+), 2 deletions(-)
fs/udf/super.c +1 -2
@@ -469,7 +469,7 @@ static int udf_parse_options(char *options, struct udf_options *uopt)return 1 ; } -void udf_write_super (struct super_block *sb) +static void udf_write_super (struct super_block *sb) {lock_kernel ();
@@ -1428,7 +1428,6 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset) map->s_type_specific.s_virtual.s_num_entries = (sbi->s_vat_inode->i_size -36 ) >>2 ; }else if (map->s_partition_type ==UDF_VIRTUAL_MAP20 ) { -struct buffer_head *bh =NULL ;uint32_t pos; pos =udf_block_map (sbi->s_vat_inode,0 );
Signature · 1 line
1.5.3.4