Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _LINUX_VMSTAT_H
       3                 :            : #define _LINUX_VMSTAT_H
       4                 :            : 
       5                 :            : #include <linux/types.h>
       6                 :            : #include <linux/percpu.h>
       7                 :            : #include <linux/mmzone.h>
       8                 :            : #include <linux/vm_event_item.h>
       9                 :            : #include <linux/atomic.h>
      10                 :            : #include <linux/static_key.h>
      11                 :            : 
      12                 :            : extern int sysctl_stat_interval;
      13                 :            : 
      14                 :            : #ifdef CONFIG_NUMA
      15                 :            : #define ENABLE_NUMA_STAT   1
      16                 :            : #define DISABLE_NUMA_STAT   0
      17                 :            : extern int sysctl_vm_numa_stat;
      18                 :            : DECLARE_STATIC_KEY_TRUE(vm_numa_stat_key);
      19                 :            : extern int sysctl_vm_numa_stat_handler(struct ctl_table *table,
      20                 :            :                 int write, void __user *buffer, size_t *length, loff_t *ppos);
      21                 :            : #endif
      22                 :            : 
      23                 :            : struct reclaim_stat {
      24                 :            :         unsigned nr_dirty;
      25                 :            :         unsigned nr_unqueued_dirty;
      26                 :            :         unsigned nr_congested;
      27                 :            :         unsigned nr_writeback;
      28                 :            :         unsigned nr_immediate;
      29                 :            :         unsigned nr_activate[2];
      30                 :            :         unsigned nr_ref_keep;
      31                 :            :         unsigned nr_unmap_fail;
      32                 :            : };
      33                 :            : 
      34                 :            : #ifdef CONFIG_VM_EVENT_COUNTERS
      35                 :            : /*
      36                 :            :  * Light weight per cpu counter implementation.
      37                 :            :  *
      38                 :            :  * Counters should only be incremented and no critical kernel component
      39                 :            :  * should rely on the counter values.
      40                 :            :  *
      41                 :            :  * Counters are handled completely inline. On many platforms the code
      42                 :            :  * generated will simply be the increment of a global address.
      43                 :            :  */
      44                 :            : 
      45                 :            : struct vm_event_state {
      46                 :            :         unsigned long event[NR_VM_EVENT_ITEMS];
      47                 :            : };
      48                 :            : 
      49                 :            : DECLARE_PER_CPU(struct vm_event_state, vm_event_states);
      50                 :            : 
      51                 :            : /*
      52                 :            :  * vm counters are allowed to be racy. Use raw_cpu_ops to avoid the
      53                 :            :  * local_irq_disable overhead.
      54                 :            :  */
      55                 :            : static inline void __count_vm_event(enum vm_event_item item)
      56                 :            : {
      57                 :          3 :         raw_cpu_inc(vm_event_states.event[item]);
      58                 :            : }
      59                 :            : 
      60                 :            : static inline void count_vm_event(enum vm_event_item item)
      61                 :            : {
      62                 :          3 :         this_cpu_inc(vm_event_states.event[item]);
      63                 :            : }
      64                 :            : 
      65                 :            : static inline void __count_vm_events(enum vm_event_item item, long delta)
      66                 :            : {
      67                 :          3 :         raw_cpu_add(vm_event_states.event[item], delta);
      68                 :            : }
      69                 :            : 
      70                 :            : static inline void count_vm_events(enum vm_event_item item, long delta)
      71                 :            : {
      72                 :          3 :         this_cpu_add(vm_event_states.event[item], delta);
      73                 :            : }
      74                 :            : 
      75                 :            : extern void all_vm_events(unsigned long *);
      76                 :            : 
      77                 :            : extern void vm_events_fold_cpu(int cpu);
      78                 :            : 
      79                 :            : #else
      80                 :            : 
      81                 :            : /* Disable counters */
      82                 :            : static inline void count_vm_event(enum vm_event_item item)
      83                 :            : {
      84                 :            : }
      85                 :            : static inline void count_vm_events(enum vm_event_item item, long delta)
      86                 :            : {
      87                 :            : }
      88                 :            : static inline void __count_vm_event(enum vm_event_item item)
      89                 :            : {
      90                 :            : }
      91                 :            : static inline void __count_vm_events(enum vm_event_item item, long delta)
      92                 :            : {
      93                 :            : }
      94                 :            : static inline void all_vm_events(unsigned long *ret)
      95                 :            : {
      96                 :            : }
      97                 :            : static inline void vm_events_fold_cpu(int cpu)
      98                 :            : {
      99                 :            : }
     100                 :            : 
     101                 :            : #endif /* CONFIG_VM_EVENT_COUNTERS */
     102                 :            : 
     103                 :            : #ifdef CONFIG_NUMA_BALANCING
     104                 :            : #define count_vm_numa_event(x)     count_vm_event(x)
     105                 :            : #define count_vm_numa_events(x, y) count_vm_events(x, y)
     106                 :            : #else
     107                 :            : #define count_vm_numa_event(x) do {} while (0)
     108                 :            : #define count_vm_numa_events(x, y) do { (void)(y); } while (0)
     109                 :            : #endif /* CONFIG_NUMA_BALANCING */
     110                 :            : 
     111                 :            : #ifdef CONFIG_DEBUG_TLBFLUSH
     112                 :            : #define count_vm_tlb_event(x)      count_vm_event(x)
     113                 :            : #define count_vm_tlb_events(x, y)  count_vm_events(x, y)
     114                 :            : #else
     115                 :            : #define count_vm_tlb_event(x)     do {} while (0)
     116                 :            : #define count_vm_tlb_events(x, y) do { (void)(y); } while (0)
     117                 :            : #endif
     118                 :            : 
     119                 :            : #ifdef CONFIG_DEBUG_VM_VMACACHE
     120                 :            : #define count_vm_vmacache_event(x) count_vm_event(x)
     121                 :            : #else
     122                 :            : #define count_vm_vmacache_event(x) do {} while (0)
     123                 :            : #endif
     124                 :            : 
     125                 :            : #define __count_zid_vm_events(item, zid, delta) \
     126                 :            :         __count_vm_events(item##_NORMAL - ZONE_NORMAL + zid, delta)
     127                 :            : 
     128                 :            : /*
     129                 :            :  * Zone and node-based page accounting with per cpu differentials.
     130                 :            :  */
     131                 :            : extern atomic_long_t vm_zone_stat[NR_VM_ZONE_STAT_ITEMS];
     132                 :            : extern atomic_long_t vm_numa_stat[NR_VM_NUMA_STAT_ITEMS];
     133                 :            : extern atomic_long_t vm_node_stat[NR_VM_NODE_STAT_ITEMS];
     134                 :            : 
     135                 :            : #ifdef CONFIG_NUMA
     136                 :            : static inline void zone_numa_state_add(long x, struct zone *zone,
     137                 :            :                                  enum numa_stat_item item)
     138                 :            : {
     139                 :            :         atomic_long_add(x, &zone->vm_numa_stat[item]);
     140                 :            :         atomic_long_add(x, &vm_numa_stat[item]);
     141                 :            : }
     142                 :            : 
     143                 :            : static inline unsigned long global_numa_state(enum numa_stat_item item)
     144                 :            : {
     145                 :            :         long x = atomic_long_read(&vm_numa_stat[item]);
     146                 :            : 
     147                 :            :         return x;
     148                 :            : }
     149                 :            : 
     150                 :            : static inline unsigned long zone_numa_state_snapshot(struct zone *zone,
     151                 :            :                                         enum numa_stat_item item)
     152                 :            : {
     153                 :            :         long x = atomic_long_read(&zone->vm_numa_stat[item]);
     154                 :            :         int cpu;
     155                 :            : 
     156                 :            :         for_each_online_cpu(cpu)
     157                 :            :                 x += per_cpu_ptr(zone->pageset, cpu)->vm_numa_stat_diff[item];
     158                 :            : 
     159                 :            :         return x;
     160                 :            : }
     161                 :            : #endif /* CONFIG_NUMA */
     162                 :            : 
     163                 :          3 : static inline void zone_page_state_add(long x, struct zone *zone,
     164                 :            :                                  enum zone_stat_item item)
     165                 :            : {
     166                 :          3 :         atomic_long_add(x, &zone->vm_stat[item]);
     167                 :          3 :         atomic_long_add(x, &vm_zone_stat[item]);
     168                 :          3 : }
     169                 :            : 
     170                 :          3 : static inline void node_page_state_add(long x, struct pglist_data *pgdat,
     171                 :            :                                  enum node_stat_item item)
     172                 :            : {
     173                 :          3 :         atomic_long_add(x, &pgdat->vm_stat[item]);
     174                 :          3 :         atomic_long_add(x, &vm_node_stat[item]);
     175                 :          3 : }
     176                 :            : 
     177                 :            : static inline unsigned long global_zone_page_state(enum zone_stat_item item)
     178                 :            : {
     179                 :          0 :         long x = atomic_long_read(&vm_zone_stat[item]);
     180                 :            : #ifdef CONFIG_SMP
     181                 :          3 :         if (x < 0)
     182                 :            :                 x = 0;
     183                 :            : #endif
     184                 :          3 :         return x;
     185                 :            : }
     186                 :            : 
     187                 :            : static inline unsigned long global_node_page_state(enum node_stat_item item)
     188                 :            : {
     189                 :          3 :         long x = atomic_long_read(&vm_node_stat[item]);
     190                 :            : #ifdef CONFIG_SMP
     191                 :          3 :         if (x < 0)
     192                 :            :                 x = 0;
     193                 :            : #endif
     194                 :          3 :         return x;
     195                 :            : }
     196                 :            : 
     197                 :            : static inline unsigned long zone_page_state(struct zone *zone,
     198                 :            :                                         enum zone_stat_item item)
     199                 :            : {
     200                 :          3 :         long x = atomic_long_read(&zone->vm_stat[item]);
     201                 :            : #ifdef CONFIG_SMP
     202                 :          3 :         if (x < 0)
     203                 :            :                 x = 0;
     204                 :            : #endif
     205                 :          3 :         return x;
     206                 :            : }
     207                 :            : 
     208                 :            : /*
     209                 :            :  * More accurate version that also considers the currently pending
     210                 :            :  * deltas. For that we need to loop over all cpus to find the current
     211                 :            :  * deltas. There is no synchronization so the result cannot be
     212                 :            :  * exactly accurate either.
     213                 :            :  */
     214                 :          0 : static inline unsigned long zone_page_state_snapshot(struct zone *zone,
     215                 :            :                                         enum zone_stat_item item)
     216                 :            : {
     217                 :          0 :         long x = atomic_long_read(&zone->vm_stat[item]);
     218                 :            : 
     219                 :            : #ifdef CONFIG_SMP
     220                 :            :         int cpu;
     221                 :          0 :         for_each_online_cpu(cpu)
     222                 :          0 :                 x += per_cpu_ptr(zone->pageset, cpu)->vm_stat_diff[item];
     223                 :            : 
     224                 :          0 :         if (x < 0)
     225                 :            :                 x = 0;
     226                 :            : #endif
     227                 :          0 :         return x;
     228                 :            : }
     229                 :            : 
     230                 :            : #ifdef CONFIG_NUMA
     231                 :            : extern void __inc_numa_state(struct zone *zone, enum numa_stat_item item);
     232                 :            : extern unsigned long sum_zone_node_page_state(int node,
     233                 :            :                                               enum zone_stat_item item);
     234                 :            : extern unsigned long sum_zone_numa_state(int node, enum numa_stat_item item);
     235                 :            : extern unsigned long node_page_state(struct pglist_data *pgdat,
     236                 :            :                                                 enum node_stat_item item);
     237                 :            : #else
     238                 :            : #define sum_zone_node_page_state(node, item) global_zone_page_state(item)
     239                 :            : #define node_page_state(node, item) global_node_page_state(item)
     240                 :            : #endif /* CONFIG_NUMA */
     241                 :            : 
     242                 :            : #ifdef CONFIG_SMP
     243                 :            : void __mod_zone_page_state(struct zone *, enum zone_stat_item item, long);
     244                 :            : void __inc_zone_page_state(struct page *, enum zone_stat_item);
     245                 :            : void __dec_zone_page_state(struct page *, enum zone_stat_item);
     246                 :            : 
     247                 :            : void __mod_node_page_state(struct pglist_data *, enum node_stat_item item, long);
     248                 :            : void __inc_node_page_state(struct page *, enum node_stat_item);
     249                 :            : void __dec_node_page_state(struct page *, enum node_stat_item);
     250                 :            : 
     251                 :            : void mod_zone_page_state(struct zone *, enum zone_stat_item, long);
     252                 :            : void inc_zone_page_state(struct page *, enum zone_stat_item);
     253                 :            : void dec_zone_page_state(struct page *, enum zone_stat_item);
     254                 :            : 
     255                 :            : void mod_node_page_state(struct pglist_data *, enum node_stat_item, long);
     256                 :            : void inc_node_page_state(struct page *, enum node_stat_item);
     257                 :            : void dec_node_page_state(struct page *, enum node_stat_item);
     258                 :            : 
     259                 :            : extern void inc_node_state(struct pglist_data *, enum node_stat_item);
     260                 :            : extern void __inc_zone_state(struct zone *, enum zone_stat_item);
     261                 :            : extern void __inc_node_state(struct pglist_data *, enum node_stat_item);
     262                 :            : extern void dec_zone_state(struct zone *, enum zone_stat_item);
     263                 :            : extern void __dec_zone_state(struct zone *, enum zone_stat_item);
     264                 :            : extern void __dec_node_state(struct pglist_data *, enum node_stat_item);
     265                 :            : 
     266                 :            : void quiet_vmstat(void);
     267                 :            : void cpu_vm_stats_fold(int cpu);
     268                 :            : void refresh_zone_stat_thresholds(void);
     269                 :            : 
     270                 :            : struct ctl_table;
     271                 :            : int vmstat_refresh(struct ctl_table *, int write,
     272                 :            :                    void __user *buffer, size_t *lenp, loff_t *ppos);
     273                 :            : 
     274                 :            : void drain_zonestat(struct zone *zone, struct per_cpu_pageset *);
     275                 :            : 
     276                 :            : int calculate_pressure_threshold(struct zone *zone);
     277                 :            : int calculate_normal_threshold(struct zone *zone);
     278                 :            : void set_pgdat_percpu_threshold(pg_data_t *pgdat,
     279                 :            :                                 int (*calculate_pressure)(struct zone *));
     280                 :            : #else /* CONFIG_SMP */
     281                 :            : 
     282                 :            : /*
     283                 :            :  * We do not maintain differentials in a single processor configuration.
     284                 :            :  * The functions directly modify the zone and global counters.
     285                 :            :  */
     286                 :            : static inline void __mod_zone_page_state(struct zone *zone,
     287                 :            :                         enum zone_stat_item item, long delta)
     288                 :            : {
     289                 :            :         zone_page_state_add(delta, zone, item);
     290                 :            : }
     291                 :            : 
     292                 :            : static inline void __mod_node_page_state(struct pglist_data *pgdat,
     293                 :            :                         enum node_stat_item item, int delta)
     294                 :            : {
     295                 :            :         node_page_state_add(delta, pgdat, item);
     296                 :            : }
     297                 :            : 
     298                 :            : static inline void __inc_zone_state(struct zone *zone, enum zone_stat_item item)
     299                 :            : {
     300                 :            :         atomic_long_inc(&zone->vm_stat[item]);
     301                 :            :         atomic_long_inc(&vm_zone_stat[item]);
     302                 :            : }
     303                 :            : 
     304                 :            : static inline void __inc_node_state(struct pglist_data *pgdat, enum node_stat_item item)
     305                 :            : {
     306                 :            :         atomic_long_inc(&pgdat->vm_stat[item]);
     307                 :            :         atomic_long_inc(&vm_node_stat[item]);
     308                 :            : }
     309                 :            : 
     310                 :            : static inline void __dec_zone_state(struct zone *zone, enum zone_stat_item item)
     311                 :            : {
     312                 :            :         atomic_long_dec(&zone->vm_stat[item]);
     313                 :            :         atomic_long_dec(&vm_zone_stat[item]);
     314                 :            : }
     315                 :            : 
     316                 :            : static inline void __dec_node_state(struct pglist_data *pgdat, enum node_stat_item item)
     317                 :            : {
     318                 :            :         atomic_long_dec(&pgdat->vm_stat[item]);
     319                 :            :         atomic_long_dec(&vm_node_stat[item]);
     320                 :            : }
     321                 :            : 
     322                 :            : static inline void __inc_zone_page_state(struct page *page,
     323                 :            :                         enum zone_stat_item item)
     324                 :            : {
     325                 :            :         __inc_zone_state(page_zone(page), item);
     326                 :            : }
     327                 :            : 
     328                 :            : static inline void __inc_node_page_state(struct page *page,
     329                 :            :                         enum node_stat_item item)
     330                 :            : {
     331                 :            :         __inc_node_state(page_pgdat(page), item);
     332                 :            : }
     333                 :            : 
     334                 :            : 
     335                 :            : static inline void __dec_zone_page_state(struct page *page,
     336                 :            :                         enum zone_stat_item item)
     337                 :            : {
     338                 :            :         __dec_zone_state(page_zone(page), item);
     339                 :            : }
     340                 :            : 
     341                 :            : static inline void __dec_node_page_state(struct page *page,
     342                 :            :                         enum node_stat_item item)
     343                 :            : {
     344                 :            :         __dec_node_state(page_pgdat(page), item);
     345                 :            : }
     346                 :            : 
     347                 :            : 
     348                 :            : /*
     349                 :            :  * We only use atomic operations to update counters. So there is no need to
     350                 :            :  * disable interrupts.
     351                 :            :  */
     352                 :            : #define inc_zone_page_state __inc_zone_page_state
     353                 :            : #define dec_zone_page_state __dec_zone_page_state
     354                 :            : #define mod_zone_page_state __mod_zone_page_state
     355                 :            : 
     356                 :            : #define inc_node_page_state __inc_node_page_state
     357                 :            : #define dec_node_page_state __dec_node_page_state
     358                 :            : #define mod_node_page_state __mod_node_page_state
     359                 :            : 
     360                 :            : #define inc_zone_state __inc_zone_state
     361                 :            : #define inc_node_state __inc_node_state
     362                 :            : #define dec_zone_state __dec_zone_state
     363                 :            : 
     364                 :            : #define set_pgdat_percpu_threshold(pgdat, callback) { }
     365                 :            : 
     366                 :            : static inline void refresh_zone_stat_thresholds(void) { }
     367                 :            : static inline void cpu_vm_stats_fold(int cpu) { }
     368                 :            : static inline void quiet_vmstat(void) { }
     369                 :            : 
     370                 :            : static inline void drain_zonestat(struct zone *zone,
     371                 :            :                         struct per_cpu_pageset *pset) { }
     372                 :            : #endif          /* CONFIG_SMP */
     373                 :            : 
     374                 :          3 : static inline void __mod_zone_freepage_state(struct zone *zone, int nr_pages,
     375                 :            :                                              int migratetype)
     376                 :            : {
     377                 :          3 :         __mod_zone_page_state(zone, NR_FREE_PAGES, nr_pages);
     378                 :          3 :         if (is_migrate_cma(migratetype))
     379                 :          3 :                 __mod_zone_page_state(zone, NR_FREE_CMA_PAGES, nr_pages);
     380                 :          3 : }
     381                 :            : 
     382                 :            : extern const char * const vmstat_text[];
     383                 :            : 
     384                 :            : #endif /* _LINUX_VMSTAT_H */