tools/hv/hv_fcopy_uio_daemon.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   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     0
  32 #define ICMSGTYPE_FCOPY         7
  33
  34 #define WIN8_SRV_MAJOR          1
  35 #define WIN8_SRV_MINOR          1
  36 #define WIN8_SRV_VERSION        (WIN8_SRV_MAJOR << 16 | WIN8_SRV_MINOR)
  37
  38 #define MAX_FOLDER_NAME         15
  39 #define MAX_PATH_LEN            15
  40 #define FCOPY_UIO               "/sys/bus/vmbus/devices/eb765408-105f-49b6-b4aa-c123b64d17d4/uio"
  41
  42 #define FCOPY_VER_COUNT         1
  43 static const int fcopy_versions[] = {
  44         WIN8_SRV_VERSION
  45 };
  46
  47 #define FW_VER_COUNT            1
  48 static const int fw_versions[] = {
  49         UTIL_FW_VERSION
  50 };
  51
  52 #define HV_RING_SIZE            0x4000 /* 16KB ring buffer size */
  53
  54 unsigned char desc[HV_RING_SIZE];
  55
  56 static int target_fd;
  57 static char target_fname[PATH_MAX];
  58 static unsigned long long filesize;
  59
  60 static 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;
 112 done:
 113         if (error)
 114                 target_fname[0] = '\0';
 115         return error;
 116 }
 117
 118 /* copy the data into the file */
 119 static 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
 143 static int hv_copy_finished(void)
 144 {
 145         close(target_fd);
 146         target_fname[0] = '\0';
 147
 148         return 0;
 149 }
 150
 151 static 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
 159 static 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 will
 198          * 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 service
 246          * version numbers we can support.
 247          */
 248 fw_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
 271 static 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                 else
 279                         dest[len++] = 'X';
 280         }
 281
 282         dest[len] = '\0';
 283 }
 284
 285 static 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
 312 static 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 in
 318          * utf16; convert it to utf8 strings.
 319          * The host assures us that the utf16 strings will not exceed
 320          * the max lengths specified. We will however, reserve room
 321          * for the string terminating character - in the utf16s_utf8s()
 322          * function we limit the size of the buffer where the converted
 323          * string is placed to W_MAX_PATH -1 to guarantee
 324          * 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 */
 340 static 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
 384 static 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
 405 int 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 the
 467                  * 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         }
 493 close:
 494         close(fcopy_fd);
 495 exit:
 496         return ret;
 497 }