mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-23 21:19:04 -04:00
Merge branch 'akpm' (patches from Andrew)
Merge third patch-bomb from Andrew Morton:
"I'm pretty much done for -rc1 now:
- the rest of MM, basically
- lib/ updates
- checkpatch, epoll, hfs, fatfs, ptrace, coredump, exit
- cpu_mask simplifications
- kexec, rapidio, MAINTAINERS etc, etc.
- more dma-mapping cleanups/simplifications from hch"
* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (109 commits)
MAINTAINERS: add/fix git URLs for various subsystems
mm: memcontrol: add "sock" to cgroup2 memory.stat
mm: memcontrol: basic memory statistics in cgroup2 memory controller
mm: memcontrol: do not uncharge old page in page cache replacement
Documentation: cgroup: add memory.swap.{current,max} description
mm: free swap cache aggressively if memcg swap is full
mm: vmscan: do not scan anon pages if memcg swap limit is hit
swap.h: move memcg related stuff to the end of the file
mm: memcontrol: replace mem_cgroup_lruvec_online with mem_cgroup_online
mm: vmscan: pass memcg to get_scan_count()
mm: memcontrol: charge swap to cgroup2
mm: memcontrol: clean up alloc, online, offline, free functions
mm: memcontrol: flatten struct cg_proto
mm: memcontrol: rein in the CONFIG space madness
net: drop tcp_memcontrol.c
mm: memcontrol: introduce CONFIG_MEMCG_LEGACY_KMEM
mm: memcontrol: allow to disable kmem accounting for cgroup2
mm: memcontrol: account "kmem" consumers in cgroup2 memory controller
mm: memcontrol: move kmem accounting code to CONFIG_MEMCG
mm: memcontrol: separate kmem code from legacy tcp accounting code
...
This commit is contained in:
Linus Torvalds
commit
eae21770b4
203 changed files with 3642 additions and 3991 deletions
|
|
@ -85,10 +85,14 @@ extern int nr_cpu_ids;
|
|||
* only one CPU.
|
||||
*/
|
||||
|
||||
extern const struct cpumask *const cpu_possible_mask;
|
||||
extern const struct cpumask *const cpu_online_mask;
|
||||
extern const struct cpumask *const cpu_present_mask;
|
||||
extern const struct cpumask *const cpu_active_mask;
|
||||
extern struct cpumask __cpu_possible_mask;
|
||||
extern struct cpumask __cpu_online_mask;
|
||||
extern struct cpumask __cpu_present_mask;
|
||||
extern struct cpumask __cpu_active_mask;
|
||||
#define cpu_possible_mask ((const struct cpumask *)&__cpu_possible_mask)
|
||||
#define cpu_online_mask ((const struct cpumask *)&__cpu_online_mask)
|
||||
#define cpu_present_mask ((const struct cpumask *)&__cpu_present_mask)
|
||||
#define cpu_active_mask ((const struct cpumask *)&__cpu_active_mask)
|
||||
|
||||
#if NR_CPUS > 1
|
||||
#define num_online_cpus() cpumask_weight(cpu_online_mask)
|
||||
|
|
@ -716,14 +720,49 @@ extern const DECLARE_BITMAP(cpu_all_bits, NR_CPUS);
|
|||
#define for_each_present_cpu(cpu) for_each_cpu((cpu), cpu_present_mask)
|
||||
|
||||
/* Wrappers for arch boot code to manipulate normally-constant masks */
|
||||
void set_cpu_possible(unsigned int cpu, bool possible);
|
||||
void set_cpu_present(unsigned int cpu, bool present);
|
||||
void set_cpu_online(unsigned int cpu, bool online);
|
||||
void set_cpu_active(unsigned int cpu, bool active);
|
||||
void init_cpu_present(const struct cpumask *src);
|
||||
void init_cpu_possible(const struct cpumask *src);
|
||||
void init_cpu_online(const struct cpumask *src);
|
||||
|
||||
static inline void
|
||||
set_cpu_possible(unsigned int cpu, bool possible)
|
||||
{
|
||||
if (possible)
|
||||
cpumask_set_cpu(cpu, &__cpu_possible_mask);
|
||||
else
|
||||
cpumask_clear_cpu(cpu, &__cpu_possible_mask);
|
||||
}
|
||||
|
||||
static inline void
|
||||
set_cpu_present(unsigned int cpu, bool present)
|
||||
{
|
||||
if (present)
|
||||
cpumask_set_cpu(cpu, &__cpu_present_mask);
|
||||
else
|
||||
cpumask_clear_cpu(cpu, &__cpu_present_mask);
|
||||
}
|
||||
|
||||
static inline void
|
||||
set_cpu_online(unsigned int cpu, bool online)
|
||||
{
|
||||
if (online) {
|
||||
cpumask_set_cpu(cpu, &__cpu_online_mask);
|
||||
cpumask_set_cpu(cpu, &__cpu_active_mask);
|
||||
} else {
|
||||
cpumask_clear_cpu(cpu, &__cpu_online_mask);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void
|
||||
set_cpu_active(unsigned int cpu, bool active)
|
||||
{
|
||||
if (active)
|
||||
cpumask_set_cpu(cpu, &__cpu_active_mask);
|
||||
else
|
||||
cpumask_clear_cpu(cpu, &__cpu_active_mask);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* to_cpumask - convert an NR_CPUS bitmap to a struct cpumask *
|
||||
* @bitmap: the bitmap
|
||||
|
|
|
|||
|
|
@ -41,7 +41,6 @@ static inline void init_dma_attrs(struct dma_attrs *attrs)
|
|||
bitmap_zero(attrs->flags, __DMA_ATTRS_LONGS);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_HAVE_DMA_ATTRS
|
||||
/**
|
||||
* dma_set_attr - set a specific attribute
|
||||
* @attr: attribute to set
|
||||
|
|
@ -67,14 +66,5 @@ static inline int dma_get_attr(enum dma_attr attr, struct dma_attrs *attrs)
|
|||
BUG_ON(attr >= DMA_ATTR_MAX);
|
||||
return test_bit(attr, attrs->flags);
|
||||
}
|
||||
#else /* !CONFIG_HAVE_DMA_ATTRS */
|
||||
static inline void dma_set_attr(enum dma_attr attr, struct dma_attrs *attrs)
|
||||
{
|
||||
}
|
||||
|
||||
static inline int dma_get_attr(enum dma_attr attr, struct dma_attrs *attrs)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif /* CONFIG_HAVE_DMA_ATTRS */
|
||||
#endif /* _DMA_ATTR_H */
|
||||
|
|
|
|||
|
|
@ -6,8 +6,11 @@
|
|||
#include <linux/device.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/dma-attrs.h>
|
||||
#include <linux/dma-debug.h>
|
||||
#include <linux/dma-direction.h>
|
||||
#include <linux/scatterlist.h>
|
||||
#include <linux/kmemcheck.h>
|
||||
#include <linux/bug.h>
|
||||
|
||||
/*
|
||||
* A dma_addr_t can hold any valid DMA or bus address for the platform.
|
||||
|
|
@ -83,10 +86,383 @@ static inline int is_device_dma_capable(struct device *dev)
|
|||
return dev->dma_mask != NULL && *dev->dma_mask != DMA_MASK_NONE;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_HAVE_GENERIC_DMA_COHERENT
|
||||
/*
|
||||
* These three functions are only for dma allocator.
|
||||
* Don't use them in device drivers.
|
||||
*/
|
||||
int dma_alloc_from_coherent(struct device *dev, ssize_t size,
|
||||
dma_addr_t *dma_handle, void **ret);
|
||||
int dma_release_from_coherent(struct device *dev, int order, void *vaddr);
|
||||
|
||||
int dma_mmap_from_coherent(struct device *dev, struct vm_area_struct *vma,
|
||||
void *cpu_addr, size_t size, int *ret);
|
||||
#else
|
||||
#define dma_alloc_from_coherent(dev, size, handle, ret) (0)
|
||||
#define dma_release_from_coherent(dev, order, vaddr) (0)
|
||||
#define dma_mmap_from_coherent(dev, vma, vaddr, order, ret) (0)
|
||||
#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
|
||||
|
||||
#ifdef CONFIG_HAS_DMA
|
||||
#include <asm/dma-mapping.h>
|
||||
#else
|
||||
#include <asm-generic/dma-mapping-broken.h>
|
||||
/*
|
||||
* Define the dma api to allow compilation but not linking of
|
||||
* dma dependent code. Code that depends on the dma-mapping
|
||||
* API needs to set 'depends on HAS_DMA' in its Kconfig
|
||||
*/
|
||||
extern struct dma_map_ops bad_dma_ops;
|
||||
static inline struct dma_map_ops *get_dma_ops(struct device *dev)
|
||||
{
|
||||
return &bad_dma_ops;
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
|
||||
size_t size,
|
||||
enum dma_data_direction dir,
|
||||
struct dma_attrs *attrs)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
dma_addr_t addr;
|
||||
|
||||
kmemcheck_mark_initialized(ptr, size);
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
addr = ops->map_page(dev, virt_to_page(ptr),
|
||||
offset_in_page(ptr), size,
|
||||
dir, attrs);
|
||||
debug_dma_map_page(dev, virt_to_page(ptr),
|
||||
offset_in_page(ptr), size,
|
||||
dir, addr, true);
|
||||
return addr;
|
||||
}
|
||||
|
||||
static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
|
||||
size_t size,
|
||||
enum dma_data_direction dir,
|
||||
struct dma_attrs *attrs)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
if (ops->unmap_page)
|
||||
ops->unmap_page(dev, addr, size, dir, attrs);
|
||||
debug_dma_unmap_page(dev, addr, size, dir, true);
|
||||
}
|
||||
|
||||
/*
|
||||
* dma_maps_sg_attrs returns 0 on error and > 0 on success.
|
||||
* It should never return a value < 0.
|
||||
*/
|
||||
static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
|
||||
int nents, enum dma_data_direction dir,
|
||||
struct dma_attrs *attrs)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
int i, ents;
|
||||
struct scatterlist *s;
|
||||
|
||||
for_each_sg(sg, s, nents, i)
|
||||
kmemcheck_mark_initialized(sg_virt(s), s->length);
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
ents = ops->map_sg(dev, sg, nents, dir, attrs);
|
||||
BUG_ON(ents < 0);
|
||||
debug_dma_map_sg(dev, sg, nents, ents, dir);
|
||||
|
||||
return ents;
|
||||
}
|
||||
|
||||
static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg,
|
||||
int nents, enum dma_data_direction dir,
|
||||
struct dma_attrs *attrs)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
debug_dma_unmap_sg(dev, sg, nents, dir);
|
||||
if (ops->unmap_sg)
|
||||
ops->unmap_sg(dev, sg, nents, dir, attrs);
|
||||
}
|
||||
|
||||
static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
|
||||
size_t offset, size_t size,
|
||||
enum dma_data_direction dir)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
dma_addr_t addr;
|
||||
|
||||
kmemcheck_mark_initialized(page_address(page) + offset, size);
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
addr = ops->map_page(dev, page, offset, size, dir, NULL);
|
||||
debug_dma_map_page(dev, page, offset, size, dir, addr, false);
|
||||
|
||||
return addr;
|
||||
}
|
||||
|
||||
static inline void dma_unmap_page(struct device *dev, dma_addr_t addr,
|
||||
size_t size, enum dma_data_direction dir)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
if (ops->unmap_page)
|
||||
ops->unmap_page(dev, addr, size, dir, NULL);
|
||||
debug_dma_unmap_page(dev, addr, size, dir, false);
|
||||
}
|
||||
|
||||
static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
|
||||
size_t size,
|
||||
enum dma_data_direction dir)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
if (ops->sync_single_for_cpu)
|
||||
ops->sync_single_for_cpu(dev, addr, size, dir);
|
||||
debug_dma_sync_single_for_cpu(dev, addr, size, dir);
|
||||
}
|
||||
|
||||
static inline void dma_sync_single_for_device(struct device *dev,
|
||||
dma_addr_t addr, size_t size,
|
||||
enum dma_data_direction dir)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
if (ops->sync_single_for_device)
|
||||
ops->sync_single_for_device(dev, addr, size, dir);
|
||||
debug_dma_sync_single_for_device(dev, addr, size, dir);
|
||||
}
|
||||
|
||||
static inline void dma_sync_single_range_for_cpu(struct device *dev,
|
||||
dma_addr_t addr,
|
||||
unsigned long offset,
|
||||
size_t size,
|
||||
enum dma_data_direction dir)
|
||||
{
|
||||
const struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
if (ops->sync_single_for_cpu)
|
||||
ops->sync_single_for_cpu(dev, addr + offset, size, dir);
|
||||
debug_dma_sync_single_range_for_cpu(dev, addr, offset, size, dir);
|
||||
}
|
||||
|
||||
static inline void dma_sync_single_range_for_device(struct device *dev,
|
||||
dma_addr_t addr,
|
||||
unsigned long offset,
|
||||
size_t size,
|
||||
enum dma_data_direction dir)
|
||||
{
|
||||
const struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
if (ops->sync_single_for_device)
|
||||
ops->sync_single_for_device(dev, addr + offset, size, dir);
|
||||
debug_dma_sync_single_range_for_device(dev, addr, offset, size, dir);
|
||||
}
|
||||
|
||||
static inline void
|
||||
dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
|
||||
int nelems, enum dma_data_direction dir)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
if (ops->sync_sg_for_cpu)
|
||||
ops->sync_sg_for_cpu(dev, sg, nelems, dir);
|
||||
debug_dma_sync_sg_for_cpu(dev, sg, nelems, dir);
|
||||
}
|
||||
|
||||
static inline void
|
||||
dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
|
||||
int nelems, enum dma_data_direction dir)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
BUG_ON(!valid_dma_direction(dir));
|
||||
if (ops->sync_sg_for_device)
|
||||
ops->sync_sg_for_device(dev, sg, nelems, dir);
|
||||
debug_dma_sync_sg_for_device(dev, sg, nelems, dir);
|
||||
|
||||
}
|
||||
|
||||
#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL)
|
||||
#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, NULL)
|
||||
#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, NULL)
|
||||
#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, NULL)
|
||||
|
||||
extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
|
||||
void *cpu_addr, dma_addr_t dma_addr, size_t size);
|
||||
|
||||
void *dma_common_contiguous_remap(struct page *page, size_t size,
|
||||
unsigned long vm_flags,
|
||||
pgprot_t prot, const void *caller);
|
||||
|
||||
void *dma_common_pages_remap(struct page **pages, size_t size,
|
||||
unsigned long vm_flags, pgprot_t prot,
|
||||
const void *caller);
|
||||
void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags);
|
||||
|
||||
/**
|
||||
* dma_mmap_attrs - map a coherent DMA allocation into user space
|
||||
* @dev: valid struct device pointer, or NULL for ISA and EISA-like devices
|
||||
* @vma: vm_area_struct describing requested user mapping
|
||||
* @cpu_addr: kernel CPU-view address returned from dma_alloc_attrs
|
||||
* @handle: device-view address returned from dma_alloc_attrs
|
||||
* @size: size of memory originally requested in dma_alloc_attrs
|
||||
* @attrs: attributes of mapping properties requested in dma_alloc_attrs
|
||||
*
|
||||
* Map a coherent DMA buffer previously allocated by dma_alloc_attrs
|
||||
* into user space. The coherent DMA buffer must not be freed by the
|
||||
* driver until the user space mapping has been released.
|
||||
*/
|
||||
static inline int
|
||||
dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, void *cpu_addr,
|
||||
dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
BUG_ON(!ops);
|
||||
if (ops->mmap)
|
||||
return ops->mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
|
||||
return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size);
|
||||
}
|
||||
|
||||
#define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, NULL)
|
||||
|
||||
int
|
||||
dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
|
||||
void *cpu_addr, dma_addr_t dma_addr, size_t size);
|
||||
|
||||
static inline int
|
||||
dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr,
|
||||
dma_addr_t dma_addr, size_t size, struct dma_attrs *attrs)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
BUG_ON(!ops);
|
||||
if (ops->get_sgtable)
|
||||
return ops->get_sgtable(dev, sgt, cpu_addr, dma_addr, size,
|
||||
attrs);
|
||||
return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size);
|
||||
}
|
||||
|
||||
#define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, NULL)
|
||||
|
||||
#ifndef arch_dma_alloc_attrs
|
||||
#define arch_dma_alloc_attrs(dev, flag) (true)
|
||||
#endif
|
||||
|
||||
static inline void *dma_alloc_attrs(struct device *dev, size_t size,
|
||||
dma_addr_t *dma_handle, gfp_t flag,
|
||||
struct dma_attrs *attrs)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
void *cpu_addr;
|
||||
|
||||
BUG_ON(!ops);
|
||||
|
||||
if (dma_alloc_from_coherent(dev, size, dma_handle, &cpu_addr))
|
||||
return cpu_addr;
|
||||
|
||||
if (!arch_dma_alloc_attrs(&dev, &flag))
|
||||
return NULL;
|
||||
if (!ops->alloc)
|
||||
return NULL;
|
||||
|
||||
cpu_addr = ops->alloc(dev, size, dma_handle, flag, attrs);
|
||||
debug_dma_alloc_coherent(dev, size, *dma_handle, cpu_addr);
|
||||
return cpu_addr;
|
||||
}
|
||||
|
||||
static inline void dma_free_attrs(struct device *dev, size_t size,
|
||||
void *cpu_addr, dma_addr_t dma_handle,
|
||||
struct dma_attrs *attrs)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
BUG_ON(!ops);
|
||||
WARN_ON(irqs_disabled());
|
||||
|
||||
if (dma_release_from_coherent(dev, get_order(size), cpu_addr))
|
||||
return;
|
||||
|
||||
if (!ops->free)
|
||||
return;
|
||||
|
||||
debug_dma_free_coherent(dev, size, cpu_addr, dma_handle);
|
||||
ops->free(dev, size, cpu_addr, dma_handle, attrs);
|
||||
}
|
||||
|
||||
static inline void *dma_alloc_coherent(struct device *dev, size_t size,
|
||||
dma_addr_t *dma_handle, gfp_t flag)
|
||||
{
|
||||
return dma_alloc_attrs(dev, size, dma_handle, flag, NULL);
|
||||
}
|
||||
|
||||
static inline void dma_free_coherent(struct device *dev, size_t size,
|
||||
void *cpu_addr, dma_addr_t dma_handle)
|
||||
{
|
||||
return dma_free_attrs(dev, size, cpu_addr, dma_handle, NULL);
|
||||
}
|
||||
|
||||
static inline void *dma_alloc_noncoherent(struct device *dev, size_t size,
|
||||
dma_addr_t *dma_handle, gfp_t gfp)
|
||||
{
|
||||
DEFINE_DMA_ATTRS(attrs);
|
||||
|
||||
dma_set_attr(DMA_ATTR_NON_CONSISTENT, &attrs);
|
||||
return dma_alloc_attrs(dev, size, dma_handle, gfp, &attrs);
|
||||
}
|
||||
|
||||
static inline void dma_free_noncoherent(struct device *dev, size_t size,
|
||||
void *cpu_addr, dma_addr_t dma_handle)
|
||||
{
|
||||
DEFINE_DMA_ATTRS(attrs);
|
||||
|
||||
dma_set_attr(DMA_ATTR_NON_CONSISTENT, &attrs);
|
||||
dma_free_attrs(dev, size, cpu_addr, dma_handle, &attrs);
|
||||
}
|
||||
|
||||
static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
|
||||
{
|
||||
debug_dma_mapping_error(dev, dma_addr);
|
||||
|
||||
if (get_dma_ops(dev)->mapping_error)
|
||||
return get_dma_ops(dev)->mapping_error(dev, dma_addr);
|
||||
|
||||
#ifdef DMA_ERROR_CODE
|
||||
return dma_addr == DMA_ERROR_CODE;
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifndef HAVE_ARCH_DMA_SUPPORTED
|
||||
static inline int dma_supported(struct device *dev, u64 mask)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
if (!ops)
|
||||
return 0;
|
||||
if (!ops->dma_supported)
|
||||
return 1;
|
||||
return ops->dma_supported(dev, mask);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_ARCH_DMA_SET_MASK
|
||||
static inline int dma_set_mask(struct device *dev, u64 mask)
|
||||
{
|
||||
struct dma_map_ops *ops = get_dma_ops(dev);
|
||||
|
||||
if (ops->set_dma_mask)
|
||||
return ops->set_dma_mask(dev, mask);
|
||||
|
||||
if (!dev->dma_mask || !dma_supported(dev, mask))
|
||||
return -EIO;
|
||||
*dev->dma_mask = mask;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline u64 dma_get_mask(struct device *dev)
|
||||
|
|
@ -208,7 +584,13 @@ static inline int dma_get_cache_alignment(void)
|
|||
#define DMA_MEMORY_INCLUDES_CHILDREN 0x04
|
||||
#define DMA_MEMORY_EXCLUSIVE 0x08
|
||||
|
||||
#ifndef ARCH_HAS_DMA_DECLARE_COHERENT_MEMORY
|
||||
#ifdef CONFIG_HAVE_GENERIC_DMA_COHERENT
|
||||
int dma_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr,
|
||||
dma_addr_t device_addr, size_t size, int flags);
|
||||
void dma_release_declared_memory(struct device *dev);
|
||||
void *dma_mark_declared_memory_occupied(struct device *dev,
|
||||
dma_addr_t device_addr, size_t size);
|
||||
#else
|
||||
static inline int
|
||||
dma_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr,
|
||||
dma_addr_t device_addr, size_t size, int flags)
|
||||
|
|
@ -227,7 +609,7 @@ dma_mark_declared_memory_occupied(struct device *dev,
|
|||
{
|
||||
return ERR_PTR(-EBUSY);
|
||||
}
|
||||
#endif
|
||||
#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
|
||||
|
||||
/*
|
||||
* Managed DMA API
|
||||
|
|
@ -240,13 +622,13 @@ extern void *dmam_alloc_noncoherent(struct device *dev, size_t size,
|
|||
dma_addr_t *dma_handle, gfp_t gfp);
|
||||
extern void dmam_free_noncoherent(struct device *dev, size_t size, void *vaddr,
|
||||
dma_addr_t dma_handle);
|
||||
#ifdef ARCH_HAS_DMA_DECLARE_COHERENT_MEMORY
|
||||
#ifdef CONFIG_HAVE_GENERIC_DMA_COHERENT
|
||||
extern int dmam_declare_coherent_memory(struct device *dev,
|
||||
phys_addr_t phys_addr,
|
||||
dma_addr_t device_addr, size_t size,
|
||||
int flags);
|
||||
extern void dmam_release_declared_memory(struct device *dev);
|
||||
#else /* ARCH_HAS_DMA_DECLARE_COHERENT_MEMORY */
|
||||
#else /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
|
||||
static inline int dmam_declare_coherent_memory(struct device *dev,
|
||||
phys_addr_t phys_addr, dma_addr_t device_addr,
|
||||
size_t size, gfp_t gfp)
|
||||
|
|
@ -257,24 +639,8 @@ static inline int dmam_declare_coherent_memory(struct device *dev,
|
|||
static inline void dmam_release_declared_memory(struct device *dev)
|
||||
{
|
||||
}
|
||||
#endif /* ARCH_HAS_DMA_DECLARE_COHERENT_MEMORY */
|
||||
#endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
|
||||
|
||||
#ifndef CONFIG_HAVE_DMA_ATTRS
|
||||
struct dma_attrs;
|
||||
|
||||
#define dma_map_single_attrs(dev, cpu_addr, size, dir, attrs) \
|
||||
dma_map_single(dev, cpu_addr, size, dir)
|
||||
|
||||
#define dma_unmap_single_attrs(dev, dma_addr, size, dir, attrs) \
|
||||
dma_unmap_single(dev, dma_addr, size, dir)
|
||||
|
||||
#define dma_map_sg_attrs(dev, sgl, nents, dir, attrs) \
|
||||
dma_map_sg(dev, sgl, nents, dir)
|
||||
|
||||
#define dma_unmap_sg_attrs(dev, sgl, nents, dir, attrs) \
|
||||
dma_unmap_sg(dev, sgl, nents, dir)
|
||||
|
||||
#else
|
||||
static inline void *dma_alloc_writecombine(struct device *dev, size_t size,
|
||||
dma_addr_t *dma_addr, gfp_t gfp)
|
||||
{
|
||||
|
|
@ -300,7 +666,6 @@ static inline int dma_mmap_writecombine(struct device *dev,
|
|||
dma_set_attr(DMA_ATTR_WRITE_COMBINE, &attrs);
|
||||
return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size, &attrs);
|
||||
}
|
||||
#endif /* CONFIG_HAVE_DMA_ATTRS */
|
||||
|
||||
#ifdef CONFIG_NEED_DMA_MAP_STATE
|
||||
#define DEFINE_DMA_UNMAP_ADDR(ADDR_NAME) dma_addr_t ADDR_NAME
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@ struct device;
|
|||
struct resource;
|
||||
|
||||
__visible void __iowrite32_copy(void __iomem *to, const void *from, size_t count);
|
||||
void __ioread32_copy(void *to, const void __iomem *from, size_t count);
|
||||
void __iowrite64_copy(void __iomem *to, const void *from, size_t count);
|
||||
|
||||
#ifdef CONFIG_MMU
|
||||
|
|
|
|||
|
|
@ -109,11 +109,7 @@ struct compat_kexec_segment {
|
|||
};
|
||||
#endif
|
||||
|
||||
struct kexec_sha_region {
|
||||
unsigned long start;
|
||||
unsigned long len;
|
||||
};
|
||||
|
||||
#ifdef CONFIG_KEXEC_FILE
|
||||
struct purgatory_info {
|
||||
/* Pointer to elf header of read only purgatory */
|
||||
Elf_Ehdr *ehdr;
|
||||
|
|
@ -130,6 +126,28 @@ struct purgatory_info {
|
|||
unsigned long purgatory_load_addr;
|
||||
};
|
||||
|
||||
typedef int (kexec_probe_t)(const char *kernel_buf, unsigned long kernel_size);
|
||||
typedef void *(kexec_load_t)(struct kimage *image, char *kernel_buf,
|
||||
unsigned long kernel_len, char *initrd,
|
||||
unsigned long initrd_len, char *cmdline,
|
||||
unsigned long cmdline_len);
|
||||
typedef int (kexec_cleanup_t)(void *loader_data);
|
||||
|
||||
#ifdef CONFIG_KEXEC_VERIFY_SIG
|
||||
typedef int (kexec_verify_sig_t)(const char *kernel_buf,
|
||||
unsigned long kernel_len);
|
||||
#endif
|
||||
|
||||
struct kexec_file_ops {
|
||||
kexec_probe_t *probe;
|
||||
kexec_load_t *load;
|
||||
kexec_cleanup_t *cleanup;
|
||||
#ifdef CONFIG_KEXEC_VERIFY_SIG
|
||||
kexec_verify_sig_t *verify_sig;
|
||||
#endif
|
||||
};
|
||||
#endif
|
||||
|
||||
struct kimage {
|
||||
kimage_entry_t head;
|
||||
kimage_entry_t *entry;
|
||||
|
|
@ -161,6 +179,7 @@ struct kimage {
|
|||
struct kimage_arch arch;
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_KEXEC_FILE
|
||||
/* Additional fields for file based kexec syscall */
|
||||
void *kernel_buf;
|
||||
unsigned long kernel_buf_len;
|
||||
|
|
@ -179,38 +198,7 @@ struct kimage {
|
|||
|
||||
/* Information for loading purgatory */
|
||||
struct purgatory_info purgatory_info;
|
||||
};
|
||||
|
||||
/*
|
||||
* Keeps track of buffer parameters as provided by caller for requesting
|
||||
* memory placement of buffer.
|
||||
*/
|
||||
struct kexec_buf {
|
||||
struct kimage *image;
|
||||
char *buffer;
|
||||
unsigned long bufsz;
|
||||
unsigned long mem;
|
||||
unsigned long memsz;
|
||||
unsigned long buf_align;
|
||||
unsigned long buf_min;
|
||||
unsigned long buf_max;
|
||||
bool top_down; /* allocate from top of memory hole */
|
||||
};
|
||||
|
||||
typedef int (kexec_probe_t)(const char *kernel_buf, unsigned long kernel_size);
|
||||
typedef void *(kexec_load_t)(struct kimage *image, char *kernel_buf,
|
||||
unsigned long kernel_len, char *initrd,
|
||||
unsigned long initrd_len, char *cmdline,
|
||||
unsigned long cmdline_len);
|
||||
typedef int (kexec_cleanup_t)(void *loader_data);
|
||||
typedef int (kexec_verify_sig_t)(const char *kernel_buf,
|
||||
unsigned long kernel_len);
|
||||
|
||||
struct kexec_file_ops {
|
||||
kexec_probe_t *probe;
|
||||
kexec_load_t *load;
|
||||
kexec_cleanup_t *cleanup;
|
||||
kexec_verify_sig_t *verify_sig;
|
||||
#endif
|
||||
};
|
||||
|
||||
/* kexec interface functions */
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ struct list_lru_node {
|
|||
spinlock_t lock;
|
||||
/* global list, used for the root cgroup in cgroup aware lrus */
|
||||
struct list_lru_one lru;
|
||||
#ifdef CONFIG_MEMCG_KMEM
|
||||
#if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
|
||||
/* for cgroup aware lrus points to per cgroup lists, otherwise NULL */
|
||||
struct list_lru_memcg *memcg_lrus;
|
||||
#endif
|
||||
|
|
@ -48,7 +48,7 @@ struct list_lru_node {
|
|||
|
||||
struct list_lru {
|
||||
struct list_lru_node *node;
|
||||
#ifdef CONFIG_MEMCG_KMEM
|
||||
#if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
|
||||
struct list_head list;
|
||||
#endif
|
||||
};
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@
|
|||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
#define LZ4_MEM_COMPRESS (4096 * sizeof(unsigned char *))
|
||||
#define LZ4HC_MEM_COMPRESS (65538 * sizeof(unsigned char *))
|
||||
#define LZ4_MEM_COMPRESS (16384)
|
||||
#define LZ4HC_MEM_COMPRESS (262144 + (2 * sizeof(unsigned char *)))
|
||||
|
||||
/*
|
||||
* lz4_compressbound()
|
||||
|
|
|
|||
|
|
@ -50,6 +50,9 @@ enum mem_cgroup_stat_index {
|
|||
MEM_CGROUP_STAT_WRITEBACK, /* # of pages under writeback */
|
||||
MEM_CGROUP_STAT_SWAP, /* # of pages, swapped out */
|
||||
MEM_CGROUP_STAT_NSTATS,
|
||||
/* default hierarchy stats */
|
||||
MEMCG_SOCK,
|
||||
MEMCG_NR_STAT,
|
||||
};
|
||||
|
||||
struct mem_cgroup_reclaim_cookie {
|
||||
|
|
@ -85,15 +88,9 @@ enum mem_cgroup_events_target {
|
|||
MEM_CGROUP_NTARGETS,
|
||||
};
|
||||
|
||||
struct cg_proto {
|
||||
struct page_counter memory_allocated; /* Current allocated memory. */
|
||||
int memory_pressure;
|
||||
bool active;
|
||||
};
|
||||
|
||||
#ifdef CONFIG_MEMCG
|
||||
struct mem_cgroup_stat_cpu {
|
||||
long count[MEM_CGROUP_STAT_NSTATS];
|
||||
long count[MEMCG_NR_STAT];
|
||||
unsigned long events[MEMCG_NR_EVENTS];
|
||||
unsigned long nr_page_events;
|
||||
unsigned long targets[MEM_CGROUP_NTARGETS];
|
||||
|
|
@ -152,6 +149,12 @@ struct mem_cgroup_thresholds {
|
|||
struct mem_cgroup_threshold_ary *spare;
|
||||
};
|
||||
|
||||
enum memcg_kmem_state {
|
||||
KMEM_NONE,
|
||||
KMEM_ALLOCATED,
|
||||
KMEM_ONLINE,
|
||||
};
|
||||
|
||||
/*
|
||||
* The memory controller data structure. The memory controller controls both
|
||||
* page cache and RSS per cgroup. We would eventually like to provide
|
||||
|
|
@ -163,8 +166,12 @@ struct mem_cgroup {
|
|||
|
||||
/* Accounted resources */
|
||||
struct page_counter memory;
|
||||
struct page_counter swap;
|
||||
|
||||
/* Legacy consumer-oriented counters */
|
||||
struct page_counter memsw;
|
||||
struct page_counter kmem;
|
||||
struct page_counter tcpmem;
|
||||
|
||||
/* Normal memory consumption range */
|
||||
unsigned long low;
|
||||
|
|
@ -178,9 +185,6 @@ struct mem_cgroup {
|
|||
/* vmpressure notifications */
|
||||
struct vmpressure vmpressure;
|
||||
|
||||
/* css_online() has been completed */
|
||||
int initialized;
|
||||
|
||||
/*
|
||||
* Should the accounting and control be hierarchical, per subtree?
|
||||
*/
|
||||
|
|
@ -227,14 +231,16 @@ struct mem_cgroup {
|
|||
*/
|
||||
struct mem_cgroup_stat_cpu __percpu *stat;
|
||||
|
||||
#if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_INET)
|
||||
struct cg_proto tcp_mem;
|
||||
#endif
|
||||
#if defined(CONFIG_MEMCG_KMEM)
|
||||
unsigned long socket_pressure;
|
||||
|
||||
/* Legacy tcp memory accounting */
|
||||
bool tcpmem_active;
|
||||
int tcpmem_pressure;
|
||||
|
||||
#ifndef CONFIG_SLOB
|
||||
/* Index in the kmem_cache->memcg_params.memcg_caches array */
|
||||
int kmemcg_id;
|
||||
bool kmem_acct_activated;
|
||||
bool kmem_acct_active;
|
||||
enum memcg_kmem_state kmem_state;
|
||||
#endif
|
||||
|
||||
int last_scanned_node;
|
||||
|
|
@ -249,10 +255,6 @@ struct mem_cgroup {
|
|||
struct wb_domain cgwb_domain;
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_INET
|
||||
unsigned long socket_pressure;
|
||||
#endif
|
||||
|
||||
/* List of events which userspace want to receive */
|
||||
struct list_head event_list;
|
||||
spinlock_t event_list_lock;
|
||||
|
|
@ -356,6 +358,13 @@ static inline bool mem_cgroup_disabled(void)
|
|||
return !cgroup_subsys_enabled(memory_cgrp_subsys);
|
||||
}
|
||||
|
||||
static inline bool mem_cgroup_online(struct mem_cgroup *memcg)
|
||||
{
|
||||
if (mem_cgroup_disabled())
|
||||
return true;
|
||||
return !!(memcg->css.flags & CSS_ONLINE);
|
||||
}
|
||||
|
||||
/*
|
||||
* For memory reclaim.
|
||||
*/
|
||||
|
|
@ -364,20 +373,6 @@ int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
|
|||
void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
|
||||
int nr_pages);
|
||||
|
||||
static inline bool mem_cgroup_lruvec_online(struct lruvec *lruvec)
|
||||
{
|
||||
struct mem_cgroup_per_zone *mz;
|
||||
struct mem_cgroup *memcg;
|
||||
|
||||
if (mem_cgroup_disabled())
|
||||
return true;
|
||||
|
||||
mz = container_of(lruvec, struct mem_cgroup_per_zone, lruvec);
|
||||
memcg = mz->memcg;
|
||||
|
||||
return !!(memcg->css.flags & CSS_ONLINE);
|
||||
}
|
||||
|
||||
static inline
|
||||
unsigned long mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
|
||||
{
|
||||
|
|
@ -590,13 +585,13 @@ static inline bool mem_cgroup_disabled(void)
|
|||
return true;
|
||||
}
|
||||
|
||||
static inline bool
|
||||
mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
|
||||
static inline bool mem_cgroup_online(struct mem_cgroup *memcg)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline bool mem_cgroup_lruvec_online(struct lruvec *lruvec)
|
||||
static inline bool
|
||||
mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
|
@ -707,15 +702,13 @@ void sock_update_memcg(struct sock *sk);
|
|||
void sock_release_memcg(struct sock *sk);
|
||||
bool mem_cgroup_charge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages);
|
||||
void mem_cgroup_uncharge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages);
|
||||
#if defined(CONFIG_MEMCG) && defined(CONFIG_INET)
|
||||
#ifdef CONFIG_MEMCG
|
||||
extern struct static_key_false memcg_sockets_enabled_key;
|
||||
#define mem_cgroup_sockets_enabled static_branch_unlikely(&memcg_sockets_enabled_key)
|
||||
static inline bool mem_cgroup_under_socket_pressure(struct mem_cgroup *memcg)
|
||||
{
|
||||
#ifdef CONFIG_MEMCG_KMEM
|
||||
if (memcg->tcp_mem.memory_pressure)
|
||||
if (!cgroup_subsys_on_dfl(memory_cgrp_subsys) && memcg->tcpmem_pressure)
|
||||
return true;
|
||||
#endif
|
||||
do {
|
||||
if (time_before(jiffies, memcg->socket_pressure))
|
||||
return true;
|
||||
|
|
@ -730,7 +723,7 @@ static inline bool mem_cgroup_under_socket_pressure(struct mem_cgroup *memcg)
|
|||
}
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_MEMCG_KMEM
|
||||
#if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
|
||||
extern struct static_key_false memcg_kmem_enabled_key;
|
||||
|
||||
extern int memcg_nr_cache_ids;
|
||||
|
|
@ -750,9 +743,9 @@ static inline bool memcg_kmem_enabled(void)
|
|||
return static_branch_unlikely(&memcg_kmem_enabled_key);
|
||||
}
|
||||
|
||||
static inline bool memcg_kmem_is_active(struct mem_cgroup *memcg)
|
||||
static inline bool memcg_kmem_online(struct mem_cgroup *memcg)
|
||||
{
|
||||
return memcg->kmem_acct_active;
|
||||
return memcg->kmem_state == KMEM_ONLINE;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -850,7 +843,7 @@ static inline bool memcg_kmem_enabled(void)
|
|||
return false;
|
||||
}
|
||||
|
||||
static inline bool memcg_kmem_is_active(struct mem_cgroup *memcg)
|
||||
static inline bool memcg_kmem_online(struct mem_cgroup *memcg)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
|
@ -886,5 +879,6 @@ memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
|
|||
static inline void memcg_kmem_put_cache(struct kmem_cache *cachep)
|
||||
{
|
||||
}
|
||||
#endif /* CONFIG_MEMCG_KMEM */
|
||||
#endif /* CONFIG_MEMCG && !CONFIG_SLOB */
|
||||
|
||||
#endif /* _LINUX_MEMCONTROL_H */
|
||||
|
|
|
|||
|
|
@ -57,7 +57,29 @@ extern void exit_ptrace(struct task_struct *tracer, struct list_head *dead);
|
|||
#define PTRACE_MODE_READ 0x01
|
||||
#define PTRACE_MODE_ATTACH 0x02
|
||||
#define PTRACE_MODE_NOAUDIT 0x04
|
||||
/* Returns true on success, false on denial. */
|
||||
#define PTRACE_MODE_FSCREDS 0x08
|
||||
#define PTRACE_MODE_REALCREDS 0x10
|
||||
|
||||
/* shorthands for READ/ATTACH and FSCREDS/REALCREDS combinations */
|
||||
#define PTRACE_MODE_READ_FSCREDS (PTRACE_MODE_READ | PTRACE_MODE_FSCREDS)
|
||||
#define PTRACE_MODE_READ_REALCREDS (PTRACE_MODE_READ | PTRACE_MODE_REALCREDS)
|
||||
#define PTRACE_MODE_ATTACH_FSCREDS (PTRACE_MODE_ATTACH | PTRACE_MODE_FSCREDS)
|
||||
#define PTRACE_MODE_ATTACH_REALCREDS (PTRACE_MODE_ATTACH | PTRACE_MODE_REALCREDS)
|
||||
|
||||
/**
|
||||
* ptrace_may_access - check whether the caller is permitted to access
|
||||
* a target task.
|
||||
* @task: target task
|
||||
* @mode: selects type of access and caller credentials
|
||||
*
|
||||
* Returns true on success, false on denial.
|
||||
*
|
||||
* One of the flags PTRACE_MODE_FSCREDS and PTRACE_MODE_REALCREDS must
|
||||
* be set in @mode to specify whether the access was requested through
|
||||
* a filesystem syscall (should use effective capabilities and fsuid
|
||||
* of the caller) or through an explicit syscall such as
|
||||
* process_vm_writev or ptrace (and should use the real credentials).
|
||||
*/
|
||||
extern bool ptrace_may_access(struct task_struct *task, unsigned int mode);
|
||||
|
||||
static inline int ptrace_reparented(struct task_struct *child)
|
||||
|
|
|
|||
|
|
@ -154,7 +154,7 @@ do { \
|
|||
* radix_tree_gang_lookup_tag_slot
|
||||
* radix_tree_tagged
|
||||
*
|
||||
* The first 7 functions are able to be called locklessly, using RCU. The
|
||||
* The first 8 functions are able to be called locklessly, using RCU. The
|
||||
* caller must ensure calls to these functions are made within rcu_read_lock()
|
||||
* regions. Other readers (lock-free or otherwise) and modifications may be
|
||||
* running concurrently.
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ struct rb_root {
|
|||
#define RB_ROOT (struct rb_root) { NULL, }
|
||||
#define rb_entry(ptr, type, member) container_of(ptr, type, member)
|
||||
|
||||
#define RB_EMPTY_ROOT(root) ((root)->rb_node == NULL)
|
||||
#define RB_EMPTY_ROOT(root) (READ_ONCE((root)->rb_node) == NULL)
|
||||
|
||||
/* 'empty' nodes are nodes that are known not to be inserted in an rbtree */
|
||||
#define RB_EMPTY_NODE(node) \
|
||||
|
|
|
|||
|
|
@ -1476,10 +1476,10 @@ struct task_struct {
|
|||
unsigned in_iowait:1;
|
||||
#ifdef CONFIG_MEMCG
|
||||
unsigned memcg_may_oom:1;
|
||||
#endif
|
||||
#ifdef CONFIG_MEMCG_KMEM
|
||||
#ifndef CONFIG_SLOB
|
||||
unsigned memcg_kmem_skip_account:1;
|
||||
#endif
|
||||
#endif
|
||||
#ifdef CONFIG_COMPAT_BRK
|
||||
unsigned brk_randomized:1;
|
||||
#endif
|
||||
|
|
@ -1643,6 +1643,9 @@ struct task_struct {
|
|||
struct held_lock held_locks[MAX_LOCK_DEPTH];
|
||||
gfp_t lockdep_reclaim_gfp;
|
||||
#endif
|
||||
#ifdef CONFIG_UBSAN
|
||||
unsigned int in_ubsan;
|
||||
#endif
|
||||
|
||||
/* journalling filesystem info */
|
||||
void *journal_info;
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ struct sysv_shm {
|
|||
|
||||
long do_shmat(int shmid, char __user *shmaddr, int shmflg, unsigned long *addr,
|
||||
unsigned long shmlba);
|
||||
int is_file_shm_hugepages(struct file *file);
|
||||
bool is_file_shm_hugepages(struct file *file);
|
||||
void exit_shm(struct task_struct *task);
|
||||
#define shm_init_task(task) INIT_LIST_HEAD(&(task)->sysvshm.shm_clist)
|
||||
#else
|
||||
|
|
@ -66,9 +66,9 @@ static inline long do_shmat(int shmid, char __user *shmaddr,
|
|||
{
|
||||
return -ENOSYS;
|
||||
}
|
||||
static inline int is_file_shm_hugepages(struct file *file)
|
||||
static inline bool is_file_shm_hugepages(struct file *file)
|
||||
{
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
static inline void exit_shm(struct task_struct *task)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@
|
|||
#else
|
||||
# define SLAB_FAILSLAB 0x00000000UL
|
||||
#endif
|
||||
#ifdef CONFIG_MEMCG_KMEM
|
||||
#if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
|
||||
# define SLAB_ACCOUNT 0x04000000UL /* Account to memcg */
|
||||
#else
|
||||
# define SLAB_ACCOUNT 0x00000000UL
|
||||
|
|
|
|||
|
|
@ -69,7 +69,8 @@ struct kmem_cache {
|
|||
*/
|
||||
int obj_offset;
|
||||
#endif /* CONFIG_DEBUG_SLAB */
|
||||
#ifdef CONFIG_MEMCG_KMEM
|
||||
|
||||
#ifdef CONFIG_MEMCG
|
||||
struct memcg_cache_params memcg_params;
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ struct kmem_cache {
|
|||
#ifdef CONFIG_SYSFS
|
||||
struct kobject kobj; /* For sysfs */
|
||||
#endif
|
||||
#ifdef CONFIG_MEMCG_KMEM
|
||||
#ifdef CONFIG_MEMCG
|
||||
struct memcg_cache_params memcg_params;
|
||||
int max_attr_size; /* for propagation, maximum size of a stored attr */
|
||||
#ifdef CONFIG_SYSFS
|
||||
|
|
|
|||
|
|
@ -350,33 +350,7 @@ extern void check_move_unevictable_pages(struct page **, int nr_pages);
|
|||
|
||||
extern int kswapd_run(int nid);
|
||||
extern void kswapd_stop(int nid);
|
||||
#ifdef CONFIG_MEMCG
|
||||
static inline int mem_cgroup_swappiness(struct mem_cgroup *memcg)
|
||||
{
|
||||
/* root ? */
|
||||
if (mem_cgroup_disabled() || !memcg->css.parent)
|
||||
return vm_swappiness;
|
||||
|
||||
return memcg->swappiness;
|
||||
}
|
||||
|
||||
#else
|
||||
static inline int mem_cgroup_swappiness(struct mem_cgroup *mem)
|
||||
{
|
||||
return vm_swappiness;
|
||||
}
|
||||
#endif
|
||||
#ifdef CONFIG_MEMCG_SWAP
|
||||
extern void mem_cgroup_swapout(struct page *page, swp_entry_t entry);
|
||||
extern void mem_cgroup_uncharge_swap(swp_entry_t entry);
|
||||
#else
|
||||
static inline void mem_cgroup_swapout(struct page *page, swp_entry_t entry)
|
||||
{
|
||||
}
|
||||
static inline void mem_cgroup_uncharge_swap(swp_entry_t entry)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
#ifdef CONFIG_SWAP
|
||||
/* linux/mm/page_io.c */
|
||||
extern int swap_readpage(struct page *);
|
||||
|
|
@ -555,5 +529,55 @@ static inline swp_entry_t get_swap_page(void)
|
|||
}
|
||||
|
||||
#endif /* CONFIG_SWAP */
|
||||
|
||||
#ifdef CONFIG_MEMCG
|
||||
static inline int mem_cgroup_swappiness(struct mem_cgroup *memcg)
|
||||
{
|
||||
/* root ? */
|
||||
if (mem_cgroup_disabled() || !memcg->css.parent)
|
||||
return vm_swappiness;
|
||||
|
||||
return memcg->swappiness;
|
||||
}
|
||||
|
||||
#else
|
||||
static inline int mem_cgroup_swappiness(struct mem_cgroup *mem)
|
||||
{
|
||||
return vm_swappiness;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_MEMCG_SWAP
|
||||
extern void mem_cgroup_swapout(struct page *page, swp_entry_t entry);
|
||||
extern int mem_cgroup_try_charge_swap(struct page *page, swp_entry_t entry);
|
||||
extern void mem_cgroup_uncharge_swap(swp_entry_t entry);
|
||||
extern long mem_cgroup_get_nr_swap_pages(struct mem_cgroup *memcg);
|
||||
extern bool mem_cgroup_swap_full(struct page *page);
|
||||
#else
|
||||
static inline void mem_cgroup_swapout(struct page *page, swp_entry_t entry)
|
||||
{
|
||||
}
|
||||
|
||||
static inline int mem_cgroup_try_charge_swap(struct page *page,
|
||||
swp_entry_t entry)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline void mem_cgroup_uncharge_swap(swp_entry_t entry)
|
||||
{
|
||||
}
|
||||
|
||||
static inline long mem_cgroup_get_nr_swap_pages(struct mem_cgroup *memcg)
|
||||
{
|
||||
return get_nr_swap_pages();
|
||||
}
|
||||
|
||||
static inline bool mem_cgroup_swap_full(struct page *page)
|
||||
{
|
||||
return vm_swap_full();
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __KERNEL__*/
|
||||
#endif /* _LINUX_SWAP_H */
|
||||
|
|
|
|||
Loading…
Reference in a new issue