block: don't init rq fields unnecessarily
[linux-2.6.git] / block / blk-ioc.c
1 /*
2  * Functions related to io context handling
3  */
4 #include <linux/kernel.h>
5 #include <linux/module.h>
6 #include <linux/init.h>
7 #include <linux/bio.h>
8 #include <linux/blkdev.h>
9 #include <linux/bootmem.h>      /* for max_pfn/max_low_pfn */
10
11 #include "blk.h"
12
13 /*
14  * For io context allocations
15  */
16 static struct kmem_cache *iocontext_cachep;
17
18 static void cfq_dtor(struct io_context *ioc)
19 {
20         if (!hlist_empty(&ioc->cic_list)) {
21                 struct cfq_io_context *cic;
22
23                 cic = list_entry(ioc->cic_list.first, struct cfq_io_context,
24                                                                 cic_list);
25                 cic->dtor(ioc);
26         }
27 }
28
29 /*
30  * IO Context helper functions. put_io_context() returns 1 if there are no
31  * more users of this io context, 0 otherwise.
32  */
33 int put_io_context(struct io_context *ioc)
34 {
35         if (ioc == NULL)
36                 return 1;
37
38         BUG_ON(atomic_read(&ioc->refcount) == 0);
39
40         if (atomic_dec_and_test(&ioc->refcount)) {
41                 rcu_read_lock();
42                 if (ioc->aic && ioc->aic->dtor)
43                         ioc->aic->dtor(ioc->aic);
44                 cfq_dtor(ioc);
45                 rcu_read_unlock();
46
47                 kmem_cache_free(iocontext_cachep, ioc);
48                 return 1;
49         }
50         return 0;
51 }
52 EXPORT_SYMBOL(put_io_context);
53
54 static void cfq_exit(struct io_context *ioc)
55 {
56         rcu_read_lock();
57
58         if (!hlist_empty(&ioc->cic_list)) {
59                 struct cfq_io_context *cic;
60
61                 cic = list_entry(ioc->cic_list.first, struct cfq_io_context,
62                                                                 cic_list);
63                 cic->exit(ioc);
64         }
65         rcu_read_unlock();
66 }
67
68 /* Called by the exitting task */
69 void exit_io_context(void)
70 {
71         struct io_context *ioc;
72
73         task_lock(current);
74         ioc = current->io_context;
75         current->io_context = NULL;
76         task_unlock(current);
77
78         if (atomic_dec_and_test(&ioc->nr_tasks)) {
79                 if (ioc->aic && ioc->aic->exit)
80                         ioc->aic->exit(ioc->aic);
81                 cfq_exit(ioc);
82
83                 put_io_context(ioc);
84         }
85 }
86
87 struct io_context *alloc_io_context(gfp_t gfp_flags, int node)
88 {
89         struct io_context *ret;
90
91         ret = kmem_cache_alloc_node(iocontext_cachep, gfp_flags, node);
92         if (ret) {
93                 atomic_set(&ret->refcount, 1);
94                 atomic_set(&ret->nr_tasks, 1);
95                 spin_lock_init(&ret->lock);
96                 ret->ioprio_changed = 0;
97                 ret->ioprio = 0;
98                 ret->last_waited = jiffies; /* doesn't matter... */
99                 ret->nr_batch_requests = 0; /* because this is 0 */
100                 ret->aic = NULL;
101                 INIT_RADIX_TREE(&ret->radix_root, GFP_ATOMIC | __GFP_HIGH);
102                 INIT_HLIST_HEAD(&ret->cic_list);
103                 ret->ioc_data = NULL;
104         }
105
106         return ret;
107 }
108
109 /*
110  * If the current task has no IO context then create one and initialise it.
111  * Otherwise, return its existing IO context.
112  *
113  * This returned IO context doesn't have a specifically elevated refcount,
114  * but since the current task itself holds a reference, the context can be
115  * used in general code, so long as it stays within `current` context.
116  */
117 struct io_context *current_io_context(gfp_t gfp_flags, int node)
118 {
119         struct task_struct *tsk = current;
120         struct io_context *ret;
121
122         ret = tsk->io_context;
123         if (likely(ret))
124                 return ret;
125
126         ret = alloc_io_context(gfp_flags, node);
127         if (ret) {
128                 /* make sure set_task_ioprio() sees the settings above */
129                 smp_wmb();
130                 tsk->io_context = ret;
131         }
132
133         return ret;
134 }
135
136 /*
137  * If the current task has no IO context then create one and initialise it.
138  * If it does have a context, take a ref on it.
139  *
140  * This is always called in the context of the task which submitted the I/O.
141  */
142 struct io_context *get_io_context(gfp_t gfp_flags, int node)
143 {
144         struct io_context *ret = NULL;
145
146         /*
147          * Check for unlikely race with exiting task. ioc ref count is
148          * zero when ioc is being detached.
149          */
150         do {
151                 ret = current_io_context(gfp_flags, node);
152                 if (unlikely(!ret))
153                         break;
154         } while (!atomic_inc_not_zero(&ret->refcount));
155
156         return ret;
157 }
158 EXPORT_SYMBOL(get_io_context);
159
160 void copy_io_context(struct io_context **pdst, struct io_context **psrc)
161 {
162         struct io_context *src = *psrc;
163         struct io_context *dst = *pdst;
164
165         if (src) {
166                 BUG_ON(atomic_read(&src->refcount) == 0);
167                 atomic_inc(&src->refcount);
168                 put_io_context(dst);
169                 *pdst = src;
170         }
171 }
172 EXPORT_SYMBOL(copy_io_context);
173
174 static int __init blk_ioc_init(void)
175 {
176         iocontext_cachep = kmem_cache_create("blkdev_ioc",
177                         sizeof(struct io_context), 0, SLAB_PANIC, NULL);
178         return 0;
179 }
180 subsys_initcall(blk_ioc_init);