1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright 2020-21 IBM Corp. 4 */ 5 6 #define pr_fmt(fmt) "vas: " fmt 7 8 #include <linux/module.h> 9 #include <linux/kernel.h> 10 #include <linux/export.h> 11 #include <linux/types.h> 12 #include <linux/delay.h> 13 #include <linux/slab.h> 14 #include <linux/interrupt.h> 15 #include <linux/irqdomain.h> 16 #include <asm/machdep.h> 17 #include <asm/hvcall.h> 18 #include <asm/plpar_wrappers.h> 19 #include <asm/vas.h> 20 #include "vas.h" 21 22 #define VAS_INVALID_WIN_ADDRESS 0xFFFFFFFFFFFFFFFFul 23 #define VAS_DEFAULT_DOMAIN_ID 0xFFFFFFFFFFFFFFFFul 24 /* The hypervisor allows one credit per window right now */ 25 #define DEF_WIN_CREDS 1 26 27 static struct vas_all_caps caps_all; 28 static bool copypaste_feat; 29 static struct hv_vas_cop_feat_caps hv_cop_caps; 30 31 static struct vas_caps vascaps[VAS_MAX_FEAT_TYPE]; 32 static DEFINE_MUTEX(vas_pseries_mutex); 33 static bool migration_in_progress; 34 35 static long hcall_return_busy_check(long rc) 36 { 37 /* Check if we are stalled for some time */ 38 if (H_IS_LONG_BUSY(rc)) { 39 msleep(get_longbusy_msecs(rc)); 40 rc = H_BUSY; 41 } else if (rc == H_BUSY) { 42 cond_resched(); 43 } 44 45 return rc; 46 } 47 48 /* 49 * Allocate VAS window hcall 50 */ 51 static int h_allocate_vas_window(struct pseries_vas_window *win, u64 *domain, 52 u8 wintype, u16 credits) 53 { 54 long retbuf[PLPAR_HCALL9_BUFSIZE] = {0}; 55 long rc; 56 57 do { 58 rc = plpar_hcall9(H_ALLOCATE_VAS_WINDOW, retbuf, wintype, 59 credits, domain[0], domain[1], domain[2], 60 domain[3], domain[4], domain[5]); 61 62 rc = hcall_return_busy_check(rc); 63 } while (rc == H_BUSY); 64 65 if (rc == H_SUCCESS) { 66 if (win->win_addr == VAS_INVALID_WIN_ADDRESS) { 67 pr_err("H_ALLOCATE_VAS_WINDOW: COPY/PASTE is not supported\n"); 68 return -ENOTSUPP; 69 } 70 win->vas_win.winid = retbuf[0]; 71 win->win_addr = retbuf[1]; 72 win->complete_irq = retbuf[2]; 73 win->fault_irq = retbuf[3]; 74 return 0; 75 } 76 77 pr_err("H_ALLOCATE_VAS_WINDOW error: %ld, wintype: %u, credits: %u\n", 78 rc, wintype, credits); 79 80 return -EIO; 81 } 82 83 /* 84 * Deallocate VAS window hcall. 85 */ 86 static int h_deallocate_vas_window(u64 winid) 87 { 88 long rc; 89 90 do { 91 rc = plpar_hcall_norets(H_DEALLOCATE_VAS_WINDOW, winid); 92 93 rc = hcall_return_busy_check(rc); 94 } while (rc == H_BUSY); 95 96 if (rc == H_SUCCESS) 97 return 0; 98 99 pr_err("H_DEALLOCATE_VAS_WINDOW error: %ld, winid: %llu\n", 100 rc, winid); 101 return -EIO; 102 } 103 104 /* 105 * Modify VAS window. 106 * After the window is opened with allocate window hcall, configure it 107 * with flags and LPAR PID before using. 108 */ 109 static int h_modify_vas_window(struct pseries_vas_window *win) 110 { 111 long rc; 112 113 /* 114 * AMR value is not supported in Linux VAS implementation. 115 * The hypervisor ignores it if 0 is passed. 116 */ 117 do { 118 rc = plpar_hcall_norets(H_MODIFY_VAS_WINDOW, 119 win->vas_win.winid, win->pid, 0, 120 VAS_MOD_WIN_FLAGS, 0); 121 122 rc = hcall_return_busy_check(rc); 123 } while (rc == H_BUSY); 124 125 if (rc == H_SUCCESS) 126 return 0; 127 128 pr_err("H_MODIFY_VAS_WINDOW error: %ld, winid %u pid %u\n", 129 rc, win->vas_win.winid, win->pid); 130 return -EIO; 131 } 132 133 /* 134 * This hcall is used to determine the capabilities from the hypervisor. 135 * @hcall: H_QUERY_VAS_CAPABILITIES or H_QUERY_NX_CAPABILITIES 136 * @query_type: If 0 is passed, the hypervisor returns the overall 137 * capabilities which provides all feature(s) that are 138 * available. Then query the hypervisor to get the 139 * corresponding capabilities for the specific feature. 140 * Example: H_QUERY_VAS_CAPABILITIES provides VAS GZIP QoS 141 * and VAS GZIP Default capabilities. 142 * H_QUERY_NX_CAPABILITIES provides NX GZIP 143 * capabilities. 144 * @result: Return buffer to save capabilities. 145 */ 146 int h_query_vas_capabilities(const u64 hcall, u8 query_type, u64 result) 147 { 148 long rc; 149 150 rc = plpar_hcall_norets(hcall, query_type, result); 151 152 if (rc == H_SUCCESS) 153 return 0; 154 155 /* H_FUNCTION means HV does not support VAS so don't print an error */ 156 if (rc != H_FUNCTION) { 157 pr_err("%s error %ld, query_type %u, result buffer 0x%llx\n", 158 (hcall == H_QUERY_VAS_CAPABILITIES) ? 159 "H_QUERY_VAS_CAPABILITIES" : 160 "H_QUERY_NX_CAPABILITIES", 161 rc, query_type, result); 162 } 163 164 return -EIO; 165 } 166 EXPORT_SYMBOL_GPL(h_query_vas_capabilities); 167 168 /* 169 * hcall to get fault CRB from the hypervisor. 170 */ 171 static int h_get_nx_fault(u32 winid, u64 buffer) 172 { 173 long rc; 174 175 rc = plpar_hcall_norets(H_GET_NX_FAULT, winid, buffer); 176 177 if (rc == H_SUCCESS) 178 return 0; 179 180 pr_err("H_GET_NX_FAULT error: %ld, winid %u, buffer 0x%llx\n", 181 rc, winid, buffer); 182 return -EIO; 183 184 } 185 186 /* 187 * Handle the fault interrupt. 188 * When the fault interrupt is received for each window, query the 189 * hypervisor to get the fault CRB on the specific fault. Then 190 * process the CRB by updating CSB or send signal if the user space 191 * CSB is invalid. 192 * Note: The hypervisor forwards an interrupt for each fault request. 193 * So one fault CRB to process for each H_GET_NX_FAULT hcall. 194 */ 195 static irqreturn_t pseries_vas_fault_thread_fn(int irq, void *data) 196 { 197 struct pseries_vas_window *txwin = data; 198 struct coprocessor_request_block crb; 199 struct vas_user_win_ref *tsk_ref; 200 int rc; 201 202 rc = h_get_nx_fault(txwin->vas_win.winid, (u64)virt_to_phys(&crb)); 203 if (!rc) { 204 tsk_ref = &txwin->vas_win.task_ref; 205 vas_dump_crb(&crb); 206 vas_update_csb(&crb, tsk_ref); 207 } 208 209 return IRQ_HANDLED; 210 } 211 212 /* 213 * Allocate window and setup IRQ mapping. 214 */ 215 static int allocate_setup_window(struct pseries_vas_window *txwin, 216 u64 *domain, u8 wintype) 217 { 218 int rc; 219 220 rc = h_allocate_vas_window(txwin, domain, wintype, DEF_WIN_CREDS); 221 if (rc) 222 return rc; 223 /* 224 * On PowerVM, the hypervisor setup and forwards the fault 225 * interrupt per window. So the IRQ setup and fault handling 226 * will be done for each open window separately. 227 */ 228 txwin->fault_virq = irq_create_mapping(NULL, txwin->fault_irq); 229 if (!txwin->fault_virq) { 230 pr_err("Failed irq mapping %d\n", txwin->fault_irq); 231 rc = -EINVAL; 232 goto out_win; 233 } 234 235 txwin->name = kasprintf(GFP_KERNEL, "vas-win-%d", 236 txwin->vas_win.winid); 237 if (!txwin->name) { 238 rc = -ENOMEM; 239 goto out_irq; 240 } 241 242 rc = request_threaded_irq(txwin->fault_virq, NULL, 243 pseries_vas_fault_thread_fn, IRQF_ONESHOT, 244 txwin->name, txwin); 245 if (rc) { 246 pr_err("VAS-Window[%d]: Request IRQ(%u) failed with %d\n", 247 txwin->vas_win.winid, txwin->fault_virq, rc); 248 goto out_free; 249 } 250 251 txwin->vas_win.wcreds_max = DEF_WIN_CREDS; 252 253 return 0; 254 out_free: 255 kfree(txwin->name); 256 out_irq: 257 irq_dispose_mapping(txwin->fault_virq); 258 out_win: 259 h_deallocate_vas_window(txwin->vas_win.winid); 260 return rc; 261 } 262 263 static inline void free_irq_setup(struct pseries_vas_window *txwin) 264 { 265 free_irq(txwin->fault_virq, txwin); 266 kfree(txwin->name); 267 irq_dispose_mapping(txwin->fault_virq); 268 } 269 270 static struct vas_window *vas_allocate_window(int vas_id, u64 flags, 271 enum vas_cop_type cop_type) 272 { 273 long domain[PLPAR_HCALL9_BUFSIZE] = {VAS_DEFAULT_DOMAIN_ID}; 274 struct vas_cop_feat_caps *cop_feat_caps; 275 struct vas_caps *caps; 276 struct pseries_vas_window *txwin; 277 int rc; 278 279 txwin = kzalloc(sizeof(*txwin), GFP_KERNEL); 280 if (!txwin) 281 return ERR_PTR(-ENOMEM); 282 283 /* 284 * A VAS window can have many credits which means that many 285 * requests can be issued simultaneously. But the hypervisor 286 * restricts one credit per window. 287 * The hypervisor introduces 2 different types of credits: 288 * Default credit type (Uses normal priority FIFO): 289 * A limited number of credits are assigned to partitions 290 * based on processor entitlement. But these credits may be 291 * over-committed on a system depends on whether the CPUs 292 * are in shared or dedicated modes - that is, more requests 293 * may be issued across the system than NX can service at 294 * once which can result in paste command failure (RMA_busy). 295 * Then the process has to resend requests or fall-back to 296 * SW compression. 297 * Quality of Service (QoS) credit type (Uses high priority FIFO): 298 * To avoid NX HW contention, the system admins can assign 299 * QoS credits for each LPAR so that this partition is 300 * guaranteed access to NX resources. These credits are 301 * assigned to partitions via the HMC. 302 * Refer PAPR for more information. 303 * 304 * Allocate window with QoS credits if user requested. Otherwise 305 * default credits are used. 306 */ 307 if (flags & VAS_TX_WIN_FLAG_QOS_CREDIT) 308 caps = &vascaps[VAS_GZIP_QOS_FEAT_TYPE]; 309 else 310 caps = &vascaps[VAS_GZIP_DEF_FEAT_TYPE]; 311 312 cop_feat_caps = &caps->caps; 313 314 if (atomic_inc_return(&cop_feat_caps->nr_used_credits) > 315 atomic_read(&cop_feat_caps->nr_total_credits)) { 316 pr_err("Credits are not available to allocate window\n"); 317 rc = -EINVAL; 318 goto out; 319 } 320 321 if (vas_id == -1) { 322 /* 323 * The user space is requesting to allocate a window on 324 * a VAS instance where the process is executing. 325 * On PowerVM, domain values are passed to the hypervisor 326 * to select VAS instance. Useful if the process is 327 * affinity to NUMA node. 328 * The hypervisor selects VAS instance if 329 * VAS_DEFAULT_DOMAIN_ID (-1) is passed for domain values. 330 * The h_allocate_vas_window hcall is defined to take a 331 * domain values as specified by h_home_node_associativity, 332 * So no unpacking needs to be done. 333 */ 334 rc = plpar_hcall9(H_HOME_NODE_ASSOCIATIVITY, domain, 335 VPHN_FLAG_VCPU, smp_processor_id()); 336 if (rc != H_SUCCESS) { 337 pr_err("H_HOME_NODE_ASSOCIATIVITY error: %d\n", rc); 338 goto out; 339 } 340 } 341 342 txwin->pid = mfspr(SPRN_PID); 343 344 /* 345 * Allocate / Deallocate window hcalls and setup / free IRQs 346 * have to be protected with mutex. 347 * Open VAS window: Allocate window hcall and setup IRQ 348 * Close VAS window: Deallocate window hcall and free IRQ 349 * The hypervisor waits until all NX requests are 350 * completed before closing the window. So expects OS 351 * to handle NX faults, means IRQ can be freed only 352 * after the deallocate window hcall is returned. 353 * So once the window is closed with deallocate hcall before 354 * the IRQ is freed, it can be assigned to new allocate 355 * hcall with the same fault IRQ by the hypervisor. It can 356 * result in setup IRQ fail for the new window since the 357 * same fault IRQ is not freed by the OS before. 358 */ 359 mutex_lock(&vas_pseries_mutex); 360 if (migration_in_progress) 361 rc = -EBUSY; 362 else 363 rc = allocate_setup_window(txwin, (u64 *)&domain[0], 364 cop_feat_caps->win_type); 365 mutex_unlock(&vas_pseries_mutex); 366 if (rc) 367 goto out; 368 369 /* 370 * Modify window and it is ready to use. 371 */ 372 rc = h_modify_vas_window(txwin); 373 if (!rc) 374 rc = get_vas_user_win_ref(&txwin->vas_win.task_ref); 375 if (rc) 376 goto out_free; 377 378 txwin->win_type = cop_feat_caps->win_type; 379 mutex_lock(&vas_pseries_mutex); 380 /* 381 * Possible to lose the acquired credit with DLPAR core 382 * removal after the window is opened. So if there are any 383 * closed windows (means with lost credits), do not give new 384 * window to user space. New windows will be opened only 385 * after the existing windows are reopened when credits are 386 * available. 387 */ 388 if (!caps->nr_close_wins) { 389 list_add(&txwin->win_list, &caps->list); 390 caps->nr_open_windows++; 391 mutex_unlock(&vas_pseries_mutex); 392 vas_user_win_add_mm_context(&txwin->vas_win.task_ref); 393 return &txwin->vas_win; 394 } 395 mutex_unlock(&vas_pseries_mutex); 396 397 put_vas_user_win_ref(&txwin->vas_win.task_ref); 398 rc = -EBUSY; 399 pr_err("No credit is available to allocate window\n"); 400 401 out_free: 402 /* 403 * Window is not operational. Free IRQ before closing 404 * window so that do not have to hold mutex. 405 */ 406 free_irq_setup(txwin); 407 h_deallocate_vas_window(txwin->vas_win.winid); 408 out: 409 atomic_dec(&cop_feat_caps->nr_used_credits); 410 kfree(txwin); 411 return ERR_PTR(rc); 412 } 413 414 static u64 vas_paste_address(struct vas_window *vwin) 415 { 416 struct pseries_vas_window *win; 417 418 win = container_of(vwin, struct pseries_vas_window, vas_win); 419 return win->win_addr; 420 } 421 422 static int deallocate_free_window(struct pseries_vas_window *win) 423 { 424 int rc = 0; 425 426 /* 427 * The hypervisor waits for all requests including faults 428 * are processed before closing the window - Means all 429 * credits have to be returned. In the case of fault 430 * request, a credit is returned after OS issues 431 * H_GET_NX_FAULT hcall. 432 * So free IRQ after executing H_DEALLOCATE_VAS_WINDOW 433 * hcall. 434 */ 435 rc = h_deallocate_vas_window(win->vas_win.winid); 436 if (!rc) 437 free_irq_setup(win); 438 439 return rc; 440 } 441 442 static int vas_deallocate_window(struct vas_window *vwin) 443 { 444 struct pseries_vas_window *win; 445 struct vas_cop_feat_caps *caps; 446 int rc = 0; 447 448 if (!vwin) 449 return -EINVAL; 450 451 win = container_of(vwin, struct pseries_vas_window, vas_win); 452 453 /* Should not happen */ 454 if (win->win_type >= VAS_MAX_FEAT_TYPE) { 455 pr_err("Window (%u): Invalid window type %u\n", 456 vwin->winid, win->win_type); 457 return -EINVAL; 458 } 459 460 caps = &vascaps[win->win_type].caps; 461 mutex_lock(&vas_pseries_mutex); 462 /* 463 * VAS window is already closed in the hypervisor when 464 * lost the credit or with migration. So just remove the entry 465 * from the list, remove task references and free vas_window 466 * struct. 467 */ 468 if (!(win->vas_win.status & VAS_WIN_NO_CRED_CLOSE) && 469 !(win->vas_win.status & VAS_WIN_MIGRATE_CLOSE)) { 470 rc = deallocate_free_window(win); 471 if (rc) { 472 mutex_unlock(&vas_pseries_mutex); 473 return rc; 474 } 475 } else 476 vascaps[win->win_type].nr_close_wins--; 477 478 list_del(&win->win_list); 479 atomic_dec(&caps->nr_used_credits); 480 vascaps[win->win_type].nr_open_windows--; 481 mutex_unlock(&vas_pseries_mutex); 482 483 put_vas_user_win_ref(&vwin->task_ref); 484 mm_context_remove_vas_window(vwin->task_ref.mm); 485 486 kfree(win); 487 return 0; 488 } 489 490 static const struct vas_user_win_ops vops_pseries = { 491 .open_win = vas_allocate_window, /* Open and configure window */ 492 .paste_addr = vas_paste_address, /* To do copy/paste */ 493 .close_win = vas_deallocate_window, /* Close window */ 494 }; 495 496 /* 497 * Supporting only nx-gzip coprocessor type now, but this API code 498 * extended to other coprocessor types later. 499 */ 500 int vas_register_api_pseries(struct module *mod, enum vas_cop_type cop_type, 501 const char *name) 502 { 503 int rc; 504 505 if (!copypaste_feat) 506 return -ENOTSUPP; 507 508 rc = vas_register_coproc_api(mod, cop_type, name, &vops_pseries); 509 510 return rc; 511 } 512 EXPORT_SYMBOL_GPL(vas_register_api_pseries); 513 514 void vas_unregister_api_pseries(void) 515 { 516 vas_unregister_coproc_api(); 517 } 518 EXPORT_SYMBOL_GPL(vas_unregister_api_pseries); 519 520 /* 521 * Get the specific capabilities based on the feature type. 522 * Right now supports GZIP default and GZIP QoS capabilities. 523 */ 524 static int __init get_vas_capabilities(u8 feat, enum vas_cop_feat_type type, 525 struct hv_vas_cop_feat_caps *hv_caps) 526 { 527 struct vas_cop_feat_caps *caps; 528 struct vas_caps *vcaps; 529 int rc = 0; 530 531 vcaps = &vascaps[type]; 532 memset(vcaps, 0, sizeof(*vcaps)); 533 INIT_LIST_HEAD(&vcaps->list); 534 535 vcaps->feat = feat; 536 caps = &vcaps->caps; 537 538 rc = h_query_vas_capabilities(H_QUERY_VAS_CAPABILITIES, feat, 539 (u64)virt_to_phys(hv_caps)); 540 if (rc) 541 return rc; 542 543 caps->user_mode = hv_caps->user_mode; 544 if (!(caps->user_mode & VAS_COPY_PASTE_USER_MODE)) { 545 pr_err("User space COPY/PASTE is not supported\n"); 546 return -ENOTSUPP; 547 } 548 549 caps->descriptor = be64_to_cpu(hv_caps->descriptor); 550 caps->win_type = hv_caps->win_type; 551 if (caps->win_type >= VAS_MAX_FEAT_TYPE) { 552 pr_err("Unsupported window type %u\n", caps->win_type); 553 return -EINVAL; 554 } 555 caps->max_lpar_creds = be16_to_cpu(hv_caps->max_lpar_creds); 556 caps->max_win_creds = be16_to_cpu(hv_caps->max_win_creds); 557 atomic_set(&caps->nr_total_credits, 558 be16_to_cpu(hv_caps->target_lpar_creds)); 559 if (feat == VAS_GZIP_DEF_FEAT) { 560 caps->def_lpar_creds = be16_to_cpu(hv_caps->def_lpar_creds); 561 562 if (caps->max_win_creds < DEF_WIN_CREDS) { 563 pr_err("Window creds(%u) > max allowed window creds(%u)\n", 564 DEF_WIN_CREDS, caps->max_win_creds); 565 return -EINVAL; 566 } 567 } 568 569 rc = sysfs_add_vas_caps(caps); 570 if (rc) 571 return rc; 572 573 copypaste_feat = true; 574 575 return 0; 576 } 577 578 /* 579 * VAS windows can be closed due to lost credits when the core is 580 * removed. So reopen them if credits are available due to DLPAR 581 * core add and set the window active status. When NX sees the page 582 * fault on the unmapped paste address, the kernel handles the fault 583 * by setting the remapping to new paste address if the window is 584 * active. 585 */ 586 static int reconfig_open_windows(struct vas_caps *vcaps, int creds, 587 bool migrate) 588 { 589 long domain[PLPAR_HCALL9_BUFSIZE] = {VAS_DEFAULT_DOMAIN_ID}; 590 struct vas_cop_feat_caps *caps = &vcaps->caps; 591 struct pseries_vas_window *win = NULL, *tmp; 592 int rc, mv_ents = 0; 593 int flag; 594 595 /* 596 * Nothing to do if there are no closed windows. 597 */ 598 if (!vcaps->nr_close_wins) 599 return 0; 600 601 /* 602 * For the core removal, the hypervisor reduces the credits 603 * assigned to the LPAR and the kernel closes VAS windows 604 * in the hypervisor depends on reduced credits. The kernel 605 * uses LIFO (the last windows that are opened will be closed 606 * first) and expects to open in the same order when credits 607 * are available. 608 * For example, 40 windows are closed when the LPAR lost 2 cores 609 * (dedicated). If 1 core is added, this LPAR can have 20 more 610 * credits. It means the kernel can reopen 20 windows. So move 611 * 20 entries in the VAS windows lost and reopen next 20 windows. 612 * For partition migration, reopen all windows that are closed 613 * during resume. 614 */ 615 if ((vcaps->nr_close_wins > creds) && !migrate) 616 mv_ents = vcaps->nr_close_wins - creds; 617 618 list_for_each_entry_safe(win, tmp, &vcaps->list, win_list) { 619 if (!mv_ents) 620 break; 621 622 mv_ents--; 623 } 624 625 /* 626 * Open windows if they are closed only with migration or 627 * DLPAR (lost credit) before. 628 */ 629 if (migrate) 630 flag = VAS_WIN_MIGRATE_CLOSE; 631 else 632 flag = VAS_WIN_NO_CRED_CLOSE; 633 634 list_for_each_entry_safe_from(win, tmp, &vcaps->list, win_list) { 635 /* 636 * This window is closed with DLPAR and migration events. 637 * So reopen the window with the last event. 638 * The user space is not suspended with the current 639 * migration notifier. So the user space can issue DLPAR 640 * CPU hotplug while migration in progress. In this case 641 * this window will be opened with the last event. 642 */ 643 if ((win->vas_win.status & VAS_WIN_NO_CRED_CLOSE) && 644 (win->vas_win.status & VAS_WIN_MIGRATE_CLOSE)) { 645 win->vas_win.status &= ~flag; 646 continue; 647 } 648 649 /* 650 * Nothing to do on this window if it is not closed 651 * with this flag 652 */ 653 if (!(win->vas_win.status & flag)) 654 continue; 655 656 rc = allocate_setup_window(win, (u64 *)&domain[0], 657 caps->win_type); 658 if (rc) 659 return rc; 660 661 rc = h_modify_vas_window(win); 662 if (rc) 663 goto out; 664 665 mutex_lock(&win->vas_win.task_ref.mmap_mutex); 666 /* 667 * Set window status to active 668 */ 669 win->vas_win.status &= ~flag; 670 mutex_unlock(&win->vas_win.task_ref.mmap_mutex); 671 win->win_type = caps->win_type; 672 if (!--vcaps->nr_close_wins) 673 break; 674 } 675 676 return 0; 677 out: 678 /* 679 * Window modify HCALL failed. So close the window to the 680 * hypervisor and return. 681 */ 682 free_irq_setup(win); 683 h_deallocate_vas_window(win->vas_win.winid); 684 return rc; 685 } 686 687 /* 688 * The hypervisor reduces the available credits if the LPAR lost core. It 689 * means the excessive windows should not be active and the user space 690 * should not be using these windows to send compression requests to NX. 691 * So the kernel closes the excessive windows and unmap the paste address 692 * such that the user space receives paste instruction failure. Then up to 693 * the user space to fall back to SW compression and manage with the 694 * existing windows. 695 */ 696 static int reconfig_close_windows(struct vas_caps *vcap, int excess_creds, 697 bool migrate) 698 { 699 struct pseries_vas_window *win, *tmp; 700 struct vas_user_win_ref *task_ref; 701 struct vm_area_struct *vma; 702 int rc = 0, flag; 703 704 if (migrate) 705 flag = VAS_WIN_MIGRATE_CLOSE; 706 else 707 flag = VAS_WIN_NO_CRED_CLOSE; 708 709 list_for_each_entry_safe(win, tmp, &vcap->list, win_list) { 710 /* 711 * This window is already closed due to lost credit 712 * or for migration before. Go for next window. 713 * For migration, nothing to do since this window 714 * closed for DLPAR and will be reopened even on 715 * the destination system with other DLPAR operation. 716 */ 717 if ((win->vas_win.status & VAS_WIN_MIGRATE_CLOSE) || 718 (win->vas_win.status & VAS_WIN_NO_CRED_CLOSE)) { 719 win->vas_win.status |= flag; 720 continue; 721 } 722 723 task_ref = &win->vas_win.task_ref; 724 mutex_lock(&task_ref->mmap_mutex); 725 vma = task_ref->vma; 726 /* 727 * Number of available credits are reduced, So select 728 * and close windows. 729 */ 730 win->vas_win.status |= flag; 731 732 mmap_write_lock(task_ref->mm); 733 /* 734 * vma is set in the original mapping. But this mapping 735 * is done with mmap() after the window is opened with ioctl. 736 * so we may not see the original mapping if the core remove 737 * is done before the original mmap() and after the ioctl. 738 */ 739 if (vma) 740 zap_page_range(vma, vma->vm_start, 741 vma->vm_end - vma->vm_start); 742 743 mmap_write_unlock(task_ref->mm); 744 mutex_unlock(&task_ref->mmap_mutex); 745 /* 746 * Close VAS window in the hypervisor, but do not 747 * free vas_window struct since it may be reused 748 * when the credit is available later (DLPAR with 749 * adding cores). This struct will be used 750 * later when the process issued with close(FD). 751 */ 752 rc = deallocate_free_window(win); 753 /* 754 * This failure is from the hypervisor. 755 * No way to stop migration for these failures. 756 * So ignore error and continue closing other windows. 757 */ 758 if (rc && !migrate) 759 return rc; 760 761 vcap->nr_close_wins++; 762 763 /* 764 * For migration, do not depend on lpar_creds in case if 765 * mismatch with the hypervisor value (should not happen). 766 * So close all active windows in the list and will be 767 * reopened windows based on the new lpar_creds on the 768 * destination system during resume. 769 */ 770 if (!migrate && !--excess_creds) 771 break; 772 } 773 774 return 0; 775 } 776 777 /* 778 * Get new VAS capabilities when the core add/removal configuration 779 * changes. Reconfig window configurations based on the credits 780 * availability from this new capabilities. 781 */ 782 int vas_reconfig_capabilties(u8 type) 783 { 784 struct vas_cop_feat_caps *caps; 785 int old_nr_creds, new_nr_creds; 786 struct vas_caps *vcaps; 787 int rc = 0, nr_active_wins; 788 789 if (type >= VAS_MAX_FEAT_TYPE) { 790 pr_err("Invalid credit type %d\n", type); 791 return -EINVAL; 792 } 793 794 vcaps = &vascaps[type]; 795 caps = &vcaps->caps; 796 797 mutex_lock(&vas_pseries_mutex); 798 rc = h_query_vas_capabilities(H_QUERY_VAS_CAPABILITIES, vcaps->feat, 799 (u64)virt_to_phys(&hv_cop_caps)); 800 if (rc) 801 goto out; 802 803 new_nr_creds = be16_to_cpu(hv_cop_caps.target_lpar_creds); 804 805 old_nr_creds = atomic_read(&caps->nr_total_credits); 806 807 atomic_set(&caps->nr_total_credits, new_nr_creds); 808 /* 809 * The total number of available credits may be decreased or 810 * inceased with DLPAR operation. Means some windows have to be 811 * closed / reopened. Hold the vas_pseries_mutex so that the 812 * the user space can not open new windows. 813 */ 814 if (old_nr_creds < new_nr_creds) { 815 /* 816 * If the existing target credits is less than the new 817 * target, reopen windows if they are closed due to 818 * the previous DLPAR (core removal). 819 */ 820 rc = reconfig_open_windows(vcaps, new_nr_creds - old_nr_creds, 821 false); 822 } else { 823 /* 824 * # active windows is more than new LPAR available 825 * credits. So close the excessive windows. 826 * On pseries, each window will have 1 credit. 827 */ 828 nr_active_wins = vcaps->nr_open_windows - vcaps->nr_close_wins; 829 if (nr_active_wins > new_nr_creds) 830 rc = reconfig_close_windows(vcaps, 831 nr_active_wins - new_nr_creds, 832 false); 833 } 834 835 out: 836 mutex_unlock(&vas_pseries_mutex); 837 return rc; 838 } 839 /* 840 * Total number of default credits available (target_credits) 841 * in LPAR depends on number of cores configured. It varies based on 842 * whether processors are in shared mode or dedicated mode. 843 * Get the notifier when CPU configuration is changed with DLPAR 844 * operation so that get the new target_credits (vas default capabilities) 845 * and then update the existing windows usage if needed. 846 */ 847 static int pseries_vas_notifier(struct notifier_block *nb, 848 unsigned long action, void *data) 849 { 850 struct of_reconfig_data *rd = data; 851 struct device_node *dn = rd->dn; 852 const __be32 *intserv = NULL; 853 int len, rc = 0; 854 855 if ((action == OF_RECONFIG_ATTACH_NODE) || 856 (action == OF_RECONFIG_DETACH_NODE)) 857 intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", 858 &len); 859 /* 860 * Processor config is not changed 861 */ 862 if (!intserv) 863 return NOTIFY_OK; 864 865 rc = vas_reconfig_capabilties(VAS_GZIP_DEF_FEAT_TYPE); 866 if (rc) 867 pr_err("Failed reconfig VAS capabilities with DLPAR\n"); 868 869 return rc; 870 } 871 872 static struct notifier_block pseries_vas_nb = { 873 .notifier_call = pseries_vas_notifier, 874 }; 875 876 /* 877 * For LPM, all windows have to be closed on the source partition 878 * before migration and reopen them on the destination partition 879 * after migration. So closing windows during suspend and 880 * reopen them during resume. 881 */ 882 int vas_migration_handler(int action) 883 { 884 struct vas_cop_feat_caps *caps; 885 int old_nr_creds, new_nr_creds = 0; 886 struct vas_caps *vcaps; 887 int i, rc = 0; 888 889 /* 890 * NX-GZIP is not enabled. Nothing to do for migration. 891 */ 892 if (!copypaste_feat) 893 return rc; 894 895 mutex_lock(&vas_pseries_mutex); 896 897 if (action == VAS_SUSPEND) 898 migration_in_progress = true; 899 else 900 migration_in_progress = false; 901 902 for (i = 0; i < VAS_MAX_FEAT_TYPE; i++) { 903 vcaps = &vascaps[i]; 904 caps = &vcaps->caps; 905 old_nr_creds = atomic_read(&caps->nr_total_credits); 906 907 rc = h_query_vas_capabilities(H_QUERY_VAS_CAPABILITIES, 908 vcaps->feat, 909 (u64)virt_to_phys(&hv_cop_caps)); 910 if (!rc) { 911 new_nr_creds = be16_to_cpu(hv_cop_caps.target_lpar_creds); 912 /* 913 * Should not happen. But incase print messages, close 914 * all windows in the list during suspend and reopen 915 * windows based on new lpar_creds on the destination 916 * system. 917 */ 918 if (old_nr_creds != new_nr_creds) { 919 pr_err("Target credits mismatch with the hypervisor\n"); 920 pr_err("state(%d): lpar creds: %d HV lpar creds: %d\n", 921 action, old_nr_creds, new_nr_creds); 922 pr_err("Used creds: %d, Active creds: %d\n", 923 atomic_read(&caps->nr_used_credits), 924 vcaps->nr_open_windows - vcaps->nr_close_wins); 925 } 926 } else { 927 pr_err("state(%d): Get VAS capabilities failed with %d\n", 928 action, rc); 929 /* 930 * We can not stop migration with the current lpm 931 * implementation. So continue closing all windows in 932 * the list (during suspend) and return without 933 * opening windows (during resume) if VAS capabilities 934 * HCALL failed. 935 */ 936 if (action == VAS_RESUME) 937 goto out; 938 } 939 940 switch (action) { 941 case VAS_SUSPEND: 942 rc = reconfig_close_windows(vcaps, vcaps->nr_open_windows, 943 true); 944 break; 945 case VAS_RESUME: 946 atomic_set(&caps->nr_total_credits, new_nr_creds); 947 rc = reconfig_open_windows(vcaps, new_nr_creds, true); 948 break; 949 default: 950 /* should not happen */ 951 pr_err("Invalid migration action %d\n", action); 952 rc = -EINVAL; 953 goto out; 954 } 955 956 /* 957 * Ignore errors during suspend and return for resume. 958 */ 959 if (rc && (action == VAS_RESUME)) 960 goto out; 961 } 962 963 out: 964 mutex_unlock(&vas_pseries_mutex); 965 return rc; 966 } 967 968 static int __init pseries_vas_init(void) 969 { 970 struct hv_vas_all_caps *hv_caps; 971 int rc = 0; 972 973 /* 974 * Linux supports user space COPY/PASTE only with Radix 975 */ 976 if (!radix_enabled()) { 977 pr_err("API is supported only with radix page tables\n"); 978 return -ENOTSUPP; 979 } 980 981 hv_caps = kmalloc(sizeof(*hv_caps), GFP_KERNEL); 982 if (!hv_caps) 983 return -ENOMEM; 984 /* 985 * Get VAS overall capabilities by passing 0 to feature type. 986 */ 987 rc = h_query_vas_capabilities(H_QUERY_VAS_CAPABILITIES, 0, 988 (u64)virt_to_phys(hv_caps)); 989 if (rc) 990 goto out; 991 992 caps_all.descriptor = be64_to_cpu(hv_caps->descriptor); 993 caps_all.feat_type = be64_to_cpu(hv_caps->feat_type); 994 995 sysfs_pseries_vas_init(&caps_all); 996 997 /* 998 * QOS capabilities available 999 */ 1000 if (caps_all.feat_type & VAS_GZIP_QOS_FEAT_BIT) { 1001 rc = get_vas_capabilities(VAS_GZIP_QOS_FEAT, 1002 VAS_GZIP_QOS_FEAT_TYPE, &hv_cop_caps); 1003 1004 if (rc) 1005 goto out; 1006 } 1007 /* 1008 * Default capabilities available 1009 */ 1010 if (caps_all.feat_type & VAS_GZIP_DEF_FEAT_BIT) 1011 rc = get_vas_capabilities(VAS_GZIP_DEF_FEAT, 1012 VAS_GZIP_DEF_FEAT_TYPE, &hv_cop_caps); 1013 1014 if (!rc && copypaste_feat) { 1015 if (firmware_has_feature(FW_FEATURE_LPAR)) 1016 of_reconfig_notifier_register(&pseries_vas_nb); 1017 1018 pr_info("GZIP feature is available\n"); 1019 } else { 1020 /* 1021 * Should not happen, but only when get default 1022 * capabilities HCALL failed. So disable copy paste 1023 * feature. 1024 */ 1025 copypaste_feat = false; 1026 } 1027 1028 out: 1029 kfree(hv_caps); 1030 return rc; 1031 } 1032 machine_device_initcall(pseries, pseries_vas_init); 1033