]>
Commit | Line | Data |
---|---|---|
83d290c5 | 1 | /* SPDX-License-Identifier: GPL-2.0+ */ |
518e2e1a WD |
2 | /* |
3 | * Copyright 2000-2002 by Hans Reiser, licensing governed by reiserfs/README | |
4 | * | |
5 | * GRUB -- GRand Unified Bootloader | |
6 | * Copyright (C) 2000, 2001 Free Software Foundation, Inc. | |
7 | * | |
8 | * (C) Copyright 2003 - 2004 | |
9 | * Sysgo AG, <www.elinos.com>, Pavel Bartusek <pba@sysgo.com> | |
10 | * | |
518e2e1a WD |
11 | */ |
12 | ||
13 | /* An implementation for the ReiserFS filesystem ported from GRUB. | |
14 | * Some parts of this code (mainly the structures and defines) are | |
15 | * from the original reiser fs code, as found in the linux kernel. | |
16 | */ | |
17 | ||
18 | #ifndef __BYTE_ORDER | |
19 | #if defined(__LITTLE_ENDIAN) && !defined(__BIG_ENDIAN) | |
20 | #define __BYTE_ORDER __LITTLE_ENDIAN | |
21 | #elif defined(__BIG_ENDIAN) && !defined(__LITTLE_ENDIAN) | |
22 | #define __BYTE_ORDER __BIG_ENDIAN | |
23 | #else | |
24 | #error "unable to define __BYTE_ORDER" | |
25 | #endif | |
26 | #endif /* not __BYTE_ORDER */ | |
27 | ||
28 | #define FSYS_BUFLEN 0x8000 | |
29 | #define FSYS_BUF fsys_buf | |
30 | ||
31 | /* This is the new super block of a journaling reiserfs system */ | |
32 | struct reiserfs_super_block | |
33 | { | |
53677ef1 WD |
34 | __u32 s_block_count; /* blocks count */ |
35 | __u32 s_free_blocks; /* free blocks count */ | |
36 | __u32 s_root_block; /* root block number */ | |
37 | __u32 s_journal_block; /* journal block number */ | |
38 | __u32 s_journal_dev; /* journal device number */ | |
39 | __u32 s_journal_size; /* size of the journal on FS creation. used to make sure they don't overflow it */ | |
40 | __u32 s_journal_trans_max; /* max number of blocks in a transaction. */ | |
41 | __u32 s_journal_magic; /* random value made on fs creation */ | |
42 | __u32 s_journal_max_batch; /* max number of blocks to batch into a trans */ | |
43 | __u32 s_journal_max_commit_age; /* in seconds, how old can an async commit be */ | |
44 | __u32 s_journal_max_trans_age; /* in seconds, how old can a transaction be */ | |
45 | __u16 s_blocksize; /* block size */ | |
46 | __u16 s_oid_maxsize; /* max size of object id array */ | |
518e2e1a | 47 | __u16 s_oid_cursize; /* current size of object id array */ |
53677ef1 WD |
48 | __u16 s_state; /* valid or error */ |
49 | char s_magic[16]; /* reiserfs magic string indicates that file system is reiserfs */ | |
50 | __u16 s_tree_height; /* height of disk tree */ | |
51 | __u16 s_bmap_nr; /* amount of bitmap blocks needed to address each block of file system */ | |
518e2e1a WD |
52 | __u16 s_version; |
53 | char s_unused[128]; /* zero filled by mkreiserfs */ | |
54 | }; | |
55 | ||
56 | ||
53677ef1 WD |
57 | #define sb_root_block(sbp) (__le32_to_cpu((sbp)->s_root_block)) |
58 | #define sb_journal_block(sbp) (__le32_to_cpu((sbp)->s_journal_block)) | |
518e2e1a | 59 | #define set_sb_journal_block(sbp,v) ((sbp)->s_journal_block = __cpu_to_le32(v)) |
53677ef1 WD |
60 | #define sb_journal_size(sbp) (__le32_to_cpu((sbp)->s_journal_size)) |
61 | #define sb_blocksize(sbp) (__le16_to_cpu((sbp)->s_blocksize)) | |
518e2e1a | 62 | #define set_sb_blocksize(sbp,v) ((sbp)->s_blocksize = __cpu_to_le16(v)) |
53677ef1 WD |
63 | #define sb_version(sbp) (__le16_to_cpu((sbp)->s_version)) |
64 | #define set_sb_version(sbp,v) ((sbp)->s_version = __cpu_to_le16(v)) | |
518e2e1a WD |
65 | |
66 | ||
67 | #define REISERFS_MAX_SUPPORTED_VERSION 2 | |
68 | #define REISERFS_SUPER_MAGIC_STRING "ReIsErFs" | |
69 | #define REISER2FS_SUPER_MAGIC_STRING "ReIsEr2Fs" | |
70 | #define REISER3FS_SUPER_MAGIC_STRING "ReIsEr3Fs" | |
71 | ||
72 | #define MAX_HEIGHT 7 | |
73 | ||
74 | /* must be correct to keep the desc and commit structs at 4k */ | |
75 | #define JOURNAL_TRANS_HALF 1018 | |
76 | ||
77 | /* first block written in a commit. */ | |
78 | struct reiserfs_journal_desc { | |
79 | __u32 j_trans_id; /* id of commit */ | |
80 | __u32 j_len; /* length of commit. len +1 is the commit block */ | |
81 | __u32 j_mount_id; /* mount id of this trans*/ | |
82 | __u32 j_realblock[JOURNAL_TRANS_HALF]; /* real locations for the first blocks */ | |
83 | char j_magic[12]; | |
84 | }; | |
85 | ||
86 | /* last block written in a commit */ | |
87 | struct reiserfs_journal_commit { | |
88 | __u32 j_trans_id; /* must match j_trans_id from the desc block */ | |
89 | __u32 j_len; /* ditto */ | |
90 | __u32 j_realblock[JOURNAL_TRANS_HALF]; /* real locations for the last blocks */ | |
91 | char j_digest[16]; /* md5 sum of all the blocks involved, including desc and commit. not used, kill it */ | |
92 | }; | |
93 | ||
94 | /* this header block gets written whenever a transaction is considered | |
95 | fully flushed, and is more recent than the last fully flushed | |
96 | transaction. | |
97 | fully flushed means all the log blocks and all the real blocks are | |
98 | on disk, and this transaction does not need to be replayed. | |
99 | */ | |
100 | struct reiserfs_journal_header { | |
101 | /* id of last fully flushed transaction */ | |
102 | __u32 j_last_flush_trans_id; | |
103 | /* offset in the log of where to start replay after a crash */ | |
104 | __u32 j_first_unflushed_offset; | |
105 | /* mount id to detect very old transactions */ | |
106 | __u32 j_mount_id; | |
107 | }; | |
108 | ||
109 | /* magic string to find desc blocks in the journal */ | |
110 | #define JOURNAL_DESC_MAGIC "ReIsErLB" | |
111 | ||
112 | ||
113 | /* | |
114 | * directories use this key as well as old files | |
115 | */ | |
116 | struct offset_v1 | |
117 | { | |
118 | /* | |
119 | * for regular files this is the offset to the first byte of the | |
120 | * body, contained in the object-item, as measured from the start of | |
121 | * the entire body of the object. | |
122 | * | |
123 | * for directory entries, k_offset consists of hash derived from | |
124 | * hashing the name and using few bits (23 or more) of the resulting | |
125 | * hash, and generation number that allows distinguishing names with | |
126 | * hash collisions. If number of collisions overflows generation | |
53677ef1 | 127 | * number, we return EEXIST. High order bit is 0 always |
518e2e1a WD |
128 | */ |
129 | __u32 k_offset; | |
130 | __u32 k_uniqueness; | |
131 | }; | |
132 | ||
133 | struct offset_v2 { | |
134 | /* | |
135 | * for regular files this is the offset to the first byte of the | |
136 | * body, contained in the object-item, as measured from the start of | |
137 | * the entire body of the object. | |
138 | * | |
139 | * for directory entries, k_offset consists of hash derived from | |
140 | * hashing the name and using few bits (23 or more) of the resulting | |
141 | * hash, and generation number that allows distinguishing names with | |
142 | * hash collisions. If number of collisions overflows generation | |
53677ef1 | 143 | * number, we return EEXIST. High order bit is 0 always |
518e2e1a WD |
144 | */ |
145 | ||
146 | #if defined(__LITTLE_ENDIAN_BITFIELD) | |
04a85b3b WD |
147 | /* little endian version */ |
148 | __u64 k_offset:60; | |
149 | __u64 k_type: 4; | |
518e2e1a | 150 | #elif defined(__BIG_ENDIAN_BITFIELD) |
04a85b3b WD |
151 | /* big endian version */ |
152 | __u64 k_type: 4; | |
153 | __u64 k_offset:60; | |
518e2e1a WD |
154 | #else |
155 | #error "__LITTLE_ENDIAN_BITFIELD or __BIG_ENDIAN_BITFIELD must be defined" | |
156 | #endif | |
157 | } __attribute__ ((__packed__)); | |
158 | ||
159 | #define TYPE_MAXTYPE 3 | |
160 | #define TYPE_ANY 15 | |
161 | ||
162 | #if (__BYTE_ORDER == __BIG_ENDIAN) | |
163 | typedef union { | |
164 | struct offset_v2 offset_v2; | |
165 | __u64 linear; | |
166 | } __attribute__ ((__packed__)) offset_v2_esafe_overlay; | |
167 | ||
168 | static inline __u16 offset_v2_k_type( const struct offset_v2 *v2 ) | |
169 | { | |
170 | offset_v2_esafe_overlay tmp = *(const offset_v2_esafe_overlay *)v2; | |
171 | tmp.linear = __le64_to_cpu( tmp.linear ); | |
172 | return (tmp.offset_v2.k_type <= TYPE_MAXTYPE)?tmp.offset_v2.k_type:TYPE_ANY; | |
173 | } | |
174 | ||
175 | static inline loff_t offset_v2_k_offset( const struct offset_v2 *v2 ) | |
176 | { | |
177 | offset_v2_esafe_overlay tmp = *(const offset_v2_esafe_overlay *)v2; | |
178 | tmp.linear = __le64_to_cpu( tmp.linear ); | |
179 | return tmp.offset_v2.k_offset; | |
180 | } | |
181 | #elif (__BYTE_ORDER == __LITTLE_ENDIAN) | |
53677ef1 WD |
182 | # define offset_v2_k_type(v2) ((v2)->k_type) |
183 | # define offset_v2_k_offset(v2) ((v2)->k_offset) | |
518e2e1a WD |
184 | #else |
185 | #error "__BYTE_ORDER must be __LITTLE_ENDIAN or __BIG_ENDIAN" | |
186 | #endif | |
187 | ||
188 | struct key | |
189 | { | |
190 | /* packing locality: by default parent directory object id */ | |
191 | __u32 k_dir_id; | |
192 | /* object identifier */ | |
193 | __u32 k_objectid; | |
194 | /* the offset and node type (old and new form) */ | |
195 | union | |
196 | { | |
197 | struct offset_v1 v1; | |
198 | struct offset_v2 v2; | |
199 | } | |
200 | u; | |
201 | }; | |
202 | ||
203 | #define KEY_SIZE (sizeof (struct key)) | |
204 | ||
205 | /* Header of a disk block. More precisely, header of a formatted leaf | |
206 | or internal node, and not the header of an unformatted node. */ | |
207 | struct block_head | |
208 | { | |
53677ef1 WD |
209 | __u16 blk_level; /* Level of a block in the tree. */ |
210 | __u16 blk_nr_item; /* Number of keys/items in a block. */ | |
518e2e1a WD |
211 | __u16 blk_free_space; /* Block free space in bytes. */ |
212 | struct key blk_right_delim_key; /* Right delimiting key for this block (supported for leaf level nodes | |
213 | only) */ | |
214 | }; | |
215 | #define BLKH_SIZE (sizeof (struct block_head)) | |
53677ef1 | 216 | #define DISK_LEAF_NODE_LEVEL 1 /* Leaf node level. */ |
518e2e1a WD |
217 | |
218 | struct item_head | |
219 | { | |
220 | /* Everything in the tree is found by searching for it based on | |
221 | * its key.*/ | |
222 | struct key ih_key; | |
223 | union { | |
224 | /* The free space in the last unformatted node of an | |
225 | indirect item if this is an indirect item. This | |
226 | equals 0xFFFF iff this is a direct item or stat data | |
227 | item. Note that the key, not this field, is used to | |
228 | determine the item type, and thus which field this | |
229 | union contains. */ | |
230 | __u16 ih_free_space; | |
231 | /* Iff this is a directory item, this field equals the | |
232 | number of directory entries in the directory item. */ | |
233 | __u16 ih_entry_count; | |
234 | } __attribute__ ((__packed__)) u; | |
53677ef1 | 235 | __u16 ih_item_len; /* total size of the item body */ |
518e2e1a WD |
236 | __u16 ih_item_location; /* an offset to the item body |
237 | * within the block */ | |
238 | __u16 ih_version; /* 0 for all old items, 2 for new | |
239 | ones. Highest bit is set by fsck | |
240 | temporary, cleaned after all | |
241 | done */ | |
242 | } __attribute__ ((__packed__)); | |
243 | ||
53677ef1 | 244 | /* size of item header */ |
518e2e1a WD |
245 | #define IH_SIZE (sizeof (struct item_head)) |
246 | ||
247 | #define ITEM_VERSION_1 0 | |
248 | #define ITEM_VERSION_2 1 | |
249 | ||
53677ef1 | 250 | #define ih_version(ih) (__le16_to_cpu((ih)->ih_version)) |
518e2e1a WD |
251 | |
252 | #define IH_KEY_OFFSET(ih) (ih_version(ih) == ITEM_VERSION_1 \ | |
253 | ? __le32_to_cpu((ih)->ih_key.u.v1.k_offset) \ | |
254 | : offset_v2_k_offset(&((ih)->ih_key.u.v2))) | |
255 | ||
256 | #define IH_KEY_ISTYPE(ih, type) (ih_version(ih) == ITEM_VERSION_1 \ | |
257 | ? __le32_to_cpu((ih)->ih_key.u.v1.k_uniqueness) == V1_##type \ | |
258 | : offset_v2_k_type(&((ih)->ih_key.u.v2)) == V2_##type) | |
259 | ||
260 | /***************************************************************************/ | |
53677ef1 | 261 | /* DISK CHILD */ |
518e2e1a WD |
262 | /***************************************************************************/ |
263 | /* Disk child pointer: The pointer from an internal node of the tree | |
264 | to a node that is on disk. */ | |
265 | struct disk_child { | |
53677ef1 WD |
266 | __u32 dc_block_number; /* Disk child's block number. */ |
267 | __u16 dc_size; /* Disk child's used space. */ | |
518e2e1a WD |
268 | __u16 dc_reserved; |
269 | }; | |
270 | ||
271 | #define DC_SIZE (sizeof(struct disk_child)) | |
272 | #define dc_block_number(dc_p) (__le32_to_cpu((dc_p)->dc_block_number)) | |
273 | ||
274 | ||
b79a11cc WD |
275 | /* |
276 | * old stat data is 32 bytes long. We are going to distinguish new one by | |
277 | * different size | |
278 | */ | |
518e2e1a WD |
279 | struct stat_data_v1 |
280 | { | |
281 | __u16 sd_mode; /* file type, permissions */ | |
282 | __u16 sd_nlink; /* number of hard links */ | |
283 | __u16 sd_uid; /* owner */ | |
284 | __u16 sd_gid; /* group */ | |
285 | __u32 sd_size; /* file size */ | |
286 | __u32 sd_atime; /* time of last access */ | |
53677ef1 | 287 | __u32 sd_mtime; /* time file was last modified */ |
518e2e1a WD |
288 | __u32 sd_ctime; /* time inode (stat data) was last changed (except changes to sd_atime and sd_mtime) */ |
289 | union { | |
290 | __u32 sd_rdev; | |
291 | __u32 sd_blocks; /* number of blocks file uses */ | |
292 | } __attribute__ ((__packed__)) u; | |
293 | __u32 sd_first_direct_byte; /* first byte of file which is stored | |
294 | in a direct item: except that if it | |
295 | equals 1 it is a symlink and if it | |
296 | equals ~(__u32)0 there is no | |
297 | direct item. The existence of this | |
298 | field really grates on me. Let's | |
299 | replace it with a macro based on | |
300 | sd_size and our tail suppression | |
301 | policy. Someday. -Hans */ | |
302 | } __attribute__ ((__packed__)); | |
303 | ||
53677ef1 WD |
304 | #define stat_data_v1(ih) (ih_version(ih) == ITEM_VERSION_1) |
305 | #define sd_v1_mode(sdp) ((sdp)->sd_mode) | |
306 | #define sd_v1_nlink(sdp) (__le16_to_cpu((sdp)->sd_nlink)) | |
307 | #define sd_v1_uid(sdp) (__le16_to_cpu((sdp)->sd_uid)) | |
308 | #define sd_v1_gid(sdp) (__le16_to_cpu((sdp)->sd_gid)) | |
309 | #define sd_v1_size(sdp) (__le32_to_cpu((sdp)->sd_size)) | |
310 | #define sd_v1_mtime(sdp) (__le32_to_cpu((sdp)->sd_mtime)) | |
518e2e1a WD |
311 | |
312 | /* Stat Data on disk (reiserfs version of UFS disk inode minus the | |
313 | address blocks) */ | |
314 | struct stat_data { | |
315 | __u16 sd_mode; /* file type, permissions */ | |
53677ef1 | 316 | __u16 sd_attrs; /* persistent inode flags */ |
518e2e1a WD |
317 | __u32 sd_nlink; /* number of hard links */ |
318 | __u64 sd_size; /* file size */ | |
319 | __u32 sd_uid; /* owner */ | |
320 | __u32 sd_gid; /* group */ | |
321 | __u32 sd_atime; /* time of last access */ | |
53677ef1 | 322 | __u32 sd_mtime; /* time file was last modified */ |
518e2e1a WD |
323 | __u32 sd_ctime; /* time inode (stat data) was last changed (except changes to sd_atime and sd_mtime) */ |
324 | __u32 sd_blocks; | |
325 | union { | |
326 | __u32 sd_rdev; | |
327 | __u32 sd_generation; | |
b79a11cc | 328 | /*__u32 sd_first_direct_byte; */ |
518e2e1a WD |
329 | /* first byte of file which is stored in a |
330 | direct item: except that if it equals 1 | |
331 | it is a symlink and if it equals | |
332 | ~(__u32)0 there is no direct item. The | |
333 | existence of this field really grates | |
334 | on me. Let's replace it with a macro | |
335 | based on sd_size and our tail | |
336 | suppression policy? */ | |
337 | } __attribute__ ((__packed__)) u; | |
338 | } __attribute__ ((__packed__)); | |
339 | ||
53677ef1 WD |
340 | #define stat_data_v2(ih) (ih_version(ih) == ITEM_VERSION_2) |
341 | #define sd_v2_mode(sdp) (__le16_to_cpu((sdp)->sd_mode)) | |
342 | #define sd_v2_nlink(sdp) (__le32_to_cpu((sdp)->sd_nlink)) | |
343 | #define sd_v2_size(sdp) (__le64_to_cpu((sdp)->sd_size)) | |
344 | #define sd_v2_uid(sdp) (__le32_to_cpu((sdp)->sd_uid)) | |
345 | #define sd_v2_gid(sdp) (__le32_to_cpu((sdp)->sd_gid)) | |
346 | #define sd_v2_mtime(sdp) (__le32_to_cpu((sdp)->sd_mtime)) | |
518e2e1a | 347 | |
53677ef1 WD |
348 | #define sd_mode(sdp) (__le16_to_cpu((sdp)->sd_mode)) |
349 | #define sd_size(sdp) (__le32_to_cpu((sdp)->sd_size)) | |
518e2e1a WD |
350 | #define sd_size_hi(sdp) (__le32_to_cpu((sdp)->sd_size_hi)) |
351 | ||
352 | struct reiserfs_de_head | |
353 | { | |
354 | __u32 deh_offset; /* third component of the directory entry key */ | |
355 | __u32 deh_dir_id; /* objectid of the parent directory of the | |
356 | object, that is referenced by directory entry */ | |
357 | __u32 deh_objectid;/* objectid of the object, that is referenced by | |
04a85b3b | 358 | directory entry */ |
518e2e1a WD |
359 | __u16 deh_location;/* offset of name in the whole item */ |
360 | __u16 deh_state; /* whether 1) entry contains stat data (for | |
361 | future), and 2) whether entry is hidden | |
362 | (unlinked) */ | |
363 | }; | |
364 | ||
365 | #define DEH_SIZE (sizeof (struct reiserfs_de_head)) | |
53677ef1 WD |
366 | #define deh_offset(p_deh) (__le32_to_cpu((p_deh)->deh_offset)) |
367 | #define deh_dir_id(p_deh) (__le32_to_cpu((p_deh)->deh_dir_id)) | |
368 | #define deh_objectid(p_deh) (__le32_to_cpu((p_deh)->deh_objectid)) | |
369 | #define deh_location(p_deh) (__le16_to_cpu((p_deh)->deh_location)) | |
370 | #define deh_state(p_deh) (__le16_to_cpu((p_deh)->deh_state)) | |
518e2e1a WD |
371 | |
372 | ||
373 | #define DEH_Statdata (1 << 0) /* not used now */ | |
374 | #define DEH_Visible (1 << 2) | |
375 | ||
376 | #define SD_OFFSET 0 | |
377 | #define SD_UNIQUENESS 0 | |
378 | #define DOT_OFFSET 1 | |
379 | #define DOT_DOT_OFFSET 2 | |
380 | #define DIRENTRY_UNIQUENESS 500 | |
381 | ||
382 | #define V1_TYPE_STAT_DATA 0x0 | |
383 | #define V1_TYPE_DIRECT 0xffffffff | |
384 | #define V1_TYPE_INDIRECT 0xfffffffe | |
385 | #define V1_TYPE_DIRECTORY_MAX 0xfffffffd | |
386 | #define V2_TYPE_STAT_DATA 0 | |
387 | #define V2_TYPE_INDIRECT 1 | |
388 | #define V2_TYPE_DIRECT 2 | |
389 | #define V2_TYPE_DIRENTRY 3 | |
390 | ||
391 | #define REISERFS_ROOT_OBJECTID 2 | |
392 | #define REISERFS_ROOT_PARENT_OBJECTID 1 | |
393 | #define REISERFS_DISK_OFFSET_IN_BYTES (64 * 1024) | |
394 | /* the spot for the super in versions 3.5 - 3.5.11 (inclusive) */ | |
395 | #define REISERFS_OLD_DISK_OFFSET_IN_BYTES (8 * 1024) | |
396 | #define REISERFS_OLD_BLOCKSIZE 4096 | |
397 | ||
398 | #define S_ISREG(mode) (((mode) & 0170000) == 0100000) | |
399 | #define S_ISDIR(mode) (((mode) & 0170000) == 0040000) | |
400 | #define S_ISLNK(mode) (((mode) & 0170000) == 0120000) | |
401 | ||
402 | #define PATH_MAX 1024 /* include/linux/limits.h */ | |
53677ef1 | 403 | #define MAX_LINK_COUNT 5 /* number of symbolic links to follow */ |
518e2e1a WD |
404 | |
405 | /* The size of the node cache */ | |
406 | #define FSYSREISER_CACHE_SIZE 24*1024 | |
407 | #define FSYSREISER_MIN_BLOCKSIZE SECTOR_SIZE | |
408 | #define FSYSREISER_MAX_BLOCKSIZE FSYSREISER_CACHE_SIZE / 3 | |
409 | ||
410 | /* Info about currently opened file */ | |
411 | struct fsys_reiser_fileinfo | |
412 | { | |
413 | __u32 k_dir_id; | |
414 | __u32 k_objectid; | |
415 | }; | |
416 | ||
417 | /* In memory info about the currently mounted filesystem */ | |
418 | struct fsys_reiser_info | |
419 | { | |
420 | /* The last read item head */ | |
421 | struct item_head *current_ih; | |
422 | /* The last read item */ | |
423 | char *current_item; | |
424 | /* The information for the currently opened file */ | |
425 | struct fsys_reiser_fileinfo fileinfo; | |
426 | /* The start of the journal */ | |
427 | __u32 journal_block; | |
428 | /* The size of the journal */ | |
429 | __u32 journal_block_count; | |
430 | /* The first valid descriptor block in journal | |
431 | (relative to journal_block) */ | |
432 | __u32 journal_first_desc; | |
433 | ||
434 | /* The ReiserFS version. */ | |
435 | __u16 version; | |
436 | /* The current depth of the reiser tree. */ | |
437 | __u16 tree_depth; | |
438 | /* SECTOR_SIZE << blocksize_shift == blocksize. */ | |
53677ef1 | 439 | __u8 blocksize_shift; |
518e2e1a | 440 | /* 1 << full_blocksize_shift == blocksize. */ |
53677ef1 | 441 | __u8 fullblocksize_shift; |
518e2e1a WD |
442 | /* The reiserfs block size (must be a power of 2) */ |
443 | __u16 blocksize; | |
444 | /* The number of cached tree nodes */ | |
445 | __u16 cached_slots; | |
446 | /* The number of valid transactions in journal */ | |
447 | __u16 journal_transactions; | |
448 | ||
449 | unsigned int blocks[MAX_HEIGHT]; | |
450 | unsigned int next_key_nr[MAX_HEIGHT]; | |
451 | }; | |
452 | ||
453 | /* The cached s+tree blocks in FSYS_BUF, see below | |
454 | * for a more detailed description. | |
455 | */ | |
53677ef1 | 456 | #define ROOT ((char *) ((int) FSYS_BUF)) |
518e2e1a | 457 | #define CACHE(i) (ROOT + ((i) << INFO->fullblocksize_shift)) |
53677ef1 | 458 | #define LEAF CACHE (DISK_LEAF_NODE_LEVEL) |
518e2e1a WD |
459 | |
460 | #define BLOCKHEAD(cache) ((struct block_head *) cache) | |
53677ef1 WD |
461 | #define ITEMHEAD ((struct item_head *) ((int) LEAF + BLKH_SIZE)) |
462 | #define KEY(cache) ((struct key *) ((int) cache + BLKH_SIZE)) | |
463 | #define DC(cache) ((struct disk_child *) \ | |
518e2e1a WD |
464 | ((int) cache + BLKH_SIZE + KEY_SIZE * nr_item)) |
465 | /* The fsys_reiser_info block. | |
466 | */ | |
467 | #define INFO \ | |
468 | ((struct fsys_reiser_info *) ((int) FSYS_BUF + FSYSREISER_CACHE_SIZE)) | |
469 | /* | |
470 | * The journal cache. For each transaction it contains the number of | |
471 | * blocks followed by the real block numbers of this transaction. | |
472 | * | |
473 | * If the block numbers of some transaction won't fit in this space, | |
474 | * this list is stopped with a 0xffffffff marker and the remaining | |
475 | * uncommitted transactions aren't cached. | |
476 | */ | |
53677ef1 WD |
477 | #define JOURNAL_START ((__u32 *) (INFO + 1)) |
478 | #define JOURNAL_END ((__u32 *) (FSYS_BUF + FSYS_BUFLEN)) | |
518e2e1a WD |
479 | |
480 | ||
481 | static __inline__ unsigned long | |
482 | log2 (unsigned long word) | |
483 | { | |
484 | #ifdef __I386__ | |
485 | __asm__ ("bsfl %1,%0" | |
486 | : "=r" (word) | |
487 | : "r" (word)); | |
488 | return word; | |
489 | #else | |
490 | int i; | |
491 | ||
492 | for(i=0; i<(8*sizeof(word)); i++) | |
493 | if ((1<<i) & word) | |
494 | return i; | |
495 | ||
496 | return 0; | |
497 | #endif | |
498 | } | |
499 | ||
500 | static __inline__ int | |
501 | is_power_of_two (unsigned long word) | |
502 | { | |
503 | return (word & -word) == word; | |
504 | } | |
505 | ||
506 | extern const char *bb_mode_string(int mode); | |
507 | extern int reiserfs_devread (int sector, int byte_offset, int byte_len, char *buf); |