/*
   * An implementation of the host initiated guest snapshot for Hyper-V.
   *
   *
   * Copyright (C) 2013, Microsoft, Inc.
   * Author : K. Y. Srinivasan <kys@microsoft.com>
   *
   * This program is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 as published
   * by the Free Software Foundation.
   *
   * This program 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, GOOD TITLE or
   * NON INFRINGEMENT.  See the GNU General Public License for more
   * details.
   *
   */
  
  
  #include <sys/types.h>

  #include <sys/poll.h>

  #include <sys/ioctl.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/hyperv.h>

  #include <syslog.h>

  #include <getopt.h>

  /* 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 differnt 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 int vss_operate(int operation)
  {

  	char match[] = "/dev/";
  	FILE *mounts;
  	struct mntent *ent;

  	char errdir[1024] = {0};

  	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 (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 (error && operation == VSS_OP_FREEZE)
  			goto err;

  	}

  	endmntent(mounts);

  	if (root_seen) {

  		error |= vss_do_freeze("/", cmd);
  		if (error && operation == VSS_OP_FREEZE)
  			goto err;

  	}

  	goto out;

  err:

  	save_errno = errno;

  	if (ent) {
  		strncpy(errdir, ent->mnt_dir, sizeof(errdir)-1);
  		endmntent(mounts);
  	}

  	vss_operate(VSS_OP_THAW);

  	/* 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]
  "
  		"Options are:
  "
  		"  -n, --no-daemon        stay in foreground, don't daemonize
  "
  		"  -h, --help             print this help
  ", argv[0]);
  }
  
  int main(int argc, char *argv[])

  {

  	int vss_fd, 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 = 1;
  	__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':
  		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());

  	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));
  			close(vss_fd);
  			return EXIT_FAILURE;

  		}

  		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
  ",
  				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
  ");
  			break;

  		default:
  			syslog(LOG_ERR, "Illegal op:%d
  ", op);
  		}
  		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));

  			exit(EXIT_FAILURE);
  		}
  	}

  	close(vss_fd);
  	exit(0);

  }