]>
Commit | Line | Data |
---|---|---|
01325476 S |
1 | /* |
2 | * An implementation of host to guest copy functionality for Linux. | |
3 | * | |
4 | * Copyright (C) 2014, Microsoft, Inc. | |
5 | * | |
6 | * Author : K. Y. Srinivasan <kys@microsoft.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify it | |
9 | * under the terms of the GNU General Public License version 2 as published | |
10 | * by the Free Software Foundation. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or | |
15 | * NON INFRINGEMENT. See the GNU General Public License for more | |
16 | * details. | |
17 | */ | |
18 | ||
19 | ||
20 | #include <sys/types.h> | |
01325476 S |
21 | #include <stdio.h> |
22 | #include <stdlib.h> | |
23 | #include <unistd.h> | |
aba8a532 | 24 | #include <string.h> |
01325476 S |
25 | #include <errno.h> |
26 | #include <linux/hyperv.h> | |
1330fc35 | 27 | #include <linux/limits.h> |
01325476 S |
28 | #include <syslog.h> |
29 | #include <sys/stat.h> | |
30 | #include <fcntl.h> | |
170f4bea | 31 | #include <getopt.h> |
01325476 S |
32 | |
33 | static int target_fd; | |
1330fc35 | 34 | static char target_fname[PATH_MAX]; |
b4ed5d16 | 35 | static unsigned long long filesize; |
01325476 S |
36 | |
37 | static int hv_start_fcopy(struct hv_start_fcopy *smsg) | |
38 | { | |
39 | int error = HV_E_FAIL; | |
40 | char *q, *p; | |
41 | ||
b4ed5d16 | 42 | filesize = 0; |
01325476 S |
43 | p = (char *)smsg->path_name; |
44 | snprintf(target_fname, sizeof(target_fname), "%s/%s", | |
aba474b8 | 45 | (char *)smsg->path_name, (char *)smsg->file_name); |
01325476 S |
46 | |
47 | syslog(LOG_INFO, "Target file name: %s", target_fname); | |
48 | /* | |
49 | * Check to see if the path is already in place; if not, | |
50 | * create if required. | |
51 | */ | |
52 | while ((q = strchr(p, '/')) != NULL) { | |
53 | if (q == p) { | |
54 | p++; | |
55 | continue; | |
56 | } | |
57 | *q = '\0'; | |
58 | if (access((char *)smsg->path_name, F_OK)) { | |
59 | if (smsg->copy_flags & CREATE_PATH) { | |
60 | if (mkdir((char *)smsg->path_name, 0755)) { | |
61 | syslog(LOG_ERR, "Failed to create %s", | |
62 | (char *)smsg->path_name); | |
63 | goto done; | |
64 | } | |
65 | } else { | |
66 | syslog(LOG_ERR, "Invalid path: %s", | |
67 | (char *)smsg->path_name); | |
68 | goto done; | |
69 | } | |
70 | } | |
71 | p = q + 1; | |
72 | *q = '/'; | |
73 | } | |
74 | ||
75 | if (!access(target_fname, F_OK)) { | |
76 | syslog(LOG_INFO, "File: %s exists", target_fname); | |
314672a2 S |
77 | if (!(smsg->copy_flags & OVER_WRITE)) { |
78 | error = HV_ERROR_ALREADY_EXISTS; | |
01325476 | 79 | goto done; |
314672a2 | 80 | } |
01325476 S |
81 | } |
82 | ||
e013ac31 YZ |
83 | target_fd = open(target_fname, |
84 | O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0744); | |
01325476 S |
85 | if (target_fd == -1) { |
86 | syslog(LOG_INFO, "Open Failed: %s", strerror(errno)); | |
87 | goto done; | |
88 | } | |
89 | ||
90 | error = 0; | |
91 | done: | |
92 | return error; | |
93 | } | |
94 | ||
95 | static int hv_copy_data(struct hv_do_fcopy *cpmsg) | |
96 | { | |
97 | ssize_t bytes_written; | |
b4ed5d16 | 98 | int ret = 0; |
01325476 S |
99 | |
100 | bytes_written = pwrite(target_fd, cpmsg->data, cpmsg->size, | |
101 | cpmsg->offset); | |
102 | ||
b4ed5d16 OH |
103 | filesize += cpmsg->size; |
104 | if (bytes_written != cpmsg->size) { | |
105 | switch (errno) { | |
106 | case ENOSPC: | |
107 | ret = HV_ERROR_DISK_FULL; | |
108 | break; | |
109 | default: | |
110 | ret = HV_E_FAIL; | |
111 | break; | |
112 | } | |
113 | syslog(LOG_ERR, "pwrite failed to write %llu bytes: %ld (%s)", | |
114 | filesize, (long)bytes_written, strerror(errno)); | |
115 | } | |
01325476 | 116 | |
b4ed5d16 | 117 | return ret; |
01325476 S |
118 | } |
119 | ||
120 | static int hv_copy_finished(void) | |
121 | { | |
122 | close(target_fd); | |
123 | return 0; | |
124 | } | |
125 | static int hv_copy_cancel(void) | |
126 | { | |
127 | close(target_fd); | |
128 | unlink(target_fname); | |
129 | return 0; | |
130 | ||
131 | } | |
132 | ||
170f4bea VK |
133 | void print_usage(char *argv[]) |
134 | { | |
135 | fprintf(stderr, "Usage: %s [options]\n" | |
136 | "Options are:\n" | |
137 | " -n, --no-daemon stay in foreground, don't daemonize\n" | |
138 | " -h, --help print this help\n", argv[0]); | |
139 | } | |
140 | ||
141 | int main(int argc, char *argv[]) | |
01325476 | 142 | { |
3f2baa8a | 143 | int fcopy_fd; |
01325476 | 144 | int error; |
170f4bea | 145 | int daemonize = 1, long_index = 0, opt; |
01325476 | 146 | int version = FCOPY_CURRENT_VERSION; |
3f2baa8a OH |
147 | union { |
148 | struct hv_fcopy_hdr hdr; | |
149 | struct hv_start_fcopy start; | |
150 | struct hv_do_fcopy copy; | |
151 | __u32 kernel_modver; | |
152 | } buffer = { }; | |
a4d1ee5b | 153 | int in_handshake = 1; |
01325476 | 154 | |
170f4bea VK |
155 | static struct option long_options[] = { |
156 | {"help", no_argument, 0, 'h' }, | |
157 | {"no-daemon", no_argument, 0, 'n' }, | |
158 | {0, 0, 0, 0 } | |
159 | }; | |
160 | ||
161 | while ((opt = getopt_long(argc, argv, "hn", long_options, | |
162 | &long_index)) != -1) { | |
163 | switch (opt) { | |
164 | case 'n': | |
165 | daemonize = 0; | |
166 | break; | |
167 | case 'h': | |
168 | default: | |
169 | print_usage(argv); | |
170 | exit(EXIT_FAILURE); | |
171 | } | |
172 | } | |
173 | ||
174 | if (daemonize && daemon(1, 0)) { | |
01325476 S |
175 | syslog(LOG_ERR, "daemon() failed; error: %s", strerror(errno)); |
176 | exit(EXIT_FAILURE); | |
177 | } | |
178 | ||
179 | openlog("HV_FCOPY", 0, LOG_USER); | |
6dfb867c | 180 | syslog(LOG_INFO, "starting; pid is:%d", getpid()); |
01325476 S |
181 | |
182 | fcopy_fd = open("/dev/vmbus/hv_fcopy", O_RDWR); | |
183 | ||
184 | if (fcopy_fd < 0) { | |
185 | syslog(LOG_ERR, "open /dev/vmbus/hv_fcopy failed; error: %d %s", | |
186 | errno, strerror(errno)); | |
187 | exit(EXIT_FAILURE); | |
188 | } | |
189 | ||
190 | /* | |
191 | * Register with the kernel. | |
192 | */ | |
193 | if ((write(fcopy_fd, &version, sizeof(int))) != sizeof(int)) { | |
194 | syslog(LOG_ERR, "Registration failed: %s", strerror(errno)); | |
195 | exit(EXIT_FAILURE); | |
196 | } | |
197 | ||
198 | while (1) { | |
199 | /* | |
200 | * In this loop we process fcopy messages after the | |
201 | * handshake is complete. | |
202 | */ | |
3f2baa8a OH |
203 | ssize_t len; |
204 | ||
205 | len = pread(fcopy_fd, &buffer, sizeof(buffer), 0); | |
01325476 S |
206 | if (len < 0) { |
207 | syslog(LOG_ERR, "pread failed: %s", strerror(errno)); | |
208 | exit(EXIT_FAILURE); | |
209 | } | |
a4d1ee5b VK |
210 | |
211 | if (in_handshake) { | |
3f2baa8a | 212 | if (len != sizeof(buffer.kernel_modver)) { |
a4d1ee5b VK |
213 | syslog(LOG_ERR, "invalid version negotiation"); |
214 | exit(EXIT_FAILURE); | |
215 | } | |
a4d1ee5b | 216 | in_handshake = 0; |
3f2baa8a OH |
217 | syslog(LOG_INFO, "kernel module version: %u", |
218 | buffer.kernel_modver); | |
a4d1ee5b VK |
219 | continue; |
220 | } | |
221 | ||
3f2baa8a | 222 | switch (buffer.hdr.operation) { |
01325476 | 223 | case START_FILE_COPY: |
3f2baa8a | 224 | error = hv_start_fcopy(&buffer.start); |
01325476 S |
225 | break; |
226 | case WRITE_TO_FILE: | |
3f2baa8a | 227 | error = hv_copy_data(&buffer.copy); |
01325476 S |
228 | break; |
229 | case COMPLETE_FCOPY: | |
230 | error = hv_copy_finished(); | |
231 | break; | |
232 | case CANCEL_FCOPY: | |
233 | error = hv_copy_cancel(); | |
234 | break; | |
235 | ||
236 | default: | |
c2d68afb | 237 | error = HV_E_FAIL; |
01325476 | 238 | syslog(LOG_ERR, "Unknown operation: %d", |
3f2baa8a | 239 | buffer.hdr.operation); |
01325476 S |
240 | |
241 | } | |
242 | ||
243 | if (pwrite(fcopy_fd, &error, sizeof(int), 0) != sizeof(int)) { | |
244 | syslog(LOG_ERR, "pwrite failed: %s", strerror(errno)); | |
245 | exit(EXIT_FAILURE); | |
246 | } | |
247 | } | |
248 | } |