+1 -1

mm/internal.h

reviewed

··· 171 171 172 172 /* 173 173 * OK, we tried to call the file hook for mmap(), but an error 174 174 - * arose. The mapping is in an inconsistent state and we most not invoke 174 174 + * arose. The mapping is in an inconsistent state and we must not invoke 175 175 * any further hooks on it. 176 176 */ 177 177 vma->vm_ops = &vma_dummy_vm_ops;

+1 -1

mm/madvise.c

reviewed

··· 1867 1867 * madvise_should_skip() - Return if the request is invalid or nothing. 1868 1868 * @start: Start address of madvise-requested address range. 1869 1869 * @len_in: Length of madvise-requested address range. 1870 1870 - * @behavior: Requested madvise behavor. 1870 1870 + * @behavior: Requested madvise behavior. 1871 1871 * @err: Pointer to store an error code from the check. 1872 1872 * 1873 1873 * If the specified behaviour is invalid or nothing would occur, we skip the

+2 -2

mm/memblock.c

reviewed

··· 773 773 unsigned long start_pfn, end_pfn, mem_size_mb; 774 774 int nid, i; 775 775 776 776 - /* calculate lose page */ 776 776 + /* calculate lost page */ 777 777 for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, &nid) { 778 778 if (!numa_valid_node(nid)) 779 779 nr_pages += end_pfn - start_pfn; ··· 2414 2414 2415 2415 /** 2416 2416 * reserve_mem_release_by_name - Release reserved memory region with a given name 2417 2417 - * @name: The name that is attatched to a reserved memory region 2417 2417 + * @name: The name that is attached to a reserved memory region 2418 2418 * 2419 2419 * Forcibly release the pages in the reserved memory region so that those memory 2420 2420 * can be used as free memory. After released the reserved region size becomes 0.

+1 -1

mm/memcontrol.c

reviewed

··· 4976 4976 memcg = folio_memcg(old); 4977 4977 /* 4978 4978 * Note that it is normal to see !memcg for a hugetlb folio. 4979 4979 - * For e.g, itt could have been allocated when memory_hugetlb_accounting 4979 4979 + * For e.g, it could have been allocated when memory_hugetlb_accounting 4980 4980 * was not selected. 4981 4981 */ 4982 4982 VM_WARN_ON_ONCE_FOLIO(!folio_test_hugetlb(old) && !memcg, old);

+1 -1

mm/memory-failure.c

reviewed

··· 864 864 * 865 865 * MF_RECOVERED - The m-f() handler marks the page as PG_hwpoisoned'ed. 866 866 * The page has been completely isolated, that is, unmapped, taken out of 867 867 - * the buddy system, or hole-punnched out of the file mapping. 867 867 + * the buddy system, or hole-punched out of the file mapping. 868 868 */ 869 869 static const char *action_name[] = { 870 870 [MF_IGNORED] = "Ignored",

+1 -1

mm/memory-tiers.c

reviewed

··· 648 648 if (node_memory_types[node].memtype == memtype || !memtype) 649 649 node_memory_types[node].map_count--; 650 650 /* 651 651 - * If we umapped all the attached devices to this node, 651 651 + * If we unmapped all the attached devices to this node, 652 652 * clear the node memory type. 653 653 */ 654 654 if (!node_memory_types[node].map_count) {

+2 -2

mm/memory.c

reviewed

··· 5935 5935 else 5936 5936 *last_cpupid = folio_last_cpupid(folio); 5937 5937 5938 5938 - /* Record the current PID acceesing VMA */ 5938 5938 + /* Record the current PID accessing VMA */ 5939 5939 vma_set_access_pid_bit(vma); 5940 5940 5941 5941 count_vm_numa_event(NUMA_HINT_FAULTS); ··· 6254 6254 * Use the maywrite version to indicate that vmf->pte may be 6255 6255 * modified, but since we will use pte_same() to detect the 6256 6256 * change of the !pte_none() entry, there is no need to recheck 6257 6257 - * the pmdval. Here we chooes to pass a dummy variable instead 6257 6257 + * the pmdval. Here we choose to pass a dummy variable instead 6258 6258 * of NULL, which helps new user think about why this place is 6259 6259 * special. 6260 6260 */

+2 -2

mm/memory_hotplug.c

reviewed

··· 926 926 * 927 927 * MOVABLE : KERNEL_EARLY 928 928 * 929 929 - * Whereby KERNEL_EARLY is memory in one of the kernel zones, available sinze 929 929 + * Whereby KERNEL_EARLY is memory in one of the kernel zones, available since 930 930 * boot. We base our calculation on KERNEL_EARLY internally, because: 931 931 * 932 932 * a) Hotplugged memory in one of the kernel zones can sometimes still get ··· 1258 1258 * NODE_DATA is preallocated (free_area_init) but its internal 1259 1259 * state is not allocated completely. Add missing pieces. 1260 1260 * Completely offline nodes stay around and they just need 1261 1261 - * reintialization. 1261 1261 + * reinitialization. 1262 1262 */ 1263 1263 pgdat = NODE_DATA(nid); 1264 1264

+2 -2

mm/migrate_device.c

reviewed

··· 1419 1419 1420 1420 /** 1421 1421 * migrate_device_pfns() - migrate device private pfns to normal memory. 1422 1422 - * @src_pfns: pre-popluated array of source device private pfns to migrate. 1422 1422 + * @src_pfns: pre-populated array of source device private pfns to migrate. 1423 1423 * @npages: number of pages to migrate. 1424 1424 * 1425 1425 - * Similar to migrate_device_range() but supports non-contiguous pre-popluated 1425 1425 + * Similar to migrate_device_range() but supports non-contiguous pre-populated 1426 1426 * array of device pages to migrate. 1427 1427 */ 1428 1428 int migrate_device_pfns(unsigned long *src_pfns, unsigned long npages)

+3 -3

mm/mm_init.c

reviewed

··· 187 187 /* 188 188 * For policy OVERCOMMIT_NEVER, set batch size to 0.4% of 189 189 * (total memory/#cpus), and lift it to 25% for other policies 190 190 - * to easy the possible lock contention for percpu_counter 190 190 + * to ease the possible lock contention for percpu_counter 191 191 * vm_committed_as, while the max limit is INT_MAX 192 192 */ 193 193 if (overcommit_policy == OVERCOMMIT_NEVER) ··· 1745 1745 lru_gen_init_pgdat(pgdat); 1746 1746 } 1747 1747 1748 1748 - /* Any regular or high memory on that node ? */ 1748 1748 + /* Any regular or high memory on that node? */ 1749 1749 static void __init check_for_memory(pg_data_t *pgdat) 1750 1750 { 1751 1751 enum zone_type zone_type; ··· 2045 2045 * Initialize and free pages. 2046 2046 * 2047 2047 * At this point reserved pages and struct pages that correspond to holes in 2048 2048 - * memblock.memory are already intialized so every free range has a valid 2048 2048 + * memblock.memory are already initialized so every free range has a valid 2049 2049 * memory map around it. 2050 2050 * This ensures that access of pages that are ahead of the range being 2051 2051 * initialized (computing buddy page in __free_one_page()) always reads a valid

+3 -3

mm/mremap.c

reviewed

··· 678 678 /* 679 679 * We don't want to have to go hunting for VMAs from the end of the old 680 680 * VMA to the next page table boundary, also we want to make sure the 681 681 - * operation is wortwhile. 681 681 + * operation is worthwhile. 682 682 * 683 683 * So ensure that we only perform this realignment if the end of the 684 684 * range being copied reaches or crosses the page table boundary. ··· 926 926 /* 927 927 * Will a new address definitely be assigned? This either if the user specifies 928 928 * it via MREMAP_FIXED, or if MREMAP_DONTUNMAP is used, indicating we will 929 929 - * always detemrine a target address. 929 929 + * always determine a target address. 930 930 */ 931 931 static bool vrm_implies_new_addr(struct vma_remap_struct *vrm) 932 932 { ··· 1806 1806 /* 1807 1807 * move_vma() need us to stay 4 maps below the threshold, otherwise 1808 1808 * it will bail out at the very beginning. 1809 1809 - * That is a problem if we have already unmaped the regions here 1809 1809 + * That is a problem if we have already unmapped the regions here 1810 1810 * (new_addr, and old_addr), because userspace will not know the 1811 1811 * state of the vma's after it gets -ENOMEM. 1812 1812 * So, to avoid such scenario we can pre-compute if the whole

+2 -2

mm/mseal.c

reviewed

··· 21 21 * It disallows unmapped regions from start to end whether they exist at the 22 22 * start, in the middle, or at the end of the range, or any combination thereof. 23 23 * 24 24 - * This is because after sealng a range, there's nothing to stop memory mapping 24 24 + * This is because after sealing a range, there's nothing to stop memory mapping 25 25 * of ranges in the remaining gaps later, meaning that the user might then 26 26 * wrongly consider the entirety of the mseal()'d range to be sealed when it 27 27 * in fact isn't. ··· 124 124 * -EINVAL: 125 125 * invalid input flags. 126 126 * start address is not page aligned. 127 127 - * Address arange (start + len) overflow. 127 127 + * Address range (start + len) overflow. 128 128 * -ENOMEM: 129 129 * addr is not a valid address (not allocated). 130 130 * end (start + len) is not a valid address.

+1 -1

mm/numa_memblks.c

reviewed

··· 467 467 * We reset memblock back to the top-down direction 468 468 * here because if we configured ACPI_NUMA, we have 469 469 * parsed SRAT in init_func(). It is ok to have the 470 470 - * reset here even if we did't configure ACPI_NUMA 470 470 + * reset here even if we didn't configure ACPI_NUMA 471 471 * or acpi numa init fails and fallbacks to dummy 472 472 * numa init. 473 473 */

+2 -2

mm/page_alloc.c

reviewed

··· 1853 1853 1854 1854 /* 1855 1855 * As memory initialization might be integrated into KASAN, 1856 1856 - * KASAN unpoisoning and memory initializion code must be 1856 1856 + * KASAN unpoisoning and memory initialization code must be 1857 1857 * kept together to avoid discrepancies in behavior. 1858 1858 */ 1859 1859 ··· 7653 7653 * unsafe in NMI. If spin_trylock() is called from hard IRQ the current 7654 7654 * task may be waiting for one rt_spin_lock, but rt_spin_trylock() will 7655 7655 * mark the task as the owner of another rt_spin_lock which will 7656 7656 - * confuse PI logic, so return immediately if called form hard IRQ or 7656 7656 + * confuse PI logic, so return immediately if called from hard IRQ or 7657 7657 * NMI. 7658 7658 * 7659 7659 * Note, irqs_disabled() case is ok. This function can be called

+2 -2

mm/page_io.c

reviewed

··· 450 450 451 451 VM_BUG_ON_FOLIO(!folio_test_swapcache(folio), folio); 452 452 /* 453 453 - * ->flags can be updated non-atomicially (scan_swap_map_slots), 453 453 + * ->flags can be updated non-atomically (scan_swap_map_slots), 454 454 * but that will never affect SWP_FS_OPS, so the data_race 455 455 * is safe. 456 456 */ 457 457 if (data_race(sis->flags & SWP_FS_OPS)) 458 458 swap_writepage_fs(folio, swap_plug); 459 459 /* 460 460 - * ->flags can be updated non-atomicially (scan_swap_map_slots), 460 460 + * ->flags can be updated non-atomically (scan_swap_map_slots), 461 461 * but that will never affect SWP_SYNCHRONOUS_IO, so the data_race 462 462 * is safe. 463 463 */

+1 -1

mm/page_isolation.c

reviewed

··· 301 301 * pageblock. When not all pageblocks within a page are isolated at the same 302 302 * time, free page accounting can go wrong. For example, in the case of 303 303 * MAX_PAGE_ORDER = pageblock_order + 1, a MAX_PAGE_ORDER page has two 304 304 - * pagelbocks. 304 304 + * pageblocks. 305 305 * [ MAX_PAGE_ORDER ] 306 306 * [ pageblock0 | pageblock1 ] 307 307 * When either pageblock is isolated, if it is a free page, the page is not

+1 -1

mm/page_reporting.c

reviewed

··· 123 123 continue; 124 124 125 125 /* 126 126 - * If page was not comingled with another page we can 126 126 + * If page was not commingled with another page we can 127 127 * consider the result to be "reported" since the page 128 128 * hasn't been modified, otherwise we will need to 129 129 * report on the new larger page when we make our way

+1 -1

mm/swap.c

reviewed

··· 513 513 EXPORT_SYMBOL(folio_add_lru); 514 514 515 515 /** 516 516 - * folio_add_lru_vma() - Add a folio to the appropate LRU list for this VMA. 516 516 + * folio_add_lru_vma() - Add a folio to the appropriate LRU list for this VMA. 517 517 * @folio: The folio to be added to the LRU. 518 518 * @vma: VMA in which the folio is mapped. 519 519 *

+1 -1

mm/swap.h

reviewed

··· 236 236 237 237 /* 238 238 * All swap cache helpers below require the caller to ensure the swap entries 239 239 - * used are valid and stablize the device by any of the following ways: 239 239 + * used are valid and stabilize the device by any of the following ways: 240 240 * - Hold a reference by get_swap_device(): this ensures a single entry is 241 241 * valid and increases the swap device's refcount. 242 242 * - Locking a folio in the swap cache: this ensures the folio's swap entries

+1 -1

mm/swap_state.c

reviewed

··· 82 82 * Context: Caller must ensure @entry is valid and protect the swap device 83 83 * with reference count or locks. 84 84 * Return: Returns the found folio on success, NULL otherwise. The caller 85 85 - * must lock nd check if the folio still matches the swap entry before 85 85 + * must lock and check if the folio still matches the swap entry before 86 86 * use (e.g., folio_matches_swap_entry). 87 87 */ 88 88 struct folio *swap_cache_get_folio(swp_entry_t entry)

+1 -1

mm/swapfile.c

reviewed

··· 2018 2018 if (get_swap_device_info(si)) { 2019 2019 if (si->flags & SWP_WRITEOK) { 2020 2020 /* 2021 2021 - * Grab the local lock to be complaint 2021 2021 + * Grab the local lock to be compliant 2022 2022 * with swap table allocation. 2023 2023 */ 2024 2024 local_lock(&percpu_swap_cluster.lock);

+2 -2

mm/userfaultfd.c

reviewed

··· 1274 1274 * Use the maywrite version to indicate that dst_pte will be modified, 1275 1275 * since dst_pte needs to be none, the subsequent pte_same() check 1276 1276 * cannot prevent the dst_pte page from being freed concurrently, so we 1277 1277 - * also need to abtain dst_pmdval and recheck pmd_same() later. 1277 1277 + * also need to obtain dst_pmdval and recheck pmd_same() later. 1278 1278 */ 1279 1279 dst_pte = pte_offset_map_rw_nolock(mm, dst_pmd, dst_addr, &dst_pmdval, 1280 1280 &dst_ptl); ··· 1330 1330 goto out; 1331 1331 } 1332 1332 1333 1333 - /* If PTE changed after we locked the folio them start over */ 1333 1333 + /* If PTE changed after we locked the folio then start over */ 1334 1334 if (src_folio && unlikely(!pte_same(src_folio_pte, orig_src_pte))) { 1335 1335 ret = -EAGAIN; 1336 1336 goto out;

+4 -4

mm/vma.c

reviewed

··· 2951 2951 return -ENOMEM; 2952 2952 2953 2953 /* 2954 2954 - * Adjust for the gap first so it doesn't interfere with the 2955 2955 - * later alignment. The first step is the minimum needed to 2956 2956 - * fulill the start gap, the next steps is the minimum to align 2957 2957 - * that. It is the minimum needed to fulill both. 2954 2954 + * Adjust for the gap first so it doesn't interfere with the later 2955 2955 + * alignment. The first step is the minimum needed to fulfill the start 2956 2956 + * gap, the next step is the minimum to align that. It is the minimum 2957 2957 + * needed to fulfill both. 2958 2958 */ 2959 2959 gap = vma_iter_addr(&vmi) + info->start_gap; 2960 2960 gap += (info->align_offset - gap) & info->align_mask;

+4 -4

mm/vma.h

reviewed

··· 267 267 struct vm_area_struct *prev, struct vm_area_struct *next); 268 268 269 269 /** 270 270 - * vma_modify_flags() - Peform any necessary split/merge in preparation for 270 270 + * vma_modify_flags() - Perform any necessary split/merge in preparation for 271 271 * setting VMA flags to *@vm_flags in the range @start to @end contained within 272 272 * @vma. 273 273 * @vmi: Valid VMA iterator positioned at @vma. ··· 295 295 vm_flags_t *vm_flags_ptr); 296 296 297 297 /** 298 298 - * vma_modify_name() - Peform any necessary split/merge in preparation for 298 298 + * vma_modify_name() - Perform any necessary split/merge in preparation for 299 299 * setting anonymous VMA name to @new_name in the range @start to @end contained 300 300 * within @vma. 301 301 * @vmi: Valid VMA iterator positioned at @vma. ··· 319 319 struct anon_vma_name *new_name); 320 320 321 321 /** 322 322 - * vma_modify_policy() - Peform any necessary split/merge in preparation for 322 322 + * vma_modify_policy() - Perform any necessary split/merge in preparation for 323 323 * setting NUMA policy to @new_pol in the range @start to @end contained 324 324 * within @vma. 325 325 * @vmi: Valid VMA iterator positioned at @vma. ··· 343 343 struct mempolicy *new_pol); 344 344 345 345 /** 346 346 - * vma_modify_flags_uffd() - Peform any necessary split/merge in preparation for 346 346 + * vma_modify_flags_uffd() - Perform any necessary split/merge in preparation for 347 347 * setting VMA flags to @vm_flags and UFFD context to @new_ctx in the range 348 348 * @start to @end contained within @vma. 349 349 * @vmi: Valid VMA iterator positioned at @vma.

+1 -1

mm/vmscan.c

reviewed

··· 1063 1063 /* 1064 1064 * We can "enter_fs" for swap-cache with only __GFP_IO 1065 1065 * providing this isn't SWP_FS_OPS. 1066 1066 - * ->flags can be updated non-atomicially (scan_swap_map_slots), 1066 1066 + * ->flags can be updated non-atomically (scan_swap_map_slots), 1067 1067 * but that will never affect SWP_FS_OPS, so the data_race 1068 1068 * is safe. 1069 1069 */

+1 -1

mm/vmstat.c

reviewed

··· 1626 1626 } 1627 1627 } 1628 1628 1629 1629 - /* Print out the free pages at each order for each migatetype */ 1629 1629 + /* Print out the free pages at each order for each migratetype */ 1630 1630 static void pagetypeinfo_showfree(struct seq_file *m, void *arg) 1631 1631 { 1632 1632 int order;

+1 -1

mm/zsmalloc.c

reviewed

··· 105 105 106 106 /* 107 107 * On systems with 4K page size, this gives 255 size classes! There is a 108 108 - * trader-off here: 108 108 + * trade-off here: 109 109 * - Large number of size classes is potentially wasteful as free page are 110 110 * spread across these classes 111 111 * - Small number of size classes causes large internal fragmentation