/*
 * Copyright 2011, 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 <fcntl.h>
#include <mntent.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/cdefs.h>
#include <sys/mount.h>
#include <sys/reboot.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>

#include <cutils/android_reboot.h>
#include <cutils/klog.h>
#include <cutils/list.h>

#define TAG "android_reboot"
#define READONLY_CHECK_MS 5000
#define READONLY_CHECK_TIMES 50

typedef struct {
    struct listnode list;
    struct mntent entry;
} mntent_list;

static bool has_mount_option(const char* opts, const char* opt_to_find)
{
  bool ret = false;
  char* copy = NULL;
  char* opt;
  char* rem;

  while ((opt = strtok_r(copy ? NULL : (copy = strdup(opts)), ",", &rem))) {
      if (!strcmp(opt, opt_to_find)) {
          ret = true;
          break;
      }
  }

  free(copy);
  return ret;
}

static bool is_block_device(const char* fsname)
{
    return !strncmp(fsname, "/dev/block", 10);
}

/* Find all read+write block devices in /proc/mounts and add them to
 * |rw_entries|.
 */
static void find_rw(struct listnode* rw_entries)
{
    FILE* fp;
    struct mntent* mentry;

    if ((fp = setmntent("/proc/mounts", "r")) == NULL) {
        KLOG_WARNING(TAG, "Failed to open /proc/mounts.\n");
        return;
    }
    while ((mentry = getmntent(fp)) != NULL) {
        if (is_block_device(mentry->mnt_fsname) &&
            has_mount_option(mentry->mnt_opts, "rw")) {
            mntent_list* item = (mntent_list*)calloc(1, sizeof(mntent_list));
            item->entry = *mentry;
            item->entry.mnt_fsname = strdup(mentry->mnt_fsname);
            item->entry.mnt_dir = strdup(mentry->mnt_dir);
            item->entry.mnt_type = strdup(mentry->mnt_type);
            item->entry.mnt_opts = strdup(mentry->mnt_opts);
            list_add_tail(rw_entries, &item->list);
        }
    }
    endmntent(fp);
}

static void free_entries(struct listnode* entries)
{
    struct listnode* node;
    struct listnode* n;
    list_for_each_safe(node, n, entries) {
        mntent_list* item = node_to_item(node, mntent_list, list);
        free(item->entry.mnt_fsname);
        free(item->entry.mnt_dir);
        free(item->entry.mnt_type);
        free(item->entry.mnt_opts);
        free(item);
    }
}

static mntent_list* find_item(struct listnode* rw_entries, const char* fsname_to_find)
{
    struct listnode* node;
    list_for_each(node, rw_entries) {
        mntent_list* item = node_to_item(node, mntent_list, list);
        if (!strcmp(item->entry.mnt_fsname, fsname_to_find)) {
            return item;
        }
    }
    return NULL;
}

/* Remounting filesystems read-only is difficult when there are files
 * opened for writing or pending deletes on the filesystem.  There is
 * no way to force the remount with the mount(2) syscall.  The magic sysrq
 * 'u' command does an emergency remount read-only on all writable filesystems
 * that have a block device (i.e. not tmpfs filesystems) by calling
 * emergency_remount(), which knows how to force the remount to read-only.
 * Unfortunately, that is asynchronous, and just schedules the work and
 * returns.  The best way to determine if it is done is to read /proc/mounts
 * repeatedly until there are no more writable filesystems mounted on
 * block devices.
 */
static void remount_ro(void (*cb_on_remount)(const struct mntent*))
{
    int fd, cnt;
    FILE* fp;
    struct mntent* mentry;
    struct listnode* node;

    list_declare(rw_entries);
    list_declare(ro_entries);

    sync();
    find_rw(&rw_entries);

    /* Trigger the remount of the filesystems as read-only,
     * which also marks them clean.
     */
    fd = TEMP_FAILURE_RETRY(open("/proc/sysrq-trigger", O_WRONLY));
    if (fd < 0) {
        KLOG_WARNING(TAG, "Failed to open sysrq-trigger.\n");
        /* TODO: Try to remount each rw parition manually in readonly mode.
         * This may succeed if no process is using the partition.
         */
        goto out;
    }
    if (TEMP_FAILURE_RETRY(write(fd, "u", 1)) != 1) {
        close(fd);
        KLOG_WARNING(TAG, "Failed to write to sysrq-trigger.\n");
        /* TODO: The same. Manually remount the paritions. */
        goto out;
    }
    close(fd);

    /* Now poll /proc/mounts till it's done */
    cnt = 0;
    while (cnt < READONLY_CHECK_TIMES) {
        if ((fp = setmntent("/proc/mounts", "r")) == NULL) {
            /* If we can't read /proc/mounts, just give up. */
            KLOG_WARNING(TAG, "Failed to open /proc/mounts.\n");
            goto out;
        }
        while ((mentry = getmntent(fp)) != NULL) {
            if (!is_block_device(mentry->mnt_fsname) ||
                !has_mount_option(mentry->mnt_opts, "ro")) {
                continue;
            }
            mntent_list* item = find_item(&rw_entries, mentry->mnt_fsname);
            if (item) {
                /* |item| has now been ro remounted. */
                list_remove(&item->list);
                list_add_tail(&ro_entries, &item->list);
            }
        }
        endmntent(fp);
        if (list_empty(&rw_entries)) {
            /* All rw block devices are now readonly. */
            break;
        }
        TEMP_FAILURE_RETRY(
            usleep(READONLY_CHECK_MS * 1000 / READONLY_CHECK_TIMES));
        cnt++;
    }

    list_for_each(node, &rw_entries) {
        mntent_list* item = node_to_item(node, mntent_list, list);
        KLOG_WARNING(TAG, "Failed to remount %s in readonly mode.\n",
                     item->entry.mnt_fsname);
    }

    if (cb_on_remount) {
        list_for_each(node, &ro_entries) {
            mntent_list* item = node_to_item(node, mntent_list, list);
            cb_on_remount(&item->entry);
        }
    }

out:
    free_entries(&rw_entries);
    free_entries(&ro_entries);
}

int android_reboot_with_callback(
    int cmd, int flags __unused, const char *arg,
    void (*cb_on_remount)(const struct mntent*))
{
    int ret = 0;
    int reason = -1;

#ifdef RECOVERY_PRE_COMMAND
    if (cmd == (int) ANDROID_RB_RESTART2) {
        if (arg && strlen(arg) > 0) {
            char cmd[PATH_MAX];
            sprintf(cmd, RECOVERY_PRE_COMMAND " %s", arg);
            system(cmd);
        }
    }
#endif

    remount_ro(cb_on_remount);
    switch (cmd) {
        case ANDROID_RB_RESTART:
            reason = RB_AUTOBOOT;
            break;

        case ANDROID_RB_POWEROFF:
            ret = reboot(RB_POWER_OFF);
            return ret;

        case ANDROID_RB_RESTART2:
            // REBOOT_MAGIC
            break;

        default:
            return -1;
    }

#ifdef RECOVERY_PRE_COMMAND_CLEAR_REASON
    reason = RB_AUTOBOOT;
#endif

    if (reason != -1)
        ret = reboot(reason);
    else
        ret = syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
                      LINUX_REBOOT_CMD_RESTART2, arg);

    return ret;
}

int android_reboot(int cmd, int flags, const char *arg)
{
    return android_reboot_with_callback(cmd, flags, arg, NULL);
}
