mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-05 18:14:07 +08:00
b24413180f
Many source files in the tree are missing licensing information, which makes it harder for compliance tools to determine the correct license. By default all files without license information are under the default license of the kernel, which is GPL version 2. Update the files which contain no license information with the 'GPL-2.0' SPDX license identifier. The SPDX identifier is a legally binding shorthand, which can be used instead of the full boiler plate text. This patch is based on work done by Thomas Gleixner and Kate Stewart and Philippe Ombredanne. How this work was done: Patches were generated and checked against linux-4.14-rc6 for a subset of the use cases: - file had no licensing information it it. - file was a */uapi/* one with no licensing information in it, - file was a */uapi/* one with existing licensing information, Further patches will be generated in subsequent months to fix up cases where non-standard license headers were used, and references to license had to be inferred by heuristics based on keywords. The analysis to determine which SPDX License Identifier to be applied to a file was done in a spreadsheet of side by side results from of the output of two independent scanners (ScanCode & Windriver) producing SPDX tag:value files created by Philippe Ombredanne. Philippe prepared the base worksheet, and did an initial spot review of a few 1000 files. The 4.13 kernel was the starting point of the analysis with 60,537 files assessed. Kate Stewart did a file by file comparison of the scanner results in the spreadsheet to determine which SPDX license identifier(s) to be applied to the file. She confirmed any determination that was not immediately clear with lawyers working with the Linux Foundation. Criteria used to select files for SPDX license identifier tagging was: - Files considered eligible had to be source code files. - Make and config files were included as candidates if they contained >5 lines of source - File already had some variant of a license header in it (even if <5 lines). All documentation files were explicitly excluded. The following heuristics were used to determine which SPDX license identifiers to apply. - when both scanners couldn't find any license traces, file was considered to have no license information in it, and the top level COPYING file license applied. For non */uapi/* files that summary was: SPDX license identifier # files ---------------------------------------------------|------- GPL-2.0 11139 and resulted in the first patch in this series. If that file was a */uapi/* path one, it was "GPL-2.0 WITH Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was: SPDX license identifier # files ---------------------------------------------------|------- GPL-2.0 WITH Linux-syscall-note 930 and resulted in the second patch in this series. - if a file had some form of licensing information in it, and was one of the */uapi/* ones, it was denoted with the Linux-syscall-note if any GPL family license was found in the file or had no licensing in it (per prior point). Results summary: SPDX license identifier # files ---------------------------------------------------|------ GPL-2.0 WITH Linux-syscall-note 270 GPL-2.0+ WITH Linux-syscall-note 169 ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21 ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17 LGPL-2.1+ WITH Linux-syscall-note 15 GPL-1.0+ WITH Linux-syscall-note 14 ((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5 LGPL-2.0+ WITH Linux-syscall-note 4 LGPL-2.1 WITH Linux-syscall-note 3 ((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3 ((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1 and that resulted in the third patch in this series. - when the two scanners agreed on the detected license(s), that became the concluded license(s). - when there was disagreement between the two scanners (one detected a license but the other didn't, or they both detected different licenses) a manual inspection of the file occurred. - In most cases a manual inspection of the information in the file resulted in a clear resolution of the license that should apply (and which scanner probably needed to revisit its heuristics). - When it was not immediately clear, the license identifier was confirmed with lawyers working with the Linux Foundation. - If there was any question as to the appropriate license identifier, the file was flagged for further research and to be revisited later in time. In total, over 70 hours of logged manual review was done on the spreadsheet to determine the SPDX license identifiers to apply to the source files by Kate, Philippe, Thomas and, in some cases, confirmation by lawyers working with the Linux Foundation. Kate also obtained a third independent scan of the 4.13 code base from FOSSology, and compared selected files where the other two scanners disagreed against that SPDX file, to see if there was new insights. The Windriver scanner is based on an older version of FOSSology in part, so they are related. Thomas did random spot checks in about 500 files from the spreadsheets for the uapi headers and agreed with SPDX license identifier in the files he inspected. For the non-uapi files Thomas did random spot checks in about 15000 files. In initial set of patches against 4.14-rc6, 3 files were found to have copy/paste license identifier errors, and have been fixed to reflect the correct identifier. Additionally Philippe spent 10 hours this week doing a detailed manual inspection and review of the 12,461 patched files from the initial patch version early this week with: - a full scancode scan run, collecting the matched texts, detected license ids and scores - reviewing anything where there was a license detected (about 500+ files) to ensure that the applied SPDX license was correct - reviewing anything where there was no detection but the patch license was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied SPDX license was correct This produced a worksheet with 20 files needing minor correction. This worksheet was then exported into 3 different .csv files for the different types of files to be modified. These .csv files were then reviewed by Greg. Thomas wrote a script to parse the csv files and add the proper SPDX tag to the file, in the format that the file expected. This script was further refined by Greg based on the output to detect more types of files automatically and to distinguish between header and source .c files (which need different comment types.) Finally Greg ran the script using the .csv files to generate the patches. Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org> Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com> Reviewed-by: Thomas Gleixner <tglx@linutronix.de> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
561 lines
18 KiB
C
561 lines
18 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/*
|
|
* linux/fs/hpfs/hpfs.h
|
|
*
|
|
* HPFS structures by Chris Smith, 1993
|
|
*
|
|
* a little bit modified by Mikulas Patocka, 1998-1999
|
|
*/
|
|
|
|
/* The paper
|
|
|
|
Duncan, Roy
|
|
Design goals and implementation of the new High Performance File System
|
|
Microsoft Systems Journal Sept 1989 v4 n5 p1(13)
|
|
|
|
describes what HPFS looked like when it was new, and it is the source
|
|
of most of the information given here. The rest is conjecture.
|
|
|
|
For definitive information on the Duncan paper, see it, not this file.
|
|
For definitive information on HPFS, ask somebody else -- this is guesswork.
|
|
There are certain to be many mistakes. */
|
|
|
|
#if !defined(__LITTLE_ENDIAN) && !defined(__BIG_ENDIAN)
|
|
#error unknown endian
|
|
#endif
|
|
|
|
/* Notation */
|
|
|
|
typedef u32 secno; /* sector number, partition relative */
|
|
|
|
typedef secno dnode_secno; /* sector number of a dnode */
|
|
typedef secno fnode_secno; /* sector number of an fnode */
|
|
typedef secno anode_secno; /* sector number of an anode */
|
|
|
|
typedef u32 time32_t; /* 32-bit time_t type */
|
|
|
|
/* sector 0 */
|
|
|
|
/* The boot block is very like a FAT boot block, except that the
|
|
29h signature byte is 28h instead, and the ID string is "HPFS". */
|
|
|
|
#define BB_MAGIC 0xaa55
|
|
|
|
struct hpfs_boot_block
|
|
{
|
|
u8 jmp[3];
|
|
u8 oem_id[8];
|
|
u8 bytes_per_sector[2]; /* 512 */
|
|
u8 sectors_per_cluster;
|
|
u8 n_reserved_sectors[2];
|
|
u8 n_fats;
|
|
u8 n_rootdir_entries[2];
|
|
u8 n_sectors_s[2];
|
|
u8 media_byte;
|
|
__le16 sectors_per_fat;
|
|
__le16 sectors_per_track;
|
|
__le16 heads_per_cyl;
|
|
__le32 n_hidden_sectors;
|
|
__le32 n_sectors_l; /* size of partition */
|
|
u8 drive_number;
|
|
u8 mbz;
|
|
u8 sig_28h; /* 28h */
|
|
u8 vol_serno[4];
|
|
u8 vol_label[11];
|
|
u8 sig_hpfs[8]; /* "HPFS " */
|
|
u8 pad[448];
|
|
__le16 magic; /* aa55 */
|
|
};
|
|
|
|
|
|
/* sector 16 */
|
|
|
|
/* The super block has the pointer to the root directory. */
|
|
|
|
#define SB_MAGIC 0xf995e849
|
|
|
|
struct hpfs_super_block
|
|
{
|
|
__le32 magic; /* f995 e849 */
|
|
__le32 magic1; /* fa53 e9c5, more magic? */
|
|
u8 version; /* version of a filesystem usually 2 */
|
|
u8 funcversion; /* functional version - oldest version
|
|
of filesystem that can understand
|
|
this disk */
|
|
__le16 zero; /* 0 */
|
|
__le32 root; /* fnode of root directory */
|
|
__le32 n_sectors; /* size of filesystem */
|
|
__le32 n_badblocks; /* number of bad blocks */
|
|
__le32 bitmaps; /* pointers to free space bit maps */
|
|
__le32 zero1; /* 0 */
|
|
__le32 badblocks; /* bad block list */
|
|
__le32 zero3; /* 0 */
|
|
__le32 last_chkdsk; /* date last checked, 0 if never */
|
|
__le32 last_optimize; /* date last optimized, 0 if never */
|
|
__le32 n_dir_band; /* number of sectors in dir band */
|
|
__le32 dir_band_start; /* first sector in dir band */
|
|
__le32 dir_band_end; /* last sector in dir band */
|
|
__le32 dir_band_bitmap; /* free space map, 1 dnode per bit */
|
|
u8 volume_name[32]; /* not used */
|
|
__le32 user_id_table; /* 8 preallocated sectors - user id */
|
|
u32 zero6[103]; /* 0 */
|
|
};
|
|
|
|
|
|
/* sector 17 */
|
|
|
|
/* The spare block has pointers to spare sectors. */
|
|
|
|
#define SP_MAGIC 0xf9911849
|
|
|
|
struct hpfs_spare_block
|
|
{
|
|
__le32 magic; /* f991 1849 */
|
|
__le32 magic1; /* fa52 29c5, more magic? */
|
|
|
|
#ifdef __LITTLE_ENDIAN
|
|
u8 dirty: 1; /* 0 clean, 1 "improperly stopped" */
|
|
u8 sparedir_used: 1; /* spare dirblks used */
|
|
u8 hotfixes_used: 1; /* hotfixes used */
|
|
u8 bad_sector: 1; /* bad sector, corrupted disk (???) */
|
|
u8 bad_bitmap: 1; /* bad bitmap */
|
|
u8 fast: 1; /* partition was fast formatted */
|
|
u8 old_wrote: 1; /* old version wrote to partion */
|
|
u8 old_wrote_1: 1; /* old version wrote to partion (?) */
|
|
#else
|
|
u8 old_wrote_1: 1; /* old version wrote to partion (?) */
|
|
u8 old_wrote: 1; /* old version wrote to partion */
|
|
u8 fast: 1; /* partition was fast formatted */
|
|
u8 bad_bitmap: 1; /* bad bitmap */
|
|
u8 bad_sector: 1; /* bad sector, corrupted disk (???) */
|
|
u8 hotfixes_used: 1; /* hotfixes used */
|
|
u8 sparedir_used: 1; /* spare dirblks used */
|
|
u8 dirty: 1; /* 0 clean, 1 "improperly stopped" */
|
|
#endif
|
|
|
|
#ifdef __LITTLE_ENDIAN
|
|
u8 install_dasd_limits: 1; /* HPFS386 flags */
|
|
u8 resynch_dasd_limits: 1;
|
|
u8 dasd_limits_operational: 1;
|
|
u8 multimedia_active: 1;
|
|
u8 dce_acls_active: 1;
|
|
u8 dasd_limits_dirty: 1;
|
|
u8 flag67: 2;
|
|
#else
|
|
u8 flag67: 2;
|
|
u8 dasd_limits_dirty: 1;
|
|
u8 dce_acls_active: 1;
|
|
u8 multimedia_active: 1;
|
|
u8 dasd_limits_operational: 1;
|
|
u8 resynch_dasd_limits: 1;
|
|
u8 install_dasd_limits: 1; /* HPFS386 flags */
|
|
#endif
|
|
|
|
u8 mm_contlgulty;
|
|
u8 unused;
|
|
|
|
__le32 hotfix_map; /* info about remapped bad sectors */
|
|
__le32 n_spares_used; /* number of hotfixes */
|
|
__le32 n_spares; /* number of spares in hotfix map */
|
|
__le32 n_dnode_spares_free; /* spare dnodes unused */
|
|
__le32 n_dnode_spares; /* length of spare_dnodes[] list,
|
|
follows in this block*/
|
|
__le32 code_page_dir; /* code page directory block */
|
|
__le32 n_code_pages; /* number of code pages */
|
|
__le32 super_crc; /* on HPFS386 and LAN Server this is
|
|
checksum of superblock, on normal
|
|
OS/2 unused */
|
|
__le32 spare_crc; /* on HPFS386 checksum of spareblock */
|
|
__le32 zero1[15]; /* unused */
|
|
__le32 spare_dnodes[100]; /* emergency free dnode list */
|
|
__le32 zero2[1]; /* room for more? */
|
|
};
|
|
|
|
/* The bad block list is 4 sectors long. The first word must be zero,
|
|
the remaining words give n_badblocks bad block numbers.
|
|
I bet you can see it coming... */
|
|
|
|
#define BAD_MAGIC 0
|
|
|
|
/* The hotfix map is 4 sectors long. It looks like
|
|
|
|
secno from[n_spares];
|
|
secno to[n_spares];
|
|
|
|
The to[] list is initialized to point to n_spares preallocated empty
|
|
sectors. The from[] list contains the sector numbers of bad blocks
|
|
which have been remapped to corresponding sectors in the to[] list.
|
|
n_spares_used gives the length of the from[] list. */
|
|
|
|
|
|
/* Sectors 18 and 19 are preallocated and unused.
|
|
Maybe they're spares for 16 and 17, but simple substitution fails. */
|
|
|
|
|
|
/* The code page info pointed to by the spare block consists of an index
|
|
block and blocks containing uppercasing tables. I don't know what
|
|
these are for (CHKDSK, maybe?) -- OS/2 does not seem to use them
|
|
itself. Linux doesn't use them either. */
|
|
|
|
/* block pointed to by spareblock->code_page_dir */
|
|
|
|
#define CP_DIR_MAGIC 0x494521f7
|
|
|
|
struct code_page_directory
|
|
{
|
|
__le32 magic; /* 4945 21f7 */
|
|
__le32 n_code_pages; /* number of pointers following */
|
|
__le32 zero1[2];
|
|
struct {
|
|
__le16 ix; /* index */
|
|
__le16 code_page_number; /* code page number */
|
|
__le32 bounds; /* matches corresponding word
|
|
in data block */
|
|
__le32 code_page_data; /* sector number of a code_page_data
|
|
containing c.p. array */
|
|
__le16 index; /* index in c.p. array in that sector*/
|
|
__le16 unknown; /* some unknown value; usually 0;
|
|
2 in Japanese version */
|
|
} array[31]; /* unknown length */
|
|
};
|
|
|
|
/* blocks pointed to by code_page_directory */
|
|
|
|
#define CP_DATA_MAGIC 0x894521f7
|
|
|
|
struct code_page_data
|
|
{
|
|
__le32 magic; /* 8945 21f7 */
|
|
__le32 n_used; /* # elements used in c_p_data[] */
|
|
__le32 bounds[3]; /* looks a bit like
|
|
(beg1,end1), (beg2,end2)
|
|
one byte each */
|
|
__le16 offs[3]; /* offsets from start of sector
|
|
to start of c_p_data[ix] */
|
|
struct {
|
|
__le16 ix; /* index */
|
|
__le16 code_page_number; /* code page number */
|
|
__le16 unknown; /* the same as in cp directory */
|
|
u8 map[128]; /* upcase table for chars 80..ff */
|
|
__le16 zero2;
|
|
} code_page[3];
|
|
u8 incognita[78];
|
|
};
|
|
|
|
|
|
/* Free space bitmaps are 4 sectors long, which is 16384 bits.
|
|
16384 sectors is 8 meg, and each 8 meg band has a 4-sector bitmap.
|
|
Bit order in the maps is little-endian. 0 means taken, 1 means free.
|
|
|
|
Bit map sectors are marked allocated in the bit maps, and so are sectors
|
|
off the end of the partition.
|
|
|
|
Band 0 is sectors 0-3fff, its map is in sectors 18-1b.
|
|
Band 1 is 4000-7fff, its map is in 7ffc-7fff.
|
|
Band 2 is 8000-ffff, its map is in 8000-8003.
|
|
The remaining bands have maps in their first (even) or last (odd) 4 sectors
|
|
-- if the last, partial, band is odd its map is in its last 4 sectors.
|
|
|
|
The bitmap locations are given in a table pointed to by the super block.
|
|
No doubt they aren't constrained to be at 18, 7ffc, 8000, ...; that is
|
|
just where they usually are.
|
|
|
|
The "directory band" is a bunch of sectors preallocated for dnodes.
|
|
It has a 4-sector free space bitmap of its own. Each bit in the map
|
|
corresponds to one 4-sector dnode, bit 0 of the map corresponding to
|
|
the first 4 sectors of the directory band. The entire band is marked
|
|
allocated in the main bitmap. The super block gives the locations
|
|
of the directory band and its bitmap. ("band" doesn't mean it is
|
|
8 meg long; it isn't.) */
|
|
|
|
|
|
/* dnode: directory. 4 sectors long */
|
|
|
|
/* A directory is a tree of dnodes. The fnode for a directory
|
|
contains one pointer, to the root dnode of the tree. The fnode
|
|
never moves, the dnodes do the B-tree thing, splitting and merging
|
|
as files are added and removed. */
|
|
|
|
#define DNODE_MAGIC 0x77e40aae
|
|
|
|
struct dnode {
|
|
__le32 magic; /* 77e4 0aae */
|
|
__le32 first_free; /* offset from start of dnode to
|
|
first free dir entry */
|
|
#ifdef __LITTLE_ENDIAN
|
|
u8 root_dnode: 1; /* Is it root dnode? */
|
|
u8 increment_me: 7; /* some kind of activity counter? */
|
|
/* Neither HPFS.IFS nor CHKDSK cares
|
|
if you change this word */
|
|
#else
|
|
u8 increment_me: 7; /* some kind of activity counter? */
|
|
/* Neither HPFS.IFS nor CHKDSK cares
|
|
if you change this word */
|
|
u8 root_dnode: 1; /* Is it root dnode? */
|
|
#endif
|
|
u8 increment_me2[3];
|
|
__le32 up; /* (root dnode) directory's fnode
|
|
(nonroot) parent dnode */
|
|
__le32 self; /* pointer to this dnode */
|
|
u8 dirent[2028]; /* one or more dirents */
|
|
};
|
|
|
|
struct hpfs_dirent {
|
|
__le16 length; /* offset to next dirent */
|
|
|
|
#ifdef __LITTLE_ENDIAN
|
|
u8 first: 1; /* set on phony ^A^A (".") entry */
|
|
u8 has_acl: 1;
|
|
u8 down: 1; /* down pointer present (after name) */
|
|
u8 last: 1; /* set on phony \377 entry */
|
|
u8 has_ea: 1; /* entry has EA */
|
|
u8 has_xtd_perm: 1; /* has extended perm list (???) */
|
|
u8 has_explicit_acl: 1;
|
|
u8 has_needea: 1; /* ?? some EA has NEEDEA set
|
|
I have no idea why this is
|
|
interesting in a dir entry */
|
|
#else
|
|
u8 has_needea: 1; /* ?? some EA has NEEDEA set
|
|
I have no idea why this is
|
|
interesting in a dir entry */
|
|
u8 has_explicit_acl: 1;
|
|
u8 has_xtd_perm: 1; /* has extended perm list (???) */
|
|
u8 has_ea: 1; /* entry has EA */
|
|
u8 last: 1; /* set on phony \377 entry */
|
|
u8 down: 1; /* down pointer present (after name) */
|
|
u8 has_acl: 1;
|
|
u8 first: 1; /* set on phony ^A^A (".") entry */
|
|
#endif
|
|
|
|
#ifdef __LITTLE_ENDIAN
|
|
u8 read_only: 1; /* dos attrib */
|
|
u8 hidden: 1; /* dos attrib */
|
|
u8 system: 1; /* dos attrib */
|
|
u8 flag11: 1; /* would be volume label dos attrib */
|
|
u8 directory: 1; /* dos attrib */
|
|
u8 archive: 1; /* dos attrib */
|
|
u8 not_8x3: 1; /* name is not 8.3 */
|
|
u8 flag15: 1;
|
|
#else
|
|
u8 flag15: 1;
|
|
u8 not_8x3: 1; /* name is not 8.3 */
|
|
u8 archive: 1; /* dos attrib */
|
|
u8 directory: 1; /* dos attrib */
|
|
u8 flag11: 1; /* would be volume label dos attrib */
|
|
u8 system: 1; /* dos attrib */
|
|
u8 hidden: 1; /* dos attrib */
|
|
u8 read_only: 1; /* dos attrib */
|
|
#endif
|
|
|
|
__le32 fnode; /* fnode giving allocation info */
|
|
__le32 write_date; /* mtime */
|
|
__le32 file_size; /* file length, bytes */
|
|
__le32 read_date; /* atime */
|
|
__le32 creation_date; /* ctime */
|
|
__le32 ea_size; /* total EA length, bytes */
|
|
u8 no_of_acls; /* number of ACL's (low 3 bits) */
|
|
u8 ix; /* code page index (of filename), see
|
|
struct code_page_data */
|
|
u8 namelen, name[1]; /* file name */
|
|
/* dnode_secno down; btree down pointer, if present,
|
|
follows name on next word boundary, or maybe it
|
|
precedes next dirent, which is on a word boundary. */
|
|
};
|
|
|
|
|
|
/* B+ tree: allocation info in fnodes and anodes */
|
|
|
|
/* dnodes point to fnodes which are responsible for listing the sectors
|
|
assigned to the file. This is done with trees of (length,address)
|
|
pairs. (Actually triples, of (length, file-address, disk-address)
|
|
which can represent holes. Find out if HPFS does that.)
|
|
At any rate, fnodes contain a small tree; if subtrees are needed
|
|
they occupy essentially a full block in anodes. A leaf-level tree node
|
|
has 3-word entries giving sector runs, a non-leaf node has 2-word
|
|
entries giving subtree pointers. A flag in the header says which. */
|
|
|
|
struct bplus_leaf_node
|
|
{
|
|
__le32 file_secno; /* first file sector in extent */
|
|
__le32 length; /* length, sectors */
|
|
__le32 disk_secno; /* first corresponding disk sector */
|
|
};
|
|
|
|
struct bplus_internal_node
|
|
{
|
|
__le32 file_secno; /* subtree maps sectors < this */
|
|
__le32 down; /* pointer to subtree */
|
|
};
|
|
|
|
enum {
|
|
BP_hbff = 1,
|
|
BP_fnode_parent = 0x20,
|
|
BP_binary_search = 0x40,
|
|
BP_internal = 0x80
|
|
};
|
|
struct bplus_header
|
|
{
|
|
u8 flags; /* bit 0 - high bit of first free entry offset
|
|
bit 5 - we're pointed to by an fnode,
|
|
the data btree or some ea or the
|
|
main ea bootage pointer ea_secno
|
|
bit 6 - suggest binary search (unused)
|
|
bit 7 - 1 -> (internal) tree of anodes
|
|
0 -> (leaf) list of extents */
|
|
u8 fill[3];
|
|
u8 n_free_nodes; /* free nodes in following array */
|
|
u8 n_used_nodes; /* used nodes in following array */
|
|
__le16 first_free; /* offset from start of header to
|
|
first free node in array */
|
|
union {
|
|
struct bplus_internal_node internal[0]; /* (internal) 2-word entries giving
|
|
subtree pointers */
|
|
struct bplus_leaf_node external[0]; /* (external) 3-word entries giving
|
|
sector runs */
|
|
} u;
|
|
};
|
|
|
|
static inline bool bp_internal(struct bplus_header *bp)
|
|
{
|
|
return bp->flags & BP_internal;
|
|
}
|
|
|
|
static inline bool bp_fnode_parent(struct bplus_header *bp)
|
|
{
|
|
return bp->flags & BP_fnode_parent;
|
|
}
|
|
|
|
/* fnode: root of allocation b+ tree, and EA's */
|
|
|
|
/* Every file and every directory has one fnode, pointed to by the directory
|
|
entry and pointing to the file's sectors or directory's root dnode. EA's
|
|
are also stored here, and there are said to be ACL's somewhere here too. */
|
|
|
|
#define FNODE_MAGIC 0xf7e40aae
|
|
|
|
enum {FNODE_anode = cpu_to_le16(2), FNODE_dir = cpu_to_le16(256)};
|
|
struct fnode
|
|
{
|
|
__le32 magic; /* f7e4 0aae */
|
|
__le32 zero1[2]; /* read history */
|
|
u8 len, name[15]; /* true length, truncated name */
|
|
__le32 up; /* pointer to file's directory fnode */
|
|
__le32 acl_size_l;
|
|
__le32 acl_secno;
|
|
__le16 acl_size_s;
|
|
u8 acl_anode;
|
|
u8 zero2; /* history bit count */
|
|
__le32 ea_size_l; /* length of disk-resident ea's */
|
|
__le32 ea_secno; /* first sector of disk-resident ea's*/
|
|
__le16 ea_size_s; /* length of fnode-resident ea's */
|
|
|
|
__le16 flags; /* bit 1 set -> ea_secno is an anode */
|
|
/* bit 8 set -> directory. first & only extent
|
|
points to dnode. */
|
|
struct bplus_header btree; /* b+ tree, 8 extents or 12 subtrees */
|
|
union {
|
|
struct bplus_leaf_node external[8];
|
|
struct bplus_internal_node internal[12];
|
|
} u;
|
|
|
|
__le32 file_size; /* file length, bytes */
|
|
__le32 n_needea; /* number of EA's with NEEDEA set */
|
|
u8 user_id[16]; /* unused */
|
|
__le16 ea_offs; /* offset from start of fnode
|
|
to first fnode-resident ea */
|
|
u8 dasd_limit_treshhold;
|
|
u8 dasd_limit_delta;
|
|
__le32 dasd_limit;
|
|
__le32 dasd_usage;
|
|
u8 ea[316]; /* zero or more EA's, packed together
|
|
with no alignment padding.
|
|
(Do not use this name, get here
|
|
via fnode + ea_offs. I think.) */
|
|
};
|
|
|
|
static inline bool fnode_in_anode(struct fnode *p)
|
|
{
|
|
return (p->flags & FNODE_anode) != 0;
|
|
}
|
|
|
|
static inline bool fnode_is_dir(struct fnode *p)
|
|
{
|
|
return (p->flags & FNODE_dir) != 0;
|
|
}
|
|
|
|
|
|
/* anode: 99.44% pure allocation tree */
|
|
|
|
#define ANODE_MAGIC 0x37e40aae
|
|
|
|
struct anode
|
|
{
|
|
__le32 magic; /* 37e4 0aae */
|
|
__le32 self; /* pointer to this anode */
|
|
__le32 up; /* parent anode or fnode */
|
|
|
|
struct bplus_header btree; /* b+tree, 40 extents or 60 subtrees */
|
|
union {
|
|
struct bplus_leaf_node external[40];
|
|
struct bplus_internal_node internal[60];
|
|
} u;
|
|
|
|
__le32 fill[3]; /* unused */
|
|
};
|
|
|
|
|
|
/* extended attributes.
|
|
|
|
A file's EA info is stored as a list of (name,value) pairs. It is
|
|
usually in the fnode, but (if it's large) it is moved to a single
|
|
sector run outside the fnode, or to multiple runs with an anode tree
|
|
that points to them.
|
|
|
|
The value of a single EA is stored along with the name, or (if large)
|
|
it is moved to a single sector run, or multiple runs pointed to by an
|
|
anode tree, pointed to by the value field of the (name,value) pair.
|
|
|
|
Flags in the EA tell whether the value is immediate, in a single sector
|
|
run, or in multiple runs. Flags in the fnode tell whether the EA list
|
|
is immediate, in a single run, or in multiple runs. */
|
|
|
|
enum {EA_indirect = 1, EA_anode = 2, EA_needea = 128 };
|
|
struct extended_attribute
|
|
{
|
|
u8 flags; /* bit 0 set -> value gives sector number
|
|
where real value starts */
|
|
/* bit 1 set -> sector is an anode
|
|
that points to fragmented value */
|
|
/* bit 7 set -> required ea */
|
|
u8 namelen; /* length of name, bytes */
|
|
u8 valuelen_lo; /* length of value, bytes */
|
|
u8 valuelen_hi; /* length of value, bytes */
|
|
u8 name[];
|
|
/*
|
|
u8 name[namelen]; ascii attrib name
|
|
u8 nul; terminating '\0', not counted
|
|
u8 value[valuelen]; value, arbitrary
|
|
if this.flags & 1, valuelen is 8 and the value is
|
|
u32 length; real length of value, bytes
|
|
secno secno; sector address where it starts
|
|
if this.anode, the above sector number is the root of an anode tree
|
|
which points to the value.
|
|
*/
|
|
};
|
|
|
|
static inline bool ea_indirect(struct extended_attribute *ea)
|
|
{
|
|
return ea->flags & EA_indirect;
|
|
}
|
|
|
|
static inline bool ea_in_anode(struct extended_attribute *ea)
|
|
{
|
|
return ea->flags & EA_anode;
|
|
}
|
|
|
|
/*
|
|
Local Variables:
|
|
comment-column: 40
|
|
End:
|
|
*/
|