开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
rtasd.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：28k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

rtasd.c：源码内容
  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.  */
  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>
  21. #include <asm/uaccess.h>
  22. #include <asm/io.h>
  23. #include <asm/rtas.h>
  24. #include <asm/prom.h>
  26. #if 0
  27. #define DEBUG(A...) printk(KERN_ERR A)
  28. #else
  29. #define DEBUG(A...)
  30. #endif
  32. static spinlock_t rtas_log_lock = SPIN_LOCK_UNLOCKED;
  34. DECLARE_WAIT_QUEUE_HEAD(rtas_log_wait);
  36. #define LOG_NUMBER 64 /* must be a power of two */
  37. #define LOG_NUMBER_MASK (LOG_NUMBER-1)
  39. static char *rtas_log_buf;
  40. static unsigned long rtas_log_start;
  41. static unsigned long rtas_log_size;
  43. static int surveillance_requested;
  44. static unsigned int rtas_event_scan_rate;
  45. static unsigned int rtas_error_log_max;
  47. #define EVENT_SCAN_ALL_EVENTS 0xf0000000
  48. #define SURVEILLANCE_TOKEN 9000
  49. #define SURVEILLANCE_TIMEOUT 1
  50. #define SURVEILLANCE_SCANRATE 1
  52. /*
  53.  * Since we use 32 bit RTAS, the physical address of this must be below
  54.  * 4G or else bad things happen. Allocate this in the kernel data and
  55.  * make it big enough.
  56.  */
  57. #define RTAS_ERROR_LOG_MAX 1024
  58. static unsigned char logdata[RTAS_ERROR_LOG_MAX];
  60. static int rtas_log_open(struct inode * inode, struct file * file)
  61. {
  62. return 0;
  63. }
  65. static int rtas_log_release(struct inode * inode, struct file * file)
  66. {
  67. return 0;
  68. }
  70. static ssize_t rtas_log_read(struct file * file, char * buf,
  71.  size_t count, loff_t *ppos)
  72. {
  73. int error;
  74. char *tmp;
  75. unsigned long offset;
  77. if (!buf || count < rtas_error_log_max)
  78. return -EINVAL;
  80. count = rtas_error_log_max;
  82. error = verify_area(VERIFY_WRITE, buf, count);
  83. if (error)
  84. return -EINVAL;
  86. tmp = kmalloc(rtas_error_log_max, GFP_KERNEL);
  87. if (!tmp)
  88. return -ENOMEM;
  90. error = wait_event_interruptible(rtas_log_wait, rtas_log_size);
  91. if (error)
  92. goto out;
  94. spin_lock(&rtas_log_lock);
  95. offset = rtas_error_log_max * (rtas_log_start & LOG_NUMBER_MASK);
  96. memcpy(tmp, &rtas_log_buf[offset], count);
  97. rtas_log_start += 1;
  98. rtas_log_size -= 1;
  99. spin_unlock(&rtas_log_lock);
  101. error = copy_to_user(buf, tmp, count) ? -EFAULT : count;
  102. out:
  103. kfree(tmp);
  104. return error;
  105. }
  107. static unsigned int rtas_log_poll(struct file *file, poll_table * wait)
  108. {
  109. poll_wait(file, &rtas_log_wait, wait);
  110. if (rtas_log_size)
  111. return POLLIN | POLLRDNORM;
  112. return 0;
  113. }
  115. struct file_operations proc_rtas_log_operations = {
  116. read: rtas_log_read,
  117. poll: rtas_log_poll,
  118. open: rtas_log_open,
  119. release: rtas_log_release,
  120. };
  123. #define RTAS_ERR KERN_ERR "RTAS: "
  125. /* Extended error log header (12 bytes) */
  126. struct exthdr {
  127. unsigned int valid:1;
  128. unsigned int unrecoverable:1;
  129. unsigned int recoverable:1;
  130. unsigned int unrecoverable_bypassed:1; /* i.e. degraded performance */
  131. unsigned int predictive:1;
  132. unsigned int newlog:1;
  133. unsigned int bigendian:1; /* always 1 */
  134. unsigned int /* reserved */:1;
  136. unsigned int platform_specific:1; /* only in version 3+ */
  137. unsigned int /* reserved */:3;
  138. unsigned int platform_value:4; /* valid iff platform_specific */
  140. unsigned int power_pc:1; /* always 1 */
  141. unsigned int /* reserved */:2;
  142. unsigned int addr_invalid:1; /* failing_address is invalid */
  143. unsigned int format_type:4;
  144. #define EXTLOG_FMT_CPU 1
  145. #define EXTLOG_FMT_MEMORY 2
  146. #define EXTLOG_FMT_IO 3
  147. #define EXTLOG_FMT_POST 4
  148. #define EXTLOG_FMT_ENV 5
  149. #define EXTLOG_FMT_POW 6
  150. #define EXTLOG_FMT_IBMDIAG 12
  151. #define EXTLOG_FMT_IBMSP 13
  153. /* This group is in version 3+ only */
  154. unsigned int non_hardware:1; /* Firmware or software is suspect */
  155. unsigned int hot_plug:1; /* Failing component may be hot plugged */
  156. unsigned int group_failure:1; /* Group of components should be replaced */
  157. unsigned int /* reserved */:1;
  159. unsigned int residual:1; /* Residual error from previous boot (maybe a crash) */
  160. unsigned int boot:1; /* Error during boot */
  161. unsigned int config_change:1; /* Configuration changed since last boot */
  162. unsigned int post:1; /* Error during POST */
  164. unsigned int bcdtime:32; /* Time of error in BCD HHMMSS00 */
  165. unsigned int bcddate:32; /* Time of error in BCD YYYYMMDD */
  166. };
  168. struct cpuhdr {
  169. unsigned int internal:1;
  170. unsigned int intcache:1;
  171. unsigned int extcache_parity:1; /* or multi-bit ECC */
  172. unsigned int extcache_ecc:1;
  173. unsigned int sysbus_timeout:1;
  174. unsigned int io_timeout:1;
  175. unsigned int sysbus_parity:1;
  176. unsigned int sysbus_protocol:1;
  177. unsigned int cpuid:8;
  178. unsigned int element:16;
  179. unsigned int failing_address_hi:32;
  180. unsigned int failing_address_lo:32;
  182. /* These are version 4+ */
  183. unsigned int try_reboot:1; /* 1 => fault may be fixed by reboot */
  184. unsigned int /* reserved */:7;
  185. /* 15 bytes reserved here */
  186. };
  188. struct memhdr {
  189. unsigned int uncorrectable:1;
  190. unsigned int ECC:1;
  191. unsigned int threshold_exceeded:1;
  192. unsigned int control_internal:1;
  193. unsigned int bad_address:1;
  194. unsigned int bad_data:1;
  195. unsigned int bus:1;
  196. unsigned int timeout:1;
  197. unsigned int sysbus_parity:1;
  198. unsigned int sysbus_timeout:1;
  199. unsigned int sysbus_protocol:1;
  200. unsigned int hostbridge_timeout:1;
  201. unsigned int hostbridge_parity:1;
  202. unsigned int reserved1:1;
  203. unsigned int support:1;
  204. unsigned int sysbus_internal:1;
  205. unsigned int mem_controller_detected:8; /* who detected fault? */
  206. unsigned int mem_controller_faulted:8; /* who caused fault? */
  207. unsigned int failing_address_hi:32;
  208. unsigned int failing_address_lo:32;
  209. unsigned int ecc_syndrome:16;
  210. unsigned int memory_card:8;
  211. unsigned int reserved2:8;
  212. unsigned int sub_elements:32; /* one bit per element */
  213. unsigned int element:16;
  214. };
  216. struct iohdr {
  217. unsigned int bus_addr_parity:1;
  218. unsigned int bus_data_parity:1;
  219. unsigned int bus_timeout:1;
  220. unsigned int bridge_internal:1;
  221. unsigned int non_pci:1; /* i.e. secondary bus such as ISA */
  222. unsigned int mezzanine_addr_parity:1;
  223. unsigned int mezzanine_data_parity:1;
  224. unsigned int mezzanine_timeout:1;
  226. unsigned int bridge_via_sysbus:1;
  227. unsigned int bridge_via_mezzanine:1;
  228. unsigned int bridge_via_expbus:1;
  229. unsigned int detected_by_expbus:1;
  230. unsigned int expbus_data_parity:1;
  231. unsigned int expbus_timeout:1;
  232. unsigned int expbus_connection_failure:1;
  233. unsigned int expbus_not_operating:1;
  235. /* IOA signalling the error */
  236. unsigned int pci_sig_busno:8;
  237. unsigned int pci_sig_devfn:8;
  238. unsigned int pci_sig_deviceid:16;
  239. unsigned int pci_sig_vendorid:16;
  240. unsigned int pci_sig_revisionid:8;
  241. unsigned int pci_sig_slot:8; /* 00 => system board, ff => multiple */
  243. /* IOA sending at time of error */
  244. unsigned int pci_send_busno:8;
  245. unsigned int pci_send_devfn:8;
  246. unsigned int pci_send_deviceid:16;
  247. unsigned int pci_send_vendorid:16;
  248. unsigned int pci_send_revisionid:8;
  249. unsigned int pci_send_slot:8; /* 00 => system board, ff => multiple */
  250. };
  252. struct posthdr {
  253. unsigned int firmware:1;
  254. unsigned int config:1;
  255. unsigned int cpu:1;
  256. unsigned int memory:1;
  257. unsigned int io:1;
  258. unsigned int keyboard:1;
  259. unsigned int mouse:1;
  260. unsigned int display:1;
  262. unsigned int ipl_floppy:1;
  263. unsigned int ipl_controller:1;
  264. unsigned int ipl_cdrom:1;
  265. unsigned int ipl_disk:1;
  266. unsigned int ipl_net:1;
  267. unsigned int ipl_other:1;
  268. unsigned int /* reserved */:1;
  269. unsigned int firmware_selftest:1;
  271. char         devname[12];
  272. unsigned int post_code:4;
  273. unsigned int firmware_rev:2;
  274. unsigned int loc_code:8; /* currently unused */
  275. };
  277. struct epowhdr {
  278. unsigned int epow_sensor_value:32;
  279. unsigned int sensor:1;
  280. unsigned int power_fault:1;
  281. unsigned int fan:1;
  282. unsigned int temp:1;
  283. unsigned int redundancy:1;
  284. unsigned int CUoD:1;
  285. unsigned int /* reserved */:2;
  287. unsigned int general:1;
  288. unsigned int power_loss:1;
  289. unsigned int power_supply:1;
  290. unsigned int power_switch:1;
  291. unsigned int /* reserved */:4;
  293. unsigned int /* reserved */:16;
  294. unsigned int sensor_token:32;
  295. unsigned int sensor_index:32;
  296. unsigned int sensor_value:32;
  297. unsigned int sensor_status:32;
  298. };
  300. struct pm_eventhdr {
  301. unsigned int event_id:32;
  302. };
  304. struct sphdr {
  305. unsigned int ibm:32; /* "IBM" */
  307. unsigned int timeout:1;
  308. unsigned int i2c_bus:1;
  309. unsigned int i2c_secondary_bus:1;
  310. unsigned int sp_memory:1;
  311. unsigned int sp_registers:1;
  312. unsigned int sp_communication:1;
  313. unsigned int sp_firmware:1;
  314. unsigned int sp_hardware:1;
  316. unsigned int vpd_eeprom:1;
  317. unsigned int op_panel:1;
  318. unsigned int power_controller:1;
  319. unsigned int fan_sensor:1;
  320. unsigned int thermal_sensor:1;
  321. unsigned int voltage_sensor:1;
  322. unsigned int reserved1:2;
  324. unsigned int serial_port:1;
  325. unsigned int nvram:1;
  326. unsigned int rtc:1;
  327. unsigned int jtag:1;
  328. unsigned int tod_battery:1;
  329. unsigned int reserved2:1;
  330. unsigned int heartbeat:1;
  331. unsigned int surveillance:1;
  333. unsigned int pcn_connection:1; /* power control network */
  334. unsigned int pcn_node:1;
  335. unsigned int reserved3:2;
  336. unsigned int pcn_access:1;
  337. unsigned int reserved:3;
  339. unsigned int sensor_token:32; /* zero if undef */
  340. unsigned int sensor_index:32; /* zero if undef */
  341. };
  344. static char *severity_names[] = {
  345. "NO ERROR", "EVENT", "WARNING", "ERROR_SYNC", "ERROR", "FATAL", "(6)", "(7)"
  346. };
  347. static char *rtas_disposition_names[] = {
  348. "FULLY RECOVERED", "LIMITED RECOVERY", "NOT RECOVERED", "(4)"
  349. };
  350. static char *entity_names[] = { /* for initiator & targets */
  351. "UNKNOWN", "CPU", "PCI", "ISA", "MEMORY", "POWER MANAGEMENT", "HOT PLUG", "(7)", "(8)",
  352. "(9)", "(10)", "(11)", "(12)", "(13)", "(14)", "(15)"
  353. };
  354. static char *error_type[] = { /* Not all types covered here so need to bounds check */
  355. "UNKNOWN", "RETRY", "TCE_ERR", "INTERN_DEV_FAIL",
  356. "TIMEOUT", "DATA_PARITY", "ADDR_PARITY", "CACHE_PARITY",
  357. "ADDR_INVALID", "ECC_UNCORR", "ECC_CORR",
  358. };
  360. static char *rtas_error_type(int type)
  361. {
  362. if (type < 11)
  363. return error_type[type];
  364. if (type == 64)
  365. return "SENSOR";
  366. if (type >=96 && type <= 159)
  367. return "POWER";
  368. return error_type[0];
  369. }
  371. static void printk_cpu_failure(int version, struct exthdr *exthdr, char *data)
  372. {
  373. struct cpuhdr cpuhdr;
  375. memcpy(&cpuhdr, data, sizeof(cpuhdr));
  377. if (cpuhdr.internal) printk(RTAS_ERR "Internal error (not cache)n");
  378. if (cpuhdr.intcache) printk(RTAS_ERR "Internal cachen");
  379. if (cpuhdr.extcache_parity) printk(RTAS_ERR "External cache parity (or multi-bit)n");
  380. if (cpuhdr.extcache_ecc) printk(RTAS_ERR "External cache ECCn");
  381. if (cpuhdr.sysbus_timeout) printk(RTAS_ERR "System bus timeoutn");
  382. if (cpuhdr.io_timeout) printk(RTAS_ERR "I/O timeoutn");
  383. if (cpuhdr.sysbus_parity) printk(RTAS_ERR "System bus parityn");
  384. if (cpuhdr.sysbus_protocol) printk(RTAS_ERR "System bus protocol/transfern");
  385. printk(RTAS_ERR "CPU id: %dn", cpuhdr.cpuid);
  386. printk(RTAS_ERR "Failing element: 0x%04xn", cpuhdr.element);
  387. if (!exthdr->addr_invalid)
  388. printk(RTAS_ERR "Failing address: %08x%08xn", cpuhdr.failing_address_hi, cpuhdr.failing_address_lo);
  389. if (version >= 4 && cpuhdr.try_reboot)
  390. printk(RTAS_ERR "A reboot of the system may correct the problemn");
  391. }
  393. static void printk_mem_failure(int version, struct exthdr *exthdr, char *data)
  394. {
  395. struct memhdr memhdr;
  397. memcpy(&memhdr, data, sizeof(memhdr));
  398. if (memhdr.uncorrectable) printk(RTAS_ERR "Uncorrectable Memory errorn");
  399. if (memhdr.ECC) printk(RTAS_ERR "ECC Correctable errorn");
  400. if (memhdr.threshold_exceeded) printk(RTAS_ERR "Correctable threshold exceededn");
  401. if (memhdr.control_internal) printk(RTAS_ERR "Memory Controller internal errorn");
  402. if (memhdr.bad_address) printk(RTAS_ERR "Memory Address errorn");
  403. if (memhdr.bad_data) printk(RTAS_ERR "Memory Data errorn");
  404. if (memhdr.bus) printk(RTAS_ERR "Memory bus/switch internal errorn");
  405. if (memhdr.timeout) printk(RTAS_ERR "Memory timeoutn");
  406. if (memhdr.sysbus_parity) printk(RTAS_ERR "System bus parityn");
  407. if (memhdr.sysbus_timeout) printk(RTAS_ERR "System bus timeoutn");
  408. if (memhdr.sysbus_protocol) printk(RTAS_ERR "System bus protocol/transfern");
  409. if (memhdr.hostbridge_timeout) printk(RTAS_ERR "I/O Host Bridge timeoutn");
  410. if (memhdr.hostbridge_parity) printk(RTAS_ERR "I/O Host Bridge parityn");
  411. if (memhdr.support) printk(RTAS_ERR "System support function errorn");
  412. if (memhdr.sysbus_internal) printk(RTAS_ERR "System bus internal hardware/switch errorn");
  413. printk(RTAS_ERR "Memory Controller that detected failure: %dn", memhdr.mem_controller_detected);
  414. printk(RTAS_ERR "Memory Controller that faulted: %dn", memhdr.mem_controller_faulted);
  415. if (!exthdr->addr_invalid)
  416. printk(RTAS_ERR "Failing address: 0x%016x%016xn", memhdr.failing_address_hi, memhdr.failing_address_lo);
  417. printk(RTAS_ERR "ECC syndrome bits: 0x%04xn", memhdr.ecc_syndrome);
  418. printk(RTAS_ERR "Memory Card: %dn", memhdr.memory_card);
  419. printk(RTAS_ERR "Failing element: 0x%04xn", memhdr.element);
  420. printk(RTAS_ERR "Sub element bits: 0x%08xn", memhdr.sub_elements);
  421. }
  423. static void printk_io_failure(int version, struct exthdr *exthdr, char *data)
  424. {
  425. struct iohdr iohdr;
  427. memcpy(&iohdr, data, sizeof(iohdr));
  428. if (iohdr.bus_addr_parity) printk(RTAS_ERR "I/O bus address parityn");
  429. if (iohdr.bus_data_parity) printk(RTAS_ERR "I/O bus data parityn");
  430. if (iohdr.bus_timeout) printk(RTAS_ERR "I/O bus timeout, access or othern");
  431. if (iohdr.bridge_internal) printk(RTAS_ERR "I/O bus bridge/device internaln");
  432. if (iohdr.non_pci) printk(RTAS_ERR "Signaling IOA is a PCI to non-PCI bridge (e.g. ISA)n");
  433. if (iohdr.mezzanine_addr_parity) printk(RTAS_ERR "Mezzanine/System bus address parityn");
  434. if (iohdr.mezzanine_data_parity) printk(RTAS_ERR "Mezzanine/System bus data parityn");
  435. if (iohdr.mezzanine_timeout) printk(RTAS_ERR "Mezzanine/System bus timeout, transfer or protocoln");
  436. if (iohdr.bridge_via_sysbus) printk(RTAS_ERR "Bridge is connected to system busn");
  437. if (iohdr.bridge_via_mezzanine) printk(RTAS_ERR "Bridge is connected to memory controller via mezzanine busn");
  438. if (iohdr.bridge_via_expbus) printk(RTAS_ERR "Bridge is connected to I/O expansion busn");
  439. if (iohdr.detected_by_expbus) printk(RTAS_ERR "Error on system bus detected by I/O expansion bus controllern");
  440. if (iohdr.expbus_data_parity) printk(RTAS_ERR "I/O expansion bus data errorn");
  441. if (iohdr.expbus_timeout) printk(RTAS_ERR "I/O expansion bus timeout, access or othern");
  442. if (iohdr.expbus_connection_failure) printk(RTAS_ERR "I/O expansion bus connection failuren");
  443. if (iohdr.expbus_not_operating) printk(RTAS_ERR "I/O expansion unit not in an operating state (powered off, off-line)n");
  445. printk(RTAS_ERR "IOA Signaling the error: %d:%d.%d vendor:%04x device:%04x rev:%02x slot:%dn",
  446.        iohdr.pci_sig_busno, iohdr.pci_sig_devfn >> 3, iohdr.pci_sig_devfn & 0x7,
  447.        iohdr.pci_sig_vendorid, iohdr.pci_sig_deviceid, iohdr.pci_sig_revisionid, iohdr.pci_sig_slot);
  448. printk(RTAS_ERR "IOA Sending during the error: %d:%d.%d vendor:%04x device:%04x rev:%02x slot:%dn",
  449.        iohdr.pci_send_busno, iohdr.pci_send_devfn >> 3, iohdr.pci_send_devfn & 0x7,
  450.        iohdr.pci_send_vendorid, iohdr.pci_send_deviceid, iohdr.pci_send_revisionid, iohdr.pci_send_slot);
  452. }
  454. static void printk_post_failure(int version, struct exthdr *exthdr, char *data)
  455. {
  456. struct posthdr posthdr;
  458. memcpy(&posthdr, data, sizeof(posthdr));
  460. if (posthdr.devname[0]) printk(RTAS_ERR "Failing Device: %sn", posthdr.devname);
  461. if (posthdr.firmware) printk(RTAS_ERR "Firmware Errorn");
  462. if (posthdr.config) printk(RTAS_ERR "Configuration Errorn");
  463. if (posthdr.cpu) printk(RTAS_ERR "CPU POST Errorn");
  464. if (posthdr.memory) printk(RTAS_ERR "Memory POST Errorn");
  465. if (posthdr.io) printk(RTAS_ERR "I/O Subsystem POST Errorn");
  466. if (posthdr.keyboard) printk(RTAS_ERR "Keyboard POST Errorn");
  467. if (posthdr.mouse) printk(RTAS_ERR "Mouse POST Errorn");
  468. if (posthdr.display) printk(RTAS_ERR "Display POST Errorn");
  470. if (posthdr.ipl_floppy) printk(RTAS_ERR "Floppy IPL Errorn");
  471. if (posthdr.ipl_controller) printk(RTAS_ERR "Drive Controller Error during IPLn");
  472. if (posthdr.ipl_cdrom) printk(RTAS_ERR "CDROM IPL Errorn");
  473. if (posthdr.ipl_disk) printk(RTAS_ERR "Disk IPL Errorn");
  474. if (posthdr.ipl_net) printk(RTAS_ERR "Network IPL Errorn");
  475. if (posthdr.ipl_other) printk(RTAS_ERR "Other (tape,flash) IPL Errorn");
  476. if (posthdr.firmware_selftest) printk(RTAS_ERR "Self-test error in firmware extended diagnosticsn");
  477. printk(RTAS_ERR "POST Code: %dn", posthdr.post_code);
  478. printk(RTAS_ERR "Firmware Revision Code: %dn", posthdr.firmware_rev);
  479. }
  481. static void printk_epow_warning(int version, struct exthdr *exthdr, char *data)
  482. {
  483. struct epowhdr epowhdr;
  485. memcpy(&epowhdr, data, sizeof(epowhdr));
  486. printk(RTAS_ERR "EPOW Sensor Value:  0x%08xn", epowhdr.epow_sensor_value); 
  487. if (epowhdr.sensor) {
  488. printk(RTAS_ERR "EPOW detected by a sensorn");
  489. printk(RTAS_ERR "Sensor Token:  0x%08xn", epowhdr.sensor_token); 
  490. printk(RTAS_ERR "Sensor Index:  0x%08xn", epowhdr.sensor_index); 
  491. printk(RTAS_ERR "Sensor Value:  0x%08xn", epowhdr.sensor_value); 
  492. printk(RTAS_ERR "Sensor Status: 0x%08xn", epowhdr.sensor_status);
  493. }
  494. if (epowhdr.power_fault) printk(RTAS_ERR "EPOW caused by a power faultn");
  495. if (epowhdr.fan) printk(RTAS_ERR "EPOW caused by fan failuren");
  496. if (epowhdr.temp) printk(RTAS_ERR "EPOW caused by over-temperature conditionn");
  497. if (epowhdr.redundancy) printk(RTAS_ERR "EPOW warning due to loss of redundancyn");
  498. if (epowhdr.CUoD) printk(RTAS_ERR "EPOW warning due to CUoD Entitlement Exceededn");
  500. if (epowhdr.general) printk(RTAS_ERR "EPOW general power faultn");
  501. if (epowhdr.power_loss) printk(RTAS_ERR "EPOW power fault due to loss of power sourcen");
  502. if (epowhdr.power_supply) printk(RTAS_ERR "EPOW power fault due to internal power supply failuren");
  503. if (epowhdr.power_switch) printk(RTAS_ERR "EPOW power fault due to activation of power switchn");
  504. }
  506. static void printk_pm_event(int version, struct exthdr *exthdr, char *data)
  507. {
  508. struct pm_eventhdr pm_eventhdr;
  510. memcpy(&pm_eventhdr, data, sizeof(pm_eventhdr));
  511. printk(RTAS_ERR "Event id: 0x%08xn", pm_eventhdr.event_id);
  512. }
  514. static void printk_sp_log_msg(int version, struct exthdr *exthdr, char *data)
  515. {
  516. struct sphdr sphdr;
  517. u32 eyecatcher;
  519. memcpy(&sphdr, data, sizeof(sphdr));
  521. eyecatcher = sphdr.ibm;
  522. if (strcmp((char *)&eyecatcher, "IBM") != 0)
  523. printk(RTAS_ERR "This log entry may be corrupt (IBM signature malformed)n");
  524. if (sphdr.timeout) printk(RTAS_ERR "Timeout on communication response from service processorn");
  525. if (sphdr.i2c_bus) printk(RTAS_ERR "I2C general bus errorn");
  526. if (sphdr.i2c_secondary_bus) printk(RTAS_ERR "I2C secondary bus errorn");
  527. if (sphdr.sp_memory) printk(RTAS_ERR "Internal service processor memory errorn");
  528. if (sphdr.sp_registers) printk(RTAS_ERR "Service processor error accessing special registersn");
  529. if (sphdr.sp_communication) printk(RTAS_ERR "Service processor reports unknown communcation errorn");
  530. if (sphdr.sp_firmware) printk(RTAS_ERR "Internal service processor firmware errorn");
  531. if (sphdr.sp_hardware) printk(RTAS_ERR "Other internal service processor hardware errorn");
  532. if (sphdr.vpd_eeprom) printk(RTAS_ERR "Service processor error accessing VPD EEPROMn");
  533. if (sphdr.op_panel) printk(RTAS_ERR "Service processor error accessing Operator Paneln");
  534. if (sphdr.power_controller) printk(RTAS_ERR "Service processor error accessing Power Controllern");
  535. if (sphdr.fan_sensor) printk(RTAS_ERR "Service processor error accessing Fan Sensorn");
  536. if (sphdr.thermal_sensor) printk(RTAS_ERR "Service processor error accessing Thermal Sensorn");
  537. if (sphdr.voltage_sensor) printk(RTAS_ERR "Service processor error accessing Voltage Sensorn");
  538. if (sphdr.serial_port) printk(RTAS_ERR "Service processor error accessing serial portn");
  539. if (sphdr.nvram) printk(RTAS_ERR "Service processor detected NVRAM errorn");
  540. if (sphdr.rtc) printk(RTAS_ERR "Service processor error accessing real time clockn");
  541. if (sphdr.jtag) printk(RTAS_ERR "Service processor error accessing JTAG/COPn");
  542. if (sphdr.tod_battery) printk(RTAS_ERR "Service processor or RTAS detects loss of voltage from TOD batteryn");
  543. if (sphdr.heartbeat) printk(RTAS_ERR "Loss of heartbeat from Service processorn");
  544. if (sphdr.surveillance) printk(RTAS_ERR "Service processor detected a surveillance timeoutn");
  545. if (sphdr.pcn_connection) printk(RTAS_ERR "Power Control Network general connection failuren");
  546. if (sphdr.pcn_node) printk(RTAS_ERR "Power Control Network node failuren");
  547. if (sphdr.pcn_access) printk(RTAS_ERR "Service processor error accessing Power Control Networkn");
  549. if (sphdr.sensor_token) printk(RTAS_ERR "Sensor Token 0x%08x (%d)n", sphdr.sensor_token, sphdr.sensor_token);
  550. if (sphdr.sensor_index) printk(RTAS_ERR "Sensor Index 0x%08x (%d)n", sphdr.sensor_index, sphdr.sensor_index);
  551. }
  554. static void printk_ext_raw_data(char *data)
  555. {
  556. int i;
  557. printk(RTAS_ERR "raw ext data: ");
  558. for (i = 0; i < 40; i++) {
  559. printk("%02x", data[i]);
  560. }
  561. printk("n");
  562. }
  564. static void printk_ext_log_data(int version, char *buf)
  565. {
  566. char *data = buf+12;
  567. struct exthdr exthdr;
  568. memcpy(&exthdr, buf, sizeof(exthdr)); /* copy for alignment */
  569. if (!exthdr.valid) {
  570. if (exthdr.bigendian && exthdr.power_pc)
  571. printk(RTAS_ERR "extended log data is not validn");
  572. else
  573. printk(RTAS_ERR "extended log data can not be decodedn");
  574. return;
  575. }
  577. /* Dump useful stuff in the exthdr */
  578. printk(RTAS_ERR "Status:%s%s%s%s%sn",
  579.        exthdr.unrecoverable ? " unrecoverable" : "",
  580.        exthdr.recoverable ? " recoverable" : "",
  581.        exthdr.unrecoverable_bypassed ? " bypassed" : "",
  582.        exthdr.predictive ? " predictive" : "",
  583.        exthdr.newlog ? " new" : "");
  584. printk(RTAS_ERR "Date/Time: %08x %08xn", exthdr.bcddate, exthdr.bcdtime);
  585. switch (exthdr.format_type) {
  586.     case EXTLOG_FMT_CPU:
  587. printk(RTAS_ERR "CPU Failuren");
  588. printk_cpu_failure(version, &exthdr, data);
  589. break;
  590.     case EXTLOG_FMT_MEMORY:
  591. printk(RTAS_ERR "Memory Failuren");
  592. printk_mem_failure(version, &exthdr, data);
  593. break;
  594.     case EXTLOG_FMT_IO:
  595. printk(RTAS_ERR "I/O Failuren");
  596. printk_io_failure(version, &exthdr, data);
  597. break;
  598.     case EXTLOG_FMT_POST:
  599. printk(RTAS_ERR "POST Failuren");
  600. printk_post_failure(version, &exthdr, data);
  601. break;
  602.     case EXTLOG_FMT_ENV:
  603. printk(RTAS_ERR "Environment and Power Warningn");
  604. printk_epow_warning(version, &exthdr, data);
  605. break;
  606.     case EXTLOG_FMT_POW:
  607. printk(RTAS_ERR "Power Management Eventn");
  608. printk_pm_event(version, &exthdr, data);
  609. break;
  610.     case EXTLOG_FMT_IBMDIAG:
  611. printk(RTAS_ERR "IBM Diagnostic Logn");
  612. printk_ext_raw_data(data);
  613. break;
  614.     case EXTLOG_FMT_IBMSP:
  615. printk(RTAS_ERR "IBM Service Processor Logn");
  616. printk_sp_log_msg(version, &exthdr, data);
  617. break;
  618.     default:
  619. printk(RTAS_ERR "Unknown ext format type %dn", exthdr.format_type);
  620. printk_ext_raw_data(data);
  621. break;
  622. }
  623. }
  625. #define MAX_LOG_DEBUG 10
  626. /* Print log debug data.  This appears after the location code.
  627.  * We limit the number of debug logs in case the data is somehow corrupt.
  628.  */
  629. static void printk_log_debug(char *buf)
  630. {
  631. unsigned char *p = (unsigned char *)_ALIGN((unsigned long)buf, 8);
  632. int len, n, logged;
  634. logged = 0;
  635. while ((logged < MAX_LOG_DEBUG) && (len = ((p[0] << 8) | p[1])) != 2) {
  636. /* len includes 2-byte length thus len == 2 is the end */
  637. printk("RTAS: Log Debug: ");
  638. if (len >= 4) /* next 2 bytes are an ascii code */
  639. printk("%c%c ", p[2], p[3]);
  640. for (n=4; n < len; n++)
  641. printk("%02x", p[n]);
  642. printk("n");
  643. p += len;
  644. logged++;
  645. }
  646. if (logged == 0)
  647. printk("RTAS: no log debug data presentn");
  648. }
  651. /* Yeah, the output here is ugly, but we want a CE to be
  652.  * able to grep RTAS /var/log/messages and see all the info
  653.  * collected together with obvious begin/end.
  654.  */
  655. static void printk_log_rtas(char *buf)
  656. {
  657. struct rtas_error_log *err = (struct rtas_error_log *)buf;
  659. printk(RTAS_ERR "-------- event-scan begin --------n");
  660. if (strcmp(buf+8+40, "IBM") == 0) {
  661. /* Location code follows */
  662. char *loc = buf+8+40+4;
  663. int len = strlen(loc);
  664. if (len < 64) { /* Sanity check */
  665. printk(RTAS_ERR "Location Code: %sn", loc);
  666. printk_log_debug(loc+len+1);
  667. }
  668. }
  670. printk(RTAS_ERR "%s: (%s) type: %sn",
  671.        severity_names[err->severity],
  672.        rtas_disposition_names[err->disposition],
  673.        rtas_error_type(err->type));
  674. printk(RTAS_ERR "initiator: %s  target: %sn",
  675.        entity_names[err->initiator], entity_names[err->target]);
  676. if (err->extended_log_length)
  677. printk_ext_log_data(err->version, buf+8);
  678. printk(RTAS_ERR "-------- event-scan end ----------n");
  679. }
  682. static void log_rtas(char *buf)
  683. {
  684. unsigned long offset;
  686. DEBUG("logging rtas eventn");
  688. /* Temporary -- perhaps we can do this when nobody has the log open? */
  689. printk_log_rtas(buf);
  691. spin_lock(&rtas_log_lock);
  693. offset = rtas_error_log_max *
  694. ((rtas_log_start+rtas_log_size) & LOG_NUMBER_MASK);
  696. memcpy(&rtas_log_buf[offset], buf, rtas_error_log_max);
  698. if (rtas_log_size < LOG_NUMBER)
  699. rtas_log_size += 1;
  700. else
  701. rtas_log_start += 1;
  703. spin_unlock(&rtas_log_lock);
  704. wake_up_interruptible(&rtas_log_wait);
  705. }
  707. static int enable_surveillance(void)
  708. {
  709. int error;
  711. error = rtas_call(rtas_token("set-indicator"), 3, 1, NULL, SURVEILLANCE_TOKEN,
  712. 0, SURVEILLANCE_TIMEOUT);
  714. if (error) {
  715. printk(KERN_ERR "rtasd: could not enable surveillancen");
  716. return -1;
  717. }
  719. rtas_event_scan_rate = SURVEILLANCE_SCANRATE;
  721. return 0;
  722. }
  724. static int get_eventscan_parms(void)
  725. {
  726. struct device_node *node;
  727. int *ip;
  729. node = find_path_device("/rtas");
  731. ip = (int *)get_property(node, "rtas-event-scan-rate", NULL);
  732. if (ip == NULL) {
  733. printk(KERN_ERR "rtasd: no rtas-event-scan-raten");
  734. return -1;
  735. }
  736. rtas_event_scan_rate = *ip;
  737. DEBUG("rtas-event-scan-rate %dn", rtas_event_scan_rate);
  739. ip = (int *)get_property(node, "rtas-error-log-max", NULL);
  740. if (ip == NULL) {
  741. printk(KERN_ERR "rtasd: no rtas-error-log-maxn");
  742. return -1;
  743. }
  744. rtas_error_log_max = *ip;
  745. DEBUG("rtas-error-log-max %dn", rtas_error_log_max);
  747. if (rtas_error_log_max > RTAS_ERROR_LOG_MAX) {
  748. printk(KERN_ERR "rtasd: truncated error log from %d to %d bytesn", rtas_error_log_max, RTAS_ERROR_LOG_MAX);
  749. rtas_error_log_max = RTAS_ERROR_LOG_MAX;
  750. }
  752. return 0;
  753. }
  755. extern long sys_sched_get_priority_max(int policy);
  757. static int rtasd(void *unused)
  758. {
  759. int cpu = 0;
  760. int error;
  761. int first_pass = 1;
  762. int event_scan = rtas_token("event-scan");
  764. if (event_scan == RTAS_UNKNOWN_SERVICE || get_eventscan_parms() == -1)
  765. goto error;
  767. rtas_log_buf = vmalloc(rtas_error_log_max*LOG_NUMBER);
  768. if (!rtas_log_buf) {
  769. printk(KERN_ERR "rtasd: no memoryn");
  770. goto error;
  771. }
  773. DEBUG("will sleep for %d jiffiesn", (HZ*60/rtas_event_scan_rate) / 2);
  775. daemonize();
  776. sigfillset(&current->blocked);
  777. sprintf(current->comm, "rtasd");
  779. /* Rusty unreal time task */
  780. current->policy = SCHED_FIFO;
  781. current->nice = sys_sched_get_priority_max(SCHED_FIFO) + 1;
  783. cpu = 0;
  784. current->cpus_allowed = 1UL << cpu_logical_map(cpu);
  785. schedule();
  787. while(1) {
  788. do {
  789. memset(logdata, 0, rtas_error_log_max);
  790. error = rtas_call(event_scan, 4, 1, NULL,
  791. EVENT_SCAN_ALL_EVENTS, 0,
  792. __pa(logdata), rtas_error_log_max);
  793. if (error == -1) {
  794. printk(KERN_ERR "event-scan failedn");
  795. break;
  796. }
  798. if (error == 0)
  799. log_rtas(logdata);
  801. } while(error == 0);
  803. DEBUG("watchdog scheduled on cpu %dn", smp_processor_id());
  805. cpu++;
  806. if (cpu >= smp_num_cpus) {
  808. if (first_pass && surveillance_requested) {
  809. DEBUG("enabling surveillancen");
  810. if (enable_surveillance())
  811. goto error_vfree;
  812. DEBUG("surveillance enabledn");
  813. }
  815. first_pass = 0;
  816. cpu = 0;
  817. }
  819. current->cpus_allowed = 1UL << cpu_logical_map(cpu);
  821. /* Check all cpus for pending events before sleeping*/
  822. if (first_pass) {
  823. schedule();
  824. } else {
  825. set_current_state(TASK_INTERRUPTIBLE);
  826. schedule_timeout((HZ*60/rtas_event_scan_rate) / 2);
  827. }
  828. }
  830. error_vfree:
  831. vfree(rtas_log_buf);
  832. error:
  833. /* Should delete proc entries */
  834. return -EINVAL;
  835. }
  837. static void __init rtas_init(void)
  838. {
  839. struct proc_dir_entry *rtas_dir, *entry;
  841. rtas_dir = proc_mkdir("rtas", 0);
  842. if (!rtas_dir) {
  843. printk(KERN_ERR "Failed to create rtas proc directoryn");
  844. } else {
  845. entry = create_proc_entry("error_log", S_IRUSR, rtas_dir);
  846. if (entry)
  847. entry->proc_fops = &proc_rtas_log_operations;
  848. else
  849. printk(KERN_ERR "Failed to create rtas/error_log proc entryn");
  850. }
  852. if (kernel_thread(rtasd, 0, CLONE_FS) < 0)
  853. printk(KERN_ERR "Failed to start RTAS daemonn");
  855. printk(KERN_ERR "RTAS daemon startedn");
  856. }
  858. static int __init surveillance_setup(char *str)
  859. {
  860. int i;
  862. if (get_option(&str,&i)) {
  863. if (i == 1)
  864. surveillance_requested = 1;
  865. }
  867. return 1;
  868. }
  870. __initcall(rtas_init);
  871. __setup("surveillance=", surveillance_setup);