roots.c

/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <errno.h>
#include <stdlib.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <ctype.h>

#include "mtdutils/mtdutils.h"
#include "mounts.h"
#include "roots.h"
#include "common.h"
#include "make_ext4fs.h"

#include "flashutils/flashutils.h"

int num_volumes;
Volume *device_volumes;

Volume* get_device_volumes()
{
  return device_volumes;
}

int get_num_volumes()
{
  return num_volumes;
}

static int
is_null (const char *sz)
{
  if (sz == NULL)
    return 1;
  if (strcmp ("NULL", sz) == 0)
    return 1;
  return 0;
}

static char *
dupe_string (const char *sz)
{
  if (is_null (sz))
    return NULL;
  return strdup (sz);
}

void
load_volume_table ()
{
  int load_silently = get_load_silently();

  int alloc = 2;

  device_volumes = malloc (alloc * sizeof (Volume));

  // Insert an entry for /tmp, which is the ramdisk and is always mounted.
  device_volumes[0].mount_point = "/tmp";
  device_volumes[0].fs_type = "ramdisk";
  device_volumes[0].device = NULL;
  device_volumes[0].device2 = NULL;
  device_volumes[0].fs_options = NULL;
  device_volumes[0].fs_options2 = NULL;
  num_volumes = 1;

  FILE *fstab = fopen ("/etc/recovery.fstab", "r");

  if (fstab == NULL)
	  {
	    LOGE ("failed to open /etc/recovery.fstab (%s)\n",
		  strerror (errno));
	    return;
	  }

  char buffer[1024];
  int i;

  while (fgets (buffer, sizeof (buffer) - 1, fstab))
	  {
	    for (i = 0; buffer[i] && isspace (buffer[i]); ++i);
	    if (buffer[i] == '\0' || buffer[i] == '#')
	      continue;

	    char *original = strdup (buffer);

	    char *mount_point = strtok (buffer + i, " \t\n");
	    char *fs_type = strtok (NULL, " \t\n");
	    char *device = strtok (NULL, " \t\n");

	    // lines may optionally have a second device, to use if
	    // mounting the first one fails.
	    char *device2 = strtok (NULL, " \t\n");
	    char *fs_type2 = strtok (NULL, " \t\n");
	    char *fs_options = strtok (NULL, " \t\n");
	    char *fs_options2 = strtok (NULL, " \t\n");

	    if (mount_point && fs_type && device)
		    {
		      while (num_volumes >= alloc)
			      {
				alloc *= 2;
				device_volumes =
				  realloc (device_volumes,
					   alloc * sizeof (Volume));
			      }
		      device_volumes[num_volumes].mount_point =
			strdup (mount_point);
		      device_volumes[num_volumes].fs_type =
			!is_null (fs_type2) ? strdup (fs_type2) :
			strdup (fs_type);
		      device_volumes[num_volumes].device = strdup (device);
		      device_volumes[num_volumes].device2 =
			!is_null (device2) ? strdup (device2) : NULL;
		      device_volumes[num_volumes].fs_type2 =
			!is_null (fs_type2) ? strdup (fs_type) : NULL;

		      if (!is_null (fs_type2))
			      {
				device_volumes[num_volumes].fs_options2 =
				  dupe_string (fs_options);
				device_volumes[num_volumes].fs_options =
				  dupe_string (fs_options2);
			      }
		      else
			      {
				device_volumes[num_volumes].fs_options2 =
				  NULL;
				device_volumes[num_volumes].fs_options =
				  dupe_string (fs_options);
			      }
		      ++num_volumes;
		    }
	    else
		    {
		      LOGE ("skipping malformed recovery.fstab line: %s\n",
			    original);
		    }
	    free (original);
	  }

  fclose (fstab);

  if (!load_silently)
  {
    printf ("recovery filesystem table\n");
    printf ("=========================\n");
    for (i = 0; i < num_volumes; ++i)
	  {
	    Volume *v = &device_volumes[i];

	    printf ("  %d %s %s %s %s\n", i, v->mount_point, v->fs_type,
		    v->device, v->device2);
	  }
    printf ("\n");
  }
}

int
is_path_mounted (const char *path)
{
  Volume *v = volume_for_path (path);

  if (v == NULL)
	  {
	    return 0;
	  }
  if (strcmp (v->fs_type, "ramdisk") == 0)
	  {
	    // the ramdisk is always mounted.
	    return 1;
	  }

  int result;

  result = scan_mounted_volumes ();
  if (result < 0)
	  {
	    LOGE ("failed to scan mounted volumes\n");
	    return 0;
	  }

  const MountedVolume *mv =
    find_mounted_volume_by_mount_point (v->mount_point);
  if (mv)
	  {
	    // volume is already mounted
	    return 1;
	  }
  return 0;
}

Volume *
volume_for_path (const char *path)
{
  int i;
  
  for (i = 0; i < num_volumes; ++i)
	  {
	    Volume *v = device_volumes + i;
	    int len = strlen (v->mount_point);

	    if (strncmp (path, v->mount_point, len) == 0 &&
		(path[len] == '\0' || path[len] == '/'))
		    {
		      return v;
		    }
	  }
  return NULL;
}

int
try_mount (const char *device, const char *mount_point, const char *fs_type,
	   const char *fs_options)
{
  if (device == NULL || mount_point == NULL || fs_type == NULL)
    return -1;
  int ret = 0;

  if (fs_options == NULL)
	  {
	    ret = mount (device, mount_point, fs_type,
			 MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
	  }
  else
	  {
	    char mount_cmd[PATH_MAX];

	    sprintf (mount_cmd, "mount -t %s -o%s %s %s", fs_type, fs_options,
		     device, mount_point);
	    ret = __system(mount_cmd);
	  }
  if (ret == 0)
    return 0;
  int fail_silently = get_fail_silently();
  if (!fail_silently) LOGW ("failed to mount %s (%s)\n", device, strerror (errno));
  return ret;
}

int
ensure_path_mounted (const char *path)
{
  int fail_silently = get_fail_silently();

  Volume *v = volume_for_path (path);

  if (v == NULL)
	  {
	    if (!fail_silently) LOGE ("unknown volume for path [%s]\n", path);
	    return -1;
	  }
  if (strcmp (v->fs_type, "ramdisk") == 0)
	  {
	    // the ramdisk is always mounted.
	    return 0;
	  }

  int result;

  result = scan_mounted_volumes ();
  if (result < 0)
	  {
	    if (!fail_silently) LOGE ("failed to scan mounted volumes\n");
	    return -1;
	  }

  const MountedVolume *mv =
    find_mounted_volume_by_mount_point (v->mount_point);
  if (mv)
	  {
	    // volume is already mounted
	    return 0;
	  }

  mkdir (v->mount_point, 0755);	// in case it doesn't already exist

  if (strcmp (v->fs_type, "yaffs2") == 0)
	  {
	    // mount an MTD partition as a YAFFS2 filesystem.
	    mtd_scan_partitions ();
	    const MtdPartition *partition;

	    partition = mtd_find_partition_by_name (v->device);
	    if (partition == NULL)
		    {
		      LOGE
			("failed to find \"%s\" partition to mount at \"%s\"\n",
			 v->device, v->mount_point);
		      return -1;
		    }
	    return mtd_mount_partition (partition, v->mount_point, v->fs_type,
					0);
	  }
  else if (strcmp (v->fs_type, "ext4") == 0 ||
	   strcmp (v->fs_type, "ext3") == 0 ||
	   strcmp (v->fs_type, "rfs") == 0 ||
	   strcmp (v->fs_type, "vfat") == 0)
	  {
	    if ((result =
		 try_mount (v->device, v->mount_point, v->fs_type,
			    v->fs_options)) == 0)
	      return 0;
	    if ((result =
		 try_mount (v->device2, v->mount_point, v->fs_type,
			    v->fs_options)) == 0)
	      return 0;
	    if ((result =
		 try_mount (v->device, v->mount_point, v->fs_type2,
			    v->fs_options2)) == 0)
	      return 0;
	    if ((result =
		 try_mount (v->device2, v->mount_point, v->fs_type2,
			    v->fs_options2)) == 0)
	      return 0;
	    return result;
	  }
  else
	  {
	    // let's try mounting with the mount binary and hope for the best.
	    char mount_cmd[PATH_MAX];

	    sprintf (mount_cmd, "mount %s", path);
	    return __system(mount_cmd);
	  }

  LOGE ("unknown fs_type \"%s\" for %s\n", v->fs_type, v->mount_point);
  return -1;
}

int
ensure_path_unmounted (const char *path)
{
  // if we are using /data/media, do not ever unmount volumes /data or /sdcard
  if (volume_for_path ("/sdcard") == NULL
      && (strstr (path, "/sdcard") == path || strstr (path, "/data") == path))
	  {
	    return 0;
	  }

  Volume *v = volume_for_path (path);

  if (v == NULL)
	  {
	    LOGE ("unknown volume for path [%s]\n", path);
	    return -1;
	  }
  if (strcmp (v->fs_type, "ramdisk") == 0)
	  {
	    // the ramdisk is always mounted; you can't unmount it.
	    return -1;
	  }

  int result;

  result = scan_mounted_volumes ();
  if (result < 0)
	  {
	    LOGE ("failed to scan mounted volumes\n");
	    return -1;
	  }

  const MountedVolume *mv =
    find_mounted_volume_by_mount_point (v->mount_point);
  if (mv == NULL)
	  {
	    // volume is already unmounted
	    return 0;
	  }

  return unmount_mounted_volume (mv);
}

int
format_volume (const char *volume)
{
  Volume *v = volume_for_path (volume);

  if (v == NULL)
	  {
	    // silent failure for sd-ext
	    if (strcmp (volume, "/sd-ext") == 0)
		    {
		      LOGE ("cannot format sd-ext n");
		      return -1;
		    }
	    LOGE ("unknown volume \"%s\"\n", volume);
	    return -1;
	  }
  if (strcmp (v->fs_type, "ramdisk") == 0)
	  {
	    // you can't format the ramdisk.
	    LOGE ("can't format_volume \"%s\"", volume);
	    return -1;
	  }
  if (strcmp (v->mount_point, volume) != 0)
	  {
#if 0
	    LOGE ("can't give path \"%s\" to format_volume\n", volume);
	    return -1;
#endif
	    return format_unknown_device (v->device, volume, NULL);
	  }

  if (ensure_path_unmounted (volume) != 0)
	  {
	    LOGE ("format_volume failed to unmount \"%s\"\n", v->mount_point);
	    return -1;
	  }

  if (strcmp (v->fs_type, "yaffs2") == 0 || strcmp (v->fs_type, "mtd") == 0)
	  {
	    mtd_scan_partitions ();
	    const MtdPartition *partition =
	      mtd_find_partition_by_name (v->device);
	    if (partition == NULL)
		    {
		      LOGE ("format_volume: no MTD partition \"%s\"\n",
			    v->device);
		      return -1;
		    }

	    MtdWriteContext *write = mtd_write_partition (partition);

	    if (write == NULL)
		    {
		      LOGW ("format_volume: can't open MTD \"%s\"\n",
			    v->device);
		      return -1;
		    }
	    else if (mtd_erase_blocks (write, -1) == (off_t) - 1)
		    {
		      LOGW ("format_volume: can't erase MTD \"%s\"\n",
			    v->device);
		      mtd_write_close (write);
		      return -1;
		    }
	    else if (mtd_write_close (write))
		    {
		      LOGW ("format_volume: can't close MTD \"%s\"\n",
			    v->device);
		      return -1;
		    }
	    return 0;
	  }

  if (strcmp (v->fs_type, "ext4") == 0)
	  {
	    reset_ext4fs_info ();
	    int result = make_ext4fs (v->device, NULL, NULL, 0, 0, 0);

	    if (result != 0)
		    {
		      LOGE ("format_volume: make_extf4fs failed on %s\n",
			    v->device);
		      return -1;
		    }
	    return 0;
	  }

#if 0
  LOGE ("format_volume: fs_type \"%s\" unsupported\n", v->fs_type);
  return -1;
#endif
  return format_unknown_device (v->device, volume, v->fs_type);
}

int
format_unknown_device (const char *device, const char *path,
		       const char *fs_type)
{
  LOGI ("Formatting unknown device.\n");

  // device may simply be a name, like "system"
  if (get_flash_type (fs_type) != UNSUPPORTED)
    return erase_raw_partition (fs_type, device);

  // if this is SDEXT:, don't worry about it if it does not exist.
  if (0 == strcmp (path, "/sd-ext"))
	  {
	    struct stat st;
	    Volume *vol = volume_for_path ("/sd-ext");

	    if (vol == NULL || 0 != stat (vol->device, &st))
		    {
		      ui_print
			("No app2sd partition found. Skipping format of /sd-ext.\n");
		      return 0;
		    }
	  }

  if (NULL != fs_type)
	  {
	    if (strcmp ("ext3", fs_type) == 0)
		    {
		      LOGI ("Formatting ext3 device.\n");
		      if (0 != ensure_path_unmounted (path))
			      {
				LOGE ("Error while unmounting %s.\n", path);
				return -12;
			      }
		      return format_ext3_device (device);
		    }

	    if (strcmp ("ext2", fs_type) == 0)
		    {
		      LOGI ("Formatting ext2 device.\n");
		      if (0 != ensure_path_unmounted (path))
			      {
				LOGE ("Error while unmounting %s.\n", path);
				return -12;
			      }
		      return format_ext2_device (device);
		    }
	  }

  if (0 != ensure_path_mounted (path))
	  {
	    ui_print ("Error mounting %s!\n", path);
	    ui_print ("Skipping format...\n");
	    return 0;
	  }

  static char tmp[PATH_MAX];

  if (strcmp (path, "/data") == 0)
	  {
	    sprintf (tmp,
		     "cd /data ; for f in $(ls -a | grep -v ^media$); do rm -rf $f; done");
	    __system(tmp);
	  }
  else
	  {
	    sprintf (tmp, "rm -rf %s/*", path);
	    __system(tmp);
	    sprintf (tmp, "rm -rf %s/.*", path);
	    __system(tmp);
	  }

  ensure_path_unmounted (path);
  return 0;
}