~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/kernel/rtasd.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
  3  *
  4  * This program is free software; you can redistribute it and/or
  5  * modify it under the terms of the GNU General Public License
  6  * as published by the Free Software Foundation; either version
  7  * 2 of the License, or (at your option) any later version.
  8  *
  9  * Communication to userspace based on kernel/printk.c
 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/workqueue.h>
 23 #include <linux/slab.h>
 24 
 25 #include <asm/uaccess.h>
 26 #include <asm/io.h>
 27 #include <asm/rtas.h>
 28 #include <asm/prom.h>
 29 #include <asm/nvram.h>
 30 #include <linux/atomic.h>
 31 #include <asm/machdep.h>
 32 #include <asm/topology.h>
 33 
 34 
 35 static DEFINE_SPINLOCK(rtasd_log_lock);
 36 
 37 static DECLARE_WAIT_QUEUE_HEAD(rtas_log_wait);
 38 
 39 static char *rtas_log_buf;
 40 static unsigned long rtas_log_start;
 41 static unsigned long rtas_log_size;
 42 
 43 static int surveillance_timeout = -1;
 44 
 45 static unsigned int rtas_error_log_max;
 46 static unsigned int rtas_error_log_buffer_max;
 47 
 48 /* RTAS service tokens */
 49 static unsigned int event_scan;
 50 static unsigned int rtas_event_scan_rate;
 51 
 52 static bool full_rtas_msgs;
 53 
 54 /* Stop logging to nvram after first fatal error */
 55 static int logging_enabled; /* Until we initialize everything,
 56                              * make sure we don't try logging
 57                              * anything */
 58 static int error_log_cnt;
 59 
 60 /*
 61  * Since we use 32 bit RTAS, the physical address of this must be below
 62  * 4G or else bad things happen. Allocate this in the kernel data and
 63  * make it big enough.
 64  */
 65 static unsigned char logdata[RTAS_ERROR_LOG_MAX];
 66 
 67 static char *rtas_type[] = {
 68         "Unknown", "Retry", "TCE Error", "Internal Device Failure",
 69         "Timeout", "Data Parity", "Address Parity", "Cache Parity",
 70         "Address Invalid", "ECC Uncorrected", "ECC Corrupted",
 71 };
 72 
 73 static char *rtas_event_type(int type)
 74 {
 75         if ((type > 0) && (type < 11))
 76                 return rtas_type[type];
 77 
 78         switch (type) {
 79                 case RTAS_TYPE_EPOW:
 80                         return "EPOW";
 81                 case RTAS_TYPE_PLATFORM:
 82                         return "Platform Error";
 83                 case RTAS_TYPE_IO:
 84                         return "I/O Event";
 85                 case RTAS_TYPE_INFO:
 86                         return "Platform Information Event";
 87                 case RTAS_TYPE_DEALLOC:
 88                         return "Resource Deallocation Event";
 89                 case RTAS_TYPE_DUMP:
 90                         return "Dump Notification Event";
 91                 case RTAS_TYPE_PRRN:
 92                         return "Platform Resource Reassignment Event";
 93         }
 94 
 95         return rtas_type[0];
 96 }
 97 
 98 /* To see this info, grep RTAS /var/log/messages and each entry
 99  * will be collected together with obvious begin/end.
100  * There will be a unique identifier on the begin and end lines.
101  * This will persist across reboots.
102  *
103  * format of error logs returned from RTAS:
104  * bytes        (size)  : contents
105  * --------------------------------------------------------
106  * 0-7          (8)     : rtas_error_log
107  * 8-47         (40)    : extended info
108  * 48-51        (4)     : vendor id
109  * 52-1023 (vendor specific) : location code and debug data
110  */
111 static 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                  * Print perline bytes on each line, each line will start
125                  * with RTAS and a changing number, so syslogd will
126                  * print lines that are otherwise the same.  Separate every
127                  * 4 bytes with a space.
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(rtas_error_type(errlog)),
154                        rtas_error_severity(errlog));
155         }
156 }
157 
158 static int log_rtas_len(char * buf)
159 {
160         int len;
161         struct rtas_error_log *err;
162         uint32_t extended_log_length;
163 
164         /* rtas fixed header */
165         len = 8;
166         err = (struct rtas_error_log *)buf;
167         extended_log_length = rtas_error_extended_log_length(err);
168         if (rtas_error_extended(err) && extended_log_length) {
169 
170                 /* extended header */
171                 len += extended_log_length;
172         }
173 
174         if (rtas_error_log_max == 0)
175                 rtas_error_log_max = rtas_get_error_log_max();
176 
177         if (len > rtas_error_log_max)
178                 len = rtas_error_log_max;
179 
180         return len;
181 }
182 
183 /*
184  * First write to nvram, if fatal error, that is the only
185  * place we log the info.  The error will be picked up
186  * on the next reboot by rtasd.  If not fatal, run the
187  * method for the type of error.  Currently, only RTAS
188  * errors have methods implemented, but in the future
189  * there might be a need to store data in nvram before a
190  * call to panic().
191  *
192  * XXX We write to nvram periodically, to indicate error has
193  * been written and sync'd, but there is a possibility
194  * that if we don't shutdown correctly, a duplicate error
195  * record will be created on next reboot.
196  */
197 void pSeries_log_error(char *buf, unsigned int err_type, int fatal)
198 {
199         unsigned long offset;
200         unsigned long s;
201         int len = 0;
202 
203         pr_debug("rtasd: logging event\n");
204         if (buf == NULL)
205                 return;
206 
207         spin_lock_irqsave(&rtasd_log_lock, s);
208 
209         /* get length and increase count */
210         switch (err_type & ERR_TYPE_MASK) {
211         case ERR_TYPE_RTAS_LOG:
212                 len = log_rtas_len(buf);
213                 if (!(err_type & ERR_FLAG_BOOT))
214                         error_log_cnt++;
215                 break;
216         case ERR_TYPE_KERNEL_PANIC:
217         default:
218                 WARN_ON_ONCE(!irqs_disabled()); /* @@@ DEBUG @@@ */
219                 spin_unlock_irqrestore(&rtasd_log_lock, s);
220                 return;
221         }
222 
223 #ifdef CONFIG_PPC64
224         /* Write error to NVRAM */
225         if (logging_enabled && !(err_type & ERR_FLAG_BOOT))
226                 nvram_write_error_log(buf, len, err_type, error_log_cnt);
227 #endif /* CONFIG_PPC64 */
228 
229         /*
230          * rtas errors can occur during boot, and we do want to capture
231          * those somewhere, even if nvram isn't ready (why not?), and even
232          * if rtasd isn't ready. Put them into the boot log, at least.
233          */
234         if ((err_type & ERR_TYPE_MASK) == ERR_TYPE_RTAS_LOG)
235                 printk_log_rtas(buf, len);
236 
237         /* Check to see if we need to or have stopped logging */
238         if (fatal || !logging_enabled) {
239                 logging_enabled = 0;
240                 WARN_ON_ONCE(!irqs_disabled()); /* @@@ DEBUG @@@ */
241                 spin_unlock_irqrestore(&rtasd_log_lock, s);
242                 return;
243         }
244 
245         /* call type specific method for error */
246         switch (err_type & ERR_TYPE_MASK) {
247         case ERR_TYPE_RTAS_LOG:
248                 offset = rtas_error_log_buffer_max *
249                         ((rtas_log_start+rtas_log_size) & LOG_NUMBER_MASK);
250 
251                 /* First copy over sequence number */
252                 memcpy(&rtas_log_buf[offset], (void *) &error_log_cnt, sizeof(int));
253 
254                 /* Second copy over error log data */
255                 offset += sizeof(int);
256                 memcpy(&rtas_log_buf[offset], buf, len);
257 
258                 if (rtas_log_size < LOG_NUMBER)
259                         rtas_log_size += 1;
260                 else
261                         rtas_log_start += 1;
262 
263                 WARN_ON_ONCE(!irqs_disabled()); /* @@@ DEBUG @@@ */
264                 spin_unlock_irqrestore(&rtasd_log_lock, s);
265                 wake_up_interruptible(&rtas_log_wait);
266                 break;
267         case ERR_TYPE_KERNEL_PANIC:
268         default:
269                 WARN_ON_ONCE(!irqs_disabled()); /* @@@ DEBUG @@@ */
270                 spin_unlock_irqrestore(&rtasd_log_lock, s);
271                 return;
272         }
273 }
274 
275 #ifdef CONFIG_PPC_PSERIES
276 static s32 prrn_update_scope;
277 
278 static void prrn_work_fn(struct work_struct *work)
279 {
280         /*
281          * For PRRN, we must pass the negative of the scope value in
282          * the RTAS event.
283          */
284         pseries_devicetree_update(-prrn_update_scope);
285 }
286 
287 static DECLARE_WORK(prrn_work, prrn_work_fn);
288 
289 static void prrn_schedule_update(u32 scope)
290 {
291         flush_work(&prrn_work);
292         prrn_update_scope = scope;
293         schedule_work(&prrn_work);
294 }
295 
296 static void handle_rtas_event(const struct rtas_error_log *log)
297 {
298         if (rtas_error_type(log) != RTAS_TYPE_PRRN || !prrn_is_enabled())
299                 return;
300 
301         /* For PRRN Events the extended log length is used to denote
302          * the scope for calling rtas update-nodes.
303          */
304         prrn_schedule_update(rtas_error_extended_log_length(log));
305 }
306 
307 #else
308 
309 static void handle_rtas_event(const struct rtas_error_log *log)
310 {
311         return;
312 }
313 
314 #endif
315 
316 static int rtas_log_open(struct inode * inode, struct file * file)
317 {
318         return 0;
319 }
320 
321 static int rtas_log_release(struct inode * inode, struct file * file)
322 {
323         return 0;
324 }
325 
326 /* This will check if all events are logged, if they are then, we
327  * know that we can safely clear the events in NVRAM.
328  * Next we'll sit and wait for something else to log.
329  */
330 static ssize_t rtas_log_read(struct file * file, char __user * buf,
331                          size_t count, loff_t *ppos)
332 {
333         int error;
334         char *tmp;
335         unsigned long s;
336         unsigned long offset;
337 
338         if (!buf || count < rtas_error_log_buffer_max)
339                 return -EINVAL;
340 
341         count = rtas_error_log_buffer_max;
342 
343         if (!access_ok(VERIFY_WRITE, buf, count))
344                 return -EFAULT;
345 
346         tmp = kmalloc(count, GFP_KERNEL);
347         if (!tmp)
348                 return -ENOMEM;
349 
350         spin_lock_irqsave(&rtasd_log_lock, s);
351 
352         /* if it's 0, then we know we got the last one (the one in NVRAM) */
353         while (rtas_log_size == 0) {
354                 if (file->f_flags & O_NONBLOCK) {
355                         spin_unlock_irqrestore(&rtasd_log_lock, s);
356                         error = -EAGAIN;
357                         goto out;
358                 }
359 
360                 if (!logging_enabled) {
361                         spin_unlock_irqrestore(&rtasd_log_lock, s);
362                         error = -ENODATA;
363                         goto out;
364                 }
365 #ifdef CONFIG_PPC64
366                 nvram_clear_error_log();
367 #endif /* CONFIG_PPC64 */
368 
369                 spin_unlock_irqrestore(&rtasd_log_lock, s);
370                 error = wait_event_interruptible(rtas_log_wait, rtas_log_size);
371                 if (error)
372                         goto out;
373                 spin_lock_irqsave(&rtasd_log_lock, s);
374         }
375 
376         offset = rtas_error_log_buffer_max * (rtas_log_start & LOG_NUMBER_MASK);
377         memcpy(tmp, &rtas_log_buf[offset], count);
378 
379         rtas_log_start += 1;
380         rtas_log_size -= 1;
381         spin_unlock_irqrestore(&rtasd_log_lock, s);
382 
383         error = copy_to_user(buf, tmp, count) ? -EFAULT : count;
384 out:
385         kfree(tmp);
386         return error;
387 }
388 
389 static unsigned int rtas_log_poll(struct file *file, poll_table * wait)
390 {
391         poll_wait(file, &rtas_log_wait, wait);
392         if (rtas_log_size)
393                 return POLLIN | POLLRDNORM;
394         return 0;
395 }
396 
397 static const struct file_operations proc_rtas_log_operations = {
398         .read =         rtas_log_read,
399         .poll =         rtas_log_poll,
400         .open =         rtas_log_open,
401         .release =      rtas_log_release,
402         .llseek =       noop_llseek,
403 };
404 
405 static int enable_surveillance(int timeout)
406 {
407         int error;
408 
409         error = rtas_set_indicator(SURVEILLANCE_TOKEN, 0, timeout);
410 
411         if (error == 0)
412                 return 0;
413 
414         if (error == -EINVAL) {
415                 printk(KERN_DEBUG "rtasd: surveillance not supported\n");
416                 return 0;
417         }
418 
419         printk(KERN_ERR "rtasd: could not update surveillance\n");
420         return -1;
421 }
422 
423 static void do_event_scan(void)
424 {
425         int error;
426         do {
427                 memset(logdata, 0, rtas_error_log_max);
428                 error = rtas_call(event_scan, 4, 1, NULL,
429                                   RTAS_EVENT_SCAN_ALL_EVENTS, 0,
430                                   __pa(logdata), rtas_error_log_max);
431                 if (error == -1) {
432                         printk(KERN_ERR "event-scan failed\n");
433                         break;
434                 }
435 
436                 if (error == 0) {
437                         pSeries_log_error(logdata, ERR_TYPE_RTAS_LOG, 0);
438                         handle_rtas_event((struct rtas_error_log *)logdata);
439                 }
440 
441         } while(error == 0);
442 }
443 
444 static void rtas_event_scan(struct work_struct *w);
445 static DECLARE_DELAYED_WORK(event_scan_work, rtas_event_scan);
446 
447 /*
448  * Delay should be at least one second since some machines have problems if
449  * we call event-scan too quickly.
450  */
451 static unsigned long event_scan_delay = 1*HZ;
452 static int first_pass = 1;
453 
454 static void rtas_event_scan(struct work_struct *w)
455 {
456         unsigned int cpu;
457 
458         do_event_scan();
459 
460         get_online_cpus();
461 
462         /* raw_ OK because just using CPU as starting point. */
463         cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask);
464         if (cpu >= nr_cpu_ids) {
465                 cpu = cpumask_first(cpu_online_mask);
466 
467                 if (first_pass) {
468                         first_pass = 0;
469                         event_scan_delay = 30*HZ/rtas_event_scan_rate;
470 
471                         if (surveillance_timeout != -1) {
472                                 pr_debug("rtasd: enabling surveillance\n");
473                                 enable_surveillance(surveillance_timeout);
474                                 pr_debug("rtasd: surveillance enabled\n");
475                         }
476                 }
477         }
478 
479         schedule_delayed_work_on(cpu, &event_scan_work,
480                 __round_jiffies_relative(event_scan_delay, cpu));
481 
482         put_online_cpus();
483 }
484 
485 #ifdef CONFIG_PPC64
486 static void retrieve_nvram_error_log(void)
487 {
488         unsigned int err_type ;
489         int rc ;
490 
491         /* See if we have any error stored in NVRAM */
492         memset(logdata, 0, rtas_error_log_max);
493         rc = nvram_read_error_log(logdata, rtas_error_log_max,
494                                   &err_type, &error_log_cnt);
495         /* We can use rtas_log_buf now */
496         logging_enabled = 1;
497         if (!rc) {
498                 if (err_type != ERR_FLAG_ALREADY_LOGGED) {
499                         pSeries_log_error(logdata, err_type | ERR_FLAG_BOOT, 0);
500                 }
501         }
502 }
503 #else /* CONFIG_PPC64 */
504 static void retrieve_nvram_error_log(void)
505 {
506 }
507 #endif /* CONFIG_PPC64 */
508 
509 static void start_event_scan(void)
510 {
511         printk(KERN_DEBUG "RTAS daemon started\n");
512         pr_debug("rtasd: will sleep for %d milliseconds\n",
513                  (30000 / rtas_event_scan_rate));
514 
515         /* Retrieve errors from nvram if any */
516         retrieve_nvram_error_log();
517 
518         schedule_delayed_work_on(cpumask_first(cpu_online_mask),
519                                  &event_scan_work, event_scan_delay);
520 }
521 
522 /* Cancel the rtas event scan work */
523 void rtas_cancel_event_scan(void)
524 {
525         cancel_delayed_work_sync(&event_scan_work);
526 }
527 EXPORT_SYMBOL_GPL(rtas_cancel_event_scan);
528 
529 static int __init rtas_event_scan_init(void)
530 {
531         if (!machine_is(pseries) && !machine_is(chrp))
532                 return 0;
533 
534         /* No RTAS */
535         event_scan = rtas_token("event-scan");
536         if (event_scan == RTAS_UNKNOWN_SERVICE) {
537                 printk(KERN_INFO "rtasd: No event-scan on system\n");
538                 return -ENODEV;
539         }
540 
541         rtas_event_scan_rate = rtas_token("rtas-event-scan-rate");
542         if (rtas_event_scan_rate == RTAS_UNKNOWN_SERVICE) {
543                 printk(KERN_ERR "rtasd: no rtas-event-scan-rate on system\n");
544                 return -ENODEV;
545         }
546 
547         if (!rtas_event_scan_rate) {
548                 /* Broken firmware: take a rate of zero to mean don't scan */
549                 printk(KERN_DEBUG "rtasd: scan rate is 0, not scanning\n");
550                 return 0;
551         }
552 
553         /* Make room for the sequence number */
554         rtas_error_log_max = rtas_get_error_log_max();
555         rtas_error_log_buffer_max = rtas_error_log_max + sizeof(int);
556 
557         rtas_log_buf = vmalloc(rtas_error_log_buffer_max*LOG_NUMBER);
558         if (!rtas_log_buf) {
559                 printk(KERN_ERR "rtasd: no memory\n");
560                 return -ENOMEM;
561         }
562 
563         start_event_scan();
564 
565         return 0;
566 }
567 arch_initcall(rtas_event_scan_init);
568 
569 static int __init rtas_init(void)
570 {
571         struct proc_dir_entry *entry;
572 
573         if (!machine_is(pseries) && !machine_is(chrp))
574                 return 0;
575 
576         if (!rtas_log_buf)
577                 return -ENODEV;
578 
579         entry = proc_create("powerpc/rtas/error_log", S_IRUSR, NULL,
580                             &proc_rtas_log_operations);
581         if (!entry)
582                 printk(KERN_ERR "Failed to create error_log proc entry\n");
583 
584         return 0;
585 }
586 __initcall(rtas_init);
587 
588 static int __init surveillance_setup(char *str)
589 {
590         int i;
591 
592         /* We only do surveillance on pseries */
593         if (!machine_is(pseries))
594                 return 0;
595 
596         if (get_option(&str,&i)) {
597                 if (i >= 0 && i <= 255)
598                         surveillance_timeout = i;
599         }
600 
601         return 1;
602 }
603 __setup("surveillance=", surveillance_setup);
604 
605 static int __init rtasmsgs_setup(char *str)
606 {
607         return (kstrtobool(str, &full_rtas_msgs) == 0);
608 }
609 __setup("rtasmsgs=", rtasmsgs_setup);
610 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp