// SPDX-License-Identifier: GPL-2.0-only
/*
 * An implementation of the host initiated guest snapshot for Hyper-V.
 *
 * Copyright (C) 2013, Microsoft, Inc.
 * Author : K. Y. Srinivasan <kys@microsoft.com>
 */


#include <sys/types.h>
#include <sys/poll.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>
#include <fcntl.h>
#include <stdio.h>
#include <mntent.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <linux/fs.h>
#include <linux/major.h>
#include <linux/hyperv.h>
#include <syslog.h>
#include <getopt.h>
#include <stdbool.h>
#include <dirent.h>

static bool fs_frozen;

/* Don't use syslog() in the function since that can cause write to disk */
static int vss_do_freeze(char *dir, unsigned int cmd)
{
        int ret, fd = open(dir, O_RDONLY);

        if (fd < 0)
                return 1;

        ret = ioctl(fd, cmd, 0);

        /*
         * If a partition is mounted more than once, only the first
         * FREEZE/THAW can succeed and the later ones will get
         * EBUSY/EINVAL respectively: there could be 2 cases:
         * 1) a user may mount the same partition to different directories
         *  by mistake or on purpose;
         * 2) The subvolume of btrfs appears to have the same partition
         * mounted more than once.
         */
        if (ret) {
                if ((cmd == FIFREEZE && errno == EBUSY) ||
                    (cmd == FITHAW && errno == EINVAL)) {
                        close(fd);
                        return 0;
                }
        }

        close(fd);
        return !!ret;
}

static bool is_dev_loop(const char *blkname)
{
        char *buffer;
        DIR *dir;
        struct dirent *entry;
        bool ret = false;

        buffer = malloc(PATH_MAX);
        if (!buffer) {
                syslog(LOG_ERR, "Can't allocate memory!");
                exit(1);
        }

        snprintf(buffer, PATH_MAX, "%s/loop", blkname);
        if (!access(buffer, R_OK | X_OK)) {
                ret = true;
                goto free_buffer;
        } else if (errno != ENOENT) {
                syslog(LOG_ERR, "Can't access: %s; error:%d %s!",
                       buffer, errno, strerror(errno));
        }

        snprintf(buffer, PATH_MAX, "%s/slaves", blkname);
        dir = opendir(buffer);
        if (!dir) {
                if (errno != ENOENT)
                        syslog(LOG_ERR, "Can't opendir: %s; error:%d %s!",
                               buffer, errno, strerror(errno));
                goto free_buffer;
        }

        while ((entry = readdir(dir)) != NULL) {
                if (strcmp(entry->d_name, ".") == 0 ||
                    strcmp(entry->d_name, "..") == 0)
                        continue;

                snprintf(buffer, PATH_MAX, "%s/slaves/%s", blkname,
                         entry->d_name);
                if (is_dev_loop(buffer)) {
                        ret = true;
                        break;
                }
        }
        closedir(dir);
free_buffer:
        free(buffer);
        return ret;
}

static int vss_operate(int operation)
{
        char match[] = "/dev/";
        FILE *mounts;
        struct mntent *ent;
        struct stat sb;
        char errdir[1024] = {0};
        char blkdir[23]; /* /sys/dev/block/XXX:XXX */
        unsigned int cmd;
        int error = 0, root_seen = 0, save_errno = 0;

        switch (operation) {
        case VSS_OP_FREEZE:
                cmd = FIFREEZE;
                break;
        case VSS_OP_THAW:
                cmd = FITHAW;
                break;
        default:
                return -1;
        }

        mounts = setmntent("/proc/mounts", "r");
        if (mounts == NULL)
                return -1;

        while ((ent = getmntent(mounts))) {
                if (strncmp(ent->mnt_fsname, match, strlen(match)))
                        continue;
                if (stat(ent->mnt_fsname, &sb)) {
                        syslog(LOG_ERR, "Can't stat: %s; error:%d %s!",
                               ent->mnt_fsname, errno, strerror(errno));
                } else {
                        sprintf(blkdir, "/sys/dev/block/%d:%d",
                                major(sb.st_rdev), minor(sb.st_rdev));
                        if (is_dev_loop(blkdir))
                                continue;
                }
                if (hasmntopt(ent, MNTOPT_RO) != NULL)
                        continue;
                if (strcmp(ent->mnt_type, "vfat") == 0)
                        continue;
                if (strcmp(ent->mnt_dir, "/") == 0) {
                        root_seen = 1;
                        continue;
                }
                error |= vss_do_freeze(ent->mnt_dir, cmd);
                if (operation == VSS_OP_FREEZE) {
                        if (error)
                                goto err;
                        fs_frozen = true;
                }
        }

        endmntent(mounts);

        if (root_seen) {
                error |= vss_do_freeze("/", cmd);
                if (operation == VSS_OP_FREEZE) {
                        if (error)
                                goto err;
                        fs_frozen = true;
                }
        }

        if (operation == VSS_OP_THAW && !error)
                fs_frozen = false;

        goto out;
err:
        save_errno = errno;
        if (ent) {
                strncpy(errdir, ent->mnt_dir, sizeof(errdir)-1);
                endmntent(mounts);
        }
        vss_operate(VSS_OP_THAW);
        fs_frozen = false;
        /* Call syslog after we thaw all filesystems */
        if (ent)
                syslog(LOG_ERR, "FREEZE of %s failed; error:%d %s",
                       errdir, save_errno, strerror(save_errno));
        else
                syslog(LOG_ERR, "FREEZE of / failed; error:%d %s", save_errno,
                       strerror(save_errno));
out:
        return error;
}

void print_usage(char *argv[])
{
        fprintf(stderr, "Usage: %s [options]\n"
                "Options are:\n"
                "  -n, --no-daemon        stay in foreground, don't daemonize\n"
                "  -h, --help             print this help\n", argv[0]);
}

int main(int argc, char *argv[])
{
        int vss_fd = -1, len;
        int error;
        struct pollfd pfd;
        int     op;
        struct hv_vss_msg vss_msg[1];
        int daemonize = 1, long_index = 0, opt;
        int in_handshake;
        __u32 kernel_modver;

        static struct option long_options[] = {
                {"help",        no_argument,       0,  'h' },
                {"no-daemon",   no_argument,       0,  'n' },
                {0,             0,                 0,  0   }
        };

        while ((opt = getopt_long(argc, argv, "hn", long_options,
                                  &long_index)) != -1) {
                switch (opt) {
                case 'n':
                        daemonize = 0;
                        break;
                case 'h':
                        print_usage(argv);
                        exit(0);
                default:
                        print_usage(argv);
                        exit(EXIT_FAILURE);
                }
        }

        if (daemonize && daemon(1, 0))
                return 1;

        openlog("Hyper-V VSS", 0, LOG_USER);
        syslog(LOG_INFO, "VSS starting; pid is:%d", getpid());

reopen_vss_fd:
        if (vss_fd != -1)
                close(vss_fd);
        if (fs_frozen) {
                if (vss_operate(VSS_OP_THAW) || fs_frozen) {
                        syslog(LOG_ERR, "failed to thaw file system: err=%d",
                               errno);
                        exit(EXIT_FAILURE);
                }
        }

        in_handshake = 1;
        vss_fd = open("/dev/vmbus/hv_vss", O_RDWR);
        if (vss_fd < 0) {
                syslog(LOG_ERR, "open /dev/vmbus/hv_vss failed; error: %d %s",
                       errno, strerror(errno));
                exit(EXIT_FAILURE);
        }
        /*
         * Register ourselves with the kernel.
         */
        vss_msg->vss_hdr.operation = VSS_OP_REGISTER1;

        len = write(vss_fd, vss_msg, sizeof(struct hv_vss_msg));
        if (len < 0) {
                syslog(LOG_ERR, "registration to kernel failed; error: %d %s",
                       errno, strerror(errno));
                close(vss_fd);
                exit(EXIT_FAILURE);
        }

        pfd.fd = vss_fd;

        while (1) {
                pfd.events = POLLIN;
                pfd.revents = 0;

                if (poll(&pfd, 1, -1) < 0) {
                        syslog(LOG_ERR, "poll failed; error:%d %s", errno, strerror(errno));
                        if (errno == EINVAL) {
                                close(vss_fd);
                                exit(EXIT_FAILURE);
                        }
                        else
                                continue;
                }

                len = read(vss_fd, vss_msg, sizeof(struct hv_vss_msg));

                if (in_handshake) {
                        if (len != sizeof(kernel_modver)) {
                                syslog(LOG_ERR, "invalid version negotiation");
                                exit(EXIT_FAILURE);
                        }
                        kernel_modver = *(__u32 *)vss_msg;
                        in_handshake = 0;
                        syslog(LOG_INFO, "VSS: kernel module version: %d",
                               kernel_modver);
                        continue;
                }

                if (len != sizeof(struct hv_vss_msg)) {
                        syslog(LOG_ERR, "read failed; error:%d %s",
                               errno, strerror(errno));
                        goto reopen_vss_fd;
                }

                op = vss_msg->vss_hdr.operation;
                error =  HV_S_OK;

                switch (op) {
                case VSS_OP_FREEZE:
                case VSS_OP_THAW:
                        error = vss_operate(op);
                        syslog(LOG_INFO, "VSS: op=%s: %s\n",
                                op == VSS_OP_FREEZE ? "FREEZE" : "THAW",
                                error ? "failed" : "succeeded");

                        if (error) {
                                error = HV_E_FAIL;
                                syslog(LOG_ERR, "op=%d failed!", op);
                                syslog(LOG_ERR, "report it with these files:");
                                syslog(LOG_ERR, "/etc/fstab and /proc/mounts");
                        }
                        break;
                case VSS_OP_HOT_BACKUP:
                        syslog(LOG_INFO, "VSS: op=CHECK HOT BACKUP\n");
                        break;
                default:
                        syslog(LOG_ERR, "Illegal op:%d\n", op);
                }

                /*
                 * The write() may return an error due to the faked VSS_OP_THAW
                 * message upon hibernation. Ignore the error by resetting the
                 * dev file, i.e. closing and re-opening it.
                 */
                vss_msg->error = error;
                len = write(vss_fd, vss_msg, sizeof(struct hv_vss_msg));
                if (len != sizeof(struct hv_vss_msg)) {
                        syslog(LOG_ERR, "write failed; error: %d %s", errno,
                               strerror(errno));
                        goto reopen_vss_fd;
                }
        }

        close(vss_fd);
        exit(0);
}