![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /*
2 * linux/kernel/printk.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
6 * Modified to make sys_syslog() more flexible: added commands to
7 * return the last 4k of kernel messages, regardless of whether
8 * they've been read or not. Added option to suppress kernel printk's
9 * to the console. Added hook for sending the console messages
10 * elsewhere, in preparation for a serial line console (someday).
11 * Ted Ts'o, 2/11/93.
12 */
13
14 #include <stdarg.h>
15
16 #include <asm/segment.h>
17 #include <asm/system.h>
18
19 #include <linux/errno.h>
20 #include <linux/sched.h>
21 #include <linux/kernel.h>
22 #include <linux/mm.h>
23 #include <linux/tty.h>
24 #include <linux/tty_driver.h>
25
26 #define LOG_BUF_LEN 4096
27
28 static char buf[1024];
29
30 extern void console_print(const char *);
31
32 /* printk's without a loglevel use this.. */
33 #define DEFAULT_MESSAGE_LOGLEVEL 5 /* KERN_NOTICE */
34
35 /* We show everything that is more important than this.. */
36 #define MINIMUM_CONSOLE_LOGLEVEL 6 /* Minimum loglevel we let people use */
37 #define DEFAULT_CONSOLE_LOGLEVEL 6 /* anything more serious than KERN_INFO */
38
39 unsigned long log_size = 0;
40 struct wait_queue * log_wait = NULL;
41 int console_loglevel = DEFAULT_CONSOLE_LOGLEVEL;
42
43 static void (*console_print_proc)(const char *) = 0;
44 static char log_buf[LOG_BUF_LEN];
45 static unsigned long log_start = 0;
46 static unsigned long logged_chars = 0;
47
48 /*
49 * Commands to sys_syslog:
50 *
51 * 0 -- Close the log. Currently a NOP.
52 * 1 -- Open the log. Currently a NOP.
53 * 2 -- Read from the log.
54 * 3 -- Read up to the last 4k of messages in the ring buffer.
55 * 4 -- Read and clear last 4k of messages in the ring buffer
56 * 5 -- Clear ring buffer.
57 * 6 -- Disable printk's to console
58 * 7 -- Enable printk's to console
59 * 8 -- Set level of messages printed to console
60 */
61 asmlinkage int sys_syslog(int type, char * buf, int len)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
62 {
63 unsigned long i, j, count;
64 int do_clear = 0;
65 char c;
66 int error;
67
68 if ((type != 3) && !suser())
69 return -EPERM;
70 switch (type) {
71 case 0: /* Close log */
72 return 0;
73 case 1: /* Open log */
74 return 0;
75 case 2: /* Read from log */
76 if (!buf || len < 0)
77 return -EINVAL;
78 if (!len)
79 return 0;
80 error = verify_area(VERIFY_WRITE,buf,len);
81 if (error)
82 return error;
83 cli();
84 while (!log_size) {
85 if (current->signal & ~current->blocked) {
86 sti();
87 return -ERESTARTSYS;
88 }
89 interruptible_sleep_on(&log_wait);
90 }
91 i = 0;
92 while (log_size && i < len) {
93 c = *((char *) log_buf+log_start);
94 log_start++;
95 log_size--;
96 log_start &= LOG_BUF_LEN-1;
97 sti();
98 put_user(c,buf);
99 buf++;
100 i++;
101 cli();
102 }
103 sti();
104 return i;
105 case 4: /* Read/clear last kernel messages */
106 do_clear = 1;
107 /* FALL THRU */
108 case 3: /* Read last kernel messages */
109 if (!buf || len < 0)
110 return -EINVAL;
111 if (!len)
112 return 0;
113 error = verify_area(VERIFY_WRITE,buf,len);
114 if (error)
115 return error;
116 count = len;
117 if (count > LOG_BUF_LEN)
118 count = LOG_BUF_LEN;
119 if (count > logged_chars)
120 count = logged_chars;
121 j = log_start + log_size - count;
122 for (i = 0; i < count; i++) {
123 c = *((char *) log_buf+(j++ & (LOG_BUF_LEN-1)));
124 put_user(c, buf++);
125 }
126 if (do_clear)
127 logged_chars = 0;
128 return i;
129 case 5: /* Clear ring buffer */
130 logged_chars = 0;
131 return 0;
132 case 6: /* Disable logging to console */
133 console_loglevel = MINIMUM_CONSOLE_LOGLEVEL;
134 return 0;
135 case 7: /* Enable logging to console */
136 console_loglevel = DEFAULT_CONSOLE_LOGLEVEL;
137 return 0;
138 case 8:
139 if (len < 1 || len > 8)
140 return -EINVAL;
141 if (len < MINIMUM_CONSOLE_LOGLEVEL)
142 len = MINIMUM_CONSOLE_LOGLEVEL;
143 console_loglevel = len;
144 return 0;
145 }
146 return -EINVAL;
147 }
148
149
150 asmlinkage int printk(const char *fmt, ...)
/* ![[previous]](../icons/left.png)
*/
151 {
152 va_list args;
153 int i;
154 char *msg, *p, *buf_end;
155 static char msg_level = -1;
156 long flags;
157
158 save_flags(flags);
159 cli();
160 va_start(args, fmt);
161 i = vsprintf(buf + 3, fmt, args); /* hopefully i < sizeof(buf)-4 */
162 buf_end = buf + 3 + i;
163 va_end(args);
164 for (p = buf + 3; p < buf_end; p++) {
165 msg = p;
166 if (msg_level < 0) {
167 if (
168 p[0] != '<' ||
169 p[1] < '0' ||
170 p[1] > '7' ||
171 p[2] != '>'
172 ) {
173 p -= 3;
174 p[0] = '<';
175 p[1] = DEFAULT_MESSAGE_LOGLEVEL + '0';
176 p[2] = '>';
177 } else
178 msg += 3;
179 msg_level = p[1] - '0';
180 }
181 for (; p < buf_end; p++) {
182 log_buf[(log_start+log_size) & (LOG_BUF_LEN-1)] = *p;
183 if (log_size < LOG_BUF_LEN)
184 log_size++;
185 else {
186 log_start++;
187 log_start &= LOG_BUF_LEN-1;
188 }
189 logged_chars++;
190 if (*p == '\n')
191 break;
192 }
193 if (msg_level < console_loglevel && console_print_proc) {
194 char tmp = p[1];
195 p[1] = '\0';
196 (*console_print_proc)(msg);
197 p[1] = tmp;
198 }
199 if (*p == '\n')
200 msg_level = -1;
201 }
202 restore_flags(flags);
203 wake_up_interruptible(&log_wait);
204 return i;
205 }
206
207 /*
208 * The console driver calls this routine during kernel initialization
209 * to register the console printing procedure with printk() and to
210 * print any messages that were printed by the kernel before the
211 * console driver was initialized.
212 */
213 void register_console(void (*proc)(const char *))
/* */
214 {
215 int i,j;
216 int p = log_start;
217 char buf[16];
218 char msg_level = -1;
219 char *q;
220
221 console_print_proc = proc;
222
223 for (i=0,j=0; i < log_size; i++) {
224 buf[j++] = log_buf[p];
225 p++; p &= LOG_BUF_LEN-1;
226 if (buf[j-1] != '\n' && i < log_size - 1 && j < sizeof(buf)-1)
227 continue;
228 buf[j] = 0;
229 q = buf;
230 if (msg_level < 0) {
231 msg_level = buf[1] - '0';
232 q = buf + 3;
233 }
234 if (msg_level < console_loglevel)
235 (*proc)(q);
236 if (buf[j-1] == '\n')
237 msg_level = -1;
238 j = 0;
239 }
240 }
241
242 /*
243 * Write a message to a certain tty, not just the console. This is used for
244 * messages that need to be redirected to a specific tty.
245 * We don't put it into the syslog queue right now maybe in the future if
246 * really needed.
247 */
248 void tty_write_message(struct tty_struct *tty, char *msg)
/* ![[last]](../icons/n_last.png)
*/
249 {
250 if (tty && tty->driver.write)
251 tty->driver.write(tty, 0, msg, strlen(msg));
252 return;
253 }
![[bottom]](../icons/n_bottom.png){kind=icon}
*/