tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

mshv: make field names descriptive in a header struct

When struct fields use very common names like "pages" or "type", it makes
it difficult to find uses of these fields with tools like grep, cscope,
etc when the struct is in a header file included in many places. Add
prefix mreg_ to some fields in struct mshv_mem_region to make it easier
to find them.

There is no functional change.

Signed-off-by: Mukesh R <mrathor@linux.microsoft.com>
Signed-off-by: Wei Liu <wei.liu@kernel.org>

authored by

Mukesh R and committed by
Wei Liu 51515bfc afefdb2b

+40 -40
+30 -30
drivers/hv/mshv_regions.c
··· 88 88 struct page *page; 89 89 int stride, ret; 90 90 91 - page = region->pages[page_offset]; 91 + page = region->mreg_pages[page_offset]; 92 92 if (!page) 93 93 return -EINVAL; 94 94 ··· 98 98 99 99 /* Start at stride since the first stride is validated */ 100 100 for (count = stride; count < page_count; count += stride) { 101 - page = region->pages[page_offset + count]; 101 + page = region->mreg_pages[page_offset + count]; 102 102 103 103 /* Break if current page is not present */ 104 104 if (!page) ··· 152 152 153 153 while (page_count) { 154 154 /* Skip non-present pages */ 155 - if (!region->pages[page_offset]) { 155 + if (!region->mreg_pages[page_offset]) { 156 156 page_offset++; 157 157 page_count--; 158 158 continue; ··· 190 190 if (flags & BIT(MSHV_SET_MEM_BIT_EXECUTABLE)) 191 191 region->hv_map_flags |= HV_MAP_GPA_EXECUTABLE; 192 192 193 - kref_init(&region->refcount); 193 + kref_init(&region->mreg_refcount); 194 194 195 195 return region; 196 196 } ··· 204 204 flags |= HV_MODIFY_SPA_PAGE_HOST_ACCESS_LARGE_PAGE; 205 205 206 206 return hv_call_modify_spa_host_access(region->partition->pt_id, 207 - region->pages + page_offset, 207 + region->mreg_pages + page_offset, 208 208 page_count, 209 209 HV_MAP_GPA_READABLE | 210 210 HV_MAP_GPA_WRITABLE, ··· 229 229 flags |= HV_MODIFY_SPA_PAGE_HOST_ACCESS_LARGE_PAGE; 230 230 231 231 return hv_call_modify_spa_host_access(region->partition->pt_id, 232 - region->pages + page_offset, 232 + region->mreg_pages + page_offset, 233 233 page_count, 0, 234 234 flags, false); 235 235 } ··· 254 254 return hv_call_map_gpa_pages(region->partition->pt_id, 255 255 region->start_gfn + page_offset, 256 256 page_count, flags, 257 - region->pages + page_offset); 257 + region->mreg_pages + page_offset); 258 258 } 259 259 260 260 static int mshv_region_remap_pages(struct mshv_mem_region *region, ··· 277 277 static void mshv_region_invalidate_pages(struct mshv_mem_region *region, 278 278 u64 page_offset, u64 page_count) 279 279 { 280 - if (region->type == MSHV_REGION_TYPE_MEM_PINNED) 281 - unpin_user_pages(region->pages + page_offset, page_count); 280 + if (region->mreg_type == MSHV_REGION_TYPE_MEM_PINNED) 281 + unpin_user_pages(region->mreg_pages + page_offset, page_count); 282 282 283 - memset(region->pages + page_offset, 0, 283 + memset(region->mreg_pages + page_offset, 0, 284 284 page_count * sizeof(struct page *)); 285 285 } 286 286 ··· 297 297 int ret; 298 298 299 299 for (done_count = 0; done_count < region->nr_pages; done_count += ret) { 300 - pages = region->pages + done_count; 300 + pages = region->mreg_pages + done_count; 301 301 userspace_addr = region->start_uaddr + 302 302 done_count * HV_HYP_PAGE_SIZE; 303 303 nr_pages = min(region->nr_pages - done_count, ··· 348 348 static void mshv_region_destroy(struct kref *ref) 349 349 { 350 350 struct mshv_mem_region *region = 351 - container_of(ref, struct mshv_mem_region, refcount); 351 + container_of(ref, struct mshv_mem_region, mreg_refcount); 352 352 struct mshv_partition *partition = region->partition; 353 353 int ret; 354 354 355 - if (region->type == MSHV_REGION_TYPE_MEM_MOVABLE) 355 + if (region->mreg_type == MSHV_REGION_TYPE_MEM_MOVABLE) 356 356 mshv_region_movable_fini(region); 357 357 358 358 if (mshv_partition_encrypted(partition)) { ··· 374 374 375 375 void mshv_region_put(struct mshv_mem_region *region) 376 376 { 377 - kref_put(&region->refcount, mshv_region_destroy); 377 + kref_put(&region->mreg_refcount, mshv_region_destroy); 378 378 } 379 379 380 380 int mshv_region_get(struct mshv_mem_region *region) 381 381 { 382 - return kref_get_unless_zero(&region->refcount); 382 + return kref_get_unless_zero(&region->mreg_refcount); 383 383 } 384 384 385 385 /** ··· 405 405 int ret; 406 406 407 407 range->notifier_seq = mmu_interval_read_begin(range->notifier); 408 - mmap_read_lock(region->mni.mm); 408 + mmap_read_lock(region->mreg_mni.mm); 409 409 ret = hmm_range_fault(range); 410 - mmap_read_unlock(region->mni.mm); 410 + mmap_read_unlock(region->mreg_mni.mm); 411 411 if (ret) 412 412 return ret; 413 413 414 - mutex_lock(&region->mutex); 414 + mutex_lock(&region->mreg_mutex); 415 415 416 416 if (mmu_interval_read_retry(range->notifier, range->notifier_seq)) { 417 - mutex_unlock(&region->mutex); 417 + mutex_unlock(&region->mreg_mutex); 418 418 cond_resched(); 419 419 return -EBUSY; 420 420 } ··· 438 438 u64 page_offset, u64 page_count) 439 439 { 440 440 struct hmm_range range = { 441 - .notifier = &region->mni, 441 + .notifier = &region->mreg_mni, 442 442 .default_flags = HMM_PFN_REQ_FAULT | HMM_PFN_REQ_WRITE, 443 443 }; 444 444 unsigned long *pfns; ··· 461 461 goto out; 462 462 463 463 for (i = 0; i < page_count; i++) 464 - region->pages[page_offset + i] = hmm_pfn_to_page(pfns[i]); 464 + region->mreg_pages[page_offset + i] = hmm_pfn_to_page(pfns[i]); 465 465 466 466 ret = mshv_region_remap_pages(region, region->hv_map_flags, 467 467 page_offset, page_count); 468 468 469 - mutex_unlock(&region->mutex); 469 + mutex_unlock(&region->mreg_mutex); 470 470 out: 471 471 kfree(pfns); 472 472 return ret; ··· 520 520 { 521 521 struct mshv_mem_region *region = container_of(mni, 522 522 struct mshv_mem_region, 523 - mni); 523 + mreg_mni); 524 524 u64 page_offset, page_count; 525 525 unsigned long mstart, mend; 526 526 int ret = -EPERM; ··· 533 533 page_count = HVPFN_DOWN(mend - mstart); 534 534 535 535 if (mmu_notifier_range_blockable(range)) 536 - mutex_lock(&region->mutex); 537 - else if (!mutex_trylock(&region->mutex)) 536 + mutex_lock(&region->mreg_mutex); 537 + else if (!mutex_trylock(&region->mreg_mutex)) 538 538 goto out_fail; 539 539 540 540 mmu_interval_set_seq(mni, cur_seq); ··· 546 546 547 547 mshv_region_invalidate_pages(region, page_offset, page_count); 548 548 549 - mutex_unlock(&region->mutex); 549 + mutex_unlock(&region->mreg_mutex); 550 550 551 551 return true; 552 552 553 553 out_unlock: 554 - mutex_unlock(&region->mutex); 554 + mutex_unlock(&region->mreg_mutex); 555 555 out_fail: 556 556 WARN_ONCE(ret, 557 557 "Failed to invalidate region %#llx-%#llx (range %#lx-%#lx, event: %u, pages %#llx-%#llx, mm: %#llx): %d\n", ··· 568 568 569 569 void mshv_region_movable_fini(struct mshv_mem_region *region) 570 570 { 571 - mmu_interval_notifier_remove(&region->mni); 571 + mmu_interval_notifier_remove(&region->mreg_mni); 572 572 } 573 573 574 574 bool mshv_region_movable_init(struct mshv_mem_region *region) 575 575 { 576 576 int ret; 577 577 578 - ret = mmu_interval_notifier_insert(&region->mni, current->mm, 578 + ret = mmu_interval_notifier_insert(&region->mreg_mni, current->mm, 579 579 region->start_uaddr, 580 580 region->nr_pages << HV_HYP_PAGE_SHIFT, 581 581 &mshv_region_mni_ops); 582 582 if (ret) 583 583 return false; 584 584 585 - mutex_init(&region->mutex); 585 + mutex_init(&region->mreg_mutex); 586 586 587 587 return true; 588 588 }
+5 -5
drivers/hv/mshv_root.h
··· 82 82 83 83 struct mshv_mem_region { 84 84 struct hlist_node hnode; 85 - struct kref refcount; 85 + struct kref mreg_refcount; 86 86 u64 nr_pages; 87 87 u64 start_gfn; 88 88 u64 start_uaddr; 89 89 u32 hv_map_flags; 90 90 struct mshv_partition *partition; 91 - enum mshv_region_type type; 92 - struct mmu_interval_notifier mni; 93 - struct mutex mutex; /* protects region pages remapping */ 94 - struct page *pages[]; 91 + enum mshv_region_type mreg_type; 92 + struct mmu_interval_notifier mreg_mni; 93 + struct mutex mreg_mutex; /* protects region pages remapping */ 94 + struct page *mreg_pages[]; 95 95 }; 96 96 97 97 struct mshv_irq_ack_notifier {
+5 -5
drivers/hv/mshv_root_main.c
··· 650 650 return false; 651 651 652 652 /* Only movable memory ranges are supported for GPA intercepts */ 653 - if (region->type == MSHV_REGION_TYPE_MEM_MOVABLE) 653 + if (region->mreg_type == MSHV_REGION_TYPE_MEM_MOVABLE) 654 654 ret = mshv_region_handle_gfn_fault(region, gfn); 655 655 else 656 656 ret = false; ··· 1193 1193 return PTR_ERR(rg); 1194 1194 1195 1195 if (is_mmio) 1196 - rg->type = MSHV_REGION_TYPE_MMIO; 1196 + rg->mreg_type = MSHV_REGION_TYPE_MMIO; 1197 1197 else if (mshv_partition_encrypted(partition) || 1198 1198 !mshv_region_movable_init(rg)) 1199 - rg->type = MSHV_REGION_TYPE_MEM_PINNED; 1199 + rg->mreg_type = MSHV_REGION_TYPE_MEM_PINNED; 1200 1200 else 1201 - rg->type = MSHV_REGION_TYPE_MEM_MOVABLE; 1201 + rg->mreg_type = MSHV_REGION_TYPE_MEM_MOVABLE; 1202 1202 1203 1203 rg->partition = partition; 1204 1204 ··· 1315 1315 if (ret) 1316 1316 return ret; 1317 1317 1318 - switch (region->type) { 1318 + switch (region->mreg_type) { 1319 1319 case MSHV_REGION_TYPE_MEM_PINNED: 1320 1320 ret = mshv_prepare_pinned_region(region); 1321 1321 break;