2005-04-17 05:20:36 +07:00
|
|
|
#ifndef _LINUX_PAGEMAP_H
|
|
|
|
#define _LINUX_PAGEMAP_H
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copyright 1995 Linus Torvalds
|
|
|
|
*/
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/highmem.h>
|
|
|
|
#include <linux/compiler.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/gfp.h>
|
2007-05-08 14:23:25 +07:00
|
|
|
#include <linux/bitops.h>
|
2008-07-26 09:45:30 +07:00
|
|
|
#include <linux/hardirq.h> /* for in_interrupt() */
|
2010-05-28 07:29:15 +07:00
|
|
|
#include <linux/hugetlb_inline.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Bits in mapping->flags. The lower __GFP_BITS_SHIFT bits are the page
|
|
|
|
* allocation mode flags.
|
|
|
|
*/
|
2009-04-03 06:56:45 +07:00
|
|
|
enum mapping_flags {
|
|
|
|
AS_EIO = __GFP_BITS_SHIFT + 0, /* IO error on async write */
|
|
|
|
AS_ENOSPC = __GFP_BITS_SHIFT + 1, /* ENOSPC on async write */
|
|
|
|
AS_MM_ALL_LOCKS = __GFP_BITS_SHIFT + 2, /* under mm_take_all_locks() */
|
|
|
|
AS_UNEVICTABLE = __GFP_BITS_SHIFT + 3, /* e.g., ramdisk, SHM_LOCK */
|
2014-10-10 05:29:29 +07:00
|
|
|
AS_EXITING = __GFP_BITS_SHIFT + 4, /* final truncate in progress */
|
2009-04-03 06:56:45 +07:00
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-05-08 14:23:25 +07:00
|
|
|
static inline void mapping_set_error(struct address_space *mapping, int error)
|
|
|
|
{
|
2008-07-24 11:27:19 +07:00
|
|
|
if (unlikely(error)) {
|
2007-05-08 14:23:25 +07:00
|
|
|
if (error == -ENOSPC)
|
|
|
|
set_bit(AS_ENOSPC, &mapping->flags);
|
|
|
|
else
|
|
|
|
set_bit(AS_EIO, &mapping->flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-10-19 10:26:42 +07:00
|
|
|
static inline void mapping_set_unevictable(struct address_space *mapping)
|
|
|
|
{
|
|
|
|
set_bit(AS_UNEVICTABLE, &mapping->flags);
|
|
|
|
}
|
|
|
|
|
2008-10-19 10:26:43 +07:00
|
|
|
static inline void mapping_clear_unevictable(struct address_space *mapping)
|
|
|
|
{
|
|
|
|
clear_bit(AS_UNEVICTABLE, &mapping->flags);
|
|
|
|
}
|
|
|
|
|
2008-10-19 10:26:42 +07:00
|
|
|
static inline int mapping_unevictable(struct address_space *mapping)
|
|
|
|
{
|
2011-01-14 06:46:16 +07:00
|
|
|
if (mapping)
|
2008-10-19 10:26:43 +07:00
|
|
|
return test_bit(AS_UNEVICTABLE, &mapping->flags);
|
|
|
|
return !!mapping;
|
2008-10-19 10:26:42 +07:00
|
|
|
}
|
|
|
|
|
2014-04-04 04:47:49 +07:00
|
|
|
static inline void mapping_set_exiting(struct address_space *mapping)
|
|
|
|
{
|
|
|
|
set_bit(AS_EXITING, &mapping->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int mapping_exiting(struct address_space *mapping)
|
|
|
|
{
|
|
|
|
return test_bit(AS_EXITING, &mapping->flags);
|
|
|
|
}
|
|
|
|
|
2005-10-07 13:46:04 +07:00
|
|
|
static inline gfp_t mapping_gfp_mask(struct address_space * mapping)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-10-21 14:22:44 +07:00
|
|
|
return (__force gfp_t)mapping->flags & __GFP_BITS_MASK;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is non-atomic. Only to be used before the mapping is activated.
|
|
|
|
* Probably needs a barrier...
|
|
|
|
*/
|
2005-10-21 14:22:44 +07:00
|
|
|
static inline void mapping_set_gfp_mask(struct address_space *m, gfp_t mask)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-10-21 14:22:44 +07:00
|
|
|
m->flags = (m->flags & ~(__force unsigned long)__GFP_BITS_MASK) |
|
|
|
|
(__force unsigned long)mask;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2014-07-24 16:39:45 +07:00
|
|
|
* The page cache can be done in larger chunks than
|
2005-04-17 05:20:36 +07:00
|
|
|
* one page, because it allows for more efficient
|
|
|
|
* throughput (it can then be mapped into user
|
|
|
|
* space in smaller chunks for same flexibility).
|
|
|
|
*
|
|
|
|
* Or rather, it _will_ be done in larger chunks.
|
|
|
|
*/
|
|
|
|
#define PAGE_CACHE_SHIFT PAGE_SHIFT
|
|
|
|
#define PAGE_CACHE_SIZE PAGE_SIZE
|
|
|
|
#define PAGE_CACHE_MASK PAGE_MASK
|
|
|
|
#define PAGE_CACHE_ALIGN(addr) (((addr)+PAGE_CACHE_SIZE-1)&PAGE_CACHE_MASK)
|
|
|
|
|
|
|
|
#define page_cache_get(page) get_page(page)
|
|
|
|
#define page_cache_release(page) put_page(page)
|
2014-06-05 06:10:22 +07:00
|
|
|
void release_pages(struct page **pages, int nr, bool cold);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-26 09:45:30 +07:00
|
|
|
/*
|
|
|
|
* speculatively take a reference to a page.
|
|
|
|
* If the page is free (_count == 0), then _count is untouched, and 0
|
|
|
|
* is returned. Otherwise, _count is incremented by 1 and 1 is returned.
|
|
|
|
*
|
|
|
|
* This function must be called inside the same rcu_read_lock() section as has
|
|
|
|
* been used to lookup the page in the pagecache radix-tree (or page table):
|
|
|
|
* this allows allocators to use a synchronize_rcu() to stabilize _count.
|
|
|
|
*
|
|
|
|
* Unless an RCU grace period has passed, the count of all pages coming out
|
|
|
|
* of the allocator must be considered unstable. page_count may return higher
|
|
|
|
* than expected, and put_page must be able to do the right thing when the
|
|
|
|
* page has been finished with, no matter what it is subsequently allocated
|
|
|
|
* for (because put_page is what is used here to drop an invalid speculative
|
|
|
|
* reference).
|
|
|
|
*
|
|
|
|
* This is the interesting part of the lockless pagecache (and lockless
|
|
|
|
* get_user_pages) locking protocol, where the lookup-side (eg. find_get_page)
|
|
|
|
* has the following pattern:
|
|
|
|
* 1. find page in radix tree
|
|
|
|
* 2. conditionally increment refcount
|
|
|
|
* 3. check the page is still in pagecache (if no, goto 1)
|
|
|
|
*
|
|
|
|
* Remove-side that cares about stability of _count (eg. reclaim) has the
|
|
|
|
* following (with tree_lock held for write):
|
|
|
|
* A. atomically check refcount is correct and set it to 0 (atomic_cmpxchg)
|
|
|
|
* B. remove page from pagecache
|
|
|
|
* C. free the page
|
|
|
|
*
|
|
|
|
* There are 2 critical interleavings that matter:
|
|
|
|
* - 2 runs before A: in this case, A sees elevated refcount and bails out
|
|
|
|
* - A runs before 2: in this case, 2 sees zero refcount and retries;
|
|
|
|
* subsequently, B will complete and 1 will find no page, causing the
|
|
|
|
* lookup to return NULL.
|
|
|
|
*
|
|
|
|
* It is possible that between 1 and 2, the page is removed then the exact same
|
|
|
|
* page is inserted into the same position in pagecache. That's OK: the
|
|
|
|
* old find_get_page using tree_lock could equally have run before or after
|
|
|
|
* such a re-insertion, depending on order that locks are granted.
|
|
|
|
*
|
|
|
|
* Lookups racing against pagecache insertion isn't a big problem: either 1
|
|
|
|
* will find the page or it will not. Likewise, the old find_get_page could run
|
|
|
|
* either before the insertion or afterwards, depending on timing.
|
|
|
|
*/
|
|
|
|
static inline int page_cache_get_speculative(struct page *page)
|
|
|
|
{
|
|
|
|
VM_BUG_ON(in_interrupt());
|
|
|
|
|
2013-04-30 05:06:13 +07:00
|
|
|
#ifdef CONFIG_TINY_RCU
|
2011-06-08 06:13:27 +07:00
|
|
|
# ifdef CONFIG_PREEMPT_COUNT
|
2008-07-26 09:45:30 +07:00
|
|
|
VM_BUG_ON(!in_atomic());
|
|
|
|
# endif
|
|
|
|
/*
|
|
|
|
* Preempt must be disabled here - we rely on rcu_read_lock doing
|
|
|
|
* this for us.
|
|
|
|
*
|
|
|
|
* Pagecache won't be truncated from interrupt context, so if we have
|
|
|
|
* found a page in the radix tree here, we have pinned its refcount by
|
|
|
|
* disabling preempt, and hence no need for the "speculative get" that
|
|
|
|
* SMP requires.
|
|
|
|
*/
|
2014-01-24 06:52:54 +07:00
|
|
|
VM_BUG_ON_PAGE(page_count(page) == 0, page);
|
2008-07-26 09:45:30 +07:00
|
|
|
atomic_inc(&page->_count);
|
|
|
|
|
|
|
|
#else
|
|
|
|
if (unlikely(!get_page_unless_zero(page))) {
|
|
|
|
/*
|
|
|
|
* Either the page has been freed, or will be freed.
|
|
|
|
* In either case, retry here and the caller should
|
|
|
|
* do the right thing (see comments above).
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
2014-01-24 06:52:54 +07:00
|
|
|
VM_BUG_ON_PAGE(PageTail(page), page);
|
2008-07-26 09:45:30 +07:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-07-30 12:23:13 +07:00
|
|
|
/*
|
|
|
|
* Same as above, but add instead of inc (could just be merged)
|
|
|
|
*/
|
|
|
|
static inline int page_cache_add_speculative(struct page *page, int count)
|
|
|
|
{
|
|
|
|
VM_BUG_ON(in_interrupt());
|
|
|
|
|
2009-08-22 12:08:51 +07:00
|
|
|
#if !defined(CONFIG_SMP) && defined(CONFIG_TREE_RCU)
|
2011-06-08 06:13:27 +07:00
|
|
|
# ifdef CONFIG_PREEMPT_COUNT
|
2008-07-30 12:23:13 +07:00
|
|
|
VM_BUG_ON(!in_atomic());
|
|
|
|
# endif
|
2014-01-24 06:52:54 +07:00
|
|
|
VM_BUG_ON_PAGE(page_count(page) == 0, page);
|
2008-07-30 12:23:13 +07:00
|
|
|
atomic_add(count, &page->_count);
|
|
|
|
|
|
|
|
#else
|
|
|
|
if (unlikely(!atomic_add_unless(&page->_count, count, 0)))
|
|
|
|
return 0;
|
|
|
|
#endif
|
2014-01-24 06:52:54 +07:00
|
|
|
VM_BUG_ON_PAGE(PageCompound(page) && page != compound_head(page), page);
|
2008-07-30 12:23:13 +07:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-07-26 09:45:30 +07:00
|
|
|
static inline int page_freeze_refs(struct page *page, int count)
|
|
|
|
{
|
|
|
|
return likely(atomic_cmpxchg(&page->_count, count, 0) == count);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void page_unfreeze_refs(struct page *page, int count)
|
|
|
|
{
|
2014-01-24 06:52:54 +07:00
|
|
|
VM_BUG_ON_PAGE(page_count(page) != 0, page);
|
2008-07-26 09:45:30 +07:00
|
|
|
VM_BUG_ON(count == 0);
|
|
|
|
|
|
|
|
atomic_set(&page->_count, count);
|
|
|
|
}
|
|
|
|
|
2006-03-24 18:16:04 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
2006-10-29 00:38:23 +07:00
|
|
|
extern struct page *__page_cache_alloc(gfp_t gfp);
|
2006-03-24 18:16:04 +07:00
|
|
|
#else
|
2006-10-29 00:38:23 +07:00
|
|
|
static inline struct page *__page_cache_alloc(gfp_t gfp)
|
|
|
|
{
|
|
|
|
return alloc_pages(gfp, 0);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static inline struct page *page_cache_alloc(struct address_space *x)
|
|
|
|
{
|
2006-10-29 00:38:23 +07:00
|
|
|
return __page_cache_alloc(mapping_gfp_mask(x));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct page *page_cache_alloc_cold(struct address_space *x)
|
|
|
|
{
|
2006-10-29 00:38:23 +07:00
|
|
|
return __page_cache_alloc(mapping_gfp_mask(x)|__GFP_COLD);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2011-05-25 07:12:25 +07:00
|
|
|
static inline struct page *page_cache_alloc_readahead(struct address_space *x)
|
|
|
|
{
|
|
|
|
return __page_cache_alloc(mapping_gfp_mask(x) |
|
|
|
|
__GFP_COLD | __GFP_NORETRY | __GFP_NOWARN);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
typedef int filler_t(void *, struct page *);
|
|
|
|
|
2014-04-04 04:47:44 +07:00
|
|
|
pgoff_t page_cache_next_hole(struct address_space *mapping,
|
|
|
|
pgoff_t index, unsigned long max_scan);
|
|
|
|
pgoff_t page_cache_prev_hole(struct address_space *mapping,
|
|
|
|
pgoff_t index, unsigned long max_scan);
|
|
|
|
|
2014-06-05 06:10:31 +07:00
|
|
|
#define FGP_ACCESSED 0x00000001
|
|
|
|
#define FGP_LOCK 0x00000002
|
|
|
|
#define FGP_CREAT 0x00000004
|
|
|
|
#define FGP_WRITE 0x00000008
|
|
|
|
#define FGP_NOFS 0x00000010
|
|
|
|
#define FGP_NOWAIT 0x00000020
|
|
|
|
|
|
|
|
struct page *pagecache_get_page(struct address_space *mapping, pgoff_t offset,
|
2014-12-30 02:30:35 +07:00
|
|
|
int fgp_flags, gfp_t cache_gfp_mask);
|
2014-06-05 06:10:31 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* find_get_page - find and get a page reference
|
|
|
|
* @mapping: the address_space to search
|
|
|
|
* @offset: the page index
|
|
|
|
*
|
|
|
|
* Looks up the page cache slot at @mapping & @offset. If there is a
|
|
|
|
* page cache page, it is returned with an increased refcount.
|
|
|
|
*
|
|
|
|
* Otherwise, %NULL is returned.
|
|
|
|
*/
|
|
|
|
static inline struct page *find_get_page(struct address_space *mapping,
|
|
|
|
pgoff_t offset)
|
|
|
|
{
|
2014-12-30 02:30:35 +07:00
|
|
|
return pagecache_get_page(mapping, offset, 0, 0);
|
2014-06-05 06:10:31 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct page *find_get_page_flags(struct address_space *mapping,
|
|
|
|
pgoff_t offset, int fgp_flags)
|
|
|
|
{
|
2014-12-30 02:30:35 +07:00
|
|
|
return pagecache_get_page(mapping, offset, fgp_flags, 0);
|
2014-06-05 06:10:31 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* find_lock_page - locate, pin and lock a pagecache page
|
|
|
|
* pagecache_get_page - find and get a page reference
|
|
|
|
* @mapping: the address_space to search
|
|
|
|
* @offset: the page index
|
|
|
|
*
|
|
|
|
* Looks up the page cache slot at @mapping & @offset. If there is a
|
|
|
|
* page cache page, it is returned locked and with an increased
|
|
|
|
* refcount.
|
|
|
|
*
|
|
|
|
* Otherwise, %NULL is returned.
|
|
|
|
*
|
|
|
|
* find_lock_page() may sleep.
|
|
|
|
*/
|
|
|
|
static inline struct page *find_lock_page(struct address_space *mapping,
|
|
|
|
pgoff_t offset)
|
|
|
|
{
|
2014-12-30 02:30:35 +07:00
|
|
|
return pagecache_get_page(mapping, offset, FGP_LOCK, 0);
|
2014-06-05 06:10:31 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* find_or_create_page - locate or add a pagecache page
|
|
|
|
* @mapping: the page's address_space
|
|
|
|
* @index: the page's index into the mapping
|
|
|
|
* @gfp_mask: page allocation mode
|
|
|
|
*
|
|
|
|
* Looks up the page cache slot at @mapping & @offset. If there is a
|
|
|
|
* page cache page, it is returned locked and with an increased
|
|
|
|
* refcount.
|
|
|
|
*
|
|
|
|
* If the page is not present, a new page is allocated using @gfp_mask
|
|
|
|
* and added to the page cache and the VM's LRU list. The page is
|
|
|
|
* returned locked and with an increased refcount.
|
|
|
|
*
|
|
|
|
* On memory exhaustion, %NULL is returned.
|
|
|
|
*
|
|
|
|
* find_or_create_page() may sleep, even if @gfp_flags specifies an
|
|
|
|
* atomic allocation!
|
|
|
|
*/
|
|
|
|
static inline struct page *find_or_create_page(struct address_space *mapping,
|
|
|
|
pgoff_t offset, gfp_t gfp_mask)
|
|
|
|
{
|
|
|
|
return pagecache_get_page(mapping, offset,
|
|
|
|
FGP_LOCK|FGP_ACCESSED|FGP_CREAT,
|
2014-12-30 02:30:35 +07:00
|
|
|
gfp_mask);
|
2014-06-05 06:10:31 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* grab_cache_page_nowait - returns locked page at given index in given cache
|
|
|
|
* @mapping: target address_space
|
|
|
|
* @index: the page index
|
|
|
|
*
|
|
|
|
* Same as grab_cache_page(), but do not wait if the page is unavailable.
|
|
|
|
* This is intended for speculative data generators, where the data can
|
|
|
|
* be regenerated if the page couldn't be grabbed. This routine should
|
|
|
|
* be safe to call while holding the lock for another page.
|
|
|
|
*
|
|
|
|
* Clear __GFP_FS when allocating the page to avoid recursion into the fs
|
|
|
|
* and deadlock against the caller's locked page.
|
|
|
|
*/
|
|
|
|
static inline struct page *grab_cache_page_nowait(struct address_space *mapping,
|
|
|
|
pgoff_t index)
|
|
|
|
{
|
|
|
|
return pagecache_get_page(mapping, index,
|
|
|
|
FGP_LOCK|FGP_CREAT|FGP_NOFS|FGP_NOWAIT,
|
2014-12-30 02:30:35 +07:00
|
|
|
mapping_gfp_mask(mapping));
|
2014-06-05 06:10:31 +07:00
|
|
|
}
|
|
|
|
|
2014-04-04 04:47:46 +07:00
|
|
|
struct page *find_get_entry(struct address_space *mapping, pgoff_t offset);
|
|
|
|
struct page *find_lock_entry(struct address_space *mapping, pgoff_t offset);
|
|
|
|
unsigned find_get_entries(struct address_space *mapping, pgoff_t start,
|
|
|
|
unsigned int nr_entries, struct page **entries,
|
|
|
|
pgoff_t *indices);
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned find_get_pages(struct address_space *mapping, pgoff_t start,
|
|
|
|
unsigned int nr_pages, struct page **pages);
|
2006-04-27 13:46:01 +07:00
|
|
|
unsigned find_get_pages_contig(struct address_space *mapping, pgoff_t start,
|
|
|
|
unsigned int nr_pages, struct page **pages);
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned find_get_pages_tag(struct address_space *mapping, pgoff_t *index,
|
|
|
|
int tag, unsigned int nr_pages, struct page **pages);
|
|
|
|
|
fs: symlink write_begin allocation context fix
With the write_begin/write_end aops, page_symlink was broken because it
could no longer pass a GFP_NOFS type mask into the point where the
allocations happened. They are done in write_begin, which would always
assume that the filesystem can be entered from reclaim. This bug could
cause filesystem deadlocks.
The funny thing with having a gfp_t mask there is that it doesn't really
allow the caller to arbitrarily tinker with the context in which it can be
called. It couldn't ever be GFP_ATOMIC, for example, because it needs to
take the page lock. The only thing any callers care about is __GFP_FS
anyway, so turn that into a single flag.
Add a new flag for write_begin, AOP_FLAG_NOFS. Filesystems can now act on
this flag in their write_begin function. Change __grab_cache_page to
accept a nofs argument as well, to honour that flag (while we're there,
change the name to grab_cache_page_write_begin which is more instructive
and does away with random leading underscores).
This is really a more flexible way to go in the end anyway -- if a
filesystem happens to want any extra allocations aside from the pagecache
ones in ints write_begin function, it may now use GFP_KERNEL (rather than
GFP_NOFS) for common case allocations (eg. ocfs2_alloc_write_ctxt, for a
random example).
[kosaki.motohiro@jp.fujitsu.com: fix ubifs]
[kosaki.motohiro@jp.fujitsu.com: fix fuse]
Signed-off-by: Nick Piggin <npiggin@suse.de>
Reviewed-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: <stable@kernel.org> [2.6.28.x]
Signed-off-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
[ Cleaned up the calling convention: just pass in the AOP flags
untouched to the grab_cache_page_write_begin() function. That
just simplifies everybody, and may even allow future expansion of the
logic. - Linus ]
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-01-05 03:00:53 +07:00
|
|
|
struct page *grab_cache_page_write_begin(struct address_space *mapping,
|
|
|
|
pgoff_t index, unsigned flags);
|
2007-10-16 15:25:01 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Returns locked page at given index in given cache, creating it if needed.
|
|
|
|
*/
|
2007-10-16 15:24:37 +07:00
|
|
|
static inline struct page *grab_cache_page(struct address_space *mapping,
|
|
|
|
pgoff_t index)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
return find_or_create_page(mapping, index, mapping_gfp_mask(mapping));
|
|
|
|
}
|
|
|
|
|
|
|
|
extern struct page * read_cache_page(struct address_space *mapping,
|
2011-07-26 07:12:23 +07:00
|
|
|
pgoff_t index, filler_t *filler, void *data);
|
2010-01-28 00:20:03 +07:00
|
|
|
extern struct page * read_cache_page_gfp(struct address_space *mapping,
|
|
|
|
pgoff_t index, gfp_t gfp_mask);
|
2005-04-17 05:20:36 +07:00
|
|
|
extern int read_cache_pages(struct address_space *mapping,
|
|
|
|
struct list_head *pages, filler_t *filler, void *data);
|
|
|
|
|
2006-06-23 16:05:08 +07:00
|
|
|
static inline struct page *read_mapping_page(struct address_space *mapping,
|
2011-07-26 07:12:23 +07:00
|
|
|
pgoff_t index, void *data)
|
2006-06-23 16:05:08 +07:00
|
|
|
{
|
|
|
|
filler_t *filler = (filler_t *)mapping->a_ops->readpage;
|
|
|
|
return read_cache_page(mapping, index, filler, data);
|
|
|
|
}
|
|
|
|
|
2014-07-24 04:00:01 +07:00
|
|
|
/*
|
|
|
|
* Get the offset in PAGE_SIZE.
|
|
|
|
* (TODO: hugepage should have ->index in PAGE_SIZE)
|
|
|
|
*/
|
|
|
|
static inline pgoff_t page_to_pgoff(struct page *page)
|
|
|
|
{
|
|
|
|
if (unlikely(PageHeadHuge(page)))
|
|
|
|
return page->index << compound_order(page);
|
|
|
|
else
|
|
|
|
return page->index << (PAGE_CACHE_SHIFT - PAGE_SHIFT);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Return byte-offset into filesystem object for page.
|
|
|
|
*/
|
|
|
|
static inline loff_t page_offset(struct page *page)
|
|
|
|
{
|
|
|
|
return ((loff_t)page->index) << PAGE_CACHE_SHIFT;
|
|
|
|
}
|
|
|
|
|
2012-08-01 06:44:47 +07:00
|
|
|
static inline loff_t page_file_offset(struct page *page)
|
|
|
|
{
|
|
|
|
return ((loff_t)page_file_index(page)) << PAGE_CACHE_SHIFT;
|
|
|
|
}
|
|
|
|
|
2010-05-28 07:29:16 +07:00
|
|
|
extern pgoff_t linear_hugepage_index(struct vm_area_struct *vma,
|
|
|
|
unsigned long address);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static inline pgoff_t linear_page_index(struct vm_area_struct *vma,
|
|
|
|
unsigned long address)
|
|
|
|
{
|
2010-05-28 07:29:16 +07:00
|
|
|
pgoff_t pgoff;
|
|
|
|
if (unlikely(is_vm_hugetlb_page(vma)))
|
|
|
|
return linear_hugepage_index(vma, address);
|
|
|
|
pgoff = (address - vma->vm_start) >> PAGE_SHIFT;
|
2005-04-17 05:20:36 +07:00
|
|
|
pgoff += vma->vm_pgoff;
|
|
|
|
return pgoff >> (PAGE_CACHE_SHIFT - PAGE_SHIFT);
|
|
|
|
}
|
|
|
|
|
2008-02-14 06:03:15 +07:00
|
|
|
extern void __lock_page(struct page *page);
|
|
|
|
extern int __lock_page_killable(struct page *page);
|
2010-10-27 04:21:57 +07:00
|
|
|
extern int __lock_page_or_retry(struct page *page, struct mm_struct *mm,
|
|
|
|
unsigned int flags);
|
2008-02-14 06:03:15 +07:00
|
|
|
extern void unlock_page(struct page *page);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-10-19 10:26:57 +07:00
|
|
|
static inline void __set_page_locked(struct page *page)
|
2008-08-02 17:01:03 +07:00
|
|
|
{
|
2008-10-19 10:26:57 +07:00
|
|
|
__set_bit(PG_locked, &page->flags);
|
2008-08-02 17:01:03 +07:00
|
|
|
}
|
|
|
|
|
2008-10-19 10:26:57 +07:00
|
|
|
static inline void __clear_page_locked(struct page *page)
|
2008-08-02 17:01:03 +07:00
|
|
|
{
|
2008-10-19 10:26:57 +07:00
|
|
|
__clear_bit(PG_locked, &page->flags);
|
2008-08-02 17:01:03 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int trylock_page(struct page *page)
|
|
|
|
{
|
2008-10-19 10:26:59 +07:00
|
|
|
return (likely(!test_and_set_bit_lock(PG_locked, &page->flags)));
|
2008-08-02 17:01:03 +07:00
|
|
|
}
|
|
|
|
|
2006-09-26 13:31:24 +07:00
|
|
|
/*
|
|
|
|
* lock_page may only be called if we have the page's inode pinned.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
static inline void lock_page(struct page *page)
|
|
|
|
{
|
|
|
|
might_sleep();
|
2008-08-02 17:01:03 +07:00
|
|
|
if (!trylock_page(page))
|
2005-04-17 05:20:36 +07:00
|
|
|
__lock_page(page);
|
|
|
|
}
|
2006-09-26 13:31:24 +07:00
|
|
|
|
2007-12-06 23:18:49 +07:00
|
|
|
/*
|
|
|
|
* lock_page_killable is like lock_page but can be interrupted by fatal
|
|
|
|
* signals. It returns 0 if it locked the page and -EINTR if it was
|
|
|
|
* killed while waiting.
|
|
|
|
*/
|
|
|
|
static inline int lock_page_killable(struct page *page)
|
|
|
|
{
|
|
|
|
might_sleep();
|
2008-08-02 17:01:03 +07:00
|
|
|
if (!trylock_page(page))
|
2007-12-06 23:18:49 +07:00
|
|
|
return __lock_page_killable(page);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-27 04:21:57 +07:00
|
|
|
/*
|
|
|
|
* lock_page_or_retry - Lock the page, unless this would block and the
|
|
|
|
* caller indicated that it can handle a retry.
|
2014-08-07 06:07:24 +07:00
|
|
|
*
|
|
|
|
* Return value and mmap_sem implications depend on flags; see
|
|
|
|
* __lock_page_or_retry().
|
2010-10-27 04:21:57 +07:00
|
|
|
*/
|
|
|
|
static inline int lock_page_or_retry(struct page *page, struct mm_struct *mm,
|
|
|
|
unsigned int flags)
|
|
|
|
{
|
|
|
|
might_sleep();
|
|
|
|
return trylock_page(page) || __lock_page_or_retry(page, mm, flags);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2014-09-24 08:28:32 +07:00
|
|
|
* This is exported only for wait_on_page_locked/wait_on_page_writeback,
|
|
|
|
* and for filesystems which need to wait on PG_private.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2008-02-14 06:03:15 +07:00
|
|
|
extern void wait_on_page_bit(struct page *page, int bit_nr);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-05-25 07:11:29 +07:00
|
|
|
extern int wait_on_page_bit_killable(struct page *page, int bit_nr);
|
2014-09-25 10:55:19 +07:00
|
|
|
extern int wait_on_page_bit_killable_timeout(struct page *page,
|
|
|
|
int bit_nr, unsigned long timeout);
|
2011-05-25 07:11:29 +07:00
|
|
|
|
|
|
|
static inline int wait_on_page_locked_killable(struct page *page)
|
|
|
|
{
|
|
|
|
if (PageLocked(page))
|
|
|
|
return wait_on_page_bit_killable(page, PG_locked);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-24 08:28:32 +07:00
|
|
|
extern wait_queue_head_t *page_waitqueue(struct page *page);
|
|
|
|
static inline void wake_up_page(struct page *page, int bit)
|
|
|
|
{
|
|
|
|
__wake_up_bit(page_waitqueue(page), &page->flags, bit);
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Wait for a page to be unlocked.
|
|
|
|
*
|
|
|
|
* This must be called with the caller "holding" the page,
|
|
|
|
* ie with increased "page->count" so that the page won't
|
|
|
|
* go away during the wait..
|
|
|
|
*/
|
|
|
|
static inline void wait_on_page_locked(struct page *page)
|
|
|
|
{
|
|
|
|
if (PageLocked(page))
|
|
|
|
wait_on_page_bit(page, PG_locked);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for a page to complete writeback
|
|
|
|
*/
|
|
|
|
static inline void wait_on_page_writeback(struct page *page)
|
|
|
|
{
|
|
|
|
if (PageWriteback(page))
|
|
|
|
wait_on_page_bit(page, PG_writeback);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern void end_page_writeback(struct page *page);
|
mm: only enforce stable page writes if the backing device requires it
Create a helper function to check if a backing device requires stable
page writes and, if so, performs the necessary wait. Then, make it so
that all points in the memory manager that handle making pages writable
use the helper function. This should provide stable page write support
to most filesystems, while eliminating unnecessary waiting for devices
that don't require the feature.
Before this patchset, all filesystems would block, regardless of whether
or not it was necessary. ext3 would wait, but still generate occasional
checksum errors. The network filesystems were left to do their own
thing, so they'd wait too.
After this patchset, all the disk filesystems except ext3 and btrfs will
wait only if the hardware requires it. ext3 (if necessary) snapshots
pages instead of blocking, and btrfs provides its own bdi so the mm will
never wait. Network filesystems haven't been touched, so either they
provide their own stable page guarantees or they don't block at all.
The blocking behavior is back to what it was before 3.0 if you don't
have a disk requiring stable page writes.
Here's the result of using dbench to test latency on ext2:
3.8.0-rc3:
Operation Count AvgLat MaxLat
----------------------------------------
WriteX 109347 0.028 59.817
ReadX 347180 0.004 3.391
Flush 15514 29.828 287.283
Throughput 57.429 MB/sec 4 clients 4 procs max_latency=287.290 ms
3.8.0-rc3 + patches:
WriteX 105556 0.029 4.273
ReadX 335004 0.005 4.112
Flush 14982 30.540 298.634
Throughput 55.4496 MB/sec 4 clients 4 procs max_latency=298.650 ms
As you can see, the maximum write latency drops considerably with this
patch enabled. The other filesystems (ext3/ext4/xfs/btrfs) behave
similarly, but see the cover letter for those results.
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Acked-by: Steven Whitehouse <swhiteho@redhat.com>
Reviewed-by: Jan Kara <jack@suse.cz>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Artem Bityutskiy <dedekind1@gmail.com>
Cc: Joel Becker <jlbec@evilplan.org>
Cc: Mark Fasheh <mfasheh@suse.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Eric Van Hensbergen <ericvh@gmail.com>
Cc: Ron Minnich <rminnich@sandia.gov>
Cc: Latchesar Ionkov <lucho@ionkov.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-22 07:42:51 +07:00
|
|
|
void wait_for_stable_page(struct page *page);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2014-06-05 06:07:45 +07:00
|
|
|
void page_endio(struct page *page, int rw, int err);
|
|
|
|
|
2009-04-03 22:42:39 +07:00
|
|
|
/*
|
|
|
|
* Add an arbitrary waiter to a page's wait queue
|
|
|
|
*/
|
|
|
|
extern void add_page_wait_queue(struct page *page, wait_queue_t *waiter);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Fault a userspace page into pagetables. Return non-zero on a fault.
|
|
|
|
*
|
|
|
|
* This assumes that two userspace pages are always sufficient. That's
|
|
|
|
* not true if PAGE_CACHE_SIZE > PAGE_SIZE.
|
|
|
|
*/
|
|
|
|
static inline int fault_in_pages_writeable(char __user *uaddr, int size)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
mm: fix pagecache write deadlocks
Modify the core write() code so that it won't take a pagefault while holding a
lock on the pagecache page. There are a number of different deadlocks possible
if we try to do such a thing:
1. generic_buffered_write
2. lock_page
3. prepare_write
4. unlock_page+vmtruncate
5. copy_from_user
6. mmap_sem(r)
7. handle_mm_fault
8. lock_page (filemap_nopage)
9. commit_write
10. unlock_page
a. sys_munmap / sys_mlock / others
b. mmap_sem(w)
c. make_pages_present
d. get_user_pages
e. handle_mm_fault
f. lock_page (filemap_nopage)
2,8 - recursive deadlock if page is same
2,8;2,8 - ABBA deadlock is page is different
2,6;b,f - ABBA deadlock if page is same
The solution is as follows:
1. If we find the destination page is uptodate, continue as normal, but use
atomic usercopies which do not take pagefaults and do not zero the uncopied
tail of the destination. The destination is already uptodate, so we can
commit_write the full length even if there was a partial copy: it does not
matter that the tail was not modified, because if it is dirtied and written
back to disk it will not cause any problems (uptodate *means* that the
destination page is as new or newer than the copy on disk).
1a. The above requires that fault_in_pages_readable correctly returns access
information, because atomic usercopies cannot distinguish between
non-present pages in a readable mapping, from lack of a readable mapping.
2. If we find the destination page is non uptodate, unlock it (this could be
made slightly more optimal), then allocate a temporary page to copy the
source data into. Relock the destination page and continue with the copy.
However, instead of a usercopy (which might take a fault), copy the data
from the pinned temporary page via the kernel address space.
(also, rename maxlen to seglen, because it was confusing)
This increases the CPU/memory copy cost by almost 50% on the affected
workloads. That will be solved by introducing a new set of pagecache write
aops in a subsequent patch.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 15:24:59 +07:00
|
|
|
if (unlikely(size == 0))
|
|
|
|
return 0;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Writing zeroes into userspace here is OK, because we know that if
|
|
|
|
* the zero gets there, we'll be overwriting it.
|
|
|
|
*/
|
|
|
|
ret = __put_user(0, uaddr);
|
|
|
|
if (ret == 0) {
|
|
|
|
char __user *end = uaddr + size - 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the page was already mapped, this will get a cache miss
|
|
|
|
* for sure, so try to avoid doing it.
|
|
|
|
*/
|
|
|
|
if (((unsigned long)uaddr & PAGE_MASK) !=
|
|
|
|
((unsigned long)end & PAGE_MASK))
|
2012-03-26 00:47:41 +07:00
|
|
|
ret = __put_user(0, end);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
mm: fix pagecache write deadlocks
Modify the core write() code so that it won't take a pagefault while holding a
lock on the pagecache page. There are a number of different deadlocks possible
if we try to do such a thing:
1. generic_buffered_write
2. lock_page
3. prepare_write
4. unlock_page+vmtruncate
5. copy_from_user
6. mmap_sem(r)
7. handle_mm_fault
8. lock_page (filemap_nopage)
9. commit_write
10. unlock_page
a. sys_munmap / sys_mlock / others
b. mmap_sem(w)
c. make_pages_present
d. get_user_pages
e. handle_mm_fault
f. lock_page (filemap_nopage)
2,8 - recursive deadlock if page is same
2,8;2,8 - ABBA deadlock is page is different
2,6;b,f - ABBA deadlock if page is same
The solution is as follows:
1. If we find the destination page is uptodate, continue as normal, but use
atomic usercopies which do not take pagefaults and do not zero the uncopied
tail of the destination. The destination is already uptodate, so we can
commit_write the full length even if there was a partial copy: it does not
matter that the tail was not modified, because if it is dirtied and written
back to disk it will not cause any problems (uptodate *means* that the
destination page is as new or newer than the copy on disk).
1a. The above requires that fault_in_pages_readable correctly returns access
information, because atomic usercopies cannot distinguish between
non-present pages in a readable mapping, from lack of a readable mapping.
2. If we find the destination page is non uptodate, unlock it (this could be
made slightly more optimal), then allocate a temporary page to copy the
source data into. Relock the destination page and continue with the copy.
However, instead of a usercopy (which might take a fault), copy the data
from the pinned temporary page via the kernel address space.
(also, rename maxlen to seglen, because it was confusing)
This increases the CPU/memory copy cost by almost 50% on the affected
workloads. That will be solved by introducing a new set of pagecache write
aops in a subsequent patch.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 15:24:59 +07:00
|
|
|
static inline int fault_in_pages_readable(const char __user *uaddr, int size)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
volatile char c;
|
|
|
|
int ret;
|
|
|
|
|
mm: fix pagecache write deadlocks
Modify the core write() code so that it won't take a pagefault while holding a
lock on the pagecache page. There are a number of different deadlocks possible
if we try to do such a thing:
1. generic_buffered_write
2. lock_page
3. prepare_write
4. unlock_page+vmtruncate
5. copy_from_user
6. mmap_sem(r)
7. handle_mm_fault
8. lock_page (filemap_nopage)
9. commit_write
10. unlock_page
a. sys_munmap / sys_mlock / others
b. mmap_sem(w)
c. make_pages_present
d. get_user_pages
e. handle_mm_fault
f. lock_page (filemap_nopage)
2,8 - recursive deadlock if page is same
2,8;2,8 - ABBA deadlock is page is different
2,6;b,f - ABBA deadlock if page is same
The solution is as follows:
1. If we find the destination page is uptodate, continue as normal, but use
atomic usercopies which do not take pagefaults and do not zero the uncopied
tail of the destination. The destination is already uptodate, so we can
commit_write the full length even if there was a partial copy: it does not
matter that the tail was not modified, because if it is dirtied and written
back to disk it will not cause any problems (uptodate *means* that the
destination page is as new or newer than the copy on disk).
1a. The above requires that fault_in_pages_readable correctly returns access
information, because atomic usercopies cannot distinguish between
non-present pages in a readable mapping, from lack of a readable mapping.
2. If we find the destination page is non uptodate, unlock it (this could be
made slightly more optimal), then allocate a temporary page to copy the
source data into. Relock the destination page and continue with the copy.
However, instead of a usercopy (which might take a fault), copy the data
from the pinned temporary page via the kernel address space.
(also, rename maxlen to seglen, because it was confusing)
This increases the CPU/memory copy cost by almost 50% on the affected
workloads. That will be solved by introducing a new set of pagecache write
aops in a subsequent patch.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 15:24:59 +07:00
|
|
|
if (unlikely(size == 0))
|
|
|
|
return 0;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
ret = __get_user(c, uaddr);
|
|
|
|
if (ret == 0) {
|
|
|
|
const char __user *end = uaddr + size - 1;
|
|
|
|
|
|
|
|
if (((unsigned long)uaddr & PAGE_MASK) !=
|
2010-08-10 07:19:02 +07:00
|
|
|
((unsigned long)end & PAGE_MASK)) {
|
2012-03-26 00:47:41 +07:00
|
|
|
ret = __get_user(c, end);
|
2010-08-10 07:19:02 +07:00
|
|
|
(void)c;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
mm: fix pagecache write deadlocks
Modify the core write() code so that it won't take a pagefault while holding a
lock on the pagecache page. There are a number of different deadlocks possible
if we try to do such a thing:
1. generic_buffered_write
2. lock_page
3. prepare_write
4. unlock_page+vmtruncate
5. copy_from_user
6. mmap_sem(r)
7. handle_mm_fault
8. lock_page (filemap_nopage)
9. commit_write
10. unlock_page
a. sys_munmap / sys_mlock / others
b. mmap_sem(w)
c. make_pages_present
d. get_user_pages
e. handle_mm_fault
f. lock_page (filemap_nopage)
2,8 - recursive deadlock if page is same
2,8;2,8 - ABBA deadlock is page is different
2,6;b,f - ABBA deadlock if page is same
The solution is as follows:
1. If we find the destination page is uptodate, continue as normal, but use
atomic usercopies which do not take pagefaults and do not zero the uncopied
tail of the destination. The destination is already uptodate, so we can
commit_write the full length even if there was a partial copy: it does not
matter that the tail was not modified, because if it is dirtied and written
back to disk it will not cause any problems (uptodate *means* that the
destination page is as new or newer than the copy on disk).
1a. The above requires that fault_in_pages_readable correctly returns access
information, because atomic usercopies cannot distinguish between
non-present pages in a readable mapping, from lack of a readable mapping.
2. If we find the destination page is non uptodate, unlock it (this could be
made slightly more optimal), then allocate a temporary page to copy the
source data into. Relock the destination page and continue with the copy.
However, instead of a usercopy (which might take a fault), copy the data
from the pinned temporary page via the kernel address space.
(also, rename maxlen to seglen, because it was confusing)
This increases the CPU/memory copy cost by almost 50% on the affected
workloads. That will be solved by introducing a new set of pagecache write
aops in a subsequent patch.
Signed-off-by: Nick Piggin <npiggin@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 15:24:59 +07:00
|
|
|
return ret;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2012-03-26 00:47:41 +07:00
|
|
|
/*
|
|
|
|
* Multipage variants of the above prefault helpers, useful if more than
|
|
|
|
* PAGE_SIZE of data needs to be prefaulted. These are separate from the above
|
|
|
|
* functions (which only handle up to PAGE_SIZE) to avoid clobbering the
|
|
|
|
* filemap.c hotpaths.
|
|
|
|
*/
|
|
|
|
static inline int fault_in_multipages_writeable(char __user *uaddr, int size)
|
|
|
|
{
|
2012-05-30 05:06:14 +07:00
|
|
|
int ret = 0;
|
2012-04-14 23:03:10 +07:00
|
|
|
char __user *end = uaddr + size - 1;
|
2012-03-26 00:47:41 +07:00
|
|
|
|
|
|
|
if (unlikely(size == 0))
|
2012-05-30 05:06:14 +07:00
|
|
|
return ret;
|
2012-03-26 00:47:41 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Writing zeroes into userspace here is OK, because we know that if
|
|
|
|
* the zero gets there, we'll be overwriting it.
|
|
|
|
*/
|
|
|
|
while (uaddr <= end) {
|
|
|
|
ret = __put_user(0, uaddr);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
|
|
|
uaddr += PAGE_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check whether the range spilled into the next page. */
|
|
|
|
if (((unsigned long)uaddr & PAGE_MASK) ==
|
|
|
|
((unsigned long)end & PAGE_MASK))
|
|
|
|
ret = __put_user(0, end);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int fault_in_multipages_readable(const char __user *uaddr,
|
|
|
|
int size)
|
|
|
|
{
|
|
|
|
volatile char c;
|
2012-05-30 05:06:14 +07:00
|
|
|
int ret = 0;
|
2012-03-26 00:47:41 +07:00
|
|
|
const char __user *end = uaddr + size - 1;
|
|
|
|
|
|
|
|
if (unlikely(size == 0))
|
2012-05-30 05:06:14 +07:00
|
|
|
return ret;
|
2012-03-26 00:47:41 +07:00
|
|
|
|
|
|
|
while (uaddr <= end) {
|
|
|
|
ret = __get_user(c, uaddr);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
|
|
|
uaddr += PAGE_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check whether the range spilled into the next page. */
|
|
|
|
if (((unsigned long)uaddr & PAGE_MASK) ==
|
|
|
|
((unsigned long)end & PAGE_MASK)) {
|
|
|
|
ret = __get_user(c, end);
|
|
|
|
(void)c;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-08-02 17:01:03 +07:00
|
|
|
int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
|
|
|
|
pgoff_t index, gfp_t gfp_mask);
|
|
|
|
int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
|
|
|
|
pgoff_t index, gfp_t gfp_mask);
|
2011-03-23 06:30:53 +07:00
|
|
|
extern void delete_from_page_cache(struct page *page);
|
memcg: add per cgroup dirty page accounting
When modifying PG_Dirty on cached file pages, update the new
MEM_CGROUP_STAT_DIRTY counter. This is done in the same places where
global NR_FILE_DIRTY is managed. The new memcg stat is visible in the
per memcg memory.stat cgroupfs file. The most recent past attempt at
this was http://thread.gmane.org/gmane.linux.kernel.cgroups/8632
The new accounting supports future efforts to add per cgroup dirty
page throttling and writeback. It also helps an administrator break
down a container's memory usage and provides evidence to understand
memcg oom kills (the new dirty count is included in memcg oom kill
messages).
The ability to move page accounting between memcg
(memory.move_charge_at_immigrate) makes this accounting more
complicated than the global counter. The existing
mem_cgroup_{begin,end}_page_stat() lock is used to serialize move
accounting with stat updates.
Typical update operation:
memcg = mem_cgroup_begin_page_stat(page)
if (TestSetPageDirty()) {
[...]
mem_cgroup_update_page_stat(memcg)
}
mem_cgroup_end_page_stat(memcg)
Summary of mem_cgroup_end_page_stat() overhead:
- Without CONFIG_MEMCG it's a no-op
- With CONFIG_MEMCG and no inter memcg task movement, it's just
rcu_read_lock()
- With CONFIG_MEMCG and inter memcg task movement, it's
rcu_read_lock() + spin_lock_irqsave()
A memcg parameter is added to several routines because their callers
now grab mem_cgroup_begin_page_stat() which returns the memcg later
needed by for mem_cgroup_update_page_stat().
Because mem_cgroup_begin_page_stat() may disable interrupts, some
adjustments are needed:
- move __mark_inode_dirty() from __set_page_dirty() to its caller.
__mark_inode_dirty() locking does not want interrupts disabled.
- use spin_lock_irqsave(tree_lock) rather than spin_lock_irq() in
__delete_from_page_cache(), replace_page_cache_page(),
invalidate_complete_page2(), and __remove_mapping().
text data bss dec hex filename
8925147 1774832 1785856 12485835 be84cb vmlinux-!CONFIG_MEMCG-before
8925339 1774832 1785856 12486027 be858b vmlinux-!CONFIG_MEMCG-after
+192 text bytes
8965977 1784992 1785856 12536825 bf4bf9 vmlinux-CONFIG_MEMCG-before
8966750 1784992 1785856 12537598 bf4efe vmlinux-CONFIG_MEMCG-after
+773 text bytes
Performance tests run on v4.0-rc1-36-g4f671fe2f952. Lower is better for
all metrics, they're all wall clock or cycle counts. The read and write
fault benchmarks just measure fault time, they do not include I/O time.
* CONFIG_MEMCG not set:
baseline patched
kbuild 1m25.030000(+-0.088% 3 samples) 1m25.426667(+-0.120% 3 samples)
dd write 100 MiB 0.859211561 +-15.10% 0.874162885 +-15.03%
dd write 200 MiB 1.670653105 +-17.87% 1.669384764 +-11.99%
dd write 1000 MiB 8.434691190 +-14.15% 8.474733215 +-14.77%
read fault cycles 254.0(+-0.000% 10 samples) 253.0(+-0.000% 10 samples)
write fault cycles 2021.2(+-3.070% 10 samples) 1984.5(+-1.036% 10 samples)
* CONFIG_MEMCG=y root_memcg:
baseline patched
kbuild 1m25.716667(+-0.105% 3 samples) 1m25.686667(+-0.153% 3 samples)
dd write 100 MiB 0.855650830 +-14.90% 0.887557919 +-14.90%
dd write 200 MiB 1.688322953 +-12.72% 1.667682724 +-13.33%
dd write 1000 MiB 8.418601605 +-14.30% 8.673532299 +-15.00%
read fault cycles 266.0(+-0.000% 10 samples) 266.0(+-0.000% 10 samples)
write fault cycles 2051.7(+-1.349% 10 samples) 2049.6(+-1.686% 10 samples)
* CONFIG_MEMCG=y non-root_memcg:
baseline patched
kbuild 1m26.120000(+-0.273% 3 samples) 1m25.763333(+-0.127% 3 samples)
dd write 100 MiB 0.861723964 +-15.25% 0.818129350 +-14.82%
dd write 200 MiB 1.669887569 +-13.30% 1.698645885 +-13.27%
dd write 1000 MiB 8.383191730 +-14.65% 8.351742280 +-14.52%
read fault cycles 265.7(+-0.172% 10 samples) 267.0(+-0.000% 10 samples)
write fault cycles 2070.6(+-1.512% 10 samples) 2084.4(+-2.148% 10 samples)
As expected anon page faults are not affected by this patch.
tj: Updated to apply on top of the recent cancel_dirty_page() changes.
Signed-off-by: Sha Zhengju <handai.szj@gmail.com>
Signed-off-by: Greg Thelen <gthelen@google.com>
Signed-off-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-05-23 04:13:16 +07:00
|
|
|
extern void __delete_from_page_cache(struct page *page, void *shadow,
|
|
|
|
struct mem_cgroup *memcg);
|
2011-03-23 06:30:52 +07:00
|
|
|
int replace_page_cache_page(struct page *old, struct page *new, gfp_t gfp_mask);
|
2008-08-02 17:01:03 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Like add_to_page_cache_locked, but used to add newly allocated pages:
|
2008-10-19 10:26:57 +07:00
|
|
|
* the page is new, so we can just run __set_page_locked() against it.
|
2008-08-02 17:01:03 +07:00
|
|
|
*/
|
|
|
|
static inline int add_to_page_cache(struct page *page,
|
|
|
|
struct address_space *mapping, pgoff_t offset, gfp_t gfp_mask)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2008-10-19 10:26:57 +07:00
|
|
|
__set_page_locked(page);
|
2008-08-02 17:01:03 +07:00
|
|
|
error = add_to_page_cache_locked(page, mapping, offset, gfp_mask);
|
|
|
|
if (unlikely(error))
|
2008-10-19 10:26:57 +07:00
|
|
|
__clear_page_locked(page);
|
2008-08-02 17:01:03 +07:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2015-05-24 22:19:41 +07:00
|
|
|
static inline unsigned long dir_pages(struct inode *inode)
|
|
|
|
{
|
|
|
|
return (unsigned long)(inode->i_size + PAGE_CACHE_SIZE - 1) >>
|
|
|
|
PAGE_CACHE_SHIFT;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif /* _LINUX_PAGEMAP_H */
|