subr_disk.c revision 77343 
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: head/sys/kern/subr_disk.c 77343 2001-05-28 16:12:55Z phk $
10 *
11 */
12
13#include <sys/param.h>
14#include <sys/systm.h>
15#include <sys/kernel.h>
16#include <sys/sysctl.h>
17#include <sys/bio.h>
18#include <sys/conf.h>
19#include <sys/disk.h>
20#include <sys/malloc.h>
21#include <sys/sysctl.h>
22#include <machine/md_var.h>
23#include <sys/ctype.h>
24
25static MALLOC_DEFINE(M_DISK, "disk", "disk data");
26
27static d_strategy_t diskstrategy;
28static d_open_t diskopen;
29static d_close_t diskclose;
30static d_ioctl_t diskioctl;
31static d_psize_t diskpsize;
32
33static LIST_HEAD(, disk) disklist = LIST_HEAD_INITIALIZER(&disklist);
34
35static void
36disk_clone(void *arg, char *name, int namelen, dev_t *dev)
37{
38	struct disk *dp;
39	char const *d;
40	int i, u, s, p;
41	dev_t pdev;
42
43	if (*dev != NODEV)
44		return;
45
46	LIST_FOREACH(dp, &disklist, d_list) {
47		d = dp->d_devsw->d_name;
48		i = strlen(d);
49		if (bcmp(d, name, i) != 0)
50			continue;
51		u = 0;
52		if (!isdigit(name[i]))
53			continue;
54		while (isdigit(name[i])) {
55			u *= 10;
56			u += name[i++] - '0';
57		}
58		if (u > DKMAXUNIT)
59			continue;
60		p = RAW_PART;
61		s = WHOLE_DISK_SLICE;
62		pdev = makedev(dp->d_devsw->d_maj, dkmakeminor(u, s, p));
63		if (pdev->si_disk == NULL)
64			continue;
65		if (name[i] != '\0') {
66			if (name[i] == 's') {
67				s = 0;
68				i++;
69				if (!isdigit(name[i]))
70					continue;
71				while (isdigit(name[i])) {
72					s *= 10;
73					s += name[i++] - '0';
74				}
75				s += BASE_SLICE - 1;
76			} else {
77				s = COMPATIBILITY_SLICE;
78			}
79			if (name[i] == '\0')
80				;
81			else if (name[i] < 'a' || name[i] > 'h')
82				continue;
83			else
84				p = name[i] - 'a';
85		}
86
87		*dev = make_dev(pdev->si_devsw, dkmakeminor(u, s, p),
88		    UID_ROOT, GID_OPERATOR, 0640, name);
89		dev_depends(pdev, *dev);
90		return;
91	}
92}
93
94static void
95inherit_raw(dev_t pdev, dev_t dev)
96{
97	dev->si_disk = pdev->si_disk;
98	dev->si_drv1 = pdev->si_drv1;
99	dev->si_drv2 = pdev->si_drv2;
100	dev->si_iosize_max = pdev->si_iosize_max;
101	dev->si_bsize_phys = pdev->si_bsize_phys;
102	dev->si_bsize_best = pdev->si_bsize_best;
103}
104
105dev_t
106disk_create(int unit, struct disk *dp, int flags, struct cdevsw *cdevsw, struct cdevsw *proto)
107{
108	static int once;
109	dev_t dev, cdev;
110	int i;
111	char buf[20];
112
113	if (!once) {
114		EVENTHANDLER_REGISTER(dev_clone, disk_clone, 0, 1000);
115		once++;
116	}
117
118	bzero(dp, sizeof(*dp));
119
120	if (proto->d_open != diskopen) {
121		*proto = *cdevsw;
122		proto->d_open = diskopen;
123		proto->d_close = diskclose;
124		proto->d_ioctl = diskioctl;
125		proto->d_strategy = diskstrategy;
126		proto->d_psize = diskpsize;
127		cdevsw_add(proto);
128	}
129
130	if (bootverbose)
131		printf("Creating DISK %s%d\n", cdevsw->d_name, unit);
132	dev = make_dev(proto, dkmakeminor(unit, WHOLE_DISK_SLICE, RAW_PART),
133	    UID_ROOT, GID_OPERATOR, 0640, "%s%d", cdevsw->d_name, unit);
134
135	dev->si_disk = dp;
136	dp->d_dev = dev;
137	dp->d_dsflags = flags;
138	dp->d_devsw = cdevsw;
139	LIST_INSERT_HEAD(&disklist, dp, d_list);
140
141	sprintf(buf, "%sc", dev->si_name);
142	cdev = NODEV;
143	disk_clone(NULL, buf, strlen(buf), &cdev);
144	for (i = 1; i < 5; i++) {
145		sprintf(buf, "%ss%d", dev->si_name, i);
146		cdev = NODEV;
147		disk_clone(NULL, buf, strlen(buf), &cdev);
148	}
149	return (dev);
150}
151
152int
153disk_dumpcheck(dev_t dev, u_int *count, u_int *blkno, u_int *secsize)
154{
155	struct disk *dp;
156	struct disklabel *dl;
157	u_int boff;
158
159	dp = dev->si_disk;
160	if (!dp)
161		return (ENXIO);
162	if (!dp->d_slice)
163		return (ENXIO);
164	dl = dsgetlabel(dev, dp->d_slice);
165	if (!dl)
166		return (ENXIO);
167	*count = (u_long)Maxmem * PAGE_SIZE / dl->d_secsize;
168	if (dumplo < 0 ||
169	    (dumplo + *count > dl->d_partitions[dkpart(dev)].p_size))
170		return (EINVAL);
171	boff = dl->d_partitions[dkpart(dev)].p_offset +
172	    dp->d_slice->dss_slices[dkslice(dev)].ds_offset;
173	*blkno = boff + dumplo;
174	*secsize = dl->d_secsize;
175	return (0);
176
177}
178
179void
180disk_invalidate (struct disk *disk)
181{
182	if (disk->d_slice)
183		dsgone(&disk->d_slice);
184}
185
186void
187disk_destroy(dev_t dev)
188{
189	LIST_REMOVE(dev->si_disk, d_list);
190	bzero(dev->si_disk, sizeof(*dev->si_disk));
191    	dev->si_disk = NULL;
192	destroy_dev(dev);
193	return;
194}
195
196struct disk *
197disk_enumerate(struct disk *disk)
198{
199	if (!disk)
200		return (LIST_FIRST(&disklist));
201	else
202		return (LIST_NEXT(disk, d_list));
203}
204
205static int
206sysctl_disks(SYSCTL_HANDLER_ARGS)
207{
208	struct disk *disk;
209	int error, first;
210
211	disk = NULL;
212	first = 1;
213
214	while ((disk = disk_enumerate(disk))) {
215		if (!first) {
216			error = SYSCTL_OUT(req, " ", 1);
217			if (error)
218				return error;
219		} else {
220			first = 0;
221		}
222		error = SYSCTL_OUT(req, disk->d_dev->si_name, strlen(disk->d_dev->si_name));
223		if (error)
224			return error;
225	}
226	error = SYSCTL_OUT(req, "", 1);
227	return error;
228}
229
230SYSCTL_PROC(_kern, OID_AUTO, disks, CTLTYPE_STRING | CTLFLAG_RD, 0, NULL,
231    sysctl_disks, "A", "names of available disks");
232
233/*
234 * The cdevsw functions
235 */
236
237static int
238diskopen(dev_t dev, int oflags, int devtype, struct proc *p)
239{
240	dev_t pdev;
241	struct disk *dp;
242	int error;
243
244	error = 0;
245	pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
246
247	dp = pdev->si_disk;
248	if (!dp)
249		return (ENXIO);
250
251	while (dp->d_flags & DISKFLAG_LOCK) {
252		dp->d_flags |= DISKFLAG_WANTED;
253		error = tsleep(dp, PRIBIO | PCATCH, "diskopen", hz);
254		if (error)
255			return (error);
256	}
257	dp->d_flags |= DISKFLAG_LOCK;
258
259	if (!dsisopen(dp->d_slice)) {
260		if (!pdev->si_iosize_max)
261			pdev->si_iosize_max = dev->si_iosize_max;
262		error = dp->d_devsw->d_open(pdev, oflags, devtype, p);
263	}
264
265	/* Inherit properties from the whole/raw dev_t */
266	inherit_raw(pdev, dev);
267
268	if (error)
269		goto out;
270
271	error = dsopen(dev, devtype, dp->d_dsflags, &dp->d_slice, &dp->d_label);
272
273	if (!dsisopen(dp->d_slice))
274		dp->d_devsw->d_close(pdev, oflags, devtype, p);
275out:
276	dp->d_flags &= ~DISKFLAG_LOCK;
277	if (dp->d_flags & DISKFLAG_WANTED) {
278		dp->d_flags &= ~DISKFLAG_WANTED;
279		wakeup(dp);
280	}
281
282	return(error);
283}
284
285static int
286diskclose(dev_t dev, int fflag, int devtype, struct proc *p)
287{
288	struct disk *dp;
289	int error;
290	dev_t pdev;
291
292	error = 0;
293	pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
294	dp = pdev->si_disk;
295	if (!dp)
296		return (ENXIO);
297	dsclose(dev, devtype, dp->d_slice);
298	if (!dsisopen(dp->d_slice))
299		error = dp->d_devsw->d_close(dp->d_dev, fflag, devtype, p);
300	return (error);
301}
302
303static void
304diskstrategy(struct bio *bp)
305{
306	dev_t pdev;
307	struct disk *dp;
308
309	pdev = dkmodpart(dkmodslice(bp->bio_dev, WHOLE_DISK_SLICE), RAW_PART);
310	dp = pdev->si_disk;
311	bp->bio_resid = bp->bio_bcount;
312	if (dp != bp->bio_dev->si_disk)
313		inherit_raw(pdev, bp->bio_dev);
314
315	if (!dp) {
316		biofinish(bp, NULL, ENXIO);
317		return;
318	}
319
320	if (dscheck(bp, dp->d_slice) <= 0) {
321		biodone(bp);
322		return;
323	}
324
325	if (bp->bio_bcount == 0) {
326		biodone(bp);
327		return;
328	}
329
330	KASSERT(dp->d_devsw != NULL, ("NULL devsw"));
331	KASSERT(dp->d_devsw->d_strategy != NULL, ("NULL d_strategy"));
332	dp->d_devsw->d_strategy(bp);
333	return;
334
335}
336
337static int
338diskioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p)
339{
340	struct disk *dp;
341	int error;
342	dev_t pdev;
343
344	pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
345	dp = pdev->si_disk;
346	if (!dp)
347		return (ENXIO);
348	error = dsioctl(dev, cmd, data, fflag, &dp->d_slice);
349	if (error == ENOIOCTL)
350		error = dp->d_devsw->d_ioctl(dev, cmd, data, fflag, p);
351	return (error);
352}
353
354static int
355diskpsize(dev_t dev)
356{
357	struct disk *dp;
358	dev_t pdev;
359
360	pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART);
361	dp = pdev->si_disk;
362	if (!dp)
363		return (-1);
364	if (dp != dev->si_disk) {
365		dev->si_drv1 = pdev->si_drv1;
366		dev->si_drv2 = pdev->si_drv2;
367		/* XXX: don't set bp->b_dev->si_disk (?) */
368	}
369	return (dssize(dev, &dp->d_slice));
370}
371
372SYSCTL_DECL(_debug_sizeof);
373
374SYSCTL_INT(_debug_sizeof, OID_AUTO, disklabel, CTLFLAG_RD,
375    0, sizeof(struct disklabel), "sizeof(struct disklabel)");
376
377SYSCTL_INT(_debug_sizeof, OID_AUTO, diskslices, CTLFLAG_RD,
378    0, sizeof(struct diskslices), "sizeof(struct diskslices)");
379
380SYSCTL_INT(_debug_sizeof, OID_AUTO, disk, CTLFLAG_RD,
381    0, sizeof(struct disk), "sizeof(struct disk)");
382