← Back to branch summary

~ubuntu-branches/ubuntu/lucid/linux-rt/lucid

« back to all changes in this revision

Viewing changes to fs/udf/ecma_167.h

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich
  • Date: 2009-08-05 23:00:52 UTC
  • Revision ID: james.westby@ubuntu.com-20090805230052-7xedvqcyk9dnnxb2
Tags: 2.6.31-1.1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/udf/ecma_167.h
38
38
#define _ECMA_167_H 1
39
39
 
40
40
/* Character set specification (ECMA 167r3 1/7.2.1) */
41
 
typedef struct {
 
41
struct charspec {
42
42
        uint8_t         charSetType;
43
43
        uint8_t         charSetInfo[63];
44
 
} __attribute__ ((packed)) charspec;
 
44
} __attribute__ ((packed));
45
45
 
46
46
/* Character Set Type (ECMA 167r3 1/7.2.1.1) */
47
47
#define CHARSPEC_TYPE_CS0               0x00    /* (1/7.2.2) */
57
57
typedef uint8_t         dstring;
58
58
 
59
59
/* Timestamp (ECMA 167r3 1/7.3) */
60
 
typedef struct {
 
60
struct timestamp {
61
61
        __le16          typeAndTimezone;
62
62
        __le16          year;
63
63
        uint8_t         month;
68
68
        uint8_t         centiseconds;
69
69
        uint8_t         hundredsOfMicroseconds;
70
70
        uint8_t         microseconds;
71
 
} __attribute__ ((packed)) timestamp;
 
71
} __attribute__ ((packed));
72
72
 
73
73
/* Type and Time Zone (ECMA 167r3 1/7.3.1) */
74
74
#define TIMESTAMP_TYPE_MASK             0xF000
78
78
#define TIMESTAMP_TIMEZONE_MASK         0x0FFF
79
79
 
80
80
/* Entity identifier (ECMA 167r3 1/7.4) */
81
 
typedef struct {
 
81
struct regid {
82
82
        uint8_t         flags;
83
83
        uint8_t         ident[23];
84
84
        uint8_t         identSuffix[8];
85
 
} __attribute__ ((packed)) regid;
 
85
} __attribute__ ((packed));
86
86
 
87
87
/* Flags (ECMA 167r3 1/7.4.1) */
88
88
#define ENTITYID_FLAGS_DIRTY            0x00
126
126
 
127
127
/* Boot Descriptor (ECMA 167r3 2/9.4) */
128
128
struct bootDesc {
129
 
        uint8_t         structType;
130
 
        uint8_t         stdIdent[VSD_STD_ID_LEN];
131
 
        uint8_t         structVersion;
132
 
        uint8_t         reserved1;
133
 
        regid           archType;
134
 
        regid           bootIdent;
135
 
        __le32          bootExtLocation;
136
 
        __le32          bootExtLength;
137
 
        __le64          loadAddress;
138
 
        __le64          startAddress;
139
 
        timestamp       descCreationDateAndTime;
140
 
        __le16          flags;
141
 
        uint8_t         reserved2[32];
142
 
        uint8_t         bootUse[1906];
 
129
        uint8_t                 structType;
 
130
        uint8_t                 stdIdent[VSD_STD_ID_LEN];
 
131
        uint8_t                 structVersion;
 
132
        uint8_t                 reserved1;
 
133
        struct regid            archType;
 
134
        struct regid            bootIdent;
 
135
        __le32                  bootExtLocation;
 
136
        __le32                  bootExtLength;
 
137
        __le64                  loadAddress;
 
138
        __le64                  startAddress;
 
139
        struct timestamp        descCreationDateAndTime;
 
140
        __le16                  flags;
 
141
        uint8_t                 reserved2[32];
 
142
        uint8_t                 bootUse[1906];
143
143
} __attribute__ ((packed));
144
144
 
145
145
/* Flags (ECMA 167r3 2/9.4.12) */
146
146
#define BOOT_FLAGS_ERASE                0x01
147
147
 
148
148
/* Extent Descriptor (ECMA 167r3 3/7.1) */
149
 
typedef struct {
 
149
struct extent_ad {
150
150
        __le32          extLength;
151
151
        __le32          extLocation;
152
 
} __attribute__ ((packed)) extent_ad;
 
152
} __attribute__ ((packed));
153
153
 
154
 
typedef struct {
 
154
struct kernel_extent_ad {
155
155
        uint32_t        extLength;
156
156
        uint32_t        extLocation;
157
 
} kernel_extent_ad;
 
157
};
158
158
 
159
159
/* Descriptor Tag (ECMA 167r3 3/7.2) */
160
 
typedef struct {
 
160
struct tag {
161
161
        __le16          tagIdent;
162
162
        __le16          descVersion;
163
163
        uint8_t         tagChecksum;
166
166
        __le16          descCRC;
167
167
        __le16          descCRCLength;
168
168
        __le32          tagLocation;
169
 
} __attribute__ ((packed)) tag;
 
169
} __attribute__ ((packed));
170
170
 
171
171
/* Tag Identifier (ECMA 167r3 3/7.2.1) */
172
172
#define TAG_IDENT_PVD                   0x0001
190
190
 
191
191
/* Primary Volume Descriptor (ECMA 167r3 3/10.1) */
192
192
struct primaryVolDesc {
193
 
        tag             descTag;
194
 
        __le32          volDescSeqNum;
195
 
        __le32          primaryVolDescNum;
196
 
        dstring         volIdent[32];
197
 
        __le16          volSeqNum;
198
 
        __le16          maxVolSeqNum;
199
 
        __le16          interchangeLvl;
200
 
        __le16          maxInterchangeLvl;
201
 
        __le32          charSetList;
202
 
        __le32          maxCharSetList;
203
 
        dstring         volSetIdent[128];
204
 
        charspec        descCharSet;
205
 
        charspec        explanatoryCharSet;
206
 
        extent_ad       volAbstract;
207
 
        extent_ad       volCopyright;
208
 
        regid           appIdent;
209
 
        timestamp       recordingDateAndTime;
210
 
        regid           impIdent;
211
 
        uint8_t         impUse[64];
212
 
        __le32          predecessorVolDescSeqLocation;
213
 
        __le16          flags;
214
 
        uint8_t         reserved[22];
 
193
        struct tag              descTag;
 
194
        __le32                  volDescSeqNum;
 
195
        __le32                  primaryVolDescNum;
 
196
        dstring                 volIdent[32];
 
197
        __le16                  volSeqNum;
 
198
        __le16                  maxVolSeqNum;
 
199
        __le16                  interchangeLvl;
 
200
        __le16                  maxInterchangeLvl;
 
201
        __le32                  charSetList;
 
202
        __le32                  maxCharSetList;
 
203
        dstring                 volSetIdent[128];
 
204
        struct charspec         descCharSet;
 
205
        struct charspec         explanatoryCharSet;
 
206
        struct extent_ad        volAbstract;
 
207
        struct extent_ad        volCopyright;
 
208
        struct regid            appIdent;
 
209
        struct timestamp        recordingDateAndTime;
 
210
        struct regid            impIdent;
 
211
        uint8_t                 impUse[64];
 
212
        __le32                  predecessorVolDescSeqLocation;
 
213
        __le16                  flags;
 
214
        uint8_t                 reserved[22];
215
215
} __attribute__ ((packed));
216
216
 
217
217
/* Flags (ECMA 167r3 3/10.1.21) */
219
219
 
220
220
/* Anchor Volume Descriptor Pointer (ECMA 167r3 3/10.2) */
221
221
struct anchorVolDescPtr {
222
 
        tag             descTag;
223
 
        extent_ad       mainVolDescSeqExt;
224
 
        extent_ad       reserveVolDescSeqExt;
225
 
        uint8_t         reserved[480];
 
222
        struct tag              descTag;
 
223
        struct extent_ad        mainVolDescSeqExt;
 
224
        struct extent_ad        reserveVolDescSeqExt;
 
225
        uint8_t                 reserved[480];
226
226
} __attribute__ ((packed));
227
227
 
228
228
/* Volume Descriptor Pointer (ECMA 167r3 3/10.3) */
229
229
struct volDescPtr {
230
 
        tag             descTag;
231
 
        __le32          volDescSeqNum;
232
 
        extent_ad       nextVolDescSeqExt;
233
 
        uint8_t         reserved[484];
 
230
        struct tag              descTag;
 
231
        __le32                  volDescSeqNum;
 
232
        struct extent_ad        nextVolDescSeqExt;
 
233
        uint8_t                 reserved[484];
234
234
} __attribute__ ((packed));
235
235
 
236
236
/* Implementation Use Volume Descriptor (ECMA 167r3 3/10.4) */
237
237
struct impUseVolDesc {
238
 
        tag             descTag;
 
238
        struct tag      descTag;
239
239
        __le32          volDescSeqNum;
240
 
        regid           impIdent;
 
240
        struct regid    impIdent;
241
241
        uint8_t         impUse[460];
242
242
} __attribute__ ((packed));
243
243
 
244
244
/* Partition Descriptor (ECMA 167r3 3/10.5) */
245
245
struct partitionDesc {
246
 
        tag descTag;
 
246
        struct tag descTag;
247
247
        __le32 volDescSeqNum;
248
248
        __le16 partitionFlags;
249
249
        __le16 partitionNumber;
250
 
        regid partitionContents;
 
250
        struct regid partitionContents;
251
251
        uint8_t partitionContentsUse[128];
252
252
        __le32 accessType;
253
253
        __le32 partitionStartingLocation;
254
254
        __le32 partitionLength;
255
 
        regid impIdent;
 
255
        struct regid impIdent;
256
256
        uint8_t impUse[128];
257
257
        uint8_t reserved[156];
258
258
} __attribute__ ((packed));
278
278
 
279
279
/* Logical Volume Descriptor (ECMA 167r3 3/10.6) */
280
280
struct logicalVolDesc {
281
 
        tag             descTag;
282
 
        __le32          volDescSeqNum;
283
 
        charspec        descCharSet;
284
 
        dstring         logicalVolIdent[128];
285
 
        __le32          logicalBlockSize;
286
 
        regid           domainIdent;
287
 
        uint8_t         logicalVolContentsUse[16];
288
 
        __le32          mapTableLength;
289
 
        __le32          numPartitionMaps;
290
 
        regid           impIdent;
291
 
        uint8_t         impUse[128];
292
 
        extent_ad       integritySeqExt;
293
 
        uint8_t         partitionMaps[0];
 
281
        struct tag              descTag;
 
282
        __le32                  volDescSeqNum;
 
283
        struct charspec         descCharSet;
 
284
        dstring                 logicalVolIdent[128];
 
285
        __le32                  logicalBlockSize;
 
286
        struct regid            domainIdent;
 
287
        uint8_t                 logicalVolContentsUse[16];
 
288
        __le32                  mapTableLength;
 
289
        __le32                  numPartitionMaps;
 
290
        struct regid            impIdent;
 
291
        uint8_t                 impUse[128];
 
292
        struct extent_ad        integritySeqExt;
 
293
        uint8_t                 partitionMaps[0];
294
294
} __attribute__ ((packed));
295
295
 
296
296
/* Generic Partition Map (ECMA 167r3 3/10.7.1) */
322
322
 
323
323
/* Unallocated Space Descriptor (ECMA 167r3 3/10.8) */
324
324
struct unallocSpaceDesc {
325
 
        tag             descTag;
326
 
        __le32          volDescSeqNum;
327
 
        __le32          numAllocDescs;
328
 
        extent_ad       allocDescs[0];
 
325
        struct tag              descTag;
 
326
        __le32                  volDescSeqNum;
 
327
        __le32                  numAllocDescs;
 
328
        struct extent_ad        allocDescs[0];
329
329
} __attribute__ ((packed));
330
330
 
331
331
/* Terminating Descriptor (ECMA 167r3 3/10.9) */
332
332
struct terminatingDesc {
333
 
        tag             descTag;
 
333
        struct tag      descTag;
334
334
        uint8_t         reserved[496];
335
335
} __attribute__ ((packed));
336
336
 
337
337
/* Logical Volume Integrity Descriptor (ECMA 167r3 3/10.10) */
338
338
struct logicalVolIntegrityDesc {
339
 
        tag             descTag;
340
 
        timestamp       recordingDateAndTime;
341
 
        __le32          integrityType;
342
 
        extent_ad       nextIntegrityExt;
343
 
        uint8_t         logicalVolContentsUse[32];
344
 
        __le32          numOfPartitions;
345
 
        __le32          lengthOfImpUse;
346
 
        __le32          freeSpaceTable[0];
347
 
        __le32          sizeTable[0];
348
 
        uint8_t         impUse[0];
 
339
        struct tag              descTag;
 
340
        struct timestamp        recordingDateAndTime;
 
341
        __le32                  integrityType;
 
342
        struct extent_ad        nextIntegrityExt;
 
343
        uint8_t                 logicalVolContentsUse[32];
 
344
        __le32                  numOfPartitions;
 
345
        __le32                  lengthOfImpUse;
 
346
        __le32                  freeSpaceTable[0];
 
347
        __le32                  sizeTable[0];
 
348
        uint8_t                 impUse[0];
349
349
} __attribute__ ((packed));
350
350
 
351
351
/* Integrity Type (ECMA 167r3 3/10.10.3) */
353
353
#define LVID_INTEGRITY_TYPE_CLOSE       0x00000001
354
354
 
355
355
/* Recorded Address (ECMA 167r3 4/7.1) */
356
 
typedef struct {
 
356
struct lb_addr {
357
357
        __le32          logicalBlockNum;
358
358
        __le16          partitionReferenceNum;
359
 
} __attribute__ ((packed)) lb_addr;
 
359
} __attribute__ ((packed));
360
360
 
361
361
/* ... and its in-core analog */
362
 
typedef struct {
 
362
struct kernel_lb_addr {
363
363
        uint32_t                logicalBlockNum;
364
364
        uint16_t                partitionReferenceNum;
365
 
} kernel_lb_addr;
 
365
};
366
366
 
367
367
/* Short Allocation Descriptor (ECMA 167r3 4/14.14.1) */
368
 
typedef struct {
 
368
struct short_ad {
369
369
        __le32          extLength;
370
370
        __le32          extPosition;
371
 
} __attribute__ ((packed)) short_ad;
 
371
} __attribute__ ((packed));
372
372
 
373
373
/* Long Allocation Descriptor (ECMA 167r3 4/14.14.2) */
374
 
typedef struct {
 
374
struct long_ad {
375
375
        __le32          extLength;
376
 
        lb_addr         extLocation;
 
376
        struct lb_addr  extLocation;
377
377
        uint8_t         impUse[6];
378
 
} __attribute__ ((packed)) long_ad;
 
378
} __attribute__ ((packed));
379
379
 
380
 
typedef struct {
381
 
        uint32_t        extLength;
382
 
        kernel_lb_addr  extLocation;
383
 
        uint8_t         impUse[6];
384
 
} kernel_long_ad;
 
380
struct kernel_long_ad {
 
381
        uint32_t                extLength;
 
382
        struct kernel_lb_addr   extLocation;
 
383
        uint8_t                 impUse[6];
 
384
};
385
385
 
386
386
/* Extended Allocation Descriptor (ECMA 167r3 4/14.14.3) */
387
 
typedef struct {
 
387
struct ext_ad {
388
388
        __le32          extLength;
389
389
        __le32          recordedLength;
390
390
        __le32          informationLength;
391
 
        lb_addr         extLocation;
392
 
} __attribute__ ((packed)) ext_ad;
 
391
        struct lb_addr  extLocation;
 
392
} __attribute__ ((packed));
393
393
 
394
 
typedef struct {
395
 
        uint32_t        extLength;
396
 
        uint32_t        recordedLength;
397
 
        uint32_t        informationLength;
398
 
        kernel_lb_addr  extLocation;
399
 
} kernel_ext_ad;
 
394
struct kernel_ext_ad {
 
395
        uint32_t                extLength;
 
396
        uint32_t                recordedLength;
 
397
        uint32_t                informationLength;
 
398
        struct kernel_lb_addr   extLocation;
 
399
};
400
400
 
401
401
/* Descriptor Tag (ECMA 167r3 4/7.2 - See 3/7.2) */
402
402
 
415
415
 
416
416
/* File Set Descriptor (ECMA 167r3 4/14.1) */
417
417
struct fileSetDesc {
418
 
        tag             descTag;
419
 
        timestamp       recordingDateAndTime;
420
 
        __le16          interchangeLvl;
421
 
        __le16          maxInterchangeLvl;
422
 
        __le32          charSetList;
423
 
        __le32          maxCharSetList;
424
 
        __le32          fileSetNum;
425
 
        __le32          fileSetDescNum;
426
 
        charspec        logicalVolIdentCharSet;
427
 
        dstring         logicalVolIdent[128];
428
 
        charspec        fileSetCharSet;
429
 
        dstring         fileSetIdent[32];
430
 
        dstring         copyrightFileIdent[32];
431
 
        dstring         abstractFileIdent[32];
432
 
        long_ad         rootDirectoryICB;
433
 
        regid           domainIdent;
434
 
        long_ad         nextExt;
435
 
        long_ad         streamDirectoryICB;
436
 
        uint8_t         reserved[32];
 
418
        struct tag              descTag;
 
419
        struct timestamp        recordingDateAndTime;
 
420
        __le16                  interchangeLvl;
 
421
        __le16                  maxInterchangeLvl;
 
422
        __le32                  charSetList;
 
423
        __le32                  maxCharSetList;
 
424
        __le32                  fileSetNum;
 
425
        __le32                  fileSetDescNum;
 
426
        struct charspec         logicalVolIdentCharSet;
 
427
        dstring                 logicalVolIdent[128];
 
428
        struct charspec         fileSetCharSet;
 
429
        dstring                 fileSetIdent[32];
 
430
        dstring                 copyrightFileIdent[32];
 
431
        dstring                 abstractFileIdent[32];
 
432
        struct long_ad          rootDirectoryICB;
 
433
        struct regid            domainIdent;
 
434
        struct long_ad          nextExt;
 
435
        struct long_ad          streamDirectoryICB;
 
436
        uint8_t                 reserved[32];
437
437
} __attribute__ ((packed));
438
438
 
439
439
/* Partition Header Descriptor (ECMA 167r3 4/14.3) */
440
440
struct partitionHeaderDesc {
441
 
        short_ad        unallocSpaceTable;
442
 
        short_ad        unallocSpaceBitmap;
443
 
        short_ad        partitionIntegrityTable;
444
 
        short_ad        freedSpaceTable;
445
 
        short_ad        freedSpaceBitmap;
 
441
        struct short_ad unallocSpaceTable;
 
442
        struct short_ad unallocSpaceBitmap;
 
443
        struct short_ad partitionIntegrityTable;
 
444
        struct short_ad freedSpaceTable;
 
445
        struct short_ad freedSpaceBitmap;
446
446
        uint8_t         reserved[88];
447
447
} __attribute__ ((packed));
448
448
 
449
449
/* File Identifier Descriptor (ECMA 167r3 4/14.4) */
450
450
struct fileIdentDesc {
451
 
        tag             descTag;
 
451
        struct tag      descTag;
452
452
        __le16          fileVersionNum;
453
453
        uint8_t         fileCharacteristics;
454
454
        uint8_t         lengthFileIdent;
455
 
        long_ad         icb;
 
455
        struct long_ad  icb;
456
456
        __le16          lengthOfImpUse;
457
457
        uint8_t         impUse[0];
458
458
        uint8_t         fileIdent[0];
468
468
 
469
469
/* Allocation Ext Descriptor (ECMA 167r3 4/14.5) */
470
470
struct allocExtDesc {
471
 
        tag             descTag;
 
471
        struct tag      descTag;
472
472
        __le32          previousAllocExtLocation;
473
473
        __le32          lengthAllocDescs;
474
474
} __attribute__ ((packed));
475
475
 
476
476
/* ICB Tag (ECMA 167r3 4/14.6) */
477
 
typedef struct {
 
477
struct icbtag {
478
478
        __le32          priorRecordedNumDirectEntries;
479
479
        __le16          strategyType;
480
480
        __le16          strategyParameter;
481
481
        __le16          numEntries;
482
482
        uint8_t         reserved;
483
483
        uint8_t         fileType;
484
 
        lb_addr         parentICBLocation;
 
484
        struct lb_addr  parentICBLocation;
485
485
        __le16          flags;
486
 
} __attribute__ ((packed)) icbtag;
 
486
} __attribute__ ((packed));
487
487
 
488
488
/* Strategy Type (ECMA 167r3 4/14.6.2) */
489
489
#define ICBTAG_STRATEGY_TYPE_UNDEF      0x0000
528
528
 
529
529
/* Indirect Entry (ECMA 167r3 4/14.7) */
530
530
struct indirectEntry {
531
 
        tag             descTag;
532
 
        icbtag          icbTag;
533
 
        long_ad         indirectICB;
 
531
        struct tag      descTag;
 
532
        struct icbtag   icbTag;
 
533
        struct long_ad  indirectICB;
534
534
} __attribute__ ((packed));
535
535
 
536
536
/* Terminal Entry (ECMA 167r3 4/14.8) */
537
537
struct terminalEntry {
538
 
        tag             descTag;
539
 
        icbtag          icbTag;
 
538
        struct tag      descTag;
 
539
        struct icbtag   icbTag;
540
540
} __attribute__ ((packed));
541
541
 
542
542
/* File Entry (ECMA 167r3 4/14.9) */
543
543
struct fileEntry {
544
 
        tag             descTag;
545
 
        icbtag          icbTag;
546
 
        __le32          uid;
547
 
        __le32          gid;
548
 
        __le32          permissions;
549
 
        __le16          fileLinkCount;
550
 
        uint8_t         recordFormat;
551
 
        uint8_t         recordDisplayAttr;
552
 
        __le32          recordLength;
553
 
        __le64          informationLength;
554
 
        __le64          logicalBlocksRecorded;
555
 
        timestamp       accessTime;
556
 
        timestamp       modificationTime;
557
 
        timestamp       attrTime;
558
 
        __le32          checkpoint;
559
 
        long_ad         extendedAttrICB;
560
 
        regid           impIdent;
561
 
        __le64          uniqueID;
562
 
        __le32          lengthExtendedAttr;
563
 
        __le32          lengthAllocDescs;
564
 
        uint8_t         extendedAttr[0];
565
 
        uint8_t         allocDescs[0];
 
544
        struct tag              descTag;
 
545
        struct icbtag           icbTag;
 
546
        __le32                  uid;
 
547
        __le32                  gid;
 
548
        __le32                  permissions;
 
549
        __le16                  fileLinkCount;
 
550
        uint8_t                 recordFormat;
 
551
        uint8_t                 recordDisplayAttr;
 
552
        __le32                  recordLength;
 
553
        __le64                  informationLength;
 
554
        __le64                  logicalBlocksRecorded;
 
555
        struct timestamp        accessTime;
 
556
        struct timestamp        modificationTime;
 
557
        struct timestamp        attrTime;
 
558
        __le32                  checkpoint;
 
559
        struct long_ad          extendedAttrICB;
 
560
        struct regid            impIdent;
 
561
        __le64                  uniqueID;
 
562
        __le32                  lengthExtendedAttr;
 
563
        __le32                  lengthAllocDescs;
 
564
        uint8_t                 extendedAttr[0];
 
565
        uint8_t                 allocDescs[0];
566
566
} __attribute__ ((packed));
567
567
 
568
568
/* Permissions (ECMA 167r3 4/14.9.5) */
604
604
 
605
605
/* Extended Attribute Header Descriptor (ECMA 167r3 4/14.10.1) */
606
606
struct extendedAttrHeaderDesc {
607
 
        tag             descTag;
 
607
        struct tag      descTag;
608
608
        __le32          impAttrLocation;
609
609
        __le32          appAttrLocation;
610
610
} __attribute__ ((packed));
687
687
        uint8_t         reserved[3];
688
688
        __le32          attrLength;
689
689
        __le32          impUseLength;
690
 
        regid           impIdent;
 
690
        struct regid    impIdent;
691
691
        uint8_t         impUse[0];
692
692
} __attribute__ ((packed));
693
693
 
698
698
        uint8_t         reserved[3];
699
699
        __le32          attrLength;
700
700
        __le32          appUseLength;
701
 
        regid           appIdent;
 
701
        struct regid    appIdent;
702
702
        uint8_t         appUse[0];
703
703
} __attribute__ ((packed));
704
704
 
712
712
 
713
713
/* Unallocated Space Entry (ECMA 167r3 4/14.11) */
714
714
struct unallocSpaceEntry {
715
 
        tag             descTag;
716
 
        icbtag          icbTag;
 
715
        struct tag      descTag;
 
716
        struct icbtag   icbTag;
717
717
        __le32          lengthAllocDescs;
718
718
        uint8_t         allocDescs[0];
719
719
} __attribute__ ((packed));
720
720
 
721
721
/* Space Bitmap Descriptor (ECMA 167r3 4/14.12) */
722
722
struct spaceBitmapDesc {
723
 
        tag             descTag;
 
723
        struct tag      descTag;
724
724
        __le32          numOfBits;
725
725
        __le32          numOfBytes;
726
726
        uint8_t         bitmap[0];
728
728
 
729
729
/* Partition Integrity Entry (ECMA 167r3 4/14.13) */
730
730
struct partitionIntegrityEntry {
731
 
        tag             descTag;
732
 
        icbtag          icbTag;
733
 
        timestamp       recordingDateAndTime;
734
 
        uint8_t         integrityType;
735
 
        uint8_t         reserved[175];
736
 
        regid           impIdent;
737
 
        uint8_t         impUse[256];
 
731
        struct tag              descTag;
 
732
        struct icbtag           icbTag;
 
733
        struct timestamp        recordingDateAndTime;
 
734
        uint8_t                 integrityType;
 
735
        uint8_t                 reserved[175];
 
736
        struct regid            impIdent;
 
737
        uint8_t                 impUse[256];
738
738
} __attribute__ ((packed));
739
739
 
740
740
/* Short Allocation Descriptor (ECMA 167r3 4/14.14.1) */
765
765
 
766
766
/* File Entry (ECMA 167r3 4/14.17) */
767
767
struct extendedFileEntry {
768
 
        tag             descTag;
769
 
        icbtag          icbTag;
770
 
        __le32          uid;
771
 
        __le32          gid;
772
 
        __le32          permissions;
773
 
        __le16          fileLinkCount;
774
 
        uint8_t         recordFormat;
775
 
        uint8_t         recordDisplayAttr;
776
 
        __le32          recordLength;
777
 
        __le64          informationLength;
778
 
        __le64          objectSize;
779
 
        __le64          logicalBlocksRecorded;
780
 
        timestamp       accessTime;
781
 
        timestamp       modificationTime;
782
 
        timestamp       createTime;
783
 
        timestamp       attrTime;
784
 
        __le32          checkpoint;
785
 
        __le32          reserved;
786
 
        long_ad         extendedAttrICB;
787
 
        long_ad         streamDirectoryICB;
788
 
        regid           impIdent;
789
 
        __le64          uniqueID;
790
 
        __le32          lengthExtendedAttr;
791
 
        __le32          lengthAllocDescs;
792
 
        uint8_t         extendedAttr[0];
793
 
        uint8_t         allocDescs[0];
 
768
        struct tag              descTag;
 
769
        struct icbtag           icbTag;
 
770
        __le32                  uid;
 
771
        __le32                  gid;
 
772
        __le32                  permissions;
 
773
        __le16                  fileLinkCount;
 
774
        uint8_t                 recordFormat;
 
775
        uint8_t                 recordDisplayAttr;
 
776
        __le32                  recordLength;
 
777
        __le64                  informationLength;
 
778
        __le64                  objectSize;
 
779
        __le64                  logicalBlocksRecorded;
 
780
        struct timestamp        accessTime;
 
781
        struct timestamp        modificationTime;
 
782
        struct timestamp        createTime;
 
783
        struct timestamp        attrTime;
 
784
        __le32                  checkpoint;
 
785
        __le32                  reserved;
 
786
        struct long_ad          extendedAttrICB;
 
787
        struct long_ad          streamDirectoryICB;
 
788
        struct regid            impIdent;
 
789
        __le64                  uniqueID;
 
790
        __le32                  lengthExtendedAttr;
 
791
        __le32                  lengthAllocDescs;
 
792
        uint8_t                 extendedAttr[0];
 
793
        uint8_t                 allocDescs[0];
794
794
} __attribute__ ((packed));
795
795
 
796
796
#endif /* _ECMA_167_H */