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