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