]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - drivers/staging/dst/trans.c
Merge branch 'for-2.6.32' of git://git.kernel.dk/linux-2.6-block
[linux-2.6.git] / drivers / staging / dst / trans.c
1 /*
2  * 2007+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
3  * All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  */
15
16 #include <linux/bio.h>
17 #include <linux/dst.h>
18 #include <linux/slab.h>
19 #include <linux/mempool.h>
20
21 /*
22  * Transaction memory pool size.
23  */
24 static int dst_mempool_num = 32;
25 module_param(dst_mempool_num, int, 0644);
26
27 /*
28  * Transaction tree management.
29  */
30 static inline int dst_trans_cmp(dst_gen_t gen, dst_gen_t new)
31 {
32         if (gen < new)
33                 return 1;
34         if (gen > new)
35                 return -1;
36         return 0;
37 }
38
39 struct dst_trans *dst_trans_search(struct dst_node *node, dst_gen_t gen)
40 {
41         struct rb_root *root = &node->trans_root;
42         struct rb_node *n = root->rb_node;
43         struct dst_trans *t, *ret = NULL;
44         int cmp;
45
46         while (n) {
47                 t = rb_entry(n, struct dst_trans, trans_entry);
48
49                 cmp = dst_trans_cmp(t->gen, gen);
50                 if (cmp < 0)
51                         n = n->rb_left;
52                 else if (cmp > 0)
53                         n = n->rb_right;
54                 else {
55                         ret = t;
56                         break;
57                 }
58         }
59
60         dprintk("%s: %s transaction: id: %llu.\n", __func__,
61                         (ret)?"found":"not found", gen);
62
63         return ret;
64 }
65
66 static int dst_trans_insert(struct dst_trans *new)
67 {
68         struct rb_root *root = &new->n->trans_root;
69         struct rb_node **n = &root->rb_node, *parent = NULL;
70         struct dst_trans *ret = NULL, *t;
71         int cmp;
72
73         while (*n) {
74                 parent = *n;
75
76                 t = rb_entry(parent, struct dst_trans, trans_entry);
77
78                 cmp = dst_trans_cmp(t->gen, new->gen);
79                 if (cmp < 0)
80                         n = &parent->rb_left;
81                 else if (cmp > 0)
82                         n = &parent->rb_right;
83                 else {
84                         ret = t;
85                         break;
86                 }
87         }
88
89         new->send_time = jiffies;
90         if (ret) {
91                 printk("%s: exist: old: gen: %llu, bio: %llu/%u, send_time: %lu, "
92                                 "new: gen: %llu, bio: %llu/%u, send_time: %lu.\n",
93                         __func__,
94                         ret->gen, (u64)ret->bio->bi_sector,
95                         ret->bio->bi_size, ret->send_time,
96                         new->gen, (u64)new->bio->bi_sector,
97                         new->bio->bi_size, new->send_time);
98                 return -EEXIST;
99         }
100
101         rb_link_node(&new->trans_entry, parent, n);
102         rb_insert_color(&new->trans_entry, root);
103
104         dprintk("%s: inserted: gen: %llu, bio: %llu/%u, send_time: %lu.\n",
105                 __func__, new->gen, (u64)new->bio->bi_sector,
106                 new->bio->bi_size, new->send_time);
107
108         return 0;
109 }
110
111 int dst_trans_remove_nolock(struct dst_trans *t)
112 {
113         struct dst_node *n = t->n;
114
115         if (t->trans_entry.rb_parent_color) {
116                 rb_erase(&t->trans_entry, &n->trans_root);
117                 t->trans_entry.rb_parent_color = 0;
118         }
119         return 0;
120 }
121
122 int dst_trans_remove(struct dst_trans *t)
123 {
124         int ret;
125         struct dst_node *n = t->n;
126
127         mutex_lock(&n->trans_lock);
128         ret = dst_trans_remove_nolock(t);
129         mutex_unlock(&n->trans_lock);
130
131         return ret;
132 }
133
134 /*
135  * When transaction is completed and there are no more users,
136  * we complete appriate block IO request with given error status.
137  */
138 void dst_trans_put(struct dst_trans *t)
139 {
140         if (atomic_dec_and_test(&t->refcnt)) {
141                 struct bio *bio = t->bio;
142
143                 dprintk("%s: completed t: %p, gen: %llu, bio: %p.\n",
144                                 __func__, t, t->gen, bio);
145
146                 bio_endio(bio, t->error);
147                 bio_put(bio);
148
149                 dst_node_put(t->n);
150                 mempool_free(t, t->n->trans_pool);
151         }
152 }
153
154 /*
155  * Process given block IO request: allocate transaction, insert it into the tree
156  * and send/schedule crypto processing.
157  */
158 int dst_process_bio(struct dst_node *n, struct bio *bio)
159 {
160         struct dst_trans *t;
161         int err = -ENOMEM;
162
163         t = mempool_alloc(n->trans_pool, GFP_NOFS);
164         if (!t)
165                 goto err_out_exit;
166
167         t->n = dst_node_get(n);
168         t->bio = bio;
169         t->error = 0;
170         t->retries = 0;
171         atomic_set(&t->refcnt, 1);
172         t->gen = atomic_long_inc_return(&n->gen);
173
174         t->enc = bio_data_dir(bio);
175         dst_bio_to_cmd(bio, &t->cmd, DST_IO, t->gen);
176
177         mutex_lock(&n->trans_lock);
178         err = dst_trans_insert(t);
179         mutex_unlock(&n->trans_lock);
180         if (err)
181                 goto err_out_free;
182
183         dprintk("%s: gen: %llu, bio: %llu/%u, dir/enc: %d, need_crypto: %d.\n",
184                         __func__, t->gen, (u64)bio->bi_sector,
185                         bio->bi_size, t->enc, dst_need_crypto(n));
186
187         if (dst_need_crypto(n) && t->enc)
188                 dst_trans_crypto(t);
189         else
190                 dst_trans_send(t);
191
192         return 0;
193
194 err_out_free:
195         dst_node_put(n);
196         mempool_free(t, n->trans_pool);
197 err_out_exit:
198         bio_endio(bio, err);
199         bio_put(bio);
200         return err;
201 }
202
203 /*
204  * Scan for timeout/stale transactions.
205  * Each transaction is being resent multiple times before error completion.
206  */
207 static void dst_trans_scan(struct work_struct *work)
208 {
209         struct dst_node *n = container_of(work, struct dst_node, trans_work.work);
210         struct rb_node *rb_node;
211         struct dst_trans *t;
212         unsigned long timeout = n->trans_scan_timeout;
213         int num = 10 * n->trans_max_retries;
214
215         mutex_lock(&n->trans_lock);
216
217         for (rb_node = rb_first(&n->trans_root); rb_node; ) {
218                 t = rb_entry(rb_node, struct dst_trans, trans_entry);
219
220                 if (timeout && time_after(t->send_time + timeout, jiffies)
221                                 && t->retries == 0)
222                         break;
223 #if 0
224                 dprintk("%s: t: %p, gen: %llu, n: %s, retries: %u, max: %u.\n",
225                         __func__, t, t->gen, n->name,
226                         t->retries, n->trans_max_retries);
227 #endif
228                 if (--num == 0)
229                         break;
230
231                 dst_trans_get(t);
232
233                 rb_node = rb_next(rb_node);
234
235                 if (timeout && (++t->retries < n->trans_max_retries)) {
236                         dst_trans_send(t);
237                 } else {
238                         t->error = -ETIMEDOUT;
239                         dst_trans_remove_nolock(t);
240                         dst_trans_put(t);
241                 }
242
243                 dst_trans_put(t);
244         }
245
246         mutex_unlock(&n->trans_lock);
247
248         /*
249          * If no timeout specified then system is in the middle of exiting process,
250          * so no need to reschedule scanning process again.
251          */
252         if (timeout) {
253                 if (!num)
254                         timeout = HZ;
255                 schedule_delayed_work(&n->trans_work, timeout);
256         }
257 }
258
259 /*
260  * Flush all transactions and mark them as timed out.
261  * Destroy transaction pools.
262  */
263 void dst_node_trans_exit(struct dst_node *n)
264 {
265         struct dst_trans *t;
266         struct rb_node *rb_node;
267
268         if (!n->trans_cache)
269                 return;
270
271         dprintk("%s: n: %p, cancelling the work.\n", __func__, n);
272         cancel_delayed_work_sync(&n->trans_work);
273         flush_scheduled_work();
274         dprintk("%s: n: %p, work has been cancelled.\n", __func__, n);
275
276         for (rb_node = rb_first(&n->trans_root); rb_node; ) {
277                 t = rb_entry(rb_node, struct dst_trans, trans_entry);
278
279                 dprintk("%s: t: %p, gen: %llu, n: %s.\n",
280                         __func__, t, t->gen, n->name);
281
282                 rb_node = rb_next(rb_node);
283
284                 t->error = -ETIMEDOUT;
285                 dst_trans_remove_nolock(t);
286                 dst_trans_put(t);
287         }
288
289         mempool_destroy(n->trans_pool);
290         kmem_cache_destroy(n->trans_cache);
291 }
292
293 /*
294  * Initialize transaction storage for given node.
295  * Transaction stores not only control information,
296  * but also network command and crypto data (if needed)
297  * to reduce number of allocations. Thus transaction size
298  * differs from node to node.
299  */
300 int dst_node_trans_init(struct dst_node *n, unsigned int size)
301 {
302         /*
303          * We need this, since node with given name can be dropped from the
304          * hash table, but be still alive, so subsequent creation of the node
305          * with the same name may collide with existing cache name.
306          */
307
308         snprintf(n->cache_name, sizeof(n->cache_name), "%s-%p", n->name, n);
309
310         n->trans_cache = kmem_cache_create(n->cache_name,
311                         size + n->crypto.crypto_attached_size,
312                         0, 0, NULL);
313         if (!n->trans_cache)
314                 goto err_out_exit;
315
316         n->trans_pool = mempool_create_slab_pool(dst_mempool_num, n->trans_cache);
317         if (!n->trans_pool)
318                 goto err_out_cache_destroy;
319
320         mutex_init(&n->trans_lock);
321         n->trans_root = RB_ROOT;
322
323         INIT_DELAYED_WORK(&n->trans_work, dst_trans_scan);
324         schedule_delayed_work(&n->trans_work, n->trans_scan_timeout);
325
326         dprintk("%s: n: %p, size: %u, crypto: %u.\n",
327                 __func__, n, size, n->crypto.crypto_attached_size);
328
329         return 0;
330
331 err_out_cache_destroy:
332         kmem_cache_destroy(n->trans_cache);
333 err_out_exit:
334         return -ENOMEM;
335 }