498 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * An implementation of host to guest copy functionality for Linux.4 *5 * Copyright (C) 2023, Microsoft, Inc.6 *7 * Author : K. Y. Srinivasan <kys@microsoft.com>8 * Author : Saurabh Sengar <ssengar@microsoft.com>9 *10 */11 12#include <dirent.h>13#include <errno.h>14#include <fcntl.h>15#include <getopt.h>16#include <locale.h>17#include <stdbool.h>18#include <stddef.h>19#include <stdint.h>20#include <stdio.h>21#include <stdlib.h>22#include <string.h>23#include <syslog.h>24#include <unistd.h>25#include <wchar.h>26#include <sys/stat.h>27#include <linux/hyperv.h>28#include <linux/limits.h>29#include "vmbus_bufring.h"30 31#define ICMSGTYPE_NEGOTIATE 032#define ICMSGTYPE_FCOPY 733 34#define WIN8_SRV_MAJOR 135#define WIN8_SRV_MINOR 136#define WIN8_SRV_VERSION (WIN8_SRV_MAJOR << 16 | WIN8_SRV_MINOR)37 38#define MAX_FOLDER_NAME 1539#define MAX_PATH_LEN 1540#define FCOPY_UIO "/sys/bus/vmbus/devices/eb765408-105f-49b6-b4aa-c123b64d17d4/uio"41 42#define FCOPY_VER_COUNT 143static const int fcopy_versions[] = {44 WIN8_SRV_VERSION45};46 47#define FW_VER_COUNT 148static const int fw_versions[] = {49 UTIL_FW_VERSION50};51 52#define HV_RING_SIZE 0x4000 /* 16KB ring buffer size */53 54unsigned char desc[HV_RING_SIZE];55 56static int target_fd;57static char target_fname[PATH_MAX];58static unsigned long long filesize;59 60static int hv_fcopy_create_file(char *file_name, char *path_name, __u32 flags)61{62 int error = HV_E_FAIL;63 char *q, *p;64 65 filesize = 0;66 p = path_name;67 snprintf(target_fname, sizeof(target_fname), "%s/%s",68 path_name, file_name);69 70 /*71 * Check to see if the path is already in place; if not,72 * create if required.73 */74 while ((q = strchr(p, '/')) != NULL) {75 if (q == p) {76 p++;77 continue;78 }79 *q = '\0';80 if (access(path_name, F_OK)) {81 if (flags & CREATE_PATH) {82 if (mkdir(path_name, 0755)) {83 syslog(LOG_ERR, "Failed to create %s",84 path_name);85 goto done;86 }87 } else {88 syslog(LOG_ERR, "Invalid path: %s", path_name);89 goto done;90 }91 }92 p = q + 1;93 *q = '/';94 }95 96 if (!access(target_fname, F_OK)) {97 syslog(LOG_INFO, "File: %s exists", target_fname);98 if (!(flags & OVER_WRITE)) {99 error = HV_ERROR_ALREADY_EXISTS;100 goto done;101 }102 }103 104 target_fd = open(target_fname,105 O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0744);106 if (target_fd == -1) {107 syslog(LOG_INFO, "Open Failed: %s", strerror(errno));108 goto done;109 }110 111 error = 0;112done:113 if (error)114 target_fname[0] = '\0';115 return error;116}117 118/* copy the data into the file */119static int hv_copy_data(struct hv_do_fcopy *cpmsg)120{121 ssize_t len;122 int ret = 0;123 124 len = pwrite(target_fd, cpmsg->data, cpmsg->size, cpmsg->offset);125 126 filesize += cpmsg->size;127 if (len != cpmsg->size) {128 switch (errno) {129 case ENOSPC:130 ret = HV_ERROR_DISK_FULL;131 break;132 default:133 ret = HV_E_FAIL;134 break;135 }136 syslog(LOG_ERR, "pwrite failed to write %llu bytes: %ld (%s)",137 filesize, (long)len, strerror(errno));138 }139 140 return ret;141}142 143static int hv_copy_finished(void)144{145 close(target_fd);146 target_fname[0] = '\0';147 148 return 0;149}150 151static void print_usage(char *argv[])152{153 fprintf(stderr, "Usage: %s [options]\n"154 "Options are:\n"155 " -n, --no-daemon stay in foreground, don't daemonize\n"156 " -h, --help print this help\n", argv[0]);157}158 159static bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, unsigned char *buf,160 unsigned int buflen, const int *fw_version, int fw_vercnt,161 const int *srv_version, int srv_vercnt,162 int *nego_fw_version, int *nego_srv_version)163{164 int icframe_major, icframe_minor;165 int icmsg_major, icmsg_minor;166 int fw_major, fw_minor;167 int srv_major, srv_minor;168 int i, j;169 bool found_match = false;170 struct icmsg_negotiate *negop;171 172 /* Check that there's enough space for icframe_vercnt, icmsg_vercnt */173 if (buflen < ICMSG_HDR + offsetof(struct icmsg_negotiate, reserved)) {174 syslog(LOG_ERR, "Invalid icmsg negotiate");175 return false;176 }177 178 icmsghdrp->icmsgsize = 0x10;179 negop = (struct icmsg_negotiate *)&buf[ICMSG_HDR];180 181 icframe_major = negop->icframe_vercnt;182 icframe_minor = 0;183 184 icmsg_major = negop->icmsg_vercnt;185 icmsg_minor = 0;186 187 /* Validate negop packet */188 if (icframe_major > IC_VERSION_NEGOTIATION_MAX_VER_COUNT ||189 icmsg_major > IC_VERSION_NEGOTIATION_MAX_VER_COUNT ||190 ICMSG_NEGOTIATE_PKT_SIZE(icframe_major, icmsg_major) > buflen) {191 syslog(LOG_ERR, "Invalid icmsg negotiate - icframe_major: %u, icmsg_major: %u\n",192 icframe_major, icmsg_major);193 goto fw_error;194 }195 196 /*197 * Select the framework version number we will198 * support.199 */200 201 for (i = 0; i < fw_vercnt; i++) {202 fw_major = (fw_version[i] >> 16);203 fw_minor = (fw_version[i] & 0xFFFF);204 205 for (j = 0; j < negop->icframe_vercnt; j++) {206 if (negop->icversion_data[j].major == fw_major &&207 negop->icversion_data[j].minor == fw_minor) {208 icframe_major = negop->icversion_data[j].major;209 icframe_minor = negop->icversion_data[j].minor;210 found_match = true;211 break;212 }213 }214 215 if (found_match)216 break;217 }218 219 if (!found_match)220 goto fw_error;221 222 found_match = false;223 224 for (i = 0; i < srv_vercnt; i++) {225 srv_major = (srv_version[i] >> 16);226 srv_minor = (srv_version[i] & 0xFFFF);227 228 for (j = negop->icframe_vercnt;229 (j < negop->icframe_vercnt + negop->icmsg_vercnt);230 j++) {231 if (negop->icversion_data[j].major == srv_major &&232 negop->icversion_data[j].minor == srv_minor) {233 icmsg_major = negop->icversion_data[j].major;234 icmsg_minor = negop->icversion_data[j].minor;235 found_match = true;236 break;237 }238 }239 240 if (found_match)241 break;242 }243 244 /*245 * Respond with the framework and service246 * version numbers we can support.247 */248fw_error:249 if (!found_match) {250 negop->icframe_vercnt = 0;251 negop->icmsg_vercnt = 0;252 } else {253 negop->icframe_vercnt = 1;254 negop->icmsg_vercnt = 1;255 }256 257 if (nego_fw_version)258 *nego_fw_version = (icframe_major << 16) | icframe_minor;259 260 if (nego_srv_version)261 *nego_srv_version = (icmsg_major << 16) | icmsg_minor;262 263 negop->icversion_data[0].major = icframe_major;264 negop->icversion_data[0].minor = icframe_minor;265 negop->icversion_data[1].major = icmsg_major;266 negop->icversion_data[1].minor = icmsg_minor;267 268 return found_match;269}270 271static void wcstoutf8(char *dest, const __u16 *src, size_t dest_size)272{273 size_t len = 0;274 275 while (len < dest_size) {276 if (src[len] < 0x80)277 dest[len++] = (char)(*src++);278 else279 dest[len++] = 'X';280 }281 282 dest[len] = '\0';283}284 285static int hv_fcopy_start(struct hv_start_fcopy *smsg_in)286{287 setlocale(LC_ALL, "en_US.utf8");288 size_t file_size, path_size;289 char *file_name, *path_name;290 char *in_file_name = (char *)smsg_in->file_name;291 char *in_path_name = (char *)smsg_in->path_name;292 293 file_size = wcstombs(NULL, (const wchar_t *restrict)in_file_name, 0) + 1;294 path_size = wcstombs(NULL, (const wchar_t *restrict)in_path_name, 0) + 1;295 296 file_name = (char *)malloc(file_size * sizeof(char));297 path_name = (char *)malloc(path_size * sizeof(char));298 299 if (!file_name || !path_name) {300 free(file_name);301 free(path_name);302 syslog(LOG_ERR, "Can't allocate memory for file name and/or path name");303 return HV_E_FAIL;304 }305 306 wcstoutf8(file_name, (__u16 *)in_file_name, file_size);307 wcstoutf8(path_name, (__u16 *)in_path_name, path_size);308 309 return hv_fcopy_create_file(file_name, path_name, smsg_in->copy_flags);310}311 312static int hv_fcopy_send_data(struct hv_fcopy_hdr *fcopy_msg, int recvlen)313{314 int operation = fcopy_msg->operation;315 316 /*317 * The strings sent from the host are encoded in318 * utf16; convert it to utf8 strings.319 * The host assures us that the utf16 strings will not exceed320 * the max lengths specified. We will however, reserve room321 * for the string terminating character - in the utf16s_utf8s()322 * function we limit the size of the buffer where the converted323 * string is placed to W_MAX_PATH -1 to guarantee324 * that the strings can be properly terminated!325 */326 327 switch (operation) {328 case START_FILE_COPY:329 return hv_fcopy_start((struct hv_start_fcopy *)fcopy_msg);330 case WRITE_TO_FILE:331 return hv_copy_data((struct hv_do_fcopy *)fcopy_msg);332 case COMPLETE_FCOPY:333 return hv_copy_finished();334 }335 336 return HV_E_FAIL;337}338 339/* process the packet recv from host */340static int fcopy_pkt_process(struct vmbus_br *txbr)341{342 int ret, offset, pktlen;343 int fcopy_srv_version;344 const struct vmbus_chanpkt_hdr *pkt;345 struct hv_fcopy_hdr *fcopy_msg;346 struct icmsg_hdr *icmsghdr;347 348 pkt = (const struct vmbus_chanpkt_hdr *)desc;349 offset = pkt->hlen << 3;350 pktlen = (pkt->tlen << 3) - offset;351 icmsghdr = (struct icmsg_hdr *)&desc[offset + sizeof(struct vmbuspipe_hdr)];352 icmsghdr->status = HV_E_FAIL;353 354 if (icmsghdr->icmsgtype == ICMSGTYPE_NEGOTIATE) {355 if (vmbus_prep_negotiate_resp(icmsghdr, desc + offset, pktlen, fw_versions,356 FW_VER_COUNT, fcopy_versions, FCOPY_VER_COUNT,357 NULL, &fcopy_srv_version)) {358 syslog(LOG_INFO, "FCopy IC version %d.%d",359 fcopy_srv_version >> 16, fcopy_srv_version & 0xFFFF);360 icmsghdr->status = 0;361 }362 } else if (icmsghdr->icmsgtype == ICMSGTYPE_FCOPY) {363 /* Ensure recvlen is big enough to contain hv_fcopy_hdr */364 if (pktlen < ICMSG_HDR + sizeof(struct hv_fcopy_hdr)) {365 syslog(LOG_ERR, "Invalid Fcopy hdr. Packet length too small: %u",366 pktlen);367 return -ENOBUFS;368 }369 370 fcopy_msg = (struct hv_fcopy_hdr *)&desc[offset + ICMSG_HDR];371 icmsghdr->status = hv_fcopy_send_data(fcopy_msg, pktlen);372 }373 374 icmsghdr->icflags = ICMSGHDRFLAG_TRANSACTION | ICMSGHDRFLAG_RESPONSE;375 ret = rte_vmbus_chan_send(txbr, 0x6, desc + offset, pktlen, 0);376 if (ret) {377 syslog(LOG_ERR, "Write to ringbuffer failed err: %d", ret);378 return ret;379 }380 381 return 0;382}383 384static void fcopy_get_first_folder(char *path, char *chan_no)385{386 DIR *dir = opendir(path);387 struct dirent *entry;388 389 if (!dir) {390 syslog(LOG_ERR, "Failed to open directory (errno=%s).\n", strerror(errno));391 return;392 }393 394 while ((entry = readdir(dir)) != NULL) {395 if (entry->d_type == DT_DIR && strcmp(entry->d_name, ".") != 0 &&396 strcmp(entry->d_name, "..") != 0) {397 strcpy(chan_no, entry->d_name);398 break;399 }400 }401 402 closedir(dir);403}404 405int main(int argc, char *argv[])406{407 int fcopy_fd = -1, tmp = 1;408 int daemonize = 1, long_index = 0, opt, ret = -EINVAL;409 struct vmbus_br txbr, rxbr;410 void *ring;411 uint32_t len = HV_RING_SIZE;412 char uio_name[MAX_FOLDER_NAME] = {0};413 char uio_dev_path[MAX_PATH_LEN] = {0};414 415 static struct option long_options[] = {416 {"help", no_argument, 0, 'h' },417 {"no-daemon", no_argument, 0, 'n' },418 {0, 0, 0, 0 }419 };420 421 while ((opt = getopt_long(argc, argv, "hn", long_options,422 &long_index)) != -1) {423 switch (opt) {424 case 'n':425 daemonize = 0;426 break;427 case 'h':428 default:429 print_usage(argv);430 goto exit;431 }432 }433 434 if (daemonize && daemon(1, 0)) {435 syslog(LOG_ERR, "daemon() failed; error: %s", strerror(errno));436 goto exit;437 }438 439 openlog("HV_UIO_FCOPY", 0, LOG_USER);440 syslog(LOG_INFO, "starting; pid is:%d", getpid());441 442 fcopy_get_first_folder(FCOPY_UIO, uio_name);443 snprintf(uio_dev_path, sizeof(uio_dev_path), "/dev/%s", uio_name);444 fcopy_fd = open(uio_dev_path, O_RDWR);445 446 if (fcopy_fd < 0) {447 syslog(LOG_ERR, "open %s failed; error: %d %s",448 uio_dev_path, errno, strerror(errno));449 ret = fcopy_fd;450 goto exit;451 }452 453 ring = vmbus_uio_map(&fcopy_fd, HV_RING_SIZE);454 if (!ring) {455 ret = errno;456 syslog(LOG_ERR, "mmap ringbuffer failed; error: %d %s", ret, strerror(ret));457 goto close;458 }459 vmbus_br_setup(&txbr, ring, HV_RING_SIZE);460 vmbus_br_setup(&rxbr, (char *)ring + HV_RING_SIZE, HV_RING_SIZE);461 462 rxbr.vbr->imask = 0;463 464 while (1) {465 /*466 * In this loop we process fcopy messages after the467 * handshake is complete.468 */469 ret = pread(fcopy_fd, &tmp, sizeof(int), 0);470 if (ret < 0) {471 syslog(LOG_ERR, "pread failed: %s", strerror(errno));472 continue;473 }474 475 len = HV_RING_SIZE;476 ret = rte_vmbus_chan_recv_raw(&rxbr, desc, &len);477 if (unlikely(ret <= 0)) {478 /* This indicates a failure to communicate (or worse) */479 syslog(LOG_ERR, "VMBus channel recv error: %d", ret);480 } else {481 ret = fcopy_pkt_process(&txbr);482 if (ret < 0)483 goto close;484 485 /* Signal host */486 if ((write(fcopy_fd, &tmp, sizeof(int))) != sizeof(int)) {487 ret = errno;488 syslog(LOG_ERR, "Signal to host failed: %s\n", strerror(ret));489 goto close;490 }491 }492 }493close:494 close(fcopy_fd);495exit:496 return ret;497}498