1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * SCLP Store Data support and sysfs interface
4 *
5 * Copyright IBM Corp. 2017
6 */
7
8 #define KMSG_COMPONENT "sclp_sd"
9 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
10
11 #include <linux/completion.h>
12 #include <linux/kobject.h>
13 #include <linux/list.h>
14 #include <linux/printk.h>
15 #include <linux/slab.h>
16 #include <linux/vmalloc.h>
17 #include <linux/async.h>
18 #include <linux/export.h>
19 #include <linux/mutex.h>
20
21 #include <asm/pgalloc.h>
22
23 #include "sclp.h"
24
25 #define SD_EQ_STORE_DATA 0
26 #define SD_EQ_HALT 1
27 #define SD_EQ_SIZE 2
28
29 #define SD_DI_CONFIG 3
30
31 struct sclp_sd_evbuf {
32 struct evbuf_header hdr;
33 u8 eq;
34 u8 di;
35 u8 rflags;
36 u64 :56;
37 u32 id;
38 u16 :16;
39 u8 fmt;
40 u8 status;
41 u64 sat;
42 u64 sa;
43 u32 esize;
44 u32 dsize;
45 } __packed;
46
47 struct sclp_sd_sccb {
48 struct sccb_header hdr;
49 struct sclp_sd_evbuf evbuf;
50 } __packed __aligned(PAGE_SIZE);
51
52 /**
53 * struct sclp_sd_data - Result of a Store Data request
54 * @esize_bytes: Resulting esize in bytes
55 * @dsize_bytes: Resulting dsize in bytes
56 * @data: Pointer to data - must be released using vfree()
57 */
58 struct sclp_sd_data {
59 size_t esize_bytes;
60 size_t dsize_bytes;
61 void *data;
62 };
63
64 /**
65 * struct sclp_sd_listener - Listener for asynchronous Store Data response
66 * @list: For enqueueing this struct
67 * @id: Event ID of response to listen for
68 * @completion: Can be used to wait for response
69 * @evbuf: Contains the resulting Store Data response after completion
70 */
71 struct sclp_sd_listener {
72 struct list_head list;
73 u32 id;
74 struct completion completion;
75 struct sclp_sd_evbuf evbuf;
76 };
77
78 /**
79 * struct sclp_sd_file - Sysfs representation of a Store Data entity
80 * @kobj: Kobject
81 * @data_attr: Attribute for accessing data contents
82 * @data_mutex: Mutex to serialize access and updates to @data
83 * @data: Data associated with this entity
84 * @di: DI value associated with this entity
85 */
86 struct sclp_sd_file {
87 struct kobject kobj;
88 struct bin_attribute data_attr;
89 struct mutex data_mutex;
90 struct sclp_sd_data data;
91 u8 di;
92 };
93 #define to_sd_file(x) container_of(x, struct sclp_sd_file, kobj)
94
95 static struct kset *sclp_sd_kset;
96 static struct sclp_sd_file *config_file;
97
98 static LIST_HEAD(sclp_sd_queue);
99 static DEFINE_SPINLOCK(sclp_sd_queue_lock);
100
101 /**
102 * sclp_sd_listener_add() - Add listener for Store Data responses
103 * @listener: Listener to add
104 */
sclp_sd_listener_add(struct sclp_sd_listener * listener)105 static void sclp_sd_listener_add(struct sclp_sd_listener *listener)
106 {
107 spin_lock_irq(&sclp_sd_queue_lock);
108 list_add_tail(&listener->list, &sclp_sd_queue);
109 spin_unlock_irq(&sclp_sd_queue_lock);
110 }
111
112 /**
113 * sclp_sd_listener_remove() - Remove listener for Store Data responses
114 * @listener: Listener to remove
115 */
sclp_sd_listener_remove(struct sclp_sd_listener * listener)116 static void sclp_sd_listener_remove(struct sclp_sd_listener *listener)
117 {
118 spin_lock_irq(&sclp_sd_queue_lock);
119 list_del(&listener->list);
120 spin_unlock_irq(&sclp_sd_queue_lock);
121 }
122
123 /**
124 * sclp_sd_listener_init() - Initialize a Store Data response listener
125 * @id: Event ID to listen for
126 *
127 * Initialize a listener for asynchronous Store Data responses. This listener
128 * can afterwards be used to wait for a specific response and to retrieve
129 * the associated response data.
130 */
sclp_sd_listener_init(struct sclp_sd_listener * listener,u32 id)131 static void sclp_sd_listener_init(struct sclp_sd_listener *listener, u32 id)
132 {
133 memset(listener, 0, sizeof(*listener));
134 listener->id = id;
135 init_completion(&listener->completion);
136 }
137
138 /**
139 * sclp_sd_receiver() - Receiver for Store Data events
140 * @evbuf_hdr: Header of received events
141 *
142 * Process Store Data events and complete listeners with matching event IDs.
143 */
sclp_sd_receiver(struct evbuf_header * evbuf_hdr)144 static void sclp_sd_receiver(struct evbuf_header *evbuf_hdr)
145 {
146 struct sclp_sd_evbuf *evbuf = (struct sclp_sd_evbuf *) evbuf_hdr;
147 struct sclp_sd_listener *listener;
148 int found = 0;
149
150 pr_debug("received event (id=0x%08x)\n", evbuf->id);
151 spin_lock(&sclp_sd_queue_lock);
152 list_for_each_entry(listener, &sclp_sd_queue, list) {
153 if (listener->id != evbuf->id)
154 continue;
155
156 listener->evbuf = *evbuf;
157 complete(&listener->completion);
158 found = 1;
159 break;
160 }
161 spin_unlock(&sclp_sd_queue_lock);
162
163 if (!found)
164 pr_debug("unsolicited event (id=0x%08x)\n", evbuf->id);
165 }
166
167 static struct sclp_register sclp_sd_register = {
168 .send_mask = EVTYP_STORE_DATA_MASK,
169 .receive_mask = EVTYP_STORE_DATA_MASK,
170 .receiver_fn = sclp_sd_receiver,
171 };
172
173 /**
174 * sclp_sd_sync() - Perform Store Data request synchronously
175 * @page: Address of work page - must be below 2GB
176 * @eq: Input EQ value
177 * @di: Input DI value
178 * @sat: Input SAT value
179 * @sa: Input SA value used to specify the address of the target buffer
180 * @dsize_ptr: Optional pointer to input and output DSIZE value
181 * @esize_ptr: Optional pointer to output ESIZE value
182 *
183 * Perform Store Data request with specified parameters and wait for completion.
184 *
185 * Return %0 on success and store resulting DSIZE and ESIZE values in
186 * @dsize_ptr and @esize_ptr (if provided). Return non-zero on error.
187 */
sclp_sd_sync(unsigned long page,u8 eq,u8 di,u64 sat,u64 sa,u32 * dsize_ptr,u32 * esize_ptr)188 static int sclp_sd_sync(unsigned long page, u8 eq, u8 di, u64 sat, u64 sa,
189 u32 *dsize_ptr, u32 *esize_ptr)
190 {
191 struct sclp_sd_sccb *sccb = (void *) page;
192 struct sclp_sd_listener listener;
193 struct sclp_sd_evbuf *evbuf;
194 int rc;
195
196 sclp_sd_listener_init(&listener, (u32) (addr_t) sccb);
197 sclp_sd_listener_add(&listener);
198
199 /* Prepare SCCB */
200 memset(sccb, 0, PAGE_SIZE);
201 sccb->hdr.length = sizeof(sccb->hdr) + sizeof(sccb->evbuf);
202 evbuf = &sccb->evbuf;
203 evbuf->hdr.length = sizeof(*evbuf);
204 evbuf->hdr.type = EVTYP_STORE_DATA;
205 evbuf->eq = eq;
206 evbuf->di = di;
207 evbuf->id = listener.id;
208 evbuf->fmt = 1;
209 evbuf->sat = sat;
210 evbuf->sa = sa;
211 if (dsize_ptr)
212 evbuf->dsize = *dsize_ptr;
213
214 /* Perform command */
215 pr_debug("request (eq=%d, di=%d, id=0x%08x)\n", eq, di, listener.id);
216 rc = sclp_sync_request(SCLP_CMDW_WRITE_EVENT_DATA, sccb);
217 pr_debug("request done (rc=%d)\n", rc);
218 if (rc)
219 goto out;
220
221 /* Evaluate response */
222 if (sccb->hdr.response_code == 0x73f0) {
223 pr_debug("event not supported\n");
224 rc = -EIO;
225 goto out_remove;
226 }
227 if (sccb->hdr.response_code != 0x0020 || !(evbuf->hdr.flags & 0x80)) {
228 rc = -EIO;
229 goto out;
230 }
231 if (!(evbuf->rflags & 0x80)) {
232 rc = wait_for_completion_interruptible(&listener.completion);
233 if (rc)
234 goto out;
235 evbuf = &listener.evbuf;
236 }
237 switch (evbuf->status) {
238 case 0:
239 if (dsize_ptr)
240 *dsize_ptr = evbuf->dsize;
241 if (esize_ptr)
242 *esize_ptr = evbuf->esize;
243 pr_debug("success (dsize=%u, esize=%u)\n", evbuf->dsize,
244 evbuf->esize);
245 break;
246 case 3:
247 rc = -ENOENT;
248 break;
249 default:
250 rc = -EIO;
251 break;
252
253 }
254
255 out:
256 if (rc && rc != -ENOENT) {
257 /* Provide some information about what went wrong */
258 pr_warn("Store Data request failed (eq=%d, di=%d, "
259 "response=0x%04x, flags=0x%02x, status=%d, rc=%d)\n",
260 eq, di, sccb->hdr.response_code, evbuf->hdr.flags,
261 evbuf->status, rc);
262 }
263
264 out_remove:
265 sclp_sd_listener_remove(&listener);
266
267 return rc;
268 }
269
270 /**
271 * sclp_sd_store_data() - Obtain data for specified Store Data entity
272 * @result: Resulting data
273 * @di: DI value associated with this entity
274 *
275 * Perform a series of Store Data requests to obtain the size and contents of
276 * the specified Store Data entity.
277 *
278 * Return:
279 * %0: Success - result is stored in @result. @result->data must be
280 * released using vfree() after use.
281 * %-ENOENT: No data available for this entity
282 * %<0: Other error
283 */
sclp_sd_store_data(struct sclp_sd_data * result,u8 di)284 static int sclp_sd_store_data(struct sclp_sd_data *result, u8 di)
285 {
286 u32 dsize = 0, esize = 0;
287 unsigned long page, asce = 0;
288 void *data = NULL;
289 int rc;
290
291 page = __get_free_page(GFP_KERNEL | GFP_DMA);
292 if (!page)
293 return -ENOMEM;
294
295 /* Get size */
296 rc = sclp_sd_sync(page, SD_EQ_SIZE, di, 0, 0, &dsize, &esize);
297 if (rc)
298 goto out;
299 if (dsize == 0)
300 goto out_result;
301
302 /* Allocate memory */
303 data = vzalloc(array_size((size_t)dsize, PAGE_SIZE));
304 if (!data) {
305 rc = -ENOMEM;
306 goto out;
307 }
308
309 /* Get translation table for buffer */
310 asce = base_asce_alloc((unsigned long) data, dsize);
311 if (!asce) {
312 vfree(data);
313 rc = -ENOMEM;
314 goto out;
315 }
316
317 /* Get data */
318 rc = sclp_sd_sync(page, SD_EQ_STORE_DATA, di, asce, (u64) data, &dsize,
319 &esize);
320 if (rc) {
321 /* Cancel running request if interrupted */
322 if (rc == -ERESTARTSYS)
323 sclp_sd_sync(page, SD_EQ_HALT, di, 0, 0, NULL, NULL);
324 vfree(data);
325 goto out;
326 }
327
328 out_result:
329 result->esize_bytes = (size_t) esize * PAGE_SIZE;
330 result->dsize_bytes = (size_t) dsize * PAGE_SIZE;
331 result->data = data;
332
333 out:
334 base_asce_free(asce);
335 free_page(page);
336
337 return rc;
338 }
339
340 /**
341 * sclp_sd_data_reset() - Reset Store Data result buffer
342 * @data: Data buffer to reset
343 *
344 * Reset @data to initial state and release associated memory.
345 */
sclp_sd_data_reset(struct sclp_sd_data * data)346 static void sclp_sd_data_reset(struct sclp_sd_data *data)
347 {
348 vfree(data->data);
349 data->data = NULL;
350 data->dsize_bytes = 0;
351 data->esize_bytes = 0;
352 }
353
354 /**
355 * sclp_sd_file_release() - Release function for sclp_sd_file object
356 * @kobj: Kobject embedded in sclp_sd_file object
357 */
sclp_sd_file_release(struct kobject * kobj)358 static void sclp_sd_file_release(struct kobject *kobj)
359 {
360 struct sclp_sd_file *sd_file = to_sd_file(kobj);
361
362 sclp_sd_data_reset(&sd_file->data);
363 kfree(sd_file);
364 }
365
366 /**
367 * sclp_sd_file_update() - Update contents of sclp_sd_file object
368 * @sd_file: Object to update
369 *
370 * Obtain the current version of data associated with the Store Data entity
371 * @sd_file.
372 *
373 * On success, return %0 and generate a KOBJ_CHANGE event to indicate that the
374 * data may have changed. Return non-zero otherwise.
375 */
sclp_sd_file_update(struct sclp_sd_file * sd_file)376 static int sclp_sd_file_update(struct sclp_sd_file *sd_file)
377 {
378 const char *name = kobject_name(&sd_file->kobj);
379 struct sclp_sd_data data;
380 int rc;
381
382 rc = sclp_sd_store_data(&data, sd_file->di);
383 if (rc) {
384 if (rc == -ENOENT) {
385 pr_info("No data is available for the %s data entity\n",
386 name);
387 }
388 return rc;
389 }
390
391 mutex_lock(&sd_file->data_mutex);
392 sclp_sd_data_reset(&sd_file->data);
393 sd_file->data = data;
394 mutex_unlock(&sd_file->data_mutex);
395
396 pr_info("A %zu-byte %s data entity was retrieved\n", data.dsize_bytes,
397 name);
398 kobject_uevent(&sd_file->kobj, KOBJ_CHANGE);
399
400 return 0;
401 }
402
403 /**
404 * sclp_sd_file_update_async() - Wrapper for asynchronous update call
405 * @data: Object to update
406 */
sclp_sd_file_update_async(void * data,async_cookie_t cookie)407 static void sclp_sd_file_update_async(void *data, async_cookie_t cookie)
408 {
409 struct sclp_sd_file *sd_file = data;
410
411 sclp_sd_file_update(sd_file);
412 }
413
414 /**
415 * reload_store() - Store function for "reload" sysfs attribute
416 * @kobj: Kobject of sclp_sd_file object
417 *
418 * Initiate a reload of the data associated with an sclp_sd_file object.
419 */
reload_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)420 static ssize_t reload_store(struct kobject *kobj, struct kobj_attribute *attr,
421 const char *buf, size_t count)
422 {
423 struct sclp_sd_file *sd_file = to_sd_file(kobj);
424
425 sclp_sd_file_update(sd_file);
426
427 return count;
428 }
429
430 static struct kobj_attribute reload_attr = __ATTR_WO(reload);
431
432 static struct attribute *sclp_sd_file_default_attrs[] = {
433 &reload_attr.attr,
434 NULL,
435 };
436
437 static struct kobj_type sclp_sd_file_ktype = {
438 .sysfs_ops = &kobj_sysfs_ops,
439 .release = sclp_sd_file_release,
440 .default_attrs = sclp_sd_file_default_attrs,
441 };
442
443 /**
444 * data_read() - Read function for "read" sysfs attribute
445 * @kobj: Kobject of sclp_sd_file object
446 * @buffer: Target buffer
447 * @off: Requested file offset
448 * @size: Requested number of bytes
449 *
450 * Store the requested portion of the Store Data entity contents into the
451 * specified buffer. Return the number of bytes stored on success, or %0
452 * on EOF.
453 */
data_read(struct file * file,struct kobject * kobj,struct bin_attribute * attr,char * buffer,loff_t off,size_t size)454 static ssize_t data_read(struct file *file, struct kobject *kobj,
455 struct bin_attribute *attr, char *buffer,
456 loff_t off, size_t size)
457 {
458 struct sclp_sd_file *sd_file = to_sd_file(kobj);
459 size_t data_size;
460 char *data;
461
462 mutex_lock(&sd_file->data_mutex);
463
464 data = sd_file->data.data;
465 data_size = sd_file->data.dsize_bytes;
466 if (!data || off >= data_size) {
467 size = 0;
468 } else {
469 if (off + size > data_size)
470 size = data_size - off;
471 memcpy(buffer, data + off, size);
472 }
473
474 mutex_unlock(&sd_file->data_mutex);
475
476 return size;
477 }
478
479 /**
480 * sclp_sd_file_create() - Add a sysfs file representing a Store Data entity
481 * @name: Name of file
482 * @di: DI value associated with this entity
483 *
484 * Create a sysfs directory with the given @name located under
485 *
486 * /sys/firmware/sclp_sd/
487 *
488 * The files in this directory can be used to access the contents of the Store
489 * Data entity associated with @DI.
490 *
491 * Return pointer to resulting sclp_sd_file object on success, %NULL otherwise.
492 * The object must be freed by calling kobject_put() on the embedded kobject
493 * pointer after use.
494 */
sclp_sd_file_create(const char * name,u8 di)495 static __init struct sclp_sd_file *sclp_sd_file_create(const char *name, u8 di)
496 {
497 struct sclp_sd_file *sd_file;
498 int rc;
499
500 sd_file = kzalloc(sizeof(*sd_file), GFP_KERNEL);
501 if (!sd_file)
502 return NULL;
503 sd_file->di = di;
504 mutex_init(&sd_file->data_mutex);
505
506 /* Create kobject located under /sys/firmware/sclp_sd/ */
507 sd_file->kobj.kset = sclp_sd_kset;
508 rc = kobject_init_and_add(&sd_file->kobj, &sclp_sd_file_ktype, NULL,
509 "%s", name);
510 if (rc) {
511 kobject_put(&sd_file->kobj);
512 return NULL;
513 }
514
515 sysfs_bin_attr_init(&sd_file->data_attr);
516 sd_file->data_attr.attr.name = "data";
517 sd_file->data_attr.attr.mode = 0444;
518 sd_file->data_attr.read = data_read;
519
520 rc = sysfs_create_bin_file(&sd_file->kobj, &sd_file->data_attr);
521 if (rc) {
522 kobject_put(&sd_file->kobj);
523 return NULL;
524 }
525
526 /*
527 * For completeness only - users interested in entity data should listen
528 * for KOBJ_CHANGE instead.
529 */
530 kobject_uevent(&sd_file->kobj, KOBJ_ADD);
531
532 /* Don't let a slow Store Data request delay further initialization */
533 async_schedule(sclp_sd_file_update_async, sd_file);
534
535 return sd_file;
536 }
537
538 /**
539 * sclp_sd_init() - Initialize sclp_sd support and register sysfs files
540 */
sclp_sd_init(void)541 static __init int sclp_sd_init(void)
542 {
543 int rc;
544
545 rc = sclp_register(&sclp_sd_register);
546 if (rc)
547 return rc;
548
549 /* Create kset named "sclp_sd" located under /sys/firmware/ */
550 rc = -ENOMEM;
551 sclp_sd_kset = kset_create_and_add("sclp_sd", NULL, firmware_kobj);
552 if (!sclp_sd_kset)
553 goto err_kset;
554
555 rc = -EINVAL;
556 config_file = sclp_sd_file_create("config", SD_DI_CONFIG);
557 if (!config_file)
558 goto err_config;
559
560 return 0;
561
562 err_config:
563 kset_unregister(sclp_sd_kset);
564 err_kset:
565 sclp_unregister(&sclp_sd_register);
566
567 return rc;
568 }
569 device_initcall(sclp_sd_init);
570