sclp_sd.c

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