| /* |
| * An implementation of host to guest copy functionality for Linux. |
| * |
| * Copyright (C) 2014, 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/socket.h> |
| #include <sys/poll.h> |
| #include <linux/types.h> |
| #include <linux/kdev_t.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <string.h> |
| #include <ctype.h> |
| #include <errno.h> |
| #include <linux/hyperv.h> |
| #include <syslog.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| #include <dirent.h> |
| #include <getopt.h> |
| |
| static int target_fd; |
| static char target_fname[W_MAX_PATH]; |
| static unsigned long long filesize; |
| |
| static int hv_start_fcopy(struct hv_start_fcopy *smsg) |
| { |
| int error = HV_E_FAIL; |
| char *q, *p; |
| |
| filesize = 0; |
| p = (char *)smsg->path_name; |
| snprintf(target_fname, sizeof(target_fname), "%s/%s", |
| (char *)smsg->path_name, (char *)smsg->file_name); |
| |
| syslog(LOG_INFO, "Target file name: %s", target_fname); |
| /* |
| * Check to see if the path is already in place; if not, |
| * create if required. |
| */ |
| while ((q = strchr(p, '/')) != NULL) { |
| if (q == p) { |
| p++; |
| continue; |
| } |
| *q = '\0'; |
| if (access((char *)smsg->path_name, F_OK)) { |
| if (smsg->copy_flags & CREATE_PATH) { |
| if (mkdir((char *)smsg->path_name, 0755)) { |
| syslog(LOG_ERR, "Failed to create %s", |
| (char *)smsg->path_name); |
| goto done; |
| } |
| } else { |
| syslog(LOG_ERR, "Invalid path: %s", |
| (char *)smsg->path_name); |
| goto done; |
| } |
| } |
| p = q + 1; |
| *q = '/'; |
| } |
| |
| if (!access(target_fname, F_OK)) { |
| syslog(LOG_INFO, "File: %s exists", target_fname); |
| if (!(smsg->copy_flags & OVER_WRITE)) { |
| error = HV_ERROR_ALREADY_EXISTS; |
| goto done; |
| } |
| } |
| |
| target_fd = open(target_fname, |
| O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0744); |
| if (target_fd == -1) { |
| syslog(LOG_INFO, "Open Failed: %s", strerror(errno)); |
| goto done; |
| } |
| |
| error = 0; |
| done: |
| return error; |
| } |
| |
| static int hv_copy_data(struct hv_do_fcopy *cpmsg) |
| { |
| ssize_t bytes_written; |
| int ret = 0; |
| |
| bytes_written = pwrite(target_fd, cpmsg->data, cpmsg->size, |
| cpmsg->offset); |
| |
| filesize += cpmsg->size; |
| if (bytes_written != cpmsg->size) { |
| switch (errno) { |
| case ENOSPC: |
| ret = HV_ERROR_DISK_FULL; |
| break; |
| default: |
| ret = HV_E_FAIL; |
| break; |
| } |
| syslog(LOG_ERR, "pwrite failed to write %llu bytes: %ld (%s)", |
| filesize, (long)bytes_written, strerror(errno)); |
| } |
| |
| return ret; |
| } |
| |
| static int hv_copy_finished(void) |
| { |
| close(target_fd); |
| return 0; |
| } |
| static int hv_copy_cancel(void) |
| { |
| close(target_fd); |
| unlink(target_fname); |
| return 0; |
| |
| } |
| |
| 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 fcopy_fd, len; |
| int error; |
| int daemonize = 1, long_index = 0, opt; |
| int version = FCOPY_CURRENT_VERSION; |
| char *buffer[4096 * 2]; |
| struct hv_fcopy_hdr *in_msg; |
| 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)) { |
| syslog(LOG_ERR, "daemon() failed; error: %s", strerror(errno)); |
| exit(EXIT_FAILURE); |
| } |
| |
| openlog("HV_FCOPY", 0, LOG_USER); |
| syslog(LOG_INFO, "starting; pid is:%d", getpid()); |
| |
| fcopy_fd = open("/dev/vmbus/hv_fcopy", O_RDWR); |
| |
| if (fcopy_fd < 0) { |
| syslog(LOG_ERR, "open /dev/vmbus/hv_fcopy failed; error: %d %s", |
| errno, strerror(errno)); |
| exit(EXIT_FAILURE); |
| } |
| |
| /* |
| * Register with the kernel. |
| */ |
| if ((write(fcopy_fd, &version, sizeof(int))) != sizeof(int)) { |
| syslog(LOG_ERR, "Registration failed: %s", strerror(errno)); |
| exit(EXIT_FAILURE); |
| } |
| |
| while (1) { |
| /* |
| * In this loop we process fcopy messages after the |
| * handshake is complete. |
| */ |
| len = pread(fcopy_fd, buffer, (4096 * 2), 0); |
| if (len < 0) { |
| syslog(LOG_ERR, "pread failed: %s", strerror(errno)); |
| exit(EXIT_FAILURE); |
| } |
| |
| if (in_handshake) { |
| if (len != sizeof(kernel_modver)) { |
| syslog(LOG_ERR, "invalid version negotiation"); |
| exit(EXIT_FAILURE); |
| } |
| kernel_modver = *(__u32 *)buffer; |
| in_handshake = 0; |
| syslog(LOG_INFO, "kernel module version: %d", |
| kernel_modver); |
| continue; |
| } |
| |
| in_msg = (struct hv_fcopy_hdr *)buffer; |
| |
| switch (in_msg->operation) { |
| case START_FILE_COPY: |
| error = hv_start_fcopy((struct hv_start_fcopy *)in_msg); |
| break; |
| case WRITE_TO_FILE: |
| error = hv_copy_data((struct hv_do_fcopy *)in_msg); |
| break; |
| case COMPLETE_FCOPY: |
| error = hv_copy_finished(); |
| break; |
| case CANCEL_FCOPY: |
| error = hv_copy_cancel(); |
| break; |
| |
| default: |
| syslog(LOG_ERR, "Unknown operation: %d", |
| in_msg->operation); |
| |
| } |
| |
| if (pwrite(fcopy_fd, &error, sizeof(int), 0) != sizeof(int)) { |
| syslog(LOG_ERR, "pwrite failed: %s", strerror(errno)); |
| exit(EXIT_FAILURE); |
| } |
| } |
| } |