This is a major cleanup of the LWKT message port code. The messaging code
[dragonfly.git] / sys / kern / subr_disk.c
1 /*
2  * ----------------------------------------------------------------------------
3  * "THE BEER-WARE LICENSE" (Revision 42):
4  * <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
5  * can do whatever you want with this stuff. If we meet some day, and you think
6  * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
7  * ----------------------------------------------------------------------------
8  *
9  * $FreeBSD: src/sys/kern/subr_disk.c,v 1.20.2.6 2001/10/05 07:14:57 peter Exp $
10  * $DragonFly: src/sys/kern/subr_disk.c,v 1.6 2003/11/20 06:05:30 dillon Exp $
11  *
12  */
13
14 #include <sys/param.h>
15 #include <sys/systm.h>
16 #include <sys/kernel.h>
17 #include <sys/sysctl.h>
18 #include <sys/buf.h>
19 #include <sys/conf.h>
20 #include <sys/disk.h>
21 #include <sys/malloc.h>
22 #include <sys/sysctl.h>
23 #include <machine/md_var.h>
24 #include <sys/ctype.h>
25 #include <sys/msgport.h>
26 #include <sys/msgport2.h>
27
28 static MALLOC_DEFINE(M_DISK, "disk", "disk data");
29
30 static d_strategy_t diskstrategy;
31 static d_open_t diskopen;
32 static d_close_t diskclose; 
33 static d_ioctl_t diskioctl;
34 static d_psize_t diskpsize;
35 static int disk_putport(lwkt_port_t port, lwkt_msg_t msg);
36
37 static LIST_HEAD(, disk) disklist = LIST_HEAD_INITIALIZER(&disklist);
38
39 static void
40 inherit_raw(dev_t pdev, dev_t dev)
41 {
42         dev->si_disk = pdev->si_disk;
43         dev->si_drv1 = pdev->si_drv1;
44         dev->si_drv2 = pdev->si_drv2;
45         dev->si_iosize_max = pdev->si_iosize_max;
46         dev->si_bsize_phys = pdev->si_bsize_phys;
47         dev->si_bsize_best = pdev->si_bsize_best;
48 }
49
50 /*
51  * Create a slice and unit managed disk.  The underlying raw disk device
52  * is specified by cdevsw.  We create the device as a managed device by
53  * first creating it normally then overriding the message port with our
54  * own frontend (which will be responsible for assigning pblkno).
55  */
56 dev_t
57 disk_create(int unit, struct disk *dp, int flags, struct cdevsw *cdevsw)
58 {
59         dev_t dev;
60
61         bzero(dp, sizeof(*dp));
62         lwkt_init_port(&dp->d_port, NULL);      /* intercept port */
63         dp->d_port.mp_putport = disk_putport;
64
65         dev = makedev(cdevsw->d_maj, 0);        /* base device */
66         dev->si_disk = dp;
67                                                 /* forwarding port */
68         dp->d_fwdport = cdevsw_add_override(cdevsw, &dp->d_port);
69
70         if (bootverbose)
71                 printf("Creating DISK %s%d\n", cdevsw->d_name, unit);
72
73         /*
74          * The whole disk placemarker holds the disk structure.
75          */
76         dev = make_dev(cdevsw, dkmakeminor(unit, WHOLE_DISK_SLICE, RAW_PART),
77             UID_ROOT, GID_OPERATOR, 0640, "%s%d", cdevsw->d_name, unit);
78         dev->si_disk = dp;
79         dp->d_dev = dev;
80         dp->d_dsflags = flags;
81         LIST_INSERT_HEAD(&disklist, dp, d_list);
82         return (dev);
83 }
84
85 void
86 disk_destroy(struct disk *disk)
87 {
88         dev_t dev = disk->d_dev;
89
90         LIST_REMOVE(disk, d_list);
91         bzero(disk, sizeof(*disk));
92         dev->si_disk = NULL;
93         destroy_dev(dev);
94         /* YYY remove cdevsw entries? */
95         return;
96 }
97
98 int
99 disk_dumpcheck(dev_t dev, u_int *count, u_int *blkno, u_int *secsize)
100 {
101         struct disk *dp;
102         struct disklabel *dl;
103         u_int boff;
104
105         dp = dev->si_disk;
106         if (!dp)
107                 return (ENXIO);
108         if (!dp->d_slice)
109                 return (ENXIO);
110         dl = dsgetlabel(dev, dp->d_slice);
111         if (!dl)
112                 return (ENXIO);
113         *count = Maxmem * (PAGE_SIZE / dl->d_secsize);
114         if (dumplo <= LABELSECTOR || 
115             (dumplo + *count > dl->d_partitions[dkpart(dev)].p_size))
116                 return (EINVAL);
117         boff = dl->d_partitions[dkpart(dev)].p_offset +
118             dp->d_slice->dss_slices[dkslice(dev)].ds_offset;
119         *blkno = boff + dumplo;
120         *secsize = dl->d_secsize;
121         return (0);
122         
123 }
124
125 void 
126 disk_invalidate (struct disk *disk)
127 {
128         if (disk->d_slice)
129                 dsgone(&disk->d_slice);
130 }
131
132 struct disk *
133 disk_enumerate(struct disk *disk)
134 {
135         if (!disk)
136                 return (LIST_FIRST(&disklist));
137         else
138                 return (LIST_NEXT(disk, d_list));
139 }
140
141 static int
142 sysctl_disks(SYSCTL_HANDLER_ARGS)
143 {
144         struct disk *disk;
145         int error, first;
146
147         disk = NULL;
148         first = 1;
149
150         while ((disk = disk_enumerate(disk))) {
151                 if (!first) {
152                         error = SYSCTL_OUT(req, " ", 1);
153                         if (error)
154                                 return error;
155                 } else {
156                         first = 0;
157                 }
158                 error = SYSCTL_OUT(req, disk->d_dev->si_name, strlen(disk->d_dev->si_name));
159                 if (error)
160                         return error;
161         }
162         error = SYSCTL_OUT(req, "", 1);
163         return error;
164 }
165  
166 SYSCTL_PROC(_kern, OID_AUTO, disks, CTLTYPE_STRING | CTLFLAG_RD, 0, NULL, 
167     sysctl_disks, "A", "names of available disks");
168
169 /*
170  * The port intercept functions
171  */
172 static
173 int
174 disk_putport(lwkt_port_t port, lwkt_msg_t lmsg)
175 {
176         struct disk *disk = (struct disk *)port;
177         cdevallmsg_t msg = (cdevallmsg_t)lmsg;
178         int error;
179
180         switch(msg->am_lmsg.ms_cmd) {
181         case CDEV_CMD_OPEN:
182                 error = diskopen(
183                             msg->am_open.msg.dev,
184                             msg->am_open.oflags,
185                             msg->am_open.devtype,
186                             msg->am_open.td);
187                 break;
188         case CDEV_CMD_CLOSE:
189                 error = diskclose(
190                             msg->am_close.msg.dev,
191                             msg->am_close.fflag,
192                             msg->am_close.devtype,
193                             msg->am_close.td);
194                 break;
195         case CDEV_CMD_IOCTL:
196                 error = diskioctl(
197                             msg->am_ioctl.msg.dev,
198                             msg->am_ioctl.cmd,
199                             msg->am_ioctl.data,
200                             msg->am_ioctl.fflag,
201                             msg->am_ioctl.td);
202                 break;
203         case CDEV_CMD_STRATEGY:
204                 diskstrategy(msg->am_strategy.bp);
205                 error = 0;
206                 break;
207         case CDEV_CMD_PSIZE:
208                 msg->am_psize.result = diskpsize(msg->am_psize.msg.dev);
209                 error = 0;      /* XXX */
210                 break;
211         default:
212                 error = lwkt_forwardmsg(disk->d_fwdport, &msg->am_lmsg);
213                 break;
214         }
215         return(error);
216 }
217
218 static int
219 diskopen(dev_t dev, int oflags, int devtype, struct thread *td)
220 {
221         dev_t pdev;
222         struct disk *dp;
223         int error;
224
225         error = 0;
226         pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
227
228         dp = pdev->si_disk;
229         if (dp == NULL)
230                 return (ENXIO);
231
232         while (dp->d_flags & DISKFLAG_LOCK) {
233                 dp->d_flags |= DISKFLAG_WANTED;
234                 error = tsleep(dp, PCATCH, "diskopen", hz);
235                 if (error)
236                         return (error);
237         }
238         dp->d_flags |= DISKFLAG_LOCK;
239
240         if (!dsisopen(dp->d_slice)) {
241                 if (!pdev->si_iosize_max)
242                         pdev->si_iosize_max = dev->si_iosize_max;
243                 error = dev_port_dopen(dp->d_fwdport, pdev, oflags, devtype, td);
244         }
245
246         /* Inherit properties from the whole/raw dev_t */
247         inherit_raw(pdev, dev);
248
249         if (error)
250                 goto out;
251         
252         error = dsopen(dev, devtype, dp->d_dsflags, &dp->d_slice, &dp->d_label);
253
254         if (!dsisopen(dp->d_slice)) 
255                 dev_port_dclose(dp->d_fwdport, pdev, oflags, devtype, td);
256 out:    
257         dp->d_flags &= ~DISKFLAG_LOCK;
258         if (dp->d_flags & DISKFLAG_WANTED) {
259                 dp->d_flags &= ~DISKFLAG_WANTED;
260                 wakeup(dp);
261         }
262         
263         return(error);
264 }
265
266 static int
267 diskclose(dev_t dev, int fflag, int devtype, struct thread *td)
268 {
269         struct disk *dp;
270         int error;
271         dev_t pdev;
272
273         error = 0;
274         pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
275         dp = pdev->si_disk;
276         if (!dp)
277                 return (ENXIO);
278         dsclose(dev, devtype, dp->d_slice);
279         if (!dsisopen(dp->d_slice))
280                 error = dev_port_dclose(dp->d_fwdport, pdev, fflag, devtype, td);
281         return (error);
282 }
283
284 static void
285 diskstrategy(struct buf *bp)
286 {
287         dev_t pdev;
288         struct disk *dp;
289
290         pdev = dkmodpart(dkmodslice(bp->b_dev, WHOLE_DISK_SLICE), RAW_PART);
291         dp = pdev->si_disk;
292         if (dp != bp->b_dev->si_disk)
293                 inherit_raw(pdev, bp->b_dev);
294
295         if (!dp) {
296                 bp->b_error = ENXIO;
297                 bp->b_flags |= B_ERROR;
298                 biodone(bp);
299                 return;
300         }
301
302         if (dscheck(bp, dp->d_slice) <= 0) {
303                 biodone(bp);
304                 return;
305         }
306         dev_port_dstrategy(dp->d_fwdport, dp->d_dev, bp);
307 }
308
309 /*
310  * note: when forwarding the ioctl we use the original device rather then
311  * the whole disk slice.
312  */
313 static int
314 diskioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
315 {
316         struct disk *dp;
317         int error;
318         dev_t pdev;
319
320         pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
321         dp = pdev->si_disk;
322         if (!dp)
323                 return (ENXIO);
324         error = dsioctl(dev, cmd, data, fflag, &dp->d_slice);
325         if (error == ENOIOCTL)
326                 error = dev_port_dioctl(dp->d_fwdport, dev, cmd, data, fflag, td);
327         return (error);
328 }
329
330 static int
331 diskpsize(dev_t dev)
332 {
333         struct disk *dp;
334         dev_t pdev;
335
336         pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
337         dp = pdev->si_disk;
338         if (!dp)
339                 return (-1);
340         if (dp != dev->si_disk) {
341                 dev->si_drv1 = pdev->si_drv1;
342                 dev->si_drv2 = pdev->si_drv2;
343                 /* XXX: don't set bp->b_dev->si_disk (?) */
344         }
345         return (dssize(dev, &dp->d_slice));
346 }
347
348 SYSCTL_DECL(_debug_sizeof);
349
350 SYSCTL_INT(_debug_sizeof, OID_AUTO, disklabel, CTLFLAG_RD, 
351     0, sizeof(struct disklabel), "sizeof(struct disklabel)");
352
353 SYSCTL_INT(_debug_sizeof, OID_AUTO, diskslices, CTLFLAG_RD, 
354     0, sizeof(struct diskslices), "sizeof(struct diskslices)");
355
356 SYSCTL_INT(_debug_sizeof, OID_AUTO, disk, CTLFLAG_RD, 
357     0, sizeof(struct disk), "sizeof(struct disk)");