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 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 */ 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 */ 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 * @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 */ 132 static 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 */ 145 static 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 168 static 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 */ 189 static 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 263 out: 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 272 out_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 */ 292 static 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 342 out_result: 343 result->esize_bytes = (size_t) esize * PAGE_SIZE; 344 result->dsize_bytes = (size_t) dsize * PAGE_SIZE; 345 result->data = data; 346 347 out: 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 */ 360 static 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 */ 372 static 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 */ 390 static 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 */ 422 static 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 */ 438 static 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 448 static struct kobj_attribute reload_attr = __ATTR_WO(reload); 449 450 static struct attribute *sclp_sd_file_default_attrs[] = { 451 &reload_attr.attr, 452 NULL, 453 }; 454 ATTRIBUTE_GROUPS(sclp_sd_file_default); 455 456 static 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 */ 475 static 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 */ 516 static __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 */ 562 static __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 583 err_config: 584 kset_unregister(sclp_sd_kset); 585 err_kset: 586 sclp_unregister(&sclp_sd_register); 587 588 return rc; 589 } 590 device_initcall(sclp_sd_init); 591