blob: 47c8630c93cdd6c6a3f55d78798c32f7defa9f03 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Base infrastructure for Linux-z/VM Monitor Stream, Stage 1.
3 * Exports appldata_register_ops() and appldata_unregister_ops() for the
4 * data gathering modules.
5 *
Gerald Schaefer524dbcd2009-06-16 10:30:36 +02006 * Copyright IBM Corp. 2003, 2009
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
Gerald Schaefer5b5dd212006-06-29 15:08:35 +02008 * Author: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 */
10
Gerald Schaefere7534b02008-12-25 13:39:41 +010011#define KMSG_COMPONENT "appldata"
12#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/module.h>
15#include <linux/init.h>
16#include <linux/slab.h>
17#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/interrupt.h>
19#include <linux/proc_fs.h>
Heiko Carstens2dcea572006-09-29 01:58:41 -070020#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/swap.h>
22#include <linux/pagemap.h>
23#include <linux/sysctl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/notifier.h>
25#include <linux/cpu.h>
Gerald Schaeferf26d5832005-06-04 15:43:33 -070026#include <linux/workqueue.h>
Gerald Schaefer524dbcd2009-06-16 10:30:36 +020027#include <linux/suspend.h>
28#include <linux/platform_device.h>
Gerald Schaefer1f38d612006-09-20 15:59:26 +020029#include <asm/appldata.h>
Martin Schwidefsky27f6b412012-07-20 11:15:08 +020030#include <asm/vtimer.h>
Gerald Schaefer1f38d612006-09-20 15:59:26 +020031#include <asm/uaccess.h>
32#include <asm/io.h>
33#include <asm/smp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35#include "appldata.h"
36
37
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#define APPLDATA_CPU_INTERVAL 10000 /* default (CPU) time for
39 sampling interval in
40 milliseconds */
41
42#define TOD_MICRO 0x01000 /* nr. of TOD clock units
43 for 1 microsecond */
Gerald Schaefer524dbcd2009-06-16 10:30:36 +020044
45static struct platform_device *appldata_pdev;
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047/*
48 * /proc entries (sysctl)
49 */
50static const char appldata_proc_name[APPLDATA_PROC_NAME_LENGTH] = "appldata";
Joe Perches302bfe22013-10-22 15:29:46 -070051static int appldata_timer_handler(struct ctl_table *ctl, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 void __user *buffer, size_t *lenp, loff_t *ppos);
Joe Perches302bfe22013-10-22 15:29:46 -070053static int appldata_interval_handler(struct ctl_table *ctl, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 void __user *buffer,
55 size_t *lenp, loff_t *ppos);
56
57static struct ctl_table_header *appldata_sysctl_header;
58static struct ctl_table appldata_table[] = {
59 {
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 .procname = "timer",
61 .mode = S_IRUGO | S_IWUSR,
Eric W. Biederman6d456112009-11-16 03:11:48 -080062 .proc_handler = appldata_timer_handler,
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 },
64 {
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 .procname = "interval",
66 .mode = S_IRUGO | S_IWUSR,
Eric W. Biederman6d456112009-11-16 03:11:48 -080067 .proc_handler = appldata_interval_handler,
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 },
Heiko Carstens37e3a6a2007-11-20 11:13:34 +010069 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -070070};
71
72static struct ctl_table appldata_dir_table[] = {
73 {
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 .procname = appldata_proc_name,
75 .maxlen = 0,
76 .mode = S_IRUGO | S_IXUGO,
77 .child = appldata_table,
78 },
Heiko Carstens37e3a6a2007-11-20 11:13:34 +010079 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -070080};
81
82/*
83 * Timer
84 */
Martin Schwidefsky27f6b412012-07-20 11:15:08 +020085static struct vtimer_list appldata_timer;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
87static DEFINE_SPINLOCK(appldata_timer_lock);
88static int appldata_interval = APPLDATA_CPU_INTERVAL;
89static int appldata_timer_active;
Gerald Schaefer524dbcd2009-06-16 10:30:36 +020090static int appldata_timer_suspended = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92/*
Gerald Schaeferf26d5832005-06-04 15:43:33 -070093 * Work queue
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 */
Gerald Schaeferf26d5832005-06-04 15:43:33 -070095static struct workqueue_struct *appldata_wq;
David Howells6d5aefb2006-12-05 19:36:26 +000096static void appldata_work_fn(struct work_struct *work);
97static DECLARE_WORK(appldata_work, appldata_work_fn);
Gerald Schaeferf26d5832005-06-04 15:43:33 -070098
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
100/*
101 * Ops list
102 */
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200103static DEFINE_MUTEX(appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104static LIST_HEAD(appldata_ops_list);
105
106
Gerald Schaeferf26d5832005-06-04 15:43:33 -0700107/*************************** timer, work, DIAG *******************************/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108/*
109 * appldata_timer_function()
110 *
Gerald Schaeferf26d5832005-06-04 15:43:33 -0700111 * schedule work and reschedule timer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 */
Heiko Carstens9d0a57c2006-10-11 15:31:26 +0200113static void appldata_timer_function(unsigned long data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
Martin Schwidefsky27f6b412012-07-20 11:15:08 +0200115 queue_work(appldata_wq, (struct work_struct *) data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116}
117
118/*
Gerald Schaeferf26d5832005-06-04 15:43:33 -0700119 * appldata_work_fn()
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 *
121 * call data gathering function for each (active) module
122 */
David Howells6d5aefb2006-12-05 19:36:26 +0000123static void appldata_work_fn(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124{
125 struct list_head *lh;
126 struct appldata_ops *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200128 mutex_lock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 list_for_each(lh, &appldata_ops_list) {
130 ops = list_entry(lh, struct appldata_ops, list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 if (ops->active == 1) {
132 ops->callback(ops->data);
133 }
134 }
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200135 mutex_unlock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
137
138/*
139 * appldata_diag()
140 *
141 * prepare parameter list, issue DIAG 0xDC
142 */
Gerald Schaefer5b5dd212006-06-29 15:08:35 +0200143int appldata_diag(char record_nr, u16 function, unsigned long buffer,
144 u16 length, char *mod_lvl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145{
Gerald Schaefer1f38d612006-09-20 15:59:26 +0200146 struct appldata_product_id id = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 .prod_nr = {0xD3, 0xC9, 0xD5, 0xE4,
Gerald Schaefer1f38d612006-09-20 15:59:26 +0200148 0xE7, 0xD2, 0xD9}, /* "LINUXKR" */
149 .prod_fn = 0xD5D3, /* "NL" */
Gerald Schaefer1f38d612006-09-20 15:59:26 +0200150 .version_nr = 0xF2F6, /* "26" */
151 .release_nr = 0xF0F1, /* "01" */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 };
153
Gerald Schaefer925afbd2006-09-28 16:55:23 +0200154 id.record_nr = record_nr;
155 id.mod_lvl = (mod_lvl[0]) << 8 | mod_lvl[1];
Gerald Schaefer1f38d612006-09-20 15:59:26 +0200156 return appldata_asm(&id, function, (void *) buffer, length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157}
Gerald Schaeferf26d5832005-06-04 15:43:33 -0700158/************************ timer, work, DIAG <END> ****************************/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
160
161/****************************** /proc stuff **********************************/
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163#define APPLDATA_ADD_TIMER 0
164#define APPLDATA_DEL_TIMER 1
165#define APPLDATA_MOD_TIMER 2
166
167/*
168 * __appldata_vtimer_setup()
169 *
170 * Add, delete or modify virtual timers on all online cpus.
171 * The caller needs to get the appldata_timer_lock spinlock.
172 */
Martin Schwidefsky27f6b412012-07-20 11:15:08 +0200173static void __appldata_vtimer_setup(int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174{
Martin Schwidefsky27f6b412012-07-20 11:15:08 +0200175 u64 timer_interval = (u64) appldata_interval * 1000 * TOD_MICRO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
177 switch (cmd) {
178 case APPLDATA_ADD_TIMER:
179 if (appldata_timer_active)
180 break;
Martin Schwidefsky27f6b412012-07-20 11:15:08 +0200181 appldata_timer.expires = timer_interval;
182 add_virt_timer_periodic(&appldata_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 appldata_timer_active = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 break;
185 case APPLDATA_DEL_TIMER:
Martin Schwidefsky27f6b412012-07-20 11:15:08 +0200186 del_virt_timer(&appldata_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 if (!appldata_timer_active)
188 break;
189 appldata_timer_active = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 break;
191 case APPLDATA_MOD_TIMER:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 if (!appldata_timer_active)
193 break;
Martin Schwidefsky27f6b412012-07-20 11:15:08 +0200194 mod_virt_timer_periodic(&appldata_timer, timer_interval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 }
196}
197
198/*
199 * appldata_timer_handler()
200 *
201 * Start/Stop timer, show status of timer (0 = not active, 1 = active)
202 */
203static int
Joe Perches302bfe22013-10-22 15:29:46 -0700204appldata_timer_handler(struct ctl_table *ctl, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 void __user *buffer, size_t *lenp, loff_t *ppos)
206{
Heiko Carstens57f47ba2013-10-14 14:08:35 +0200207 unsigned int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 char buf[2];
209
210 if (!*lenp || *ppos) {
211 *lenp = 0;
212 return 0;
213 }
214 if (!write) {
Chen Gangd5b4c2f2013-05-27 17:55:13 +0800215 strncpy(buf, appldata_timer_active ? "1\n" : "0\n",
216 ARRAY_SIZE(buf));
217 len = strnlen(buf, ARRAY_SIZE(buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 if (len > *lenp)
219 len = *lenp;
220 if (copy_to_user(buffer, buf, len))
221 return -EFAULT;
222 goto out;
223 }
224 len = *lenp;
225 if (copy_from_user(buf, buffer, len > sizeof(buf) ? sizeof(buf) : len))
226 return -EFAULT;
227 spin_lock(&appldata_timer_lock);
228 if (buf[0] == '1')
229 __appldata_vtimer_setup(APPLDATA_ADD_TIMER);
230 else if (buf[0] == '0')
231 __appldata_vtimer_setup(APPLDATA_DEL_TIMER);
232 spin_unlock(&appldata_timer_lock);
233out:
234 *lenp = len;
235 *ppos += len;
236 return 0;
237}
238
239/*
240 * appldata_interval_handler()
241 *
242 * Set (CPU) timer interval for collection of data (in milliseconds), show
243 * current timer interval.
244 */
245static int
Joe Perches302bfe22013-10-22 15:29:46 -0700246appldata_interval_handler(struct ctl_table *ctl, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 void __user *buffer, size_t *lenp, loff_t *ppos)
248{
Heiko Carstens57f47ba2013-10-14 14:08:35 +0200249 unsigned int len;
250 int interval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 char buf[16];
252
253 if (!*lenp || *ppos) {
254 *lenp = 0;
255 return 0;
256 }
257 if (!write) {
258 len = sprintf(buf, "%i\n", appldata_interval);
259 if (len > *lenp)
260 len = *lenp;
261 if (copy_to_user(buffer, buf, len))
262 return -EFAULT;
263 goto out;
264 }
265 len = *lenp;
Martin Schwidefsky27f6b412012-07-20 11:15:08 +0200266 if (copy_from_user(buf, buffer, len > sizeof(buf) ? sizeof(buf) : len))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 return -EFAULT;
Gerald Schaefer95425f12006-10-27 12:39:13 +0200268 interval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 sscanf(buf, "%i", &interval);
Gerald Schaeferd3ae9422008-07-14 09:59:34 +0200270 if (interval <= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
273 spin_lock(&appldata_timer_lock);
274 appldata_interval = interval;
275 __appldata_vtimer_setup(APPLDATA_MOD_TIMER);
276 spin_unlock(&appldata_timer_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277out:
278 *lenp = len;
279 *ppos += len;
280 return 0;
281}
282
283/*
284 * appldata_generic_handler()
285 *
286 * Generic start/stop monitoring and DIAG, show status of
287 * monitoring (0 = not in process, 1 = in process)
288 */
289static int
Joe Perches302bfe22013-10-22 15:29:46 -0700290appldata_generic_handler(struct ctl_table *ctl, int write,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 void __user *buffer, size_t *lenp, loff_t *ppos)
292{
293 struct appldata_ops *ops = NULL, *tmp_ops;
Heiko Carstens57f47ba2013-10-14 14:08:35 +0200294 unsigned int len;
295 int rc, found;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 char buf[2];
297 struct list_head *lh;
298
299 found = 0;
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200300 mutex_lock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 list_for_each(lh, &appldata_ops_list) {
302 tmp_ops = list_entry(lh, struct appldata_ops, list);
303 if (&tmp_ops->ctl_table[2] == ctl) {
304 found = 1;
305 }
306 }
307 if (!found) {
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200308 mutex_unlock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 return -ENODEV;
310 }
311 ops = ctl->data;
312 if (!try_module_get(ops->owner)) { // protect this function
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200313 mutex_unlock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 return -ENODEV;
315 }
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200316 mutex_unlock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
318 if (!*lenp || *ppos) {
319 *lenp = 0;
320 module_put(ops->owner);
321 return 0;
322 }
323 if (!write) {
Chen Gangd5b4c2f2013-05-27 17:55:13 +0800324 strncpy(buf, ops->active ? "1\n" : "0\n", ARRAY_SIZE(buf));
325 len = strnlen(buf, ARRAY_SIZE(buf));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 if (len > *lenp)
327 len = *lenp;
328 if (copy_to_user(buffer, buf, len)) {
329 module_put(ops->owner);
330 return -EFAULT;
331 }
332 goto out;
333 }
334 len = *lenp;
335 if (copy_from_user(buf, buffer,
336 len > sizeof(buf) ? sizeof(buf) : len)) {
337 module_put(ops->owner);
338 return -EFAULT;
339 }
340
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200341 mutex_lock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 if ((buf[0] == '1') && (ops->active == 0)) {
Gerald Schaeferf26d5832005-06-04 15:43:33 -0700343 // protect work queue callback
344 if (!try_module_get(ops->owner)) {
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200345 mutex_unlock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 module_put(ops->owner);
347 return -ENODEV;
348 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 ops->callback(ops->data); // init record
350 rc = appldata_diag(ops->record_nr,
351 APPLDATA_START_INTERVAL_REC,
Gerald Schaefer5b5dd212006-06-29 15:08:35 +0200352 (unsigned long) ops->data, ops->size,
353 ops->mod_lvl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 if (rc != 0) {
Gerald Schaefere7534b02008-12-25 13:39:41 +0100355 pr_err("Starting the data collection for %s "
356 "failed with rc=%d\n", ops->name, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 module_put(ops->owner);
Gerald Schaeferd3ae9422008-07-14 09:59:34 +0200358 } else
Gerald Schaefer5b5dd212006-06-29 15:08:35 +0200359 ops->active = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 } else if ((buf[0] == '0') && (ops->active == 1)) {
361 ops->active = 0;
362 rc = appldata_diag(ops->record_nr, APPLDATA_STOP_REC,
Gerald Schaefer5b5dd212006-06-29 15:08:35 +0200363 (unsigned long) ops->data, ops->size,
364 ops->mod_lvl);
Gerald Schaeferd3ae9422008-07-14 09:59:34 +0200365 if (rc != 0)
Gerald Schaefere7534b02008-12-25 13:39:41 +0100366 pr_err("Stopping the data collection for %s "
367 "failed with rc=%d\n", ops->name, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 module_put(ops->owner);
369 }
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200370 mutex_unlock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371out:
372 *lenp = len;
373 *ppos += len;
374 module_put(ops->owner);
375 return 0;
376}
377
378/*************************** /proc stuff <END> *******************************/
379
380
381/************************* module-ops management *****************************/
382/*
383 * appldata_register_ops()
384 *
385 * update ops list, register /proc/sys entries
386 */
387int appldata_register_ops(struct appldata_ops *ops)
388{
Roel Kluin13f8b7c2008-10-28 11:10:18 +0100389 if (ops->size > APPLDATA_MAX_REC_SIZE)
Heiko Carstens37e3a6a2007-11-20 11:13:34 +0100390 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
Heiko Carstens37e3a6a2007-11-20 11:13:34 +0100392 ops->ctl_table = kzalloc(4 * sizeof(struct ctl_table), GFP_KERNEL);
393 if (!ops->ctl_table)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200396 mutex_lock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 list_add(&ops->list, &appldata_ops_list);
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200398 mutex_unlock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 ops->ctl_table[0].procname = appldata_proc_name;
401 ops->ctl_table[0].maxlen = 0;
402 ops->ctl_table[0].mode = S_IRUGO | S_IXUGO;
403 ops->ctl_table[0].child = &ops->ctl_table[2];
404
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 ops->ctl_table[2].procname = ops->name;
406 ops->ctl_table[2].mode = S_IRUGO | S_IWUSR;
407 ops->ctl_table[2].proc_handler = appldata_generic_handler;
408 ops->ctl_table[2].data = ops;
409
Eric W. Biederman0b4d4142007-02-14 00:34:09 -0800410 ops->sysctl_header = register_sysctl_table(ops->ctl_table);
Heiko Carstens37e3a6a2007-11-20 11:13:34 +0100411 if (!ops->sysctl_header)
412 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 return 0;
Heiko Carstens37e3a6a2007-11-20 11:13:34 +0100414out:
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200415 mutex_lock(&appldata_ops_mutex);
Heiko Carstens37e3a6a2007-11-20 11:13:34 +0100416 list_del(&ops->list);
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200417 mutex_unlock(&appldata_ops_mutex);
Heiko Carstens37e3a6a2007-11-20 11:13:34 +0100418 kfree(ops->ctl_table);
419 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420}
421
422/*
423 * appldata_unregister_ops()
424 *
425 * update ops list, unregister /proc entries, stop DIAG if necessary
426 */
427void appldata_unregister_ops(struct appldata_ops *ops)
428{
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200429 mutex_lock(&appldata_ops_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 list_del(&ops->list);
Gerald Schaeferb1ad1712009-04-23 13:58:07 +0200431 mutex_unlock(&appldata_ops_mutex);
Al Viro330d57f2005-11-04 10:18:40 +0000432 unregister_sysctl_table(ops->sysctl_header);
Heiko Carstens37e3a6a2007-11-20 11:13:34 +0100433 kfree(ops->ctl_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434}
435/********************** module-ops management <END> **************************/
436
437
Gerald Schaefer524dbcd2009-06-16 10:30:36 +0200438/**************************** suspend / resume *******************************/
439static int appldata_freeze(struct device *dev)
440{
441 struct appldata_ops *ops;
442 int rc;
443 struct list_head *lh;
444
Gerald Schaefer524dbcd2009-06-16 10:30:36 +0200445 spin_lock(&appldata_timer_lock);
446 if (appldata_timer_active) {
447 __appldata_vtimer_setup(APPLDATA_DEL_TIMER);
448 appldata_timer_suspended = 1;
449 }
450 spin_unlock(&appldata_timer_lock);
Gerald Schaefer524dbcd2009-06-16 10:30:36 +0200451
452 mutex_lock(&appldata_ops_mutex);
453 list_for_each(lh, &appldata_ops_list) {
454 ops = list_entry(lh, struct appldata_ops, list);
455 if (ops->active == 1) {
456 rc = appldata_diag(ops->record_nr, APPLDATA_STOP_REC,
457 (unsigned long) ops->data, ops->size,
458 ops->mod_lvl);
459 if (rc != 0)
460 pr_err("Stopping the data collection for %s "
461 "failed with rc=%d\n", ops->name, rc);
462 }
463 }
464 mutex_unlock(&appldata_ops_mutex);
465 return 0;
466}
467
468static int appldata_restore(struct device *dev)
469{
470 struct appldata_ops *ops;
471 int rc;
472 struct list_head *lh;
473
Gerald Schaefer524dbcd2009-06-16 10:30:36 +0200474 spin_lock(&appldata_timer_lock);
475 if (appldata_timer_suspended) {
476 __appldata_vtimer_setup(APPLDATA_ADD_TIMER);
477 appldata_timer_suspended = 0;
478 }
479 spin_unlock(&appldata_timer_lock);
Gerald Schaefer524dbcd2009-06-16 10:30:36 +0200480
481 mutex_lock(&appldata_ops_mutex);
482 list_for_each(lh, &appldata_ops_list) {
483 ops = list_entry(lh, struct appldata_ops, list);
484 if (ops->active == 1) {
485 ops->callback(ops->data); // init record
486 rc = appldata_diag(ops->record_nr,
487 APPLDATA_START_INTERVAL_REC,
488 (unsigned long) ops->data, ops->size,
489 ops->mod_lvl);
490 if (rc != 0) {
491 pr_err("Starting the data collection for %s "
492 "failed with rc=%d\n", ops->name, rc);
493 }
494 }
495 }
496 mutex_unlock(&appldata_ops_mutex);
497 return 0;
498}
499
500static int appldata_thaw(struct device *dev)
501{
502 return appldata_restore(dev);
503}
504
Alexey Dobriyan47145212009-12-14 18:00:08 -0800505static const struct dev_pm_ops appldata_pm_ops = {
Gerald Schaefer524dbcd2009-06-16 10:30:36 +0200506 .freeze = appldata_freeze,
507 .thaw = appldata_thaw,
508 .restore = appldata_restore,
509};
510
511static struct platform_driver appldata_pdrv = {
512 .driver = {
513 .name = "appldata",
514 .owner = THIS_MODULE,
515 .pm = &appldata_pm_ops,
516 },
517};
518/************************* suspend / resume <END> ****************************/
519
520
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521/******************************* init / exit *********************************/
522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523/*
524 * appldata_init()
525 *
Gerald Schaeferf26d5832005-06-04 15:43:33 -0700526 * init timer, register /proc entries
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 */
528static int __init appldata_init(void)
529{
Martin Schwidefsky27f6b412012-07-20 11:15:08 +0200530 int rc;
531
Gerald Schaeferb7c5b1a2014-01-28 18:40:12 +0100532 init_virt_timer(&appldata_timer);
Martin Schwidefsky27f6b412012-07-20 11:15:08 +0200533 appldata_timer.function = appldata_timer_function;
534 appldata_timer.data = (unsigned long) &appldata_work;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
Gerald Schaefer524dbcd2009-06-16 10:30:36 +0200536 rc = platform_driver_register(&appldata_pdrv);
537 if (rc)
538 return rc;
539
540 appldata_pdev = platform_device_register_simple("appldata", -1, NULL,
541 0);
542 if (IS_ERR(appldata_pdev)) {
543 rc = PTR_ERR(appldata_pdev);
544 goto out_driver;
545 }
Gerald Schaeferf26d5832005-06-04 15:43:33 -0700546 appldata_wq = create_singlethread_workqueue("appldata");
Gerald Schaefer524dbcd2009-06-16 10:30:36 +0200547 if (!appldata_wq) {
548 rc = -ENOMEM;
549 goto out_device;
550 }
Gerald Schaeferf26d5832005-06-04 15:43:33 -0700551
Eric W. Biederman0b4d4142007-02-14 00:34:09 -0800552 appldata_sysctl_header = register_sysctl_table(appldata_dir_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 return 0;
Gerald Schaefer524dbcd2009-06-16 10:30:36 +0200554
555out_device:
556 platform_device_unregister(appldata_pdev);
557out_driver:
558 platform_driver_unregister(&appldata_pdrv);
559 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560}
561
Satyam Sharma076fc802007-10-12 16:11:32 +0200562__initcall(appldata_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564/**************************** init / exit <END> ******************************/
565
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566EXPORT_SYMBOL_GPL(appldata_register_ops);
567EXPORT_SYMBOL_GPL(appldata_unregister_ops);
Gerald Schaefer5b5dd212006-06-29 15:08:35 +0200568EXPORT_SYMBOL_GPL(appldata_diag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Gerald Schaefer0c3252d2008-07-14 09:57:27 +0200570#ifdef CONFIG_SWAP
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571EXPORT_SYMBOL_GPL(si_swapinfo);
Gerald Schaefer0c3252d2008-07-14 09:57:27 +0200572#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573EXPORT_SYMBOL_GPL(nr_threads);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574EXPORT_SYMBOL_GPL(nr_running);
575EXPORT_SYMBOL_GPL(nr_iowait);