+3 -3

mm/compaction.c

reviewed

··· 625 625 } 626 626 627 627 /* Found a free page, will break it into order-0 pages */ 628 628 - order = page_order(page); 628 628 + order = buddy_order(page); 629 629 isolated = __isolate_free_page(page, order); 630 630 if (!isolated) 631 631 break; ··· 898 898 * potential isolation targets. 899 899 */ 900 900 if (PageBuddy(page)) { 901 901 - unsigned long freepage_order = page_order_unsafe(page); 901 901 + unsigned long freepage_order = buddy_order_unsafe(page); 902 902 903 903 /* 904 904 * Without lock, we cannot be sure that what we got is ··· 1172 1172 * the only small danger is that we skip a potentially suitable 1173 1173 * pageblock, so it's not worth to check order for valid range. 1174 1174 */ 1175 1175 - if (page_order_unsafe(page) >= pageblock_order) 1175 1175 + if (buddy_order_unsafe(page) >= pageblock_order) 1176 1176 return false; 1177 1177 } 1178 1178

+4 -4

mm/internal.h

reviewed

··· 270 270 * page from being allocated in parallel and returning garbage as the order. 271 271 * If a caller does not hold page_zone(page)->lock, it must guarantee that the 272 272 * page cannot be allocated or merged in parallel. Alternatively, it must 273 273 - * handle invalid values gracefully, and use page_order_unsafe() below. 273 273 + * handle invalid values gracefully, and use buddy_order_unsafe() below. 274 274 */ 275 275 - static inline unsigned int page_order(struct page *page) 275 275 + static inline unsigned int buddy_order(struct page *page) 276 276 { 277 277 /* PageBuddy() must be checked by the caller */ 278 278 return page_private(page); 279 279 } 280 280 281 281 /* 282 282 - * Like page_order(), but for callers who cannot afford to hold the zone lock. 282 282 + * Like buddy_order(), but for callers who cannot afford to hold the zone lock. 283 283 * PageBuddy() should be checked first by the caller to minimize race window, 284 284 * and invalid values must be handled gracefully. 285 285 * ··· 289 289 * times, potentially observing different values in the tests and the actual 290 290 * use of the result. 291 291 */ 292 292 - #define page_order_unsafe(page) READ_ONCE(page_private(page)) 292 292 + #define buddy_order_unsafe(page) READ_ONCE(page_private(page)) 293 293 294 294 static inline bool is_cow_mapping(vm_flags_t flags) 295 295 {

+15 -15

mm/page_alloc.c

reviewed

··· 792 792 unsigned int order, int migratetype) {} 793 793 #endif 794 794 795 795 - static inline void set_page_order(struct page *page, unsigned int order) 795 795 + static inline void set_buddy_order(struct page *page, unsigned int order) 796 796 { 797 797 set_page_private(page, order); 798 798 __SetPageBuddy(page); ··· 817 817 if (!page_is_guard(buddy) && !PageBuddy(buddy)) 818 818 return false; 819 819 820 820 - if (page_order(buddy) != order) 820 820 + if (buddy_order(buddy) != order) 821 821 return false; 822 822 823 823 /* ··· 1059 1059 } 1060 1060 1061 1061 done_merging: 1062 1062 - set_page_order(page, order); 1062 1062 + set_buddy_order(page, order); 1063 1063 1064 1064 if (fpi_flags & FPI_TO_TAIL) 1065 1065 to_tail = true; ··· 2178 2178 continue; 2179 2179 2180 2180 add_to_free_list(&page[size], zone, high, migratetype); 2181 2181 - set_page_order(&page[size], high); 2181 2181 + set_buddy_order(&page[size], high); 2182 2182 } 2183 2183 } 2184 2184 ··· 2392 2392 VM_BUG_ON_PAGE(page_to_nid(page) != zone_to_nid(zone), page); 2393 2393 VM_BUG_ON_PAGE(page_zone(page) != zone, page); 2394 2394 2395 2395 - order = page_order(page); 2395 2395 + order = buddy_order(page); 2396 2396 move_to_free_list(page, zone, order, migratetype); 2397 2397 page += 1 << order; 2398 2398 pages_moved += 1 << order; ··· 2516 2516 static void steal_suitable_fallback(struct zone *zone, struct page *page, 2517 2517 unsigned int alloc_flags, int start_type, bool whole_block) 2518 2518 { 2519 2519 - unsigned int current_order = page_order(page); 2519 2519 + unsigned int current_order = buddy_order(page); 2520 2520 int free_pages, movable_pages, alike_pages; 2521 2521 int old_block_type; 2522 2522 ··· 8344 8344 */ 8345 8345 if (!page_ref_count(page)) { 8346 8346 if (PageBuddy(page)) 8347 8347 - iter += (1 << page_order(page)) - 1; 8347 8347 + iter += (1 << buddy_order(page)) - 1; 8348 8348 continue; 8349 8349 } 8350 8350 ··· 8557 8557 } 8558 8558 8559 8559 if (outer_start != start) { 8560 8560 - order = page_order(pfn_to_page(outer_start)); 8560 8560 + order = buddy_order(pfn_to_page(outer_start)); 8561 8561 8562 8562 /* 8563 8563 * outer_start page could be small order buddy page and ··· 8782 8782 8783 8783 BUG_ON(page_count(page)); 8784 8784 BUG_ON(!PageBuddy(page)); 8785 8785 - order = page_order(page); 8785 8785 + order = buddy_order(page); 8786 8786 del_page_from_free_list(page, zone, order); 8787 8787 pfn += (1 << order); 8788 8788 } ··· 8801 8801 for (order = 0; order < MAX_ORDER; order++) { 8802 8802 struct page *page_head = page - (pfn & ((1 << order) - 1)); 8803 8803 8804 8804 - if (PageBuddy(page_head) && page_order(page_head) >= order) 8804 8804 + if (PageBuddy(page_head) && buddy_order(page_head) >= order) 8805 8805 break; 8806 8806 } 8807 8807 spin_unlock_irqrestore(&zone->lock, flags); ··· 8838 8838 8839 8839 if (current_buddy != target) { 8840 8840 add_to_free_list(current_buddy, zone, high, migratetype); 8841 8841 - set_page_order(current_buddy, high); 8841 8841 + set_buddy_order(current_buddy, high); 8842 8842 page = next_page; 8843 8843 } 8844 8844 } ··· 8858 8858 spin_lock_irqsave(&zone->lock, flags); 8859 8859 for (order = 0; order < MAX_ORDER; order++) { 8860 8860 struct page *page_head = page - (pfn & ((1 << order) - 1)); 8861 8861 - int buddy_order = page_order(page_head); 8861 8861 + int page_order = buddy_order(page_head); 8862 8862 8863 8863 - if (PageBuddy(page_head) && buddy_order >= order) { 8863 8863 + if (PageBuddy(page_head) && page_order >= order) { 8864 8864 unsigned long pfn_head = page_to_pfn(page_head); 8865 8865 int migratetype = get_pfnblock_migratetype(page_head, 8866 8866 pfn_head); 8867 8867 8868 8868 - del_page_from_free_list(page_head, zone, buddy_order); 8868 8868 + del_page_from_free_list(page_head, zone, page_order); 8869 8869 break_down_buddy_pages(zone, page_head, page, 0, 8870 8870 - buddy_order, migratetype); 8870 8870 + page_order, migratetype); 8871 8871 ret = true; 8872 8872 break; 8873 8873 }

+2 -2

mm/page_isolation.c

reviewed

··· 88 88 * these pages to be merged. 89 89 */ 90 90 if (PageBuddy(page)) { 91 91 - order = page_order(page); 91 91 + order = buddy_order(page); 92 92 if (order >= pageblock_order) { 93 93 pfn = page_to_pfn(page); 94 94 buddy_pfn = __find_buddy_pfn(pfn, order); ··· 261 261 * the correct MIGRATE_ISOLATE freelist. There is no 262 262 * simple way to verify that as VM_BUG_ON(), though. 263 263 */ 264 264 - pfn += 1 << page_order(page); 264 264 + pfn += 1 << buddy_order(page); 265 265 else if ((flags & MEMORY_OFFLINE) && PageHWPoison(page)) 266 266 /* A HWPoisoned page cannot be also PageBuddy */ 267 267 pfn++;

+3 -3

mm/page_owner.c

reviewed

··· 295 295 if (PageBuddy(page)) { 296 296 unsigned long freepage_order; 297 297 298 298 - freepage_order = page_order_unsafe(page); 298 298 + freepage_order = buddy_order_unsafe(page); 299 299 if (freepage_order < MAX_ORDER) 300 300 pfn += (1UL << freepage_order) - 1; 301 301 continue; ··· 490 490 491 491 page = pfn_to_page(pfn); 492 492 if (PageBuddy(page)) { 493 493 - unsigned long freepage_order = page_order_unsafe(page); 493 493 + unsigned long freepage_order = buddy_order_unsafe(page); 494 494 495 495 if (freepage_order < MAX_ORDER) 496 496 pfn += (1UL << freepage_order) - 1; ··· 584 584 * heavy lock contention. 585 585 */ 586 586 if (PageBuddy(page)) { 587 587 - unsigned long order = page_order_unsafe(page); 587 587 + unsigned long order = buddy_order_unsafe(page); 588 588 589 589 if (order > 0 && order < MAX_ORDER) 590 590 pfn += (1UL << order) - 1;

+1 -1

mm/page_reporting.c

reviewed

··· 92 92 * report on the new larger page when we make our way 93 93 * up to that higher order. 94 94 */ 95 95 - if (PageBuddy(page) && page_order(page) == order) 95 95 + if (PageBuddy(page) && buddy_order(page) == order) 96 96 __SetPageReported(page); 97 97 } while ((sg = sg_next(sg))); 98 98

+1 -1

mm/shuffle.c

reviewed

··· 60 60 * ...is the page on the same list as the page we will 61 61 * shuffle it with? 62 62 */ 63 63 - if (page_order(page) != order) 63 63 + if (buddy_order(page) != order) 64 64 return NULL; 65 65 66 66 return page;