mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-25 14:13:01 -04:00
Merge branch 'akpm' (patches from Andrew)
Merge second patch-bomb from Andrew Morton: - most of the rest of MM - procfs - lib/ updates - printk updates - bitops infrastructure tweaks - checkpatch updates - nilfs2 update - signals - various other misc bits: coredump, seqfile, kexec, pidns, zlib, ipc, dma-debug, dma-mapping, ... * emailed patches from Andrew Morton <akpm@linux-foundation.org>: (102 commits) ipc,msg: drop dst nil validation in copy_msg include/linux/zutil.h: fix usage example of zlib_adler32() panic: release stale console lock to always get the logbuf printed out dma-debug: check nents in dma_sync_sg* dma-mapping: tidy up dma_parms default handling pidns: fix set/getpriority and ioprio_set/get in PRIO_USER mode kexec: use file name as the output message prefix fs, seqfile: always allow oom killer seq_file: reuse string_escape_str() fs/seq_file: use seq_* helpers in seq_hex_dump() coredump: change zap_threads() and zap_process() to use for_each_thread() coredump: ensure all coredumping tasks have SIGNAL_GROUP_COREDUMP signal: remove jffs2_garbage_collect_thread()->allow_signal(SIGCONT) signal: introduce kernel_signal_stop() to fix jffs2_garbage_collect_thread() signal: turn dequeue_signal_lock() into kernel_dequeue_signal() signals: kill block_all_signals() and unblock_all_signals() nilfs2: fix gcc uninitialized-variable warnings in powerpc build nilfs2: fix gcc unused-but-set-variable warnings MAINTAINERS: nilfs2: add header file for tracing nilfs2: add tracepoints for analyzing reading and writing metadata files ...
This commit is contained in:
Linus Torvalds
commit
ad804a0b2a
211 changed files with 2298 additions and 1632 deletions
|
|
@ -164,6 +164,8 @@ static inline __u8 ror8(__u8 word, unsigned int shift)
|
|||
* sign_extend32 - sign extend a 32-bit value using specified bit as sign-bit
|
||||
* @value: value to sign extend
|
||||
* @index: 0 based bit index (0<=index<32) to sign bit
|
||||
*
|
||||
* This is safe to use for 16- and 8-bit types as well.
|
||||
*/
|
||||
static inline __s32 sign_extend32(__u32 value, int index)
|
||||
{
|
||||
|
|
@ -171,6 +173,17 @@ static inline __s32 sign_extend32(__u32 value, int index)
|
|||
return (__s32)(value << shift) >> shift;
|
||||
}
|
||||
|
||||
/**
|
||||
* sign_extend64 - sign extend a 64-bit value using specified bit as sign-bit
|
||||
* @value: value to sign extend
|
||||
* @index: 0 based bit index (0<=index<64) to sign bit
|
||||
*/
|
||||
static inline __s64 sign_extend64(__u64 value, int index)
|
||||
{
|
||||
__u8 shift = 63 - index;
|
||||
return (__s64)(value << shift) >> shift;
|
||||
}
|
||||
|
||||
static inline unsigned fls_long(unsigned long l)
|
||||
{
|
||||
if (sizeof(l) == 4)
|
||||
|
|
|
|||
|
|
@ -205,7 +205,10 @@
|
|||
|
||||
#if GCC_VERSION >= 40600
|
||||
/*
|
||||
* Tell the optimizer that something else uses this function or variable.
|
||||
* When used with Link Time Optimization, gcc can optimize away C functions or
|
||||
* variables which are referenced only from assembly code. __visible tells the
|
||||
* optimizer that something else uses this function or variable, thus preventing
|
||||
* this.
|
||||
*/
|
||||
#define __visible __attribute__((externally_visible))
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -104,6 +104,9 @@ extern void cpuset_print_current_mems_allowed(void);
|
|||
*/
|
||||
static inline unsigned int read_mems_allowed_begin(void)
|
||||
{
|
||||
if (!cpusets_enabled())
|
||||
return 0;
|
||||
|
||||
return read_seqcount_begin(¤t->mems_allowed_seq);
|
||||
}
|
||||
|
||||
|
|
@ -115,6 +118,9 @@ static inline unsigned int read_mems_allowed_begin(void)
|
|||
*/
|
||||
static inline bool read_mems_allowed_retry(unsigned int seq)
|
||||
{
|
||||
if (!cpusets_enabled())
|
||||
return false;
|
||||
|
||||
return read_seqcount_retry(¤t->mems_allowed_seq, seq);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
#ifndef _LINUX_DMA_MAPPING_H
|
||||
#define _LINUX_DMA_MAPPING_H
|
||||
|
||||
#include <linux/sizes.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/err.h>
|
||||
|
|
@ -145,7 +146,9 @@ static inline void arch_teardown_dma_ops(struct device *dev) { }
|
|||
|
||||
static inline unsigned int dma_get_max_seg_size(struct device *dev)
|
||||
{
|
||||
return dev->dma_parms ? dev->dma_parms->max_segment_size : 65536;
|
||||
if (dev->dma_parms && dev->dma_parms->max_segment_size)
|
||||
return dev->dma_parms->max_segment_size;
|
||||
return SZ_64K;
|
||||
}
|
||||
|
||||
static inline unsigned int dma_set_max_seg_size(struct device *dev,
|
||||
|
|
@ -154,14 +157,15 @@ static inline unsigned int dma_set_max_seg_size(struct device *dev,
|
|||
if (dev->dma_parms) {
|
||||
dev->dma_parms->max_segment_size = size;
|
||||
return 0;
|
||||
} else
|
||||
return -EIO;
|
||||
}
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static inline unsigned long dma_get_seg_boundary(struct device *dev)
|
||||
{
|
||||
return dev->dma_parms ?
|
||||
dev->dma_parms->segment_boundary_mask : 0xffffffff;
|
||||
if (dev->dma_parms && dev->dma_parms->segment_boundary_mask)
|
||||
return dev->dma_parms->segment_boundary_mask;
|
||||
return DMA_BIT_MASK(32);
|
||||
}
|
||||
|
||||
static inline int dma_set_seg_boundary(struct device *dev, unsigned long mask)
|
||||
|
|
@ -169,8 +173,8 @@ static inline int dma_set_seg_boundary(struct device *dev, unsigned long mask)
|
|||
if (dev->dma_parms) {
|
||||
dev->dma_parms->segment_boundary_mask = mask;
|
||||
return 0;
|
||||
} else
|
||||
return -EIO;
|
||||
}
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
#ifndef dma_max_pfn
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@ struct vm_area_struct;
|
|||
#define ___GFP_HIGHMEM 0x02u
|
||||
#define ___GFP_DMA32 0x04u
|
||||
#define ___GFP_MOVABLE 0x08u
|
||||
#define ___GFP_WAIT 0x10u
|
||||
#define ___GFP_RECLAIMABLE 0x10u
|
||||
#define ___GFP_HIGH 0x20u
|
||||
#define ___GFP_IO 0x40u
|
||||
#define ___GFP_FS 0x80u
|
||||
|
|
@ -29,18 +29,17 @@ struct vm_area_struct;
|
|||
#define ___GFP_NOMEMALLOC 0x10000u
|
||||
#define ___GFP_HARDWALL 0x20000u
|
||||
#define ___GFP_THISNODE 0x40000u
|
||||
#define ___GFP_RECLAIMABLE 0x80000u
|
||||
#define ___GFP_ATOMIC 0x80000u
|
||||
#define ___GFP_NOACCOUNT 0x100000u
|
||||
#define ___GFP_NOTRACK 0x200000u
|
||||
#define ___GFP_NO_KSWAPD 0x400000u
|
||||
#define ___GFP_DIRECT_RECLAIM 0x400000u
|
||||
#define ___GFP_OTHER_NODE 0x800000u
|
||||
#define ___GFP_WRITE 0x1000000u
|
||||
#define ___GFP_KSWAPD_RECLAIM 0x2000000u
|
||||
/* If the above are modified, __GFP_BITS_SHIFT may need updating */
|
||||
|
||||
/*
|
||||
* GFP bitmasks..
|
||||
*
|
||||
* Zone modifiers (see linux/mmzone.h - low three bits)
|
||||
* Physical address zone modifiers (see linux/mmzone.h - low four bits)
|
||||
*
|
||||
* Do not put any conditional on these. If necessary modify the definitions
|
||||
* without the underscores and use them consistently. The definitions here may
|
||||
|
|
@ -50,116 +49,229 @@ struct vm_area_struct;
|
|||
#define __GFP_HIGHMEM ((__force gfp_t)___GFP_HIGHMEM)
|
||||
#define __GFP_DMA32 ((__force gfp_t)___GFP_DMA32)
|
||||
#define __GFP_MOVABLE ((__force gfp_t)___GFP_MOVABLE) /* Page is movable */
|
||||
#define __GFP_MOVABLE ((__force gfp_t)___GFP_MOVABLE) /* ZONE_MOVABLE allowed */
|
||||
#define GFP_ZONEMASK (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)
|
||||
|
||||
/*
|
||||
* Action modifiers - doesn't change the zoning
|
||||
* Page mobility and placement hints
|
||||
*
|
||||
* These flags provide hints about how mobile the page is. Pages with similar
|
||||
* mobility are placed within the same pageblocks to minimise problems due
|
||||
* to external fragmentation.
|
||||
*
|
||||
* __GFP_MOVABLE (also a zone modifier) indicates that the page can be
|
||||
* moved by page migration during memory compaction or can be reclaimed.
|
||||
*
|
||||
* __GFP_RECLAIMABLE is used for slab allocations that specify
|
||||
* SLAB_RECLAIM_ACCOUNT and whose pages can be freed via shrinkers.
|
||||
*
|
||||
* __GFP_WRITE indicates the caller intends to dirty the page. Where possible,
|
||||
* these pages will be spread between local zones to avoid all the dirty
|
||||
* pages being in one zone (fair zone allocation policy).
|
||||
*
|
||||
* __GFP_HARDWALL enforces the cpuset memory allocation policy.
|
||||
*
|
||||
* __GFP_THISNODE forces the allocation to be satisified from the requested
|
||||
* node with no fallbacks or placement policy enforcements.
|
||||
*/
|
||||
#define __GFP_RECLAIMABLE ((__force gfp_t)___GFP_RECLAIMABLE)
|
||||
#define __GFP_WRITE ((__force gfp_t)___GFP_WRITE)
|
||||
#define __GFP_HARDWALL ((__force gfp_t)___GFP_HARDWALL)
|
||||
#define __GFP_THISNODE ((__force gfp_t)___GFP_THISNODE)
|
||||
|
||||
/*
|
||||
* Watermark modifiers -- controls access to emergency reserves
|
||||
*
|
||||
* __GFP_HIGH indicates that the caller is high-priority and that granting
|
||||
* the request is necessary before the system can make forward progress.
|
||||
* For example, creating an IO context to clean pages.
|
||||
*
|
||||
* __GFP_ATOMIC indicates that the caller cannot reclaim or sleep and is
|
||||
* high priority. Users are typically interrupt handlers. This may be
|
||||
* used in conjunction with __GFP_HIGH
|
||||
*
|
||||
* __GFP_MEMALLOC allows access to all memory. This should only be used when
|
||||
* the caller guarantees the allocation will allow more memory to be freed
|
||||
* very shortly e.g. process exiting or swapping. Users either should
|
||||
* be the MM or co-ordinating closely with the VM (e.g. swap over NFS).
|
||||
*
|
||||
* __GFP_NOMEMALLOC is used to explicitly forbid access to emergency reserves.
|
||||
* This takes precedence over the __GFP_MEMALLOC flag if both are set.
|
||||
*
|
||||
* __GFP_NOACCOUNT ignores the accounting for kmemcg limit enforcement.
|
||||
*/
|
||||
#define __GFP_ATOMIC ((__force gfp_t)___GFP_ATOMIC)
|
||||
#define __GFP_HIGH ((__force gfp_t)___GFP_HIGH)
|
||||
#define __GFP_MEMALLOC ((__force gfp_t)___GFP_MEMALLOC)
|
||||
#define __GFP_NOMEMALLOC ((__force gfp_t)___GFP_NOMEMALLOC)
|
||||
#define __GFP_NOACCOUNT ((__force gfp_t)___GFP_NOACCOUNT)
|
||||
|
||||
/*
|
||||
* Reclaim modifiers
|
||||
*
|
||||
* __GFP_IO can start physical IO.
|
||||
*
|
||||
* __GFP_FS can call down to the low-level FS. Clearing the flag avoids the
|
||||
* allocator recursing into the filesystem which might already be holding
|
||||
* locks.
|
||||
*
|
||||
* __GFP_DIRECT_RECLAIM indicates that the caller may enter direct reclaim.
|
||||
* This flag can be cleared to avoid unnecessary delays when a fallback
|
||||
* option is available.
|
||||
*
|
||||
* __GFP_KSWAPD_RECLAIM indicates that the caller wants to wake kswapd when
|
||||
* the low watermark is reached and have it reclaim pages until the high
|
||||
* watermark is reached. A caller may wish to clear this flag when fallback
|
||||
* options are available and the reclaim is likely to disrupt the system. The
|
||||
* canonical example is THP allocation where a fallback is cheap but
|
||||
* reclaim/compaction may cause indirect stalls.
|
||||
*
|
||||
* __GFP_RECLAIM is shorthand to allow/forbid both direct and kswapd reclaim.
|
||||
*
|
||||
* __GFP_REPEAT: Try hard to allocate the memory, but the allocation attempt
|
||||
* _might_ fail. This depends upon the particular VM implementation.
|
||||
* _might_ fail. This depends upon the particular VM implementation.
|
||||
*
|
||||
* __GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller
|
||||
* cannot handle allocation failures. New users should be evaluated carefully
|
||||
* (and the flag should be used only when there is no reasonable failure policy)
|
||||
* but it is definitely preferable to use the flag rather than opencode endless
|
||||
* loop around allocator.
|
||||
* cannot handle allocation failures. New users should be evaluated carefully
|
||||
* (and the flag should be used only when there is no reasonable failure
|
||||
* policy) but it is definitely preferable to use the flag rather than
|
||||
* opencode endless loop around allocator.
|
||||
*
|
||||
* __GFP_NORETRY: The VM implementation must not retry indefinitely and will
|
||||
* return NULL when direct reclaim and memory compaction have failed to allow
|
||||
* the allocation to succeed. The OOM killer is not called with the current
|
||||
* implementation.
|
||||
*
|
||||
* __GFP_MOVABLE: Flag that this page will be movable by the page migration
|
||||
* mechanism or reclaimed
|
||||
* return NULL when direct reclaim and memory compaction have failed to allow
|
||||
* the allocation to succeed. The OOM killer is not called with the current
|
||||
* implementation.
|
||||
*/
|
||||
#define __GFP_WAIT ((__force gfp_t)___GFP_WAIT) /* Can wait and reschedule? */
|
||||
#define __GFP_HIGH ((__force gfp_t)___GFP_HIGH) /* Should access emergency pools? */
|
||||
#define __GFP_IO ((__force gfp_t)___GFP_IO) /* Can start physical IO? */
|
||||
#define __GFP_FS ((__force gfp_t)___GFP_FS) /* Can call down to low-level FS? */
|
||||
#define __GFP_COLD ((__force gfp_t)___GFP_COLD) /* Cache-cold page required */
|
||||
#define __GFP_NOWARN ((__force gfp_t)___GFP_NOWARN) /* Suppress page allocation failure warning */
|
||||
#define __GFP_REPEAT ((__force gfp_t)___GFP_REPEAT) /* See above */
|
||||
#define __GFP_NOFAIL ((__force gfp_t)___GFP_NOFAIL) /* See above */
|
||||
#define __GFP_NORETRY ((__force gfp_t)___GFP_NORETRY) /* See above */
|
||||
#define __GFP_MEMALLOC ((__force gfp_t)___GFP_MEMALLOC)/* Allow access to emergency reserves */
|
||||
#define __GFP_COMP ((__force gfp_t)___GFP_COMP) /* Add compound page metadata */
|
||||
#define __GFP_ZERO ((__force gfp_t)___GFP_ZERO) /* Return zeroed page on success */
|
||||
#define __GFP_NOMEMALLOC ((__force gfp_t)___GFP_NOMEMALLOC) /* Don't use emergency reserves.
|
||||
* This takes precedence over the
|
||||
* __GFP_MEMALLOC flag if both are
|
||||
* set
|
||||
*/
|
||||
#define __GFP_HARDWALL ((__force gfp_t)___GFP_HARDWALL) /* Enforce hardwall cpuset memory allocs */
|
||||
#define __GFP_THISNODE ((__force gfp_t)___GFP_THISNODE)/* No fallback, no policies */
|
||||
#define __GFP_RECLAIMABLE ((__force gfp_t)___GFP_RECLAIMABLE) /* Page is reclaimable */
|
||||
#define __GFP_NOACCOUNT ((__force gfp_t)___GFP_NOACCOUNT) /* Don't account to kmemcg */
|
||||
#define __GFP_NOTRACK ((__force gfp_t)___GFP_NOTRACK) /* Don't track with kmemcheck */
|
||||
|
||||
#define __GFP_NO_KSWAPD ((__force gfp_t)___GFP_NO_KSWAPD)
|
||||
#define __GFP_OTHER_NODE ((__force gfp_t)___GFP_OTHER_NODE) /* On behalf of other node */
|
||||
#define __GFP_WRITE ((__force gfp_t)___GFP_WRITE) /* Allocator intends to dirty page */
|
||||
#define __GFP_IO ((__force gfp_t)___GFP_IO)
|
||||
#define __GFP_FS ((__force gfp_t)___GFP_FS)
|
||||
#define __GFP_DIRECT_RECLAIM ((__force gfp_t)___GFP_DIRECT_RECLAIM) /* Caller can reclaim */
|
||||
#define __GFP_KSWAPD_RECLAIM ((__force gfp_t)___GFP_KSWAPD_RECLAIM) /* kswapd can wake */
|
||||
#define __GFP_RECLAIM ((__force gfp_t)(___GFP_DIRECT_RECLAIM|___GFP_KSWAPD_RECLAIM))
|
||||
#define __GFP_REPEAT ((__force gfp_t)___GFP_REPEAT)
|
||||
#define __GFP_NOFAIL ((__force gfp_t)___GFP_NOFAIL)
|
||||
#define __GFP_NORETRY ((__force gfp_t)___GFP_NORETRY)
|
||||
|
||||
/*
|
||||
* This may seem redundant, but it's a way of annotating false positives vs.
|
||||
* allocations that simply cannot be supported (e.g. page tables).
|
||||
* Action modifiers
|
||||
*
|
||||
* __GFP_COLD indicates that the caller does not expect to be used in the near
|
||||
* future. Where possible, a cache-cold page will be returned.
|
||||
*
|
||||
* __GFP_NOWARN suppresses allocation failure reports.
|
||||
*
|
||||
* __GFP_COMP address compound page metadata.
|
||||
*
|
||||
* __GFP_ZERO returns a zeroed page on success.
|
||||
*
|
||||
* __GFP_NOTRACK avoids tracking with kmemcheck.
|
||||
*
|
||||
* __GFP_NOTRACK_FALSE_POSITIVE is an alias of __GFP_NOTRACK. It's a means of
|
||||
* distinguishing in the source between false positives and allocations that
|
||||
* cannot be supported (e.g. page tables).
|
||||
*
|
||||
* __GFP_OTHER_NODE is for allocations that are on a remote node but that
|
||||
* should not be accounted for as a remote allocation in vmstat. A
|
||||
* typical user would be khugepaged collapsing a huge page on a remote
|
||||
* node.
|
||||
*/
|
||||
#define __GFP_COLD ((__force gfp_t)___GFP_COLD)
|
||||
#define __GFP_NOWARN ((__force gfp_t)___GFP_NOWARN)
|
||||
#define __GFP_COMP ((__force gfp_t)___GFP_COMP)
|
||||
#define __GFP_ZERO ((__force gfp_t)___GFP_ZERO)
|
||||
#define __GFP_NOTRACK ((__force gfp_t)___GFP_NOTRACK)
|
||||
#define __GFP_NOTRACK_FALSE_POSITIVE (__GFP_NOTRACK)
|
||||
#define __GFP_OTHER_NODE ((__force gfp_t)___GFP_OTHER_NODE)
|
||||
|
||||
#define __GFP_BITS_SHIFT 25 /* Room for N __GFP_FOO bits */
|
||||
/* Room for N __GFP_FOO bits */
|
||||
#define __GFP_BITS_SHIFT 26
|
||||
#define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
|
||||
|
||||
/* This equals 0, but use constants in case they ever change */
|
||||
#define GFP_NOWAIT (GFP_ATOMIC & ~__GFP_HIGH)
|
||||
/* GFP_ATOMIC means both !wait (__GFP_WAIT not set) and use emergency pool */
|
||||
#define GFP_ATOMIC (__GFP_HIGH)
|
||||
#define GFP_NOIO (__GFP_WAIT)
|
||||
#define GFP_NOFS (__GFP_WAIT | __GFP_IO)
|
||||
#define GFP_KERNEL (__GFP_WAIT | __GFP_IO | __GFP_FS)
|
||||
#define GFP_TEMPORARY (__GFP_WAIT | __GFP_IO | __GFP_FS | \
|
||||
/*
|
||||
* Useful GFP flag combinations that are commonly used. It is recommended
|
||||
* that subsystems start with one of these combinations and then set/clear
|
||||
* __GFP_FOO flags as necessary.
|
||||
*
|
||||
* GFP_ATOMIC users can not sleep and need the allocation to succeed. A lower
|
||||
* watermark is applied to allow access to "atomic reserves"
|
||||
*
|
||||
* GFP_KERNEL is typical for kernel-internal allocations. The caller requires
|
||||
* ZONE_NORMAL or a lower zone for direct access but can direct reclaim.
|
||||
*
|
||||
* GFP_NOWAIT is for kernel allocations that should not stall for direct
|
||||
* reclaim, start physical IO or use any filesystem callback.
|
||||
*
|
||||
* GFP_NOIO will use direct reclaim to discard clean pages or slab pages
|
||||
* that do not require the starting of any physical IO.
|
||||
*
|
||||
* GFP_NOFS will use direct reclaim but will not use any filesystem interfaces.
|
||||
*
|
||||
* GFP_USER is for userspace allocations that also need to be directly
|
||||
* accessibly by the kernel or hardware. It is typically used by hardware
|
||||
* for buffers that are mapped to userspace (e.g. graphics) that hardware
|
||||
* still must DMA to. cpuset limits are enforced for these allocations.
|
||||
*
|
||||
* GFP_DMA exists for historical reasons and should be avoided where possible.
|
||||
* The flags indicates that the caller requires that the lowest zone be
|
||||
* used (ZONE_DMA or 16M on x86-64). Ideally, this would be removed but
|
||||
* it would require careful auditing as some users really require it and
|
||||
* others use the flag to avoid lowmem reserves in ZONE_DMA and treat the
|
||||
* lowest zone as a type of emergency reserve.
|
||||
*
|
||||
* GFP_DMA32 is similar to GFP_DMA except that the caller requires a 32-bit
|
||||
* address.
|
||||
*
|
||||
* GFP_HIGHUSER is for userspace allocations that may be mapped to userspace,
|
||||
* do not need to be directly accessible by the kernel but that cannot
|
||||
* move once in use. An example may be a hardware allocation that maps
|
||||
* data directly into userspace but has no addressing limitations.
|
||||
*
|
||||
* GFP_HIGHUSER_MOVABLE is for userspace allocations that the kernel does not
|
||||
* need direct access to but can use kmap() when access is required. They
|
||||
* are expected to be movable via page reclaim or page migration. Typically,
|
||||
* pages on the LRU would also be allocated with GFP_HIGHUSER_MOVABLE.
|
||||
*
|
||||
* GFP_TRANSHUGE is used for THP allocations. They are compound allocations
|
||||
* that will fail quickly if memory is not available and will not wake
|
||||
* kswapd on failure.
|
||||
*/
|
||||
#define GFP_ATOMIC (__GFP_HIGH|__GFP_ATOMIC|__GFP_KSWAPD_RECLAIM)
|
||||
#define GFP_KERNEL (__GFP_RECLAIM | __GFP_IO | __GFP_FS)
|
||||
#define GFP_NOWAIT (__GFP_KSWAPD_RECLAIM)
|
||||
#define GFP_NOIO (__GFP_RECLAIM)
|
||||
#define GFP_NOFS (__GFP_RECLAIM | __GFP_IO)
|
||||
#define GFP_TEMPORARY (__GFP_RECLAIM | __GFP_IO | __GFP_FS | \
|
||||
__GFP_RECLAIMABLE)
|
||||
#define GFP_USER (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL)
|
||||
#define GFP_USER (__GFP_RECLAIM | __GFP_IO | __GFP_FS | __GFP_HARDWALL)
|
||||
#define GFP_DMA __GFP_DMA
|
||||
#define GFP_DMA32 __GFP_DMA32
|
||||
#define GFP_HIGHUSER (GFP_USER | __GFP_HIGHMEM)
|
||||
#define GFP_HIGHUSER_MOVABLE (GFP_HIGHUSER | __GFP_MOVABLE)
|
||||
#define GFP_IOFS (__GFP_IO | __GFP_FS)
|
||||
#define GFP_TRANSHUGE (GFP_HIGHUSER_MOVABLE | __GFP_COMP | \
|
||||
__GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN | \
|
||||
__GFP_NO_KSWAPD)
|
||||
|
||||
/* This mask makes up all the page movable related flags */
|
||||
#define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE)
|
||||
|
||||
/* Control page allocator reclaim behavior */
|
||||
#define GFP_RECLAIM_MASK (__GFP_WAIT|__GFP_HIGH|__GFP_IO|__GFP_FS|\
|
||||
__GFP_NOWARN|__GFP_REPEAT|__GFP_NOFAIL|\
|
||||
__GFP_NORETRY|__GFP_MEMALLOC|__GFP_NOMEMALLOC)
|
||||
|
||||
/* Control slab gfp mask during early boot */
|
||||
#define GFP_BOOT_MASK (__GFP_BITS_MASK & ~(__GFP_WAIT|__GFP_IO|__GFP_FS))
|
||||
|
||||
/* Control allocation constraints */
|
||||
#define GFP_CONSTRAINT_MASK (__GFP_HARDWALL|__GFP_THISNODE)
|
||||
|
||||
/* Do not use these with a slab allocator */
|
||||
#define GFP_SLAB_BUG_MASK (__GFP_DMA32|__GFP_HIGHMEM|~__GFP_BITS_MASK)
|
||||
|
||||
/* Flag - indicates that the buffer will be suitable for DMA. Ignored on some
|
||||
platforms, used as appropriate on others */
|
||||
|
||||
#define GFP_DMA __GFP_DMA
|
||||
|
||||
/* 4GB DMA on some platforms */
|
||||
#define GFP_DMA32 __GFP_DMA32
|
||||
#define GFP_TRANSHUGE ((GFP_HIGHUSER_MOVABLE | __GFP_COMP | \
|
||||
__GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN) & \
|
||||
~__GFP_KSWAPD_RECLAIM)
|
||||
|
||||
/* Convert GFP flags to their corresponding migrate type */
|
||||
#define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE)
|
||||
#define GFP_MOVABLE_SHIFT 3
|
||||
|
||||
static inline int gfpflags_to_migratetype(const gfp_t gfp_flags)
|
||||
{
|
||||
WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK);
|
||||
VM_WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK);
|
||||
BUILD_BUG_ON((1UL << GFP_MOVABLE_SHIFT) != ___GFP_MOVABLE);
|
||||
BUILD_BUG_ON((___GFP_MOVABLE >> GFP_MOVABLE_SHIFT) != MIGRATE_MOVABLE);
|
||||
|
||||
if (unlikely(page_group_by_mobility_disabled))
|
||||
return MIGRATE_UNMOVABLE;
|
||||
|
||||
/* Group based on mobility */
|
||||
return (((gfp_flags & __GFP_MOVABLE) != 0) << 1) |
|
||||
((gfp_flags & __GFP_RECLAIMABLE) != 0);
|
||||
return (gfp_flags & GFP_MOVABLE_MASK) >> GFP_MOVABLE_SHIFT;
|
||||
}
|
||||
#undef GFP_MOVABLE_MASK
|
||||
#undef GFP_MOVABLE_SHIFT
|
||||
|
||||
static inline bool gfpflags_allow_blocking(const gfp_t gfp_flags)
|
||||
{
|
||||
return gfp_flags & __GFP_DIRECT_RECLAIM;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_HIGHMEM
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ static inline struct hugetlb_cgroup *hugetlb_cgroup_from_page(struct page *page)
|
|||
|
||||
if (compound_order(page) < HUGETLB_CGROUP_MIN_ORDER)
|
||||
return NULL;
|
||||
return (struct hugetlb_cgroup *)page[2].lru.next;
|
||||
return (struct hugetlb_cgroup *)page[2].private;
|
||||
}
|
||||
|
||||
static inline
|
||||
|
|
@ -42,7 +42,7 @@ int set_hugetlb_cgroup(struct page *page, struct hugetlb_cgroup *h_cg)
|
|||
|
||||
if (compound_order(page) < HUGETLB_CGROUP_MIN_ORDER)
|
||||
return -1;
|
||||
page[2].lru.next = (void *)h_cg;
|
||||
page[2].private = (unsigned long)h_cg;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -413,6 +413,8 @@ extern __printf(2, 3)
|
|||
char *kasprintf(gfp_t gfp, const char *fmt, ...);
|
||||
extern __printf(2, 0)
|
||||
char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
|
||||
extern __printf(2, 0)
|
||||
const char *kvasprintf_const(gfp_t gfp, const char *fmt, va_list args);
|
||||
|
||||
extern __scanf(2, 3)
|
||||
int sscanf(const char *, const char *, ...);
|
||||
|
|
|
|||
|
|
@ -430,46 +430,6 @@ static inline void compound_unlock_irqrestore(struct page *page,
|
|||
#endif
|
||||
}
|
||||
|
||||
static inline struct page *compound_head_by_tail(struct page *tail)
|
||||
{
|
||||
struct page *head = tail->first_page;
|
||||
|
||||
/*
|
||||
* page->first_page may be a dangling pointer to an old
|
||||
* compound page, so recheck that it is still a tail
|
||||
* page before returning.
|
||||
*/
|
||||
smp_rmb();
|
||||
if (likely(PageTail(tail)))
|
||||
return head;
|
||||
return tail;
|
||||
}
|
||||
|
||||
/*
|
||||
* Since either compound page could be dismantled asynchronously in THP
|
||||
* or we access asynchronously arbitrary positioned struct page, there
|
||||
* would be tail flag race. To handle this race, we should call
|
||||
* smp_rmb() before checking tail flag. compound_head_by_tail() did it.
|
||||
*/
|
||||
static inline struct page *compound_head(struct page *page)
|
||||
{
|
||||
if (unlikely(PageTail(page)))
|
||||
return compound_head_by_tail(page);
|
||||
return page;
|
||||
}
|
||||
|
||||
/*
|
||||
* If we access compound page synchronously such as access to
|
||||
* allocated page, there is no need to handle tail flag race, so we can
|
||||
* check tail flag directly without any synchronization primitive.
|
||||
*/
|
||||
static inline struct page *compound_head_fast(struct page *page)
|
||||
{
|
||||
if (unlikely(PageTail(page)))
|
||||
return page->first_page;
|
||||
return page;
|
||||
}
|
||||
|
||||
/*
|
||||
* The atomic page->_mapcount, starts from -1: so that transitions
|
||||
* both from it and to it can be tracked, using atomic_inc_and_test
|
||||
|
|
@ -518,7 +478,7 @@ static inline void get_huge_page_tail(struct page *page)
|
|||
VM_BUG_ON_PAGE(!PageTail(page), page);
|
||||
VM_BUG_ON_PAGE(page_mapcount(page) < 0, page);
|
||||
VM_BUG_ON_PAGE(atomic_read(&page->_count) != 0, page);
|
||||
if (compound_tail_refcounted(page->first_page))
|
||||
if (compound_tail_refcounted(compound_head(page)))
|
||||
atomic_inc(&page->_mapcount);
|
||||
}
|
||||
|
||||
|
|
@ -541,13 +501,7 @@ static inline struct page *virt_to_head_page(const void *x)
|
|||
{
|
||||
struct page *page = virt_to_page(x);
|
||||
|
||||
/*
|
||||
* We don't need to worry about synchronization of tail flag
|
||||
* when we call virt_to_head_page() since it is only called for
|
||||
* already allocated page and this page won't be freed until
|
||||
* this virt_to_head_page() is finished. So use _fast variant.
|
||||
*/
|
||||
return compound_head_fast(page);
|
||||
return compound_head(page);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -568,28 +522,42 @@ int split_free_page(struct page *page);
|
|||
/*
|
||||
* Compound pages have a destructor function. Provide a
|
||||
* prototype for that function and accessor functions.
|
||||
* These are _only_ valid on the head of a PG_compound page.
|
||||
* These are _only_ valid on the head of a compound page.
|
||||
*/
|
||||
typedef void compound_page_dtor(struct page *);
|
||||
|
||||
/* Keep the enum in sync with compound_page_dtors array in mm/page_alloc.c */
|
||||
enum compound_dtor_id {
|
||||
NULL_COMPOUND_DTOR,
|
||||
COMPOUND_PAGE_DTOR,
|
||||
#ifdef CONFIG_HUGETLB_PAGE
|
||||
HUGETLB_PAGE_DTOR,
|
||||
#endif
|
||||
NR_COMPOUND_DTORS,
|
||||
};
|
||||
extern compound_page_dtor * const compound_page_dtors[];
|
||||
|
||||
static inline void set_compound_page_dtor(struct page *page,
|
||||
compound_page_dtor *dtor)
|
||||
enum compound_dtor_id compound_dtor)
|
||||
{
|
||||
page[1].compound_dtor = dtor;
|
||||
VM_BUG_ON_PAGE(compound_dtor >= NR_COMPOUND_DTORS, page);
|
||||
page[1].compound_dtor = compound_dtor;
|
||||
}
|
||||
|
||||
static inline compound_page_dtor *get_compound_page_dtor(struct page *page)
|
||||
{
|
||||
return page[1].compound_dtor;
|
||||
VM_BUG_ON_PAGE(page[1].compound_dtor >= NR_COMPOUND_DTORS, page);
|
||||
return compound_page_dtors[page[1].compound_dtor];
|
||||
}
|
||||
|
||||
static inline int compound_order(struct page *page)
|
||||
static inline unsigned int compound_order(struct page *page)
|
||||
{
|
||||
if (!PageHead(page))
|
||||
return 0;
|
||||
return page[1].compound_order;
|
||||
}
|
||||
|
||||
static inline void set_compound_order(struct page *page, unsigned long order)
|
||||
static inline void set_compound_order(struct page *page, unsigned int order)
|
||||
{
|
||||
page[1].compound_order = order;
|
||||
}
|
||||
|
|
@ -1572,8 +1540,7 @@ static inline bool ptlock_init(struct page *page)
|
|||
* with 0. Make sure nobody took it in use in between.
|
||||
*
|
||||
* It can happen if arch try to use slab for page table allocation:
|
||||
* slab code uses page->slab_cache and page->first_page (for tail
|
||||
* pages), which share storage with page->ptl.
|
||||
* slab code uses page->slab_cache, which share storage with page->ptl.
|
||||
*/
|
||||
VM_BUG_ON_PAGE(*(unsigned long *)&page->ptl, page);
|
||||
if (!ptlock_alloc(page))
|
||||
|
|
@ -1843,7 +1810,8 @@ extern void si_meminfo(struct sysinfo * val);
|
|||
extern void si_meminfo_node(struct sysinfo *val, int nid);
|
||||
|
||||
extern __printf(3, 4)
|
||||
void warn_alloc_failed(gfp_t gfp_mask, int order, const char *fmt, ...);
|
||||
void warn_alloc_failed(gfp_t gfp_mask, unsigned int order,
|
||||
const char *fmt, ...);
|
||||
|
||||
extern void setup_per_cpu_pageset(void);
|
||||
|
||||
|
|
|
|||
|
|
@ -28,8 +28,6 @@ struct mem_cgroup;
|
|||
IS_ENABLED(CONFIG_ARCH_ENABLE_SPLIT_PMD_PTLOCK))
|
||||
#define ALLOC_SPLIT_PTLOCKS (SPINLOCK_SIZE > BITS_PER_LONG/8)
|
||||
|
||||
typedef void compound_page_dtor(struct page *);
|
||||
|
||||
/*
|
||||
* Each physical page in the system has a struct page associated with
|
||||
* it to keep track of whatever it is we are using the page for at the
|
||||
|
|
@ -113,7 +111,13 @@ struct page {
|
|||
};
|
||||
};
|
||||
|
||||
/* Third double word block */
|
||||
/*
|
||||
* Third double word block
|
||||
*
|
||||
* WARNING: bit 0 of the first word encode PageTail(). That means
|
||||
* the rest users of the storage space MUST NOT use the bit to
|
||||
* avoid collision and false-positive PageTail().
|
||||
*/
|
||||
union {
|
||||
struct list_head lru; /* Pageout list, eg. active_list
|
||||
* protected by zone->lru_lock !
|
||||
|
|
@ -131,18 +135,37 @@ struct page {
|
|||
#endif
|
||||
};
|
||||
|
||||
struct slab *slab_page; /* slab fields */
|
||||
struct rcu_head rcu_head; /* Used by SLAB
|
||||
* when destroying via RCU
|
||||
*/
|
||||
/* First tail page of compound page */
|
||||
/* Tail pages of compound page */
|
||||
struct {
|
||||
compound_page_dtor *compound_dtor;
|
||||
unsigned long compound_order;
|
||||
unsigned long compound_head; /* If bit zero is set */
|
||||
|
||||
/* First tail page only */
|
||||
#ifdef CONFIG_64BIT
|
||||
/*
|
||||
* On 64 bit system we have enough space in struct page
|
||||
* to encode compound_dtor and compound_order with
|
||||
* unsigned int. It can help compiler generate better or
|
||||
* smaller code on some archtectures.
|
||||
*/
|
||||
unsigned int compound_dtor;
|
||||
unsigned int compound_order;
|
||||
#else
|
||||
unsigned short int compound_dtor;
|
||||
unsigned short int compound_order;
|
||||
#endif
|
||||
};
|
||||
|
||||
#if defined(CONFIG_TRANSPARENT_HUGEPAGE) && USE_SPLIT_PMD_PTLOCKS
|
||||
pgtable_t pmd_huge_pte; /* protected by page->ptl */
|
||||
struct {
|
||||
unsigned long __pad; /* do not overlay pmd_huge_pte
|
||||
* with compound_head to avoid
|
||||
* possible bit 0 collision.
|
||||
*/
|
||||
pgtable_t pmd_huge_pte; /* protected by page->ptl */
|
||||
};
|
||||
#endif
|
||||
};
|
||||
|
||||
|
|
@ -163,7 +186,6 @@ struct page {
|
|||
#endif
|
||||
#endif
|
||||
struct kmem_cache *slab_cache; /* SL[AU]B: Pointer to slab */
|
||||
struct page *first_page; /* Compound tail pages */
|
||||
};
|
||||
|
||||
#ifdef CONFIG_MEMCG
|
||||
|
|
|
|||
|
|
@ -37,10 +37,10 @@
|
|||
|
||||
enum {
|
||||
MIGRATE_UNMOVABLE,
|
||||
MIGRATE_RECLAIMABLE,
|
||||
MIGRATE_MOVABLE,
|
||||
MIGRATE_RECLAIMABLE,
|
||||
MIGRATE_PCPTYPES, /* the number of types on the pcp lists */
|
||||
MIGRATE_RESERVE = MIGRATE_PCPTYPES,
|
||||
MIGRATE_HIGHATOMIC = MIGRATE_PCPTYPES,
|
||||
#ifdef CONFIG_CMA
|
||||
/*
|
||||
* MIGRATE_CMA migration type is designed to mimic the way
|
||||
|
|
@ -334,13 +334,16 @@ struct zone {
|
|||
/* zone watermarks, access with *_wmark_pages(zone) macros */
|
||||
unsigned long watermark[NR_WMARK];
|
||||
|
||||
unsigned long nr_reserved_highatomic;
|
||||
|
||||
/*
|
||||
* We don't know if the memory that we're going to allocate will be freeable
|
||||
* or/and it will be released eventually, so to avoid totally wasting several
|
||||
* GB of ram we must reserve some of the lower zone memory (otherwise we risk
|
||||
* to run OOM on the lower zones despite there's tons of freeable ram
|
||||
* on the higher zones). This array is recalculated at runtime if the
|
||||
* sysctl_lowmem_reserve_ratio sysctl changes.
|
||||
* We don't know if the memory that we're going to allocate will be
|
||||
* freeable or/and it will be released eventually, so to avoid totally
|
||||
* wasting several GB of ram we must reserve some of the lower zone
|
||||
* memory (otherwise we risk to run OOM on the lower zones despite
|
||||
* there being tons of freeable ram on the higher zones). This array is
|
||||
* recalculated at runtime if the sysctl_lowmem_reserve_ratio sysctl
|
||||
* changes.
|
||||
*/
|
||||
long lowmem_reserve[MAX_NR_ZONES];
|
||||
|
||||
|
|
@ -429,12 +432,6 @@ struct zone {
|
|||
|
||||
const char *name;
|
||||
|
||||
/*
|
||||
* Number of MIGRATE_RESERVE page block. To maintain for just
|
||||
* optimization. Protected by zone->lock.
|
||||
*/
|
||||
int nr_migrate_reserve_block;
|
||||
|
||||
#ifdef CONFIG_MEMORY_ISOLATION
|
||||
/*
|
||||
* Number of isolated pageblock. It is used to solve incorrect
|
||||
|
|
@ -589,75 +586,8 @@ static inline bool zone_is_empty(struct zone *zone)
|
|||
* [1] : No fallback (__GFP_THISNODE)
|
||||
*/
|
||||
#define MAX_ZONELISTS 2
|
||||
|
||||
|
||||
/*
|
||||
* We cache key information from each zonelist for smaller cache
|
||||
* footprint when scanning for free pages in get_page_from_freelist().
|
||||
*
|
||||
* 1) The BITMAP fullzones tracks which zones in a zonelist have come
|
||||
* up short of free memory since the last time (last_fullzone_zap)
|
||||
* we zero'd fullzones.
|
||||
* 2) The array z_to_n[] maps each zone in the zonelist to its node
|
||||
* id, so that we can efficiently evaluate whether that node is
|
||||
* set in the current tasks mems_allowed.
|
||||
*
|
||||
* Both fullzones and z_to_n[] are one-to-one with the zonelist,
|
||||
* indexed by a zones offset in the zonelist zones[] array.
|
||||
*
|
||||
* The get_page_from_freelist() routine does two scans. During the
|
||||
* first scan, we skip zones whose corresponding bit in 'fullzones'
|
||||
* is set or whose corresponding node in current->mems_allowed (which
|
||||
* comes from cpusets) is not set. During the second scan, we bypass
|
||||
* this zonelist_cache, to ensure we look methodically at each zone.
|
||||
*
|
||||
* Once per second, we zero out (zap) fullzones, forcing us to
|
||||
* reconsider nodes that might have regained more free memory.
|
||||
* The field last_full_zap is the time we last zapped fullzones.
|
||||
*
|
||||
* This mechanism reduces the amount of time we waste repeatedly
|
||||
* reexaming zones for free memory when they just came up low on
|
||||
* memory momentarilly ago.
|
||||
*
|
||||
* The zonelist_cache struct members logically belong in struct
|
||||
* zonelist. However, the mempolicy zonelists constructed for
|
||||
* MPOL_BIND are intentionally variable length (and usually much
|
||||
* shorter). A general purpose mechanism for handling structs with
|
||||
* multiple variable length members is more mechanism than we want
|
||||
* here. We resort to some special case hackery instead.
|
||||
*
|
||||
* The MPOL_BIND zonelists don't need this zonelist_cache (in good
|
||||
* part because they are shorter), so we put the fixed length stuff
|
||||
* at the front of the zonelist struct, ending in a variable length
|
||||
* zones[], as is needed by MPOL_BIND.
|
||||
*
|
||||
* Then we put the optional zonelist cache on the end of the zonelist
|
||||
* struct. This optional stuff is found by a 'zlcache_ptr' pointer in
|
||||
* the fixed length portion at the front of the struct. This pointer
|
||||
* both enables us to find the zonelist cache, and in the case of
|
||||
* MPOL_BIND zonelists, (which will just set the zlcache_ptr to NULL)
|
||||
* to know that the zonelist cache is not there.
|
||||
*
|
||||
* The end result is that struct zonelists come in two flavors:
|
||||
* 1) The full, fixed length version, shown below, and
|
||||
* 2) The custom zonelists for MPOL_BIND.
|
||||
* The custom MPOL_BIND zonelists have a NULL zlcache_ptr and no zlcache.
|
||||
*
|
||||
* Even though there may be multiple CPU cores on a node modifying
|
||||
* fullzones or last_full_zap in the same zonelist_cache at the same
|
||||
* time, we don't lock it. This is just hint data - if it is wrong now
|
||||
* and then, the allocator will still function, perhaps a bit slower.
|
||||
*/
|
||||
|
||||
|
||||
struct zonelist_cache {
|
||||
unsigned short z_to_n[MAX_ZONES_PER_ZONELIST]; /* zone->nid */
|
||||
DECLARE_BITMAP(fullzones, MAX_ZONES_PER_ZONELIST); /* zone full? */
|
||||
unsigned long last_full_zap; /* when last zap'd (jiffies) */
|
||||
};
|
||||
#else
|
||||
#define MAX_ZONELISTS 1
|
||||
struct zonelist_cache;
|
||||
#endif
|
||||
|
||||
/*
|
||||
|
|
@ -675,9 +605,6 @@ struct zoneref {
|
|||
* allocation, the other zones are fallback zones, in decreasing
|
||||
* priority.
|
||||
*
|
||||
* If zlcache_ptr is not NULL, then it is just the address of zlcache,
|
||||
* as explained above. If zlcache_ptr is NULL, there is no zlcache.
|
||||
* *
|
||||
* To speed the reading of the zonelist, the zonerefs contain the zone index
|
||||
* of the entry being read. Helper functions to access information given
|
||||
* a struct zoneref are
|
||||
|
|
@ -687,11 +614,7 @@ struct zoneref {
|
|||
* zonelist_node_idx() - Return the index of the node for an entry
|
||||
*/
|
||||
struct zonelist {
|
||||
struct zonelist_cache *zlcache_ptr; // NULL or &zlcache
|
||||
struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
|
||||
#ifdef CONFIG_NUMA
|
||||
struct zonelist_cache zlcache; // optional ...
|
||||
#endif
|
||||
};
|
||||
|
||||
#ifndef CONFIG_DISCONTIGMEM
|
||||
|
|
@ -817,7 +740,7 @@ void wakeup_kswapd(struct zone *zone, int order, enum zone_type classzone_idx);
|
|||
bool zone_watermark_ok(struct zone *z, unsigned int order,
|
||||
unsigned long mark, int classzone_idx, int alloc_flags);
|
||||
bool zone_watermark_ok_safe(struct zone *z, unsigned int order,
|
||||
unsigned long mark, int classzone_idx, int alloc_flags);
|
||||
unsigned long mark, int classzone_idx);
|
||||
enum memmap_context {
|
||||
MEMMAP_EARLY,
|
||||
MEMMAP_HOTPLUG,
|
||||
|
|
|
|||
|
|
@ -386,6 +386,7 @@ extern int param_get_ullong(char *buffer, const struct kernel_param *kp);
|
|||
extern const struct kernel_param_ops param_ops_charp;
|
||||
extern int param_set_charp(const char *val, const struct kernel_param *kp);
|
||||
extern int param_get_charp(char *buffer, const struct kernel_param *kp);
|
||||
extern void param_free_charp(void *arg);
|
||||
#define param_check_charp(name, p) __param_check(name, p, char *)
|
||||
|
||||
/* We used to allow int as well as bool. We're taking that away! */
|
||||
|
|
|
|||
|
|
@ -86,12 +86,7 @@ enum pageflags {
|
|||
PG_private, /* If pagecache, has fs-private data */
|
||||
PG_private_2, /* If pagecache, has fs aux data */
|
||||
PG_writeback, /* Page is under writeback */
|
||||
#ifdef CONFIG_PAGEFLAGS_EXTENDED
|
||||
PG_head, /* A head page */
|
||||
PG_tail, /* A tail page */
|
||||
#else
|
||||
PG_compound, /* A compound page */
|
||||
#endif
|
||||
PG_swapcache, /* Swap page: swp_entry_t in private */
|
||||
PG_mappedtodisk, /* Has blocks allocated on-disk */
|
||||
PG_reclaim, /* To be reclaimed asap */
|
||||
|
|
@ -398,21 +393,35 @@ static inline void set_page_writeback_keepwrite(struct page *page)
|
|||
test_set_page_writeback_keepwrite(page);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PAGEFLAGS_EXTENDED
|
||||
/*
|
||||
* System with lots of page flags available. This allows separate
|
||||
* flags for PageHead() and PageTail() checks of compound pages so that bit
|
||||
* tests can be used in performance sensitive paths. PageCompound is
|
||||
* generally not used in hot code paths except arch/powerpc/mm/init_64.c
|
||||
* and arch/powerpc/kvm/book3s_64_vio_hv.c which use it to detect huge pages
|
||||
* and avoid handling those in real mode.
|
||||
*/
|
||||
__PAGEFLAG(Head, head) CLEARPAGEFLAG(Head, head)
|
||||
__PAGEFLAG(Tail, tail)
|
||||
|
||||
static inline int PageTail(struct page *page)
|
||||
{
|
||||
return READ_ONCE(page->compound_head) & 1;
|
||||
}
|
||||
|
||||
static inline void set_compound_head(struct page *page, struct page *head)
|
||||
{
|
||||
WRITE_ONCE(page->compound_head, (unsigned long)head + 1);
|
||||
}
|
||||
|
||||
static inline void clear_compound_head(struct page *page)
|
||||
{
|
||||
WRITE_ONCE(page->compound_head, 0);
|
||||
}
|
||||
|
||||
static inline struct page *compound_head(struct page *page)
|
||||
{
|
||||
unsigned long head = READ_ONCE(page->compound_head);
|
||||
|
||||
if (unlikely(head & 1))
|
||||
return (struct page *) (head - 1);
|
||||
return page;
|
||||
}
|
||||
|
||||
static inline int PageCompound(struct page *page)
|
||||
{
|
||||
return page->flags & ((1L << PG_head) | (1L << PG_tail));
|
||||
return PageHead(page) || PageTail(page);
|
||||
|
||||
}
|
||||
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
||||
|
|
@ -425,59 +434,6 @@ static inline void ClearPageCompound(struct page *page)
|
|||
|
||||
#define PG_head_mask ((1L << PG_head))
|
||||
|
||||
#else
|
||||
/*
|
||||
* Reduce page flag use as much as possible by overlapping
|
||||
* compound page flags with the flags used for page cache pages. Possible
|
||||
* because PageCompound is always set for compound pages and not for
|
||||
* pages on the LRU and/or pagecache.
|
||||
*/
|
||||
TESTPAGEFLAG(Compound, compound)
|
||||
__SETPAGEFLAG(Head, compound) __CLEARPAGEFLAG(Head, compound)
|
||||
|
||||
/*
|
||||
* PG_reclaim is used in combination with PG_compound to mark the
|
||||
* head and tail of a compound page. This saves one page flag
|
||||
* but makes it impossible to use compound pages for the page cache.
|
||||
* The PG_reclaim bit would have to be used for reclaim or readahead
|
||||
* if compound pages enter the page cache.
|
||||
*
|
||||
* PG_compound & PG_reclaim => Tail page
|
||||
* PG_compound & ~PG_reclaim => Head page
|
||||
*/
|
||||
#define PG_head_mask ((1L << PG_compound))
|
||||
#define PG_head_tail_mask ((1L << PG_compound) | (1L << PG_reclaim))
|
||||
|
||||
static inline int PageHead(struct page *page)
|
||||
{
|
||||
return ((page->flags & PG_head_tail_mask) == PG_head_mask);
|
||||
}
|
||||
|
||||
static inline int PageTail(struct page *page)
|
||||
{
|
||||
return ((page->flags & PG_head_tail_mask) == PG_head_tail_mask);
|
||||
}
|
||||
|
||||
static inline void __SetPageTail(struct page *page)
|
||||
{
|
||||
page->flags |= PG_head_tail_mask;
|
||||
}
|
||||
|
||||
static inline void __ClearPageTail(struct page *page)
|
||||
{
|
||||
page->flags &= ~PG_head_tail_mask;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
||||
static inline void ClearPageCompound(struct page *page)
|
||||
{
|
||||
BUG_ON((page->flags & PG_head_tail_mask) != (1 << PG_compound));
|
||||
clear_bit(PG_compound, &page->flags);
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* !PAGEFLAGS_EXTENDED */
|
||||
|
||||
#ifdef CONFIG_HUGETLB_PAGE
|
||||
int PageHuge(struct page *page);
|
||||
int PageHeadHuge(struct page *page);
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ enum pageblock_bits {
|
|||
#ifdef CONFIG_HUGETLB_PAGE_SIZE_VARIABLE
|
||||
|
||||
/* Huge page sizes are variable */
|
||||
extern int pageblock_order;
|
||||
extern unsigned int pageblock_order;
|
||||
|
||||
#else /* CONFIG_HUGETLB_PAGE_SIZE_VARIABLE */
|
||||
|
||||
|
|
|
|||
|
|
@ -69,6 +69,13 @@ static inline gfp_t mapping_gfp_mask(struct address_space * mapping)
|
|||
return (__force gfp_t)mapping->flags & __GFP_BITS_MASK;
|
||||
}
|
||||
|
||||
/* Restricts the given gfp_mask to what the mapping allows. */
|
||||
static inline gfp_t mapping_gfp_constraint(struct address_space *mapping,
|
||||
gfp_t gfp_mask)
|
||||
{
|
||||
return mapping_gfp_mask(mapping) & gfp_mask;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is non-atomic. Only to be used before the mapping is activated.
|
||||
* Probably needs a barrier...
|
||||
|
|
|
|||
|
|
@ -101,13 +101,21 @@ static inline void rb_link_node_rcu(struct rb_node *node, struct rb_node *parent
|
|||
})
|
||||
|
||||
/**
|
||||
* rbtree_postorder_for_each_entry_safe - iterate over rb_root in post order of
|
||||
* given type safe against removal of rb_node entry
|
||||
* rbtree_postorder_for_each_entry_safe - iterate in post-order over rb_root of
|
||||
* given type allowing the backing memory of @pos to be invalidated
|
||||
*
|
||||
* @pos: the 'type *' to use as a loop cursor.
|
||||
* @n: another 'type *' to use as temporary storage
|
||||
* @root: 'rb_root *' of the rbtree.
|
||||
* @field: the name of the rb_node field within 'type'.
|
||||
*
|
||||
* rbtree_postorder_for_each_entry_safe() provides a similar guarantee as
|
||||
* list_for_each_entry_safe() and allows the iteration to continue independent
|
||||
* of changes to @pos by the body of the loop.
|
||||
*
|
||||
* Note, however, that it cannot handle other modifications that re-order the
|
||||
* rbtree it is iterating over. This includes calling rb_erase() on @pos, as
|
||||
* rb_erase() may rebalance the tree, causing us to miss some nodes.
|
||||
*/
|
||||
#define rbtree_postorder_for_each_entry_safe(pos, n, root, field) \
|
||||
for (pos = rb_entry_safe(rb_first_postorder(root), typeof(*pos), field); \
|
||||
|
|
|
|||
|
|
@ -1570,9 +1570,7 @@ struct task_struct {
|
|||
|
||||
unsigned long sas_ss_sp;
|
||||
size_t sas_ss_size;
|
||||
int (*notifier)(void *priv);
|
||||
void *notifier_data;
|
||||
sigset_t *notifier_mask;
|
||||
|
||||
struct callback_head *task_works;
|
||||
|
||||
struct audit_context *audit_context;
|
||||
|
|
@ -2464,21 +2462,29 @@ extern void ignore_signals(struct task_struct *);
|
|||
extern void flush_signal_handlers(struct task_struct *, int force_default);
|
||||
extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
|
||||
|
||||
static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
|
||||
static inline int kernel_dequeue_signal(siginfo_t *info)
|
||||
{
|
||||
unsigned long flags;
|
||||
struct task_struct *tsk = current;
|
||||
siginfo_t __info;
|
||||
int ret;
|
||||
|
||||
spin_lock_irqsave(&tsk->sighand->siglock, flags);
|
||||
ret = dequeue_signal(tsk, mask, info);
|
||||
spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
|
||||
spin_lock_irq(&tsk->sighand->siglock);
|
||||
ret = dequeue_signal(tsk, &tsk->blocked, info ?: &__info);
|
||||
spin_unlock_irq(&tsk->sighand->siglock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
extern void block_all_signals(int (*notifier)(void *priv), void *priv,
|
||||
sigset_t *mask);
|
||||
extern void unblock_all_signals(void);
|
||||
static inline void kernel_signal_stop(void)
|
||||
{
|
||||
spin_lock_irq(¤t->sighand->siglock);
|
||||
if (current->jobctl & JOBCTL_STOP_DEQUEUED)
|
||||
__set_current_state(TASK_STOPPED);
|
||||
spin_unlock_irq(¤t->sighand->siglock);
|
||||
|
||||
schedule();
|
||||
}
|
||||
|
||||
extern void release_task(struct task_struct * p);
|
||||
extern int send_sig_info(int, struct siginfo *, struct task_struct *);
|
||||
extern int force_sigsegv(int, struct task_struct *);
|
||||
|
|
|
|||
|
|
@ -1224,7 +1224,7 @@ static inline int skb_cloned(const struct sk_buff *skb)
|
|||
|
||||
static inline int skb_unclone(struct sk_buff *skb, gfp_t pri)
|
||||
{
|
||||
might_sleep_if(pri & __GFP_WAIT);
|
||||
might_sleep_if(gfpflags_allow_blocking(pri));
|
||||
|
||||
if (skb_cloned(skb))
|
||||
return pskb_expand_head(skb, 0, 0, pri);
|
||||
|
|
@ -1308,7 +1308,7 @@ static inline int skb_shared(const struct sk_buff *skb)
|
|||
*/
|
||||
static inline struct sk_buff *skb_share_check(struct sk_buff *skb, gfp_t pri)
|
||||
{
|
||||
might_sleep_if(pri & __GFP_WAIT);
|
||||
might_sleep_if(gfpflags_allow_blocking(pri));
|
||||
if (skb_shared(skb)) {
|
||||
struct sk_buff *nskb = skb_clone(skb, pri);
|
||||
|
||||
|
|
@ -1344,7 +1344,7 @@ static inline struct sk_buff *skb_share_check(struct sk_buff *skb, gfp_t pri)
|
|||
static inline struct sk_buff *skb_unshare(struct sk_buff *skb,
|
||||
gfp_t pri)
|
||||
{
|
||||
might_sleep_if(pri & __GFP_WAIT);
|
||||
might_sleep_if(gfpflags_allow_blocking(pri));
|
||||
if (skb_cloned(skb)) {
|
||||
struct sk_buff *nskb = skb_copy(skb, pri);
|
||||
|
||||
|
|
|
|||
|
|
@ -38,10 +38,10 @@ enum zpool_mapmode {
|
|||
|
||||
bool zpool_has_pool(char *type);
|
||||
|
||||
struct zpool *zpool_create_pool(char *type, char *name,
|
||||
struct zpool *zpool_create_pool(const char *type, const char *name,
|
||||
gfp_t gfp, const struct zpool_ops *ops);
|
||||
|
||||
char *zpool_get_type(struct zpool *pool);
|
||||
const char *zpool_get_type(struct zpool *pool);
|
||||
|
||||
void zpool_destroy_pool(struct zpool *pool);
|
||||
|
||||
|
|
@ -83,7 +83,9 @@ struct zpool_driver {
|
|||
atomic_t refcount;
|
||||
struct list_head list;
|
||||
|
||||
void *(*create)(char *name, gfp_t gfp, const struct zpool_ops *ops,
|
||||
void *(*create)(const char *name,
|
||||
gfp_t gfp,
|
||||
const struct zpool_ops *ops,
|
||||
struct zpool *zpool);
|
||||
void (*destroy)(void *pool);
|
||||
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ struct zs_pool_stats {
|
|||
|
||||
struct zs_pool;
|
||||
|
||||
struct zs_pool *zs_create_pool(char *name, gfp_t flags);
|
||||
struct zs_pool *zs_create_pool(const char *name, gfp_t flags);
|
||||
void zs_destroy_pool(struct zs_pool *pool);
|
||||
|
||||
unsigned long zs_malloc(struct zs_pool *pool, size_t size);
|
||||
|
|
|
|||
|
|
@ -68,10 +68,10 @@ typedef uLong (*check_func) (uLong check, const Byte *buf,
|
|||
An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
|
||||
much faster. Usage example:
|
||||
|
||||
uLong adler = adler32(0L, NULL, 0);
|
||||
uLong adler = zlib_adler32(0L, NULL, 0);
|
||||
|
||||
while (read_buffer(buffer, length) != EOF) {
|
||||
adler = adler32(adler, buffer, length);
|
||||
adler = zlib_adler32(adler, buffer, length);
|
||||
}
|
||||
if (adler != original_adler) error();
|
||||
*/
|
||||
|
|
|
|||
Loading…
Reference in a new issue