2008-01-24 07:52:45 +00:00
|
|
|
#ifndef IOCONTEXT_H
|
|
|
|
#define IOCONTEXT_H
|
|
|
|
|
2008-01-24 07:44:49 +00:00
|
|
|
#include <linux/radix-tree.h>
|
2008-04-02 12:31:02 +00:00
|
|
|
#include <linux/rcupdate.h>
|
2011-12-13 23:33:39 +00:00
|
|
|
#include <linux/workqueue.h>
|
2008-01-24 07:44:49 +00:00
|
|
|
|
2011-12-13 23:33:38 +00:00
|
|
|
enum {
|
2012-02-15 08:45:49 +00:00
|
|
|
ICQ_IOPRIO_CHANGED = 1 << 0,
|
|
|
|
ICQ_CGROUP_CHANGED = 1 << 1,
|
|
|
|
|
|
|
|
ICQ_CHANGED_MASK = ICQ_IOPRIO_CHANGED | ICQ_CGROUP_CHANGED,
|
2011-12-13 23:33:38 +00:00
|
|
|
};
|
|
|
|
|
2011-12-13 23:33:42 +00:00
|
|
|
/*
|
|
|
|
* An io_cq (icq) is association between an io_context (ioc) and a
|
|
|
|
* request_queue (q). This is used by elevators which need to track
|
|
|
|
* information per ioc - q pair.
|
|
|
|
*
|
|
|
|
* Elevator can request use of icq by setting elevator_type->icq_size and
|
|
|
|
* ->icq_align. Both size and align must be larger than that of struct
|
|
|
|
* io_cq and elevator can use the tail area for private information. The
|
|
|
|
* recommended way to do this is defining a struct which contains io_cq as
|
|
|
|
* the first member followed by private members and using its size and
|
|
|
|
* align. For example,
|
|
|
|
*
|
|
|
|
* struct snail_io_cq {
|
|
|
|
* struct io_cq icq;
|
|
|
|
* int poke_snail;
|
|
|
|
* int feed_snail;
|
|
|
|
* };
|
|
|
|
*
|
|
|
|
* struct elevator_type snail_elv_type {
|
|
|
|
* .ops = { ... },
|
|
|
|
* .icq_size = sizeof(struct snail_io_cq),
|
|
|
|
* .icq_align = __alignof__(struct snail_io_cq),
|
|
|
|
* ...
|
|
|
|
* };
|
|
|
|
*
|
|
|
|
* If icq_size is set, block core will manage icq's. All requests will
|
|
|
|
* have its ->elv.icq field set before elevator_ops->elevator_set_req_fn()
|
|
|
|
* is called and be holding a reference to the associated io_context.
|
|
|
|
*
|
|
|
|
* Whenever a new icq is created, elevator_ops->elevator_init_icq_fn() is
|
|
|
|
* called and, on destruction, ->elevator_exit_icq_fn(). Both functions
|
|
|
|
* are called with both the associated io_context and queue locks held.
|
|
|
|
*
|
|
|
|
* Elevator is allowed to lookup icq using ioc_lookup_icq() while holding
|
|
|
|
* queue lock but the returned icq is valid only until the queue lock is
|
|
|
|
* released. Elevators can not and should not try to create or destroy
|
|
|
|
* icq's.
|
|
|
|
*
|
|
|
|
* As icq's are linked from both ioc and q, the locking rules are a bit
|
|
|
|
* complex.
|
|
|
|
*
|
|
|
|
* - ioc lock nests inside q lock.
|
|
|
|
*
|
|
|
|
* - ioc->icq_list and icq->ioc_node are protected by ioc lock.
|
|
|
|
* q->icq_list and icq->q_node by q lock.
|
|
|
|
*
|
|
|
|
* - ioc->icq_tree and ioc->icq_hint are protected by ioc lock, while icq
|
|
|
|
* itself is protected by q lock. However, both the indexes and icq
|
|
|
|
* itself are also RCU managed and lookup can be performed holding only
|
|
|
|
* the q lock.
|
|
|
|
*
|
|
|
|
* - icq's are not reference counted. They are destroyed when either the
|
|
|
|
* ioc or q goes away. Each request with icq set holds an extra
|
|
|
|
* reference to ioc to ensure it stays until the request is completed.
|
|
|
|
*
|
|
|
|
* - Linking and unlinking icq's are performed while holding both ioc and q
|
|
|
|
* locks. Due to the lock ordering, q exit is simple but ioc exit
|
|
|
|
* requires reverse-order double lock dance.
|
|
|
|
*/
|
2011-12-13 23:33:41 +00:00
|
|
|
struct io_cq {
|
|
|
|
struct request_queue *q;
|
|
|
|
struct io_context *ioc;
|
2008-01-24 07:52:45 +00:00
|
|
|
|
2011-12-13 23:33:42 +00:00
|
|
|
/*
|
|
|
|
* q_node and ioc_node link io_cq through icq_list of q and ioc
|
|
|
|
* respectively. Both fields are unused once ioc_exit_icq() is
|
|
|
|
* called and shared with __rcu_icq_cache and __rcu_head which are
|
|
|
|
* used for RCU free of io_cq.
|
|
|
|
*/
|
|
|
|
union {
|
|
|
|
struct list_head q_node;
|
|
|
|
struct kmem_cache *__rcu_icq_cache;
|
|
|
|
};
|
|
|
|
union {
|
|
|
|
struct hlist_node ioc_node;
|
|
|
|
struct rcu_head __rcu_head;
|
|
|
|
};
|
2011-12-13 23:33:38 +00:00
|
|
|
|
2012-02-15 08:45:49 +00:00
|
|
|
unsigned int flags;
|
2008-01-24 07:52:45 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2008-01-24 07:53:35 +00:00
|
|
|
* I/O subsystem state of the associated processes. It is refcounted
|
|
|
|
* and kmalloc'ed. These could be shared between processes.
|
2008-01-24 07:52:45 +00:00
|
|
|
*/
|
|
|
|
struct io_context {
|
2009-06-10 19:57:06 +00:00
|
|
|
atomic_long_t refcount;
|
2008-01-24 07:53:35 +00:00
|
|
|
atomic_t nr_tasks;
|
|
|
|
|
|
|
|
/* all the fields below are protected by this lock */
|
|
|
|
spinlock_t lock;
|
2008-01-24 07:52:45 +00:00
|
|
|
|
|
|
|
unsigned short ioprio;
|
2009-12-03 17:59:42 +00:00
|
|
|
|
2008-01-24 07:52:45 +00:00
|
|
|
/*
|
|
|
|
* For request batching
|
|
|
|
*/
|
|
|
|
int nr_batch_requests; /* Number of requests left in the batch */
|
2010-02-26 13:00:43 +00:00
|
|
|
unsigned long last_waited; /* Time last woken after wait for request */
|
2008-01-24 07:52:45 +00:00
|
|
|
|
2011-12-13 23:33:41 +00:00
|
|
|
struct radix_tree_root icq_tree;
|
|
|
|
struct io_cq __rcu *icq_hint;
|
|
|
|
struct hlist_head icq_list;
|
2011-12-13 23:33:39 +00:00
|
|
|
|
|
|
|
struct work_struct release_work;
|
2008-01-24 07:52:45 +00:00
|
|
|
};
|
|
|
|
|
2008-01-24 07:53:35 +00:00
|
|
|
static inline struct io_context *ioc_task_link(struct io_context *ioc)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* if ref count is zero, don't allow sharing (ioc is going away, it's
|
|
|
|
* a race).
|
|
|
|
*/
|
2009-06-10 19:57:06 +00:00
|
|
|
if (ioc && atomic_long_inc_not_zero(&ioc->refcount)) {
|
2009-07-31 06:55:48 +00:00
|
|
|
atomic_inc(&ioc->nr_tasks);
|
2008-01-24 07:53:35 +00:00
|
|
|
return ioc;
|
2008-04-15 07:25:33 +00:00
|
|
|
}
|
2008-01-24 07:53:35 +00:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-12-04 13:52:42 +00:00
|
|
|
struct task_struct;
|
2008-06-30 18:42:08 +00:00
|
|
|
#ifdef CONFIG_BLOCK
|
2012-02-07 06:51:30 +00:00
|
|
|
void put_io_context(struct io_context *ioc);
|
2009-12-04 13:52:42 +00:00
|
|
|
void exit_io_context(struct task_struct *task);
|
block: make ioc get/put interface more conventional and fix race on alloction
Ignoring copy_io() during fork, io_context can be allocated from two
places - current_io_context() and set_task_ioprio(). The former is
always called from local task while the latter can be called from
different task. The synchornization between them are peculiar and
dubious.
* current_io_context() doesn't grab task_lock() and assumes that if it
saw %NULL ->io_context, it would stay that way until allocation and
assignment is complete. It has smp_wmb() between alloc/init and
assignment.
* set_task_ioprio() grabs task_lock() for assignment and does
smp_read_barrier_depends() between "ioc = task->io_context" and "if
(ioc)". Unfortunately, this doesn't achieve anything - the latter
is not a dependent load of the former. ie, if ioc itself were being
dereferenced "ioc->xxx", it would mean something (not sure what tho)
but as the code currently stands, the dependent read barrier is
noop.
As only one of the the two test-assignment sequences is task_lock()
protected, the task_lock() can't do much about race between the two.
Nothing prevents current_io_context() and set_task_ioprio() allocating
its own ioc for the same task and overwriting the other's.
Also, set_task_ioprio() can race with exiting task and create a new
ioc after exit_io_context() is finished.
ioc get/put doesn't have any reason to be complex. The only hot path
is accessing the existing ioc of %current, which is simple to achieve
given that ->io_context is never destroyed as long as the task is
alive. All other paths can happily go through task_lock() like all
other task sub structures without impacting anything.
This patch updates ioc get/put so that it becomes more conventional.
* alloc_io_context() is replaced with get_task_io_context(). This is
the only interface which can acquire access to ioc of another task.
On return, the caller has an explicit reference to the object which
should be put using put_io_context() afterwards.
* The functionality of current_io_context() remains the same but when
creating a new ioc, it shares the code path with
get_task_io_context() and always goes through task_lock().
* get_io_context() now means incrementing ref on an ioc which the
caller already has access to (be that an explicit refcnt or implicit
%current one).
* PF_EXITING inhibits creation of new io_context and once
exit_io_context() is finished, it's guaranteed that both ioc
acquisition functions return %NULL.
* All users are updated. Most are trivial but
smp_read_barrier_depends() removal from cfq_get_io_context() needs a
bit of explanation. I suppose the original intention was to ensure
ioc->ioprio is visible when set_task_ioprio() allocates new
io_context and installs it; however, this wouldn't have worked
because set_task_ioprio() doesn't have wmb between init and install.
There are other problems with this which will be fixed in another
patch.
* While at it, use NUMA_NO_NODE instead of -1 for wildcard node
specification.
-v2: Vivek spotted contamination from debug patch. Removed.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2011-12-13 23:33:38 +00:00
|
|
|
struct io_context *get_task_io_context(struct task_struct *task,
|
|
|
|
gfp_t gfp_flags, int node);
|
2011-12-13 23:33:38 +00:00
|
|
|
void ioc_ioprio_changed(struct io_context *ioc, int ioprio);
|
|
|
|
void ioc_cgroup_changed(struct io_context *ioc);
|
2012-02-15 08:45:49 +00:00
|
|
|
unsigned int icq_get_changed(struct io_cq *icq);
|
2008-06-30 18:42:08 +00:00
|
|
|
#else
|
|
|
|
struct io_context;
|
2012-02-07 06:51:30 +00:00
|
|
|
static inline void put_io_context(struct io_context *ioc) { }
|
2011-12-13 23:33:37 +00:00
|
|
|
static inline void exit_io_context(struct task_struct *task) { }
|
2008-06-30 18:42:08 +00:00
|
|
|
#endif
|
|
|
|
|
2008-01-24 07:52:45 +00:00
|
|
|
#endif
|