tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 *
16 * Copyright (c) 2005 Linas Vepstas <linas@linas.org>
17 */
18
19#include <linux/delay.h>
20#include <linux/list.h>
21#include <linux/mutex.h>
22#include <linux/sched.h>
23#include <linux/pci.h>
24#include <linux/slab.h>
25#include <linux/workqueue.h>
26#include <linux/kthread.h>
27#include <asm/eeh_event.h>
28#include <asm/ppc-pci.h>
29
30/** Overview:
31 * EEH error states may be detected within exception handlers;
32 * however, the recovery processing needs to occur asynchronously
33 * in a normal kernel context and not an interrupt context.
34 * This pair of routines creates an event and queues it onto a
35 * work-queue, where a worker thread can drive recovery.
36 */
37
38/* EEH event workqueue setup. */
39static DEFINE_SPINLOCK(eeh_eventlist_lock);
40LIST_HEAD(eeh_eventlist);
41static void eeh_thread_launcher(struct work_struct *);
42DECLARE_WORK(eeh_event_wq, eeh_thread_launcher);
43
44/* Serialize reset sequences for a given pci device */
45DEFINE_MUTEX(eeh_event_mutex);
46
47/**
48 * eeh_event_handler - Dispatch EEH events.
49 * @dummy - unused
50 *
51 * The detection of a frozen slot can occur inside an interrupt,
52 * where it can be hard to do anything about it. The goal of this
53 * routine is to pull these detection events out of the context
54 * of the interrupt handler, and re-dispatch them for processing
55 * at a later time in a normal context.
56 */
57static int eeh_event_handler(void * dummy)
58{
59 unsigned long flags;
60 struct eeh_event *event;
61 struct eeh_pe *pe;
62
63 spin_lock_irqsave(&eeh_eventlist_lock, flags);
64 event = NULL;
65
66 /* Unqueue the event, get ready to process. */
67 if (!list_empty(&eeh_eventlist)) {
68 event = list_entry(eeh_eventlist.next, struct eeh_event, list);
69 list_del(&event->list);
70 }
71 spin_unlock_irqrestore(&eeh_eventlist_lock, flags);
72
73 if (event == NULL)
74 return 0;
75
76 /* Serialize processing of EEH events */
77 mutex_lock(&eeh_event_mutex);
78 pe = event->pe;
79 eeh_pe_state_mark(pe, EEH_PE_RECOVERING);
80 pr_info("EEH: Detected PCI bus error on PHB#%d-PE#%x\n",
81 pe->phb->global_number, pe->addr);
82
83 set_current_state(TASK_INTERRUPTIBLE); /* Don't add to load average */
84 eeh_handle_event(pe);
85 eeh_pe_state_clear(pe, EEH_PE_RECOVERING);
86
87 kfree(event);
88 mutex_unlock(&eeh_event_mutex);
89
90 /* If there are no new errors after an hour, clear the counter. */
91 if (pe && pe->freeze_count > 0) {
92 msleep_interruptible(3600*1000);
93 if (pe->freeze_count > 0)
94 pe->freeze_count--;
95
96 }
97
98 return 0;
99}
100
101/**
102 * eeh_thread_launcher - Start kernel thread to handle EEH events
103 * @dummy - unused
104 *
105 * This routine is called to start the kernel thread for processing
106 * EEH event.
107 */
108static void eeh_thread_launcher(struct work_struct *dummy)
109{
110 if (IS_ERR(kthread_run(eeh_event_handler, NULL, "eehd")))
111 printk(KERN_ERR "Failed to start EEH daemon\n");
112}
113
114/**
115 * eeh_send_failure_event - Generate a PCI error event
116 * @pe: EEH PE
117 *
118 * This routine can be called within an interrupt context;
119 * the actual event will be delivered in a normal context
120 * (from a workqueue).
121 */
122int eeh_send_failure_event(struct eeh_pe *pe)
123{
124 unsigned long flags;
125 struct eeh_event *event;
126
127 event = kzalloc(sizeof(*event), GFP_ATOMIC);
128 if (!event) {
129 pr_err("EEH: out of memory, event not handled\n");
130 return -ENOMEM;
131 }
132 event->pe = pe;
133
134 /* We may or may not be called in an interrupt context */
135 spin_lock_irqsave(&eeh_eventlist_lock, flags);
136 list_add(&event->list, &eeh_eventlist);
137 spin_unlock_irqrestore(&eeh_eventlist_lock, flags);
138
139 schedule_work(&eeh_event_wq);
140
141 return 0;
142}