diff options
author | Chandra Seetharaman <sekharan@us.ibm.com> | 2008-05-01 17:50:40 -0400 |
---|---|---|
committer | James Bottomley <James.Bottomley@HansenPartnership.com> | 2008-06-05 10:23:42 -0400 |
commit | 688864e29869a71a8183e4e2f96ccf9f2de1375f (patch) | |
tree | c77035b81c5eb798ecdad1d971a8a4a66fda8949 /drivers/md/dm-hw-handler.c | |
parent | cb520223d7f22c5386aff27a5856a66e2c32aaac (diff) |
[SCSI] scsi_dh: Remove hardware handler infrastructure from dm
This patch just removes infrastructure that provided support for hardware
handlers in the dm layer as it is not needed anymore.
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Acked-by: Alasdair G Kergon <agk@redhat.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
Diffstat (limited to 'drivers/md/dm-hw-handler.c')
-rw-r--r-- | drivers/md/dm-hw-handler.c | 213 |
1 files changed, 0 insertions, 213 deletions
diff --git a/drivers/md/dm-hw-handler.c b/drivers/md/dm-hw-handler.c deleted file mode 100644 index 2ee84d8aa0bf..000000000000 --- a/drivers/md/dm-hw-handler.c +++ /dev/null | |||
@@ -1,213 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2004 Red Hat, Inc. All rights reserved. | ||
3 | * | ||
4 | * This file is released under the GPL. | ||
5 | * | ||
6 | * Multipath hardware handler registration. | ||
7 | */ | ||
8 | |||
9 | #include "dm.h" | ||
10 | #include "dm-hw-handler.h" | ||
11 | |||
12 | #include <linux/slab.h> | ||
13 | |||
14 | struct hwh_internal { | ||
15 | struct hw_handler_type hwht; | ||
16 | |||
17 | struct list_head list; | ||
18 | long use; | ||
19 | }; | ||
20 | |||
21 | #define hwht_to_hwhi(__hwht) container_of((__hwht), struct hwh_internal, hwht) | ||
22 | |||
23 | static LIST_HEAD(_hw_handlers); | ||
24 | static DECLARE_RWSEM(_hwh_lock); | ||
25 | |||
26 | static struct hwh_internal *__find_hw_handler_type(const char *name) | ||
27 | { | ||
28 | struct hwh_internal *hwhi; | ||
29 | |||
30 | list_for_each_entry(hwhi, &_hw_handlers, list) { | ||
31 | if (!strcmp(name, hwhi->hwht.name)) | ||
32 | return hwhi; | ||
33 | } | ||
34 | |||
35 | return NULL; | ||
36 | } | ||
37 | |||
38 | static struct hwh_internal *get_hw_handler(const char *name) | ||
39 | { | ||
40 | struct hwh_internal *hwhi; | ||
41 | |||
42 | down_read(&_hwh_lock); | ||
43 | hwhi = __find_hw_handler_type(name); | ||
44 | if (hwhi) { | ||
45 | if ((hwhi->use == 0) && !try_module_get(hwhi->hwht.module)) | ||
46 | hwhi = NULL; | ||
47 | else | ||
48 | hwhi->use++; | ||
49 | } | ||
50 | up_read(&_hwh_lock); | ||
51 | |||
52 | return hwhi; | ||
53 | } | ||
54 | |||
55 | struct hw_handler_type *dm_get_hw_handler(const char *name) | ||
56 | { | ||
57 | struct hwh_internal *hwhi; | ||
58 | |||
59 | if (!name) | ||
60 | return NULL; | ||
61 | |||
62 | hwhi = get_hw_handler(name); | ||
63 | if (!hwhi) { | ||
64 | request_module("dm-%s", name); | ||
65 | hwhi = get_hw_handler(name); | ||
66 | } | ||
67 | |||
68 | return hwhi ? &hwhi->hwht : NULL; | ||
69 | } | ||
70 | |||
71 | void dm_put_hw_handler(struct hw_handler_type *hwht) | ||
72 | { | ||
73 | struct hwh_internal *hwhi; | ||
74 | |||
75 | if (!hwht) | ||
76 | return; | ||
77 | |||
78 | down_read(&_hwh_lock); | ||
79 | hwhi = __find_hw_handler_type(hwht->name); | ||
80 | if (!hwhi) | ||
81 | goto out; | ||
82 | |||
83 | if (--hwhi->use == 0) | ||
84 | module_put(hwhi->hwht.module); | ||
85 | |||
86 | BUG_ON(hwhi->use < 0); | ||
87 | |||
88 | out: | ||
89 | up_read(&_hwh_lock); | ||
90 | } | ||
91 | |||
92 | static struct hwh_internal *_alloc_hw_handler(struct hw_handler_type *hwht) | ||
93 | { | ||
94 | struct hwh_internal *hwhi = kzalloc(sizeof(*hwhi), GFP_KERNEL); | ||
95 | |||
96 | if (hwhi) | ||
97 | hwhi->hwht = *hwht; | ||
98 | |||
99 | return hwhi; | ||
100 | } | ||
101 | |||
102 | int dm_register_hw_handler(struct hw_handler_type *hwht) | ||
103 | { | ||
104 | int r = 0; | ||
105 | struct hwh_internal *hwhi = _alloc_hw_handler(hwht); | ||
106 | |||
107 | if (!hwhi) | ||
108 | return -ENOMEM; | ||
109 | |||
110 | down_write(&_hwh_lock); | ||
111 | |||
112 | if (__find_hw_handler_type(hwht->name)) { | ||
113 | kfree(hwhi); | ||
114 | r = -EEXIST; | ||
115 | } else | ||
116 | list_add(&hwhi->list, &_hw_handlers); | ||
117 | |||
118 | up_write(&_hwh_lock); | ||
119 | |||
120 | return r; | ||
121 | } | ||
122 | |||
123 | int dm_unregister_hw_handler(struct hw_handler_type *hwht) | ||
124 | { | ||
125 | struct hwh_internal *hwhi; | ||
126 | |||
127 | down_write(&_hwh_lock); | ||
128 | |||
129 | hwhi = __find_hw_handler_type(hwht->name); | ||
130 | if (!hwhi) { | ||
131 | up_write(&_hwh_lock); | ||
132 | return -EINVAL; | ||
133 | } | ||
134 | |||
135 | if (hwhi->use) { | ||
136 | up_write(&_hwh_lock); | ||
137 | return -ETXTBSY; | ||
138 | } | ||
139 | |||
140 | list_del(&hwhi->list); | ||
141 | |||
142 | up_write(&_hwh_lock); | ||
143 | |||
144 | kfree(hwhi); | ||
145 | |||
146 | return 0; | ||
147 | } | ||
148 | |||
149 | unsigned dm_scsi_err_handler(struct hw_handler *hwh, struct bio *bio) | ||
150 | { | ||
151 | #if 0 | ||
152 | int sense_key, asc, ascq; | ||
153 | |||
154 | if (bio->bi_error & BIO_SENSE) { | ||
155 | /* FIXME: This is just an initial guess. */ | ||
156 | /* key / asc / ascq */ | ||
157 | sense_key = (bio->bi_error >> 16) & 0xff; | ||
158 | asc = (bio->bi_error >> 8) & 0xff; | ||
159 | ascq = bio->bi_error & 0xff; | ||
160 | |||
161 | switch (sense_key) { | ||
162 | /* This block as a whole comes from the device. | ||
163 | * So no point retrying on another path. */ | ||
164 | case 0x03: /* Medium error */ | ||
165 | case 0x05: /* Illegal request */ | ||
166 | case 0x07: /* Data protect */ | ||
167 | case 0x08: /* Blank check */ | ||
168 | case 0x0a: /* copy aborted */ | ||
169 | case 0x0c: /* obsolete - no clue ;-) */ | ||
170 | case 0x0d: /* volume overflow */ | ||
171 | case 0x0e: /* data miscompare */ | ||
172 | case 0x0f: /* reserved - no idea either. */ | ||
173 | return MP_ERROR_IO; | ||
174 | |||
175 | /* For these errors it's unclear whether they | ||
176 | * come from the device or the controller. | ||
177 | * So just lets try a different path, and if | ||
178 | * it eventually succeeds, user-space will clear | ||
179 | * the paths again... */ | ||
180 | case 0x02: /* Not ready */ | ||
181 | case 0x04: /* Hardware error */ | ||
182 | case 0x09: /* vendor specific */ | ||
183 | case 0x0b: /* Aborted command */ | ||
184 | return MP_FAIL_PATH; | ||
185 | |||
186 | case 0x06: /* Unit attention - might want to decode */ | ||
187 | if (asc == 0x04 && ascq == 0x01) | ||
188 | /* "Unit in the process of | ||
189 | * becoming ready" */ | ||
190 | return 0; | ||
191 | return MP_FAIL_PATH; | ||
192 | |||
193 | /* FIXME: For Unit Not Ready we may want | ||
194 | * to have a generic pg activation | ||
195 | * feature (START_UNIT). */ | ||
196 | |||
197 | /* Should these two ever end up in the | ||
198 | * error path? I don't think so. */ | ||
199 | case 0x00: /* No sense */ | ||
200 | case 0x01: /* Recovered error */ | ||
201 | return 0; | ||
202 | } | ||
203 | } | ||
204 | #endif | ||
205 | |||
206 | /* We got no idea how to decode the other kinds of errors -> | ||
207 | * assume generic error condition. */ | ||
208 | return MP_FAIL_PATH; | ||
209 | } | ||
210 | |||
211 | EXPORT_SYMBOL_GPL(dm_register_hw_handler); | ||
212 | EXPORT_SYMBOL_GPL(dm_unregister_hw_handler); | ||
213 | EXPORT_SYMBOL_GPL(dm_scsi_err_handler); | ||