Merge branch 'x86-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6] / drivers / md / dm-target.c
1 /*
2  * Copyright (C) 2001 Sistina Software (UK) Limited
3  *
4  * This file is released under the GPL.
5  */
6
7 #include "dm.h"
8
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/kmod.h>
12 #include <linux/bio.h>
13 #include <linux/slab.h>
14
15 #define DM_MSG_PREFIX "target"
16
17 static LIST_HEAD(_targets);
18 static DECLARE_RWSEM(_lock);
19
20 #define DM_MOD_NAME_SIZE 32
21
22 static inline struct target_type *__find_target_type(const char *name)
23 {
24         struct target_type *tt;
25
26         list_for_each_entry(tt, &_targets, list)
27                 if (!strcmp(name, tt->name))
28                         return tt;
29
30         return NULL;
31 }
32
33 static struct target_type *get_target_type(const char *name)
34 {
35         struct target_type *tt;
36
37         down_read(&_lock);
38
39         tt = __find_target_type(name);
40         if (tt && !try_module_get(tt->module))
41                 tt = NULL;
42
43         up_read(&_lock);
44         return tt;
45 }
46
47 static void load_module(const char *name)
48 {
49         request_module("dm-%s", name);
50 }
51
52 struct target_type *dm_get_target_type(const char *name)
53 {
54         struct target_type *tt = get_target_type(name);
55
56         if (!tt) {
57                 load_module(name);
58                 tt = get_target_type(name);
59         }
60
61         return tt;
62 }
63
64 void dm_put_target_type(struct target_type *tt)
65 {
66         down_read(&_lock);
67         module_put(tt->module);
68         up_read(&_lock);
69 }
70
71 int dm_target_iterate(void (*iter_func)(struct target_type *tt,
72                                         void *param), void *param)
73 {
74         struct target_type *tt;
75
76         down_read(&_lock);
77         list_for_each_entry(tt, &_targets, list)
78                 iter_func(tt, param);
79         up_read(&_lock);
80
81         return 0;
82 }
83
84 int dm_register_target(struct target_type *tt)
85 {
86         int rv = 0;
87
88         down_write(&_lock);
89         if (__find_target_type(tt->name))
90                 rv = -EEXIST;
91         else
92                 list_add(&tt->list, &_targets);
93
94         up_write(&_lock);
95         return rv;
96 }
97
98 void dm_unregister_target(struct target_type *tt)
99 {
100         down_write(&_lock);
101         if (!__find_target_type(tt->name)) {
102                 DMCRIT("Unregistering unrecognised target: %s", tt->name);
103                 BUG();
104         }
105
106         list_del(&tt->list);
107
108         up_write(&_lock);
109 }
110
111 /*
112  * io-err: always fails an io, useful for bringing
113  * up LVs that have holes in them.
114  */
115 static int io_err_ctr(struct dm_target *tt, unsigned int argc, char **args)
116 {
117         return 0;
118 }
119
120 static void io_err_dtr(struct dm_target *tt)
121 {
122         /* empty */
123 }
124
125 static int io_err_map(struct dm_target *tt, struct bio *bio,
126                       union map_info *map_context)
127 {
128         return -EIO;
129 }
130
131 static struct target_type error_target = {
132         .name = "error",
133         .version = {1, 0, 1},
134         .ctr  = io_err_ctr,
135         .dtr  = io_err_dtr,
136         .map  = io_err_map,
137 };
138
139 int __init dm_target_init(void)
140 {
141         return dm_register_target(&error_target);
142 }
143
144 void dm_target_exit(void)
145 {
146         dm_unregister_target(&error_target);
147 }
148
149 EXPORT_SYMBOL(dm_register_target);
150 EXPORT_SYMBOL(dm_unregister_target);