Merge 5.18-rc5 into driver-core-next
We need the kernfs/driver core fixes in here as well. Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Greg Kroah-Hartman
commit
0e509f537f
1035 changed files with 8397 additions and 5719 deletions
|
|
@ -167,7 +167,7 @@ static inline int suspend_disable_secondary_cpus(void) { return 0; }
|
|||
static inline void suspend_enable_secondary_cpus(void) { }
|
||||
#endif /* !CONFIG_PM_SLEEP_SMP */
|
||||
|
||||
void cpu_startup_entry(enum cpuhp_state state);
|
||||
void __noreturn cpu_startup_entry(enum cpuhp_state state);
|
||||
|
||||
void cpu_idle_poll_ctrl(bool enable);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,266 +0,0 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
/*
|
||||
* Pointer to dma-buf-mapped memory, plus helpers.
|
||||
*/
|
||||
|
||||
#ifndef __DMA_BUF_MAP_H__
|
||||
#define __DMA_BUF_MAP_H__
|
||||
|
||||
#include <linux/io.h>
|
||||
#include <linux/string.h>
|
||||
|
||||
/**
|
||||
* DOC: overview
|
||||
*
|
||||
* Calling dma-buf's vmap operation returns a pointer to the buffer's memory.
|
||||
* Depending on the location of the buffer, users may have to access it with
|
||||
* I/O operations or memory load/store operations. For example, copying to
|
||||
* system memory could be done with memcpy(), copying to I/O memory would be
|
||||
* done with memcpy_toio().
|
||||
*
|
||||
* .. code-block:: c
|
||||
*
|
||||
* void *vaddr = ...; // pointer to system memory
|
||||
* memcpy(vaddr, src, len);
|
||||
*
|
||||
* void *vaddr_iomem = ...; // pointer to I/O memory
|
||||
* memcpy_toio(vaddr, _iomem, src, len);
|
||||
*
|
||||
* When using dma-buf's vmap operation, the returned pointer is encoded as
|
||||
* :c:type:`struct dma_buf_map <dma_buf_map>`.
|
||||
* :c:type:`struct dma_buf_map <dma_buf_map>` stores the buffer's address in
|
||||
* system or I/O memory and a flag that signals the required method of
|
||||
* accessing the buffer. Use the returned instance and the helper functions
|
||||
* to access the buffer's memory in the correct way.
|
||||
*
|
||||
* The type :c:type:`struct dma_buf_map <dma_buf_map>` and its helpers are
|
||||
* actually independent from the dma-buf infrastructure. When sharing buffers
|
||||
* among devices, drivers have to know the location of the memory to access
|
||||
* the buffers in a safe way. :c:type:`struct dma_buf_map <dma_buf_map>`
|
||||
* solves this problem for dma-buf and its users. If other drivers or
|
||||
* sub-systems require similar functionality, the type could be generalized
|
||||
* and moved to a more prominent header file.
|
||||
*
|
||||
* Open-coding access to :c:type:`struct dma_buf_map <dma_buf_map>` is
|
||||
* considered bad style. Rather then accessing its fields directly, use one
|
||||
* of the provided helper functions, or implement your own. For example,
|
||||
* instances of :c:type:`struct dma_buf_map <dma_buf_map>` can be initialized
|
||||
* statically with DMA_BUF_MAP_INIT_VADDR(), or at runtime with
|
||||
* dma_buf_map_set_vaddr(). These helpers will set an address in system memory.
|
||||
*
|
||||
* .. code-block:: c
|
||||
*
|
||||
* struct dma_buf_map map = DMA_BUF_MAP_INIT_VADDR(0xdeadbeaf);
|
||||
*
|
||||
* dma_buf_map_set_vaddr(&map, 0xdeadbeaf);
|
||||
*
|
||||
* To set an address in I/O memory, use dma_buf_map_set_vaddr_iomem().
|
||||
*
|
||||
* .. code-block:: c
|
||||
*
|
||||
* dma_buf_map_set_vaddr_iomem(&map, 0xdeadbeaf);
|
||||
*
|
||||
* Instances of struct dma_buf_map do not have to be cleaned up, but
|
||||
* can be cleared to NULL with dma_buf_map_clear(). Cleared mappings
|
||||
* always refer to system memory.
|
||||
*
|
||||
* .. code-block:: c
|
||||
*
|
||||
* dma_buf_map_clear(&map);
|
||||
*
|
||||
* Test if a mapping is valid with either dma_buf_map_is_set() or
|
||||
* dma_buf_map_is_null().
|
||||
*
|
||||
* .. code-block:: c
|
||||
*
|
||||
* if (dma_buf_map_is_set(&map) != dma_buf_map_is_null(&map))
|
||||
* // always true
|
||||
*
|
||||
* Instances of :c:type:`struct dma_buf_map <dma_buf_map>` can be compared
|
||||
* for equality with dma_buf_map_is_equal(). Mappings the point to different
|
||||
* memory spaces, system or I/O, are never equal. That's even true if both
|
||||
* spaces are located in the same address space, both mappings contain the
|
||||
* same address value, or both mappings refer to NULL.
|
||||
*
|
||||
* .. code-block:: c
|
||||
*
|
||||
* struct dma_buf_map sys_map; // refers to system memory
|
||||
* struct dma_buf_map io_map; // refers to I/O memory
|
||||
*
|
||||
* if (dma_buf_map_is_equal(&sys_map, &io_map))
|
||||
* // always false
|
||||
*
|
||||
* A set up instance of struct dma_buf_map can be used to access or manipulate
|
||||
* the buffer memory. Depending on the location of the memory, the provided
|
||||
* helpers will pick the correct operations. Data can be copied into the memory
|
||||
* with dma_buf_map_memcpy_to(). The address can be manipulated with
|
||||
* dma_buf_map_incr().
|
||||
*
|
||||
* .. code-block:: c
|
||||
*
|
||||
* const void *src = ...; // source buffer
|
||||
* size_t len = ...; // length of src
|
||||
*
|
||||
* dma_buf_map_memcpy_to(&map, src, len);
|
||||
* dma_buf_map_incr(&map, len); // go to first byte after the memcpy
|
||||
*/
|
||||
|
||||
/**
|
||||
* struct dma_buf_map - Pointer to vmap'ed dma-buf memory.
|
||||
* @vaddr_iomem: The buffer's address if in I/O memory
|
||||
* @vaddr: The buffer's address if in system memory
|
||||
* @is_iomem: True if the dma-buf memory is located in I/O
|
||||
* memory, or false otherwise.
|
||||
*/
|
||||
struct dma_buf_map {
|
||||
union {
|
||||
void __iomem *vaddr_iomem;
|
||||
void *vaddr;
|
||||
};
|
||||
bool is_iomem;
|
||||
};
|
||||
|
||||
/**
|
||||
* DMA_BUF_MAP_INIT_VADDR - Initializes struct dma_buf_map to an address in system memory
|
||||
* @vaddr_: A system-memory address
|
||||
*/
|
||||
#define DMA_BUF_MAP_INIT_VADDR(vaddr_) \
|
||||
{ \
|
||||
.vaddr = (vaddr_), \
|
||||
.is_iomem = false, \
|
||||
}
|
||||
|
||||
/**
|
||||
* dma_buf_map_set_vaddr - Sets a dma-buf mapping structure to an address in system memory
|
||||
* @map: The dma-buf mapping structure
|
||||
* @vaddr: A system-memory address
|
||||
*
|
||||
* Sets the address and clears the I/O-memory flag.
|
||||
*/
|
||||
static inline void dma_buf_map_set_vaddr(struct dma_buf_map *map, void *vaddr)
|
||||
{
|
||||
map->vaddr = vaddr;
|
||||
map->is_iomem = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* dma_buf_map_set_vaddr_iomem - Sets a dma-buf mapping structure to an address in I/O memory
|
||||
* @map: The dma-buf mapping structure
|
||||
* @vaddr_iomem: An I/O-memory address
|
||||
*
|
||||
* Sets the address and the I/O-memory flag.
|
||||
*/
|
||||
static inline void dma_buf_map_set_vaddr_iomem(struct dma_buf_map *map,
|
||||
void __iomem *vaddr_iomem)
|
||||
{
|
||||
map->vaddr_iomem = vaddr_iomem;
|
||||
map->is_iomem = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* dma_buf_map_is_equal - Compares two dma-buf mapping structures for equality
|
||||
* @lhs: The dma-buf mapping structure
|
||||
* @rhs: A dma-buf mapping structure to compare with
|
||||
*
|
||||
* Two dma-buf mapping structures are equal if they both refer to the same type of memory
|
||||
* and to the same address within that memory.
|
||||
*
|
||||
* Returns:
|
||||
* True is both structures are equal, or false otherwise.
|
||||
*/
|
||||
static inline bool dma_buf_map_is_equal(const struct dma_buf_map *lhs,
|
||||
const struct dma_buf_map *rhs)
|
||||
{
|
||||
if (lhs->is_iomem != rhs->is_iomem)
|
||||
return false;
|
||||
else if (lhs->is_iomem)
|
||||
return lhs->vaddr_iomem == rhs->vaddr_iomem;
|
||||
else
|
||||
return lhs->vaddr == rhs->vaddr;
|
||||
}
|
||||
|
||||
/**
|
||||
* dma_buf_map_is_null - Tests for a dma-buf mapping to be NULL
|
||||
* @map: The dma-buf mapping structure
|
||||
*
|
||||
* Depending on the state of struct dma_buf_map.is_iomem, tests if the
|
||||
* mapping is NULL.
|
||||
*
|
||||
* Returns:
|
||||
* True if the mapping is NULL, or false otherwise.
|
||||
*/
|
||||
static inline bool dma_buf_map_is_null(const struct dma_buf_map *map)
|
||||
{
|
||||
if (map->is_iomem)
|
||||
return !map->vaddr_iomem;
|
||||
return !map->vaddr;
|
||||
}
|
||||
|
||||
/**
|
||||
* dma_buf_map_is_set - Tests is the dma-buf mapping has been set
|
||||
* @map: The dma-buf mapping structure
|
||||
*
|
||||
* Depending on the state of struct dma_buf_map.is_iomem, tests if the
|
||||
* mapping has been set.
|
||||
*
|
||||
* Returns:
|
||||
* True if the mapping is been set, or false otherwise.
|
||||
*/
|
||||
static inline bool dma_buf_map_is_set(const struct dma_buf_map *map)
|
||||
{
|
||||
return !dma_buf_map_is_null(map);
|
||||
}
|
||||
|
||||
/**
|
||||
* dma_buf_map_clear - Clears a dma-buf mapping structure
|
||||
* @map: The dma-buf mapping structure
|
||||
*
|
||||
* Clears all fields to zero; including struct dma_buf_map.is_iomem. So
|
||||
* mapping structures that were set to point to I/O memory are reset for
|
||||
* system memory. Pointers are cleared to NULL. This is the default.
|
||||
*/
|
||||
static inline void dma_buf_map_clear(struct dma_buf_map *map)
|
||||
{
|
||||
if (map->is_iomem) {
|
||||
map->vaddr_iomem = NULL;
|
||||
map->is_iomem = false;
|
||||
} else {
|
||||
map->vaddr = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* dma_buf_map_memcpy_to - Memcpy into dma-buf mapping
|
||||
* @dst: The dma-buf mapping structure
|
||||
* @src: The source buffer
|
||||
* @len: The number of byte in src
|
||||
*
|
||||
* Copies data into a dma-buf mapping. The source buffer is in system
|
||||
* memory. Depending on the buffer's location, the helper picks the correct
|
||||
* method of accessing the memory.
|
||||
*/
|
||||
static inline void dma_buf_map_memcpy_to(struct dma_buf_map *dst, const void *src, size_t len)
|
||||
{
|
||||
if (dst->is_iomem)
|
||||
memcpy_toio(dst->vaddr_iomem, src, len);
|
||||
else
|
||||
memcpy(dst->vaddr, src, len);
|
||||
}
|
||||
|
||||
/**
|
||||
* dma_buf_map_incr - Increments the address stored in a dma-buf mapping
|
||||
* @map: The dma-buf mapping structure
|
||||
* @incr: The number of bytes to increment
|
||||
*
|
||||
* Increments the address stored in a dma-buf mapping. Depending on the
|
||||
* buffer's location, the correct value will be updated.
|
||||
*/
|
||||
static inline void dma_buf_map_incr(struct dma_buf_map *map, size_t incr)
|
||||
{
|
||||
if (map->is_iomem)
|
||||
map->vaddr_iomem += incr;
|
||||
else
|
||||
map->vaddr += incr;
|
||||
}
|
||||
|
||||
#endif /* __DMA_BUF_MAP_H__ */
|
||||
|
|
@ -573,7 +573,6 @@ int fscache_write(struct netfs_cache_resources *cres,
|
|||
|
||||
/**
|
||||
* fscache_clear_page_bits - Clear the PG_fscache bits from a set of pages
|
||||
* @cookie: The cookie representing the cache object
|
||||
* @mapping: The netfs inode to use as the source
|
||||
* @start: The start position in @mapping
|
||||
* @len: The amount of data to unlock
|
||||
|
|
@ -582,8 +581,7 @@ int fscache_write(struct netfs_cache_resources *cres,
|
|||
* Clear the PG_fscache flag from a sequence of pages and wake up anyone who's
|
||||
* waiting.
|
||||
*/
|
||||
static inline void fscache_clear_page_bits(struct fscache_cookie *cookie,
|
||||
struct address_space *mapping,
|
||||
static inline void fscache_clear_page_bits(struct address_space *mapping,
|
||||
loff_t start, size_t len,
|
||||
bool caching)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -688,7 +688,7 @@ void acpi_dev_remove_driver_gpios(struct acpi_device *adev);
|
|||
int devm_acpi_dev_add_driver_gpios(struct device *dev,
|
||||
const struct acpi_gpio_mapping *gpios);
|
||||
|
||||
struct gpio_desc *acpi_get_and_request_gpiod(char *path, int pin, char *label);
|
||||
struct gpio_desc *acpi_get_and_request_gpiod(char *path, unsigned int pin, char *label);
|
||||
|
||||
#else /* CONFIG_GPIOLIB && CONFIG_ACPI */
|
||||
|
||||
|
|
@ -705,6 +705,12 @@ static inline int devm_acpi_dev_add_driver_gpios(struct device *dev,
|
|||
return -ENXIO;
|
||||
}
|
||||
|
||||
static inline struct gpio_desc *acpi_get_and_request_gpiod(char *path, unsigned int pin,
|
||||
char *label)
|
||||
{
|
||||
return ERR_PTR(-ENOSYS);
|
||||
}
|
||||
|
||||
#endif /* CONFIG_GPIOLIB && CONFIG_ACPI */
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -169,6 +169,7 @@ long hugetlb_unreserve_pages(struct inode *inode, long start, long end,
|
|||
long freed);
|
||||
bool isolate_huge_page(struct page *page, struct list_head *list);
|
||||
int get_hwpoison_huge_page(struct page *page, bool *hugetlb);
|
||||
int get_huge_page_for_hwpoison(unsigned long pfn, int flags);
|
||||
void putback_active_hugepage(struct page *page);
|
||||
void move_hugetlb_state(struct page *oldpage, struct page *newpage, int reason);
|
||||
void free_huge_page(struct page *page);
|
||||
|
|
@ -378,6 +379,11 @@ static inline int get_hwpoison_huge_page(struct page *page, bool *hugetlb)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static inline int get_huge_page_for_hwpoison(unsigned long pfn, int flags)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void putback_active_hugepage(struct page *page)
|
||||
{
|
||||
}
|
||||
|
|
|
|||
|
|
@ -63,15 +63,6 @@
|
|||
} \
|
||||
)
|
||||
|
||||
/**
|
||||
* lower_48_bits() - return bits 0-47 of a number
|
||||
* @n: the number we're accessing
|
||||
*/
|
||||
static inline u64 lower_48_bits(u64 n)
|
||||
{
|
||||
return n & ((1ull << 48) - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* upper_32_bits - return bits 32-63 of a number
|
||||
* @n: the number we're accessing
|
||||
|
|
@ -294,7 +285,7 @@ static inline char *hex_byte_pack_upper(char *buf, u8 byte)
|
|||
return buf;
|
||||
}
|
||||
|
||||
extern int hex_to_bin(char ch);
|
||||
extern int hex_to_bin(unsigned char ch);
|
||||
extern int __must_check hex2bin(u8 *dst, const char *src, size_t count);
|
||||
extern char *bin2hex(char *dst, const void *src, size_t count);
|
||||
|
||||
|
|
|
|||
|
|
@ -204,6 +204,22 @@ static __always_inline __must_check bool kfence_free(void *addr)
|
|||
*/
|
||||
bool __must_check kfence_handle_page_fault(unsigned long addr, bool is_write, struct pt_regs *regs);
|
||||
|
||||
#ifdef CONFIG_PRINTK
|
||||
struct kmem_obj_info;
|
||||
/**
|
||||
* __kfence_obj_info() - fill kmem_obj_info struct
|
||||
* @kpp: kmem_obj_info to be filled
|
||||
* @object: the object
|
||||
*
|
||||
* Return:
|
||||
* * false - not a KFENCE object
|
||||
* * true - a KFENCE object, filled @kpp
|
||||
*
|
||||
* Copies information to @kpp for KFENCE objects.
|
||||
*/
|
||||
bool __kfence_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab);
|
||||
#endif
|
||||
|
||||
#else /* CONFIG_KFENCE */
|
||||
|
||||
static inline bool is_kfence_address(const void *addr) { return false; }
|
||||
|
|
@ -221,6 +237,14 @@ static inline bool __must_check kfence_handle_page_fault(unsigned long addr, boo
|
|||
return false;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PRINTK
|
||||
struct kmem_obj_info;
|
||||
static inline bool __kfence_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* _LINUX_KFENCE_H */
|
||||
|
|
|
|||
|
|
@ -315,7 +315,10 @@ struct kvm_vcpu {
|
|||
int cpu;
|
||||
int vcpu_id; /* id given by userspace at creation */
|
||||
int vcpu_idx; /* index in kvm->vcpus array */
|
||||
int srcu_idx;
|
||||
int ____srcu_idx; /* Don't use this directly. You've been warned. */
|
||||
#ifdef CONFIG_PROVE_RCU
|
||||
int srcu_depth;
|
||||
#endif
|
||||
int mode;
|
||||
u64 requests;
|
||||
unsigned long guest_debug;
|
||||
|
|
@ -840,6 +843,25 @@ static inline void kvm_vm_bugged(struct kvm *kvm)
|
|||
unlikely(__ret); \
|
||||
})
|
||||
|
||||
static inline void kvm_vcpu_srcu_read_lock(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
#ifdef CONFIG_PROVE_RCU
|
||||
WARN_ONCE(vcpu->srcu_depth++,
|
||||
"KVM: Illegal vCPU srcu_idx LOCK, depth=%d", vcpu->srcu_depth - 1);
|
||||
#endif
|
||||
vcpu->____srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
|
||||
}
|
||||
|
||||
static inline void kvm_vcpu_srcu_read_unlock(struct kvm_vcpu *vcpu)
|
||||
{
|
||||
srcu_read_unlock(&vcpu->kvm->srcu, vcpu->____srcu_idx);
|
||||
|
||||
#ifdef CONFIG_PROVE_RCU
|
||||
WARN_ONCE(--vcpu->srcu_depth,
|
||||
"KVM: Illegal vCPU srcu_idx UNLOCK, depth=%d", vcpu->srcu_depth);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline bool kvm_dirty_log_manual_protect_and_init_set(struct kvm *kvm)
|
||||
{
|
||||
return !!(kvm->manual_dirty_log_protect & KVM_DIRTY_LOG_INITIALLY_SET);
|
||||
|
|
@ -2197,6 +2219,8 @@ static inline long kvm_arch_vcpu_async_ioctl(struct file *filp,
|
|||
void kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm,
|
||||
unsigned long start, unsigned long end);
|
||||
|
||||
void kvm_arch_guest_memory_reclaimed(struct kvm *kvm);
|
||||
|
||||
#ifdef CONFIG_HAVE_KVM_VCPU_RUN_PID_CHANGE
|
||||
int kvm_arch_vcpu_run_pid_change(struct kvm_vcpu *vcpu);
|
||||
#else
|
||||
|
|
|
|||
|
|
@ -1012,6 +1012,7 @@ static inline unsigned long lruvec_page_state_local(struct lruvec *lruvec,
|
|||
}
|
||||
|
||||
void mem_cgroup_flush_stats(void);
|
||||
void mem_cgroup_flush_stats_delayed(void);
|
||||
|
||||
void __mod_memcg_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
|
||||
int val);
|
||||
|
|
@ -1455,6 +1456,10 @@ static inline void mem_cgroup_flush_stats(void)
|
|||
{
|
||||
}
|
||||
|
||||
static inline void mem_cgroup_flush_stats_delayed(void)
|
||||
{
|
||||
}
|
||||
|
||||
static inline void __mod_memcg_lruvec_state(struct lruvec *lruvec,
|
||||
enum node_stat_item idx, int val)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -3197,6 +3197,14 @@ extern int sysctl_memory_failure_recovery;
|
|||
extern void shake_page(struct page *p);
|
||||
extern atomic_long_t num_poisoned_pages __read_mostly;
|
||||
extern int soft_offline_page(unsigned long pfn, int flags);
|
||||
#ifdef CONFIG_MEMORY_FAILURE
|
||||
extern int __get_huge_page_for_hwpoison(unsigned long pfn, int flags);
|
||||
#else
|
||||
static inline int __get_huge_page_for_hwpoison(unsigned long pfn, int flags)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef arch_memory_failure
|
||||
static inline int arch_memory_failure(unsigned long pfn, int flags)
|
||||
|
|
|
|||
|
|
@ -389,10 +389,8 @@ struct mtd_info {
|
|||
/* List of partitions attached to this MTD device */
|
||||
struct list_head partitions;
|
||||
|
||||
union {
|
||||
struct mtd_part part;
|
||||
struct mtd_master master;
|
||||
};
|
||||
struct mtd_part part;
|
||||
struct mtd_master master;
|
||||
};
|
||||
|
||||
static inline struct mtd_info *mtd_get_master(struct mtd_info *mtd)
|
||||
|
|
|
|||
|
|
@ -199,10 +199,10 @@ struct net_device_stats {
|
|||
* Try to fit them in a single cache line, for dev_get_stats() sake.
|
||||
*/
|
||||
struct net_device_core_stats {
|
||||
local_t rx_dropped;
|
||||
local_t tx_dropped;
|
||||
local_t rx_nohandler;
|
||||
} __aligned(4 * sizeof(local_t));
|
||||
unsigned long rx_dropped;
|
||||
unsigned long tx_dropped;
|
||||
unsigned long rx_nohandler;
|
||||
} __aligned(4 * sizeof(unsigned long));
|
||||
|
||||
#include <linux/cache.h>
|
||||
#include <linux/skbuff.h>
|
||||
|
|
@ -3843,15 +3843,15 @@ static __always_inline bool __is_skb_forwardable(const struct net_device *dev,
|
|||
return false;
|
||||
}
|
||||
|
||||
struct net_device_core_stats *netdev_core_stats_alloc(struct net_device *dev);
|
||||
struct net_device_core_stats __percpu *netdev_core_stats_alloc(struct net_device *dev);
|
||||
|
||||
static inline struct net_device_core_stats *dev_core_stats(struct net_device *dev)
|
||||
static inline struct net_device_core_stats __percpu *dev_core_stats(struct net_device *dev)
|
||||
{
|
||||
/* This READ_ONCE() pairs with the write in netdev_core_stats_alloc() */
|
||||
struct net_device_core_stats __percpu *p = READ_ONCE(dev->core_stats);
|
||||
|
||||
if (likely(p))
|
||||
return this_cpu_ptr(p);
|
||||
return p;
|
||||
|
||||
return netdev_core_stats_alloc(dev);
|
||||
}
|
||||
|
|
@ -3859,14 +3859,11 @@ static inline struct net_device_core_stats *dev_core_stats(struct net_device *de
|
|||
#define DEV_CORE_STATS_INC(FIELD) \
|
||||
static inline void dev_core_stats_##FIELD##_inc(struct net_device *dev) \
|
||||
{ \
|
||||
struct net_device_core_stats *p; \
|
||||
struct net_device_core_stats __percpu *p; \
|
||||
\
|
||||
preempt_disable(); \
|
||||
p = dev_core_stats(dev); \
|
||||
\
|
||||
if (p) \
|
||||
local_inc(&p->FIELD); \
|
||||
preempt_enable(); \
|
||||
this_cpu_inc(p->FIELD); \
|
||||
}
|
||||
DEV_CORE_STATS_INC(rx_dropped)
|
||||
DEV_CORE_STATS_INC(tx_dropped)
|
||||
|
|
|
|||
|
|
@ -34,15 +34,19 @@ posix_acl_xattr_count(size_t size)
|
|||
|
||||
#ifdef CONFIG_FS_POSIX_ACL
|
||||
void posix_acl_fix_xattr_from_user(struct user_namespace *mnt_userns,
|
||||
struct inode *inode,
|
||||
void *value, size_t size);
|
||||
void posix_acl_fix_xattr_to_user(struct user_namespace *mnt_userns,
|
||||
struct inode *inode,
|
||||
void *value, size_t size);
|
||||
#else
|
||||
static inline void posix_acl_fix_xattr_from_user(struct user_namespace *mnt_userns,
|
||||
struct inode *inode,
|
||||
void *value, size_t size)
|
||||
{
|
||||
}
|
||||
static inline void posix_acl_fix_xattr_to_user(struct user_namespace *mnt_userns,
|
||||
struct inode *inode,
|
||||
void *value, size_t size)
|
||||
{
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1443,6 +1443,7 @@ struct task_struct {
|
|||
int pagefault_disabled;
|
||||
#ifdef CONFIG_MMU
|
||||
struct task_struct *oom_reaper_list;
|
||||
struct timer_list oom_reaper_timer;
|
||||
#endif
|
||||
#ifdef CONFIG_VMAP_STACK
|
||||
struct vm_struct *stack_vm_area;
|
||||
|
|
|
|||
|
|
@ -136,6 +136,14 @@ static inline void mm_update_next_owner(struct mm_struct *mm)
|
|||
#endif /* CONFIG_MEMCG */
|
||||
|
||||
#ifdef CONFIG_MMU
|
||||
#ifndef arch_get_mmap_end
|
||||
#define arch_get_mmap_end(addr) (TASK_SIZE)
|
||||
#endif
|
||||
|
||||
#ifndef arch_get_mmap_base
|
||||
#define arch_get_mmap_base(addr, base) (base)
|
||||
#endif
|
||||
|
||||
extern void arch_pick_mmap_layout(struct mm_struct *mm,
|
||||
struct rlimit *rlim_stack);
|
||||
extern unsigned long
|
||||
|
|
|
|||
|
|
@ -395,6 +395,7 @@ struct svc_deferred_req {
|
|||
size_t addrlen;
|
||||
struct sockaddr_storage daddr; /* where reply must come from */
|
||||
size_t daddrlen;
|
||||
void *xprt_ctxt;
|
||||
struct cache_deferred_req handle;
|
||||
size_t xprt_hlen;
|
||||
int argslen;
|
||||
|
|
|
|||
|
|
@ -59,6 +59,15 @@ struct crc64_pi_tuple {
|
|||
__u8 ref_tag[6];
|
||||
};
|
||||
|
||||
/**
|
||||
* lower_48_bits() - return bits 0-47 of a number
|
||||
* @n: the number we're accessing
|
||||
*/
|
||||
static inline u64 lower_48_bits(u64 n)
|
||||
{
|
||||
return n & ((1ull << 48) - 1);
|
||||
}
|
||||
|
||||
static inline u64 ext_pi_ref_tag(struct request *rq)
|
||||
{
|
||||
unsigned int shift = ilog2(queue_logical_block_size(rq->q));
|
||||
|
|
|
|||
|
|
@ -75,7 +75,7 @@
|
|||
* By default we use get_cycles() for this purpose, but individual
|
||||
* architectures may override this in their asm/timex.h header file.
|
||||
*/
|
||||
#define random_get_entropy() get_cycles()
|
||||
#define random_get_entropy() ((unsigned long)get_cycles())
|
||||
#endif
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
#define BDO_MODE_CARRIER2 (5 << 28)
|
||||
#define BDO_MODE_CARRIER3 (6 << 28)
|
||||
#define BDO_MODE_EYE (7 << 28)
|
||||
#define BDO_MODE_TESTDATA (8 << 28)
|
||||
#define BDO_MODE_TESTDATA (8U << 28)
|
||||
|
||||
#define BDO_MODE_MASK(mode) ((mode) & 0xf0000000)
|
||||
|
||||
|
|
|
|||
|
|
@ -133,6 +133,8 @@ struct vfio_pci_core_device {
|
|||
struct mutex ioeventfds_lock;
|
||||
struct list_head ioeventfds_list;
|
||||
struct vfio_pci_vf_token *vf_token;
|
||||
struct list_head sriov_pfs_item;
|
||||
struct vfio_pci_core_device *sriov_pf_core_dev;
|
||||
struct notifier_block nb;
|
||||
struct mutex vma_lock;
|
||||
struct list_head vma_list;
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ struct notifier_block; /* in notifier.h */
|
|||
#define VM_KASAN 0x00000080 /* has allocated kasan shadow memory */
|
||||
#define VM_FLUSH_RESET_PERMS 0x00000100 /* reset direct map and flush TLB on unmap, can't be freed in atomic context */
|
||||
#define VM_MAP_PUT_PAGES 0x00000200 /* put pages and free array in vfree */
|
||||
#define VM_NO_HUGE_VMAP 0x00000400 /* force PAGE_SIZE pte mapping */
|
||||
#define VM_ALLOW_HUGE_VMAP 0x00000400 /* Allow for huge pages on archs with HAVE_ARCH_HUGE_VMALLOC */
|
||||
|
||||
#if (defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS)) && \
|
||||
!defined(CONFIG_KASAN_VMALLOC)
|
||||
|
|
@ -153,7 +153,7 @@ extern void *__vmalloc_node_range(unsigned long size, unsigned long align,
|
|||
const void *caller) __alloc_size(1);
|
||||
void *__vmalloc_node(unsigned long size, unsigned long align, gfp_t gfp_mask,
|
||||
int node, const void *caller) __alloc_size(1);
|
||||
void *vmalloc_no_huge(unsigned long size) __alloc_size(1);
|
||||
void *vmalloc_huge(unsigned long size, gfp_t gfp_mask) __alloc_size(1);
|
||||
|
||||
extern void *__vmalloc_array(size_t n, size_t size, gfp_t flags) __alloc_size(1, 2);
|
||||
extern void *vmalloc_array(size_t n, size_t size) __alloc_size(1, 2);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue