Merge tag 'dmaengine-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw...
[linux-2.6-block.git] / include / linux / iocontext.h
CommitLineData
fd0928df
JA
1#ifndef IOCONTEXT_H
2#define IOCONTEXT_H
3
4ac845a2 4#include <linux/radix-tree.h>
34e6bbf2 5#include <linux/rcupdate.h>
b2efa052 6#include <linux/workqueue.h>
4ac845a2 7
dc86900e 8enum {
d705ae6b
TH
9 ICQ_IOPRIO_CHANGED = 1 << 0,
10 ICQ_CGROUP_CHANGED = 1 << 1,
621032ad 11 ICQ_EXITED = 1 << 2,
d705ae6b
TH
12
13 ICQ_CHANGED_MASK = ICQ_IOPRIO_CHANGED | ICQ_CGROUP_CHANGED,
dc86900e
TH
14};
15
f1f8cc94
TH
16/*
17 * An io_cq (icq) is association between an io_context (ioc) and a
18 * request_queue (q). This is used by elevators which need to track
19 * information per ioc - q pair.
20 *
21 * Elevator can request use of icq by setting elevator_type->icq_size and
22 * ->icq_align. Both size and align must be larger than that of struct
23 * io_cq and elevator can use the tail area for private information. The
24 * recommended way to do this is defining a struct which contains io_cq as
25 * the first member followed by private members and using its size and
26 * align. For example,
27 *
28 * struct snail_io_cq {
29 * struct io_cq icq;
30 * int poke_snail;
31 * int feed_snail;
32 * };
33 *
34 * struct elevator_type snail_elv_type {
35 * .ops = { ... },
36 * .icq_size = sizeof(struct snail_io_cq),
37 * .icq_align = __alignof__(struct snail_io_cq),
38 * ...
39 * };
40 *
41 * If icq_size is set, block core will manage icq's. All requests will
42 * have its ->elv.icq field set before elevator_ops->elevator_set_req_fn()
43 * is called and be holding a reference to the associated io_context.
44 *
45 * Whenever a new icq is created, elevator_ops->elevator_init_icq_fn() is
46 * called and, on destruction, ->elevator_exit_icq_fn(). Both functions
47 * are called with both the associated io_context and queue locks held.
48 *
49 * Elevator is allowed to lookup icq using ioc_lookup_icq() while holding
50 * queue lock but the returned icq is valid only until the queue lock is
51 * released. Elevators can not and should not try to create or destroy
52 * icq's.
53 *
54 * As icq's are linked from both ioc and q, the locking rules are a bit
55 * complex.
56 *
57 * - ioc lock nests inside q lock.
58 *
59 * - ioc->icq_list and icq->ioc_node are protected by ioc lock.
60 * q->icq_list and icq->q_node by q lock.
61 *
62 * - ioc->icq_tree and ioc->icq_hint are protected by ioc lock, while icq
63 * itself is protected by q lock. However, both the indexes and icq
64 * itself are also RCU managed and lookup can be performed holding only
65 * the q lock.
66 *
67 * - icq's are not reference counted. They are destroyed when either the
68 * ioc or q goes away. Each request with icq set holds an extra
69 * reference to ioc to ensure it stays until the request is completed.
70 *
71 * - Linking and unlinking icq's are performed while holding both ioc and q
72 * locks. Due to the lock ordering, q exit is simple but ioc exit
73 * requires reverse-order double lock dance.
74 */
c5869807
TH
75struct io_cq {
76 struct request_queue *q;
77 struct io_context *ioc;
fd0928df 78
7e5a8794
TH
79 /*
80 * q_node and ioc_node link io_cq through icq_list of q and ioc
81 * respectively. Both fields are unused once ioc_exit_icq() is
82 * called and shared with __rcu_icq_cache and __rcu_head which are
83 * used for RCU free of io_cq.
84 */
85 union {
86 struct list_head q_node;
87 struct kmem_cache *__rcu_icq_cache;
88 };
89 union {
90 struct hlist_node ioc_node;
91 struct rcu_head __rcu_head;
92 };
dc86900e 93
d705ae6b 94 unsigned int flags;
fd0928df
JA
95};
96
97/*
d38ecf93
JA
98 * I/O subsystem state of the associated processes. It is refcounted
99 * and kmalloc'ed. These could be shared between processes.
fd0928df
JA
100 */
101struct io_context {
d9c7d394 102 atomic_long_t refcount;
d38ecf93
JA
103 atomic_t nr_tasks;
104
105 /* all the fields below are protected by this lock */
106 spinlock_t lock;
fd0928df
JA
107
108 unsigned short ioprio;
31e4c28d 109
fd0928df
JA
110 /*
111 * For request batching
112 */
fd0928df 113 int nr_batch_requests; /* Number of requests left in the batch */
58c24a61 114 unsigned long last_waited; /* Time last woken after wait for request */
fd0928df 115
c5869807
TH
116 struct radix_tree_root icq_tree;
117 struct io_cq __rcu *icq_hint;
118 struct hlist_head icq_list;
b2efa052
TH
119
120 struct work_struct release_work;
fd0928df
JA
121};
122
d38ecf93
JA
123static inline struct io_context *ioc_task_link(struct io_context *ioc)
124{
125 /*
126 * if ref count is zero, don't allow sharing (ioc is going away, it's
127 * a race).
128 */
d9c7d394 129 if (ioc && atomic_long_inc_not_zero(&ioc->refcount)) {
cbb4f264 130 atomic_inc(&ioc->nr_tasks);
d38ecf93 131 return ioc;
d237e5c7 132 }
d38ecf93
JA
133
134 return NULL;
135}
136
b69f2292 137struct task_struct;
da9cbc87 138#ifdef CONFIG_BLOCK
11a3122f 139void put_io_context(struct io_context *ioc);
b69f2292 140void exit_io_context(struct task_struct *task);
6e736be7
TH
141struct io_context *get_task_io_context(struct task_struct *task,
142 gfp_t gfp_flags, int node);
dc86900e
TH
143void ioc_ioprio_changed(struct io_context *ioc, int ioprio);
144void ioc_cgroup_changed(struct io_context *ioc);
d705ae6b 145unsigned int icq_get_changed(struct io_cq *icq);
da9cbc87 146#else
da9cbc87 147struct io_context;
11a3122f 148static inline void put_io_context(struct io_context *ioc) { }
42ec57a8 149static inline void exit_io_context(struct task_struct *task) { }
da9cbc87
JA
150#endif
151
fd0928df 152#endif