Attachment #313069 for bug #360513

View | Details | Raw Unified | Return to bug 360513 | Differences between
Collapse All | Expand All




++ b/grub/asmstub.c


int
biosdisk (int subfunc, int drive, struct geometry *geometry,
	  unsigned sector, unsigned nsec, int segment)
{
  char *buf;
  int fd = geometry->flags;
++ b/stage2/bios.c

   return the error number. Otherwise, return 0.  */
int
biosdisk (int read, int drive, struct geometry *geometry,
	  unsigned sector, unsigned nsec, int segment)
{
  int err;
  
++ b/stage2/builtins.c


/* Print which sector is read when loading a file.  */
static void
disk_read_print_func (unsigned sector, unsigned offset, int length)
{
  grub_printf ("[%d,%d,%d]", sector, offset, length);
}

  int saved_lengths[2];

  /* Save sector information about at most two sectors.  */
  auto void disk_read_savesect_func (unsigned sector, unsigned offset, int length);
  void disk_read_savesect_func (unsigned sector, unsigned offset, int length)
    {
      if (sector_count < 2)
	{
++ b/stage2/disk_io.c

struct geometry buf_geom;

/* filesystem common variables */
unsigned filepos;
unsigned filemax;

static inline unsigned long
log2 (unsigned long word)

}

int
rawread (int drive, unsigned sector, unsigned byte_offset, unsigned byte_len, char *buf)
{
  int slen, sectors_per_vtrack;
  int sector_size_bits = log2 (buf_geom.sector_size);


  while (byte_len > 0 && !errnum)
    {
      unsigned soff, num_sect, track, size = byte_len;
      char *bufaddr;

      /*

	}

      /* Make sure that SECTOR is valid.  */
      if (sector >= buf_geom.total_sectors)
	{
	  errnum = ERR_GEOM;
	  return 0;


      if (track != buf_track)
	{
	  int bios_err;
	  unsigned read_start = track, read_len = sectors_per_vtrack;

	  /*
	   *  If there's more than one read in this entire loop, then



int
devread (unsigned sector, unsigned byte_offset, unsigned byte_len, char *buf)
{
  /*
   *  Check partition boundaries
   */
  if ( ((sector + ((byte_offset + byte_len - 1) >> SECTOR_BITS))
      || ((sector + ((byte_offset + byte_len - 1) >> SECTOR_BITS))
	  >= part_length))
    {
      errnum = ERR_OUTSIDE_PART;



int
grub_read (char *buf, unsigned len)
{
  /* Make sure "filepos" is a sane value */
  if (filepos > filemax)
    filepos = filemax;

  /* Make sure "len" is a sane value */
  if ((len > (filemax - filepos)))
    len = filemax - filepos;

  /* if target file position is past the end of

#ifndef STAGE1_5
/* Reposition a file offset.  */
int
grub_seek (unsigned offset)
{
  if (offset > filemax)
    return -1;

  filepos = offset;
++ b/stage2/filesys.h

#ifdef FSYS_EXT2FS
#define FSYS_EXT2FS_NUM 1
int ext2fs_mount (void);
int ext2fs_read (char *buf, unsigned len);
int ext2fs_dir (char *dirname);
#else
#define FSYS_EXT2FS_NUM 0

#ifdef FSYS_REISERFS
#define FSYS_REISERFS_NUM 1
int reiserfs_mount (void);
int reiserfs_read (char *buf, unsigned len);
int reiserfs_dir (char *dirname);
int reiserfs_embed (int *start_sector, int needed_sectors);
#else
++ b/stage2/fsys_ext2fs.c

#include "shared.h"
#include "filesys.h"

static unsigned mapblock1, mapblock2;

/* sizes are always in bytes, BLOCK values are always in DEV_BSIZE (sectors) */
#define DEV_BSIZE 512

#define INODE \
    ((struct ext2_inode *)((int)GROUP_DESC + EXT2_BLOCK_SIZE(SUPERBLOCK)))
#define DATABLOCK1 \
    ((unsigned int)((int)INODE + sizeof(struct ext2_inode)))
#define DATABLOCK2 \
    ((unsigned int)(DATABLOCK1 + EXT2_BLOCK_SIZE(SUPERBLOCK)))

/* linux/ext2_fs.h */
#define EXT2_ADDR_PER_BLOCK(s)          (EXT2_BLOCK_SIZE(s) / sizeof (__u32))

/* linux/ext2_fs.h */
#define EXT2_BLOCK_SIZE_BITS(s)        ((s)->s_log_block_size + 10)
/* kind of from ext2/super.c */
#define EXT2_BLOCK_SIZE(s)	(1UL << EXT2_BLOCK_SIZE_BITS(s))
/* linux/ext2fs.h */
/* sizeof(struct ext2_group_desc) is changed in ext4 
 * in kernel code, ext2/3 uses sizeof(struct ext2_group_desc) to calculate 


/* Takes a file system block number and reads it into BUFFER. */
static int
ext2_rdfsb (unsigned fsblock, int buffer)
{
#ifdef E2DEBUG
  printf ("fsblock %d buffer %d\n", fsblock, buffer);

*/
/* Maps LOGICAL_BLOCK (the file offset divided by the blocksize) into
   a physical block (the location in the file system) via an inode. */
static unsigned
ext2fs_block_map (unsigned logical_block)
{

#ifdef E2DEBUG

	  && !ext2_rdfsb (INODE->i_block[EXT2_IND_BLOCK], DATABLOCK1))
	{
	  errnum = ERR_FSYS_CORRUPT;
	  return (unsigned)-1;
	}
      mapblock1 = 1;
      return ((__u32 *) DATABLOCK1)[logical_block];

  /* else */
  logical_block -= EXT2_ADDR_PER_BLOCK (SUPERBLOCK);
  /* now try the double indirect block */
  if (logical_block < (1UL << (EXT2_ADDR_PER_BLOCK_BITS (SUPERBLOCK) * 2)))
    {
      unsigned bnum;
      if (mapblock1 != 2
	  && !ext2_rdfsb (INODE->i_block[EXT2_DIND_BLOCK], DATABLOCK1))
	{
	  errnum = ERR_FSYS_CORRUPT;
	  return (unsigned)-1;
	}
      mapblock1 = 2;
      if ((bnum = (((__u32 *) DATABLOCK1)

	  && !ext2_rdfsb (bnum, DATABLOCK2))
	{
	  errnum = ERR_FSYS_CORRUPT;
	  return (unsigned)-1;
	}
      mapblock2 = bnum;
      return ((__u32 *) DATABLOCK2)
	[logical_block & (EXT2_ADDR_PER_BLOCK (SUPERBLOCK) - 1)];
    }
  /* else */
  mapblock2 = (unsigned)-1;
  logical_block -= (1UL << (EXT2_ADDR_PER_BLOCK_BITS (SUPERBLOCK) * 2));
  if (mapblock1 != 3
      && !ext2_rdfsb (INODE->i_block[EXT2_TIND_BLOCK], DATABLOCK1))
    {
      errnum = ERR_FSYS_CORRUPT;
      return (unsigned)-1;
    }
  mapblock1 = 3;
  if (!ext2_rdfsb (((__u32 *) DATABLOCK1)

		   DATABLOCK2))
    {
      errnum = ERR_FSYS_CORRUPT;
      return (unsigned)-1;
    }
  if (!ext2_rdfsb (((__u32 *) DATABLOCK2)
		   [(logical_block >> EXT2_ADDR_PER_BLOCK_BITS (SUPERBLOCK))

		   DATABLOCK2))
    {
      errnum = ERR_FSYS_CORRUPT;
      return (unsigned)-1;
    }
  return ((__u32 *) DATABLOCK2)
    [logical_block & (EXT2_ADDR_PER_BLOCK (SUPERBLOCK) - 1)];


/* preconditions: all preconds of ext2fs_block_map */
int
ext2fs_read (char *buf, unsigned len)
{
  unsigned logical_block;
  unsigned offset;
  unsigned map;
  int ret = 0;
  unsigned size = 0;

#ifdef E2DEBUG
  static char hexdigit[] = "0123456789abcdef";

#ifdef E2DEBUG
      printf ("map=%d\n", map);
#endif /* E2DEBUG */
      if (map == (unsigned)-1)
	break;

      size = EXT2_BLOCK_SIZE (SUPERBLOCK);

static inline
int ext2_is_fast_symlink (void)
{
  unsigned long ea_blocks;
  ea_blocks = INODE->i_file_acl ? EXT2_BLOCK_SIZE (SUPERBLOCK) / DEV_BSIZE : 0;
  return INODE->i_blocks == ea_blocks;
}

int
ext2fs_dir (char *dirname)
{
  unsigned current_ino = EXT2_ROOT_INO;	/* start at the root */
  unsigned updir_ino = current_ino;	/* the parent of the current directory */
  unsigned group_id;			/* which group the inode is in */
  unsigned group_desc;		/* fs pointer to that group */
  unsigned desc;			/* index within that group */
  unsigned ino_blk;			/* fs pointer of the inode's information */
  int str_chk = 0;		/* used to hold the results of a string compare */
  struct ext4_group_desc *ext4_gdp;
  struct ext2_inode *raw_inode;	/* inode info corresponding to current_ino */

  char *rest;
  char ch;			/* temp char holder */

  unsigned off;			/* offset within block of directory entry (off mod blocksize) */
  unsigned loc;			/* location within a directory */
  unsigned blk;			/* which data blk within dir entry (off div blocksize) */
  unsigned map;			/* fs pointer of a particular block from dir entry */
  struct ext2_dir_entry *dp;	/* pointer to directory entry */
#ifdef E2DEBUG
  unsigned char *i;

	}

      /* reset indirect blocks! */
      mapblock2 = mapblock1 = (unsigned)-1;

      raw_inode = (struct ext2_inode *)((char *)INODE +
	((current_ino - 1) & (EXT2_INODES_PER_BLOCK (SUPERBLOCK) - 1)) *

      /* If we've got a symbolic link, then chase it. */
      if (S_ISLNK (INODE->i_mode))
	{
	  unsigned len;
	  if (++link_count > MAX_LINK_COUNT)
	    {
	      errnum = ERR_SYMLINK_LOOP;

#ifdef E2DEBUG
	  printf ("fs block=%d\n", map);
#endif /* E2DEBUG */
	  mapblock2 = (unsigned)-1;
	  if (map == (unsigned)-1) 
	  {
	      *rest = ch;
	      return 0;
++ b/stage2/fsys_reiserfs.c

}

static int 
journal_read (__u32 block, unsigned len, char *buffer) 
{
  return devread ((INFO->journal_block + block) << INFO->blocksize_shift, 
		  0, len, buffer);

 * journal taken.  
 */
static int
block_read (unsigned blockNr, unsigned start, unsigned len, char *buffer)
{
  int transactions = INFO->journal_transactions;
  unsigned desc_block = INFO->journal_first_desc;
  unsigned journal_mask = INFO->journal_block_count - 1;
  unsigned translatedNr = blockNr;
  __u32 *journal_table = JOURNAL_START;
  while (transactions-- > 0) 
    {
      unsigned i = 0;
      unsigned j_len;
      if (*journal_table != 0xffffffff)
	{
	  /* Search for the blockNr in cached journal */

	  
	  if (j_len >= JOURNAL_TRANS_HALF)
	    {
	      unsigned commit_block = (desc_block + 1 + j_len) & journal_mask;
	      if (! journal_read (commit_block, 
				  sizeof (commit), (char *) &commit))
		return 0;

	    }
	  else
	    {
	      unsigned i;
	      /* Cache the length and the realblock numbers in the table.
	       * The block number of descriptor can easily be computed.
	       * and need not to be stored here.

reiserfs_mount (void)
{
  struct reiserfs_super_block super;
  unsigned superblock = REISERFS_DISK_OFFSET_IN_BYTES >> SECTOR_BITS;

  if (part_length < superblock + (sizeof (super) >> SECTOR_BITS)
      || ! devread (superblock, 0, sizeof (struct reiserfs_super_block), 

      
      do
	{
	  unsigned nr_item = BLOCKHEAD (cache)->blk_nr_item;
	  unsigned key_nr = INFO->next_key_nr[depth]++;
#ifdef REISERDEBUG
	  printf ("  depth=%d, i=%d/%d\n", depth, key_nr, nr_item);
#endif /* REISERDEBUG */

{
  char *cache;
  int depth;
  unsigned nr_item;
  unsigned i;
  struct item_head *ih;
#ifdef REISERDEBUG
  printf ("search_stat:\n  key %d:%d:0:0\n", dir_id, objectid);

}

int
reiserfs_read (char *buf, unsigned len)
{
  unsigned int blocksize;
  unsigned int offset;

	      disk_read_func = disk_read_hook;
	      
	      block_read (INFO->blocks[DISK_LEAF_NODE_LEVEL],
			  (unsigned)(INFO->current_item - LEAF + offset), to_read, buf);
	      
	      disk_read_func = NULL;
	    }

	    {
	      __u32 blocknr = ((__u32 *) INFO->current_item)
		[offset >> INFO->fullblocksize_shift];
	      unsigned blk_offset = offset & (INFO->blocksize-1);
	      
	      to_read = INFO->blocksize - blk_offset;
	      if (to_read > len)

      /* If we've got a symbolic link, then chase it. */
      if (S_ISLNK (mode))
	{
	  unsigned len;
	  if (++link_count > MAX_LINK_COUNT)
	    {
	      errnum = ERR_SYMLINK_LOOP;
++ b/stage2/fsys_vstafs.c

 * In f_sector we store the sector number in which the information about
 * the found file is.
 */
extern unsigned filepos;
static int f_sector;

int 
++ b/stage2/shared.h

extern struct geometry buf_geom;

/* these are the current file position and maximum file position */
extern unsigned filepos;
extern unsigned filemax;

/*
 *  Common BIOS/boot data.

/* Low-level disk I/O */
int get_diskinfo (int drive, struct geometry *geometry);
int biosdisk (int subfunc, int drive, struct geometry *geometry,
	      unsigned sector, unsigned nsec, int segment);
void stop_floppy (void);

/* Command-line interface functions. */

int gunzip_read (char *buf, int len);
#endif /* NO_DECOMPRESSION */

int rawread (int drive, unsigned sector, unsigned byte_offset, unsigned byte_len, char *buf);
int devread (unsigned sector, unsigned byte_offset, unsigned byte_len, char *buf);
int rawwrite (int drive, int sector, char *buf);
int devwrite (int sector, int sector_len, char *buf);



/* Read LEN bytes into BUF from the file that was opened with
   GRUB_OPEN.  If LEN is -1, read all the remaining data in the file.  */
int grub_read (char *buf, unsigned len);

/* Reposition a file offset.  */
int grub_seek (unsigned offset);

/* Close a file.  */
void grub_close (void);

Return to bug 360513