Commit | Line | Data |
---|---|---|
17566092 SW |
1 | /*- |
2 | * Redistribution and use in source and binary forms, with or without | |
3 | * modification, are permitted provided that the following conditions | |
4 | * are met: | |
5 | * | |
6 | * Copyright 1994-2009 The FreeBSD Project. | |
7 | * All rights reserved. | |
8 | * | |
9 | * 1. Redistributions of source code must retain the above copyright | |
10 | * notice, this list of conditions and the following disclaimer. | |
11 | * 2. Redistributions in binary form must reproduce the above copyright | |
12 | * notice, this list of conditions and the following disclaimer in the | |
13 | * documentation and/or other materials provided with the distribution. | |
14 | * | |
15 | * THIS SOFTWARE IS PROVIDED BY THE FREEBSD PROJECT``AS IS'' AND | |
16 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, | |
17 | * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR | |
18 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FREEBSD PROJECT OR | |
19 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | |
20 | * EXEMPLARY,OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
21 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | |
22 | * PROFITS; OR BUSINESS INTERRUPTION)HOWEVER CAUSED AND ON ANY THEORY | |
23 | * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | |
24 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
26 | * | |
27 | * The views and conclusions contained in the software and documentation | |
28 | * are those of the authors and should not be interpreted as representing | |
29 | * official policies,either expressed or implied, of the FreeBSD Project. | |
30 | * | |
31 | * $FreeBSD: src/sys/dev/mfi/mfi_pddisk.c,v 1.2.2.6 2007/08/24 17:29:18 jhb Exp $ | |
590ba11d | 32 | * FreeBSD projects/head_mfi/ r232888 |
17566092 SW |
33 | */ |
34 | ||
35 | #include "opt_mfi.h" | |
36 | ||
37 | #include <sys/param.h> | |
38 | #include <sys/systm.h> | |
39 | #include <sys/kernel.h> | |
40 | #include <sys/module.h> | |
41 | #include <sys/malloc.h> | |
42 | #include <sys/uio.h> | |
43 | ||
44 | #include <sys/bio.h> | |
45 | #include <sys/buf2.h> | |
46 | #include <sys/bus.h> | |
47 | #include <sys/conf.h> | |
48 | #include <sys/disk.h> | |
49 | ||
50 | #include <vm/vm.h> | |
51 | #include <vm/pmap.h> | |
52 | ||
53 | #include <machine/md_var.h> | |
54 | #include <sys/rman.h> | |
55 | ||
56 | #include <dev/raid/mfi/mfireg.h> | |
57 | #include <dev/raid/mfi/mfi_ioctl.h> | |
58 | #include <dev/raid/mfi/mfivar.h> | |
59 | ||
60 | static int mfi_syspd_probe(device_t dev); | |
61 | static int mfi_syspd_attach(device_t dev); | |
62 | static int mfi_syspd_detach(device_t dev); | |
63 | ||
64 | static d_open_t mfi_syspd_open; | |
65 | static d_close_t mfi_syspd_close; | |
66 | static d_strategy_t mfi_syspd_strategy; | |
67 | static d_dump_t mfi_syspd_dump; | |
68 | ||
69 | static struct dev_ops mfi_syspd_ops = { | |
986e2176 | 70 | { "mfisyspd", 0, D_DISK | D_MPSAFE }, |
17566092 SW |
71 | .d_open = mfi_syspd_open, |
72 | .d_close = mfi_syspd_close, | |
73 | .d_strategy = mfi_syspd_strategy, | |
74 | .d_dump = mfi_syspd_dump, | |
75 | }; | |
76 | ||
77 | static devclass_t mfi_syspd_devclass; | |
78 | ||
79 | static device_method_t mfi_syspd_methods[] = { | |
80 | DEVMETHOD(device_probe, mfi_syspd_probe), | |
81 | DEVMETHOD(device_attach, mfi_syspd_attach), | |
82 | DEVMETHOD(device_detach, mfi_syspd_detach), | |
d3c9c58e | 83 | DEVMETHOD_END |
17566092 SW |
84 | }; |
85 | ||
86 | static driver_t mfi_syspd_driver = { | |
87 | "mfisyspd", | |
88 | mfi_syspd_methods, | |
89 | sizeof(struct mfi_system_pd) | |
90 | }; | |
91 | ||
8515b7f9 | 92 | DRIVER_MODULE(mfisyspd, mfi, mfi_syspd_driver, mfi_syspd_devclass, NULL, NULL); |
17566092 SW |
93 | |
94 | static int | |
95 | mfi_syspd_probe(device_t dev) | |
96 | { | |
97 | ||
98 | return (0); | |
99 | } | |
100 | ||
101 | static int | |
102 | mfi_syspd_attach(device_t dev) | |
103 | { | |
104 | struct mfi_system_pd *sc; | |
105 | struct mfi_pd_info *pd_info; | |
106 | struct disk_info info; | |
107 | uint64_t sectors; | |
108 | uint32_t secsize; | |
109 | ||
110 | sc = device_get_softc(dev); | |
111 | pd_info = device_get_ivars(dev); | |
112 | ||
113 | sc->pd_dev = dev; | |
114 | sc->pd_id = pd_info->ref.v.device_id; | |
115 | sc->pd_unit = device_get_unit(dev); | |
116 | sc->pd_info = pd_info; | |
117 | sc->pd_controller = device_get_softc(device_get_parent(dev)); | |
118 | sc->pd_flags = MFI_DISK_FLAGS_SYSPD; | |
119 | ||
120 | sectors = pd_info->raw_size; | |
121 | secsize = MFI_SECTOR_LEN; | |
122 | lockmgr(&sc->pd_controller->mfi_io_lock, LK_EXCLUSIVE); | |
123 | TAILQ_INSERT_TAIL(&sc->pd_controller->mfi_syspd_tqh, sc, pd_link); | |
124 | lockmgr(&sc->pd_controller->mfi_io_lock, LK_RELEASE); | |
125 | device_printf(dev, "%juMB (%ju sectors) SYSPD volume\n", | |
126 | sectors / (1024 * 1024 / secsize), sectors); | |
127 | ||
128 | devstat_add_entry(&sc->pd_devstat, "mfisyspd", device_get_unit(dev), | |
129 | MFI_SECTOR_LEN, DEVSTAT_NO_ORDERED_TAGS, | |
130 | DEVSTAT_TYPE_STORARRAY | DEVSTAT_TYPE_IF_OTHER, | |
131 | DEVSTAT_PRIORITY_ARRAY); | |
132 | ||
9049decf SW |
133 | sc->pd_dev_t = disk_create(sc->pd_unit, &sc->pd_disk, &mfi_syspd_ops); |
134 | sc->pd_dev_t->si_drv1 = sc; | |
135 | sc->pd_dev_t->si_iosize_max = sc->pd_controller->mfi_max_io * | |
17566092 SW |
136 | secsize; |
137 | ||
138 | bzero(&info, sizeof(info)); | |
139 | info.d_media_blksize = secsize; /* mandatory */ | |
140 | info.d_media_blocks = sectors; | |
141 | ||
142 | if (info.d_media_blocks >= (1 * 1024 * 1024)) { | |
143 | info.d_nheads = 255; | |
144 | info.d_secpertrack = 63; | |
145 | } else { | |
146 | info.d_nheads = 64; | |
147 | info.d_secpertrack = 32; | |
148 | } | |
149 | ||
150 | disk_setdiskinfo(&sc->pd_disk, &info); | |
151 | ||
17566092 SW |
152 | return (0); |
153 | } | |
154 | ||
155 | static int | |
156 | mfi_syspd_detach(device_t dev) | |
157 | { | |
158 | struct mfi_system_pd *sc; | |
159 | ||
160 | sc = device_get_softc(dev); | |
17566092 SW |
161 | lockmgr(&sc->pd_controller->mfi_io_lock, LK_EXCLUSIVE); |
162 | if ((sc->pd_flags & MFI_DISK_FLAGS_OPEN) && | |
163 | (sc->pd_controller->mfi_keep_deleted_volumes || | |
164 | sc->pd_controller->mfi_detaching)) { | |
165 | lockmgr(&sc->pd_controller->mfi_io_lock, LK_RELEASE); | |
17566092 SW |
166 | return (EBUSY); |
167 | } | |
168 | lockmgr(&sc->pd_controller->mfi_io_lock, LK_RELEASE); | |
169 | ||
170 | disk_destroy(&sc->pd_disk); | |
171 | devstat_remove_entry(&sc->pd_devstat); | |
172 | lockmgr(&sc->pd_controller->mfi_io_lock, LK_EXCLUSIVE); | |
173 | TAILQ_REMOVE(&sc->pd_controller->mfi_syspd_tqh, sc, pd_link); | |
174 | lockmgr(&sc->pd_controller->mfi_io_lock, LK_RELEASE); | |
175 | kfree(sc->pd_info, M_MFIBUF); | |
176 | return (0); | |
177 | } | |
178 | ||
179 | static int | |
180 | mfi_syspd_open(struct dev_open_args *ap) | |
181 | { | |
182 | struct mfi_system_pd *sc = ap->a_head.a_dev->si_drv1; | |
183 | int error; | |
184 | ||
185 | lockmgr(&sc->pd_controller->mfi_io_lock, LK_EXCLUSIVE); | |
186 | if (sc->pd_flags & MFI_DISK_FLAGS_DISABLED) | |
187 | error = ENXIO; | |
188 | else { | |
189 | sc->pd_flags |= MFI_DISK_FLAGS_OPEN; | |
190 | error = 0; | |
191 | } | |
192 | lockmgr(&sc->pd_controller->mfi_io_lock, LK_RELEASE); | |
193 | return (error); | |
194 | } | |
195 | ||
196 | static int | |
197 | mfi_syspd_close(struct dev_close_args *ap) | |
198 | { | |
199 | struct mfi_system_pd *sc = ap->a_head.a_dev->si_drv1; | |
200 | ||
201 | lockmgr(&sc->pd_controller->mfi_io_lock, LK_EXCLUSIVE); | |
202 | sc->pd_flags &= ~MFI_DISK_FLAGS_OPEN; | |
203 | lockmgr(&sc->pd_controller->mfi_io_lock, LK_RELEASE); | |
204 | ||
205 | return (0); | |
206 | } | |
207 | ||
208 | int | |
209 | mfi_syspd_disable(struct mfi_system_pd *sc) | |
210 | { | |
211 | ||
148e9c0b | 212 | mfi_lockassert(&sc->pd_controller->mfi_io_lock); |
17566092 SW |
213 | if (sc->pd_flags & MFI_DISK_FLAGS_OPEN) { |
214 | if (sc->pd_controller->mfi_delete_busy_volumes) | |
215 | return (0); | |
590ba11d SW |
216 | device_printf(sc->pd_dev, |
217 | "Unable to delete busy syspd device\n"); | |
17566092 SW |
218 | return (EBUSY); |
219 | } | |
220 | sc->pd_flags |= MFI_DISK_FLAGS_DISABLED; | |
221 | return (0); | |
222 | } | |
223 | ||
224 | void | |
225 | mfi_syspd_enable(struct mfi_system_pd *sc) | |
226 | { | |
227 | ||
148e9c0b | 228 | mfi_lockassert(&sc->pd_controller->mfi_io_lock); |
17566092 SW |
229 | sc->pd_flags &= ~MFI_DISK_FLAGS_DISABLED; |
230 | } | |
231 | ||
232 | static int | |
233 | mfi_syspd_strategy(struct dev_strategy_args *ap) | |
234 | { | |
235 | struct bio *bio = ap->a_bio; | |
236 | struct buf *bp = bio->bio_buf; | |
237 | struct mfi_system_pd *sc = ap->a_head.a_dev->si_drv1; | |
25641c66 | 238 | struct mfi_softc *controller; |
17566092 SW |
239 | |
240 | if (sc == NULL) { | |
241 | bp->b_error = EINVAL; | |
242 | bp->b_flags |= B_ERROR; | |
243 | bp->b_resid = bp->b_bcount; | |
244 | biodone(bio); | |
245 | return (0); | |
246 | } | |
25641c66 | 247 | controller = sc->pd_controller; |
17566092 | 248 | |
590ba11d SW |
249 | if (controller->hw_crit_error) { |
250 | bp->b_error = EBUSY; | |
251 | return (0); | |
252 | } | |
253 | ||
254 | if (controller->issuepend_done == 0) { | |
255 | bp->b_error = EBUSY; | |
256 | return (0); | |
257 | } | |
258 | ||
17566092 SW |
259 | /* |
260 | * XXX swildner | |
261 | * | |
262 | * If it's a null transfer, do nothing. FreeBSD's original driver | |
263 | * doesn't have this, but that caused hard error messages (even | |
264 | * though everything else continued to work fine). Interestingly, | |
265 | * only when HAMMER was used. | |
266 | * | |
267 | * Several others of our RAID drivers have this check, such as | |
268 | * aac(4) and ida(4), so we insert it here, too. | |
269 | * | |
270 | * The cause of null transfers is yet unknown. | |
271 | */ | |
272 | if (bp->b_bcount == 0) { | |
273 | bp->b_resid = bp->b_bcount; | |
274 | biodone(bio); | |
275 | return (0); | |
276 | } | |
277 | ||
17566092 SW |
278 | bio->bio_driver_info = sc; |
279 | lockmgr(&controller->mfi_io_lock, LK_EXCLUSIVE); | |
280 | mfi_enqueue_bio(controller, bio); | |
281 | devstat_start_transaction(&sc->pd_devstat); | |
282 | mfi_startio(controller); | |
283 | lockmgr(&controller->mfi_io_lock, LK_RELEASE); | |
284 | return (0); | |
285 | } | |
286 | ||
17566092 SW |
287 | static int |
288 | mfi_syspd_dump(struct dev_dump_args *ap) | |
289 | { | |
290 | cdev_t dev = ap->a_head.a_dev; | |
291 | off_t offset = ap->a_offset; | |
292 | void *virt = ap->a_virtual; | |
293 | size_t len = ap->a_length; | |
294 | struct mfi_system_pd *sc; | |
295 | struct mfi_softc *parent_sc; | |
296 | int error; | |
297 | ||
298 | sc = dev->si_drv1; | |
299 | parent_sc = sc->pd_controller; | |
300 | ||
301 | if (len > 0) { | |
590ba11d SW |
302 | if ((error = mfi_dump_syspd_blocks(parent_sc, |
303 | sc->pd_id, offset / MFI_SECTOR_LEN, virt, len)) != 0) | |
17566092 SW |
304 | return (error); |
305 | } else { | |
306 | /* mfi_sync_cache(parent_sc, sc->ld_id); */ | |
307 | } | |
308 | return (0); | |
309 | } |