에프에이리눅스 / 1611_0007_prime_oven

Blame view

kernel/linux-imx6_3.14.28/tools/virtio/virtio-trace/trace-agent-ctl.c 2.61 KB
edit raw normal view history
6b13f685e   김민수   BSP 최초 추가 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
  /*
   * Controller of read/write threads for virtio-trace
   *
   * Copyright (C) 2012 Hitachi, Ltd.
   * Created by Yoshihiro Yunomae <yoshihiro.yunomae.ez@hitachi.com>
   *            Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
   *
   * Licensed under GPL version 2 only.
   *
   */
  
  #define _GNU_SOURCE
  #include <fcntl.h>
  #include <poll.h>
  #include <signal.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <unistd.h>
  #include "trace-agent.h"
  
  #define HOST_MSG_SIZE		256
  #define EVENT_WAIT_MSEC		100
  
  static volatile sig_atomic_t global_signal_val;
  bool global_sig_receive;	/* default false */
  bool global_run_operation;	/* default false*/
  
  /* Handle SIGTERM/SIGINT/SIGQUIT to exit */
  static void signal_handler(int sig)
  {
  	global_signal_val = sig;
  }
  
  int rw_ctl_init(const char *ctl_path)
  {
  	int ctl_fd;
  
  	ctl_fd = open(ctl_path, O_RDONLY);
  	if (ctl_fd == -1) {
  		pr_err("Cannot open ctl_fd
  ");
  		goto error;
  	}
  
  	return ctl_fd;
  
  error:
  	exit(EXIT_FAILURE);
  }
  
  static int wait_order(int ctl_fd)
  {
  	struct pollfd poll_fd;
  	int ret = 0;
  
  	while (!global_sig_receive) {
  		poll_fd.fd = ctl_fd;
  		poll_fd.events = POLLIN;
  
  		ret = poll(&poll_fd, 1, EVENT_WAIT_MSEC);
  
  		if (global_signal_val) {
  			global_sig_receive = true;
  			pr_info("Receive interrupt %d
  ", global_signal_val);
  
  			/* Wakes rw-threads when they are sleeping */
  			if (!global_run_operation)
  				pthread_cond_broadcast(&cond_wakeup);
  
  			ret = -1;
  			break;
  		}
  
  		if (ret < 0) {
  			pr_err("Polling error
  ");
  			goto error;
  		}
  
  		if (ret)
  			break;
  	};
  
  	return ret;
  
  error:
  	exit(EXIT_FAILURE);
  }
  
  /*
   * contol read/write threads by handling global_run_operation
   */
  void *rw_ctl_loop(int ctl_fd)
  {
  	ssize_t rlen;
  	char buf[HOST_MSG_SIZE];
  	int ret;
  
  	/* Setup signal handlers */
  	signal(SIGTERM, signal_handler);
  	signal(SIGINT, signal_handler);
  	signal(SIGQUIT, signal_handler);
  
  	while (!global_sig_receive) {
  
  		ret = wait_order(ctl_fd);
  		if (ret < 0)
  			break;
  
  		rlen = read(ctl_fd, buf, sizeof(buf));
  		if (rlen < 0) {
  			pr_err("read data error in ctl thread
  ");
  			goto error;
  		}
  
  		if (rlen == 2 && buf[0] == '1') {
  			/*
  			 * If host writes '1' to a control path,
  			 * this controller wakes all read/write threads.
  			 */
  			global_run_operation = true;
  			pthread_cond_broadcast(&cond_wakeup);
  			pr_debug("Wake up all read/write threads
  ");
  		} else if (rlen == 2 && buf[0] == '0') {
  			/*
  			 * If host writes '0' to a control path, read/write
  			 * threads will wait for notification from Host.
  			 */
  			global_run_operation = false;
  			pr_debug("Stop all read/write threads
  ");
  		} else
  			pr_info("Invalid host notification: %s
  ", buf);
  	}
  
  	return NULL;
  
  error:
  	exit(EXIT_FAILURE);
  }