blob: 7ad30e72f868de1e45ef7e4bdd81cfa8a4701ca4 [file] [log] [blame]
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +02001/*
2 * Enable Asynchronous Notification via SCLP.
3 *
4 * Copyright IBM Corp. 2009
5 * Author(s): Hans-Joachim Picht <hans@linux.vnet.ibm.com>
6 *
7 */
8
9#include <linux/init.h>
10#include <linux/module.h>
11#include <linux/device.h>
12#include <linux/stat.h>
13#include <linux/string.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090014#include <linux/slab.h>
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +020015#include <linux/ctype.h>
16#include <linux/kmod.h>
17#include <linux/err.h>
18#include <linux/errno.h>
19#include <linux/proc_fs.h>
20#include <linux/sysctl.h>
21#include <linux/utsname.h>
22#include "sclp.h"
23
24static int callhome_enabled;
25static struct sclp_req *request;
26static struct sclp_async_sccb *sccb;
27static int sclp_async_send_wait(char *message);
28static struct ctl_table_header *callhome_sysctl_header;
29static DEFINE_SPINLOCK(sclp_async_lock);
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +020030#define SCLP_NORMAL_WRITE 0x00
31
32struct async_evbuf {
33 struct evbuf_header header;
34 u64 reserved;
35 u8 rflags;
36 u8 empty;
37 u8 rtype;
38 u8 otype;
39 char comp_id[12];
40 char data[3000]; /* there is still some space left */
41} __attribute__((packed));
42
43struct sclp_async_sccb {
44 struct sccb_header header;
45 struct async_evbuf evbuf;
46} __attribute__((packed));
47
48static struct sclp_register sclp_async_register = {
49 .send_mask = EVTYP_ASYNC_MASK,
50};
51
52static int call_home_on_panic(struct notifier_block *self,
53 unsigned long event, void *data)
54{
Heiko Carstense8a79c92009-10-29 15:04:11 +010055 strncat(data, init_utsname()->nodename,
56 sizeof(init_utsname()->nodename));
57 sclp_async_send_wait(data);
58 return NOTIFY_DONE;
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +020059}
60
61static struct notifier_block call_home_panic_nb = {
62 .notifier_call = call_home_on_panic,
63 .priority = INT_MAX,
64};
65
Heiko Carstensd3acf712009-10-14 12:43:49 +020066static int proc_handler_callhome(struct ctl_table *ctl, int write,
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +020067 void __user *buffer, size_t *count,
68 loff_t *ppos)
69{
70 unsigned long val;
71 int len, rc;
Sebastian Ott3f0b3c32009-10-29 15:04:07 +010072 char buf[3];
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +020073
Sebastian Ott3f0b3c32009-10-29 15:04:07 +010074 if (!*count || (*ppos && !write)) {
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +020075 *count = 0;
76 return 0;
77 }
78 if (!write) {
Sebastian Ott3f0b3c32009-10-29 15:04:07 +010079 len = snprintf(buf, sizeof(buf), "%d\n", callhome_enabled);
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +020080 rc = copy_to_user(buffer, buf, sizeof(buf));
81 if (rc != 0)
82 return -EFAULT;
83 } else {
84 len = *count;
85 rc = copy_from_user(buf, buffer, sizeof(buf));
86 if (rc != 0)
87 return -EFAULT;
Dan Carpenter35ac7342010-04-09 13:42:59 +020088 buf[sizeof(buf) - 1] = '\0';
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +020089 if (strict_strtoul(buf, 0, &val) != 0)
90 return -EINVAL;
91 if (val != 0 && val != 1)
92 return -EINVAL;
93 callhome_enabled = val;
94 }
95 *count = len;
96 *ppos += len;
97 return 0;
98}
99
100static struct ctl_table callhome_table[] = {
101 {
102 .procname = "callhome",
103 .mode = 0644,
Heiko Carstensd3acf712009-10-14 12:43:49 +0200104 .proc_handler = proc_handler_callhome,
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200105 },
Eric W. Biedermanb05fd352009-04-03 04:36:34 -0700106 {}
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200107};
108
109static struct ctl_table kern_dir_table[] = {
110 {
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200111 .procname = "kernel",
112 .maxlen = 0,
113 .mode = 0555,
114 .child = callhome_table,
115 },
Eric W. Biedermanb05fd352009-04-03 04:36:34 -0700116 {}
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200117};
118
119/*
120 * Function used to transfer asynchronous notification
121 * records which waits for send completion
122 */
123static int sclp_async_send_wait(char *message)
124{
125 struct async_evbuf *evb;
126 int rc;
127 unsigned long flags;
128
129 if (!callhome_enabled)
130 return 0;
131 sccb->evbuf.header.type = EVTYP_ASYNC;
132 sccb->evbuf.rtype = 0xA5;
133 sccb->evbuf.otype = 0x00;
134 evb = &sccb->evbuf;
135 request->command = SCLP_CMDW_WRITE_EVENT_DATA;
136 request->sccb = sccb;
137 request->status = SCLP_REQ_FILLED;
138 strncpy(sccb->evbuf.data, message, sizeof(sccb->evbuf.data));
139 /*
140 * Retain Queue
141 * e.g. 5639CC140 500 Red Hat RHEL5 Linux for zSeries (RHEL AS)
142 */
143 strncpy(sccb->evbuf.comp_id, "000000000", sizeof(sccb->evbuf.comp_id));
144 sccb->evbuf.header.length = sizeof(sccb->evbuf);
145 sccb->header.length = sizeof(sccb->evbuf) + sizeof(sccb->header);
146 sccb->header.function_code = SCLP_NORMAL_WRITE;
147 rc = sclp_add_request(request);
148 if (rc)
149 return rc;
150 spin_lock_irqsave(&sclp_async_lock, flags);
151 while (request->status != SCLP_REQ_DONE &&
152 request->status != SCLP_REQ_FAILED) {
153 sclp_sync_wait();
154 }
155 spin_unlock_irqrestore(&sclp_async_lock, flags);
156 if (request->status != SCLP_REQ_DONE)
157 return -EIO;
158 rc = ((struct sclp_async_sccb *)
159 request->sccb)->header.response_code;
160 if (rc != 0x0020)
161 return -EIO;
162 if (evb->header.flags != 0x80)
163 return -EIO;
164 return rc;
165}
166
167static int __init sclp_async_init(void)
168{
169 int rc;
170
171 rc = sclp_register(&sclp_async_register);
172 if (rc)
173 return rc;
Heiko Carstens4a0fb4c2009-10-29 15:04:10 +0100174 rc = -EOPNOTSUPP;
175 if (!(sclp_async_register.sclp_receive_mask & EVTYP_ASYNC_MASK))
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200176 goto out_sclp;
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200177 rc = -ENOMEM;
Heiko Carstens4a0fb4c2009-10-29 15:04:10 +0100178 callhome_sysctl_header = register_sysctl_table(kern_dir_table);
179 if (!callhome_sysctl_header)
180 goto out_sclp;
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200181 request = kzalloc(sizeof(struct sclp_req), GFP_KERNEL);
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200182 sccb = (struct sclp_async_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
Heiko Carstens4a0fb4c2009-10-29 15:04:10 +0100183 if (!request || !sccb)
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200184 goto out_mem;
Heiko Carstens4a0fb4c2009-10-29 15:04:10 +0100185 rc = atomic_notifier_chain_register(&panic_notifier_list,
186 &call_home_panic_nb);
Heiko Carstense8a79c92009-10-29 15:04:11 +0100187 if (!rc)
188 goto out;
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200189out_mem:
190 kfree(request);
191 free_page((unsigned long) sccb);
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200192 unregister_sysctl_table(callhome_sysctl_header);
193out_sclp:
194 sclp_unregister(&sclp_async_register);
Heiko Carstens4a0fb4c2009-10-29 15:04:10 +0100195out:
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200196 return rc;
Hans-Joachim Pichtc114728a2009-09-11 10:28:47 +0200197}
198module_init(sclp_async_init);
199
200static void __exit sclp_async_exit(void)
201{
202 atomic_notifier_chain_unregister(&panic_notifier_list,
203 &call_home_panic_nb);
204 unregister_sysctl_table(callhome_sysctl_header);
205 sclp_unregister(&sclp_async_register);
206 free_page((unsigned long) sccb);
207 kfree(request);
208}
209module_exit(sclp_async_exit);
210
211MODULE_AUTHOR("Copyright IBM Corp. 2009");
212MODULE_AUTHOR("Hans-Joachim Picht <hans@linux.vnet.ibm.com>");
213MODULE_LICENSE("GPL");
214MODULE_DESCRIPTION("SCLP Asynchronous Notification Records");