source: rtems/cpukit/libmisc/redirector/stdio-redirect.c @ 2fd31117

5
Last change on this file since 2fd31117 was 2fd31117, checked in by Sebastian Huber <sebastian.huber@…>, on 01/09/18 at 05:13:32

stdio-redirector: Use self-contained mutex

Update #2843.

  • Property mode set to 100644
File size: 6.5 KB
Line 
1/*
2 * Copyright (C) 2014 Chris Johns (chrisj@rtems.org)
3 *
4 * The license and distribution terms for this file may be
5 * found in the file LICENSE in this distribution.
6 *
7 * This software with is provided ``as is'' and with NO WARRANTY.
8 */
9
10/*
11 * RTEMS std redirector.
12 */
13
14#include <errno.h>
15#include <stdio.h>
16#include <stdlib.h>
17#include <string.h>
18#include <strings.h>
19#include <sys/types.h>
20#include <unistd.h>
21
22#include <rtems/thread.h>
23#include <rtems/error.h>
24#include <rtems/stdio-redirect.h>
25
26#define RTEMS_STDIO_REDIRECT_RUNNING  (1 << 0)
27#define RTEMS_STDIO_REDIRECT_FINISHED (1 << 1)
28
29static void
30rtems_stdio_redirect_lock(rtems_stdio_redirect* sr)
31{
32  rtems_mutex_lock(&sr->lock);
33}
34
35static void
36rtems_stdio_redirect_unlock(rtems_stdio_redirect* sr)
37{
38  rtems_mutex_unlock(&sr->lock);
39}
40
41static void
42rtems_stdio_redirect_write (rtems_stdio_redirect* sr, const char* buf, ssize_t len)
43{
44  rtems_stdio_redirect_lock(sr);
45
46  if (sr->buffer)
47  {
48    if (len >= sr->buffer_size)
49    {
50      ssize_t offset = len - sr->buffer_size;
51      memcpy (sr->buffer, buf + offset, sr->buffer_size);
52      sr->in  = 0;
53      sr->full = true;
54    }
55    else
56    {
57      if ((sr->in + len) > sr->buffer_size)
58      {
59        ssize_t bytes = sr->buffer_size - sr->in;
60        memcpy (sr->buffer + sr->in, buf, bytes);
61        buf += bytes;
62        len -= bytes;
63        sr->in = 0;
64        sr->full = true;
65      }
66      else
67      {
68        memcpy (sr->buffer + sr->in, buf, len);
69        sr->in += len;
70      }
71    }
72  }
73
74  if (sr->handler)
75    sr->handler(buf, len);
76
77  rtems_stdio_redirect_unlock(sr);
78}
79
80static rtems_task
81rtems_stdio_redirect_reader(rtems_task_argument arg)
82{
83  rtems_stdio_redirect* sr = (rtems_stdio_redirect*) arg;
84
85  while (sr->state & RTEMS_STDIO_REDIRECT_RUNNING)
86  {
87    ssize_t r = read (sr->pipe[0], sr->input, sr->input_size);
88
89    if (r <= 0)
90      break;
91
92    if (sr->echo)
93      write (sr->fd_dup, sr->input, r);
94
95    rtems_stdio_redirect_write (sr, sr->input, r);
96  }
97
98  sr->state |= RTEMS_STDIO_REDIRECT_FINISHED;
99
100  rtems_task_delete(RTEMS_SELF);
101}
102
103rtems_stdio_redirect*
104rtems_stdio_redirect_open(int                          fd,
105                          rtems_task_priority          priority,
106                          size_t                       stack_size,
107                          ssize_t                      input_size,
108                          ssize_t                      buffer_size,
109                          bool                         echo,
110                          rtems_stdio_redirect_handler handler)
111{
112  rtems_stdio_redirect* sr;
113  rtems_name            name;
114  rtems_status_code     sc;
115
116  sr = malloc(sizeof(*sr));
117  if (!sr)
118  {
119    fprintf(stderr, "error: stdio-redirect: no memory\n");
120    return NULL;
121  }
122
123  memset(sr, 0, sizeof(*sr));
124
125  sr->input_size = input_size;
126  sr->input = malloc(input_size);
127  if (!sr->input)
128  {
129    fprintf(stderr, "error: stdio-redirect: no memory for input\n");
130    free(sr);
131    return NULL;
132  }
133
134  if (buffer_size)
135  {
136    sr->buffer_size = buffer_size;
137    sr->buffer = malloc(buffer_size);
138    if (!sr->buffer)
139    {
140      fprintf(stderr, "error: stdio-redirect: no memory for buffer\n");
141      free(sr->input);
142      free(sr);
143      return NULL;
144    }
145  }
146
147  sr->fd = fd;
148
149  sr->fd_dup = dup(fd);
150  if (sr->fd_dup < 0)
151  {
152    fprintf(stderr, "error: stdio-redirect: dup: %s\n", strerror(errno));
153    free(sr->buffer);
154    free(sr->input);
155    free(sr);
156    return NULL;
157  }
158
159  if (pipe(sr->pipe) < 0)
160  {
161    fprintf(stderr, "error: stdio-redirect: pipe create: %s\n", strerror(errno));
162    free(sr->buffer);
163    free(sr->input);
164    free(sr);
165    return NULL;
166
167  }
168
169  sr->echo = echo;
170  sr->handler = handler;
171
172  rtems_mutex_init(&sr->lock, "stdio-redirect");
173
174  name = rtems_build_name ('S', 'R', '0' + (fd / 10), '0' + (fd % 10));
175  sc = rtems_task_create (name,
176                          priority,
177                          stack_size,
178                          RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
179                          RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
180                          &sr->reader);
181  if (sc != RTEMS_SUCCESSFUL)
182  {
183    fprintf(stderr, "error: stdio-redirect: reader create: %s\n", rtems_status_text(sc));
184    rtems_mutex_destroy(&sr->lock);
185    free(sr->buffer);
186    free(sr->input);
187    free(sr);
188    return NULL;
189  }
190
191  sr->state |= RTEMS_STDIO_REDIRECT_RUNNING;
192
193  if (dup2 (sr->pipe[1], fd) < 0)
194  {
195    fprintf(stderr, "error: stdio-redirect: dup2: %s\n", strerror(errno));
196    free(sr->buffer);
197    free(sr->input);
198    free(sr);
199    return NULL;
200  }
201
202  sc = rtems_task_start (sr->reader,
203                         rtems_stdio_redirect_reader,
204                         (rtems_task_argument) sr);
205
206  if (sc != RTEMS_SUCCESSFUL)
207  {
208    fprintf(stderr, "error: stdio-redirect: reader start: %s\n", rtems_status_text(sc));
209    rtems_task_delete(sr->reader);
210    rtems_mutex_destroy(&sr->lock);
211    free(sr->buffer);
212    free(sr->input);
213    free(sr);
214    return NULL;
215  }
216
217  return sr;
218}
219
220void
221rtems_stdio_redirect_close(rtems_stdio_redirect* sr)
222{
223  rtems_stdio_redirect_lock(sr);
224
225  sr->state &= ~RTEMS_STDIO_REDIRECT_RUNNING;
226  close(sr->pipe[0]);
227
228  rtems_stdio_redirect_unlock(sr);
229
230  while (sr->state & RTEMS_STDIO_REDIRECT_FINISHED)
231  {
232    usleep(250UL * 1000000UL);
233  }
234
235  rtems_stdio_redirect_lock(sr);
236
237  dup2(sr->fd, sr->fd_dup);
238
239  free(sr->buffer);
240  free(sr->input);
241
242  rtems_stdio_redirect_unlock(sr);
243
244  rtems_mutex_destroy(&sr->lock);
245
246  free(sr);
247}
248
249ssize_t
250rtems_stdio_redirect_read(rtems_stdio_redirect* sr,
251                          char*                 buffer,
252                          ssize_t               length)
253{
254  ssize_t written = 0;
255
256  rtems_stdio_redirect_lock(sr);
257
258  if (sr->buffer)
259  {
260    ssize_t rem = 0;
261
262    if (sr->full)
263    {
264      if (length < sr->buffer_size)
265      {
266        if (length > sr->in)
267        {
268          rem = length - sr->in;
269          memcpy (buffer, sr->buffer + sr->buffer_size - rem, rem);
270        }
271
272        memcpy (buffer + rem, sr->buffer, sr->in);
273        written = length;
274      }
275      else
276      {
277        rem = sr->buffer_size - sr->in;
278        memcpy (buffer, sr->buffer + sr->in, rem);
279        memcpy (buffer + rem, sr->buffer, sr->in);
280        written = sr->buffer_size;
281      }
282
283      sr->full = false;
284    }
285    else if (length < sr->in)
286    {
287      rem = sr->in - length;
288      memcpy (buffer, sr->buffer + rem, length);
289      written = length;
290    }
291    else
292    {
293      memcpy (buffer, sr->buffer, sr->in);
294      written = sr->in;
295    }
296  }
297
298  rtems_stdio_redirect_unlock(sr);
299
300  return written;
301}
Note: See TracBrowser for help on using the repository browser.