Remove struct typedefs from fs/udf/ecma_167.h et al. (5ca4e4be) · Commits · 戴 / test

fs/udf/balloc.c

+19 −19

Original line number	Diff line number	Diff line
		@@ -87,7 +87,7 @@ static int read_block_bitmap(struct super_block *sb,
		{
		struct buffer_head *bh = NULL;
		int retval = 0;
		kernel_lb_addr loc;
		struct kernel_lb_addr loc;

		loc.logicalBlockNum = bitmap->s_extPosition;
		loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
		@@ -156,7 +156,7 @@ static bool udf_add_free_space(struct udf_sb_info *sbi,
		static void udf_bitmap_free_blocks(struct super_block *sb,
		struct inode *inode,
		struct udf_bitmap *bitmap,
		kernel_lb_addr bloc, uint32_t offset,
		struct kernel_lb_addr bloc, uint32_t offset,
		uint32_t count)
		{
		struct udf_sb_info *sbi = UDF_SB(sb);
		@@ -425,13 +425,13 @@ error_return:
		static void udf_table_free_blocks(struct super_block *sb,
		struct inode *inode,
		struct inode *table,
		kernel_lb_addr bloc, uint32_t offset,
		struct kernel_lb_addr bloc, uint32_t offset,
		uint32_t count)
		{
		struct udf_sb_info *sbi = UDF_SB(sb);
		uint32_t start, end;
		uint32_t elen;
		kernel_lb_addr eloc;
		struct kernel_lb_addr eloc;
		struct extent_position oepos, epos;
		int8_t etype;
		int i;
		@@ -532,8 +532,8 @@ static void udf_table_free_blocks(struct super_block *sb,
		*/

		int adsize;
		short_ad *sad = NULL;
		long_ad *lad = NULL;
		struct short_ad *sad = NULL;
		struct long_ad *lad = NULL;
		struct allocExtDesc *aed;

		eloc.logicalBlockNum = start;
		@@ -541,9 +541,9 @@ static void udf_table_free_blocks(struct super_block *sb,
		(count << sb->s_blocksize_bits);

		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
		adsize = sizeof(short_ad);
		adsize = sizeof(struct short_ad);
		else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
		adsize = sizeof(long_ad);
		adsize = sizeof(struct long_ad);
		else {
		brelse(oepos.bh);
		brelse(epos.bh);
		@@ -601,15 +601,15 @@ static void udf_table_free_blocks(struct super_block *sb,
		if (sbi->s_udfrev >= 0x0200)
		udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
		3, 1, epos.block.logicalBlockNum,
		sizeof(tag));
		sizeof(struct tag));
		else
		udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
		2, 1, epos.block.logicalBlockNum,
		sizeof(tag));
		sizeof(struct tag));

		switch (iinfo->i_alloc_type) {
		case ICBTAG_FLAG_AD_SHORT:
		sad = (short_ad *)sptr;
		sad = (struct short_ad *)sptr;
		sad->extLength = cpu_to_le32(
		EXT_NEXT_EXTENT_ALLOCDECS \|
		sb->s_blocksize);
		@@ -617,7 +617,7 @@ static void udf_table_free_blocks(struct super_block *sb,
		cpu_to_le32(epos.block.logicalBlockNum);
		break;
		case ICBTAG_FLAG_AD_LONG:
		lad = (long_ad *)sptr;
		lad = (struct long_ad *)sptr;
		lad->extLength = cpu_to_le32(
		EXT_NEXT_EXTENT_ALLOCDECS \|
		sb->s_blocksize);
		@@ -666,7 +666,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
		struct udf_sb_info *sbi = UDF_SB(sb);
		int alloc_count = 0;
		uint32_t elen, adsize;
		kernel_lb_addr eloc;
		struct kernel_lb_addr eloc;
		struct extent_position epos;
		int8_t etype = -1;
		struct udf_inode_info *iinfo;
		@@ -677,9 +677,9 @@ static int udf_table_prealloc_blocks(struct super_block *sb,

		iinfo = UDF_I(table);
		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
		adsize = sizeof(short_ad);
		adsize = sizeof(struct short_ad);
		else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
		adsize = sizeof(long_ad);
		adsize = sizeof(struct long_ad);
		else
		return 0;

		@@ -735,7 +735,7 @@ static int udf_table_new_block(struct super_block *sb,
		uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
		uint32_t newblock = 0, adsize;
		uint32_t elen, goal_elen = 0;
		kernel_lb_addr eloc, uninitialized_var(goal_eloc);
		struct kernel_lb_addr eloc, uninitialized_var(goal_eloc);
		struct extent_position epos, goal_epos;
		int8_t etype;
		struct udf_inode_info *iinfo = UDF_I(table);
		@@ -743,9 +743,9 @@ static int udf_table_new_block(struct super_block *sb,
		*err = -ENOSPC;

		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
		adsize = sizeof(short_ad);
		adsize = sizeof(struct short_ad);
		else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
		adsize = sizeof(long_ad);
		adsize = sizeof(struct long_ad);
		else
		return newblock;

		@@ -830,7 +830,7 @@ static int udf_table_new_block(struct super_block *sb,

		inline void udf_free_blocks(struct super_block *sb,
		struct inode *inode,
		kernel_lb_addr bloc, uint32_t offset,
		struct kernel_lb_addr bloc, uint32_t offset,
		uint32_t count)
		{
		uint16_t partition = bloc.partitionReferenceNum;

fs/udf/dir.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -51,7 +51,7 @@ static int do_udf_readdir(struct inode dir, struct file filp,
		uint8_t lfi;
		loff_t size = udf_ext0_offset(dir) + dir->i_size;
		struct buffer_head tmp, bha[16];
		kernel_lb_addr eloc;
		struct kernel_lb_addr eloc;
		uint32_t elen;
		sector_t offset;
		int i, num, ret = 0;
		@@ -83,10 +83,10 @@ static int do_udf_readdir(struct inode dir, struct file filp,
		block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
		if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
		epos.offset -= sizeof(short_ad);
		epos.offset -= sizeof(struct short_ad);
		else if (iinfo->i_alloc_type ==
		ICBTAG_FLAG_AD_LONG)
		epos.offset -= sizeof(long_ad);
		epos.offset -= sizeof(struct long_ad);
		} else {
		offset = 0;
		}
		@@ -161,7 +161,7 @@ static int do_udf_readdir(struct inode dir, struct file filp,
		memcpy(fname, "..", flen);
		dt_type = DT_DIR;
		} else {
		kernel_lb_addr tloc = lelb_to_cpu(cfi.icb.extLocation);
		struct kernel_lb_addr tloc = lelb_to_cpu(cfi.icb.extLocation);

		iblock = udf_get_lb_pblock(dir->i_sb, tloc, 0);
		flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi);

fs/udf/directory.c

+16 −16

Original line number	Diff line number	Diff line
		@@ -20,7 +20,7 @@

		#if 0
		static uint8_t udf_filead_read(struct inode dir, uint8_t *tmpad,
		uint8_t ad_size, kernel_lb_addr fe_loc,
		uint8_t ad_size, struct kernel_lb_addr fe_loc,
		int pos, int offset, struct buffer_head **bh,
		int *error)
		{
		@@ -75,7 +75,7 @@ struct fileIdentDesc udf_fileident_read(struct inode dir, loff_t *nf_pos,
		struct udf_fileident_bh *fibh,
		struct fileIdentDesc *cfi,
		struct extent_position *epos,
		kernel_lb_addr eloc, uint32_t elen,
		struct kernel_lb_addr eloc, uint32_t elen,
		sector_t *offset)
		{
		struct fileIdentDesc *fi;
		@@ -249,9 +249,9 @@ struct fileIdentDesc udf_get_fileident(void buffer, int bufsize, int *offset)
		}

		#if 0
		static extent_ad udf_get_fileextent(void buffer, int bufsize, int *offset)
		static struct extent_ad udf_get_fileextent(void buffer, int bufsize, int *offset)
		{
		extent_ad *ext;
		struct extent_ad *ext;
		struct fileEntry *fe;
		uint8_t *ptr;

		@@ -274,54 +274,54 @@ static extent_ad udf_get_fileextent(void buffer, int bufsize, int *offset)
		if ((offset > 0) && (offset < le32_to_cpu(fe->lengthAllocDescs)))
		ptr += *offset;

		ext = (extent_ad *)ptr;
		ext = (struct extent_ad *)ptr;

		offset = offset + sizeof(extent_ad);
		offset = offset + sizeof(struct extent_ad);
		return ext;
		}
		#endif

		short_ad udf_get_fileshortad(uint8_t ptr, int maxoffset, uint32_t *offset,
		struct short_ad udf_get_fileshortad(uint8_t ptr, int maxoffset, uint32_t *offset,
		int inc)
		{
		short_ad *sa;
		struct short_ad *sa;

		if ((!ptr) \|\| (!offset)) {
		printk(KERN_ERR "udf: udf_get_fileshortad() invalidparms\n");
		return NULL;
		}

		if ((*offset + sizeof(short_ad)) > maxoffset)
		if ((*offset + sizeof(struct short_ad)) > maxoffset)
		return NULL;
		else {
		sa = (short_ad *)ptr;
		sa = (struct short_ad *)ptr;
		if (sa->extLength == 0)
		return NULL;
		}

		if (inc)
		*offset += sizeof(short_ad);
		*offset += sizeof(struct short_ad);
		return sa;
		}

		long_ad udf_get_filelongad(uint8_t ptr, int maxoffset, uint32_t *offset, int inc)
		struct long_ad udf_get_filelongad(uint8_t ptr, int maxoffset, uint32_t *offset, int inc)
		{
		long_ad *la;
		struct long_ad *la;

		if ((!ptr) \|\| (!offset)) {
		printk(KERN_ERR "udf: udf_get_filelongad() invalidparms\n");
		return NULL;
		}

		if ((*offset + sizeof(long_ad)) > maxoffset)
		if ((*offset + sizeof(struct long_ad)) > maxoffset)
		return NULL;
		else {
		la = (long_ad *)ptr;
		la = (struct long_ad *)ptr;
		if (la->extLength == 0)
		return NULL;
		}

		if (inc)
		*offset += sizeof(long_ad);
		*offset += sizeof(struct long_ad);
		return la;
		}

fs/udf/ecma_167.h

+208 −208

Original line number	Diff line number	Diff line
		@@ -38,10 +38,10 @@
		#define _ECMA_167_H 1

		/* Character set specification (ECMA 167r3 1/7.2.1) */
		typedef struct {
		struct charspec {
		uint8_t charSetType;
		uint8_t charSetInfo[63];
		} __attribute__ ((packed)) charspec;
		} __attribute__ ((packed));

		/* Character Set Type (ECMA 167r3 1/7.2.1.1) */
		#define CHARSPEC_TYPE_CS0 0x00 /* (1/7.2.2) */
		@@ -57,7 +57,7 @@ typedef struct {
		typedef uint8_t dstring;

		/* Timestamp (ECMA 167r3 1/7.3) */
		typedef struct {
		struct timestamp {
		__le16 typeAndTimezone;
		__le16 year;
		uint8_t month;
		@@ -68,7 +68,7 @@ typedef struct {
		uint8_t centiseconds;
		uint8_t hundredsOfMicroseconds;
		uint8_t microseconds;
		} __attribute__ ((packed)) timestamp;
		} __attribute__ ((packed));

		/* Type and Time Zone (ECMA 167r3 1/7.3.1) */
		#define TIMESTAMP_TYPE_MASK 0xF000
		@@ -78,11 +78,11 @@ typedef struct {
		#define TIMESTAMP_TIMEZONE_MASK 0x0FFF

		/* Entity identifier (ECMA 167r3 1/7.4) */
		typedef struct {
		struct regid {
		uint8_t flags;
		uint8_t ident[23];
		uint8_t identSuffix[8];
		} __attribute__ ((packed)) regid;
		} __attribute__ ((packed));

		/* Flags (ECMA 167r3 1/7.4.1) */
		#define ENTITYID_FLAGS_DIRTY 0x00
		@@ -130,13 +130,13 @@ struct bootDesc {
		uint8_t stdIdent[VSD_STD_ID_LEN];
		uint8_t structVersion;
		uint8_t reserved1;
		regid archType;
		regid bootIdent;
		struct regid archType;
		struct regid bootIdent;
		__le32 bootExtLocation;
		__le32 bootExtLength;
		__le64 loadAddress;
		__le64 startAddress;
		timestamp descCreationDateAndTime;
		struct timestamp descCreationDateAndTime;
		__le16 flags;
		uint8_t reserved2[32];
		uint8_t bootUse[1906];
		@@ -146,18 +146,18 @@ struct bootDesc {
		#define BOOT_FLAGS_ERASE 0x01

		/* Extent Descriptor (ECMA 167r3 3/7.1) */
		typedef struct {
		struct extent_ad {
		__le32 extLength;
		__le32 extLocation;
		} __attribute__ ((packed)) extent_ad;
		} __attribute__ ((packed));

		typedef struct {
		struct kernel_extent_ad {
		uint32_t extLength;
		uint32_t extLocation;
		} kernel_extent_ad;
		};

		/* Descriptor Tag (ECMA 167r3 3/7.2) */
		typedef struct {
		struct tag {
		__le16 tagIdent;
		__le16 descVersion;
		uint8_t tagChecksum;
		@@ -166,7 +166,7 @@ typedef struct {
		__le16 descCRC;
		__le16 descCRCLength;
		__le32 tagLocation;
		} __attribute__ ((packed)) tag;
		} __attribute__ ((packed));

		/* Tag Identifier (ECMA 167r3 3/7.2.1) */
		#define TAG_IDENT_PVD 0x0001
		@@ -190,7 +190,7 @@ struct NSRDesc {

		/* Primary Volume Descriptor (ECMA 167r3 3/10.1) */
		struct primaryVolDesc {
		tag descTag;
		struct tag descTag;
		__le32 volDescSeqNum;
		__le32 primaryVolDescNum;
		dstring volIdent[32];
		@@ -201,13 +201,13 @@ struct primaryVolDesc {
		__le32 charSetList;
		__le32 maxCharSetList;
		dstring volSetIdent[128];
		charspec descCharSet;
		charspec explanatoryCharSet;
		extent_ad volAbstract;
		extent_ad volCopyright;
		regid appIdent;
		timestamp recordingDateAndTime;
		regid impIdent;
		struct charspec descCharSet;
		struct charspec explanatoryCharSet;
		struct extent_ad volAbstract;
		struct extent_ad volCopyright;
		struct regid appIdent;
		struct timestamp recordingDateAndTime;
		struct regid impIdent;
		uint8_t impUse[64];
		__le32 predecessorVolDescSeqLocation;
		__le16 flags;
		@@ -219,40 +219,40 @@ struct primaryVolDesc {

		/* Anchor Volume Descriptor Pointer (ECMA 167r3 3/10.2) */
		struct anchorVolDescPtr {
		tag descTag;
		extent_ad mainVolDescSeqExt;
		extent_ad reserveVolDescSeqExt;
		struct tag descTag;
		struct extent_ad mainVolDescSeqExt;
		struct extent_ad reserveVolDescSeqExt;
		uint8_t reserved[480];
		} __attribute__ ((packed));

		/* Volume Descriptor Pointer (ECMA 167r3 3/10.3) */
		struct volDescPtr {
		tag descTag;
		struct tag descTag;
		__le32 volDescSeqNum;
		extent_ad nextVolDescSeqExt;
		struct extent_ad nextVolDescSeqExt;
		uint8_t reserved[484];
		} __attribute__ ((packed));

		/* Implementation Use Volume Descriptor (ECMA 167r3 3/10.4) */
		struct impUseVolDesc {
		tag descTag;
		struct tag descTag;
		__le32 volDescSeqNum;
		regid impIdent;
		struct regid impIdent;
		uint8_t impUse[460];
		} __attribute__ ((packed));

		/* Partition Descriptor (ECMA 167r3 3/10.5) */
		struct partitionDesc {
		tag descTag;
		struct tag descTag;
		__le32 volDescSeqNum;
		__le16 partitionFlags;
		__le16 partitionNumber;
		regid partitionContents;
		struct regid partitionContents;
		uint8_t partitionContentsUse[128];
		__le32 accessType;
		__le32 partitionStartingLocation;
		__le32 partitionLength;
		regid impIdent;
		struct regid impIdent;
		uint8_t impUse[128];
		uint8_t reserved[156];
		} __attribute__ ((packed));
		@@ -278,18 +278,18 @@ struct partitionDesc {

		/* Logical Volume Descriptor (ECMA 167r3 3/10.6) */
		struct logicalVolDesc {
		tag descTag;
		struct tag descTag;
		__le32 volDescSeqNum;
		charspec descCharSet;
		struct charspec descCharSet;
		dstring logicalVolIdent[128];
		__le32 logicalBlockSize;
		regid domainIdent;
		struct regid domainIdent;
		uint8_t logicalVolContentsUse[16];
		__le32 mapTableLength;
		__le32 numPartitionMaps;
		regid impIdent;
		struct regid impIdent;
		uint8_t impUse[128];
		extent_ad integritySeqExt;
		struct extent_ad integritySeqExt;
		uint8_t partitionMaps[0];
		} __attribute__ ((packed));

		@@ -322,24 +322,24 @@ struct genericPartitionMap2 {

		/* Unallocated Space Descriptor (ECMA 167r3 3/10.8) */
		struct unallocSpaceDesc {
		tag descTag;
		struct tag descTag;
		__le32 volDescSeqNum;
		__le32 numAllocDescs;
		extent_ad allocDescs[0];
		struct extent_ad allocDescs[0];
		} __attribute__ ((packed));

		/* Terminating Descriptor (ECMA 167r3 3/10.9) */
		struct terminatingDesc {
		tag descTag;
		struct tag descTag;
		uint8_t reserved[496];
		} __attribute__ ((packed));

		/* Logical Volume Integrity Descriptor (ECMA 167r3 3/10.10) */
		struct logicalVolIntegrityDesc {
		tag descTag;
		timestamp recordingDateAndTime;
		struct tag descTag;
		struct timestamp recordingDateAndTime;
		__le32 integrityType;
		extent_ad nextIntegrityExt;
		struct extent_ad nextIntegrityExt;
		uint8_t logicalVolContentsUse[32];
		__le32 numOfPartitions;
		__le32 lengthOfImpUse;
		@@ -353,50 +353,50 @@ struct logicalVolIntegrityDesc {
		#define LVID_INTEGRITY_TYPE_CLOSE 0x00000001

		/* Recorded Address (ECMA 167r3 4/7.1) */
		typedef struct {
		struct lb_addr {
		__le32 logicalBlockNum;
		__le16 partitionReferenceNum;
		} __attribute__ ((packed)) lb_addr;
		} __attribute__ ((packed));

		/* ... and its in-core analog */
		typedef struct {
		struct kernel_lb_addr {
		uint32_t logicalBlockNum;
		uint16_t partitionReferenceNum;
		} kernel_lb_addr;
		};

		/* Short Allocation Descriptor (ECMA 167r3 4/14.14.1) */
		typedef struct {
		struct short_ad {
		__le32 extLength;
		__le32 extPosition;
		} __attribute__ ((packed)) short_ad;
		} __attribute__ ((packed));

		/* Long Allocation Descriptor (ECMA 167r3 4/14.14.2) */
		typedef struct {
		struct long_ad {
		__le32 extLength;
		lb_addr extLocation;
		struct lb_addr extLocation;
		uint8_t impUse[6];
		} __attribute__ ((packed)) long_ad;
		} __attribute__ ((packed));

		typedef struct {
		struct kernel_long_ad {
		uint32_t extLength;
		kernel_lb_addr extLocation;
		struct kernel_lb_addr extLocation;
		uint8_t impUse[6];
		} kernel_long_ad;
		};

		/* Extended Allocation Descriptor (ECMA 167r3 4/14.14.3) */
		typedef struct {
		struct ext_ad {
		__le32 extLength;
		__le32 recordedLength;
		__le32 informationLength;
		lb_addr extLocation;
		} __attribute__ ((packed)) ext_ad;
		struct lb_addr extLocation;
		} __attribute__ ((packed));

		typedef struct {
		struct kernel_ext_ad {
		uint32_t extLength;
		uint32_t recordedLength;
		uint32_t informationLength;
		kernel_lb_addr extLocation;
		} kernel_ext_ad;
		struct kernel_lb_addr extLocation;
		};

		/* Descriptor Tag (ECMA 167r3 4/7.2 - See 3/7.2) */

		@@ -415,44 +415,44 @@ typedef struct {

		/* File Set Descriptor (ECMA 167r3 4/14.1) */
		struct fileSetDesc {
		tag descTag;
		timestamp recordingDateAndTime;
		struct tag descTag;
		struct timestamp recordingDateAndTime;
		__le16 interchangeLvl;
		__le16 maxInterchangeLvl;
		__le32 charSetList;
		__le32 maxCharSetList;
		__le32 fileSetNum;
		__le32 fileSetDescNum;
		charspec logicalVolIdentCharSet;
		struct charspec logicalVolIdentCharSet;
		dstring logicalVolIdent[128];
		charspec fileSetCharSet;
		struct charspec fileSetCharSet;
		dstring fileSetIdent[32];
		dstring copyrightFileIdent[32];
		dstring abstractFileIdent[32];
		long_ad rootDirectoryICB;
		regid domainIdent;
		long_ad nextExt;
		long_ad streamDirectoryICB;
		struct long_ad rootDirectoryICB;
		struct regid domainIdent;
		struct long_ad nextExt;
		struct long_ad streamDirectoryICB;
		uint8_t reserved[32];
		} __attribute__ ((packed));

		/* Partition Header Descriptor (ECMA 167r3 4/14.3) */
		struct partitionHeaderDesc {
		short_ad unallocSpaceTable;
		short_ad unallocSpaceBitmap;
		short_ad partitionIntegrityTable;
		short_ad freedSpaceTable;
		short_ad freedSpaceBitmap;
		struct short_ad unallocSpaceTable;
		struct short_ad unallocSpaceBitmap;
		struct short_ad partitionIntegrityTable;
		struct short_ad freedSpaceTable;
		struct short_ad freedSpaceBitmap;
		uint8_t reserved[88];
		} __attribute__ ((packed));

		/* File Identifier Descriptor (ECMA 167r3 4/14.4) */
		struct fileIdentDesc {
		tag descTag;
		struct tag descTag;
		__le16 fileVersionNum;
		uint8_t fileCharacteristics;
		uint8_t lengthFileIdent;
		long_ad icb;
		struct long_ad icb;
		__le16 lengthOfImpUse;
		uint8_t impUse[0];
		uint8_t fileIdent[0];
		@@ -468,22 +468,22 @@ struct fileIdentDesc {

		/* Allocation Ext Descriptor (ECMA 167r3 4/14.5) */
		struct allocExtDesc {
		tag descTag;
		struct tag descTag;
		__le32 previousAllocExtLocation;
		__le32 lengthAllocDescs;
		} __attribute__ ((packed));

		/* ICB Tag (ECMA 167r3 4/14.6) */
		typedef struct {
		struct icbtag {
		__le32 priorRecordedNumDirectEntries;
		__le16 strategyType;
		__le16 strategyParameter;
		__le16 numEntries;
		uint8_t reserved;
		uint8_t fileType;
		lb_addr parentICBLocation;
		struct lb_addr parentICBLocation;
		__le16 flags;
		} __attribute__ ((packed)) icbtag;
		} __attribute__ ((packed));

		/* Strategy Type (ECMA 167r3 4/14.6.2) */
		#define ICBTAG_STRATEGY_TYPE_UNDEF 0x0000
		@@ -528,21 +528,21 @@ typedef struct {

		/* Indirect Entry (ECMA 167r3 4/14.7) */
		struct indirectEntry {
		tag descTag;
		icbtag icbTag;
		long_ad indirectICB;
		struct tag descTag;
		struct icbtag icbTag;
		struct long_ad indirectICB;
		} __attribute__ ((packed));

		/* Terminal Entry (ECMA 167r3 4/14.8) */
		struct terminalEntry {
		tag descTag;
		icbtag icbTag;
		struct tag descTag;
		struct icbtag icbTag;
		} __attribute__ ((packed));

		/* File Entry (ECMA 167r3 4/14.9) */
		struct fileEntry {
		tag descTag;
		icbtag icbTag;
		struct tag descTag;
		struct icbtag icbTag;
		__le32 uid;
		__le32 gid;
		__le32 permissions;
		@@ -552,12 +552,12 @@ struct fileEntry {
		__le32 recordLength;
		__le64 informationLength;
		__le64 logicalBlocksRecorded;
		timestamp accessTime;
		timestamp modificationTime;
		timestamp attrTime;
		struct timestamp accessTime;
		struct timestamp modificationTime;
		struct timestamp attrTime;
		__le32 checkpoint;
		long_ad extendedAttrICB;
		regid impIdent;
		struct long_ad extendedAttrICB;
		struct regid impIdent;
		__le64 uniqueID;
		__le32 lengthExtendedAttr;
		__le32 lengthAllocDescs;
		@@ -604,7 +604,7 @@ struct fileEntry {

		/* Extended Attribute Header Descriptor (ECMA 167r3 4/14.10.1) */
		struct extendedAttrHeaderDesc {
		tag descTag;
		struct tag descTag;
		__le32 impAttrLocation;
		__le32 appAttrLocation;
		} __attribute__ ((packed));
		@@ -687,7 +687,7 @@ struct impUseExtAttr {
		uint8_t reserved[3];
		__le32 attrLength;
		__le32 impUseLength;
		regid impIdent;
		struct regid impIdent;
		uint8_t impUse[0];
		} __attribute__ ((packed));

		@@ -698,7 +698,7 @@ struct appUseExtAttr {
		uint8_t reserved[3];
		__le32 attrLength;
		__le32 appUseLength;
		regid appIdent;
		struct regid appIdent;
		uint8_t appUse[0];
		} __attribute__ ((packed));

		@@ -712,15 +712,15 @@ struct appUseExtAttr {

		/* Unallocated Space Entry (ECMA 167r3 4/14.11) */
		struct unallocSpaceEntry {
		tag descTag;
		icbtag icbTag;
		struct tag descTag;
		struct icbtag icbTag;
		__le32 lengthAllocDescs;
		uint8_t allocDescs[0];
		} __attribute__ ((packed));

		/* Space Bitmap Descriptor (ECMA 167r3 4/14.12) */
		struct spaceBitmapDesc {
		tag descTag;
		struct tag descTag;
		__le32 numOfBits;
		__le32 numOfBytes;
		uint8_t bitmap[0];
		@@ -728,12 +728,12 @@ struct spaceBitmapDesc {

		/* Partition Integrity Entry (ECMA 167r3 4/14.13) */
		struct partitionIntegrityEntry {
		tag descTag;
		icbtag icbTag;
		timestamp recordingDateAndTime;
		struct tag descTag;
		struct icbtag icbTag;
		struct timestamp recordingDateAndTime;
		uint8_t integrityType;
		uint8_t reserved[175];
		regid impIdent;
		struct regid impIdent;
		uint8_t impUse[256];
		} __attribute__ ((packed));

		@@ -765,8 +765,8 @@ struct pathComponent {

		/* File Entry (ECMA 167r3 4/14.17) */
		struct extendedFileEntry {
		tag descTag;
		icbtag icbTag;
		struct tag descTag;
		struct icbtag icbTag;
		__le32 uid;
		__le32 gid;
		__le32 permissions;
		@@ -777,15 +777,15 @@ struct extendedFileEntry {
		__le64 informationLength;
		__le64 objectSize;
		__le64 logicalBlocksRecorded;
		timestamp accessTime;
		timestamp modificationTime;
		timestamp createTime;
		timestamp attrTime;
		struct timestamp accessTime;
		struct timestamp modificationTime;
		struct timestamp createTime;
		struct timestamp attrTime;
		__le32 checkpoint;
		__le32 reserved;
		long_ad extendedAttrICB;
		long_ad streamDirectoryICB;
		regid impIdent;
		struct long_ad extendedAttrICB;
		struct long_ad streamDirectoryICB;
		struct regid impIdent;
		__le64 uniqueID;
		__le32 lengthExtendedAttr;
		__le32 lengthAllocDescs;

fs/udf/inode.c

+70 −70

File changed.

Preview size limit exceeded, changes collapsed.

Admin message