mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
![Matthew Wilcox](/assets/img/avatar_default.png)
Patch series "XArray", v9. (First part thereof). This patchset is, I believe, appropriate for merging for 4.17. It contains the XArray implementation, to eventually replace the radix tree, and converts the page cache to use it. This conversion keeps the radix tree and XArray data structures in sync at all times. That allows us to convert the page cache one function at a time and should allow for easier bisection. Other than renaming some elements of the structures, the data structures are fundamentally unchanged; a radix tree walk and an XArray walk will touch the same number of cachelines. I have changes planned to the XArray data structure, but those will happen in future patches. Improvements the XArray has over the radix tree: - The radix tree provides operations like other trees do; 'insert' and 'delete'. But what most users really want is an automatically resizing array, and so it makes more sense to give users an API that is like an array -- 'load' and 'store'. We still have an 'insert' operation for users that really want that semantic. - The XArray considers locking as part of its API. This simplifies a lot of users who formerly had to manage their own locking just for the radix tree. It also improves code generation as we can now tell RCU that we're holding a lock and it doesn't need to generate as much fencing code. The other advantage is that tree nodes can be moved (not yet implemented). - GFP flags are now parameters to calls which may need to allocate memory. The radix tree forced users to decide what the allocation flags would be at creation time. It's much clearer to specify them at allocation time. - Memory is not preloaded; we don't tie up dozens of pages on the off chance that the slab allocator fails. Instead, we drop the lock, allocate a new node and retry the operation. We have to convert all the radix tree, IDA and IDR preload users before we can realise this benefit, but I have not yet found a user which cannot be converted. - The XArray provides a cmpxchg operation. The radix tree forces users to roll their own (and at least four have). - Iterators take a 'max' parameter. That simplifies many users and will reduce the amount of iteration done. - Iteration can proceed backwards. We only have one user for this, but since it's called as part of the pagefault readahead algorithm, that seemed worth mentioning. - RCU-protected pointers are not exposed as part of the API. There are some fun bugs where the page cache forgets to use rcu_dereference() in the current codebase. - Value entries gain an extra bit compared to radix tree exceptional entries. That gives us the extra bit we need to put huge page swap entries in the page cache. - Some iterators now take a 'filter' argument instead of having separate iterators for tagged/untagged iterations. The page cache is improved by this: - Shorter, easier to read code - More efficient iterations - Reduction in size of struct address_space - Fewer walks from the top of the data structure; the XArray API encourages staying at the leaf node and conducting operations there. This patch (of 8): None of these bits may be used for slab allocations, so we can use them as radix tree flags as long as we mask them off before passing them to the slab allocator. Move the IDR flag from the high bits to the GFP_ZONEMASK bits. Link: http://lkml.kernel.org/r/20180313132639.17387-3-willy@infradead.org Signed-off-by: Matthew Wilcox <mawilcox@microsoft.com> Acked-by: Jeff Layton <jlayton@kernel.org> Cc: Darrick J. Wong <darrick.wong@oracle.com> Cc: Dave Chinner <david@fromorbit.com> Cc: Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp> Cc: Will Deacon <will.deacon@arm.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
257 lines
7.2 KiB
C
257 lines
7.2 KiB
C
/*
|
|
* include/linux/idr.h
|
|
*
|
|
* 2002-10-18 written by Jim Houston jim.houston@ccur.com
|
|
* Copyright (C) 2002 by Concurrent Computer Corporation
|
|
* Distributed under the GNU GPL license version 2.
|
|
*
|
|
* Small id to pointer translation service avoiding fixed sized
|
|
* tables.
|
|
*/
|
|
|
|
#ifndef __IDR_H__
|
|
#define __IDR_H__
|
|
|
|
#include <linux/radix-tree.h>
|
|
#include <linux/gfp.h>
|
|
#include <linux/percpu.h>
|
|
|
|
struct idr {
|
|
struct radix_tree_root idr_rt;
|
|
unsigned int idr_base;
|
|
unsigned int idr_next;
|
|
};
|
|
|
|
/*
|
|
* The IDR API does not expose the tagging functionality of the radix tree
|
|
* to users. Use tag 0 to track whether a node has free space below it.
|
|
*/
|
|
#define IDR_FREE 0
|
|
|
|
/* Set the IDR flag and the IDR_FREE tag */
|
|
#define IDR_RT_MARKER (ROOT_IS_IDR | (__force gfp_t) \
|
|
(1 << (ROOT_TAG_SHIFT + IDR_FREE)))
|
|
|
|
#define IDR_INIT_BASE(base) { \
|
|
.idr_rt = RADIX_TREE_INIT(IDR_RT_MARKER), \
|
|
.idr_base = (base), \
|
|
.idr_next = 0, \
|
|
}
|
|
|
|
/**
|
|
* IDR_INIT() - Initialise an IDR.
|
|
*
|
|
* A freshly-initialised IDR contains no IDs.
|
|
*/
|
|
#define IDR_INIT IDR_INIT_BASE(0)
|
|
|
|
/**
|
|
* DEFINE_IDR() - Define a statically-allocated IDR
|
|
* @name: Name of IDR
|
|
*
|
|
* An IDR defined using this macro is ready for use with no additional
|
|
* initialisation required. It contains no IDs.
|
|
*/
|
|
#define DEFINE_IDR(name) struct idr name = IDR_INIT
|
|
|
|
/**
|
|
* idr_get_cursor - Return the current position of the cyclic allocator
|
|
* @idr: idr handle
|
|
*
|
|
* The value returned is the value that will be next returned from
|
|
* idr_alloc_cyclic() if it is free (otherwise the search will start from
|
|
* this position).
|
|
*/
|
|
static inline unsigned int idr_get_cursor(const struct idr *idr)
|
|
{
|
|
return READ_ONCE(idr->idr_next);
|
|
}
|
|
|
|
/**
|
|
* idr_set_cursor - Set the current position of the cyclic allocator
|
|
* @idr: idr handle
|
|
* @val: new position
|
|
*
|
|
* The next call to idr_alloc_cyclic() will return @val if it is free
|
|
* (otherwise the search will start from this position).
|
|
*/
|
|
static inline void idr_set_cursor(struct idr *idr, unsigned int val)
|
|
{
|
|
WRITE_ONCE(idr->idr_next, val);
|
|
}
|
|
|
|
/**
|
|
* DOC: idr sync
|
|
* idr synchronization (stolen from radix-tree.h)
|
|
*
|
|
* idr_find() is able to be called locklessly, using RCU. The caller must
|
|
* ensure calls to this function are made within rcu_read_lock() regions.
|
|
* Other readers (lock-free or otherwise) and modifications may be running
|
|
* concurrently.
|
|
*
|
|
* It is still required that the caller manage the synchronization and
|
|
* lifetimes of the items. So if RCU lock-free lookups are used, typically
|
|
* this would mean that the items have their own locks, or are amenable to
|
|
* lock-free access; and that the items are freed by RCU (or only freed after
|
|
* having been deleted from the idr tree *and* a synchronize_rcu() grace
|
|
* period).
|
|
*/
|
|
|
|
void idr_preload(gfp_t gfp_mask);
|
|
|
|
int idr_alloc(struct idr *, void *ptr, int start, int end, gfp_t);
|
|
int __must_check idr_alloc_u32(struct idr *, void *ptr, u32 *id,
|
|
unsigned long max, gfp_t);
|
|
int idr_alloc_cyclic(struct idr *, void *ptr, int start, int end, gfp_t);
|
|
void *idr_remove(struct idr *, unsigned long id);
|
|
void *idr_find(const struct idr *, unsigned long id);
|
|
int idr_for_each(const struct idr *,
|
|
int (*fn)(int id, void *p, void *data), void *data);
|
|
void *idr_get_next(struct idr *, int *nextid);
|
|
void *idr_get_next_ul(struct idr *, unsigned long *nextid);
|
|
void *idr_replace(struct idr *, void *, unsigned long id);
|
|
void idr_destroy(struct idr *);
|
|
|
|
/**
|
|
* idr_init_base() - Initialise an IDR.
|
|
* @idr: IDR handle.
|
|
* @base: The base value for the IDR.
|
|
*
|
|
* This variation of idr_init() creates an IDR which will allocate IDs
|
|
* starting at %base.
|
|
*/
|
|
static inline void idr_init_base(struct idr *idr, int base)
|
|
{
|
|
INIT_RADIX_TREE(&idr->idr_rt, IDR_RT_MARKER);
|
|
idr->idr_base = base;
|
|
idr->idr_next = 0;
|
|
}
|
|
|
|
/**
|
|
* idr_init() - Initialise an IDR.
|
|
* @idr: IDR handle.
|
|
*
|
|
* Initialise a dynamically allocated IDR. To initialise a
|
|
* statically allocated IDR, use DEFINE_IDR().
|
|
*/
|
|
static inline void idr_init(struct idr *idr)
|
|
{
|
|
idr_init_base(idr, 0);
|
|
}
|
|
|
|
/**
|
|
* idr_is_empty() - Are there any IDs allocated?
|
|
* @idr: IDR handle.
|
|
*
|
|
* Return: %true if any IDs have been allocated from this IDR.
|
|
*/
|
|
static inline bool idr_is_empty(const struct idr *idr)
|
|
{
|
|
return radix_tree_empty(&idr->idr_rt) &&
|
|
radix_tree_tagged(&idr->idr_rt, IDR_FREE);
|
|
}
|
|
|
|
/**
|
|
* idr_preload_end - end preload section started with idr_preload()
|
|
*
|
|
* Each idr_preload() should be matched with an invocation of this
|
|
* function. See idr_preload() for details.
|
|
*/
|
|
static inline void idr_preload_end(void)
|
|
{
|
|
preempt_enable();
|
|
}
|
|
|
|
/**
|
|
* idr_for_each_entry() - Iterate over an IDR's elements of a given type.
|
|
* @idr: IDR handle.
|
|
* @entry: The type * to use as cursor
|
|
* @id: Entry ID.
|
|
*
|
|
* @entry and @id do not need to be initialized before the loop, and
|
|
* after normal termination @entry is left with the value NULL. This
|
|
* is convenient for a "not found" value.
|
|
*/
|
|
#define idr_for_each_entry(idr, entry, id) \
|
|
for (id = 0; ((entry) = idr_get_next(idr, &(id))) != NULL; ++id)
|
|
|
|
/**
|
|
* idr_for_each_entry_ul() - Iterate over an IDR's elements of a given type.
|
|
* @idr: IDR handle.
|
|
* @entry: The type * to use as cursor.
|
|
* @id: Entry ID.
|
|
*
|
|
* @entry and @id do not need to be initialized before the loop, and
|
|
* after normal termination @entry is left with the value NULL. This
|
|
* is convenient for a "not found" value.
|
|
*/
|
|
#define idr_for_each_entry_ul(idr, entry, id) \
|
|
for (id = 0; ((entry) = idr_get_next_ul(idr, &(id))) != NULL; ++id)
|
|
|
|
/**
|
|
* idr_for_each_entry_continue() - Continue iteration over an IDR's elements of a given type
|
|
* @idr: IDR handle.
|
|
* @entry: The type * to use as a cursor.
|
|
* @id: Entry ID.
|
|
*
|
|
* Continue to iterate over entries, continuing after the current position.
|
|
*/
|
|
#define idr_for_each_entry_continue(idr, entry, id) \
|
|
for ((entry) = idr_get_next((idr), &(id)); \
|
|
entry; \
|
|
++id, (entry) = idr_get_next((idr), &(id)))
|
|
|
|
/*
|
|
* IDA - IDR based id allocator, use when translation from id to
|
|
* pointer isn't necessary.
|
|
*/
|
|
#define IDA_CHUNK_SIZE 128 /* 128 bytes per chunk */
|
|
#define IDA_BITMAP_LONGS (IDA_CHUNK_SIZE / sizeof(long))
|
|
#define IDA_BITMAP_BITS (IDA_BITMAP_LONGS * sizeof(long) * 8)
|
|
|
|
struct ida_bitmap {
|
|
unsigned long bitmap[IDA_BITMAP_LONGS];
|
|
};
|
|
|
|
DECLARE_PER_CPU(struct ida_bitmap *, ida_bitmap);
|
|
|
|
struct ida {
|
|
struct radix_tree_root ida_rt;
|
|
};
|
|
|
|
#define IDA_INIT { \
|
|
.ida_rt = RADIX_TREE_INIT(IDR_RT_MARKER | GFP_NOWAIT), \
|
|
}
|
|
#define DEFINE_IDA(name) struct ida name = IDA_INIT
|
|
|
|
int ida_pre_get(struct ida *ida, gfp_t gfp_mask);
|
|
int ida_get_new_above(struct ida *ida, int starting_id, int *p_id);
|
|
void ida_remove(struct ida *ida, int id);
|
|
void ida_destroy(struct ida *ida);
|
|
|
|
int ida_simple_get(struct ida *ida, unsigned int start, unsigned int end,
|
|
gfp_t gfp_mask);
|
|
void ida_simple_remove(struct ida *ida, unsigned int id);
|
|
|
|
static inline void ida_init(struct ida *ida)
|
|
{
|
|
INIT_RADIX_TREE(&ida->ida_rt, IDR_RT_MARKER | GFP_NOWAIT);
|
|
}
|
|
|
|
/**
|
|
* ida_get_new - allocate new ID
|
|
* @ida: idr handle
|
|
* @p_id: pointer to the allocated handle
|
|
*
|
|
* Simple wrapper around ida_get_new_above() w/ @starting_id of zero.
|
|
*/
|
|
static inline int ida_get_new(struct ida *ida, int *p_id)
|
|
{
|
|
return ida_get_new_above(ida, 0, p_id);
|
|
}
|
|
|
|
static inline bool ida_is_empty(const struct ida *ida)
|
|
{
|
|
return radix_tree_empty(&ida->ida_rt);
|
|
}
|
|
#endif /* __IDR_H__ */
|