1*83d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+
2518e2e1aSwdenk /*
3518e2e1aSwdenk * Copyright 2000-2002 by Hans Reiser, licensing governed by reiserfs/README
4518e2e1aSwdenk *
5518e2e1aSwdenk * GRUB -- GRand Unified Bootloader
6518e2e1aSwdenk * Copyright (C) 2000, 2001 Free Software Foundation, Inc.
7518e2e1aSwdenk *
8518e2e1aSwdenk * (C) Copyright 2003 - 2004
9518e2e1aSwdenk * Sysgo AG, <www.elinos.com>, Pavel Bartusek <pba@sysgo.com>
10518e2e1aSwdenk *
11518e2e1aSwdenk */
12518e2e1aSwdenk
13518e2e1aSwdenk /* An implementation for the ReiserFS filesystem ported from GRUB.
14518e2e1aSwdenk * Some parts of this code (mainly the structures and defines) are
15518e2e1aSwdenk * from the original reiser fs code, as found in the linux kernel.
16518e2e1aSwdenk */
17518e2e1aSwdenk
18518e2e1aSwdenk #include <common.h>
19518e2e1aSwdenk #include <malloc.h>
20518e2e1aSwdenk #include <linux/ctype.h>
21518e2e1aSwdenk #include <linux/time.h>
22518e2e1aSwdenk #include <asm/byteorder.h>
23518e2e1aSwdenk #include <reiserfs.h>
24518e2e1aSwdenk
25518e2e1aSwdenk #include "reiserfs_private.h"
26518e2e1aSwdenk
27518e2e1aSwdenk #undef REISERDEBUG
28518e2e1aSwdenk
29518e2e1aSwdenk /* Some parts of this code (mainly the structures and defines) are
30518e2e1aSwdenk * from the original reiser fs code, as found in the linux kernel.
31518e2e1aSwdenk */
32518e2e1aSwdenk
33518e2e1aSwdenk static char fsys_buf[FSYS_BUFLEN];
34518e2e1aSwdenk static reiserfs_error_t errnum = ERR_NONE;
35518e2e1aSwdenk static int print_possibilities;
36518e2e1aSwdenk static unsigned int filepos, filemax;
37518e2e1aSwdenk
38518e2e1aSwdenk static int
substring(const char * s1,const char * s2)39518e2e1aSwdenk substring (const char *s1, const char *s2)
40518e2e1aSwdenk {
41518e2e1aSwdenk while (*s1 == *s2)
42518e2e1aSwdenk {
43518e2e1aSwdenk /* The strings match exactly. */
44518e2e1aSwdenk if (! *(s1++))
45518e2e1aSwdenk return 0;
46518e2e1aSwdenk s2 ++;
47518e2e1aSwdenk }
48518e2e1aSwdenk
49518e2e1aSwdenk /* S1 is a substring of S2. */
50518e2e1aSwdenk if (*s1 == 0)
51518e2e1aSwdenk return -1;
52518e2e1aSwdenk
53518e2e1aSwdenk /* S1 isn't a substring. */
54518e2e1aSwdenk return 1;
55518e2e1aSwdenk }
56518e2e1aSwdenk
sd_print_item(struct item_head * ih,char * item)57518e2e1aSwdenk static void sd_print_item (struct item_head * ih, char * item)
58518e2e1aSwdenk {
59518e2e1aSwdenk char filetime[30];
60518e2e1aSwdenk time_t ttime;
61518e2e1aSwdenk
62518e2e1aSwdenk if (stat_data_v1 (ih)) {
63518e2e1aSwdenk struct stat_data_v1 * sd = (struct stat_data_v1 *)item;
64518e2e1aSwdenk ttime = sd_v1_mtime(sd);
65518e2e1aSwdenk ctime_r(&ttime, filetime);
66518e2e1aSwdenk printf ("%-10s %4hd %6d %6d %9d %24.24s",
67518e2e1aSwdenk bb_mode_string(sd_v1_mode(sd)), sd_v1_nlink(sd),sd_v1_uid(sd), sd_v1_gid(sd),
68518e2e1aSwdenk sd_v1_size(sd), filetime);
69518e2e1aSwdenk } else {
70518e2e1aSwdenk struct stat_data * sd = (struct stat_data *)item;
71518e2e1aSwdenk ttime = sd_v2_mtime(sd);
72518e2e1aSwdenk ctime_r(&ttime, filetime);
73518e2e1aSwdenk printf ("%-10s %4d %6d %6d %9d %24.24s",
74518e2e1aSwdenk bb_mode_string(sd_v2_mode(sd)), sd_v2_nlink(sd),sd_v2_uid(sd),sd_v2_gid(sd),
75518e2e1aSwdenk (__u32) sd_v2_size(sd), filetime);
76518e2e1aSwdenk }
77518e2e1aSwdenk }
78518e2e1aSwdenk
79518e2e1aSwdenk static int
journal_read(int block,int len,char * buffer)80518e2e1aSwdenk journal_read (int block, int len, char *buffer)
81518e2e1aSwdenk {
82518e2e1aSwdenk return reiserfs_devread ((INFO->journal_block + block) << INFO->blocksize_shift,
83518e2e1aSwdenk 0, len, buffer);
84518e2e1aSwdenk }
85518e2e1aSwdenk
86518e2e1aSwdenk /* Read a block from ReiserFS file system, taking the journal into
87518e2e1aSwdenk * account. If the block nr is in the journal, the block from the
88518e2e1aSwdenk * journal taken.
89518e2e1aSwdenk */
90518e2e1aSwdenk static int
block_read(unsigned int blockNr,int start,int len,char * buffer)91518e2e1aSwdenk block_read (unsigned int blockNr, int start, int len, char *buffer)
92518e2e1aSwdenk {
93518e2e1aSwdenk int transactions = INFO->journal_transactions;
94518e2e1aSwdenk int desc_block = INFO->journal_first_desc;
95518e2e1aSwdenk int journal_mask = INFO->journal_block_count - 1;
96518e2e1aSwdenk int translatedNr = blockNr;
97518e2e1aSwdenk __u32 *journal_table = JOURNAL_START;
98518e2e1aSwdenk while (transactions-- > 0)
99518e2e1aSwdenk {
100518e2e1aSwdenk int i = 0;
101518e2e1aSwdenk int j_len;
102518e2e1aSwdenk if (__le32_to_cpu(*journal_table) != 0xffffffff)
103518e2e1aSwdenk {
104518e2e1aSwdenk /* Search for the blockNr in cached journal */
105518e2e1aSwdenk j_len = __le32_to_cpu(*journal_table++);
106518e2e1aSwdenk while (i++ < j_len)
107518e2e1aSwdenk {
108518e2e1aSwdenk if (__le32_to_cpu(*journal_table++) == blockNr)
109518e2e1aSwdenk {
110518e2e1aSwdenk journal_table += j_len - i;
111518e2e1aSwdenk goto found;
112518e2e1aSwdenk }
113518e2e1aSwdenk }
114518e2e1aSwdenk }
115518e2e1aSwdenk else
116518e2e1aSwdenk {
117518e2e1aSwdenk /* This is the end of cached journal marker. The remaining
118518e2e1aSwdenk * transactions are still on disk.
119518e2e1aSwdenk */
120518e2e1aSwdenk struct reiserfs_journal_desc desc;
121518e2e1aSwdenk struct reiserfs_journal_commit commit;
122518e2e1aSwdenk
123518e2e1aSwdenk if (! journal_read (desc_block, sizeof (desc), (char *) &desc))
124518e2e1aSwdenk return 0;
125518e2e1aSwdenk
126518e2e1aSwdenk j_len = __le32_to_cpu(desc.j_len);
127518e2e1aSwdenk while (i < j_len && i < JOURNAL_TRANS_HALF)
128518e2e1aSwdenk if (__le32_to_cpu(desc.j_realblock[i++]) == blockNr)
129518e2e1aSwdenk goto found;
130518e2e1aSwdenk
131518e2e1aSwdenk if (j_len >= JOURNAL_TRANS_HALF)
132518e2e1aSwdenk {
133518e2e1aSwdenk int commit_block = (desc_block + 1 + j_len) & journal_mask;
134518e2e1aSwdenk if (! journal_read (commit_block,
135518e2e1aSwdenk sizeof (commit), (char *) &commit))
136518e2e1aSwdenk return 0;
137518e2e1aSwdenk while (i < j_len)
138518e2e1aSwdenk if (__le32_to_cpu(commit.j_realblock[i++ - JOURNAL_TRANS_HALF]) == blockNr)
139518e2e1aSwdenk goto found;
140518e2e1aSwdenk }
141518e2e1aSwdenk }
142518e2e1aSwdenk goto not_found;
143518e2e1aSwdenk
144518e2e1aSwdenk found:
145518e2e1aSwdenk translatedNr = INFO->journal_block + ((desc_block + i) & journal_mask);
146518e2e1aSwdenk #ifdef REISERDEBUG
147518e2e1aSwdenk printf ("block_read: block %d is mapped to journal block %d.\n",
148518e2e1aSwdenk blockNr, translatedNr - INFO->journal_block);
149518e2e1aSwdenk #endif
150518e2e1aSwdenk /* We must continue the search, as this block may be overwritten
151518e2e1aSwdenk * in later transactions.
152518e2e1aSwdenk */
153518e2e1aSwdenk not_found:
154518e2e1aSwdenk desc_block = (desc_block + 2 + j_len) & journal_mask;
155518e2e1aSwdenk }
156518e2e1aSwdenk return reiserfs_devread (translatedNr << INFO->blocksize_shift, start, len, buffer);
157518e2e1aSwdenk }
158518e2e1aSwdenk
159518e2e1aSwdenk /* Init the journal data structure. We try to cache as much as
160518e2e1aSwdenk * possible in the JOURNAL_START-JOURNAL_END space, but if it is full
161518e2e1aSwdenk * we can still read the rest from the disk on demand.
162518e2e1aSwdenk *
163518e2e1aSwdenk * The first number of valid transactions and the descriptor block of the
164518e2e1aSwdenk * first valid transaction are held in INFO. The transactions are all
165518e2e1aSwdenk * adjacent, but we must take care of the journal wrap around.
166518e2e1aSwdenk */
167518e2e1aSwdenk static int
journal_init(void)168518e2e1aSwdenk journal_init (void)
169518e2e1aSwdenk {
170518e2e1aSwdenk unsigned int block_count = INFO->journal_block_count;
171518e2e1aSwdenk unsigned int desc_block;
172518e2e1aSwdenk unsigned int commit_block;
173518e2e1aSwdenk unsigned int next_trans_id;
174518e2e1aSwdenk struct reiserfs_journal_header header;
175518e2e1aSwdenk struct reiserfs_journal_desc desc;
176518e2e1aSwdenk struct reiserfs_journal_commit commit;
177518e2e1aSwdenk __u32 *journal_table = JOURNAL_START;
178518e2e1aSwdenk
179518e2e1aSwdenk journal_read (block_count, sizeof (header), (char *) &header);
180518e2e1aSwdenk desc_block = __le32_to_cpu(header.j_first_unflushed_offset);
181518e2e1aSwdenk if (desc_block >= block_count)
182518e2e1aSwdenk return 0;
183518e2e1aSwdenk
184518e2e1aSwdenk INFO->journal_first_desc = desc_block;
185518e2e1aSwdenk next_trans_id = __le32_to_cpu(header.j_last_flush_trans_id) + 1;
186518e2e1aSwdenk
187518e2e1aSwdenk #ifdef REISERDEBUG
188518e2e1aSwdenk printf ("journal_init: last flushed %d\n",
189518e2e1aSwdenk __le32_to_cpu(header.j_last_flush_trans_id));
190518e2e1aSwdenk #endif
191518e2e1aSwdenk
192518e2e1aSwdenk while (1)
193518e2e1aSwdenk {
194518e2e1aSwdenk journal_read (desc_block, sizeof (desc), (char *) &desc);
195518e2e1aSwdenk if (substring (JOURNAL_DESC_MAGIC, desc.j_magic) > 0
196518e2e1aSwdenk || __le32_to_cpu(desc.j_trans_id) != next_trans_id
197518e2e1aSwdenk || __le32_to_cpu(desc.j_mount_id) != __le32_to_cpu(header.j_mount_id))
198518e2e1aSwdenk /* no more valid transactions */
199518e2e1aSwdenk break;
200518e2e1aSwdenk
201518e2e1aSwdenk commit_block = (desc_block + __le32_to_cpu(desc.j_len) + 1) & (block_count - 1);
202518e2e1aSwdenk journal_read (commit_block, sizeof (commit), (char *) &commit);
203518e2e1aSwdenk if (__le32_to_cpu(desc.j_trans_id) != commit.j_trans_id
204518e2e1aSwdenk || __le32_to_cpu(desc.j_len) != __le32_to_cpu(commit.j_len))
205518e2e1aSwdenk /* no more valid transactions */
206518e2e1aSwdenk break;
207518e2e1aSwdenk
208518e2e1aSwdenk #ifdef REISERDEBUG
209518e2e1aSwdenk printf ("Found valid transaction %d/%d at %d.\n",
210518e2e1aSwdenk __le32_to_cpu(desc.j_trans_id), __le32_to_cpu(desc.j_mount_id), desc_block);
211518e2e1aSwdenk #endif
212518e2e1aSwdenk
213518e2e1aSwdenk next_trans_id++;
214518e2e1aSwdenk if (journal_table < JOURNAL_END)
215518e2e1aSwdenk {
216518e2e1aSwdenk if ((journal_table + 1 + __le32_to_cpu(desc.j_len)) >= JOURNAL_END)
217518e2e1aSwdenk {
218518e2e1aSwdenk /* The table is almost full; mark the end of the cached
219518e2e1aSwdenk * journal.*/
220518e2e1aSwdenk *journal_table = __cpu_to_le32(0xffffffff);
221518e2e1aSwdenk journal_table = JOURNAL_END;
222518e2e1aSwdenk }
223518e2e1aSwdenk else
224518e2e1aSwdenk {
225518e2e1aSwdenk unsigned int i;
226518e2e1aSwdenk /* Cache the length and the realblock numbers in the table.
227518e2e1aSwdenk * The block number of descriptor can easily be computed.
228518e2e1aSwdenk * and need not to be stored here.
229518e2e1aSwdenk */
230518e2e1aSwdenk
231518e2e1aSwdenk /* both are in the little endian format */
232518e2e1aSwdenk *journal_table++ = desc.j_len;
233518e2e1aSwdenk for (i = 0; i < __le32_to_cpu(desc.j_len) && i < JOURNAL_TRANS_HALF; i++)
234518e2e1aSwdenk {
235518e2e1aSwdenk /* both are in the little endian format */
236518e2e1aSwdenk *journal_table++ = desc.j_realblock[i];
237518e2e1aSwdenk #ifdef REISERDEBUG
238518e2e1aSwdenk printf ("block %d is in journal %d.\n",
239518e2e1aSwdenk __le32_to_cpu(desc.j_realblock[i]), desc_block);
240518e2e1aSwdenk #endif
241518e2e1aSwdenk }
242518e2e1aSwdenk for ( ; i < __le32_to_cpu(desc.j_len); i++)
243518e2e1aSwdenk {
244518e2e1aSwdenk /* both are in the little endian format */
245518e2e1aSwdenk *journal_table++ = commit.j_realblock[i-JOURNAL_TRANS_HALF];
246518e2e1aSwdenk #ifdef REISERDEBUG
247518e2e1aSwdenk printf ("block %d is in journal %d.\n",
248518e2e1aSwdenk __le32_to_cpu(commit.j_realblock[i-JOURNAL_TRANS_HALF]),
249518e2e1aSwdenk desc_block);
250518e2e1aSwdenk #endif
251518e2e1aSwdenk }
252518e2e1aSwdenk }
253518e2e1aSwdenk }
254518e2e1aSwdenk desc_block = (commit_block + 1) & (block_count - 1);
255518e2e1aSwdenk }
256518e2e1aSwdenk #ifdef REISERDEBUG
257518e2e1aSwdenk printf ("Transaction %d/%d at %d isn't valid.\n",
258518e2e1aSwdenk __le32_to_cpu(desc.j_trans_id), __le32_to_cpu(desc.j_mount_id), desc_block);
259518e2e1aSwdenk #endif
260518e2e1aSwdenk
261518e2e1aSwdenk INFO->journal_transactions
262518e2e1aSwdenk = next_trans_id - __le32_to_cpu(header.j_last_flush_trans_id) - 1;
263518e2e1aSwdenk return errnum == 0;
264518e2e1aSwdenk }
265518e2e1aSwdenk
266518e2e1aSwdenk /* check filesystem types and read superblock into memory buffer */
267518e2e1aSwdenk int
reiserfs_mount(unsigned part_length)268518e2e1aSwdenk reiserfs_mount (unsigned part_length)
269518e2e1aSwdenk {
270518e2e1aSwdenk struct reiserfs_super_block super;
271518e2e1aSwdenk int superblock = REISERFS_DISK_OFFSET_IN_BYTES >> SECTOR_BITS;
272fa75f515SAnatolij Gustschin char *cache;
273518e2e1aSwdenk
274518e2e1aSwdenk if (part_length < superblock + (sizeof (super) >> SECTOR_BITS)
275518e2e1aSwdenk || ! reiserfs_devread (superblock, 0, sizeof (struct reiserfs_super_block),
276518e2e1aSwdenk (char *) &super)
277518e2e1aSwdenk || (substring (REISER3FS_SUPER_MAGIC_STRING, super.s_magic) > 0
278518e2e1aSwdenk && substring (REISER2FS_SUPER_MAGIC_STRING, super.s_magic) > 0
279518e2e1aSwdenk && substring (REISERFS_SUPER_MAGIC_STRING, super.s_magic) > 0)
280518e2e1aSwdenk || (/* check that this is not a copy inside the journal log */
281518e2e1aSwdenk sb_journal_block(&super) * sb_blocksize(&super)
282518e2e1aSwdenk <= REISERFS_DISK_OFFSET_IN_BYTES))
283518e2e1aSwdenk {
284518e2e1aSwdenk /* Try old super block position */
285518e2e1aSwdenk superblock = REISERFS_OLD_DISK_OFFSET_IN_BYTES >> SECTOR_BITS;
286518e2e1aSwdenk if (part_length < superblock + (sizeof (super) >> SECTOR_BITS)
287518e2e1aSwdenk || ! reiserfs_devread (superblock, 0, sizeof (struct reiserfs_super_block),
288518e2e1aSwdenk (char *) &super))
289518e2e1aSwdenk return 0;
290518e2e1aSwdenk
291518e2e1aSwdenk if (substring (REISER2FS_SUPER_MAGIC_STRING, super.s_magic) > 0
292518e2e1aSwdenk && substring (REISERFS_SUPER_MAGIC_STRING, super.s_magic) > 0)
293518e2e1aSwdenk {
294518e2e1aSwdenk /* pre journaling super block ? */
295518e2e1aSwdenk if (substring (REISERFS_SUPER_MAGIC_STRING,
296518e2e1aSwdenk (char*) ((int) &super + 20)) > 0)
297518e2e1aSwdenk return 0;
298518e2e1aSwdenk
299518e2e1aSwdenk set_sb_blocksize(&super, REISERFS_OLD_BLOCKSIZE);
300518e2e1aSwdenk set_sb_journal_block(&super, 0);
301518e2e1aSwdenk set_sb_version(&super, 0);
302518e2e1aSwdenk }
303518e2e1aSwdenk }
304518e2e1aSwdenk
305518e2e1aSwdenk /* check the version number. */
306518e2e1aSwdenk if (sb_version(&super) > REISERFS_MAX_SUPPORTED_VERSION)
307518e2e1aSwdenk return 0;
308518e2e1aSwdenk
309518e2e1aSwdenk INFO->version = sb_version(&super);
310518e2e1aSwdenk INFO->blocksize = sb_blocksize(&super);
311518e2e1aSwdenk INFO->fullblocksize_shift = log2 (sb_blocksize(&super));
312518e2e1aSwdenk INFO->blocksize_shift = INFO->fullblocksize_shift - SECTOR_BITS;
313518e2e1aSwdenk INFO->cached_slots =
314518e2e1aSwdenk (FSYSREISER_CACHE_SIZE >> INFO->fullblocksize_shift) - 1;
315518e2e1aSwdenk
316518e2e1aSwdenk #ifdef REISERDEBUG
317518e2e1aSwdenk printf ("reiserfs_mount: version=%d, blocksize=%d\n",
318518e2e1aSwdenk INFO->version, INFO->blocksize);
319518e2e1aSwdenk #endif /* REISERDEBUG */
320518e2e1aSwdenk
321518e2e1aSwdenk /* Clear node cache. */
322518e2e1aSwdenk memset (INFO->blocks, 0, sizeof (INFO->blocks));
323518e2e1aSwdenk
324518e2e1aSwdenk if (sb_blocksize(&super) < FSYSREISER_MIN_BLOCKSIZE
325518e2e1aSwdenk || sb_blocksize(&super) > FSYSREISER_MAX_BLOCKSIZE
326518e2e1aSwdenk || (SECTOR_SIZE << INFO->blocksize_shift) != sb_blocksize(&super))
327518e2e1aSwdenk return 0;
328518e2e1aSwdenk
329518e2e1aSwdenk /* Initialize journal code. If something fails we end with zero
330518e2e1aSwdenk * journal_transactions, so we don't access the journal at all.
331518e2e1aSwdenk */
332518e2e1aSwdenk INFO->journal_transactions = 0;
333518e2e1aSwdenk if (sb_journal_block(&super) != 0 && super.s_journal_dev == 0)
334518e2e1aSwdenk {
335518e2e1aSwdenk INFO->journal_block = sb_journal_block(&super);
336518e2e1aSwdenk INFO->journal_block_count = sb_journal_size(&super);
337518e2e1aSwdenk if (is_power_of_two (INFO->journal_block_count))
338518e2e1aSwdenk journal_init ();
339518e2e1aSwdenk
340518e2e1aSwdenk /* Read in super block again, maybe it is in the journal */
341518e2e1aSwdenk block_read (superblock >> INFO->blocksize_shift,
342518e2e1aSwdenk 0, sizeof (struct reiserfs_super_block), (char *) &super);
343518e2e1aSwdenk }
344518e2e1aSwdenk
345518e2e1aSwdenk if (! block_read (sb_root_block(&super), 0, INFO->blocksize, (char*) ROOT))
346518e2e1aSwdenk return 0;
347518e2e1aSwdenk
348fa75f515SAnatolij Gustschin cache = ROOT;
349fa75f515SAnatolij Gustschin INFO->tree_depth = __le16_to_cpu(BLOCKHEAD (cache)->blk_level);
350518e2e1aSwdenk
351518e2e1aSwdenk #ifdef REISERDEBUG
352518e2e1aSwdenk printf ("root read_in: block=%d, depth=%d\n",
353518e2e1aSwdenk sb_root_block(&super), INFO->tree_depth);
354518e2e1aSwdenk #endif /* REISERDEBUG */
355518e2e1aSwdenk
356518e2e1aSwdenk if (INFO->tree_depth >= MAX_HEIGHT)
357518e2e1aSwdenk return 0;
358518e2e1aSwdenk if (INFO->tree_depth == DISK_LEAF_NODE_LEVEL)
359518e2e1aSwdenk {
360518e2e1aSwdenk /* There is only one node in the whole filesystem,
361518e2e1aSwdenk * which is simultanously leaf and root */
362518e2e1aSwdenk memcpy (LEAF, ROOT, INFO->blocksize);
363518e2e1aSwdenk }
364518e2e1aSwdenk return 1;
365518e2e1aSwdenk }
366518e2e1aSwdenk
367518e2e1aSwdenk /***************** TREE ACCESSING METHODS *****************************/
368518e2e1aSwdenk
369518e2e1aSwdenk /* I assume you are familiar with the ReiserFS tree, if not go to
370518e2e1aSwdenk * http://www.namesys.com/content_table.html
371518e2e1aSwdenk *
372518e2e1aSwdenk * My tree node cache is organized as following
373518e2e1aSwdenk * 0 ROOT node
374518e2e1aSwdenk * 1 LEAF node (if the ROOT is also a LEAF it is copied here
375518e2e1aSwdenk * 2-n other nodes on current path from bottom to top.
376518e2e1aSwdenk * if there is not enough space in the cache, the top most are
377518e2e1aSwdenk * omitted.
378518e2e1aSwdenk *
379518e2e1aSwdenk * I have only two methods to find a key in the tree:
380518e2e1aSwdenk * search_stat(dir_id, objectid) searches for the stat entry (always
381518e2e1aSwdenk * the first entry) of an object.
382518e2e1aSwdenk * next_key() gets the next key in tree order.
383518e2e1aSwdenk *
384518e2e1aSwdenk * This means, that I can only sequential reads of files are
385518e2e1aSwdenk * efficient, but this really doesn't hurt for grub.
386518e2e1aSwdenk */
387518e2e1aSwdenk
388518e2e1aSwdenk /* Read in the node at the current path and depth into the node cache.
389518e2e1aSwdenk * You must set INFO->blocks[depth] before.
390518e2e1aSwdenk */
391518e2e1aSwdenk static char *
read_tree_node(unsigned int blockNr,int depth)392518e2e1aSwdenk read_tree_node (unsigned int blockNr, int depth)
393518e2e1aSwdenk {
394518e2e1aSwdenk char* cache = CACHE(depth);
395518e2e1aSwdenk int num_cached = INFO->cached_slots;
396518e2e1aSwdenk if (depth < num_cached)
397518e2e1aSwdenk {
398518e2e1aSwdenk /* This is the cached part of the path. Check if same block is
399518e2e1aSwdenk * needed.
400518e2e1aSwdenk */
401518e2e1aSwdenk if (blockNr == INFO->blocks[depth])
402518e2e1aSwdenk return cache;
403518e2e1aSwdenk }
404518e2e1aSwdenk else
405518e2e1aSwdenk cache = CACHE(num_cached);
406518e2e1aSwdenk
407518e2e1aSwdenk #ifdef REISERDEBUG
408518e2e1aSwdenk printf (" next read_in: block=%d (depth=%d)\n",
409518e2e1aSwdenk blockNr, depth);
410518e2e1aSwdenk #endif /* REISERDEBUG */
411518e2e1aSwdenk if (! block_read (blockNr, 0, INFO->blocksize, cache))
412518e2e1aSwdenk return 0;
413518e2e1aSwdenk /* Make sure it has the right node level */
414518e2e1aSwdenk if (__le16_to_cpu(BLOCKHEAD (cache)->blk_level) != depth)
415518e2e1aSwdenk {
416518e2e1aSwdenk errnum = ERR_FSYS_CORRUPT;
417518e2e1aSwdenk return 0;
418518e2e1aSwdenk }
419518e2e1aSwdenk
420518e2e1aSwdenk INFO->blocks[depth] = blockNr;
421518e2e1aSwdenk return cache;
422518e2e1aSwdenk }
423518e2e1aSwdenk
424518e2e1aSwdenk /* Get the next key, i.e. the key following the last retrieved key in
425518e2e1aSwdenk * tree order. INFO->current_ih and
426518e2e1aSwdenk * INFO->current_info are adapted accordingly. */
427518e2e1aSwdenk static int
next_key(void)428518e2e1aSwdenk next_key (void)
429518e2e1aSwdenk {
430518e2e1aSwdenk int depth;
431518e2e1aSwdenk struct item_head *ih = INFO->current_ih + 1;
432518e2e1aSwdenk char *cache;
433518e2e1aSwdenk
434518e2e1aSwdenk #ifdef REISERDEBUG
435518e2e1aSwdenk printf ("next_key:\n old ih: key %d:%d:%d:%d version:%d\n",
436518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.k_dir_id),
437518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.k_objectid),
438518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_offset),
439518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_uniqueness),
440518e2e1aSwdenk __le16_to_cpu(INFO->current_ih->ih_version));
441518e2e1aSwdenk #endif /* REISERDEBUG */
442518e2e1aSwdenk
443518e2e1aSwdenk if (ih == &ITEMHEAD[__le16_to_cpu(BLOCKHEAD (LEAF)->blk_nr_item)])
444518e2e1aSwdenk {
445518e2e1aSwdenk depth = DISK_LEAF_NODE_LEVEL;
446518e2e1aSwdenk /* The last item, was the last in the leaf node.
447518e2e1aSwdenk * Read in the next block
448518e2e1aSwdenk */
449518e2e1aSwdenk do
450518e2e1aSwdenk {
451518e2e1aSwdenk if (depth == INFO->tree_depth)
452518e2e1aSwdenk {
453518e2e1aSwdenk /* There are no more keys at all.
454518e2e1aSwdenk * Return a dummy item with MAX_KEY */
455518e2e1aSwdenk ih = (struct item_head *) &BLOCKHEAD (LEAF)->blk_right_delim_key;
456518e2e1aSwdenk goto found;
457518e2e1aSwdenk }
458518e2e1aSwdenk depth++;
459518e2e1aSwdenk #ifdef REISERDEBUG
460518e2e1aSwdenk printf (" depth=%d, i=%d\n", depth, INFO->next_key_nr[depth]);
461518e2e1aSwdenk #endif /* REISERDEBUG */
462518e2e1aSwdenk }
463518e2e1aSwdenk while (INFO->next_key_nr[depth] == 0);
464518e2e1aSwdenk
465518e2e1aSwdenk if (depth == INFO->tree_depth)
466518e2e1aSwdenk cache = ROOT;
467518e2e1aSwdenk else if (depth <= INFO->cached_slots)
468518e2e1aSwdenk cache = CACHE (depth);
469518e2e1aSwdenk else
470518e2e1aSwdenk {
471518e2e1aSwdenk cache = read_tree_node (INFO->blocks[depth], depth);
472518e2e1aSwdenk if (! cache)
473518e2e1aSwdenk return 0;
474518e2e1aSwdenk }
475518e2e1aSwdenk
476518e2e1aSwdenk do
477518e2e1aSwdenk {
478518e2e1aSwdenk int nr_item = __le16_to_cpu(BLOCKHEAD (cache)->blk_nr_item);
479518e2e1aSwdenk int key_nr = INFO->next_key_nr[depth]++;
480518e2e1aSwdenk #ifdef REISERDEBUG
481518e2e1aSwdenk printf (" depth=%d, i=%d/%d\n", depth, key_nr, nr_item);
482518e2e1aSwdenk #endif /* REISERDEBUG */
483518e2e1aSwdenk if (key_nr == nr_item)
484518e2e1aSwdenk /* This is the last item in this block, set the next_key_nr to 0 */
485518e2e1aSwdenk INFO->next_key_nr[depth] = 0;
486518e2e1aSwdenk
487518e2e1aSwdenk cache = read_tree_node (dc_block_number(&(DC (cache)[key_nr])), --depth);
488518e2e1aSwdenk if (! cache)
489518e2e1aSwdenk return 0;
490518e2e1aSwdenk }
491518e2e1aSwdenk while (depth > DISK_LEAF_NODE_LEVEL);
492518e2e1aSwdenk
493518e2e1aSwdenk ih = ITEMHEAD;
494518e2e1aSwdenk }
495518e2e1aSwdenk found:
496518e2e1aSwdenk INFO->current_ih = ih;
497518e2e1aSwdenk INFO->current_item = &LEAF[__le16_to_cpu(ih->ih_item_location)];
498518e2e1aSwdenk #ifdef REISERDEBUG
499518e2e1aSwdenk printf (" new ih: key %d:%d:%d:%d version:%d\n",
500518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.k_dir_id),
501518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.k_objectid),
502518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_offset),
503518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_uniqueness),
504518e2e1aSwdenk __le16_to_cpu(INFO->current_ih->ih_version));
505518e2e1aSwdenk #endif /* REISERDEBUG */
506518e2e1aSwdenk return 1;
507518e2e1aSwdenk }
508518e2e1aSwdenk
509518e2e1aSwdenk /* preconditions: reiserfs_mount already executed, therefore
510518e2e1aSwdenk * INFO block is valid
511518e2e1aSwdenk * returns: 0 if error (errnum is set),
512518e2e1aSwdenk * nonzero iff we were able to find the key successfully.
513518e2e1aSwdenk * postconditions: on a nonzero return, the current_ih and
514518e2e1aSwdenk * current_item fields describe the key that equals the
515518e2e1aSwdenk * searched key. INFO->next_key contains the next key after
516518e2e1aSwdenk * the searched key.
517518e2e1aSwdenk * side effects: messes around with the cache.
518518e2e1aSwdenk */
519518e2e1aSwdenk static int
search_stat(__u32 dir_id,__u32 objectid)520518e2e1aSwdenk search_stat (__u32 dir_id, __u32 objectid)
521518e2e1aSwdenk {
522518e2e1aSwdenk char *cache;
523518e2e1aSwdenk int depth;
524518e2e1aSwdenk int nr_item;
525518e2e1aSwdenk int i;
526518e2e1aSwdenk struct item_head *ih;
527518e2e1aSwdenk #ifdef REISERDEBUG
528518e2e1aSwdenk printf ("search_stat:\n key %d:%d:0:0\n", dir_id, objectid);
529518e2e1aSwdenk #endif /* REISERDEBUG */
530518e2e1aSwdenk
531518e2e1aSwdenk depth = INFO->tree_depth;
532518e2e1aSwdenk cache = ROOT;
533518e2e1aSwdenk
534518e2e1aSwdenk while (depth > DISK_LEAF_NODE_LEVEL)
535518e2e1aSwdenk {
536518e2e1aSwdenk struct key *key;
537518e2e1aSwdenk nr_item = __le16_to_cpu(BLOCKHEAD (cache)->blk_nr_item);
538518e2e1aSwdenk
539518e2e1aSwdenk key = KEY (cache);
540518e2e1aSwdenk
541518e2e1aSwdenk for (i = 0; i < nr_item; i++)
542518e2e1aSwdenk {
543518e2e1aSwdenk if (__le32_to_cpu(key->k_dir_id) > dir_id
544518e2e1aSwdenk || (__le32_to_cpu(key->k_dir_id) == dir_id
545518e2e1aSwdenk && (__le32_to_cpu(key->k_objectid) > objectid
546518e2e1aSwdenk || (__le32_to_cpu(key->k_objectid) == objectid
547518e2e1aSwdenk && (__le32_to_cpu(key->u.v1.k_offset)
548518e2e1aSwdenk | __le32_to_cpu(key->u.v1.k_uniqueness)) > 0))))
549518e2e1aSwdenk break;
550518e2e1aSwdenk key++;
551518e2e1aSwdenk }
552518e2e1aSwdenk
553518e2e1aSwdenk #ifdef REISERDEBUG
554518e2e1aSwdenk printf (" depth=%d, i=%d/%d\n", depth, i, nr_item);
555518e2e1aSwdenk #endif /* REISERDEBUG */
556518e2e1aSwdenk INFO->next_key_nr[depth] = (i == nr_item) ? 0 : i+1;
557518e2e1aSwdenk cache = read_tree_node (dc_block_number(&(DC (cache)[i])), --depth);
558518e2e1aSwdenk if (! cache)
559518e2e1aSwdenk return 0;
560518e2e1aSwdenk }
561518e2e1aSwdenk
562518e2e1aSwdenk /* cache == LEAF */
563518e2e1aSwdenk nr_item = __le16_to_cpu(BLOCKHEAD (LEAF)->blk_nr_item);
564518e2e1aSwdenk ih = ITEMHEAD;
565518e2e1aSwdenk for (i = 0; i < nr_item; i++)
566518e2e1aSwdenk {
567518e2e1aSwdenk if (__le32_to_cpu(ih->ih_key.k_dir_id) == dir_id
568518e2e1aSwdenk && __le32_to_cpu(ih->ih_key.k_objectid) == objectid
569518e2e1aSwdenk && __le32_to_cpu(ih->ih_key.u.v1.k_offset) == 0
570518e2e1aSwdenk && __le32_to_cpu(ih->ih_key.u.v1.k_uniqueness) == 0)
571518e2e1aSwdenk {
572518e2e1aSwdenk #ifdef REISERDEBUG
573518e2e1aSwdenk printf (" depth=%d, i=%d/%d\n", depth, i, nr_item);
574518e2e1aSwdenk #endif /* REISERDEBUG */
575518e2e1aSwdenk INFO->current_ih = ih;
576518e2e1aSwdenk INFO->current_item = &LEAF[__le16_to_cpu(ih->ih_item_location)];
577518e2e1aSwdenk return 1;
578518e2e1aSwdenk }
579518e2e1aSwdenk ih++;
580518e2e1aSwdenk }
581518e2e1aSwdenk errnum = ERR_FSYS_CORRUPT;
582518e2e1aSwdenk return 0;
583518e2e1aSwdenk }
584518e2e1aSwdenk
585518e2e1aSwdenk int
reiserfs_read(char * buf,unsigned len)586518e2e1aSwdenk reiserfs_read (char *buf, unsigned len)
587518e2e1aSwdenk {
588518e2e1aSwdenk unsigned int blocksize;
589518e2e1aSwdenk unsigned int offset;
590518e2e1aSwdenk unsigned int to_read;
591518e2e1aSwdenk char *prev_buf = buf;
592518e2e1aSwdenk
593518e2e1aSwdenk #ifdef REISERDEBUG
594518e2e1aSwdenk printf ("reiserfs_read: filepos=%d len=%d, offset=%Lx\n",
595518e2e1aSwdenk filepos, len, (__u64) IH_KEY_OFFSET (INFO->current_ih) - 1);
596518e2e1aSwdenk #endif /* REISERDEBUG */
597518e2e1aSwdenk
598518e2e1aSwdenk if (__le32_to_cpu(INFO->current_ih->ih_key.k_objectid) != INFO->fileinfo.k_objectid
599518e2e1aSwdenk || IH_KEY_OFFSET (INFO->current_ih) > filepos + 1)
600518e2e1aSwdenk {
601518e2e1aSwdenk search_stat (INFO->fileinfo.k_dir_id, INFO->fileinfo.k_objectid);
602518e2e1aSwdenk goto get_next_key;
603518e2e1aSwdenk }
604518e2e1aSwdenk
605518e2e1aSwdenk while (! errnum)
606518e2e1aSwdenk {
607518e2e1aSwdenk if (__le32_to_cpu(INFO->current_ih->ih_key.k_objectid) != INFO->fileinfo.k_objectid) {
608518e2e1aSwdenk break;
609518e2e1aSwdenk }
610518e2e1aSwdenk
611518e2e1aSwdenk offset = filepos - IH_KEY_OFFSET (INFO->current_ih) + 1;
612518e2e1aSwdenk blocksize = __le16_to_cpu(INFO->current_ih->ih_item_len);
613518e2e1aSwdenk
614518e2e1aSwdenk #ifdef REISERDEBUG
615518e2e1aSwdenk printf (" loop: filepos=%d len=%d, offset=%d blocksize=%d\n",
616518e2e1aSwdenk filepos, len, offset, blocksize);
617518e2e1aSwdenk #endif /* REISERDEBUG */
618518e2e1aSwdenk
619518e2e1aSwdenk if (IH_KEY_ISTYPE(INFO->current_ih, TYPE_DIRECT)
620518e2e1aSwdenk && offset < blocksize)
621518e2e1aSwdenk {
622518e2e1aSwdenk #ifdef REISERDEBUG
623518e2e1aSwdenk printf ("direct_read: offset=%d, blocksize=%d\n",
624518e2e1aSwdenk offset, blocksize);
625518e2e1aSwdenk #endif /* REISERDEBUG */
626518e2e1aSwdenk to_read = blocksize - offset;
627518e2e1aSwdenk if (to_read > len)
628518e2e1aSwdenk to_read = len;
629518e2e1aSwdenk
630518e2e1aSwdenk memcpy (buf, INFO->current_item + offset, to_read);
631518e2e1aSwdenk goto update_buf_len;
632518e2e1aSwdenk }
633518e2e1aSwdenk else if (IH_KEY_ISTYPE(INFO->current_ih, TYPE_INDIRECT))
634518e2e1aSwdenk {
635518e2e1aSwdenk blocksize = (blocksize >> 2) << INFO->fullblocksize_shift;
636518e2e1aSwdenk #ifdef REISERDEBUG
637518e2e1aSwdenk printf ("indirect_read: offset=%d, blocksize=%d\n",
638518e2e1aSwdenk offset, blocksize);
639518e2e1aSwdenk #endif /* REISERDEBUG */
640518e2e1aSwdenk
641518e2e1aSwdenk while (offset < blocksize)
642518e2e1aSwdenk {
643518e2e1aSwdenk __u32 blocknr = __le32_to_cpu(((__u32 *) INFO->current_item)
644518e2e1aSwdenk [offset >> INFO->fullblocksize_shift]);
645518e2e1aSwdenk int blk_offset = offset & (INFO->blocksize-1);
646518e2e1aSwdenk to_read = INFO->blocksize - blk_offset;
647518e2e1aSwdenk if (to_read > len)
648518e2e1aSwdenk to_read = len;
649518e2e1aSwdenk
650518e2e1aSwdenk /* Journal is only for meta data. Data blocks can be read
651518e2e1aSwdenk * directly without using block_read
652518e2e1aSwdenk */
653518e2e1aSwdenk reiserfs_devread (blocknr << INFO->blocksize_shift,
654518e2e1aSwdenk blk_offset, to_read, buf);
655518e2e1aSwdenk update_buf_len:
656518e2e1aSwdenk len -= to_read;
657518e2e1aSwdenk buf += to_read;
658518e2e1aSwdenk offset += to_read;
659518e2e1aSwdenk filepos += to_read;
660518e2e1aSwdenk if (len == 0)
661518e2e1aSwdenk goto done;
662518e2e1aSwdenk }
663518e2e1aSwdenk }
664518e2e1aSwdenk get_next_key:
665518e2e1aSwdenk next_key ();
666518e2e1aSwdenk }
667518e2e1aSwdenk done:
668518e2e1aSwdenk return errnum ? 0 : buf - prev_buf;
669518e2e1aSwdenk }
670518e2e1aSwdenk
671518e2e1aSwdenk
672518e2e1aSwdenk /* preconditions: reiserfs_mount already executed, therefore
673518e2e1aSwdenk * INFO block is valid
674518e2e1aSwdenk * returns: 0 if error, nonzero iff we were able to find the file successfully
675518e2e1aSwdenk * postconditions: on a nonzero return, INFO->fileinfo contains the info
676518e2e1aSwdenk * of the file we were trying to look up, filepos is 0 and filemax is
677518e2e1aSwdenk * the size of the file.
678518e2e1aSwdenk */
679518e2e1aSwdenk static int
reiserfs_dir(char * dirname)680518e2e1aSwdenk reiserfs_dir (char *dirname)
681518e2e1aSwdenk {
682518e2e1aSwdenk struct reiserfs_de_head *de_head;
683518e2e1aSwdenk char *rest, ch;
684518e2e1aSwdenk __u32 dir_id, objectid, parent_dir_id = 0, parent_objectid = 0;
685518e2e1aSwdenk #ifndef STAGE1_5
686518e2e1aSwdenk int do_possibilities = 0;
687518e2e1aSwdenk #endif /* ! STAGE1_5 */
688518e2e1aSwdenk char linkbuf[PATH_MAX]; /* buffer for following symbolic links */
689518e2e1aSwdenk int link_count = 0;
690518e2e1aSwdenk int mode;
691518e2e1aSwdenk
692518e2e1aSwdenk dir_id = REISERFS_ROOT_PARENT_OBJECTID;
693518e2e1aSwdenk objectid = REISERFS_ROOT_OBJECTID;
694518e2e1aSwdenk
695518e2e1aSwdenk while (1)
696518e2e1aSwdenk {
697518e2e1aSwdenk #ifdef REISERDEBUG
698518e2e1aSwdenk printf ("dirname=%s\n", dirname);
699518e2e1aSwdenk #endif /* REISERDEBUG */
700518e2e1aSwdenk
701518e2e1aSwdenk /* Search for the stat info first. */
702518e2e1aSwdenk if (! search_stat (dir_id, objectid))
703518e2e1aSwdenk return 0;
704518e2e1aSwdenk
705518e2e1aSwdenk #ifdef REISERDEBUG
706518e2e1aSwdenk printf ("sd_mode=%x sd_size=%d\n",
707518e2e1aSwdenk stat_data_v1(INFO->current_ih) ? sd_v1_mode((struct stat_data_v1 *) INFO->current_item) :
708518e2e1aSwdenk sd_v2_mode((struct stat_data *) (INFO->current_item)),
709518e2e1aSwdenk stat_data_v1(INFO->current_ih) ? sd_v1_size((struct stat_data_v1 *) INFO->current_item) :
710518e2e1aSwdenk sd_v2_size((struct stat_data *) INFO->current_item)
711518e2e1aSwdenk );
712518e2e1aSwdenk
713518e2e1aSwdenk #endif /* REISERDEBUG */
714518e2e1aSwdenk mode = stat_data_v1(INFO->current_ih) ?
715518e2e1aSwdenk sd_v1_mode((struct stat_data_v1 *) INFO->current_item) :
716518e2e1aSwdenk sd_v2_mode((struct stat_data *) INFO->current_item);
717518e2e1aSwdenk
718518e2e1aSwdenk /* If we've got a symbolic link, then chase it. */
719518e2e1aSwdenk if (S_ISLNK (mode))
720518e2e1aSwdenk {
721518e2e1aSwdenk unsigned int len;
722518e2e1aSwdenk if (++link_count > MAX_LINK_COUNT)
723518e2e1aSwdenk {
724518e2e1aSwdenk errnum = ERR_SYMLINK_LOOP;
725518e2e1aSwdenk return 0;
726518e2e1aSwdenk }
727518e2e1aSwdenk
728518e2e1aSwdenk /* Get the symlink size. */
729518e2e1aSwdenk filemax = stat_data_v1(INFO->current_ih) ?
730518e2e1aSwdenk sd_v1_size((struct stat_data_v1 *) INFO->current_item) :
731518e2e1aSwdenk sd_v2_size((struct stat_data *) INFO->current_item);
732518e2e1aSwdenk
733518e2e1aSwdenk /* Find out how long our remaining name is. */
734518e2e1aSwdenk len = 0;
735518e2e1aSwdenk while (dirname[len] && !isspace (dirname[len]))
736518e2e1aSwdenk len++;
737518e2e1aSwdenk
738518e2e1aSwdenk if (filemax + len > sizeof (linkbuf) - 1)
739518e2e1aSwdenk {
740518e2e1aSwdenk errnum = ERR_FILELENGTH;
741518e2e1aSwdenk return 0;
742518e2e1aSwdenk }
743518e2e1aSwdenk
744518e2e1aSwdenk /* Copy the remaining name to the end of the symlink data.
745518e2e1aSwdenk Note that DIRNAME and LINKBUF may overlap! */
746518e2e1aSwdenk memmove (linkbuf + filemax, dirname, len+1);
747518e2e1aSwdenk
748518e2e1aSwdenk INFO->fileinfo.k_dir_id = dir_id;
749518e2e1aSwdenk INFO->fileinfo.k_objectid = objectid;
750518e2e1aSwdenk filepos = 0;
751518e2e1aSwdenk if (! next_key ()
752518e2e1aSwdenk || reiserfs_read (linkbuf, filemax) != filemax)
753518e2e1aSwdenk {
754518e2e1aSwdenk if (! errnum)
755518e2e1aSwdenk errnum = ERR_FSYS_CORRUPT;
756518e2e1aSwdenk return 0;
757518e2e1aSwdenk }
758518e2e1aSwdenk
759518e2e1aSwdenk #ifdef REISERDEBUG
760518e2e1aSwdenk printf ("symlink=%s\n", linkbuf);
761518e2e1aSwdenk #endif /* REISERDEBUG */
762518e2e1aSwdenk
763518e2e1aSwdenk dirname = linkbuf;
764518e2e1aSwdenk if (*dirname == '/')
765518e2e1aSwdenk {
766518e2e1aSwdenk /* It's an absolute link, so look it up in root. */
767518e2e1aSwdenk dir_id = REISERFS_ROOT_PARENT_OBJECTID;
768518e2e1aSwdenk objectid = REISERFS_ROOT_OBJECTID;
769518e2e1aSwdenk }
770518e2e1aSwdenk else
771518e2e1aSwdenk {
772518e2e1aSwdenk /* Relative, so look it up in our parent directory. */
773518e2e1aSwdenk dir_id = parent_dir_id;
774518e2e1aSwdenk objectid = parent_objectid;
775518e2e1aSwdenk }
776518e2e1aSwdenk
777518e2e1aSwdenk /* Now lookup the new name. */
778518e2e1aSwdenk continue;
779518e2e1aSwdenk }
780518e2e1aSwdenk
781518e2e1aSwdenk /* if we have a real file (and we're not just printing possibilities),
782518e2e1aSwdenk then this is where we want to exit */
783518e2e1aSwdenk
784518e2e1aSwdenk if (! *dirname || isspace (*dirname))
785518e2e1aSwdenk {
786518e2e1aSwdenk if (! S_ISREG (mode))
787518e2e1aSwdenk {
788518e2e1aSwdenk errnum = ERR_BAD_FILETYPE;
789518e2e1aSwdenk return 0;
790518e2e1aSwdenk }
791518e2e1aSwdenk
792518e2e1aSwdenk filepos = 0;
793518e2e1aSwdenk filemax = stat_data_v1(INFO->current_ih) ?
794518e2e1aSwdenk sd_v1_size((struct stat_data_v1 *) INFO->current_item) :
795518e2e1aSwdenk sd_v2_size((struct stat_data *) INFO->current_item);
796518e2e1aSwdenk #if 0
797518e2e1aSwdenk /* If this is a new stat data and size is > 4GB set filemax to
798518e2e1aSwdenk * maximum
799518e2e1aSwdenk */
800518e2e1aSwdenk if (__le16_to_cpu(INFO->current_ih->ih_version) == ITEM_VERSION_2
801518e2e1aSwdenk && sd_size_hi((struct stat_data *) INFO->current_item) > 0)
802518e2e1aSwdenk filemax = 0xffffffff;
803518e2e1aSwdenk #endif
804518e2e1aSwdenk INFO->fileinfo.k_dir_id = dir_id;
805518e2e1aSwdenk INFO->fileinfo.k_objectid = objectid;
806518e2e1aSwdenk return next_key ();
807518e2e1aSwdenk }
808518e2e1aSwdenk
809518e2e1aSwdenk /* continue with the file/directory name interpretation */
810518e2e1aSwdenk while (*dirname == '/')
811518e2e1aSwdenk dirname++;
812518e2e1aSwdenk if (! S_ISDIR (mode))
813518e2e1aSwdenk {
814518e2e1aSwdenk errnum = ERR_BAD_FILETYPE;
815518e2e1aSwdenk return 0;
816518e2e1aSwdenk }
817518e2e1aSwdenk for (rest = dirname; (ch = *rest) && ! isspace (ch) && ch != '/'; rest++);
818518e2e1aSwdenk *rest = 0;
819518e2e1aSwdenk
820518e2e1aSwdenk # ifndef STAGE1_5
821518e2e1aSwdenk if (print_possibilities && ch != '/')
822518e2e1aSwdenk do_possibilities = 1;
823518e2e1aSwdenk # endif /* ! STAGE1_5 */
824518e2e1aSwdenk
825518e2e1aSwdenk while (1)
826518e2e1aSwdenk {
827518e2e1aSwdenk char *name_end;
828518e2e1aSwdenk int num_entries;
829518e2e1aSwdenk
830518e2e1aSwdenk if (! next_key ())
831518e2e1aSwdenk return 0;
832518e2e1aSwdenk #ifdef REISERDEBUG
833518e2e1aSwdenk printf ("ih: key %d:%d:%d:%d version:%d\n",
834518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.k_dir_id),
835518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.k_objectid),
836518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_offset),
837518e2e1aSwdenk __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_uniqueness),
838518e2e1aSwdenk __le16_to_cpu(INFO->current_ih->ih_version));
839518e2e1aSwdenk #endif /* REISERDEBUG */
840518e2e1aSwdenk
841518e2e1aSwdenk if (__le32_to_cpu(INFO->current_ih->ih_key.k_objectid) != objectid)
842518e2e1aSwdenk break;
843518e2e1aSwdenk
844518e2e1aSwdenk name_end = INFO->current_item + __le16_to_cpu(INFO->current_ih->ih_item_len);
845518e2e1aSwdenk de_head = (struct reiserfs_de_head *) INFO->current_item;
846518e2e1aSwdenk num_entries = __le16_to_cpu(INFO->current_ih->u.ih_entry_count);
847518e2e1aSwdenk while (num_entries > 0)
848518e2e1aSwdenk {
849518e2e1aSwdenk char *filename = INFO->current_item + deh_location(de_head);
850518e2e1aSwdenk char tmp = *name_end;
851518e2e1aSwdenk if ((deh_state(de_head) & DEH_Visible))
852518e2e1aSwdenk {
853518e2e1aSwdenk int cmp;
854518e2e1aSwdenk /* Directory names in ReiserFS are not null
855518e2e1aSwdenk * terminated. We write a temporary 0 behind it.
856518e2e1aSwdenk * NOTE: that this may overwrite the first block in
857518e2e1aSwdenk * the tree cache. That doesn't hurt as long as we
858518e2e1aSwdenk * don't call next_key () in between.
859518e2e1aSwdenk */
860518e2e1aSwdenk *name_end = 0;
861518e2e1aSwdenk cmp = substring (dirname, filename);
862518e2e1aSwdenk *name_end = tmp;
863518e2e1aSwdenk # ifndef STAGE1_5
864518e2e1aSwdenk if (do_possibilities)
865518e2e1aSwdenk {
866518e2e1aSwdenk if (cmp <= 0)
867518e2e1aSwdenk {
868518e2e1aSwdenk char fn[PATH_MAX];
869518e2e1aSwdenk struct fsys_reiser_info info_save;
870518e2e1aSwdenk
871518e2e1aSwdenk if (print_possibilities > 0)
872518e2e1aSwdenk print_possibilities = -print_possibilities;
873518e2e1aSwdenk *name_end = 0;
874518e2e1aSwdenk strcpy(fn, filename);
875518e2e1aSwdenk *name_end = tmp;
876518e2e1aSwdenk
877518e2e1aSwdenk /* If NAME is "." or "..", do not count it. */
878518e2e1aSwdenk if (strcmp (fn, ".") != 0 && strcmp (fn, "..") != 0) {
879518e2e1aSwdenk memcpy(&info_save, INFO, sizeof(struct fsys_reiser_info));
880518e2e1aSwdenk search_stat (deh_dir_id(de_head), deh_objectid(de_head));
881518e2e1aSwdenk sd_print_item(INFO->current_ih, INFO->current_item);
882518e2e1aSwdenk printf(" %s\n", fn);
883518e2e1aSwdenk search_stat (dir_id, objectid);
884518e2e1aSwdenk memcpy(INFO, &info_save, sizeof(struct fsys_reiser_info));
885518e2e1aSwdenk }
886518e2e1aSwdenk }
887518e2e1aSwdenk }
888518e2e1aSwdenk else
889518e2e1aSwdenk # endif /* ! STAGE1_5 */
890518e2e1aSwdenk if (cmp == 0)
891518e2e1aSwdenk goto found;
892518e2e1aSwdenk }
893518e2e1aSwdenk /* The beginning of this name marks the end of the next name.
894518e2e1aSwdenk */
895518e2e1aSwdenk name_end = filename;
896518e2e1aSwdenk de_head++;
897518e2e1aSwdenk num_entries--;
898518e2e1aSwdenk }
899518e2e1aSwdenk }
900518e2e1aSwdenk
901518e2e1aSwdenk # ifndef STAGE1_5
902518e2e1aSwdenk if (print_possibilities < 0)
903518e2e1aSwdenk return 1;
904518e2e1aSwdenk # endif /* ! STAGE1_5 */
905518e2e1aSwdenk
906518e2e1aSwdenk errnum = ERR_FILE_NOT_FOUND;
907518e2e1aSwdenk *rest = ch;
908518e2e1aSwdenk return 0;
909518e2e1aSwdenk
910518e2e1aSwdenk found:
911518e2e1aSwdenk *rest = ch;
912518e2e1aSwdenk dirname = rest;
913518e2e1aSwdenk
914518e2e1aSwdenk parent_dir_id = dir_id;
915518e2e1aSwdenk parent_objectid = objectid;
916518e2e1aSwdenk dir_id = deh_dir_id(de_head);
917518e2e1aSwdenk objectid = deh_objectid(de_head);
918518e2e1aSwdenk }
919518e2e1aSwdenk }
920518e2e1aSwdenk
921518e2e1aSwdenk /*
922518e2e1aSwdenk * U-Boot interface functions
923518e2e1aSwdenk */
924518e2e1aSwdenk
925518e2e1aSwdenk /*
926518e2e1aSwdenk * List given directory
927518e2e1aSwdenk *
928518e2e1aSwdenk * RETURN: 0 - OK, else grub_error_t errnum
929518e2e1aSwdenk */
930518e2e1aSwdenk int
reiserfs_ls(char * dirname)931518e2e1aSwdenk reiserfs_ls (char *dirname)
932518e2e1aSwdenk {
933518e2e1aSwdenk char *dir_slash;
934518e2e1aSwdenk int res;
935518e2e1aSwdenk
936518e2e1aSwdenk errnum = 0;
937518e2e1aSwdenk dir_slash = malloc(strlen(dirname) + 1);
938518e2e1aSwdenk if (dir_slash == NULL) {
939518e2e1aSwdenk return ERR_NUMBER_OVERFLOW;
940518e2e1aSwdenk }
941518e2e1aSwdenk strcpy(dir_slash, dirname);
942518e2e1aSwdenk /* add "/" to the directory name */
943518e2e1aSwdenk strcat(dir_slash, "/");
944518e2e1aSwdenk
945518e2e1aSwdenk print_possibilities = 1;
946518e2e1aSwdenk res = reiserfs_dir (dir_slash);
947518e2e1aSwdenk free(dir_slash);
948518e2e1aSwdenk if (!res || errnum) {
949518e2e1aSwdenk return errnum;
950518e2e1aSwdenk }
951518e2e1aSwdenk
952518e2e1aSwdenk return 0;
953518e2e1aSwdenk }
954518e2e1aSwdenk
955518e2e1aSwdenk /*
956518e2e1aSwdenk * Open file for reading
957518e2e1aSwdenk *
958518e2e1aSwdenk * RETURN: >0 - OK, size of opened file
959518e2e1aSwdenk * <0 - ERROR -grub_error_t errnum
960518e2e1aSwdenk */
961518e2e1aSwdenk int
reiserfs_open(char * filename)962518e2e1aSwdenk reiserfs_open (char *filename)
963518e2e1aSwdenk {
964518e2e1aSwdenk /* open the file */
965518e2e1aSwdenk errnum = 0;
966518e2e1aSwdenk print_possibilities = 0;
967518e2e1aSwdenk if (!reiserfs_dir (filename) || errnum) {
968518e2e1aSwdenk return -errnum;
969518e2e1aSwdenk }
970518e2e1aSwdenk return filemax;
971518e2e1aSwdenk }
972