kernel/tools/virtio/virtio-trace/trace-agent-rw.c

   1 /*
   2  * Read/write thread of a guest agent for virtio-trace
   3  *
   4  * Copyright (C) 2012 Hitachi, Ltd.
   5  * Created by Yoshihiro Yunomae <yoshihiro.yunomae.ez@hitachi.com>
   6  *            Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
   7  *
   8  * Licensed under GPL version 2 only.
   9  *
  10  */
  11
  12 #define _GNU_SOURCE
  13 #include <fcntl.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <unistd.h>
  17 #include <sys/syscall.h>
  18 #include "trace-agent.h"
  19
  20 #define READ_WAIT_USEC  100000
  21
  22 void *rw_thread_info_new(void)
  23 {
  24         struct rw_thread_info *rw_ti;
  25
  26         rw_ti = zalloc(sizeof(struct rw_thread_info));
  27         if (rw_ti == NULL) {
  28                 pr_err("rw_thread_info zalloc error\n");
  29                 exit(EXIT_FAILURE);
  30         }
  31
  32         rw_ti->cpu_num = -1;
  33         rw_ti->in_fd = -1;
  34         rw_ti->out_fd = -1;
  35         rw_ti->read_pipe = -1;
  36         rw_ti->write_pipe = -1;
  37         rw_ti->pipe_size = PIPE_INIT;
  38
  39         return rw_ti;
  40 }
  41
  42 void *rw_thread_init(int cpu, const char *in_path, const char *out_path,
  43                                 bool stdout_flag, unsigned long pipe_size,
  44                                 struct rw_thread_info *rw_ti)
  45 {
  46         int data_pipe[2];
  47
  48         rw_ti->cpu_num = cpu;
  49
  50         /* set read(input) fd */
  51         rw_ti->in_fd = open(in_path, O_RDONLY);
  52         if (rw_ti->in_fd == -1) {
  53                 pr_err("Could not open in_fd (CPU:%d)\n", cpu);
  54                 goto error;
  55         }
  56
  57         /* set write(output) fd */
  58         if (!stdout_flag) {
  59                 /* virtio-serial output mode */
  60                 rw_ti->out_fd = open(out_path, O_WRONLY);
  61                 if (rw_ti->out_fd == -1) {
  62                         pr_err("Could not open out_fd (CPU:%d)\n", cpu);
  63                         goto error;
  64                 }
  65         } else
  66                 /* stdout mode */
  67                 rw_ti->out_fd = STDOUT_FILENO;
  68
  69         if (pipe2(data_pipe, O_NONBLOCK) < 0) {
  70                 pr_err("Could not create pipe in rw-thread(%d)\n", cpu);
  71                 goto error;
  72         }
  73
  74         /*
  75          * Size of pipe is 64kB in default based on fs/pipe.c.
  76          * To read/write trace data speedy, pipe size is changed.
  77          */
  78         if (fcntl(*data_pipe, F_SETPIPE_SZ, pipe_size) < 0) {
  79                 pr_err("Could not change pipe size in rw-thread(%d)\n", cpu);
  80                 goto error;
  81         }
  82
  83         rw_ti->read_pipe = data_pipe[1];
  84         rw_ti->write_pipe = data_pipe[0];
  85         rw_ti->pipe_size = pipe_size;
  86
  87         return NULL;
  88
  89 error:
  90         exit(EXIT_FAILURE);
  91 }
  92
  93 /* Bind a thread to a cpu */
  94 static void bind_cpu(int cpu_num)
  95 {
  96         cpu_set_t mask;
  97
  98         CPU_ZERO(&mask);
  99         CPU_SET(cpu_num, &mask);
 100
 101         /* bind my thread to cpu_num by assigning zero to the first argument */
 102         if (sched_setaffinity(0, sizeof(mask), &mask) == -1)
 103                 pr_err("Could not set CPU#%d affinity\n", (int)cpu_num);
 104 }
 105
 106 static void *rw_thread_main(void *thread_info)
 107 {
 108         ssize_t rlen, wlen;
 109         ssize_t ret;
 110         struct rw_thread_info *ts = (struct rw_thread_info *)thread_info;
 111
 112         bind_cpu(ts->cpu_num);
 113
 114         while (1) {
 115                 /* Wait for a read order of trace data by Host OS */
 116                 if (!global_run_operation) {
 117                         pthread_mutex_lock(&mutex_notify);
 118                         pthread_cond_wait(&cond_wakeup, &mutex_notify);
 119                         pthread_mutex_unlock(&mutex_notify);
 120                 }
 121
 122                 if (global_sig_receive)
 123                         break;
 124
 125                 /*
 126                  * Each thread read trace_pipe_raw of each cpu bounding the
 127                  * thread, so contention of multi-threads does not occur.
 128                  */
 129                 rlen = splice(ts->in_fd, NULL, ts->read_pipe, NULL,
 130                                 ts->pipe_size, SPLICE_F_MOVE | SPLICE_F_MORE);
 131
 132                 if (rlen < 0) {
 133                         pr_err("Splice_read in rw-thread(%d)\n", ts->cpu_num);
 134                         goto error;
 135                 } else if (rlen == 0) {
 136                         /*
 137                          * If trace data do not exist or are unreadable not
 138                          * for exceeding the page size, splice_read returns
 139                          * NULL. Then, this waits for being filled the data in a
 140                          * ring-buffer.
 141                          */
 142                         usleep(READ_WAIT_USEC);
 143                         pr_debug("Read retry(cpu:%d)\n", ts->cpu_num);
 144                         continue;
 145                 }
 146
 147                 wlen = 0;
 148
 149                 do {
 150                         ret = splice(ts->write_pipe, NULL, ts->out_fd, NULL,
 151                                         rlen - wlen,
 152                                         SPLICE_F_MOVE | SPLICE_F_MORE);
 153
 154                         if (ret < 0) {
 155                                 pr_err("Splice_write in rw-thread(%d)\n",
 156                                                                 ts->cpu_num);
 157                                 goto error;
 158                         } else if (ret == 0)
 159                                 /*
 160                                  * When host reader is not in time for reading
 161                                  * trace data, guest will be stopped. This is
 162                                  * because char dev in QEMU is not supported
 163                                  * non-blocking mode. Then, writer might be
 164                                  * sleep in that case.
 165                                  * This sleep will be removed by supporting
 166                                  * non-blocking mode.
 167                                  */
 168                                 sleep(1);
 169                         wlen += ret;
 170                 } while (wlen < rlen);
 171         }
 172
 173         return NULL;
 174
 175 error:
 176         exit(EXIT_FAILURE);
 177 }
 178
 179
 180 pthread_t rw_thread_run(struct rw_thread_info *rw_ti)
 181 {
 182         int ret;
 183         pthread_t rw_thread_per_cpu;
 184
 185         ret = pthread_create(&rw_thread_per_cpu, NULL, rw_thread_main, rw_ti);
 186         if (ret != 0) {
 187                 pr_err("Could not create a rw thread(%d)\n", rw_ti->cpu_num);
 188                 exit(EXIT_FAILURE);
 189         }
 190
 191         return rw_thread_per_cpu;
 192 }