1/* SPDX-License-Identifier: GPL-2.0 */
  2#ifndef _LINUX_MM_PAGE_IDLE_H
  3#define _LINUX_MM_PAGE_IDLE_H
  4
  5#include <linux/bitops.h>
  6#include <linux/page-flags.h>
  7#include <linux/page_ext.h>
  8
  9#ifdef CONFIG_IDLE_PAGE_TRACKING
 10
 11#ifdef CONFIG_64BIT
 12static inline bool page_is_young(struct page *page)
 13{
 14	return PageYoung(page);
 15}
 16
 17static inline void set_page_young(struct page *page)
 18{
 19	SetPageYoung(page);
 20}
 21
 22static inline bool test_and_clear_page_young(struct page *page)
 23{
 24	return TestClearPageYoung(page);
 25}
 26
 27static inline bool page_is_idle(struct page *page)
 28{
 29	return PageIdle(page);
 30}
 31
 32static inline void set_page_idle(struct page *page)
 33{
 34	SetPageIdle(page);
 35}
 36
 37static inline void clear_page_idle(struct page *page)
 38{
 39	ClearPageIdle(page);
 40}
 41#else /* !CONFIG_64BIT */
 42/*
 43 * If there is not enough space to store Idle and Young bits in page flags, use
 44 * page ext flags instead.
 45 */
 46extern struct page_ext_operations page_idle_ops;
 47
 48static inline bool page_is_young(struct page *page)
 49{
 50	struct page_ext *page_ext = lookup_page_ext(page);
 51
 52	if (unlikely(!page_ext))
 53		return false;
 54
 55	return test_bit(PAGE_EXT_YOUNG, &page_ext->flags);
 56}
 57
 58static inline void set_page_young(struct page *page)
 59{
 60	struct page_ext *page_ext = lookup_page_ext(page);
 61
 62	if (unlikely(!page_ext))
 63		return;
 64
 65	set_bit(PAGE_EXT_YOUNG, &page_ext->flags);
 66}
 67
 68static inline bool test_and_clear_page_young(struct page *page)
 69{
 70	struct page_ext *page_ext = lookup_page_ext(page);
 71
 72	if (unlikely(!page_ext))
 73		return false;
 74
 75	return test_and_clear_bit(PAGE_EXT_YOUNG, &page_ext->flags);
 76}
 77
 78static inline bool page_is_idle(struct page *page)
 79{
 80	struct page_ext *page_ext = lookup_page_ext(page);
 81
 82	if (unlikely(!page_ext))
 83		return false;
 84
 85	return test_bit(PAGE_EXT_IDLE, &page_ext->flags);
 86}
 87
 88static inline void set_page_idle(struct page *page)
 89{
 90	struct page_ext *page_ext = lookup_page_ext(page);
 91
 92	if (unlikely(!page_ext))
 93		return;
 94
 95	set_bit(PAGE_EXT_IDLE, &page_ext->flags);
 96}
 97
 98static inline void clear_page_idle(struct page *page)
 99{
100	struct page_ext *page_ext = lookup_page_ext(page);
101
102	if (unlikely(!page_ext))
103		return;
104
105	clear_bit(PAGE_EXT_IDLE, &page_ext->flags);
106}
107#endif /* CONFIG_64BIT */
108
109#else /* !CONFIG_IDLE_PAGE_TRACKING */
110
111static inline bool page_is_young(struct page *page)
112{
113	return false;
114}
115
116static inline void set_page_young(struct page *page)
117{
118}
119
120static inline bool test_and_clear_page_young(struct page *page)
121{
122	return false;
123}
124
125static inline bool page_is_idle(struct page *page)
126{
127	return false;
128}
129
130static inline void set_page_idle(struct page *page)
131{
132}
133
134static inline void clear_page_idle(struct page *page)
135{
136}
137
138#endif /* CONFIG_IDLE_PAGE_TRACKING */
139
140#endif /* _LINUX_MM_PAGE_IDLE_H */

 
  1#ifndef _LINUX_MM_PAGE_IDLE_H
  2#define _LINUX_MM_PAGE_IDLE_H
  3
  4#include <linux/bitops.h>
  5#include <linux/page-flags.h>
  6#include <linux/page_ext.h>
  7
  8#ifdef CONFIG_IDLE_PAGE_TRACKING
  9
 10#ifdef CONFIG_64BIT
 11static inline bool page_is_young(struct page *page)
 12{
 13	return PageYoung(page);
 14}
 15
 16static inline void set_page_young(struct page *page)
 17{
 18	SetPageYoung(page);
 19}
 20
 21static inline bool test_and_clear_page_young(struct page *page)
 22{
 23	return TestClearPageYoung(page);
 24}
 25
 26static inline bool page_is_idle(struct page *page)
 27{
 28	return PageIdle(page);
 29}
 30
 31static inline void set_page_idle(struct page *page)
 32{
 33	SetPageIdle(page);
 34}
 35
 36static inline void clear_page_idle(struct page *page)
 37{
 38	ClearPageIdle(page);
 39}
 40#else /* !CONFIG_64BIT */
 41/*
 42 * If there is not enough space to store Idle and Young bits in page flags, use
 43 * page ext flags instead.
 44 */
 45extern struct page_ext_operations page_idle_ops;
 46
 47static inline bool page_is_young(struct page *page)
 48{
 49	return test_bit(PAGE_EXT_YOUNG, &lookup_page_ext(page)->flags);
 
 
 
 
 
 50}
 51
 52static inline void set_page_young(struct page *page)
 53{
 54	set_bit(PAGE_EXT_YOUNG, &lookup_page_ext(page)->flags);
 
 
 
 
 
 55}
 56
 57static inline bool test_and_clear_page_young(struct page *page)
 58{
 59	return test_and_clear_bit(PAGE_EXT_YOUNG,
 60				  &lookup_page_ext(page)->flags);
 
 
 
 
 61}
 62
 63static inline bool page_is_idle(struct page *page)
 64{
 65	return test_bit(PAGE_EXT_IDLE, &lookup_page_ext(page)->flags);
 
 
 
 
 
 66}
 67
 68static inline void set_page_idle(struct page *page)
 69{
 70	set_bit(PAGE_EXT_IDLE, &lookup_page_ext(page)->flags);
 
 
 
 
 
 71}
 72
 73static inline void clear_page_idle(struct page *page)
 74{
 75	clear_bit(PAGE_EXT_IDLE, &lookup_page_ext(page)->flags);
 
 
 
 
 
 76}
 77#endif /* CONFIG_64BIT */
 78
 79#else /* !CONFIG_IDLE_PAGE_TRACKING */
 80
 81static inline bool page_is_young(struct page *page)
 82{
 83	return false;
 84}
 85
 86static inline void set_page_young(struct page *page)
 87{
 88}
 89
 90static inline bool test_and_clear_page_young(struct page *page)
 91{
 92	return false;
 93}
 94
 95static inline bool page_is_idle(struct page *page)
 96{
 97	return false;
 98}
 99
100static inline void set_page_idle(struct page *page)
101{
102}
103
104static inline void clear_page_idle(struct page *page)
105{
106}
107
108#endif /* CONFIG_IDLE_PAGE_TRACKING */
109
110#endif /* _LINUX_MM_PAGE_IDLE_H */