Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : /*
       3             :  * include/linux/node.h - generic node definition
       4             :  *
       5             :  * This is mainly for topological representation. We define the 
       6             :  * basic 'struct node' here, which can be embedded in per-arch 
       7             :  * definitions of processors.
       8             :  *
       9             :  * Basic handling of the devices is done in drivers/base/node.c
      10             :  * and system devices are handled in drivers/base/sys.c. 
      11             :  *
      12             :  * Nodes are exported via driverfs in the class/node/devices/
      13             :  * directory. 
      14             :  */
      15             : #ifndef _LINUX_NODE_H_
      16             : #define _LINUX_NODE_H_
      17             : 
      18             : #include <linux/device.h>
      19             : #include <linux/cpumask.h>
      20             : #include <linux/list.h>
      21             : #include <linux/workqueue.h>
      22             : 
      23             : /**
      24             :  * struct node_hmem_attrs - heterogeneous memory performance attributes
      25             :  *
      26             :  * @read_bandwidth:     Read bandwidth in MB/s
      27             :  * @write_bandwidth:    Write bandwidth in MB/s
      28             :  * @read_latency:       Read latency in nanoseconds
      29             :  * @write_latency:      Write latency in nanoseconds
      30             :  */
      31             : struct node_hmem_attrs {
      32             :         unsigned int read_bandwidth;
      33             :         unsigned int write_bandwidth;
      34             :         unsigned int read_latency;
      35             :         unsigned int write_latency;
      36             : };
      37             : 
      38             : enum cache_indexing {
      39             :         NODE_CACHE_DIRECT_MAP,
      40             :         NODE_CACHE_INDEXED,
      41             :         NODE_CACHE_OTHER,
      42             : };
      43             : 
      44             : enum cache_write_policy {
      45             :         NODE_CACHE_WRITE_BACK,
      46             :         NODE_CACHE_WRITE_THROUGH,
      47             :         NODE_CACHE_WRITE_OTHER,
      48             : };
      49             : 
      50             : /**
      51             :  * struct node_cache_attrs - system memory caching attributes
      52             :  *
      53             :  * @indexing:           The ways memory blocks may be placed in cache
      54             :  * @write_policy:       Write back or write through policy
      55             :  * @size:               Total size of cache in bytes
      56             :  * @line_size:          Number of bytes fetched on a cache miss
      57             :  * @level:              The cache hierarchy level
      58             :  */
      59             : struct node_cache_attrs {
      60             :         enum cache_indexing indexing;
      61             :         enum cache_write_policy write_policy;
      62             :         u64 size;
      63             :         u16 line_size;
      64             :         u8 level;
      65             : };
      66             : 
      67             : #ifdef CONFIG_HMEM_REPORTING
      68             : void node_add_cache(unsigned int nid, struct node_cache_attrs *cache_attrs);
      69             : void node_set_perf_attrs(unsigned int nid, struct node_hmem_attrs *hmem_attrs,
      70             :                          unsigned access);
      71             : #else
      72             : static inline void node_add_cache(unsigned int nid,
      73             :                                   struct node_cache_attrs *cache_attrs)
      74             : {
      75             : }
      76             : 
      77             : static inline void node_set_perf_attrs(unsigned int nid,
      78             :                                        struct node_hmem_attrs *hmem_attrs,
      79             :                                        unsigned access)
      80             : {
      81             : }
      82             : #endif
      83             : 
      84             : struct node {
      85             :         struct device   dev;
      86             :         struct list_head access_list;
      87             : 
      88             : #if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) && defined(CONFIG_HUGETLBFS)
      89             :         struct work_struct      node_work;
      90             : #endif
      91             : #ifdef CONFIG_HMEM_REPORTING
      92             :         struct list_head cache_attrs;
      93             :         struct device *cache_dev;
      94             : #endif
      95             : };
      96             : 
      97             : struct memory_block;
      98             : extern struct node *node_devices[];
      99             : typedef  void (*node_registration_func_t)(struct node *);
     100             : 
     101             : #if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) && defined(CONFIG_NUMA)
     102             : void link_mem_sections(int nid, unsigned long start_pfn,
     103             :                        unsigned long end_pfn,
     104             :                        enum meminit_context context);
     105             : #else
     106             : static inline void link_mem_sections(int nid, unsigned long start_pfn,
     107             :                                      unsigned long end_pfn,
     108             :                                      enum meminit_context context)
     109             : {
     110             : }
     111             : #endif
     112             : 
     113             : extern void unregister_node(struct node *node);
     114             : #ifdef CONFIG_NUMA
     115             : /* Core of the node registration - only memory hotplug should use this */
     116             : extern int __register_one_node(int nid);
     117             : 
     118             : /* Registers an online node */
     119           1 : static inline int register_one_node(int nid)
     120             : {
     121           1 :         int error = 0;
     122             : 
     123           1 :         if (node_online(nid)) {
     124           1 :                 struct pglist_data *pgdat = NODE_DATA(nid);
     125           1 :                 unsigned long start_pfn = pgdat->node_start_pfn;
     126           1 :                 unsigned long end_pfn = start_pfn + pgdat->node_spanned_pages;
     127             : 
     128           1 :                 error = __register_one_node(nid);
     129           1 :                 if (error)
     130             :                         return error;
     131             :                 /* link memory sections under this node */
     132           1 :                 link_mem_sections(nid, start_pfn, end_pfn, MEMINIT_EARLY);
     133             :         }
     134             : 
     135             :         return error;
     136             : }
     137             : 
     138             : extern void unregister_one_node(int nid);
     139             : extern int register_cpu_under_node(unsigned int cpu, unsigned int nid);
     140             : extern int unregister_cpu_under_node(unsigned int cpu, unsigned int nid);
     141             : extern void unregister_memory_block_under_nodes(struct memory_block *mem_blk);
     142             : 
     143             : extern int register_memory_node_under_compute_node(unsigned int mem_nid,
     144             :                                                    unsigned int cpu_nid,
     145             :                                                    unsigned access);
     146             : 
     147             : #ifdef CONFIG_HUGETLBFS
     148             : extern void register_hugetlbfs_with_node(node_registration_func_t doregister,
     149             :                                          node_registration_func_t unregister);
     150             : #endif
     151             : #else
     152             : static inline int __register_one_node(int nid)
     153             : {
     154             :         return 0;
     155             : }
     156             : static inline int register_one_node(int nid)
     157             : {
     158             :         return 0;
     159             : }
     160             : static inline int unregister_one_node(int nid)
     161             : {
     162             :         return 0;
     163             : }
     164             : static inline int register_cpu_under_node(unsigned int cpu, unsigned int nid)
     165             : {
     166             :         return 0;
     167             : }
     168             : static inline int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
     169             : {
     170             :         return 0;
     171             : }
     172             : static inline void unregister_memory_block_under_nodes(struct memory_block *mem_blk)
     173             : {
     174             : }
     175             : 
     176             : static inline void register_hugetlbfs_with_node(node_registration_func_t reg,
     177             :                                                 node_registration_func_t unreg)
     178             : {
     179             : }
     180             : #endif
     181             : 
     182             : #define to_node(device) container_of(device, struct node, dev)
     183             : 
     184             : #endif /* _LINUX_NODE_H_ */