1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2015-2016 Mentor Graphics
4 */
5
6 #include <linux/list.h>
7 #include <linux/slab.h>
8 #include <linux/spinlock.h>
9 #include <linux/string.h>
10 #include <linux/watchdog.h>
11
12 #include "watchdog_core.h"
13 #include "watchdog_pretimeout.h"
14
15 /* Default watchdog pretimeout governor */
16 static struct watchdog_governor *default_gov;
17
18 /* The spinlock protects default_gov, wdd->gov and pretimeout_list */
19 static DEFINE_SPINLOCK(pretimeout_lock);
20
21 /* List of watchdog devices, which can generate a pretimeout event */
22 static LIST_HEAD(pretimeout_list);
23
24 struct watchdog_pretimeout {
25 struct watchdog_device *wdd;
26 struct list_head entry;
27 };
28
29 /* The mutex protects governor list and serializes external interfaces */
30 static DEFINE_MUTEX(governor_lock);
31
32 /* List of the registered watchdog pretimeout governors */
33 static LIST_HEAD(governor_list);
34
35 struct governor_priv {
36 struct watchdog_governor *gov;
37 struct list_head entry;
38 };
39
find_governor_by_name(const char * gov_name)40 static struct governor_priv *find_governor_by_name(const char *gov_name)
41 {
42 struct governor_priv *priv;
43
44 list_for_each_entry(priv, &governor_list, entry)
45 if (sysfs_streq(gov_name, priv->gov->name))
46 return priv;
47
48 return NULL;
49 }
50
watchdog_pretimeout_available_governors_get(char * buf)51 int watchdog_pretimeout_available_governors_get(char *buf)
52 {
53 struct governor_priv *priv;
54 int count = 0;
55
56 mutex_lock(&governor_lock);
57
58 list_for_each_entry(priv, &governor_list, entry)
59 count += sysfs_emit_at(buf, count, "%s\n", priv->gov->name);
60
61 mutex_unlock(&governor_lock);
62
63 return count;
64 }
65
watchdog_pretimeout_governor_get(struct watchdog_device * wdd,char * buf)66 int watchdog_pretimeout_governor_get(struct watchdog_device *wdd, char *buf)
67 {
68 int count = 0;
69
70 spin_lock_irq(&pretimeout_lock);
71 if (wdd->gov)
72 count = sysfs_emit(buf, "%s\n", wdd->gov->name);
73 spin_unlock_irq(&pretimeout_lock);
74
75 return count;
76 }
77
watchdog_pretimeout_governor_set(struct watchdog_device * wdd,const char * buf)78 int watchdog_pretimeout_governor_set(struct watchdog_device *wdd,
79 const char *buf)
80 {
81 struct governor_priv *priv;
82
83 mutex_lock(&governor_lock);
84
85 priv = find_governor_by_name(buf);
86 if (!priv) {
87 mutex_unlock(&governor_lock);
88 return -EINVAL;
89 }
90
91 spin_lock_irq(&pretimeout_lock);
92 wdd->gov = priv->gov;
93 spin_unlock_irq(&pretimeout_lock);
94
95 mutex_unlock(&governor_lock);
96
97 return 0;
98 }
99
watchdog_notify_pretimeout(struct watchdog_device * wdd)100 void watchdog_notify_pretimeout(struct watchdog_device *wdd)
101 {
102 unsigned long flags;
103
104 spin_lock_irqsave(&pretimeout_lock, flags);
105 if (!wdd->gov) {
106 spin_unlock_irqrestore(&pretimeout_lock, flags);
107 return;
108 }
109
110 wdd->gov->pretimeout(wdd);
111 spin_unlock_irqrestore(&pretimeout_lock, flags);
112 }
113 EXPORT_SYMBOL_GPL(watchdog_notify_pretimeout);
114
watchdog_register_governor(struct watchdog_governor * gov)115 int watchdog_register_governor(struct watchdog_governor *gov)
116 {
117 struct watchdog_pretimeout *p;
118 struct governor_priv *priv;
119
120 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
121 if (!priv)
122 return -ENOMEM;
123
124 mutex_lock(&governor_lock);
125
126 if (find_governor_by_name(gov->name)) {
127 mutex_unlock(&governor_lock);
128 kfree(priv);
129 return -EBUSY;
130 }
131
132 priv->gov = gov;
133 list_add(&priv->entry, &governor_list);
134
135 if (!strncmp(gov->name, WATCHDOG_PRETIMEOUT_DEFAULT_GOV,
136 WATCHDOG_GOV_NAME_MAXLEN)) {
137 spin_lock_irq(&pretimeout_lock);
138 default_gov = gov;
139
140 list_for_each_entry(p, &pretimeout_list, entry)
141 if (!p->wdd->gov)
142 p->wdd->gov = default_gov;
143 spin_unlock_irq(&pretimeout_lock);
144 }
145
146 mutex_unlock(&governor_lock);
147
148 return 0;
149 }
150 EXPORT_SYMBOL(watchdog_register_governor);
151
watchdog_unregister_governor(struct watchdog_governor * gov)152 void watchdog_unregister_governor(struct watchdog_governor *gov)
153 {
154 struct watchdog_pretimeout *p;
155 struct governor_priv *priv, *t;
156
157 mutex_lock(&governor_lock);
158
159 list_for_each_entry_safe(priv, t, &governor_list, entry) {
160 if (priv->gov == gov) {
161 list_del(&priv->entry);
162 kfree(priv);
163 break;
164 }
165 }
166
167 spin_lock_irq(&pretimeout_lock);
168 list_for_each_entry(p, &pretimeout_list, entry)
169 if (p->wdd->gov == gov)
170 p->wdd->gov = default_gov;
171 spin_unlock_irq(&pretimeout_lock);
172
173 mutex_unlock(&governor_lock);
174 }
175 EXPORT_SYMBOL(watchdog_unregister_governor);
176
watchdog_register_pretimeout(struct watchdog_device * wdd)177 int watchdog_register_pretimeout(struct watchdog_device *wdd)
178 {
179 struct watchdog_pretimeout *p;
180
181 if (!watchdog_have_pretimeout(wdd))
182 return 0;
183
184 p = kzalloc(sizeof(*p), GFP_KERNEL);
185 if (!p)
186 return -ENOMEM;
187
188 spin_lock_irq(&pretimeout_lock);
189 list_add(&p->entry, &pretimeout_list);
190 p->wdd = wdd;
191 wdd->gov = default_gov;
192 spin_unlock_irq(&pretimeout_lock);
193
194 return 0;
195 }
196
watchdog_unregister_pretimeout(struct watchdog_device * wdd)197 void watchdog_unregister_pretimeout(struct watchdog_device *wdd)
198 {
199 struct watchdog_pretimeout *p, *t;
200
201 if (!watchdog_have_pretimeout(wdd))
202 return;
203
204 spin_lock_irq(&pretimeout_lock);
205 wdd->gov = NULL;
206
207 list_for_each_entry_safe(p, t, &pretimeout_list, entry) {
208 if (p->wdd == wdd) {
209 list_del(&p->entry);
210 kfree(p);
211 break;
212 }
213 }
214 spin_unlock_irq(&pretimeout_lock);
215 }
216