1
2
3
4
5
6
7
8
9
10
11
12#include <linux/types.h>
13#include <linux/errno.h>
14#include <linux/sched.h>
15#include <linux/kernel.h>
16#include <linux/poll.h>
17#include <linux/proc_fs.h>
18#include <linux/init.h>
19#include <linux/vmalloc.h>
20#include <linux/spinlock.h>
21#include <linux/cpu.h>
22#include <linux/delay.h>
23
24#include <asm/uaccess.h>
25#include <asm/io.h>
26#include <asm/rtas.h>
27#include <asm/prom.h>
28#include <asm/nvram.h>
29#include <asm/atomic.h>
30#include <asm/machdep.h>
31
32#if 0
33#define DEBUG(A...) printk(KERN_ERR A)
34#else
35#define DEBUG(A...)
36#endif
37
38static DEFINE_SPINLOCK(rtasd_log_lock);
39
40DECLARE_WAIT_QUEUE_HEAD(rtas_log_wait);
41
42static char *rtas_log_buf;
43static unsigned long rtas_log_start;
44static unsigned long rtas_log_size;
45
46static int surveillance_timeout = -1;
47static unsigned int rtas_error_log_max;
48static unsigned int rtas_error_log_buffer_max;
49
50
51static unsigned int event_scan;
52static unsigned int rtas_event_scan_rate;
53
54static int full_rtas_msgs = 0;
55
56
57static int logging_enabled;
58
59
60static int error_log_cnt;
61
62
63
64
65
66
67static unsigned char logdata[RTAS_ERROR_LOG_MAX];
68
69static char *rtas_type[] = {
70 "Unknown", "Retry", "TCE Error", "Internal Device Failure",
71 "Timeout", "Data Parity", "Address Parity", "Cache Parity",
72 "Address Invalid", "ECC Uncorrected", "ECC Corrupted",
73};
74
75static char *rtas_event_type(int type)
76{
77 if ((type > 0) && (type < 11))
78 return rtas_type[type];
79
80 switch (type) {
81 case RTAS_TYPE_EPOW:
82 return "EPOW";
83 case RTAS_TYPE_PLATFORM:
84 return "Platform Error";
85 case RTAS_TYPE_IO:
86 return "I/O Event";
87 case RTAS_TYPE_INFO:
88 return "Platform Information Event";
89 case RTAS_TYPE_DEALLOC:
90 return "Resource Deallocation Event";
91 case RTAS_TYPE_DUMP:
92 return "Dump Notification Event";
93 }
94
95 return rtas_type[0];
96}
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111static void printk_log_rtas(char *buf, int len)
112{
113
114 int i,j,n = 0;
115 int perline = 16;
116 char buffer[64];
117 char * str = "RTAS event";
118
119 if (full_rtas_msgs) {
120 printk(RTAS_DEBUG "%d -------- %s begin --------\n",
121 error_log_cnt, str);
122
123
124
125
126
127
128
129 for (i = 0; i < len; i++) {
130 j = i % perline;
131 if (j == 0) {
132 memset(buffer, 0, sizeof(buffer));
133 n = sprintf(buffer, "RTAS %d:", i/perline);
134 }
135
136 if ((i % 4) == 0)
137 n += sprintf(buffer+n, " ");
138
139 n += sprintf(buffer+n, "%02x", (unsigned char)buf[i]);
140
141 if (j == (perline-1))
142 printk(KERN_DEBUG "%s\n", buffer);
143 }
144 if ((i % perline) != 0)
145 printk(KERN_DEBUG "%s\n", buffer);
146
147 printk(RTAS_DEBUG "%d -------- %s end ----------\n",
148 error_log_cnt, str);
149 } else {
150 struct rtas_error_log *errlog = (struct rtas_error_log *)buf;
151
152 printk(RTAS_DEBUG "event: %d, Type: %s, Severity: %d\n",
153 error_log_cnt, rtas_event_type(errlog->type),
154 errlog->severity);
155 }
156}
157
158static int log_rtas_len(char * buf)
159{
160 int len;
161 struct rtas_error_log *err;
162
163
164 len = 8;
165 err = (struct rtas_error_log *)buf;
166 if (err->extended_log_length) {
167
168
169 len += err->extended_log_length;
170 }
171
172 if (rtas_error_log_max == 0)
173 rtas_error_log_max = rtas_get_error_log_max();
174
175 if (len > rtas_error_log_max)
176 len = rtas_error_log_max;
177
178 return len;
179}
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195void pSeries_log_error(char *buf, unsigned int err_type, int fatal)
196{
197 unsigned long offset;
198 unsigned long s;
199 int len = 0;
200
201 DEBUG("logging event\n");
202 if (buf == NULL)
203 return;
204
205 spin_lock_irqsave(&rtasd_log_lock, s);
206
207
208 switch (err_type & ERR_TYPE_MASK) {
209 case ERR_TYPE_RTAS_LOG:
210 len = log_rtas_len(buf);
211 if (!(err_type & ERR_FLAG_BOOT))
212 error_log_cnt++;
213 break;
214 case ERR_TYPE_KERNEL_PANIC:
215 default:
216 spin_unlock_irqrestore(&rtasd_log_lock, s);
217 return;
218 }
219
220
221 if (logging_enabled && !(err_type & ERR_FLAG_BOOT))
222 nvram_write_error_log(buf, len, err_type, error_log_cnt);
223
224
225
226
227
228
229 if ((err_type & ERR_TYPE_MASK) == ERR_TYPE_RTAS_LOG)
230 printk_log_rtas(buf, len);
231
232
233 if (fatal || !logging_enabled) {
234 logging_enabled = 0;
235 spin_unlock_irqrestore(&rtasd_log_lock, s);
236 return;
237 }
238
239
240 switch (err_type & ERR_TYPE_MASK) {
241 case ERR_TYPE_RTAS_LOG:
242 offset = rtas_error_log_buffer_max *
243 ((rtas_log_start+rtas_log_size) & LOG_NUMBER_MASK);
244
245
246 memcpy(&rtas_log_buf[offset], (void *) &error_log_cnt, sizeof(int));
247
248
249 offset += sizeof(int);
250 memcpy(&rtas_log_buf[offset], buf, len);
251
252 if (rtas_log_size < LOG_NUMBER)
253 rtas_log_size += 1;
254 else
255 rtas_log_start += 1;
256
257 spin_unlock_irqrestore(&rtasd_log_lock, s);
258 wake_up_interruptible(&rtas_log_wait);
259 break;
260 case ERR_TYPE_KERNEL_PANIC:
261 default:
262 spin_unlock_irqrestore(&rtasd_log_lock, s);
263 return;
264 }
265
266}
267
268
269static int rtas_log_open(struct inode * inode, struct file * file)
270{
271 return 0;
272}
273
274static int rtas_log_release(struct inode * inode, struct file * file)
275{
276 return 0;
277}
278
279
280
281
282
283static ssize_t rtas_log_read(struct file * file, char __user * buf,
284 size_t count, loff_t *ppos)
285{
286 int error;
287 char *tmp;
288 unsigned long s;
289 unsigned long offset;
290
291 if (!buf || count < rtas_error_log_buffer_max)
292 return -EINVAL;
293
294 count = rtas_error_log_buffer_max;
295
296 if (!access_ok(VERIFY_WRITE, buf, count))
297 return -EFAULT;
298
299 tmp = kmalloc(count, GFP_KERNEL);
300 if (!tmp)
301 return -ENOMEM;
302
303
304 spin_lock_irqsave(&rtasd_log_lock, s);
305
306 if (rtas_log_size == 0 && logging_enabled)
307 nvram_clear_error_log();
308 spin_unlock_irqrestore(&rtasd_log_lock, s);
309
310
311 error = wait_event_interruptible(rtas_log_wait, rtas_log_size);
312 if (error)
313 goto out;
314
315 spin_lock_irqsave(&rtasd_log_lock, s);
316 offset = rtas_error_log_buffer_max * (rtas_log_start & LOG_NUMBER_MASK);
317 memcpy(tmp, &rtas_log_buf[offset], count);
318
319 rtas_log_start += 1;
320 rtas_log_size -= 1;
321 spin_unlock_irqrestore(&rtasd_log_lock, s);
322
323 error = copy_to_user(buf, tmp, count) ? -EFAULT : count;
324out:
325 kfree(tmp);
326 return error;
327}
328
329static unsigned int rtas_log_poll(struct file *file, poll_table * wait)
330{
331 poll_wait(file, &rtas_log_wait, wait);
332 if (rtas_log_size)
333 return POLLIN | POLLRDNORM;
334 return 0;
335}
336
337const struct file_operations proc_rtas_log_operations = {
338 .read = rtas_log_read,
339 .poll = rtas_log_poll,
340 .open = rtas_log_open,
341 .release = rtas_log_release,
342};
343
344static int enable_surveillance(int timeout)
345{
346 int error;
347
348 error = rtas_set_indicator(SURVEILLANCE_TOKEN, 0, timeout);
349
350 if (error == 0)
351 return 0;
352
353 if (error == -EINVAL) {
354 printk(KERN_DEBUG "rtasd: surveillance not supported\n");
355 return 0;
356 }
357
358 printk(KERN_ERR "rtasd: could not update surveillance\n");
359 return -1;
360}
361
362static void do_event_scan(void)
363{
364 int error;
365 do {
366 memset(logdata, 0, rtas_error_log_max);
367 error = rtas_call(event_scan, 4, 1, NULL,
368 RTAS_EVENT_SCAN_ALL_EVENTS, 0,
369 __pa(logdata), rtas_error_log_max);
370 if (error == -1) {
371 printk(KERN_ERR "event-scan failed\n");
372 break;
373 }
374
375 if (error == 0)
376 pSeries_log_error(logdata, ERR_TYPE_RTAS_LOG, 0);
377
378 } while(error == 0);
379}
380
381static void do_event_scan_all_cpus(long delay)
382{
383 int cpu;
384
385 lock_cpu_hotplug();
386 cpu = first_cpu(cpu_online_map);
387 for (;;) {
388 set_cpus_allowed(current, cpumask_of_cpu(cpu));
389 do_event_scan();
390 set_cpus_allowed(current, CPU_MASK_ALL);
391
392
393 unlock_cpu_hotplug();
394 msleep_interruptible(delay);
395 lock_cpu_hotplug();
396
397 cpu = next_cpu(cpu, cpu_online_map);
398 if (cpu == NR_CPUS)
399 break;
400 }
401 unlock_cpu_hotplug();
402}
403
404static int rtasd(void *unused)
405{
406 unsigned int err_type;
407 int rc;
408
409 daemonize("rtasd");
410
411 printk(KERN_DEBUG "RTAS daemon started\n");
412 DEBUG("will sleep for %d milliseconds\n", (30000/rtas_event_scan_rate));
413
414
415 memset(logdata, 0, rtas_error_log_max);
416 rc = nvram_read_error_log(logdata, rtas_error_log_max,
417 &err_type, &error_log_cnt);
418
419 logging_enabled = 1;
420
421 if (!rc) {
422 if (err_type != ERR_FLAG_ALREADY_LOGGED) {
423 pSeries_log_error(logdata, err_type | ERR_FLAG_BOOT, 0);
424 }
425 }
426
427
428 do_event_scan_all_cpus(1000);
429
430 if (surveillance_timeout != -1) {
431 DEBUG("enabling surveillance\n");
432 enable_surveillance(surveillance_timeout);
433 DEBUG("surveillance enabled\n");
434 }
435
436
437
438
439 for (;;)
440 do_event_scan_all_cpus(30000/rtas_event_scan_rate);
441
442 return -EINVAL;
443}
444
445static int __init rtas_init(void)
446{
447 struct proc_dir_entry *entry;
448
449 if (!machine_is(pseries))
450 return 0;
451
452
453 event_scan = rtas_token("event-scan");
454 if (event_scan == RTAS_UNKNOWN_SERVICE) {
455 printk(KERN_DEBUG "rtasd: no event-scan on system\n");
456 return -ENODEV;
457 }
458
459 rtas_event_scan_rate = rtas_token("rtas-event-scan-rate");
460 if (rtas_event_scan_rate == RTAS_UNKNOWN_SERVICE) {
461 printk(KERN_ERR "rtasd: no rtas-event-scan-rate on system\n");
462 return -ENODEV;
463 }
464
465
466 rtas_error_log_max = rtas_get_error_log_max();
467 rtas_error_log_buffer_max = rtas_error_log_max + sizeof(int);
468
469 rtas_log_buf = vmalloc(rtas_error_log_buffer_max*LOG_NUMBER);
470 if (!rtas_log_buf) {
471 printk(KERN_ERR "rtasd: no memory\n");
472 return -ENOMEM;
473 }
474
475 entry = create_proc_entry("ppc64/rtas/error_log", S_IRUSR, NULL);
476 if (entry)
477 entry->proc_fops = &proc_rtas_log_operations;
478 else
479 printk(KERN_ERR "Failed to create error_log proc entry\n");
480
481 if (kernel_thread(rtasd, NULL, CLONE_FS) < 0)
482 printk(KERN_ERR "Failed to start RTAS daemon\n");
483
484 return 0;
485}
486
487static int __init surveillance_setup(char *str)
488{
489 int i;
490
491 if (get_option(&str,&i)) {
492 if (i >= 0 && i <= 255)
493 surveillance_timeout = i;
494 }
495
496 return 1;
497}
498
499static int __init rtasmsgs_setup(char *str)
500{
501 if (strcmp(str, "on") == 0)
502 full_rtas_msgs = 1;
503 else if (strcmp(str, "off") == 0)
504 full_rtas_msgs = 0;
505
506 return 1;
507}
508__initcall(rtas_init);
509__setup("surveillance=", surveillance_setup);
510__setup("rtasmsgs=", rtasmsgs_setup);
511