xref: /openbmc/u-boot/fs/reiserfs/reiserfs.c (revision 6b7c0f5e)
1 /*
2  *  Copyright 2000-2002 by Hans Reiser, licensing governed by reiserfs/README
3  *
4  *  GRUB  --  GRand Unified Bootloader
5  *  Copyright (C) 2000, 2001  Free Software Foundation, Inc.
6  *
7  *  (C) Copyright 2003 - 2004
8  *  Sysgo AG, <www.elinos.com>, Pavel Bartusek <pba@sysgo.com>
9  *
10  *
11  *  This program is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License as published by
13  *  the Free Software Foundation; either version 2 of the License, or
14  *  (at your option) any later version.
15  *
16  *  This program is distributed in the hope that it will be useful,
17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *  GNU General Public License for more details.
20  *
21  *  You should have received a copy of the GNU General Public License
22  *  along with this program; if not, write to the Free Software
23  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24  */
25 
26 /* An implementation for the ReiserFS filesystem ported from GRUB.
27  * Some parts of this code (mainly the structures and defines) are
28  * from the original reiser fs code, as found in the linux kernel.
29  */
30 
31 #include <common.h>
32 #include <malloc.h>
33 #include <linux/ctype.h>
34 #include <linux/time.h>
35 #include <asm/byteorder.h>
36 #include <reiserfs.h>
37 
38 #include "reiserfs_private.h"
39 
40 #undef REISERDEBUG
41 
42 /* Some parts of this code (mainly the structures and defines) are
43  * from the original reiser fs code, as found in the linux kernel.
44  */
45 
46 static char fsys_buf[FSYS_BUFLEN];
47 static reiserfs_error_t errnum = ERR_NONE;
48 static int print_possibilities;
49 static unsigned int filepos, filemax;
50 
51 static int
52 substring (const char *s1, const char *s2)
53 {
54   while (*s1 == *s2)
55     {
56       /* The strings match exactly. */
57       if (! *(s1++))
58 	return 0;
59       s2 ++;
60     }
61 
62   /* S1 is a substring of S2. */
63   if (*s1 == 0)
64     return -1;
65 
66   /* S1 isn't a substring. */
67   return 1;
68 }
69 
70 static void sd_print_item (struct item_head * ih, char * item)
71 {
72     char filetime[30];
73     time_t ttime;
74 
75     if (stat_data_v1 (ih)) {
76 	struct stat_data_v1 * sd = (struct stat_data_v1 *)item;
77 	ttime = sd_v1_mtime(sd);
78 	ctime_r(&ttime, filetime);
79 	printf ("%-10s %4hd %6d %6d %9d %24.24s",
80 		 bb_mode_string(sd_v1_mode(sd)), sd_v1_nlink(sd),sd_v1_uid(sd), sd_v1_gid(sd),
81 		 sd_v1_size(sd), filetime);
82     } else {
83 	struct stat_data * sd = (struct stat_data *)item;
84 	ttime = sd_v2_mtime(sd);
85 	ctime_r(&ttime, filetime);
86 	printf ("%-10s %4d %6d %6d %9d %24.24s",
87 		 bb_mode_string(sd_v2_mode(sd)), sd_v2_nlink(sd),sd_v2_uid(sd),sd_v2_gid(sd),
88 		 (__u32) sd_v2_size(sd), filetime);
89     }
90 }
91 
92 static int
93 journal_read (int block, int len, char *buffer)
94 {
95   return reiserfs_devread ((INFO->journal_block + block) << INFO->blocksize_shift,
96 			   0, len, buffer);
97 }
98 
99 /* Read a block from ReiserFS file system, taking the journal into
100  * account.  If the block nr is in the journal, the block from the
101  * journal taken.
102  */
103 static int
104 block_read (unsigned int blockNr, int start, int len, char *buffer)
105 {
106   int transactions = INFO->journal_transactions;
107   int desc_block = INFO->journal_first_desc;
108   int journal_mask = INFO->journal_block_count - 1;
109   int translatedNr = blockNr;
110   __u32 *journal_table = JOURNAL_START;
111   while (transactions-- > 0)
112     {
113       int i = 0;
114       int j_len;
115       if (__le32_to_cpu(*journal_table) != 0xffffffff)
116 	{
117 	  /* Search for the blockNr in cached journal */
118 	  j_len = __le32_to_cpu(*journal_table++);
119 	  while (i++ < j_len)
120 	    {
121 	      if (__le32_to_cpu(*journal_table++) == blockNr)
122 		{
123 		  journal_table += j_len - i;
124 		  goto found;
125 		}
126 	    }
127 	}
128       else
129 	{
130 	  /* This is the end of cached journal marker.  The remaining
131 	   * transactions are still on disk.
132 	   */
133 	  struct reiserfs_journal_desc   desc;
134 	  struct reiserfs_journal_commit commit;
135 
136 	  if (! journal_read (desc_block, sizeof (desc), (char *) &desc))
137 	    return 0;
138 
139 	  j_len = __le32_to_cpu(desc.j_len);
140 	  while (i < j_len && i < JOURNAL_TRANS_HALF)
141 	    if (__le32_to_cpu(desc.j_realblock[i++]) == blockNr)
142 	      goto found;
143 
144 	  if (j_len >= JOURNAL_TRANS_HALF)
145 	    {
146 	      int commit_block = (desc_block + 1 + j_len) & journal_mask;
147 	      if (! journal_read (commit_block,
148 				  sizeof (commit), (char *) &commit))
149 		return 0;
150 	      while (i < j_len)
151 		if (__le32_to_cpu(commit.j_realblock[i++ - JOURNAL_TRANS_HALF]) == blockNr)
152 		  goto found;
153 	    }
154 	}
155       goto not_found;
156 
157     found:
158       translatedNr = INFO->journal_block + ((desc_block + i) & journal_mask);
159 #ifdef REISERDEBUG
160       printf ("block_read: block %d is mapped to journal block %d.\n",
161 	      blockNr, translatedNr - INFO->journal_block);
162 #endif
163       /* We must continue the search, as this block may be overwritten
164        * in later transactions.
165        */
166     not_found:
167       desc_block = (desc_block + 2 + j_len) & journal_mask;
168     }
169   return reiserfs_devread (translatedNr << INFO->blocksize_shift, start, len, buffer);
170 }
171 
172 /* Init the journal data structure.  We try to cache as much as
173  * possible in the JOURNAL_START-JOURNAL_END space, but if it is full
174  * we can still read the rest from the disk on demand.
175  *
176  * The first number of valid transactions and the descriptor block of the
177  * first valid transaction are held in INFO.  The transactions are all
178  * adjacent, but we must take care of the journal wrap around.
179  */
180 static int
181 journal_init (void)
182 {
183   unsigned int block_count = INFO->journal_block_count;
184   unsigned int desc_block;
185   unsigned int commit_block;
186   unsigned int next_trans_id;
187   struct reiserfs_journal_header header;
188   struct reiserfs_journal_desc   desc;
189   struct reiserfs_journal_commit commit;
190   __u32 *journal_table = JOURNAL_START;
191 
192   journal_read (block_count, sizeof (header), (char *) &header);
193   desc_block = __le32_to_cpu(header.j_first_unflushed_offset);
194   if (desc_block >= block_count)
195     return 0;
196 
197   INFO->journal_first_desc = desc_block;
198   next_trans_id = __le32_to_cpu(header.j_last_flush_trans_id) + 1;
199 
200 #ifdef REISERDEBUG
201   printf ("journal_init: last flushed %d\n",
202 	  __le32_to_cpu(header.j_last_flush_trans_id));
203 #endif
204 
205   while (1)
206     {
207       journal_read (desc_block, sizeof (desc), (char *) &desc);
208       if (substring (JOURNAL_DESC_MAGIC, desc.j_magic) > 0
209 	  || __le32_to_cpu(desc.j_trans_id) != next_trans_id
210 	  || __le32_to_cpu(desc.j_mount_id) != __le32_to_cpu(header.j_mount_id))
211 	/* no more valid transactions */
212 	break;
213 
214       commit_block = (desc_block + __le32_to_cpu(desc.j_len) + 1) & (block_count - 1);
215       journal_read (commit_block, sizeof (commit), (char *) &commit);
216       if (__le32_to_cpu(desc.j_trans_id) != commit.j_trans_id
217 	  || __le32_to_cpu(desc.j_len) != __le32_to_cpu(commit.j_len))
218 	/* no more valid transactions */
219 	break;
220 
221 #ifdef REISERDEBUG
222       printf ("Found valid transaction %d/%d at %d.\n",
223 	      __le32_to_cpu(desc.j_trans_id), __le32_to_cpu(desc.j_mount_id), desc_block);
224 #endif
225 
226       next_trans_id++;
227       if (journal_table < JOURNAL_END)
228 	{
229 	  if ((journal_table + 1 + __le32_to_cpu(desc.j_len)) >= JOURNAL_END)
230 	    {
231 	      /* The table is almost full; mark the end of the cached
232 	       * journal.*/
233 	      *journal_table = __cpu_to_le32(0xffffffff);
234 	      journal_table = JOURNAL_END;
235 	    }
236 	  else
237 	    {
238 	      unsigned int i;
239 	      /* Cache the length and the realblock numbers in the table.
240 	       * The block number of descriptor can easily be computed.
241 	       * and need not to be stored here.
242 	       */
243 
244 	      /* both are in the little endian format */
245 	      *journal_table++ = desc.j_len;
246 	      for (i = 0; i < __le32_to_cpu(desc.j_len) && i < JOURNAL_TRANS_HALF; i++)
247 		{
248 		  /* both are in the little endian format */
249 		  *journal_table++ = desc.j_realblock[i];
250 #ifdef REISERDEBUG
251 		  printf ("block %d is in journal %d.\n",
252 			  __le32_to_cpu(desc.j_realblock[i]), desc_block);
253 #endif
254 		}
255 	      for (     ; i < __le32_to_cpu(desc.j_len); i++)
256 		{
257 		  /* both are in the little endian format */
258 		  *journal_table++ = commit.j_realblock[i-JOURNAL_TRANS_HALF];
259 #ifdef REISERDEBUG
260 		  printf ("block %d is in journal %d.\n",
261 			  __le32_to_cpu(commit.j_realblock[i-JOURNAL_TRANS_HALF]),
262 			  desc_block);
263 #endif
264 		}
265 	    }
266 	}
267       desc_block = (commit_block + 1) & (block_count - 1);
268     }
269 #ifdef REISERDEBUG
270   printf ("Transaction %d/%d at %d isn't valid.\n",
271 	  __le32_to_cpu(desc.j_trans_id), __le32_to_cpu(desc.j_mount_id), desc_block);
272 #endif
273 
274   INFO->journal_transactions
275     = next_trans_id - __le32_to_cpu(header.j_last_flush_trans_id) - 1;
276   return errnum == 0;
277 }
278 
279 /* check filesystem types and read superblock into memory buffer */
280 int
281 reiserfs_mount (unsigned part_length)
282 {
283   struct reiserfs_super_block super;
284   int superblock = REISERFS_DISK_OFFSET_IN_BYTES >> SECTOR_BITS;
285 
286   if (part_length < superblock + (sizeof (super) >> SECTOR_BITS)
287       || ! reiserfs_devread (superblock, 0, sizeof (struct reiserfs_super_block),
288 			     (char *) &super)
289       || (substring (REISER3FS_SUPER_MAGIC_STRING, super.s_magic) > 0
290 	  && substring (REISER2FS_SUPER_MAGIC_STRING, super.s_magic) > 0
291 	  && substring (REISERFS_SUPER_MAGIC_STRING, super.s_magic) > 0)
292       || (/* check that this is not a copy inside the journal log */
293 	  sb_journal_block(&super) * sb_blocksize(&super)
294 	  <= REISERFS_DISK_OFFSET_IN_BYTES))
295     {
296       /* Try old super block position */
297       superblock = REISERFS_OLD_DISK_OFFSET_IN_BYTES >> SECTOR_BITS;
298       if (part_length < superblock + (sizeof (super) >> SECTOR_BITS)
299 	  || ! reiserfs_devread (superblock, 0, sizeof (struct reiserfs_super_block),
300 				 (char *) &super))
301 	return 0;
302 
303       if (substring (REISER2FS_SUPER_MAGIC_STRING, super.s_magic) > 0
304 	  && substring (REISERFS_SUPER_MAGIC_STRING, super.s_magic) > 0)
305 	{
306 	  /* pre journaling super block ? */
307 	  if (substring (REISERFS_SUPER_MAGIC_STRING,
308 			 (char*) ((int) &super + 20)) > 0)
309 	    return 0;
310 
311 	  set_sb_blocksize(&super, REISERFS_OLD_BLOCKSIZE);
312 	  set_sb_journal_block(&super, 0);
313 	  set_sb_version(&super, 0);
314 	}
315     }
316 
317   /* check the version number.  */
318   if (sb_version(&super) > REISERFS_MAX_SUPPORTED_VERSION)
319     return 0;
320 
321   INFO->version = sb_version(&super);
322   INFO->blocksize = sb_blocksize(&super);
323   INFO->fullblocksize_shift = log2 (sb_blocksize(&super));
324   INFO->blocksize_shift = INFO->fullblocksize_shift - SECTOR_BITS;
325   INFO->cached_slots =
326     (FSYSREISER_CACHE_SIZE >> INFO->fullblocksize_shift) - 1;
327 
328 #ifdef REISERDEBUG
329   printf ("reiserfs_mount: version=%d, blocksize=%d\n",
330 	  INFO->version, INFO->blocksize);
331 #endif /* REISERDEBUG */
332 
333   /* Clear node cache. */
334   memset (INFO->blocks, 0, sizeof (INFO->blocks));
335 
336   if (sb_blocksize(&super) < FSYSREISER_MIN_BLOCKSIZE
337       || sb_blocksize(&super) > FSYSREISER_MAX_BLOCKSIZE
338       || (SECTOR_SIZE << INFO->blocksize_shift) != sb_blocksize(&super))
339     return 0;
340 
341   /* Initialize journal code.  If something fails we end with zero
342    * journal_transactions, so we don't access the journal at all.
343    */
344   INFO->journal_transactions = 0;
345   if (sb_journal_block(&super) != 0 && super.s_journal_dev == 0)
346     {
347       INFO->journal_block = sb_journal_block(&super);
348       INFO->journal_block_count = sb_journal_size(&super);
349       if (is_power_of_two (INFO->journal_block_count))
350 	journal_init ();
351 
352       /* Read in super block again, maybe it is in the journal */
353       block_read (superblock >> INFO->blocksize_shift,
354 		  0, sizeof (struct reiserfs_super_block), (char *) &super);
355     }
356 
357   if (! block_read (sb_root_block(&super), 0, INFO->blocksize, (char*) ROOT))
358     return 0;
359 
360   INFO->tree_depth = __le16_to_cpu(BLOCKHEAD (ROOT)->blk_level);
361 
362 #ifdef REISERDEBUG
363   printf ("root read_in: block=%d, depth=%d\n",
364 	  sb_root_block(&super), INFO->tree_depth);
365 #endif /* REISERDEBUG */
366 
367   if (INFO->tree_depth >= MAX_HEIGHT)
368     return 0;
369   if (INFO->tree_depth == DISK_LEAF_NODE_LEVEL)
370     {
371       /* There is only one node in the whole filesystem,
372        * which is simultanously leaf and root */
373       memcpy (LEAF, ROOT, INFO->blocksize);
374     }
375   return 1;
376 }
377 
378 /***************** TREE ACCESSING METHODS *****************************/
379 
380 /* I assume you are familiar with the ReiserFS tree, if not go to
381  * http://www.namesys.com/content_table.html
382  *
383  * My tree node cache is organized as following
384  *   0   ROOT node
385  *   1   LEAF node  (if the ROOT is also a LEAF it is copied here
386  *   2-n other nodes on current path from bottom to top.
387  *       if there is not enough space in the cache, the top most are
388  *       omitted.
389  *
390  * I have only two methods to find a key in the tree:
391  *   search_stat(dir_id, objectid) searches for the stat entry (always
392  *       the first entry) of an object.
393  *   next_key() gets the next key in tree order.
394  *
395  * This means, that I can only sequential reads of files are
396  * efficient, but this really doesn't hurt for grub.
397  */
398 
399 /* Read in the node at the current path and depth into the node cache.
400  * You must set INFO->blocks[depth] before.
401  */
402 static char *
403 read_tree_node (unsigned int blockNr, int depth)
404 {
405   char* cache = CACHE(depth);
406   int num_cached = INFO->cached_slots;
407   if (depth < num_cached)
408     {
409       /* This is the cached part of the path.  Check if same block is
410        * needed.
411        */
412       if (blockNr == INFO->blocks[depth])
413 	return cache;
414     }
415   else
416     cache = CACHE(num_cached);
417 
418 #ifdef REISERDEBUG
419   printf ("  next read_in: block=%d (depth=%d)\n",
420 	  blockNr, depth);
421 #endif /* REISERDEBUG */
422   if (! block_read (blockNr, 0, INFO->blocksize, cache))
423     return 0;
424   /* Make sure it has the right node level */
425   if (__le16_to_cpu(BLOCKHEAD (cache)->blk_level) != depth)
426     {
427       errnum = ERR_FSYS_CORRUPT;
428       return 0;
429     }
430 
431   INFO->blocks[depth] = blockNr;
432   return cache;
433 }
434 
435 /* Get the next key, i.e. the key following the last retrieved key in
436  * tree order.  INFO->current_ih and
437  * INFO->current_info are adapted accordingly.  */
438 static int
439 next_key (void)
440 {
441   int depth;
442   struct item_head *ih = INFO->current_ih + 1;
443   char *cache;
444 
445 #ifdef REISERDEBUG
446   printf ("next_key:\n  old ih: key %d:%d:%d:%d version:%d\n",
447 	  __le32_to_cpu(INFO->current_ih->ih_key.k_dir_id),
448 	  __le32_to_cpu(INFO->current_ih->ih_key.k_objectid),
449 	  __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_offset),
450 	  __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_uniqueness),
451 	  __le16_to_cpu(INFO->current_ih->ih_version));
452 #endif /* REISERDEBUG */
453 
454   if (ih == &ITEMHEAD[__le16_to_cpu(BLOCKHEAD (LEAF)->blk_nr_item)])
455     {
456       depth = DISK_LEAF_NODE_LEVEL;
457       /* The last item, was the last in the leaf node.
458        * Read in the next block
459        */
460       do
461 	{
462 	  if (depth == INFO->tree_depth)
463 	    {
464 	      /* There are no more keys at all.
465 	       * Return a dummy item with MAX_KEY */
466 	      ih = (struct item_head *) &BLOCKHEAD (LEAF)->blk_right_delim_key;
467 	      goto found;
468 	    }
469 	  depth++;
470 #ifdef REISERDEBUG
471 	  printf ("  depth=%d, i=%d\n", depth, INFO->next_key_nr[depth]);
472 #endif /* REISERDEBUG */
473 	}
474       while (INFO->next_key_nr[depth] == 0);
475 
476       if (depth == INFO->tree_depth)
477 	cache = ROOT;
478       else if (depth <= INFO->cached_slots)
479 	cache = CACHE (depth);
480       else
481 	{
482 	  cache = read_tree_node (INFO->blocks[depth], depth);
483 	  if (! cache)
484 	    return 0;
485 	}
486 
487       do
488 	{
489 	  int nr_item = __le16_to_cpu(BLOCKHEAD (cache)->blk_nr_item);
490 	  int key_nr = INFO->next_key_nr[depth]++;
491 #ifdef REISERDEBUG
492 	  printf ("  depth=%d, i=%d/%d\n", depth, key_nr, nr_item);
493 #endif /* REISERDEBUG */
494 	  if (key_nr == nr_item)
495 	    /* This is the last item in this block, set the next_key_nr to 0 */
496 	    INFO->next_key_nr[depth] = 0;
497 
498 	  cache = read_tree_node (dc_block_number(&(DC (cache)[key_nr])), --depth);
499 	  if (! cache)
500 	    return 0;
501 	}
502       while (depth > DISK_LEAF_NODE_LEVEL);
503 
504       ih = ITEMHEAD;
505     }
506  found:
507   INFO->current_ih   = ih;
508   INFO->current_item = &LEAF[__le16_to_cpu(ih->ih_item_location)];
509 #ifdef REISERDEBUG
510   printf ("  new ih: key %d:%d:%d:%d version:%d\n",
511 	  __le32_to_cpu(INFO->current_ih->ih_key.k_dir_id),
512 	  __le32_to_cpu(INFO->current_ih->ih_key.k_objectid),
513 	  __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_offset),
514 	  __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_uniqueness),
515 	  __le16_to_cpu(INFO->current_ih->ih_version));
516 #endif /* REISERDEBUG */
517   return 1;
518 }
519 
520 /* preconditions: reiserfs_mount already executed, therefore
521  *   INFO block is valid
522  * returns: 0 if error (errnum is set),
523  *   nonzero iff we were able to find the key successfully.
524  * postconditions: on a nonzero return, the current_ih and
525  *   current_item fields describe the key that equals the
526  *   searched key.  INFO->next_key contains the next key after
527  *   the searched key.
528  * side effects: messes around with the cache.
529  */
530 static int
531 search_stat (__u32 dir_id, __u32 objectid)
532 {
533   char *cache;
534   int depth;
535   int nr_item;
536   int i;
537   struct item_head *ih;
538 #ifdef REISERDEBUG
539   printf ("search_stat:\n  key %d:%d:0:0\n", dir_id, objectid);
540 #endif /* REISERDEBUG */
541 
542   depth = INFO->tree_depth;
543   cache = ROOT;
544 
545   while (depth > DISK_LEAF_NODE_LEVEL)
546     {
547       struct key *key;
548       nr_item = __le16_to_cpu(BLOCKHEAD (cache)->blk_nr_item);
549 
550       key = KEY (cache);
551 
552       for (i = 0; i < nr_item; i++)
553 	{
554 	  if (__le32_to_cpu(key->k_dir_id) > dir_id
555 	      || (__le32_to_cpu(key->k_dir_id) == dir_id
556 		  && (__le32_to_cpu(key->k_objectid) > objectid
557 		      || (__le32_to_cpu(key->k_objectid) == objectid
558 			  && (__le32_to_cpu(key->u.v1.k_offset)
559 			      | __le32_to_cpu(key->u.v1.k_uniqueness)) > 0))))
560 	    break;
561 	  key++;
562 	}
563 
564 #ifdef REISERDEBUG
565       printf ("  depth=%d, i=%d/%d\n", depth, i, nr_item);
566 #endif /* REISERDEBUG */
567       INFO->next_key_nr[depth] = (i == nr_item) ? 0 : i+1;
568       cache = read_tree_node (dc_block_number(&(DC (cache)[i])), --depth);
569       if (! cache)
570 	return 0;
571     }
572 
573   /* cache == LEAF */
574   nr_item = __le16_to_cpu(BLOCKHEAD (LEAF)->blk_nr_item);
575   ih = ITEMHEAD;
576   for (i = 0; i < nr_item; i++)
577     {
578       if (__le32_to_cpu(ih->ih_key.k_dir_id) == dir_id
579 	  && __le32_to_cpu(ih->ih_key.k_objectid) == objectid
580 	  && __le32_to_cpu(ih->ih_key.u.v1.k_offset) == 0
581 	  && __le32_to_cpu(ih->ih_key.u.v1.k_uniqueness) == 0)
582 	{
583 #ifdef REISERDEBUG
584 	  printf ("  depth=%d, i=%d/%d\n", depth, i, nr_item);
585 #endif /* REISERDEBUG */
586 	  INFO->current_ih   = ih;
587 	  INFO->current_item = &LEAF[__le16_to_cpu(ih->ih_item_location)];
588 	  return 1;
589 	}
590       ih++;
591     }
592   errnum = ERR_FSYS_CORRUPT;
593   return 0;
594 }
595 
596 int
597 reiserfs_read (char *buf, unsigned len)
598 {
599   unsigned int blocksize;
600   unsigned int offset;
601   unsigned int to_read;
602   char *prev_buf = buf;
603 
604 #ifdef REISERDEBUG
605   printf ("reiserfs_read: filepos=%d len=%d, offset=%Lx\n",
606 	  filepos, len, (__u64) IH_KEY_OFFSET (INFO->current_ih) - 1);
607 #endif /* REISERDEBUG */
608 
609   if (__le32_to_cpu(INFO->current_ih->ih_key.k_objectid) != INFO->fileinfo.k_objectid
610       || IH_KEY_OFFSET (INFO->current_ih) > filepos + 1)
611     {
612       search_stat (INFO->fileinfo.k_dir_id, INFO->fileinfo.k_objectid);
613       goto get_next_key;
614     }
615 
616   while (! errnum)
617     {
618       if (__le32_to_cpu(INFO->current_ih->ih_key.k_objectid) != INFO->fileinfo.k_objectid) {
619 	break;
620       }
621 
622       offset = filepos - IH_KEY_OFFSET (INFO->current_ih) + 1;
623       blocksize = __le16_to_cpu(INFO->current_ih->ih_item_len);
624 
625 #ifdef REISERDEBUG
626       printf ("  loop: filepos=%d len=%d, offset=%d blocksize=%d\n",
627 	      filepos, len, offset, blocksize);
628 #endif /* REISERDEBUG */
629 
630       if (IH_KEY_ISTYPE(INFO->current_ih, TYPE_DIRECT)
631 	  && offset < blocksize)
632 	{
633 #ifdef REISERDEBUG
634 	  printf ("direct_read: offset=%d, blocksize=%d\n",
635 		  offset, blocksize);
636 #endif /* REISERDEBUG */
637 	  to_read = blocksize - offset;
638 	  if (to_read > len)
639 	    to_read = len;
640 
641 	  memcpy (buf, INFO->current_item + offset, to_read);
642 	  goto update_buf_len;
643 	}
644       else if (IH_KEY_ISTYPE(INFO->current_ih, TYPE_INDIRECT))
645 	{
646 	  blocksize = (blocksize >> 2) << INFO->fullblocksize_shift;
647 #ifdef REISERDEBUG
648 	  printf ("indirect_read: offset=%d, blocksize=%d\n",
649 		  offset, blocksize);
650 #endif /* REISERDEBUG */
651 
652 	  while (offset < blocksize)
653 	    {
654 	      __u32 blocknr = __le32_to_cpu(((__u32 *) INFO->current_item)
655 		[offset >> INFO->fullblocksize_shift]);
656 	      int blk_offset = offset & (INFO->blocksize-1);
657 	      to_read = INFO->blocksize - blk_offset;
658 	      if (to_read > len)
659 		to_read = len;
660 
661 	      /* Journal is only for meta data.  Data blocks can be read
662 	       * directly without using block_read
663 	       */
664 	      reiserfs_devread (blocknr << INFO->blocksize_shift,
665 				blk_offset, to_read, buf);
666 	    update_buf_len:
667 	      len -= to_read;
668 	      buf += to_read;
669 	      offset += to_read;
670 	      filepos += to_read;
671 	      if (len == 0)
672 		goto done;
673 	    }
674 	}
675     get_next_key:
676       next_key ();
677     }
678  done:
679   return errnum ? 0 : buf - prev_buf;
680 }
681 
682 
683 /* preconditions: reiserfs_mount already executed, therefore
684  *   INFO block is valid
685  * returns: 0 if error, nonzero iff we were able to find the file successfully
686  * postconditions: on a nonzero return, INFO->fileinfo contains the info
687  *   of the file we were trying to look up, filepos is 0 and filemax is
688  *   the size of the file.
689  */
690 static int
691 reiserfs_dir (char *dirname)
692 {
693   struct reiserfs_de_head *de_head;
694   char *rest, ch;
695   __u32 dir_id, objectid, parent_dir_id = 0, parent_objectid = 0;
696 #ifndef STAGE1_5
697   int do_possibilities = 0;
698 #endif /* ! STAGE1_5 */
699   char linkbuf[PATH_MAX];	/* buffer for following symbolic links */
700   int link_count = 0;
701   int mode;
702 
703   dir_id = REISERFS_ROOT_PARENT_OBJECTID;
704   objectid = REISERFS_ROOT_OBJECTID;
705 
706   while (1)
707     {
708 #ifdef REISERDEBUG
709       printf ("dirname=%s\n", dirname);
710 #endif /* REISERDEBUG */
711 
712       /* Search for the stat info first. */
713       if (! search_stat (dir_id, objectid))
714 	return 0;
715 
716 #ifdef REISERDEBUG
717        printf ("sd_mode=%x sd_size=%d\n",
718 	       stat_data_v1(INFO->current_ih) ? sd_v1_mode((struct stat_data_v1 *) INFO->current_item) :
719 						sd_v2_mode((struct stat_data *) (INFO->current_item)),
720 	       stat_data_v1(INFO->current_ih) ? sd_v1_size((struct stat_data_v1 *) INFO->current_item) :
721 						sd_v2_size((struct stat_data *) INFO->current_item)
722 	      );
723 
724 #endif /* REISERDEBUG */
725       mode = stat_data_v1(INFO->current_ih) ?
726 	       sd_v1_mode((struct stat_data_v1 *) INFO->current_item) :
727 	       sd_v2_mode((struct stat_data *) INFO->current_item);
728 
729       /* If we've got a symbolic link, then chase it. */
730       if (S_ISLNK (mode))
731 	{
732 	  unsigned int len;
733 	  if (++link_count > MAX_LINK_COUNT)
734 	    {
735 	      errnum = ERR_SYMLINK_LOOP;
736 	      return 0;
737 	    }
738 
739 	  /* Get the symlink size. */
740 	  filemax = stat_data_v1(INFO->current_ih) ?
741 		     sd_v1_size((struct stat_data_v1 *) INFO->current_item) :
742 		     sd_v2_size((struct stat_data *) INFO->current_item);
743 
744 	  /* Find out how long our remaining name is. */
745 	  len = 0;
746 	  while (dirname[len] && !isspace (dirname[len]))
747 	    len++;
748 
749 	  if (filemax + len > sizeof (linkbuf) - 1)
750 	    {
751 	      errnum = ERR_FILELENGTH;
752 	      return 0;
753 	    }
754 
755 	  /* Copy the remaining name to the end of the symlink data.
756 	     Note that DIRNAME and LINKBUF may overlap! */
757 	  memmove (linkbuf + filemax, dirname, len+1);
758 
759 	  INFO->fileinfo.k_dir_id = dir_id;
760 	  INFO->fileinfo.k_objectid = objectid;
761 	  filepos = 0;
762 	  if (! next_key ()
763 	      || reiserfs_read (linkbuf, filemax) != filemax)
764 	    {
765 	      if (! errnum)
766 		errnum = ERR_FSYS_CORRUPT;
767 	      return 0;
768 	    }
769 
770 #ifdef REISERDEBUG
771 	  printf ("symlink=%s\n", linkbuf);
772 #endif /* REISERDEBUG */
773 
774 	  dirname = linkbuf;
775 	  if (*dirname == '/')
776 	    {
777 	      /* It's an absolute link, so look it up in root. */
778 	      dir_id = REISERFS_ROOT_PARENT_OBJECTID;
779 	      objectid = REISERFS_ROOT_OBJECTID;
780 	    }
781 	  else
782 	    {
783 	      /* Relative, so look it up in our parent directory. */
784 	      dir_id   = parent_dir_id;
785 	      objectid = parent_objectid;
786 	    }
787 
788 	  /* Now lookup the new name. */
789 	  continue;
790 	}
791 
792       /* if we have a real file (and we're not just printing possibilities),
793 	 then this is where we want to exit */
794 
795       if (! *dirname || isspace (*dirname))
796 	{
797 	  if (! S_ISREG (mode))
798 	    {
799 	      errnum = ERR_BAD_FILETYPE;
800 	      return 0;
801 	    }
802 
803 	  filepos = 0;
804 	  filemax = stat_data_v1(INFO->current_ih) ?
805 		      sd_v1_size((struct stat_data_v1 *) INFO->current_item) :
806 		      sd_v2_size((struct stat_data *) INFO->current_item);
807 #if 0
808 	  /* If this is a new stat data and size is > 4GB set filemax to
809 	   * maximum
810 	   */
811 	  if (__le16_to_cpu(INFO->current_ih->ih_version) == ITEM_VERSION_2
812 	      && sd_size_hi((struct stat_data *) INFO->current_item) > 0)
813 	    filemax = 0xffffffff;
814 #endif
815 	  INFO->fileinfo.k_dir_id = dir_id;
816 	  INFO->fileinfo.k_objectid = objectid;
817 	  return next_key ();
818 	}
819 
820       /* continue with the file/directory name interpretation */
821       while (*dirname == '/')
822 	dirname++;
823       if (! S_ISDIR (mode))
824 	{
825 	  errnum = ERR_BAD_FILETYPE;
826 	  return 0;
827 	}
828       for (rest = dirname; (ch = *rest) && ! isspace (ch) && ch != '/'; rest++);
829       *rest = 0;
830 
831 # ifndef STAGE1_5
832       if (print_possibilities && ch != '/')
833 	do_possibilities = 1;
834 # endif /* ! STAGE1_5 */
835 
836       while (1)
837 	{
838 	  char *name_end;
839 	  int num_entries;
840 
841 	  if (! next_key ())
842 	    return 0;
843 #ifdef REISERDEBUG
844 	  printf ("ih: key %d:%d:%d:%d version:%d\n",
845 		  __le32_to_cpu(INFO->current_ih->ih_key.k_dir_id),
846 		  __le32_to_cpu(INFO->current_ih->ih_key.k_objectid),
847 		  __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_offset),
848 		  __le32_to_cpu(INFO->current_ih->ih_key.u.v1.k_uniqueness),
849 		  __le16_to_cpu(INFO->current_ih->ih_version));
850 #endif /* REISERDEBUG */
851 
852 	  if (__le32_to_cpu(INFO->current_ih->ih_key.k_objectid) != objectid)
853 	    break;
854 
855 	  name_end = INFO->current_item + __le16_to_cpu(INFO->current_ih->ih_item_len);
856 	  de_head = (struct reiserfs_de_head *) INFO->current_item;
857 	  num_entries = __le16_to_cpu(INFO->current_ih->u.ih_entry_count);
858 	  while (num_entries > 0)
859 	    {
860 	      char *filename = INFO->current_item + deh_location(de_head);
861 	      char  tmp = *name_end;
862 	      if ((deh_state(de_head) & DEH_Visible))
863 		{
864 		  int cmp;
865 		  /* Directory names in ReiserFS are not null
866 		   * terminated.  We write a temporary 0 behind it.
867 		   * NOTE: that this may overwrite the first block in
868 		   * the tree cache.  That doesn't hurt as long as we
869 		   * don't call next_key () in between.
870 		   */
871 		  *name_end = 0;
872 		  cmp = substring (dirname, filename);
873 		  *name_end = tmp;
874 # ifndef STAGE1_5
875 		  if (do_possibilities)
876 		    {
877 		      if (cmp <= 0)
878 			{
879 			  char fn[PATH_MAX];
880 			  struct fsys_reiser_info info_save;
881 
882 			  if (print_possibilities > 0)
883 			    print_possibilities = -print_possibilities;
884 			  *name_end = 0;
885 			  strcpy(fn, filename);
886 			  *name_end = tmp;
887 
888 			  /* If NAME is "." or "..", do not count it.  */
889 			  if (strcmp (fn, ".") != 0 && strcmp (fn, "..") != 0) {
890 			    memcpy(&info_save, INFO, sizeof(struct fsys_reiser_info));
891 			    search_stat (deh_dir_id(de_head), deh_objectid(de_head));
892 			    sd_print_item(INFO->current_ih, INFO->current_item);
893 			    printf(" %s\n", fn);
894 			    search_stat (dir_id, objectid);
895 			    memcpy(INFO, &info_save, sizeof(struct fsys_reiser_info));
896 			  }
897 			}
898 		    }
899 		  else
900 # endif /* ! STAGE1_5 */
901 		    if (cmp == 0)
902 		      goto found;
903 		}
904 	      /* The beginning of this name marks the end of the next name.
905 	       */
906 	      name_end = filename;
907 	      de_head++;
908 	      num_entries--;
909 	    }
910 	}
911 
912 # ifndef STAGE1_5
913       if (print_possibilities < 0)
914 	return 1;
915 # endif /* ! STAGE1_5 */
916 
917       errnum = ERR_FILE_NOT_FOUND;
918       *rest = ch;
919       return 0;
920 
921     found:
922       *rest = ch;
923       dirname = rest;
924 
925       parent_dir_id = dir_id;
926       parent_objectid = objectid;
927       dir_id = deh_dir_id(de_head);
928       objectid = deh_objectid(de_head);
929     }
930 }
931 
932 /*
933  * U-Boot interface functions
934  */
935 
936 /*
937  * List given directory
938  *
939  * RETURN: 0 - OK, else grub_error_t errnum
940  */
941 int
942 reiserfs_ls (char *dirname)
943 {
944 	char *dir_slash;
945 	int res;
946 
947 	errnum = 0;
948 	dir_slash = malloc(strlen(dirname) + 1);
949 	if (dir_slash == NULL) {
950 		return ERR_NUMBER_OVERFLOW;
951 	}
952 	strcpy(dir_slash, dirname);
953 	/* add "/" to the directory name */
954 	strcat(dir_slash, "/");
955 
956 	print_possibilities = 1;
957 	res = reiserfs_dir (dir_slash);
958 	free(dir_slash);
959 	if (!res || errnum) {
960 		return errnum;
961 	}
962 
963 	return 0;
964 }
965 
966 /*
967  * Open file for reading
968  *
969  * RETURN: >0 - OK, size of opened file
970  *         <0 - ERROR  -grub_error_t errnum
971  */
972 int
973 reiserfs_open (char *filename)
974 {
975 	/* open the file */
976 	errnum = 0;
977 	print_possibilities = 0;
978 	if (!reiserfs_dir (filename) || errnum) {
979 		return -errnum;
980 	}
981 	return filemax;
982 }
983