grub-0.97/stage2/fsys_vstafs.c

	fsys_vstafs.c revision 1
1N/A/*
1N/A *  GRUB  --  GRand Unified Bootloader
1N/A *  Copyright (C) 2001   Free Software Foundation, Inc.
1N/A *
1N/A *  This program is free software; you can redistribute it and/or modify
1N/A *  it under the terms of the GNU General Public License as published by
1N/A *  the Free Software Foundation; either version 2 of the License, or
1N/A *  (at your option) any later version.
1N/A *
1N/A *  This program is distributed in the hope that it will be useful,
1N/A *  but WITHOUT ANY WARRANTY; without even the implied warranty of
1N/A *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1N/A *  GNU General Public License for more details.
1N/A *
1N/A *  You should have received a copy of the GNU General Public License
1N/A *  along with this program; if not, write to the Free Software
1N/A *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
1N/A */
1N/A
1N/A#ifdef FSYS_VSTAFS
1N/A
1N/A#include "shared.h"
1N/A#include "filesys.h"
1N/A#include "vstafs.h"
1N/A
1N/A
1N/Astatic void get_file_info (int sector);
1N/Astatic struct dir_entry *vstafs_readdir (long sector);
1N/Astatic struct dir_entry *vstafs_nextdir (void);
1N/A
1N/A
1N/A#define FIRST_SECTOR    ((struct first_sector *) FSYS_BUF)
1N/A#define FILE_INFO   ((struct fs_file *) (int) FIRST_SECTOR + 8192)
1N/A#define DIRECTORY_BUF   ((struct dir_entry *) (int) FILE_INFO + 512)
1N/A
1N/A#define ROOT_SECTOR 1
1N/A
1N/A/*
1N/A * In f_sector we store the sector number in which the information about
1N/A * the found file is.
1N/A */
1N/Aextern int filepos;
1N/Astatic int f_sector;
1N/A
1N/Aint
1N/Avstafs_mount (void)
1N/A{
1N/A  int retval = 1;
1N/A
1N/A  if( (((current_drive & 0x80) || (current_slice != 0))
1N/A       && current_slice != PC_SLICE_TYPE_VSTAFS)
1N/A      ||  ! devread (0, 0, BLOCK_SIZE, (char *) FSYS_BUF)
1N/A      ||  FIRST_SECTOR->fs_magic != 0xDEADFACE)
1N/A    retval = 0;

  return retval;
}

static void
get_file_info (int sector)
{
  devread (sector, 0, BLOCK_SIZE, (char *) FILE_INFO);
}

static int curr_ext, current_direntry, current_blockpos;
static struct alloc *a;

static struct dir_entry *
vstafs_readdir (long sector)
{
  /*
   * Get some information from the current directory
   */
  get_file_info (sector);
  if (FILE_INFO->type != 2)
    {
      errnum = ERR_FILE_NOT_FOUND;
      return 0;
    }

  a = FILE_INFO->blocks;
  curr_ext = 0;
  devread (a[curr_ext].a_start, 0, 512, (char *) DIRECTORY_BUF);
  current_direntry = 11;
  current_blockpos = 0;

  return &DIRECTORY_BUF[10];
}

static struct dir_entry *
vstafs_nextdir (void)
{
  if (current_direntry > 15)
    {
      current_direntry = 0;
      if (++current_blockpos > (a[curr_ext].a_len - 1))
    {
      current_blockpos = 0;
      curr_ext++;
    }

      if (curr_ext < FILE_INFO->extents)
    {
      devread (a[curr_ext].a_start + current_blockpos, 0,
           512, (char *) DIRECTORY_BUF);
    }
      else
    {
      /* errnum =ERR_FILE_NOT_FOUND; */
      return 0;
    }
    }

  return &DIRECTORY_BUF[current_direntry++];
}

int
vstafs_dir (char *dirname)
{
  char *fn, ch;
  struct dir_entry *d;
  /* int l, i, s; */

  /*
   * Read in the entries of the current directory.
   */
  f_sector = ROOT_SECTOR;
  do
    {
      if (! (d = vstafs_readdir (f_sector)))
    {
      return 0;
    }

      /*
       * Find the file in the path
       */
      while (*dirname == '/') dirname++;
      fn = dirname;
      while ((ch = *fn) && ch != '/' && ! isspace (ch)) fn++;
      *fn = 0;

      do
    {
      if (d->name[0] == 0 || d->name[0] & 0x80)
        continue;

#ifndef STAGE1_5
      if (print_possibilities && ch != '/'
          && (! *dirname || strcmp (dirname, d->name) <= 0))
        {
          if (print_possibilities > 0)
        print_possibilities = -print_possibilities;

          printf ("  %s", d->name);
        }
#endif
      if (! grub_strcmp (dirname, d->name))
        {
          f_sector = d->start;
          get_file_info (f_sector);
          filemax = FILE_INFO->len;
          break;
        }
    }
      while ((d =vstafs_nextdir ()));

      *(dirname = fn) = ch;
      if (! d)
    {
      if (print_possibilities < 0)
        {
          putchar ('\n');
          return 1;
        }

      errnum = ERR_FILE_NOT_FOUND;
      return 0;
    }
    }
  while (*dirname && ! isspace (ch));

  return 1;
}

int
vstafs_read (char *addr, int len)
{
  struct alloc *a;
  int size, ret = 0, offset, curr_len = 0;
  int curr_ext;
  char extent;
  int ext_size;
  char *curr_pos;

  get_file_info (f_sector);
  size = FILE_INFO->len-VSTAFS_START_DATA;
  a = FILE_INFO->blocks;

  if (filepos > 0)
    {
      if (filepos < a[0].a_len * 512 - VSTAFS_START_DATA)
    {
      offset = filepos + VSTAFS_START_DATA;
      extent = 0;
      curr_len = a[0].a_len * 512 - offset - filepos;
    }
      else
    {
      ext_size = a[0].a_len * 512 - VSTAFS_START_DATA;
      offset = filepos - ext_size;
      extent = 1;
      do
        {
          curr_len -= ext_size;
          offset -= ext_size;
          ext_size = a[extent+1].a_len * 512;
        }
      while (extent < FILE_INFO->extents && offset>ext_size);
    }
    }
  else
    {
      offset = VSTAFS_START_DATA;
      extent = 0;
      curr_len = a[0].a_len * 512 - offset;
    }

  curr_pos = addr;
  if (curr_len > len)
    curr_len = len;

  for (curr_ext=extent;
       curr_ext < FILE_INFO->extents;
       curr_len = a[curr_ext].a_len * 512, curr_pos += curr_len, curr_ext++)
    {
      ret += curr_len;
      size -= curr_len;
      if (size < 0)
    {
      ret += size;
      curr_len += size;
    }

      devread (a[curr_ext].a_start,offset, curr_len, curr_pos);
      offset = 0;
    }

  return ret;
}

#endif /* FSYS_VSTAFS */