Merge branch 'fix/asoc' into topic/asoc
[linux-2.6] / drivers / staging / pohmelfs / mcache.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/module.h>
17 #include <linux/slab.h>
18 #include <linux/mempool.h>
19
20 #include "netfs.h"
21
22 static struct kmem_cache *pohmelfs_mcache_cache;
23 static mempool_t *pohmelfs_mcache_pool;
24
25 static inline int pohmelfs_mcache_cmp(u64 gen, u64 new)
26 {
27         if (gen < new)
28                 return 1;
29         if (gen > new)
30                 return -1;
31         return 0;
32 }
33
34 struct pohmelfs_mcache *pohmelfs_mcache_search(struct pohmelfs_sb *psb, u64 gen)
35 {
36         struct rb_root *root = &psb->mcache_root;
37         struct rb_node *n = root->rb_node;
38         struct pohmelfs_mcache *tmp, *ret = NULL;
39         int cmp;
40
41         while (n) {
42                 tmp = rb_entry(n, struct pohmelfs_mcache, mcache_entry);
43
44                 cmp = pohmelfs_mcache_cmp(tmp->gen, gen);
45                 if (cmp < 0)
46                         n = n->rb_left;
47                 else if (cmp > 0)
48                         n = n->rb_right;
49                 else {
50                         ret = tmp;
51                         pohmelfs_mcache_get(ret);
52                         break;
53                 }
54         }
55
56         return ret;
57 }
58
59 static int pohmelfs_mcache_insert(struct pohmelfs_sb *psb, struct pohmelfs_mcache *m)
60 {
61         struct rb_root *root = &psb->mcache_root;
62         struct rb_node **n = &root->rb_node, *parent = NULL;
63         struct pohmelfs_mcache *ret = NULL, *tmp;
64         int cmp;
65
66         while (*n) {
67                 parent = *n;
68
69                 tmp = rb_entry(parent, struct pohmelfs_mcache, mcache_entry);
70
71                 cmp = pohmelfs_mcache_cmp(tmp->gen, m->gen);
72                 if (cmp < 0)
73                         n = &parent->rb_left;
74                 else if (cmp > 0)
75                         n = &parent->rb_right;
76                 else {
77                         ret = tmp;
78                         break;
79                 }
80         }
81
82         if (ret)
83                 return -EEXIST;
84
85         rb_link_node(&m->mcache_entry, parent, n);
86         rb_insert_color(&m->mcache_entry, root);
87
88         return 0;
89 }
90
91 static int pohmelfs_mcache_remove(struct pohmelfs_sb *psb, struct pohmelfs_mcache *m)
92 {
93         if (m && m->mcache_entry.rb_parent_color) {
94                 rb_erase(&m->mcache_entry, &psb->mcache_root);
95                 m->mcache_entry.rb_parent_color = 0;
96                 return 1;
97         }
98         return 0;
99 }
100
101 void pohmelfs_mcache_remove_locked(struct pohmelfs_sb *psb, struct pohmelfs_mcache *m)
102 {
103         mutex_lock(&psb->mcache_lock);
104         pohmelfs_mcache_remove(psb, m);
105         mutex_unlock(&psb->mcache_lock);
106 }
107
108 struct pohmelfs_mcache *pohmelfs_mcache_alloc(struct pohmelfs_sb *psb, u64 start,
109                 unsigned int size, void *data)
110 {
111         struct pohmelfs_mcache *m;
112         int err = -ENOMEM;
113
114         m = mempool_alloc(pohmelfs_mcache_pool, GFP_KERNEL);
115         if (!m)
116                 goto err_out_exit;
117
118         init_completion(&m->complete);
119         m->err = 0;
120         atomic_set(&m->refcnt, 1);
121         m->data = data;
122         m->start = start;
123         m->size = size;
124         m->gen = atomic_long_inc_return(&psb->mcache_gen);
125
126         mutex_lock(&psb->mcache_lock);
127         err = pohmelfs_mcache_insert(psb, m);
128         mutex_unlock(&psb->mcache_lock);
129         if (err)
130                 goto err_out_free;
131
132         return m;
133
134 err_out_free:
135         mempool_free(m, pohmelfs_mcache_pool);
136 err_out_exit:
137         return ERR_PTR(err);
138 }
139
140 void pohmelfs_mcache_free(struct pohmelfs_sb *psb, struct pohmelfs_mcache *m)
141 {
142         pohmelfs_mcache_remove_locked(psb, m);
143
144         mempool_free(m, pohmelfs_mcache_pool);
145 }
146
147 int __init pohmelfs_mcache_init(void)
148 {
149         pohmelfs_mcache_cache = kmem_cache_create("pohmelfs_mcache_cache",
150                                 sizeof(struct pohmelfs_mcache),
151                                 0, (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD), NULL);
152         if (!pohmelfs_mcache_cache)
153                 goto err_out_exit;
154
155         pohmelfs_mcache_pool = mempool_create_slab_pool(256, pohmelfs_mcache_cache);
156         if (!pohmelfs_mcache_pool)
157                 goto err_out_free;
158
159         return 0;
160
161 err_out_free:
162         kmem_cache_destroy(pohmelfs_mcache_cache);
163 err_out_exit:
164         return -ENOMEM;
165 }
166
167 void pohmelfs_mcache_exit(void)
168 {
169         mempool_destroy(pohmelfs_mcache_pool);
170         kmem_cache_destroy(pohmelfs_mcache_cache);
171 }