vaseboot/VasEBoot-core/fs/romfs.c

/*
 *  VAS_EBOOT  --  GRand Unified Bootloader
 *  Copyright (C) 2010  Free Software Foundation, Inc.
 *
 *  VAS_EBOOT is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  VAS_EBOOT is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with VAS_EBOOT.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <VasEBoot/file.h>
#include <VasEBoot/types.h>
#include <VasEBoot/dl.h>
#include <VasEBoot/mm.h>
#include <VasEBoot/disk.h>
#include <VasEBoot/fs.h>
#include <VasEBoot/fshelp.h>
#include <VasEBoot/lockdown.h>

VAS_EBOOT_MOD_LICENSE ("GPLv3+");

struct VasEBoot_romfs_superblock
{
  char magic[8];
#define VAS_EBOOT_ROMFS_MAGIC "-rom1fs-"
  VasEBoot_uint32_t total_size;
  VasEBoot_uint32_t chksum;
  char label[0];
};

struct VasEBoot_romfs_file_header
{
  VasEBoot_uint32_t next_file;
  VasEBoot_uint32_t spec;
  VasEBoot_uint32_t size;
  VasEBoot_uint32_t chksum;
  char name[0];
};

struct VasEBoot_romfs_data
{
  VasEBoot_disk_addr_t first_file;
  VasEBoot_disk_t disk;
};

struct VasEBoot_fshelp_node
{
  VasEBoot_disk_addr_t addr;
  struct VasEBoot_romfs_data *data;
  VasEBoot_disk_addr_t data_addr;
  /* Not filled for root.  */
  struct VasEBoot_romfs_file_header file;
};

#define VAS_EBOOT_ROMFS_ALIGN 16
#define VAS_EBOOT_ROMFS_TYPE_MASK 7
#define VAS_EBOOT_ROMFS_TYPE_HARDLINK 0
#define VAS_EBOOT_ROMFS_TYPE_DIRECTORY 1
#define VAS_EBOOT_ROMFS_TYPE_REGULAR 2
#define VAS_EBOOT_ROMFS_TYPE_SYMLINK 3

static VasEBoot_err_t
do_checksum (void *in, VasEBoot_size_t insize)
{
  VasEBoot_uint32_t *a = in;
  VasEBoot_size_t sz = insize / 4;
  VasEBoot_uint32_t *b = a + sz;
  VasEBoot_uint32_t csum = 0;

  while (a < b)
    csum += VasEBoot_be_to_cpu32 (*a++);
  if (csum)
    return VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "invalid checksum");
  return VAS_EBOOT_ERR_NONE;
}

static struct VasEBoot_romfs_data *
VasEBoot_romfs_mount (VasEBoot_device_t dev)
{
  union {
    struct VasEBoot_romfs_superblock sb;
    char d[512];
  } sb;
  VasEBoot_err_t err;
  char *ptr;
  VasEBoot_disk_addr_t sec = 0;
  struct VasEBoot_romfs_data *data;
  if (!dev->disk)
    {
      VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "not a disk");
      return NULL;
    }
  err = VasEBoot_disk_read (dev->disk, 0, 0, sizeof (sb), &sb);
  if (err == VAS_EBOOT_ERR_OUT_OF_RANGE)
    err = VasEBoot_errno = VAS_EBOOT_ERR_BAD_FS;
  if (err)
    return NULL;
  if (VasEBoot_be_to_cpu32 (sb.sb.total_size) < sizeof (sb))
    {
      VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "too short filesystem");
      return NULL;
    }
  if (VasEBoot_memcmp (sb.sb.magic, VAS_EBOOT_ROMFS_MAGIC,
		   sizeof (sb.sb.magic)) != 0)
    {
      VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "not romfs");
      return NULL;
    }
  err = do_checksum (&sb, sizeof (sb) < VasEBoot_be_to_cpu32 (sb.sb.total_size) ?
		     sizeof (sb) : VasEBoot_be_to_cpu32 (sb.sb.total_size));
  if (err)
    {
      VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "checksum incorrect");
      return NULL;
    }
  for (ptr = sb.sb.label; (void *) ptr < (void *) (&sb + 1)
	 && ptr - sb.d < (VasEBoot_ssize_t) VasEBoot_be_to_cpu32 (sb.sb.total_size); ptr++)
    if (!*ptr)
      break;
  while ((void *) ptr == &sb + 1)
    {
      sec++;
      err = VasEBoot_disk_read (dev->disk, sec, 0, sizeof (sb), &sb);
      if (err == VAS_EBOOT_ERR_OUT_OF_RANGE)
	err = VasEBoot_errno = VAS_EBOOT_ERR_BAD_FS;
      if (err)
	return NULL;
      for (ptr = sb.d; (void *) ptr < (void *) (&sb + 1)
	     && (ptr - sb.d + (sec << VAS_EBOOT_DISK_SECTOR_BITS)
		 < VasEBoot_be_to_cpu32 (sb.sb.total_size));
	   ptr++)
	if (!*ptr)
	  break;
    }
  data = VasEBoot_malloc (sizeof (*data));
  if (!data)
    return NULL;
  data->first_file = ALIGN_UP (ptr + 1 - sb.d, VAS_EBOOT_ROMFS_ALIGN)
    + (sec << VAS_EBOOT_DISK_SECTOR_BITS);
  data->disk = dev->disk;
  return data;
}

static char *
VasEBoot_romfs_read_symlink (VasEBoot_fshelp_node_t node)
{
  char *ret;
  VasEBoot_err_t err;
  ret = VasEBoot_malloc (VasEBoot_be_to_cpu32 (node->file.size) + 1);
  if (!ret)
    return NULL;
  err = VasEBoot_disk_read (node->data->disk,
			(node->data_addr) >> VAS_EBOOT_DISK_SECTOR_BITS,
			(node->data_addr) & (VAS_EBOOT_DISK_SECTOR_SIZE - 1),
			VasEBoot_be_to_cpu32 (node->file.size), ret);
  if (err)
    {
      VasEBoot_free (ret);
      return NULL;
    }
  ret[VasEBoot_be_to_cpu32 (node->file.size)] = 0;
  return ret;
}

static int
VasEBoot_romfs_iterate_dir (VasEBoot_fshelp_node_t dir,
			VasEBoot_fshelp_iterate_dir_hook_t hook, void *hook_data)
{
  VasEBoot_disk_addr_t caddr;
  struct VasEBoot_romfs_file_header hdr;
  unsigned nptr;
  unsigned i, j;
  VasEBoot_size_t a = 0;
  VasEBoot_properly_aligned_t *name = NULL;

  for (caddr = dir->data_addr; caddr;
       caddr = VasEBoot_be_to_cpu32 (hdr.next_file) & ~(VAS_EBOOT_ROMFS_ALIGN - 1))
    {
      VasEBoot_disk_addr_t naddr = caddr + sizeof (hdr);
      VasEBoot_uint32_t csum = 0;
      enum VasEBoot_fshelp_filetype filetype = VAS_EBOOT_FSHELP_UNKNOWN;
      struct VasEBoot_fshelp_node *node = NULL;
      VasEBoot_err_t err;

      err = VasEBoot_disk_read (dir->data->disk, caddr >> VAS_EBOOT_DISK_SECTOR_BITS,
			    caddr & (VAS_EBOOT_DISK_SECTOR_SIZE - 1),
			    sizeof (hdr), &hdr);
      if (err)
	{
	  VasEBoot_free (name);
	  return 1;
	}
      for (nptr = 0; ; nptr++, naddr += 16)
	{
	  if (a <= nptr)
	    {
	      VasEBoot_properly_aligned_t *on;
	      a = 2 * (nptr + 1);
	      on = name;
	      name = VasEBoot_realloc (name, a * 16);
	      if (!name)
		{
		  VasEBoot_free (on);
		  return 1;
		}
	    }
	  COMPILE_TIME_ASSERT (16 % sizeof (name[0]) == 0);
	  err = VasEBoot_disk_read (dir->data->disk, naddr >> VAS_EBOOT_DISK_SECTOR_BITS,
				naddr & (VAS_EBOOT_DISK_SECTOR_SIZE - 1),
				16, name + (16 / sizeof (name[0])) * nptr);
	  if (err)
	    return 1;
	  for (j = 0; j < 16; j++)
	    if (!((char *) name)[16 * nptr + j])
	      break;
	  if (j != 16)
	    break;
	}
      for (i = 0; i < sizeof (hdr) / sizeof (VasEBoot_uint32_t); i++)
	csum += VasEBoot_be_to_cpu32 (((VasEBoot_uint32_t *) &hdr)[i]);
      for (i = 0; i < (nptr + 1) * 4; i++)
	csum += VasEBoot_be_to_cpu32 (((VasEBoot_uint32_t *) name)[i]);
      if (csum != 0)
	{
	  VasEBoot_error (VAS_EBOOT_ERR_BAD_FS, "invalid checksum");
	  VasEBoot_free (name);
	  return 1;
	}
      node = VasEBoot_malloc (sizeof (*node));
      if (!node)
	return 1;
      node->addr = caddr;
      node->data_addr = caddr + (nptr + 1) * 16 + sizeof (hdr);
      node->data = dir->data;
      node->file = hdr;
      switch (VasEBoot_be_to_cpu32 (hdr.next_file) & VAS_EBOOT_ROMFS_TYPE_MASK)
	{
	case VAS_EBOOT_ROMFS_TYPE_REGULAR:
	  filetype = VAS_EBOOT_FSHELP_REG;
	  break;
	case VAS_EBOOT_ROMFS_TYPE_SYMLINK:
	  filetype = VAS_EBOOT_FSHELP_SYMLINK;
	  break;
	case VAS_EBOOT_ROMFS_TYPE_DIRECTORY:
	  node->data_addr = VasEBoot_be_to_cpu32 (hdr.spec);
	  filetype = VAS_EBOOT_FSHELP_DIR;
	  break;
	case VAS_EBOOT_ROMFS_TYPE_HARDLINK:
	  {
	    VasEBoot_disk_addr_t laddr;
	    node->addr = laddr = VasEBoot_be_to_cpu32 (hdr.spec);
	    err = VasEBoot_disk_read (dir->data->disk,
				  laddr >> VAS_EBOOT_DISK_SECTOR_BITS,
				  laddr & (VAS_EBOOT_DISK_SECTOR_SIZE - 1),
				  sizeof (node->file), &node->file);
	    if (err)
	      return 1;
	    if ((VasEBoot_be_to_cpu32 (node->file.next_file) & VAS_EBOOT_ROMFS_TYPE_MASK)
		== VAS_EBOOT_ROMFS_TYPE_REGULAR
		|| (VasEBoot_be_to_cpu32 (node->file.next_file)
		    & VAS_EBOOT_ROMFS_TYPE_MASK) == VAS_EBOOT_ROMFS_TYPE_SYMLINK)
	      {
		laddr += sizeof (hdr);
		while (1)
		  {
		    char buf[16];
		    err = VasEBoot_disk_read (dir->data->disk,
					  laddr >> VAS_EBOOT_DISK_SECTOR_BITS,
					  laddr & (VAS_EBOOT_DISK_SECTOR_SIZE - 1),
					  16, buf);
		    if (err)
		      return 1;
		    for (i = 0; i < 16; i++)
		      if (!buf[i])
			break;
		    if (i != 16)
		      break;
		    laddr += 16;
		  }
		node->data_addr = laddr + 16;
	      }
	    if ((VasEBoot_be_to_cpu32 (node->file.next_file)
		 & VAS_EBOOT_ROMFS_TYPE_MASK) == VAS_EBOOT_ROMFS_TYPE_REGULAR)
	      filetype = VAS_EBOOT_FSHELP_REG;
	    if ((VasEBoot_be_to_cpu32 (node->file.next_file)
		 & VAS_EBOOT_ROMFS_TYPE_MASK) == VAS_EBOOT_ROMFS_TYPE_SYMLINK)
	      filetype = VAS_EBOOT_FSHELP_SYMLINK;
	    if ((VasEBoot_be_to_cpu32 (node->file.next_file) & VAS_EBOOT_ROMFS_TYPE_MASK)
		== VAS_EBOOT_ROMFS_TYPE_DIRECTORY)
	      {
		node->data_addr = VasEBoot_be_to_cpu32 (node->file.spec);
		filetype = VAS_EBOOT_FSHELP_DIR;
	      }

	    break;
	  }
	}

      if (hook ((char *) name, filetype, node, hook_data))
	{
	  VasEBoot_free (name);
	  return 1;
	}
    }
  VasEBoot_free (name);
  return 0;
}

/* Context for VasEBoot_romfs_dir.  */
struct VasEBoot_romfs_dir_ctx
{
  VasEBoot_fs_dir_hook_t hook;
  void *hook_data;
};

/* Helper for VasEBoot_romfs_dir.  */
static int
VasEBoot_romfs_dir_iter (const char *filename, enum VasEBoot_fshelp_filetype filetype,
		     VasEBoot_fshelp_node_t node, void *data)
{
  struct VasEBoot_romfs_dir_ctx *ctx = data;
  struct VasEBoot_dirhook_info info;

  VasEBoot_memset (&info, 0, sizeof (info));

  info.dir = ((filetype & VAS_EBOOT_FSHELP_TYPE_MASK) == VAS_EBOOT_FSHELP_DIR);
  VasEBoot_free (node);
  return ctx->hook (filename, &info, ctx->hook_data);
}

static VasEBoot_err_t
VasEBoot_romfs_dir (VasEBoot_device_t device, const char *path,
		VasEBoot_fs_dir_hook_t hook, void *hook_data)
{
  struct VasEBoot_romfs_dir_ctx ctx = { hook, hook_data };
  struct VasEBoot_romfs_data *data = 0;
  struct VasEBoot_fshelp_node *fdiro = 0, start;

  data = VasEBoot_romfs_mount (device);
  if (! data)
    goto fail;

  start.addr = data->first_file;
  start.data_addr = data->first_file;
  start.data = data;
  VasEBoot_fshelp_find_file (path, &start, &fdiro, VasEBoot_romfs_iterate_dir,
			 VasEBoot_romfs_read_symlink, VAS_EBOOT_FSHELP_DIR);
  if (VasEBoot_errno)
    goto fail;

  VasEBoot_romfs_iterate_dir (fdiro, VasEBoot_romfs_dir_iter, &ctx);

 fail:
  VasEBoot_free (data);

  return VasEBoot_errno;
}

static VasEBoot_err_t
VasEBoot_romfs_open (struct VasEBoot_file *file, const char *name)
{
  struct VasEBoot_romfs_data *data = 0;
  struct VasEBoot_fshelp_node *fdiro = 0, start;

  data = VasEBoot_romfs_mount (file->device);
  if (! data)
    goto fail;

  start.addr = data->first_file;
  start.data_addr = data->first_file;
  start.data = data;

  VasEBoot_fshelp_find_file (name, &start, &fdiro, VasEBoot_romfs_iterate_dir,
			 VasEBoot_romfs_read_symlink, VAS_EBOOT_FSHELP_REG);
  if (VasEBoot_errno)
    goto fail;

  file->size = VasEBoot_be_to_cpu32 (fdiro->file.size);
  file->data = fdiro;
  return VAS_EBOOT_ERR_NONE;

 fail:
  VasEBoot_free (data);

  return VasEBoot_errno;
}

static VasEBoot_ssize_t
VasEBoot_romfs_read (VasEBoot_file_t file, char *buf, VasEBoot_size_t len)
{
  struct VasEBoot_fshelp_node *data = file->data;

  /* XXX: The file is stored in as a single extent.  */
  data->data->disk->read_hook = file->read_hook;
  data->data->disk->read_hook_data = file->read_hook_data;
  VasEBoot_disk_read (data->data->disk,
		  (data->data_addr + file->offset) >> VAS_EBOOT_DISK_SECTOR_BITS,
		  (data->data_addr + file->offset) & (VAS_EBOOT_DISK_SECTOR_SIZE - 1),
		  len, buf);
  data->data->disk->read_hook = NULL;

  if (VasEBoot_errno)
    return -1;

  return len;
}

static VasEBoot_err_t
VasEBoot_romfs_close (VasEBoot_file_t file)
{
  struct VasEBoot_fshelp_node *data = file->data;

  VasEBoot_free (data->data);
  VasEBoot_free (data);

  return VAS_EBOOT_ERR_NONE;
}

static VasEBoot_err_t
VasEBoot_romfs_label (VasEBoot_device_t device, char **label)
{
  struct VasEBoot_romfs_data *data;
  VasEBoot_err_t err;

  *label = NULL;

  data = VasEBoot_romfs_mount (device);
  if (!data)
    return VasEBoot_errno;
  *label = VasEBoot_malloc (data->first_file + 1
			- sizeof (struct VasEBoot_romfs_superblock));
  if (!*label)
    {
      VasEBoot_free (data);
      return VasEBoot_errno;
    }
  err = VasEBoot_disk_read (device->disk, 0, sizeof (struct VasEBoot_romfs_superblock),
			data->first_file
			- sizeof (struct VasEBoot_romfs_superblock),
			*label);
  if (err)
    {
      VasEBoot_free (data);
      VasEBoot_free (*label);
      *label = NULL;
      return err;
    }
  (*label)[data->first_file - sizeof (struct VasEBoot_romfs_superblock)] = 0;
  VasEBoot_free (data);
  return VAS_EBOOT_ERR_NONE;
}


static struct VasEBoot_fs VasEBoot_romfs_fs =
  {
    .name = "romfs",
    .fs_dir = VasEBoot_romfs_dir,
    .fs_open = VasEBoot_romfs_open,
    .fs_read = VasEBoot_romfs_read,
    .fs_close = VasEBoot_romfs_close,
    .fs_label = VasEBoot_romfs_label,
#ifdef VAS_EBOOT_UTIL
    .reserved_first_sector = 0,
    .blocklist_install = 0,
#endif
    .next = 0
  };

VAS_EBOOT_MOD_INIT(romfs)
{
  if (!VasEBoot_is_lockdown ())
    {
      VasEBoot_romfs_fs.mod = mod;
      VasEBoot_fs_register (&VasEBoot_romfs_fs);
    }
}

VAS_EBOOT_MOD_FINI(romfs)
{
  if (!VasEBoot_is_lockdown ())
    VasEBoot_fs_unregister (&VasEBoot_romfs_fs);
}