1
2
3
4
5
6
7
8#define KMSG_COMPONENT "sclp_sdias"
9#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
10
11#include <linux/completion.h>
12#include <linux/sched.h>
13#include <asm/sclp.h>
14#include <asm/debug.h>
15#include <asm/ipl.h>
16
17#include "sclp_sdias.h"
18#include "sclp.h"
19#include "sclp_rw.h"
20
21#define TRACE(x...) debug_sprintf_event(sdias_dbf, 1, x)
22
23#define SDIAS_RETRIES 300
24
25static struct debug_info *sdias_dbf;
26
27static struct sclp_register sclp_sdias_register = {
28 .send_mask = EVTYP_SDIAS_MASK,
29};
30
31static struct sdias_sccb sccb __attribute__((aligned(4096)));
32static struct sdias_evbuf sdias_evbuf;
33
34static DECLARE_COMPLETION(evbuf_accepted);
35static DECLARE_COMPLETION(evbuf_done);
36static DEFINE_MUTEX(sdias_mutex);
37
38
39
40
41static void sclp_sdias_receiver_fn(struct evbuf_header *evbuf)
42{
43 memcpy(&sdias_evbuf, evbuf,
44 min_t(unsigned long, sizeof(sdias_evbuf), evbuf->length));
45 complete(&evbuf_done);
46 TRACE("sclp_sdias_receiver_fn done\n");
47}
48
49
50
51
52static void sdias_callback(struct sclp_req *request, void *data)
53{
54 complete(&evbuf_accepted);
55 TRACE("callback done\n");
56}
57
58static int sdias_sclp_send(struct sclp_req *req)
59{
60 int retries;
61 int rc;
62
63 for (retries = SDIAS_RETRIES; retries; retries--) {
64 TRACE("add request\n");
65 rc = sclp_add_request(req);
66 if (rc) {
67
68 set_current_state(TASK_INTERRUPTIBLE);
69 TRACE("add request failed: rc = %i\n",rc);
70 schedule_timeout(msecs_to_jiffies(500));
71 continue;
72 }
73
74 wait_for_completion(&evbuf_accepted);
75 if (req->status == SCLP_REQ_FAILED) {
76 TRACE("sclp request failed\n");
77 continue;
78 }
79
80 if (!(sccb.evbuf.hdr.flags & 0x80)) {
81 TRACE("sclp request failed: flags=%x\n",
82 sccb.evbuf.hdr.flags);
83 continue;
84 }
85
86
87
88 if (!sclp_sdias_register.receiver_fn) {
89 memcpy(&sdias_evbuf, &sccb.evbuf, sizeof(sdias_evbuf));
90 TRACE("sync request done\n");
91 return 0;
92 }
93
94 wait_for_completion(&evbuf_done);
95 TRACE("request done\n");
96 return 0;
97 }
98 return -EIO;
99}
100
101
102
103
104int sclp_sdias_blk_count(void)
105{
106 struct sclp_req request;
107 int rc;
108
109 mutex_lock(&sdias_mutex);
110
111 memset(&sccb, 0, sizeof(sccb));
112 memset(&request, 0, sizeof(request));
113
114 sccb.hdr.length = sizeof(sccb);
115 sccb.evbuf.hdr.length = sizeof(struct sdias_evbuf);
116 sccb.evbuf.hdr.type = EVTYP_SDIAS;
117 sccb.evbuf.event_qual = SDIAS_EQ_SIZE;
118 sccb.evbuf.data_id = SDIAS_DI_FCP_DUMP;
119 sccb.evbuf.event_id = 4712;
120 sccb.evbuf.dbs = 1;
121
122 request.sccb = &sccb;
123 request.command = SCLP_CMDW_WRITE_EVENT_DATA;
124 request.status = SCLP_REQ_FILLED;
125 request.callback = sdias_callback;
126
127 rc = sdias_sclp_send(&request);
128 if (rc) {
129 pr_err("sclp_send failed for get_nr_blocks\n");
130 goto out;
131 }
132 if (sccb.hdr.response_code != 0x0020) {
133 TRACE("send failed: %x\n", sccb.hdr.response_code);
134 rc = -EIO;
135 goto out;
136 }
137
138 switch (sdias_evbuf.event_status) {
139 case 0:
140 rc = sdias_evbuf.blk_cnt;
141 break;
142 default:
143 pr_err("SCLP error: %x\n", sdias_evbuf.event_status);
144 rc = -EIO;
145 goto out;
146 }
147 TRACE("%i blocks\n", rc);
148out:
149 mutex_unlock(&sdias_mutex);
150 return rc;
151}
152
153
154
155
156
157
158
159
160
161
162
163int sclp_sdias_copy(void *dest, int start_blk, int nr_blks)
164{
165 struct sclp_req request;
166 int rc;
167
168 mutex_lock(&sdias_mutex);
169
170 memset(&sccb, 0, sizeof(sccb));
171 memset(&request, 0, sizeof(request));
172
173 sccb.hdr.length = sizeof(sccb);
174 sccb.evbuf.hdr.length = sizeof(struct sdias_evbuf);
175 sccb.evbuf.hdr.type = EVTYP_SDIAS;
176 sccb.evbuf.hdr.flags = 0;
177 sccb.evbuf.event_qual = SDIAS_EQ_STORE_DATA;
178 sccb.evbuf.data_id = SDIAS_DI_FCP_DUMP;
179 sccb.evbuf.event_id = 4712;
180 sccb.evbuf.asa_size = SDIAS_ASA_SIZE_64;
181 sccb.evbuf.event_status = 0;
182 sccb.evbuf.blk_cnt = nr_blks;
183 sccb.evbuf.asa = (unsigned long)dest;
184 sccb.evbuf.fbn = start_blk;
185 sccb.evbuf.lbn = 0;
186 sccb.evbuf.dbs = 1;
187
188 request.sccb = &sccb;
189 request.command = SCLP_CMDW_WRITE_EVENT_DATA;
190 request.status = SCLP_REQ_FILLED;
191 request.callback = sdias_callback;
192
193 rc = sdias_sclp_send(&request);
194 if (rc) {
195 pr_err("sclp_send failed: %x\n", rc);
196 goto out;
197 }
198 if (sccb.hdr.response_code != 0x0020) {
199 TRACE("copy failed: %x\n", sccb.hdr.response_code);
200 rc = -EIO;
201 goto out;
202 }
203
204 switch (sdias_evbuf.event_status) {
205 case SDIAS_EVSTATE_ALL_STORED:
206 TRACE("all stored\n");
207 break;
208 case SDIAS_EVSTATE_PART_STORED:
209 TRACE("part stored: %i\n", sdias_evbuf.blk_cnt);
210 break;
211 case SDIAS_EVSTATE_NO_DATA:
212 TRACE("no data\n");
213
214 default:
215 pr_err("Error from SCLP while copying hsa. Event status = %x\n",
216 sdias_evbuf.event_status);
217 rc = -EIO;
218 }
219out:
220 mutex_unlock(&sdias_mutex);
221 return rc;
222}
223
224static int __init sclp_sdias_register_check(void)
225{
226 int rc;
227
228 rc = sclp_register(&sclp_sdias_register);
229 if (rc)
230 return rc;
231 if (sclp_sdias_blk_count() == 0) {
232 sclp_unregister(&sclp_sdias_register);
233 return -ENODEV;
234 }
235 return 0;
236}
237
238static int __init sclp_sdias_init_sync(void)
239{
240 TRACE("Try synchronous mode\n");
241 sclp_sdias_register.receive_mask = 0;
242 sclp_sdias_register.receiver_fn = NULL;
243 return sclp_sdias_register_check();
244}
245
246static int __init sclp_sdias_init_async(void)
247{
248 TRACE("Try asynchronous mode\n");
249 sclp_sdias_register.receive_mask = EVTYP_SDIAS_MASK;
250 sclp_sdias_register.receiver_fn = sclp_sdias_receiver_fn;
251 return sclp_sdias_register_check();
252}
253
254int __init sclp_sdias_init(void)
255{
256 if (ipl_info.type != IPL_TYPE_FCP_DUMP)
257 return 0;
258 sdias_dbf = debug_register("dump_sdias", 4, 1, 4 * sizeof(long));
259 debug_register_view(sdias_dbf, &debug_sprintf_view);
260 debug_set_level(sdias_dbf, 6);
261 if (sclp_sdias_init_sync() == 0)
262 goto out;
263 if (sclp_sdias_init_async() == 0)
264 goto out;
265 TRACE("init failed\n");
266 return -ENODEV;
267out:
268 TRACE("init done\n");
269 return 0;
270}
271
272void __exit sclp_sdias_exit(void)
273{
274 debug_unregister(sdias_dbf);
275 sclp_unregister(&sclp_sdias_register);
276}
277