spelling fixes: arch/frv/
[linux-2.6] / arch / um / os-Linux / tty_log.c
1 /*
2  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com) and
3  * geoffrey hing <ghing@net.ohio-state.edu>
4  * Licensed under the GPL
5  */
6
7 #include <errno.h>
8 #include <string.h>
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <unistd.h>
12 #include <sys/time.h>
13 #include "init.h"
14 #include "user.h"
15 #include "kern_util.h"
16 #include "os.h"
17
18 #define TTY_LOG_DIR "./"
19
20 /* Set early in boot and then unchanged */
21 static char *tty_log_dir = TTY_LOG_DIR;
22 static int tty_log_fd = -1;
23
24 #define TTY_LOG_OPEN 1
25 #define TTY_LOG_CLOSE 2
26 #define TTY_LOG_WRITE 3
27 #define TTY_LOG_EXEC 4
28
29 #define TTY_READ 1
30 #define TTY_WRITE 2
31
32 struct tty_log_buf {
33         int what;
34         unsigned long tty;
35         int len;
36         int direction;
37         unsigned long sec;
38         unsigned long usec;
39 };
40
41 int open_tty_log(void *tty, void *current_tty)
42 {
43         struct timeval tv;
44         struct tty_log_buf data;
45         char buf[strlen(tty_log_dir) + sizeof("01234567890-01234567\0")];
46         int fd;
47
48         gettimeofday(&tv, NULL);
49         if(tty_log_fd != -1){
50                 data = ((struct tty_log_buf) { .what    = TTY_LOG_OPEN,
51                                                .tty  = (unsigned long) tty,
52                                                .len  = sizeof(current_tty),
53                                                .direction = 0,
54                                                .sec = tv.tv_sec,
55                                                .usec = tv.tv_usec } );
56                 write(tty_log_fd, &data, sizeof(data));
57                 write(tty_log_fd, &current_tty, data.len);
58                 return tty_log_fd;
59         }
60
61         sprintf(buf, "%s/%0u-%0u", tty_log_dir, (unsigned int) tv.tv_sec,
62                 (unsigned int) tv.tv_usec);
63
64         fd = os_open_file(buf, of_append(of_create(of_rdwr(OPENFLAGS()))),
65                           0644);
66         if(fd < 0){
67                 printk("open_tty_log : couldn't open '%s', errno = %d\n",
68                        buf, -fd);
69         }
70         return fd;
71 }
72
73 void close_tty_log(int fd, void *tty)
74 {
75         struct tty_log_buf data;
76         struct timeval tv;
77
78         if(tty_log_fd != -1){
79                 gettimeofday(&tv, NULL);
80                 data = ((struct tty_log_buf) { .what    = TTY_LOG_CLOSE,
81                                                .tty  = (unsigned long) tty,
82                                                .len  = 0,
83                                                .direction = 0,
84                                                .sec = tv.tv_sec,
85                                                .usec = tv.tv_usec } );
86                 write(tty_log_fd, &data, sizeof(data));
87                 return;
88         }
89         os_close_file(fd);
90 }
91
92 static int log_chunk(int fd, const char *buf, int len)
93 {
94         int total = 0, try, missed, n;
95         char chunk[64];
96
97         while(len > 0){
98                 try = (len > sizeof(chunk)) ? sizeof(chunk) : len;
99                 missed = copy_from_user_proc(chunk, (char *) buf, try);
100                 try -= missed;
101                 n = write(fd, chunk, try);
102                 if(n != try) {
103                         if(n < 0)
104                                 return -errno;
105                         return -EIO;
106                 }
107                 if(missed != 0)
108                         return -EFAULT;
109
110                 len -= try;
111                 total += try;
112                 buf += try;
113         }
114
115         return total;
116 }
117
118 int write_tty_log(int fd, const char *buf, int len, void *tty, int is_read)
119 {
120         struct timeval tv;
121         struct tty_log_buf data;
122         int direction;
123
124         if(fd == tty_log_fd){
125                 gettimeofday(&tv, NULL);
126                 direction = is_read ? TTY_READ : TTY_WRITE;
127                 data = ((struct tty_log_buf) { .what    = TTY_LOG_WRITE,
128                                                .tty  = (unsigned long) tty,
129                                                .len  = len,
130                                                .direction = direction,
131                                                .sec = tv.tv_sec,
132                                                .usec = tv.tv_usec } );
133                 write(tty_log_fd, &data, sizeof(data));
134         }
135
136         return log_chunk(fd, buf, len);
137 }
138
139 void log_exec(char **argv, void *tty)
140 {
141         struct timeval tv;
142         struct tty_log_buf data;
143         char **ptr,*arg;
144         int len;
145
146         if(tty_log_fd == -1) return;
147
148         gettimeofday(&tv, NULL);
149
150         len = 0;
151         for(ptr = argv; ; ptr++){
152                 if(copy_from_user_proc(&arg, ptr, sizeof(arg)))
153                         return;
154                 if(arg == NULL) break;
155                 len += strlen_user_proc(arg);
156         }
157
158         data = ((struct tty_log_buf) { .what    = TTY_LOG_EXEC,
159                                        .tty  = (unsigned long) tty,
160                                        .len  = len,
161                                        .direction = 0,
162                                        .sec = tv.tv_sec,
163                                        .usec = tv.tv_usec } );
164         write(tty_log_fd, &data, sizeof(data));
165
166         for(ptr = argv; ; ptr++){
167                 if(copy_from_user_proc(&arg, ptr, sizeof(arg)))
168                         return;
169                 if(arg == NULL) break;
170                 log_chunk(tty_log_fd, arg, strlen_user_proc(arg));
171         }
172 }
173
174 extern void register_tty_logger(int (*opener)(void *, void *),
175                                 int (*writer)(int, const char *, int,
176                                               void *, int),
177                                 void (*closer)(int, void *));
178
179 static int register_logger(void)
180 {
181         register_tty_logger(open_tty_log, write_tty_log, close_tty_log);
182         return 0;
183 }
184
185 __uml_initcall(register_logger);
186
187 static int __init set_tty_log_dir(char *name, int *add)
188 {
189         tty_log_dir = name;
190         return 0;
191 }
192
193 __uml_setup("tty_log_dir=", set_tty_log_dir,
194 "tty_log_dir=<directory>\n"
195 "    This is used to specify the directory where the logs of all pty\n"
196 "    data from this UML machine will be written.\n\n"
197 );
198
199 static int __init set_tty_log_fd(char *name, int *add)
200 {
201         char *end;
202
203         tty_log_fd = strtoul(name, &end, 0);
204         if((*end != '\0') || (end == name)){
205                 printf("set_tty_log_fd - strtoul failed on '%s'\n", name);
206                 tty_log_fd = -1;
207         }
208
209         *add = 0;
210         return 0;
211 }
212
213 __uml_setup("tty_log_fd=", set_tty_log_fd,
214 "tty_log_fd=<fd>\n"
215 "    This is used to specify a preconfigured file descriptor to which all\n"
216 "    tty data will be written.  Preconfigure the descriptor with something\n"
217 "    like '10>tty_log tty_log_fd=10'.\n\n"
218 );