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