![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fsys_reiserfs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs|
Return to fsys_reiserfs.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / fs / grubfs |
1.1 ! root 1: /* fsys_reiserfs.c - an implementation for the ReiserFS filesystem */ ! 2: /* ! 3: * GRUB -- GRand Unified Bootloader ! 4: * Copyright (C) 2000, 2001 Free Software Foundation, Inc. ! 5: * ! 6: * This program is free software; you can redistribute it and/or modify ! 7: * it under the terms of the GNU General Public License as published by ! 8: * the Free Software Foundation; either version 2 of the License, or ! 9: * (at your option) any later version. ! 10: * ! 11: * This program is distributed in the hope that it will be useful, ! 12: * but WITHOUT ANY WARRANTY; without even the implied warranty of ! 13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 14: * GNU General Public License for more details. ! 15: * ! 16: * You should have received a copy of the GNU General Public License ! 17: * along with this program; if not, write to the Free Software ! 18: * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, ! 19: * MA 02110-1301, USA. ! 20: */ ! 21: ! 22: #ifdef FSYS_REISERFS ! 23: #include "shared.h" ! 24: #include "filesys.h" ! 25: ! 26: #undef REISERDEBUG ! 27: ! 28: /* Some parts of this code (mainly the structures and defines) are ! 29: * from the original reiser fs code, as found in the linux kernel. ! 30: */ ! 31: ! 32: /* include/asm-i386/types.h */ ! 33: typedef __signed__ char __s8; ! 34: typedef unsigned char __u8; ! 35: typedef __signed__ short __s16; ! 36: typedef unsigned short __u16; ! 37: typedef __signed__ int __s32; ! 38: typedef unsigned int __u32; ! 39: typedef unsigned long long __u64; ! 40: ! 41: /* linux/posix_type.h */ ! 42: typedef long linux_off_t; ! 43: ! 44: #include "libc/byteorder.h" ! 45: ! 46: /* include/linux/reiser_fs.h */ ! 47: /* This is the new super block of a journaling reiserfs system */ ! 48: struct reiserfs_super_block ! 49: { ! 50: __u32 s_block_count; /* blocks count */ ! 51: __u32 s_free_blocks; /* free blocks count */ ! 52: __u32 s_root_block; /* root block number */ ! 53: __u32 s_journal_block; /* journal block number */ ! 54: __u32 s_journal_dev; /* journal device number */ ! 55: __u32 s_journal_size; /* size of the journal on FS creation. used to make sure they don't overflow it */ ! 56: __u32 s_journal_trans_max; /* max number of blocks in a transaction. */ ! 57: __u32 s_journal_magic; /* random value made on fs creation */ ! 58: __u32 s_journal_max_batch; /* max number of blocks to batch into a trans */ ! 59: __u32 s_journal_max_commit_age; /* in seconds, how old can an async commit be */ ! 60: __u32 s_journal_max_trans_age; /* in seconds, how old can a transaction be */ ! 61: __u16 s_blocksize; /* block size */ ! 62: __u16 s_oid_maxsize; /* max size of object id array */ ! 63: __u16 s_oid_cursize; /* current size of object id array */ ! 64: __u16 s_state; /* valid or error */ ! 65: char s_magic[16]; /* reiserfs magic string indicates that file system is reiserfs */ ! 66: __u16 s_tree_height; /* height of disk tree */ ! 67: __u16 s_bmap_nr; /* amount of bitmap blocks needed to address each block of file system */ ! 68: __u16 s_version; ! 69: char s_unused[128]; /* zero filled by mkreiserfs */ ! 70: }; ! 71: ! 72: #define REISERFS_MAX_SUPPORTED_VERSION 2 ! 73: #define REISERFS_SUPER_MAGIC_STRING "ReIsErFs" ! 74: #define REISER2FS_SUPER_MAGIC_STRING "ReIsEr2Fs" ! 75: ! 76: #define MAX_HEIGHT 7 ! 77: ! 78: /* must be correct to keep the desc and commit structs at 4k */ ! 79: #define JOURNAL_TRANS_HALF 1018 ! 80: ! 81: /* first block written in a commit. */ ! 82: struct reiserfs_journal_desc { ! 83: __u32 j_trans_id; /* id of commit */ ! 84: __u32 j_len; /* length of commit. len +1 is the commit block */ ! 85: __u32 j_mount_id; /* mount id of this trans*/ ! 86: __u32 j_realblock[JOURNAL_TRANS_HALF]; /* real locations for the first blocks */ ! 87: char j_magic[12]; ! 88: }; ! 89: ! 90: /* last block written in a commit */ ! 91: struct reiserfs_journal_commit { ! 92: __u32 j_trans_id; /* must match j_trans_id from the desc block */ ! 93: __u32 j_len; /* ditto */ ! 94: __u32 j_realblock[JOURNAL_TRANS_HALF]; /* real locations for the last blocks */ ! 95: char j_digest[16]; /* md5 sum of all the blocks involved, including desc and commit. not used, kill it */ ! 96: }; ! 97: ! 98: /* this header block gets written whenever a transaction is considered ! 99: fully flushed, and is more recent than the last fully flushed ! 100: transaction. ! 101: fully flushed means all the log blocks and all the real blocks are ! 102: on disk, and this transaction does not need to be replayed. ! 103: */ ! 104: struct reiserfs_journal_header { ! 105: /* id of last fully flushed transaction */ ! 106: __u32 j_last_flush_trans_id; ! 107: /* offset in the log of where to start replay after a crash */ ! 108: __u32 j_first_unflushed_offset; ! 109: /* mount id to detect very old transactions */ ! 110: __u32 j_mount_id; ! 111: }; ! 112: ! 113: /* magic string to find desc blocks in the journal */ ! 114: #define JOURNAL_DESC_MAGIC "ReIsErLB" ! 115: ! 116: ! 117: /* ! 118: * directories use this key as well as old files ! 119: */ ! 120: struct offset_v1 ! 121: { ! 122: /* ! 123: * for regular files this is the offset to the first byte of the ! 124: * body, contained in the object-item, as measured from the start of ! 125: * the entire body of the object. ! 126: * ! 127: * for directory entries, k_offset consists of hash derived from ! 128: * hashing the name and using few bits (23 or more) of the resulting ! 129: * hash, and generation number that allows distinguishing names with ! 130: * hash collisions. If number of collisions overflows generation ! 131: * number, we return EEXIST. High order bit is 0 always ! 132: */ ! 133: __u32 k_offset; ! 134: __u32 k_uniqueness; ! 135: }; ! 136: ! 137: struct offset_v2 ! 138: { ! 139: /* ! 140: * for regular files this is the offset to the first byte of the ! 141: * body, contained in the object-item, as measured from the start of ! 142: * the entire body of the object. ! 143: * ! 144: * for directory entries, k_offset consists of hash derived from ! 145: * hashing the name and using few bits (23 or more) of the resulting ! 146: * hash, and generation number that allows distinguishing names with ! 147: * hash collisions. If number of collisions overflows generation ! 148: * number, we return EEXIST. High order bit is 0 always ! 149: */ ! 150: __u64 k_offset:60; ! 151: __u64 k_type: 4; ! 152: }; ! 153: ! 154: ! 155: struct key ! 156: { ! 157: /* packing locality: by default parent directory object id */ ! 158: __u32 k_dir_id; ! 159: /* object identifier */ ! 160: __u32 k_objectid; ! 161: /* the offset and node type (old and new form) */ ! 162: union ! 163: { ! 164: struct offset_v1 v1; ! 165: struct offset_v2 v2; ! 166: } ! 167: u; ! 168: }; ! 169: ! 170: #define KEY_SIZE (sizeof (struct key)) ! 171: ! 172: /* Header of a disk block. More precisely, header of a formatted leaf ! 173: or internal node, and not the header of an unformatted node. */ ! 174: struct block_head ! 175: { ! 176: __u16 blk_level; /* Level of a block in the tree. */ ! 177: __u16 blk_nr_item; /* Number of keys/items in a block. */ ! 178: __u16 blk_free_space; /* Block free space in bytes. */ ! 179: struct key blk_right_delim_key; /* Right delimiting key for this block (supported for leaf level nodes ! 180: only) */ ! 181: }; ! 182: #define BLKH_SIZE (sizeof (struct block_head)) ! 183: #define DISK_LEAF_NODE_LEVEL 1 /* Leaf node level. */ ! 184: ! 185: struct item_head ! 186: { ! 187: struct key ih_key; /* Everything in the tree is found by searching for it based on its key.*/ ! 188: ! 189: union ! 190: { ! 191: __u16 ih_free_space; /* The free space in the last unformatted node of an indirect item if this ! 192: is an indirect item. This equals 0xFFFF iff this is a direct item or ! 193: stat data item. Note that the key, not this field, is used to determine ! 194: the item type, and thus which field this union contains. */ ! 195: __u16 ih_entry_count; /* Iff this is a directory item, this field equals the number of directory ! 196: entries in the directory item. */ ! 197: } ! 198: u; ! 199: __u16 ih_item_len; /* total size of the item body */ ! 200: __u16 ih_item_location; /* an offset to the item body within the block */ ! 201: __u16 ih_version; /* ITEM_VERSION_1 for all old items, ! 202: ITEM_VERSION_2 for new ones. ! 203: Highest bit is set by fsck ! 204: temporary, cleaned after all done */ ! 205: }; ! 206: /* size of item header */ ! 207: #define IH_SIZE (sizeof (struct item_head)) ! 208: ! 209: #define ITEM_VERSION_1 0 ! 210: #define ITEM_VERSION_2 1 ! 211: #define IH_KEY_OFFSET(ih) ((ih)->ih_version == ITEM_VERSION_1 \ ! 212: ? (ih)->ih_key.u.v1.k_offset \ ! 213: : (ih)->ih_key.u.v2.k_offset) ! 214: ! 215: #define IH_KEY_ISTYPE(ih, type) ((ih)->ih_version == ITEM_VERSION_1 \ ! 216: ? (ih)->ih_key.u.v1.k_uniqueness == V1_##type \ ! 217: : (ih)->ih_key.u.v2.k_type == V2_##type) ! 218: ! 219: /* FIXME these types look wrong. */ ! 220: struct disk_child ! 221: { ! 222: unsigned long dc_block_number; /* Disk child's block number. */ ! 223: unsigned short dc_size; /* Disk child's used space. */ ! 224: }; ! 225: ! 226: #define DC_SIZE (sizeof (struct disk_child)) ! 227: ! 228: /* Stat Data on disk. ! 229: * ! 230: * Note that reiserfs has two different forms of stat data. Luckily ! 231: * the fields needed by grub are at the same position. ! 232: */ ! 233: struct stat_data ! 234: { ! 235: __u16 sd_mode; /* file type, permissions */ ! 236: __u16 sd_notused1[3]; /* fields not needed by reiserfs */ ! 237: __u32 sd_size; /* file size */ ! 238: __u32 sd_size_hi; /* file size high 32 bits (since version 2) */ ! 239: }; ! 240: ! 241: struct reiserfs_de_head ! 242: { ! 243: __u32 deh_offset; /* third component of the directory entry key */ ! 244: __u32 deh_dir_id; /* objectid of the parent directory of the ! 245: object, that is referenced by directory entry */ ! 246: __u32 deh_objectid;/* objectid of the object, that is referenced by ! 247: directory entry */ ! 248: __u16 deh_location;/* offset of name in the whole item */ ! 249: __u16 deh_state; /* whether 1) entry contains stat data (for ! 250: future), and 2) whether entry is hidden ! 251: (unlinked) */ ! 252: }; ! 253: ! 254: #define DEH_SIZE (sizeof (struct reiserfs_de_head)) ! 255: ! 256: #define DEH_Statdata (1 << 0) /* not used now */ ! 257: #define DEH_Visible (1 << 2) ! 258: ! 259: #define SD_OFFSET 0 ! 260: #define SD_UNIQUENESS 0 ! 261: #define DOT_OFFSET 1 ! 262: #define DOT_DOT_OFFSET 2 ! 263: #define DIRENTRY_UNIQUENESS 500 ! 264: ! 265: #define V1_TYPE_STAT_DATA 0x0 ! 266: #define V1_TYPE_DIRECT 0xffffffff ! 267: #define V1_TYPE_INDIRECT 0xfffffffe ! 268: #define V1_TYPE_DIRECTORY_MAX 0xfffffffd ! 269: #define V2_TYPE_STAT_DATA 0 ! 270: #define V2_TYPE_INDIRECT 1 ! 271: #define V2_TYPE_DIRECT 2 ! 272: #define V2_TYPE_DIRENTRY 3 ! 273: ! 274: #define REISERFS_ROOT_OBJECTID 2 ! 275: #define REISERFS_ROOT_PARENT_OBJECTID 1 ! 276: #define REISERFS_DISK_OFFSET_IN_BYTES (64 * 1024) ! 277: /* the spot for the super in versions 3.5 - 3.5.11 (inclusive) */ ! 278: #define REISERFS_OLD_DISK_OFFSET_IN_BYTES (8 * 1024) ! 279: #define REISERFS_OLD_BLOCKSIZE 4096 ! 280: ! 281: #define S_ISREG(mode) (((mode) & 0170000) == 0100000) ! 282: #define S_ISDIR(mode) (((mode) & 0170000) == 0040000) ! 283: #define S_ISLNK(mode) (((mode) & 0170000) == 0120000) ! 284: ! 285: #define PATH_MAX 1024 /* include/linux/limits.h */ ! 286: #define MAX_LINK_COUNT 5 /* number of symbolic links to follow */ ! 287: ! 288: /* The size of the node cache */ ! 289: #define FSYSREISER_CACHE_SIZE 24*1024 ! 290: #define FSYSREISER_MIN_BLOCKSIZE SECTOR_SIZE ! 291: #define FSYSREISER_MAX_BLOCKSIZE FSYSREISER_CACHE_SIZE / 3 ! 292: ! 293: /* Info about currently opened file */ ! 294: struct fsys_reiser_fileinfo ! 295: { ! 296: __u32 k_dir_id; ! 297: __u32 k_objectid; ! 298: }; ! 299: ! 300: /* In memory info about the currently mounted filesystem */ ! 301: struct fsys_reiser_info ! 302: { ! 303: /* The last read item head */ ! 304: struct item_head *current_ih; ! 305: /* The last read item */ ! 306: char *current_item; ! 307: /* The information for the currently opened file */ ! 308: struct fsys_reiser_fileinfo fileinfo; ! 309: /* The start of the journal */ ! 310: __u32 journal_block; ! 311: /* The size of the journal */ ! 312: __u32 journal_block_count; ! 313: /* The first valid descriptor block in journal ! 314: (relative to journal_block) */ ! 315: __u32 journal_first_desc; ! 316: ! 317: /* The ReiserFS version. */ ! 318: __u16 version; ! 319: /* The current depth of the reiser tree. */ ! 320: __u16 tree_depth; ! 321: /* SECTOR_SIZE << blocksize_shift == blocksize. */ ! 322: __u8 blocksize_shift; ! 323: /* 1 << full_blocksize_shift == blocksize. */ ! 324: __u8 fullblocksize_shift; ! 325: /* The reiserfs block size (must be a power of 2) */ ! 326: __u16 blocksize; ! 327: /* The number of cached tree nodes */ ! 328: __u16 cached_slots; ! 329: /* The number of valid transactions in journal */ ! 330: __u16 journal_transactions; ! 331: ! 332: unsigned int blocks[MAX_HEIGHT]; ! 333: unsigned int next_key_nr[MAX_HEIGHT]; ! 334: }; ! 335: ! 336: /* The cached s+tree blocks in FSYS_BUF, see below ! 337: * for a more detailed description. ! 338: */ ! 339: #define ROOT ((char *)FSYS_BUF) ! 340: #define CACHE(i) (ROOT + ((i) << INFO->fullblocksize_shift)) ! 341: #define LEAF CACHE (DISK_LEAF_NODE_LEVEL) ! 342: ! 343: #define BLOCKHEAD(cache) ((struct block_head *) cache) ! 344: #define ITEMHEAD ((struct item_head *) ((char *) LEAF + BLKH_SIZE)) ! 345: #define KEY(cache) ((struct key *) ((char *) cache + BLKH_SIZE)) ! 346: #define DC(cache) ((struct disk_child *) \ ! 347: ((char *) cache + BLKH_SIZE + KEY_SIZE * nr_item)) ! 348: /* The fsys_reiser_info block. ! 349: */ ! 350: #define INFO \ ! 351: ((struct fsys_reiser_info *) ((char *) FSYS_BUF + FSYSREISER_CACHE_SIZE)) ! 352: /* ! 353: * The journal cache. For each transaction it contains the number of ! 354: * blocks followed by the real block numbers of this transaction. ! 355: * ! 356: * If the block numbers of some transaction won't fit in this space, ! 357: * this list is stopped with a 0xffffffff marker and the remaining ! 358: * uncommitted transactions aren't cached. ! 359: */ ! 360: #define JOURNAL_START ((__u32 *) (INFO + 1)) ! 361: #define JOURNAL_END ((__u32 *) (FSYS_BUF + FSYS_BUFLEN)) ! 362: ! 363: static __inline__ int ! 364: is_power_of_two (unsigned long word) ! 365: { ! 366: return (word & -word) == word; ! 367: } ! 368: ! 369: static int ! 370: journal_read (int block, int len, char *buffer) ! 371: { ! 372: return devread ((INFO->journal_block + block) << INFO->blocksize_shift, ! 373: 0, len, buffer); ! 374: } ! 375: ! 376: /* Read a block from ReiserFS file system, taking the journal into ! 377: * account. If the block nr is in the journal, the block from the ! 378: * journal taken. ! 379: */ ! 380: static int ! 381: block_read (int blockNr, int start, int len, char *buffer) ! 382: { ! 383: int transactions = INFO->journal_transactions; ! 384: int desc_block = INFO->journal_first_desc; ! 385: int journal_mask = INFO->journal_block_count - 1; ! 386: int translatedNr = blockNr; ! 387: __u32 *journal_table = JOURNAL_START; ! 388: while (transactions-- > 0) ! 389: { ! 390: int i = 0; ! 391: int j_len; ! 392: if (*journal_table != 0xffffffff) ! 393: { ! 394: /* Search for the blockNr in cached journal */ ! 395: j_len = *journal_table++; ! 396: while (i++ < j_len) ! 397: { ! 398: if (*journal_table++ == blockNr) ! 399: { ! 400: journal_table += j_len - i; ! 401: goto found; ! 402: } ! 403: } ! 404: } ! 405: else ! 406: { ! 407: /* This is the end of cached journal marker. The remaining ! 408: * transactions are still on disk. ! 409: */ ! 410: struct reiserfs_journal_desc desc; ! 411: struct reiserfs_journal_commit commit; ! 412: ! 413: if (! journal_read (desc_block, sizeof (desc), (char *) &desc)) ! 414: return 0; ! 415: ! 416: j_len = desc.j_len; ! 417: while (i < j_len && i < JOURNAL_TRANS_HALF) ! 418: if (desc.j_realblock[i++] == blockNr) ! 419: goto found; ! 420: ! 421: if (j_len >= JOURNAL_TRANS_HALF) ! 422: { ! 423: int commit_block = (desc_block + 1 + j_len) & journal_mask; ! 424: if (! journal_read (commit_block, ! 425: sizeof (commit), (char *) &commit)) ! 426: return 0; ! 427: while (i < j_len) ! 428: if (commit.j_realblock[i++ - JOURNAL_TRANS_HALF] == blockNr) ! 429: goto found; ! 430: } ! 431: } ! 432: goto not_found; ! 433: ! 434: found: ! 435: translatedNr = INFO->journal_block + ((desc_block + i) & journal_mask); ! 436: #ifdef REISERDEBUG ! 437: printf ("block_read: block %d is mapped to journal block %d.\n", ! 438: blockNr, translatedNr - INFO->journal_block); ! 439: #endif ! 440: /* We must continue the search, as this block may be overwritten ! 441: * in later transactions. ! 442: */ ! 443: not_found: ! 444: desc_block = (desc_block + 2 + j_len) & journal_mask; ! 445: } ! 446: return devread (translatedNr << INFO->blocksize_shift, start, len, buffer); ! 447: } ! 448: ! 449: /* Init the journal data structure. We try to cache as much as ! 450: * possible in the JOURNAL_START-JOURNAL_END space, but if it is full ! 451: * we can still read the rest from the disk on demand. ! 452: * ! 453: * The first number of valid transactions and the descriptor block of the ! 454: * first valid transaction are held in INFO. The transactions are all ! 455: * adjacent, but we must take care of the journal wrap around. ! 456: */ ! 457: static int ! 458: journal_init (void) ! 459: { ! 460: unsigned int block_count = INFO->journal_block_count; ! 461: unsigned int desc_block; ! 462: unsigned int commit_block; ! 463: unsigned int next_trans_id; ! 464: struct reiserfs_journal_header header; ! 465: struct reiserfs_journal_desc desc; ! 466: struct reiserfs_journal_commit commit; ! 467: __u32 *journal_table = JOURNAL_START; ! 468: ! 469: journal_read (block_count, sizeof (header), (char *) &header); ! 470: desc_block = header.j_first_unflushed_offset; ! 471: if (desc_block >= block_count) ! 472: return 0; ! 473: ! 474: INFO->journal_first_desc = desc_block; ! 475: next_trans_id = header.j_last_flush_trans_id + 1; ! 476: ! 477: #ifdef REISERDEBUG ! 478: printf ("journal_init: last flushed %d\n", ! 479: header.j_last_flush_trans_id); ! 480: #endif ! 481: ! 482: while (1) ! 483: { ! 484: journal_read (desc_block, sizeof (desc), (char *) &desc); ! 485: if (substring (JOURNAL_DESC_MAGIC, desc.j_magic) > 0 ! 486: || desc.j_trans_id != next_trans_id ! 487: || desc.j_mount_id != header.j_mount_id) ! 488: /* no more valid transactions */ ! 489: break; ! 490: ! 491: commit_block = (desc_block + desc.j_len + 1) & (block_count - 1); ! 492: journal_read (commit_block, sizeof (commit), (char *) &commit); ! 493: if (desc.j_trans_id != commit.j_trans_id ! 494: || desc.j_len != commit.j_len) ! 495: /* no more valid transactions */ ! 496: break; ! 497: ! 498: #ifdef REISERDEBUG ! 499: printf ("Found valid transaction %d/%d at %d.\n", ! 500: desc.j_trans_id, desc.j_mount_id, desc_block); ! 501: #endif ! 502: ! 503: next_trans_id++; ! 504: if (journal_table < JOURNAL_END) ! 505: { ! 506: if ((journal_table + 1 + desc.j_len) >= JOURNAL_END) ! 507: { ! 508: /* The table is almost full; mark the end of the cached ! 509: * journal.*/ ! 510: *journal_table = 0xffffffff; ! 511: journal_table = JOURNAL_END; ! 512: } ! 513: else ! 514: { ! 515: int i; ! 516: /* Cache the length and the realblock numbers in the table. ! 517: * The block number of descriptor can easily be computed. ! 518: * and need not to be stored here. ! 519: */ ! 520: *journal_table++ = desc.j_len; ! 521: for (i = 0; i < desc.j_len && i < JOURNAL_TRANS_HALF; i++) ! 522: { ! 523: *journal_table++ = desc.j_realblock[i]; ! 524: #ifdef REISERDEBUG ! 525: printf ("block %d is in journal %d.\n", ! 526: desc.j_realblock[i], desc_block); ! 527: #endif ! 528: } ! 529: for ( ; i < desc.j_len; i++) ! 530: { ! 531: *journal_table++ = commit.j_realblock[i-JOURNAL_TRANS_HALF]; ! 532: #ifdef REISERDEBUG ! 533: printf ("block %d is in journal %d.\n", ! 534: commit.j_realblock[i-JOURNAL_TRANS_HALF], ! 535: desc_block); ! 536: #endif ! 537: } ! 538: } ! 539: } ! 540: desc_block = (commit_block + 1) & (block_count - 1); ! 541: } ! 542: #ifdef REISERDEBUG ! 543: printf ("Transaction %d/%d at %d isn't valid.\n", ! 544: desc.j_trans_id, desc.j_mount_id, desc_block); ! 545: #endif ! 546: ! 547: INFO->journal_transactions ! 548: = next_trans_id - header.j_last_flush_trans_id - 1; ! 549: return errnum == 0; ! 550: } ! 551: ! 552: /* check filesystem types and read superblock into memory buffer */ ! 553: int ! 554: reiserfs_mount (void) ! 555: { ! 556: struct reiserfs_super_block super; ! 557: int superblock = REISERFS_DISK_OFFSET_IN_BYTES >> SECTOR_BITS; ! 558: ! 559: if (part_length < superblock + (sizeof (super) >> SECTOR_BITS) ! 560: || ! devread (superblock, 0, sizeof (struct reiserfs_super_block), ! 561: (char *) &super) ! 562: || (substring (REISER2FS_SUPER_MAGIC_STRING, super.s_magic) > 0 ! 563: && substring (REISERFS_SUPER_MAGIC_STRING, super.s_magic) > 0) ! 564: || (/* check that this is not a copy inside the journal log */ ! 565: super.s_journal_block * super.s_blocksize ! 566: <= REISERFS_DISK_OFFSET_IN_BYTES)) ! 567: { ! 568: /* Try old super block position */ ! 569: superblock = REISERFS_OLD_DISK_OFFSET_IN_BYTES >> SECTOR_BITS; ! 570: if (part_length < superblock + (sizeof (super) >> SECTOR_BITS) ! 571: || ! devread (superblock, 0, sizeof (struct reiserfs_super_block), ! 572: (char *) &super)) ! 573: return 0; ! 574: ! 575: if (substring (REISER2FS_SUPER_MAGIC_STRING, super.s_magic) > 0 ! 576: && substring (REISERFS_SUPER_MAGIC_STRING, super.s_magic) > 0) ! 577: { ! 578: /* pre journaling super block ? */ ! 579: if (substring (REISERFS_SUPER_MAGIC_STRING, ! 580: (char*) ((char *) &super + 20)) > 0) ! 581: return 0; ! 582: ! 583: super.s_blocksize = REISERFS_OLD_BLOCKSIZE; ! 584: super.s_journal_block = 0; ! 585: super.s_version = 0; ! 586: } ! 587: } ! 588: ! 589: /* check the version number. */ ! 590: if (super.s_version > REISERFS_MAX_SUPPORTED_VERSION) ! 591: return 0; ! 592: ! 593: INFO->version = super.s_version; ! 594: INFO->blocksize = super.s_blocksize; ! 595: INFO->fullblocksize_shift = log2 (super.s_blocksize); ! 596: INFO->blocksize_shift = INFO->fullblocksize_shift - SECTOR_BITS; ! 597: INFO->cached_slots = ! 598: (FSYSREISER_CACHE_SIZE >> INFO->fullblocksize_shift) - 1; ! 599: ! 600: #ifdef REISERDEBUG ! 601: printf ("reiserfs_mount: version=%d, blocksize=%d\n", ! 602: INFO->version, INFO->blocksize); ! 603: #endif /* REISERDEBUG */ ! 604: ! 605: /* Clear node cache. */ ! 606: memset (INFO->blocks, 0, sizeof (INFO->blocks)); ! 607: ! 608: if (super.s_blocksize < FSYSREISER_MIN_BLOCKSIZE ! 609: || super.s_blocksize > FSYSREISER_MAX_BLOCKSIZE ! 610: || (SECTOR_SIZE << INFO->blocksize_shift) != super.s_blocksize) ! 611: return 0; ! 612: ! 613: /* Initialize journal code. If something fails we end with zero ! 614: * journal_transactions, so we don't access the journal at all. ! 615: */ ! 616: INFO->journal_transactions = 0; ! 617: if (super.s_journal_block != 0 && super.s_journal_dev == 0) ! 618: { ! 619: INFO->journal_block = super.s_journal_block; ! 620: INFO->journal_block_count = super.s_journal_size; ! 621: if (is_power_of_two (INFO->journal_block_count)) ! 622: journal_init (); ! 623: ! 624: /* Read in super block again, maybe it is in the journal */ ! 625: block_read (superblock >> INFO->blocksize_shift, ! 626: 0, sizeof (struct reiserfs_super_block), (char *) &super); ! 627: } ! 628: ! 629: if (! block_read (super.s_root_block, 0, INFO->blocksize, (char*) ROOT)) ! 630: return 0; ! 631: ! 632: INFO->tree_depth = BLOCKHEAD (ROOT)->blk_level; ! 633: ! 634: #ifdef REISERDEBUG ! 635: printf ("root read_in: block=%d, depth=%d\n", ! 636: super.s_root_block, INFO->tree_depth); ! 637: #endif /* REISERDEBUG */ ! 638: ! 639: if (INFO->tree_depth >= MAX_HEIGHT) ! 640: return 0; ! 641: if (INFO->tree_depth == DISK_LEAF_NODE_LEVEL) ! 642: { ! 643: /* There is only one node in the whole filesystem, ! 644: * which is simultanously leaf and root */ ! 645: memcpy (LEAF, ROOT, INFO->blocksize); ! 646: } ! 647: return 1; ! 648: } ! 649: ! 650: /***************** TREE ACCESSING METHODS *****************************/ ! 651: ! 652: /* I assume you are familiar with the ReiserFS tree, if not go to ! 653: * http://www.namesys.com/content_table.html ! 654: * ! 655: * My tree node cache is organized as following ! 656: * 0 ROOT node ! 657: * 1 LEAF node (if the ROOT is also a LEAF it is copied here ! 658: * 2-n other nodes on current path from bottom to top. ! 659: * if there is not enough space in the cache, the top most are ! 660: * omitted. ! 661: * ! 662: * I have only two methods to find a key in the tree: ! 663: * search_stat(dir_id, objectid) searches for the stat entry (always ! 664: * the first entry) of an object. ! 665: * next_key() gets the next key in tree order. ! 666: * ! 667: * This means, that I can only sequential reads of files are ! 668: * efficient, but this really doesn't hurt for grub. ! 669: */ ! 670: ! 671: /* Read in the node at the current path and depth into the node cache. ! 672: * You must set INFO->blocks[depth] before. ! 673: */ ! 674: static char * ! 675: read_tree_node (unsigned int blockNr, int depth) ! 676: { ! 677: char* cache = CACHE(depth); ! 678: int num_cached = INFO->cached_slots; ! 679: if (depth < num_cached) ! 680: { ! 681: /* This is the cached part of the path. Check if same block is ! 682: * needed. ! 683: */ ! 684: if (blockNr == INFO->blocks[depth]) ! 685: return cache; ! 686: } ! 687: else ! 688: cache = CACHE(num_cached); ! 689: ! 690: #ifdef REISERDEBUG ! 691: printf (" next read_in: block=%d (depth=%d)\n", ! 692: blockNr, depth); ! 693: #endif /* REISERDEBUG */ ! 694: if (! block_read (blockNr, 0, INFO->blocksize, cache)) ! 695: return NULL; ! 696: /* Make sure it has the right node level */ ! 697: if (BLOCKHEAD (cache)->blk_level != depth) ! 698: { ! 699: errnum = ERR_FSYS_CORRUPT; ! 700: return NULL; ! 701: } ! 702: ! 703: INFO->blocks[depth] = blockNr; ! 704: return cache; ! 705: } ! 706: ! 707: /* Get the next key, i.e. the key following the last retrieved key in ! 708: * tree order. INFO->current_ih and ! 709: * INFO->current_info are adapted accordingly. */ ! 710: static int ! 711: next_key (void) ! 712: { ! 713: int depth; ! 714: struct item_head *ih = INFO->current_ih + 1; ! 715: char *cache; ! 716: ! 717: #ifdef REISERDEBUG ! 718: printf ("next_key:\n old ih: key %d:%d:%d:%d version:%d\n", ! 719: INFO->current_ih->ih_key.k_dir_id, ! 720: INFO->current_ih->ih_key.k_objectid, ! 721: INFO->current_ih->ih_key.u.v1.k_offset, ! 722: INFO->current_ih->ih_key.u.v1.k_uniqueness, ! 723: INFO->current_ih->ih_version); ! 724: #endif /* REISERDEBUG */ ! 725: ! 726: if (ih == &ITEMHEAD[BLOCKHEAD (LEAF)->blk_nr_item]) ! 727: { ! 728: depth = DISK_LEAF_NODE_LEVEL; ! 729: /* The last item, was the last in the leaf node. ! 730: * Read in the next block ! 731: */ ! 732: do ! 733: { ! 734: if (depth == INFO->tree_depth) ! 735: { ! 736: /* There are no more keys at all. ! 737: * Return a dummy item with MAX_KEY */ ! 738: ih = (struct item_head *) &BLOCKHEAD (LEAF)->blk_right_delim_key; ! 739: goto found; ! 740: } ! 741: depth++; ! 742: #ifdef REISERDEBUG ! 743: printf (" depth=%d, i=%d\n", depth, INFO->next_key_nr[depth]); ! 744: #endif /* REISERDEBUG */ ! 745: } ! 746: while (INFO->next_key_nr[depth] == 0); ! 747: ! 748: if (depth == INFO->tree_depth) ! 749: cache = ROOT; ! 750: else if (depth <= INFO->cached_slots) ! 751: cache = CACHE (depth); ! 752: else ! 753: { ! 754: cache = read_tree_node (INFO->blocks[depth], depth); ! 755: if (! cache) ! 756: return 0; ! 757: } ! 758: ! 759: do ! 760: { ! 761: int nr_item = BLOCKHEAD (cache)->blk_nr_item; ! 762: int key_nr = INFO->next_key_nr[depth]++; ! 763: #ifdef REISERDEBUG ! 764: printf (" depth=%d, i=%d/%d\n", depth, key_nr, nr_item); ! 765: #endif /* REISERDEBUG */ ! 766: if (key_nr == nr_item) ! 767: /* This is the last item in this block, set the next_key_nr to 0 */ ! 768: INFO->next_key_nr[depth] = 0; ! 769: ! 770: cache = read_tree_node (DC (cache)[key_nr].dc_block_number, --depth); ! 771: if (! cache) ! 772: return 0; ! 773: } ! 774: while (depth > DISK_LEAF_NODE_LEVEL); ! 775: ! 776: ih = ITEMHEAD; ! 777: } ! 778: found: ! 779: INFO->current_ih = ih; ! 780: INFO->current_item = &LEAF[ih->ih_item_location]; ! 781: #ifdef REISERDEBUG ! 782: printf (" new ih: key %d:%d:%d:%d version:%d\n", ! 783: INFO->current_ih->ih_key.k_dir_id, ! 784: INFO->current_ih->ih_key.k_objectid, ! 785: INFO->current_ih->ih_key.u.v1.k_offset, ! 786: INFO->current_ih->ih_key.u.v1.k_uniqueness, ! 787: INFO->current_ih->ih_version); ! 788: #endif /* REISERDEBUG */ ! 789: return 1; ! 790: } ! 791: ! 792: /* preconditions: reiserfs_mount already executed, therefore ! 793: * INFO block is valid ! 794: * returns: 0 if error (errnum is set), ! 795: * nonzero iff we were able to find the key successfully. ! 796: * postconditions: on a nonzero return, the current_ih and ! 797: * current_item fields describe the key that equals the ! 798: * searched key. INFO->next_key contains the next key after ! 799: * the searched key. ! 800: * side effects: messes around with the cache. ! 801: */ ! 802: static int ! 803: search_stat (__u32 dir_id, __u32 objectid) ! 804: { ! 805: char *cache; ! 806: int depth; ! 807: int nr_item; ! 808: int i; ! 809: struct item_head *ih; ! 810: #ifdef REISERDEBUG ! 811: printf ("search_stat:\n key %d:%d:0:0\n", dir_id, objectid); ! 812: #endif /* REISERDEBUG */ ! 813: ! 814: depth = INFO->tree_depth; ! 815: cache = ROOT; ! 816: ! 817: while (depth > DISK_LEAF_NODE_LEVEL) ! 818: { ! 819: struct key *key; ! 820: nr_item = BLOCKHEAD (cache)->blk_nr_item; ! 821: ! 822: key = KEY (cache); ! 823: ! 824: for (i = 0; i < nr_item; i++) ! 825: { ! 826: if (key->k_dir_id > dir_id ! 827: || (key->k_dir_id == dir_id ! 828: && (key->k_objectid > objectid ! 829: || (key->k_objectid == objectid ! 830: && (key->u.v1.k_offset ! 831: | key->u.v1.k_uniqueness) > 0)))) ! 832: break; ! 833: key++; ! 834: } ! 835: ! 836: #ifdef REISERDEBUG ! 837: printf (" depth=%d, i=%d/%d\n", depth, i, nr_item); ! 838: #endif /* REISERDEBUG */ ! 839: INFO->next_key_nr[depth] = (i == nr_item) ? 0 : i+1; ! 840: cache = read_tree_node (DC (cache)[i].dc_block_number, --depth); ! 841: if (! cache) ! 842: return 0; ! 843: } ! 844: ! 845: /* cache == LEAF */ ! 846: nr_item = BLOCKHEAD (LEAF)->blk_nr_item; ! 847: ih = ITEMHEAD; ! 848: for (i = 0; i < nr_item; i++) ! 849: { ! 850: if (ih->ih_key.k_dir_id == dir_id ! 851: && ih->ih_key.k_objectid == objectid ! 852: && ih->ih_key.u.v1.k_offset == 0 ! 853: && ih->ih_key.u.v1.k_uniqueness == 0) ! 854: { ! 855: #ifdef REISERDEBUG ! 856: printf (" depth=%d, i=%d/%d\n", depth, i, nr_item); ! 857: #endif /* REISERDEBUG */ ! 858: INFO->current_ih = ih; ! 859: INFO->current_item = &LEAF[ih->ih_item_location]; ! 860: return 1; ! 861: } ! 862: ih++; ! 863: } ! 864: errnum = ERR_FSYS_CORRUPT; ! 865: return 0; ! 866: } ! 867: ! 868: int ! 869: reiserfs_read (char *buf, int len) ! 870: { ! 871: unsigned int blocksize; ! 872: unsigned int offset; ! 873: unsigned int to_read; ! 874: char *prev_buf = buf; ! 875: ! 876: #ifdef REISERDEBUG ! 877: printf ("reiserfs_read: filepos=%d len=%d, offset=%x:%x\n", ! 878: filepos, len, (__u64) IH_KEY_OFFSET (INFO->current_ih) - 1); ! 879: #endif /* REISERDEBUG */ ! 880: ! 881: if (INFO->current_ih->ih_key.k_objectid != INFO->fileinfo.k_objectid ! 882: || IH_KEY_OFFSET (INFO->current_ih) > filepos + 1) ! 883: { ! 884: search_stat (INFO->fileinfo.k_dir_id, INFO->fileinfo.k_objectid); ! 885: goto get_next_key; ! 886: } ! 887: ! 888: while (! errnum) ! 889: { ! 890: if (INFO->current_ih->ih_key.k_objectid != INFO->fileinfo.k_objectid) ! 891: break; ! 892: ! 893: offset = filepos - IH_KEY_OFFSET (INFO->current_ih) + 1; ! 894: blocksize = INFO->current_ih->ih_item_len; ! 895: ! 896: #ifdef REISERDEBUG ! 897: printf (" loop: filepos=%d len=%d, offset=%d blocksize=%d\n", ! 898: filepos, len, offset, blocksize); ! 899: #endif /* REISERDEBUG */ ! 900: ! 901: if (IH_KEY_ISTYPE(INFO->current_ih, TYPE_DIRECT) ! 902: && offset < blocksize) ! 903: { ! 904: #ifdef REISERDEBUG ! 905: printf ("direct_read: offset=%d, blocksize=%d\n", ! 906: offset, blocksize); ! 907: #endif /* REISERDEBUG */ ! 908: to_read = blocksize - offset; ! 909: if (to_read > len) ! 910: to_read = len; ! 911: ! 912: if (disk_read_hook != NULL) ! 913: { ! 914: disk_read_func = disk_read_hook; ! 915: ! 916: block_read (INFO->blocks[DISK_LEAF_NODE_LEVEL], ! 917: (INFO->current_item - LEAF + offset), to_read, buf); ! 918: ! 919: disk_read_func = NULL; ! 920: } ! 921: else ! 922: memcpy (buf, INFO->current_item + offset, to_read); ! 923: goto update_buf_len; ! 924: } ! 925: else if (IH_KEY_ISTYPE(INFO->current_ih, TYPE_INDIRECT)) ! 926: { ! 927: blocksize = (blocksize >> 2) << INFO->fullblocksize_shift; ! 928: #ifdef REISERDEBUG ! 929: printf ("indirect_read: offset=%d, blocksize=%d\n", ! 930: offset, blocksize); ! 931: #endif /* REISERDEBUG */ ! 932: ! 933: while (offset < blocksize) ! 934: { ! 935: __u32 blocknr = ((__u32 *) INFO->current_item) ! 936: [offset >> INFO->fullblocksize_shift]; ! 937: int blk_offset = offset & (INFO->blocksize-1); ! 938: ! 939: to_read = INFO->blocksize - blk_offset; ! 940: if (to_read > len) ! 941: to_read = len; ! 942: ! 943: disk_read_func = disk_read_hook; ! 944: ! 945: /* Journal is only for meta data. Data blocks can be read ! 946: * directly without using block_read ! 947: */ ! 948: devread (blocknr << INFO->blocksize_shift, ! 949: blk_offset, to_read, buf); ! 950: ! 951: disk_read_func = NULL; ! 952: update_buf_len: ! 953: len -= to_read; ! 954: buf += to_read; ! 955: offset += to_read; ! 956: filepos += to_read; ! 957: if (len == 0) ! 958: goto done; ! 959: } ! 960: } ! 961: get_next_key: ! 962: next_key (); ! 963: } ! 964: done: ! 965: return errnum ? 0 : buf - prev_buf; ! 966: } ! 967: ! 968: ! 969: /* preconditions: reiserfs_mount already executed, therefore ! 970: * INFO block is valid ! 971: * returns: 0 if error, nonzero iff we were able to find the file successfully ! 972: * postconditions: on a nonzero return, INFO->fileinfo contains the info ! 973: * of the file we were trying to look up, filepos is 0 and filemax is ! 974: * the size of the file. ! 975: */ ! 976: int ! 977: reiserfs_dir (char *dirname) ! 978: { ! 979: struct reiserfs_de_head *de_head; ! 980: char *rest, ch; ! 981: __u32 dir_id, objectid, parent_dir_id = 0, parent_objectid = 0; ! 982: #ifndef STAGE1_5 ! 983: int do_possibilities = 0; ! 984: #endif /* ! STAGE1_5 */ ! 985: char linkbuf[PATH_MAX]; /* buffer for following symbolic links */ ! 986: int link_count = 0; ! 987: int mode; ! 988: ! 989: dir_id = REISERFS_ROOT_PARENT_OBJECTID; ! 990: objectid = REISERFS_ROOT_OBJECTID; ! 991: ! 992: while (1) ! 993: { ! 994: #ifdef REISERDEBUG ! 995: printf ("dirname=%s\n", dirname); ! 996: #endif /* REISERDEBUG */ ! 997: ! 998: /* Search for the stat info first. */ ! 999: if (! search_stat (dir_id, objectid)) ! 1000: return 0; ! 1001: ! 1002: #ifdef REISERDEBUG ! 1003: printf ("sd_mode=%x sd_size=%d\n", ! 1004: ((struct stat_data *) INFO->current_item)->sd_mode, ! 1005: ((struct stat_data *) INFO->current_item)->sd_size); ! 1006: #endif /* REISERDEBUG */ ! 1007: ! 1008: mode = ((struct stat_data *) INFO->current_item)->sd_mode; ! 1009: ! 1010: /* If we've got a symbolic link, then chase it. */ ! 1011: if (S_ISLNK (mode)) ! 1012: { ! 1013: int len; ! 1014: if (++link_count > MAX_LINK_COUNT) ! 1015: { ! 1016: errnum = ERR_SYMLINK_LOOP; ! 1017: return 0; ! 1018: } ! 1019: ! 1020: /* Get the symlink size. */ ! 1021: filemax = ((struct stat_data *) INFO->current_item)->sd_size; ! 1022: ! 1023: /* Find out how long our remaining name is. */ ! 1024: len = 0; ! 1025: while (dirname[len] && !isspace (dirname[len])) ! 1026: len++; ! 1027: ! 1028: if (filemax + len > sizeof (linkbuf) - 1) ! 1029: { ! 1030: errnum = ERR_FILELENGTH; ! 1031: return 0; ! 1032: } ! 1033: ! 1034: /* Copy the remaining name to the end of the symlink data. ! 1035: Note that DIRNAME and LINKBUF may overlap! */ ! 1036: grub_memmove (linkbuf + filemax, dirname, len+1); ! 1037: ! 1038: INFO->fileinfo.k_dir_id = dir_id; ! 1039: INFO->fileinfo.k_objectid = objectid; ! 1040: filepos = 0; ! 1041: if (! next_key () ! 1042: || reiserfs_read (linkbuf, filemax) != filemax) ! 1043: { ! 1044: if (! errnum) ! 1045: errnum = ERR_FSYS_CORRUPT; ! 1046: return 0; ! 1047: } ! 1048: ! 1049: #ifdef REISERDEBUG ! 1050: printf ("symlink=%s\n", linkbuf); ! 1051: #endif /* REISERDEBUG */ ! 1052: ! 1053: dirname = linkbuf; ! 1054: if (*dirname == '/') ! 1055: { ! 1056: /* It's an absolute link, so look it up in root. */ ! 1057: dir_id = REISERFS_ROOT_PARENT_OBJECTID; ! 1058: objectid = REISERFS_ROOT_OBJECTID; ! 1059: } ! 1060: else ! 1061: { ! 1062: /* Relative, so look it up in our parent directory. */ ! 1063: dir_id = parent_dir_id; ! 1064: objectid = parent_objectid; ! 1065: } ! 1066: ! 1067: /* Now lookup the new name. */ ! 1068: continue; ! 1069: } ! 1070: ! 1071: /* if we have a real file (and we're not just printing possibilities), ! 1072: then this is where we want to exit */ ! 1073: ! 1074: if (! *dirname || isspace (*dirname)) ! 1075: { ! 1076: if (! S_ISREG (mode)) ! 1077: { ! 1078: errnum = ERR_BAD_FILETYPE; ! 1079: return 0; ! 1080: } ! 1081: ! 1082: filepos = 0; ! 1083: filemax = ((struct stat_data *) INFO->current_item)->sd_size; ! 1084: ! 1085: /* If this is a new stat data and size is > 4GB set filemax to ! 1086: * maximum ! 1087: */ ! 1088: if (INFO->current_ih->ih_version == ITEM_VERSION_2 ! 1089: && ((struct stat_data *) INFO->current_item)->sd_size_hi > 0) ! 1090: filemax = 0xffffffff; ! 1091: ! 1092: INFO->fileinfo.k_dir_id = dir_id; ! 1093: INFO->fileinfo.k_objectid = objectid; ! 1094: return next_key (); ! 1095: } ! 1096: ! 1097: /* continue with the file/directory name interpretation */ ! 1098: while (*dirname == '/') ! 1099: dirname++; ! 1100: if (! S_ISDIR (mode)) ! 1101: { ! 1102: errnum = ERR_BAD_FILETYPE; ! 1103: return 0; ! 1104: } ! 1105: for (rest = dirname; (ch = *rest) && ! isspace (ch) && ch != '/'; rest++); ! 1106: *rest = 0; ! 1107: ! 1108: # ifndef STAGE1_5 ! 1109: if (print_possibilities && ch != '/') ! 1110: do_possibilities = 1; ! 1111: # endif /* ! STAGE1_5 */ ! 1112: ! 1113: while (1) ! 1114: { ! 1115: char *name_end; ! 1116: int num_entries; ! 1117: ! 1118: if (! next_key ()) ! 1119: return 0; ! 1120: #ifdef REISERDEBUG ! 1121: printf ("ih: key %d:%d:%d:%d version:%d\n", ! 1122: INFO->current_ih->ih_key.k_dir_id, ! 1123: INFO->current_ih->ih_key.k_objectid, ! 1124: INFO->current_ih->ih_key.u.v1.k_offset, ! 1125: INFO->current_ih->ih_key.u.v1.k_uniqueness, ! 1126: INFO->current_ih->ih_version); ! 1127: #endif /* REISERDEBUG */ ! 1128: ! 1129: if (INFO->current_ih->ih_key.k_objectid != objectid) ! 1130: break; ! 1131: ! 1132: name_end = INFO->current_item + INFO->current_ih->ih_item_len; ! 1133: de_head = (struct reiserfs_de_head *) INFO->current_item; ! 1134: num_entries = INFO->current_ih->u.ih_entry_count; ! 1135: while (num_entries > 0) ! 1136: { ! 1137: char *filename = INFO->current_item + de_head->deh_location; ! 1138: char tmp = *name_end; ! 1139: if ((de_head->deh_state & DEH_Visible)) ! 1140: { ! 1141: int cmp; ! 1142: /* Directory names in ReiserFS are not null ! 1143: * terminated. We write a temporary 0 behind it. ! 1144: * NOTE: that this may overwrite the first block in ! 1145: * the tree cache. That doesn't hurt as long as we ! 1146: * don't call next_key () in between. ! 1147: */ ! 1148: *name_end = 0; ! 1149: cmp = substring (dirname, filename); ! 1150: *name_end = tmp; ! 1151: # ifndef STAGE1_5 ! 1152: if (do_possibilities) ! 1153: { ! 1154: if (cmp <= 0) ! 1155: { ! 1156: if (print_possibilities > 0) ! 1157: print_possibilities = -print_possibilities; ! 1158: *name_end = 0; ! 1159: print_a_completion (filename); ! 1160: *name_end = tmp; ! 1161: } ! 1162: } ! 1163: else ! 1164: # endif /* ! STAGE1_5 */ ! 1165: if (cmp == 0) ! 1166: goto found; ! 1167: } ! 1168: /* The beginning of this name marks the end of the next name. ! 1169: */ ! 1170: name_end = filename; ! 1171: de_head++; ! 1172: num_entries--; ! 1173: } ! 1174: } ! 1175: ! 1176: # ifndef STAGE1_5 ! 1177: if (print_possibilities < 0) ! 1178: return 1; ! 1179: # endif /* ! STAGE1_5 */ ! 1180: ! 1181: errnum = ERR_FILE_NOT_FOUND; ! 1182: *rest = ch; ! 1183: return 0; ! 1184: ! 1185: found: ! 1186: ! 1187: *rest = ch; ! 1188: dirname = rest; ! 1189: ! 1190: parent_dir_id = dir_id; ! 1191: parent_objectid = objectid; ! 1192: dir_id = de_head->deh_dir_id; ! 1193: objectid = de_head->deh_objectid; ! 1194: } ! 1195: } ! 1196: ! 1197: int ! 1198: reiserfs_embed (int *start_sector, int needed_sectors) ! 1199: { ! 1200: struct reiserfs_super_block super; ! 1201: int num_sectors; ! 1202: ! 1203: if (! devread (REISERFS_DISK_OFFSET_IN_BYTES >> SECTOR_BITS, 0, ! 1204: sizeof (struct reiserfs_super_block), (char *) &super)) ! 1205: return 0; ! 1206: ! 1207: *start_sector = 1; /* reserve first sector for stage1 */ ! 1208: if ((substring (REISERFS_SUPER_MAGIC_STRING, super.s_magic) <= 0 ! 1209: || substring (REISER2FS_SUPER_MAGIC_STRING, super.s_magic) <= 0) ! 1210: && (/* check that this is not a super block copy inside ! 1211: * the journal log */ ! 1212: super.s_journal_block * super.s_blocksize ! 1213: > REISERFS_DISK_OFFSET_IN_BYTES)) ! 1214: num_sectors = (REISERFS_DISK_OFFSET_IN_BYTES >> SECTOR_BITS) - 1; ! 1215: else ! 1216: num_sectors = (REISERFS_OLD_DISK_OFFSET_IN_BYTES >> SECTOR_BITS) - 1; ! 1217: ! 1218: return (needed_sectors <= num_sectors); ! 1219: } ! 1220: #endif /* FSYS_REISERFS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.