1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * linux/fs/hpfs/hpfs.h |
4 | * |
5 | * HPFS structures by Chris Smith, 1993 |
6 | * |
7 | * a little bit modified by Mikulas Patocka, 1998-1999 |
8 | */ |
9 | |
10 | /* The paper |
11 | |
12 | Duncan, Roy |
13 | Design goals and implementation of the new High Performance File System |
14 | Microsoft Systems Journal Sept 1989 v4 n5 p1(13) |
15 | |
16 | describes what HPFS looked like when it was new, and it is the source |
17 | of most of the information given here. The rest is conjecture. |
18 | |
19 | For definitive information on the Duncan paper, see it, not this file. |
20 | For definitive information on HPFS, ask somebody else -- this is guesswork. |
21 | There are certain to be many mistakes. */ |
22 | |
23 | #if !defined(__LITTLE_ENDIAN) && !defined(__BIG_ENDIAN) |
24 | #error unknown endian |
25 | #endif |
26 | |
27 | /* Notation */ |
28 | |
29 | typedef u32 secno; /* sector number, partition relative */ |
30 | |
31 | typedef secno dnode_secno; /* sector number of a dnode */ |
32 | typedef secno fnode_secno; /* sector number of an fnode */ |
33 | typedef secno anode_secno; /* sector number of an anode */ |
34 | |
35 | typedef u32 time32_t; /* 32-bit time_t type */ |
36 | |
37 | /* sector 0 */ |
38 | |
39 | /* The boot block is very like a FAT boot block, except that the |
40 | 29h signature byte is 28h instead, and the ID string is "HPFS". */ |
41 | |
42 | #define BB_MAGIC 0xaa55 |
43 | |
44 | struct hpfs_boot_block |
45 | { |
46 | u8 jmp[3]; |
47 | u8 oem_id[8]; |
48 | u8 bytes_per_sector[2]; /* 512 */ |
49 | u8 sectors_per_cluster; |
50 | u8 n_reserved_sectors[2]; |
51 | u8 n_fats; |
52 | u8 n_rootdir_entries[2]; |
53 | u8 n_sectors_s[2]; |
54 | u8 media_byte; |
55 | __le16 sectors_per_fat; |
56 | __le16 sectors_per_track; |
57 | __le16 heads_per_cyl; |
58 | __le32 n_hidden_sectors; |
59 | __le32 n_sectors_l; /* size of partition */ |
60 | u8 drive_number; |
61 | u8 mbz; |
62 | u8 sig_28h; /* 28h */ |
63 | u8 vol_serno[4]; |
64 | u8 vol_label[11]; |
65 | u8 sig_hpfs[8]; /* "HPFS " */ |
66 | u8 pad[448]; |
67 | __le16 magic; /* aa55 */ |
68 | }; |
69 | |
70 | |
71 | /* sector 16 */ |
72 | |
73 | /* The super block has the pointer to the root directory. */ |
74 | |
75 | #define SB_MAGIC 0xf995e849 |
76 | |
77 | struct hpfs_super_block |
78 | { |
79 | __le32 magic; /* f995 e849 */ |
80 | __le32 magic1; /* fa53 e9c5, more magic? */ |
81 | u8 version; /* version of a filesystem usually 2 */ |
82 | u8 funcversion; /* functional version - oldest version |
83 | of filesystem that can understand |
84 | this disk */ |
85 | __le16 zero; /* 0 */ |
86 | __le32 root; /* fnode of root directory */ |
87 | __le32 n_sectors; /* size of filesystem */ |
88 | __le32 n_badblocks; /* number of bad blocks */ |
89 | __le32 bitmaps; /* pointers to free space bit maps */ |
90 | __le32 zero1; /* 0 */ |
91 | __le32 badblocks; /* bad block list */ |
92 | __le32 zero3; /* 0 */ |
93 | __le32 last_chkdsk; /* date last checked, 0 if never */ |
94 | __le32 last_optimize; /* date last optimized, 0 if never */ |
95 | __le32 n_dir_band; /* number of sectors in dir band */ |
96 | __le32 dir_band_start; /* first sector in dir band */ |
97 | __le32 dir_band_end; /* last sector in dir band */ |
98 | __le32 dir_band_bitmap; /* free space map, 1 dnode per bit */ |
99 | u8 volume_name[32]; /* not used */ |
100 | __le32 user_id_table; /* 8 preallocated sectors - user id */ |
101 | u32 zero6[103]; /* 0 */ |
102 | }; |
103 | |
104 | |
105 | /* sector 17 */ |
106 | |
107 | /* The spare block has pointers to spare sectors. */ |
108 | |
109 | #define SP_MAGIC 0xf9911849 |
110 | |
111 | struct hpfs_spare_block |
112 | { |
113 | __le32 magic; /* f991 1849 */ |
114 | __le32 magic1; /* fa52 29c5, more magic? */ |
115 | |
116 | #ifdef __LITTLE_ENDIAN |
117 | u8 dirty: 1; /* 0 clean, 1 "improperly stopped" */ |
118 | u8 sparedir_used: 1; /* spare dirblks used */ |
119 | u8 hotfixes_used: 1; /* hotfixes used */ |
120 | u8 bad_sector: 1; /* bad sector, corrupted disk (???) */ |
121 | u8 bad_bitmap: 1; /* bad bitmap */ |
122 | u8 fast: 1; /* partition was fast formatted */ |
123 | u8 old_wrote: 1; /* old version wrote to partition */ |
124 | u8 old_wrote_1: 1; /* old version wrote to partition (?) */ |
125 | #else |
126 | u8 old_wrote_1: 1; /* old version wrote to partition (?) */ |
127 | u8 old_wrote: 1; /* old version wrote to partition */ |
128 | u8 fast: 1; /* partition was fast formatted */ |
129 | u8 bad_bitmap: 1; /* bad bitmap */ |
130 | u8 bad_sector: 1; /* bad sector, corrupted disk (???) */ |
131 | u8 hotfixes_used: 1; /* hotfixes used */ |
132 | u8 sparedir_used: 1; /* spare dirblks used */ |
133 | u8 dirty: 1; /* 0 clean, 1 "improperly stopped" */ |
134 | #endif |
135 | |
136 | #ifdef __LITTLE_ENDIAN |
137 | u8 install_dasd_limits: 1; /* HPFS386 flags */ |
138 | u8 resynch_dasd_limits: 1; |
139 | u8 dasd_limits_operational: 1; |
140 | u8 multimedia_active: 1; |
141 | u8 dce_acls_active: 1; |
142 | u8 dasd_limits_dirty: 1; |
143 | u8 flag67: 2; |
144 | #else |
145 | u8 flag67: 2; |
146 | u8 dasd_limits_dirty: 1; |
147 | u8 dce_acls_active: 1; |
148 | u8 multimedia_active: 1; |
149 | u8 dasd_limits_operational: 1; |
150 | u8 resynch_dasd_limits: 1; |
151 | u8 install_dasd_limits: 1; /* HPFS386 flags */ |
152 | #endif |
153 | |
154 | u8 mm_contlgulty; |
155 | u8 unused; |
156 | |
157 | __le32 hotfix_map; /* info about remapped bad sectors */ |
158 | __le32 n_spares_used; /* number of hotfixes */ |
159 | __le32 n_spares; /* number of spares in hotfix map */ |
160 | __le32 n_dnode_spares_free; /* spare dnodes unused */ |
161 | __le32 n_dnode_spares; /* length of spare_dnodes[] list, |
162 | follows in this block*/ |
163 | __le32 code_page_dir; /* code page directory block */ |
164 | __le32 n_code_pages; /* number of code pages */ |
165 | __le32 super_crc; /* on HPFS386 and LAN Server this is |
166 | checksum of superblock, on normal |
167 | OS/2 unused */ |
168 | __le32 spare_crc; /* on HPFS386 checksum of spareblock */ |
169 | __le32 zero1[15]; /* unused */ |
170 | __le32 spare_dnodes[100]; /* emergency free dnode list */ |
171 | __le32 zero2[1]; /* room for more? */ |
172 | }; |
173 | |
174 | /* The bad block list is 4 sectors long. The first word must be zero, |
175 | the remaining words give n_badblocks bad block numbers. |
176 | I bet you can see it coming... */ |
177 | |
178 | #define BAD_MAGIC 0 |
179 | |
180 | /* The hotfix map is 4 sectors long. It looks like |
181 | |
182 | secno from[n_spares]; |
183 | secno to[n_spares]; |
184 | |
185 | The to[] list is initialized to point to n_spares preallocated empty |
186 | sectors. The from[] list contains the sector numbers of bad blocks |
187 | which have been remapped to corresponding sectors in the to[] list. |
188 | n_spares_used gives the length of the from[] list. */ |
189 | |
190 | |
191 | /* Sectors 18 and 19 are preallocated and unused. |
192 | Maybe they're spares for 16 and 17, but simple substitution fails. */ |
193 | |
194 | |
195 | /* The code page info pointed to by the spare block consists of an index |
196 | block and blocks containing uppercasing tables. I don't know what |
197 | these are for (CHKDSK, maybe?) -- OS/2 does not seem to use them |
198 | itself. Linux doesn't use them either. */ |
199 | |
200 | /* block pointed to by spareblock->code_page_dir */ |
201 | |
202 | #define CP_DIR_MAGIC 0x494521f7 |
203 | |
204 | struct code_page_directory |
205 | { |
206 | __le32 magic; /* 4945 21f7 */ |
207 | __le32 n_code_pages; /* number of pointers following */ |
208 | __le32 zero1[2]; |
209 | struct { |
210 | __le16 ix; /* index */ |
211 | __le16 code_page_number; /* code page number */ |
212 | __le32 bounds; /* matches corresponding word |
213 | in data block */ |
214 | __le32 code_page_data; /* sector number of a code_page_data |
215 | containing c.p. array */ |
216 | __le16 index; /* index in c.p. array in that sector*/ |
217 | __le16 unknown; /* some unknown value; usually 0; |
218 | 2 in Japanese version */ |
219 | } array[31]; /* unknown length */ |
220 | }; |
221 | |
222 | /* blocks pointed to by code_page_directory */ |
223 | |
224 | #define CP_DATA_MAGIC 0x894521f7 |
225 | |
226 | struct code_page_data |
227 | { |
228 | __le32 magic; /* 8945 21f7 */ |
229 | __le32 n_used; /* # elements used in c_p_data[] */ |
230 | __le32 bounds[3]; /* looks a bit like |
231 | (beg1,end1), (beg2,end2) |
232 | one byte each */ |
233 | __le16 offs[3]; /* offsets from start of sector |
234 | to start of c_p_data[ix] */ |
235 | struct { |
236 | __le16 ix; /* index */ |
237 | __le16 code_page_number; /* code page number */ |
238 | __le16 unknown; /* the same as in cp directory */ |
239 | u8 map[128]; /* upcase table for chars 80..ff */ |
240 | __le16 zero2; |
241 | } code_page[3]; |
242 | u8 incognita[78]; |
243 | }; |
244 | |
245 | |
246 | /* Free space bitmaps are 4 sectors long, which is 16384 bits. |
247 | 16384 sectors is 8 meg, and each 8 meg band has a 4-sector bitmap. |
248 | Bit order in the maps is little-endian. 0 means taken, 1 means free. |
249 | |
250 | Bit map sectors are marked allocated in the bit maps, and so are sectors |
251 | off the end of the partition. |
252 | |
253 | Band 0 is sectors 0-3fff, its map is in sectors 18-1b. |
254 | Band 1 is 4000-7fff, its map is in 7ffc-7fff. |
255 | Band 2 is 8000-ffff, its map is in 8000-8003. |
256 | The remaining bands have maps in their first (even) or last (odd) 4 sectors |
257 | -- if the last, partial, band is odd its map is in its last 4 sectors. |
258 | |
259 | The bitmap locations are given in a table pointed to by the super block. |
260 | No doubt they aren't constrained to be at 18, 7ffc, 8000, ...; that is |
261 | just where they usually are. |
262 | |
263 | The "directory band" is a bunch of sectors preallocated for dnodes. |
264 | It has a 4-sector free space bitmap of its own. Each bit in the map |
265 | corresponds to one 4-sector dnode, bit 0 of the map corresponding to |
266 | the first 4 sectors of the directory band. The entire band is marked |
267 | allocated in the main bitmap. The super block gives the locations |
268 | of the directory band and its bitmap. ("band" doesn't mean it is |
269 | 8 meg long; it isn't.) */ |
270 | |
271 | |
272 | /* dnode: directory. 4 sectors long */ |
273 | |
274 | /* A directory is a tree of dnodes. The fnode for a directory |
275 | contains one pointer, to the root dnode of the tree. The fnode |
276 | never moves, the dnodes do the B-tree thing, splitting and merging |
277 | as files are added and removed. */ |
278 | |
279 | #define DNODE_MAGIC 0x77e40aae |
280 | |
281 | struct dnode { |
282 | __le32 magic; /* 77e4 0aae */ |
283 | __le32 first_free; /* offset from start of dnode to |
284 | first free dir entry */ |
285 | #ifdef __LITTLE_ENDIAN |
286 | u8 root_dnode: 1; /* Is it root dnode? */ |
287 | u8 increment_me: 7; /* some kind of activity counter? */ |
288 | /* Neither HPFS.IFS nor CHKDSK cares |
289 | if you change this word */ |
290 | #else |
291 | u8 increment_me: 7; /* some kind of activity counter? */ |
292 | /* Neither HPFS.IFS nor CHKDSK cares |
293 | if you change this word */ |
294 | u8 root_dnode: 1; /* Is it root dnode? */ |
295 | #endif |
296 | u8 increment_me2[3]; |
297 | __le32 up; /* (root dnode) directory's fnode |
298 | (nonroot) parent dnode */ |
299 | __le32 self; /* pointer to this dnode */ |
300 | u8 dirent[2028]; /* one or more dirents */ |
301 | }; |
302 | |
303 | struct hpfs_dirent { |
304 | __le16 length; /* offset to next dirent */ |
305 | |
306 | #ifdef __LITTLE_ENDIAN |
307 | u8 first: 1; /* set on phony ^A^A (".") entry */ |
308 | u8 has_acl: 1; |
309 | u8 down: 1; /* down pointer present (after name) */ |
310 | u8 last: 1; /* set on phony \377 entry */ |
311 | u8 has_ea: 1; /* entry has EA */ |
312 | u8 has_xtd_perm: 1; /* has extended perm list (???) */ |
313 | u8 has_explicit_acl: 1; |
314 | u8 has_needea: 1; /* ?? some EA has NEEDEA set |
315 | I have no idea why this is |
316 | interesting in a dir entry */ |
317 | #else |
318 | u8 has_needea: 1; /* ?? some EA has NEEDEA set |
319 | I have no idea why this is |
320 | interesting in a dir entry */ |
321 | u8 has_explicit_acl: 1; |
322 | u8 has_xtd_perm: 1; /* has extended perm list (???) */ |
323 | u8 has_ea: 1; /* entry has EA */ |
324 | u8 last: 1; /* set on phony \377 entry */ |
325 | u8 down: 1; /* down pointer present (after name) */ |
326 | u8 has_acl: 1; |
327 | u8 first: 1; /* set on phony ^A^A (".") entry */ |
328 | #endif |
329 | |
330 | #ifdef __LITTLE_ENDIAN |
331 | u8 read_only: 1; /* dos attrib */ |
332 | u8 hidden: 1; /* dos attrib */ |
333 | u8 system: 1; /* dos attrib */ |
334 | u8 flag11: 1; /* would be volume label dos attrib */ |
335 | u8 directory: 1; /* dos attrib */ |
336 | u8 archive: 1; /* dos attrib */ |
337 | u8 not_8x3: 1; /* name is not 8.3 */ |
338 | u8 flag15: 1; |
339 | #else |
340 | u8 flag15: 1; |
341 | u8 not_8x3: 1; /* name is not 8.3 */ |
342 | u8 archive: 1; /* dos attrib */ |
343 | u8 directory: 1; /* dos attrib */ |
344 | u8 flag11: 1; /* would be volume label dos attrib */ |
345 | u8 system: 1; /* dos attrib */ |
346 | u8 hidden: 1; /* dos attrib */ |
347 | u8 read_only: 1; /* dos attrib */ |
348 | #endif |
349 | |
350 | __le32 fnode; /* fnode giving allocation info */ |
351 | __le32 write_date; /* mtime */ |
352 | __le32 file_size; /* file length, bytes */ |
353 | __le32 read_date; /* atime */ |
354 | __le32 creation_date; /* ctime */ |
355 | __le32 ea_size; /* total EA length, bytes */ |
356 | u8 no_of_acls; /* number of ACL's (low 3 bits) */ |
357 | u8 ix; /* code page index (of filename), see |
358 | struct code_page_data */ |
359 | u8 namelen; /* file name length */ |
360 | u8 name[]; /* file name */ |
361 | /* dnode_secno down; btree down pointer, if present, |
362 | follows name on next word boundary, or maybe it |
363 | precedes next dirent, which is on a word boundary. */ |
364 | }; |
365 | |
366 | |
367 | /* B+ tree: allocation info in fnodes and anodes */ |
368 | |
369 | /* dnodes point to fnodes which are responsible for listing the sectors |
370 | assigned to the file. This is done with trees of (length,address) |
371 | pairs. (Actually triples, of (length, file-address, disk-address) |
372 | which can represent holes. Find out if HPFS does that.) |
373 | At any rate, fnodes contain a small tree; if subtrees are needed |
374 | they occupy essentially a full block in anodes. A leaf-level tree node |
375 | has 3-word entries giving sector runs, a non-leaf node has 2-word |
376 | entries giving subtree pointers. A flag in the header says which. */ |
377 | |
378 | struct bplus_leaf_node |
379 | { |
380 | __le32 file_secno; /* first file sector in extent */ |
381 | __le32 length; /* length, sectors */ |
382 | __le32 disk_secno; /* first corresponding disk sector */ |
383 | }; |
384 | |
385 | struct bplus_internal_node |
386 | { |
387 | __le32 file_secno; /* subtree maps sectors < this */ |
388 | __le32 down; /* pointer to subtree */ |
389 | }; |
390 | |
391 | enum { |
392 | BP_hbff = 1, |
393 | BP_fnode_parent = 0x20, |
394 | BP_binary_search = 0x40, |
395 | BP_internal = 0x80 |
396 | }; |
397 | struct |
398 | { |
399 | u8 ; /* bit 0 - high bit of first free entry offset |
400 | bit 5 - we're pointed to by an fnode, |
401 | the data btree or some ea or the |
402 | main ea bootage pointer ea_secno |
403 | bit 6 - suggest binary search (unused) |
404 | bit 7 - 1 -> (internal) tree of anodes |
405 | 0 -> (leaf) list of extents */ |
406 | u8 [3]; |
407 | u8 ; /* free nodes in following array */ |
408 | u8 ; /* used nodes in following array */ |
409 | __le16 ; /* offset from start of header to |
410 | first free node in array */ |
411 | union { |
412 | /* (internal) 2-word entries giving subtree pointers */ |
413 | DECLARE_FLEX_ARRAY(struct bplus_internal_node, ); |
414 | /* (external) 3-word entries giving sector runs */ |
415 | DECLARE_FLEX_ARRAY(struct bplus_leaf_node, ); |
416 | } ; |
417 | }; |
418 | |
419 | static inline bool bp_internal(struct bplus_header *bp) |
420 | { |
421 | return bp->flags & BP_internal; |
422 | } |
423 | |
424 | static inline bool bp_fnode_parent(struct bplus_header *bp) |
425 | { |
426 | return bp->flags & BP_fnode_parent; |
427 | } |
428 | |
429 | /* fnode: root of allocation b+ tree, and EA's */ |
430 | |
431 | /* Every file and every directory has one fnode, pointed to by the directory |
432 | entry and pointing to the file's sectors or directory's root dnode. EA's |
433 | are also stored here, and there are said to be ACL's somewhere here too. */ |
434 | |
435 | #define FNODE_MAGIC 0xf7e40aae |
436 | |
437 | enum {FNODE_anode = cpu_to_le16(2), FNODE_dir = cpu_to_le16(256)}; |
438 | struct fnode |
439 | { |
440 | __le32 magic; /* f7e4 0aae */ |
441 | __le32 zero1[2]; /* read history */ |
442 | u8 len, name[15]; /* true length, truncated name */ |
443 | __le32 up; /* pointer to file's directory fnode */ |
444 | __le32 acl_size_l; |
445 | __le32 acl_secno; |
446 | __le16 acl_size_s; |
447 | u8 acl_anode; |
448 | u8 zero2; /* history bit count */ |
449 | __le32 ea_size_l; /* length of disk-resident ea's */ |
450 | __le32 ea_secno; /* first sector of disk-resident ea's*/ |
451 | __le16 ea_size_s; /* length of fnode-resident ea's */ |
452 | |
453 | __le16 flags; /* bit 1 set -> ea_secno is an anode */ |
454 | /* bit 8 set -> directory. first & only extent |
455 | points to dnode. */ |
456 | struct bplus_header btree; /* b+ tree, 8 extents or 12 subtrees */ |
457 | union { |
458 | struct bplus_leaf_node external[8]; |
459 | struct bplus_internal_node internal[12]; |
460 | } u; |
461 | |
462 | __le32 file_size; /* file length, bytes */ |
463 | __le32 n_needea; /* number of EA's with NEEDEA set */ |
464 | u8 user_id[16]; /* unused */ |
465 | __le16 ea_offs; /* offset from start of fnode |
466 | to first fnode-resident ea */ |
467 | u8 dasd_limit_treshhold; |
468 | u8 dasd_limit_delta; |
469 | __le32 dasd_limit; |
470 | __le32 dasd_usage; |
471 | u8 ea[316]; /* zero or more EA's, packed together |
472 | with no alignment padding. |
473 | (Do not use this name, get here |
474 | via fnode + ea_offs. I think.) */ |
475 | }; |
476 | |
477 | static inline bool fnode_in_anode(struct fnode *p) |
478 | { |
479 | return (p->flags & FNODE_anode) != 0; |
480 | } |
481 | |
482 | static inline bool fnode_is_dir(struct fnode *p) |
483 | { |
484 | return (p->flags & FNODE_dir) != 0; |
485 | } |
486 | |
487 | |
488 | /* anode: 99.44% pure allocation tree */ |
489 | |
490 | #define ANODE_MAGIC 0x37e40aae |
491 | |
492 | struct anode |
493 | { |
494 | __le32 magic; /* 37e4 0aae */ |
495 | __le32 self; /* pointer to this anode */ |
496 | __le32 up; /* parent anode or fnode */ |
497 | |
498 | struct bplus_header btree; /* b+tree, 40 extents or 60 subtrees */ |
499 | union { |
500 | struct bplus_leaf_node external[40]; |
501 | struct bplus_internal_node internal[60]; |
502 | } u; |
503 | |
504 | __le32 fill[3]; /* unused */ |
505 | }; |
506 | |
507 | |
508 | /* extended attributes. |
509 | |
510 | A file's EA info is stored as a list of (name,value) pairs. It is |
511 | usually in the fnode, but (if it's large) it is moved to a single |
512 | sector run outside the fnode, or to multiple runs with an anode tree |
513 | that points to them. |
514 | |
515 | The value of a single EA is stored along with the name, or (if large) |
516 | it is moved to a single sector run, or multiple runs pointed to by an |
517 | anode tree, pointed to by the value field of the (name,value) pair. |
518 | |
519 | Flags in the EA tell whether the value is immediate, in a single sector |
520 | run, or in multiple runs. Flags in the fnode tell whether the EA list |
521 | is immediate, in a single run, or in multiple runs. */ |
522 | |
523 | enum {EA_indirect = 1, EA_anode = 2, EA_needea = 128 }; |
524 | struct extended_attribute |
525 | { |
526 | u8 flags; /* bit 0 set -> value gives sector number |
527 | where real value starts */ |
528 | /* bit 1 set -> sector is an anode |
529 | that points to fragmented value */ |
530 | /* bit 7 set -> required ea */ |
531 | u8 namelen; /* length of name, bytes */ |
532 | u8 valuelen_lo; /* length of value, bytes */ |
533 | u8 valuelen_hi; /* length of value, bytes */ |
534 | u8 name[]; |
535 | /* |
536 | u8 name[namelen]; ascii attrib name |
537 | u8 nul; terminating '\0', not counted |
538 | u8 value[valuelen]; value, arbitrary |
539 | if this.flags & 1, valuelen is 8 and the value is |
540 | u32 length; real length of value, bytes |
541 | secno secno; sector address where it starts |
542 | if this.anode, the above sector number is the root of an anode tree |
543 | which points to the value. |
544 | */ |
545 | }; |
546 | |
547 | static inline bool ea_indirect(struct extended_attribute *ea) |
548 | { |
549 | return ea->flags & EA_indirect; |
550 | } |
551 | |
552 | static inline bool ea_in_anode(struct extended_attribute *ea) |
553 | { |
554 | return ea->flags & EA_anode; |
555 | } |
556 | |
557 | /* |
558 | Local Variables: |
559 | comment-column: 40 |
560 | End: |
561 | */ |
562 | |