1 /*-
2 * Copyright (c) 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * %sccs.include.redist.c%
6 *
7 * @(#)conf.c 8.5 (Berkeley) 01/09/95
8 */
9
10 #include <sys/param.h>
11 #include <sys/systm.h>
12 #include <sys/buf.h>
13 #include <sys/ioctl.h>
14 #include <sys/proc.h>
15 #include <sys/vnode.h>
16 #include <sys/tty.h>
17 #include <sys/conf.h>
18
19 int rawread __P((dev_t, struct uio *, int));
20 int rawwrite __P((dev_t, struct uio *, int));
21 void swstrategy __P((struct buf *));
22 int ttselect __P((dev_t, int, struct proc *));
23
24 #define dev_type_open(n) int n __P((dev_t, int, int, struct proc *))
25 #define dev_type_close(n) int n __P((dev_t, int, int, struct proc *))
26 #define dev_type_strategy(n) void n __P((struct buf *))
27 #define dev_type_ioctl(n) \
28 int n __P((dev_t, u_long, caddr_t, int, struct proc *))
29
30 /* bdevsw-specific types */
31 #define dev_type_dump(n) int n __P(())
32 #define dev_type_size(n) int n __P((dev_t))
33
34 #define dev_decl(n,t) __CONCAT(dev_type_,t)(__CONCAT(n,t))
35 #define dev_init(c,n,t) \
36 (c > 0 ? __CONCAT(n,t) : (__CONCAT(dev_type_,t)((*))) enxio)
37
38 /* bdevsw-specific initializations */
39 #define dev_size_init(c,n) (c > 0 ? __CONCAT(n,size) : 0)
40
41 #define bdev_decl(n) \
42 dev_decl(n,open); dev_decl(n,close); dev_decl(n,strategy); \
43 dev_decl(n,ioctl); dev_decl(n,dump); dev_decl(n,size)
44
45 /* disk without close routine */
46 #define bdev_disk_init(c,n) { \
47 dev_init(c,n,open), (dev_type_close((*))) nullop, \
48 dev_init(c,n,strategy), dev_init(c,n,ioctl), \
49 dev_init(c,n,dump), dev_size_init(c,n), 0 }
50
51 /* disk with close routine */
52 #define bdev_ldisk_init(c,n) { \
53 dev_init(c,n,open), dev_init(c,n,close), \
54 dev_init(c,n,strategy), dev_init(c,n,ioctl), \
55 dev_init(c,n,dump), dev_size_init(c,n), D_DISK }
56
57 #define bdev_tape_init(c,n) { \
58 dev_init(c,n,open), dev_init(c,n,close), \
59 dev_init(c,n,strategy), dev_init(c,n,ioctl), \
60 dev_init(c,n,dump), 0, D_TAPE }
61
62 #define bdev_swap_init() { \
63 (dev_type_open((*))) enodev, (dev_type_close((*))) enodev, \
64 swstrategy, (dev_type_ioctl((*))) enodev, \
65 (dev_type_dump((*))) enodev, 0 }
66
67 #define bdev_notdef() bdev_tape_init(0,no)
68 bdev_decl(no); /* dummy declarations */
69
70 #include "ct.h"
71 #include "st.h"
72 #include "rd.h"
73 #include "sd.h"
74 #include "cd.h"
75 #include "vn.h"
76
77 bdev_decl(ct);
78 bdev_decl(st);
79 bdev_decl(rd);
80 bdev_decl(sd);
81 bdev_decl(cd);
82 bdev_decl(vn);
83
84 struct bdevsw bdevsw[] =
85 {
86 bdev_tape_init(NCT,ct), /* 0: cs80 cartridge tape */
87 bdev_notdef(), /* 1 */
88 bdev_ldisk_init(NRD,rd),/* 2: hpib disk */
89 bdev_swap_init(), /* 3: swap pseudo-device */
90 bdev_ldisk_init(NSD,sd),/* 4: scsi disk */
91 bdev_disk_init(NCD,cd), /* 5: concatenated disk driver */
92 bdev_disk_init(NVN,vn), /* 6: vnode disk driver (swap to files) */
93 bdev_tape_init(NST,st), /* 7: exabyte tape */
94 };
95
96 int nblkdev = sizeof (bdevsw) / sizeof (bdevsw[0]);
97
98 /* cdevsw-specific types */
99 #define dev_type_read(n) int n __P((dev_t, struct uio *, int))
100 #define dev_type_write(n) int n __P((dev_t, struct uio *, int))
101 #define dev_type_stop(n) int n __P((struct tty *, int))
102 #define dev_type_reset(n) int n __P((int))
103 #define dev_type_select(n) int n __P((dev_t, int, struct proc *))
104 #define dev_type_map(n) int n __P(())
105
106 #define cdev_decl(n) \
107 dev_decl(n,open); dev_decl(n,close); dev_decl(n,read); \
108 dev_decl(n,write); dev_decl(n,ioctl); dev_decl(n,stop); \
109 dev_decl(n,reset); dev_decl(n,select); dev_decl(n,map); \
110 dev_decl(n,strategy); extern struct tty __CONCAT(n,_tty)[]
111
112 #define dev_tty_init(c,n) (c > 0 ? __CONCAT(n,_tty) : 0)
113
114 /* open, read, write, ioctl, strategy */
115 #define cdev_disk_init(c,n) { \
116 dev_init(c,n,open), (dev_type_close((*))) nullop, dev_init(c,n,read), \
117 dev_init(c,n,write), dev_init(c,n,ioctl), (dev_type_stop((*))) enodev, \
118 (dev_type_reset((*))) nullop, 0, seltrue, (dev_type_map((*))) enodev, \
119 dev_init(c,n,strategy), D_DISK }
120
121 /* open, close, read, write, ioctl, strategy */
122 #define cdev_ldisk_init(c,n) { \
123 dev_init(c,n,open), dev_init(c,n,close), dev_init(c,n,read), \
124 dev_init(c,n,write), dev_init(c,n,ioctl), (dev_type_stop((*))) enodev, \
125 (dev_type_reset((*))) nullop, 0, seltrue, (dev_type_map((*))) enodev, \
126 dev_init(c,n,strategy), D_TAPE }
127
128 /* open, close, read, write, ioctl, strategy */
129 #define cdev_tape_init(c,n) { \
130 dev_init(c,n,open), dev_init(c,n,close), dev_init(c,n,read), \
131 dev_init(c,n,write), dev_init(c,n,ioctl), (dev_type_stop((*))) enodev, \
132 (dev_type_reset((*))) nullop, 0, seltrue, (dev_type_map((*))) enodev, \
133 dev_init(c,n,strategy) }
134
135 /* open, close, read, write, ioctl, stop, tty */
136 #define cdev_tty_init(c,n) { \
137 dev_init(c,n,open), dev_init(c,n,close), dev_init(c,n,read), \
138 dev_init(c,n,write), dev_init(c,n,ioctl), dev_init(c,n,stop), \
139 (dev_type_reset((*))) nullop, dev_tty_init(c,n), ttselect, \
140 (dev_type_map((*))) enodev, 0, D_TTY }
141
142 #define cdev_notdef() { \
143 (dev_type_open((*))) enodev, (dev_type_close((*))) enodev, \
144 (dev_type_read((*))) enodev, (dev_type_write((*))) enodev, \
145 (dev_type_ioctl((*))) enodev, (dev_type_stop((*))) enodev, \
146 (dev_type_reset((*))) nullop, 0, seltrue, \
147 (dev_type_map((*))) enodev, 0 }
148
149 cdev_decl(no); /* dummy declarations */
150
151 cdev_decl(cn);
152 /* open, close, read, write, ioctl, select -- XXX should be a tty */
153 #define cdev_cn_init(c,n) { \
154 dev_init(c,n,open), dev_init(c,n,close), dev_init(c,n,read), \
155 dev_init(c,n,write), dev_init(c,n,ioctl), (dev_type_stop((*))) nullop, \
156 (dev_type_reset((*))) nullop, 0, dev_init(c,n,select), \
157 (dev_type_map((*))) enodev, 0, D_TTY }
158
159 cdev_decl(ctty);
160 /* open, read, write, ioctl, select -- XXX should be a tty */
161 #define cdev_ctty_init(c,n) { \
162 dev_init(c,n,open), (dev_type_close((*))) nullop, dev_init(c,n,read), \
163 dev_init(c,n,write), dev_init(c,n,ioctl), (dev_type_stop((*))) nullop, \
164 (dev_type_reset((*))) nullop, 0, dev_init(c,n,select), \
165 (dev_type_map((*))) enodev, 0, D_TTY }
166
167 dev_type_read(mmrw);
168 dev_type_map(mmmap);
169 /* read, write, mmap */
170 #define cdev_mm_init(c,n) { \
171 (dev_type_open((*))) nullop, (dev_type_close((*))) nullop, mmrw, \
172 mmrw, (dev_type_ioctl((*))) enodev, (dev_type_stop((*))) nullop, \
173 (dev_type_reset((*))) nullop, 0, seltrue, mmmap, 0 }
174
175 /* read, write, strategy */
176 #define cdev_swap_init(c,n) { \
177 (dev_type_open((*))) nullop, (dev_type_close((*))) nullop, rawread, \
178 rawwrite, (dev_type_ioctl((*))) enodev, (dev_type_stop((*))) enodev, \
179 (dev_type_reset((*))) nullop, 0, (dev_type_select((*))) enodev, \
180 (dev_type_map((*))) enodev, dev_init(c,n,strategy) }
181
182 #include "pty.h"
183 #define pts_tty pt_tty
184 #define ptsioctl ptyioctl
185 cdev_decl(pts);
186 #define ptc_tty pt_tty
187 #define ptcioctl ptyioctl
188 cdev_decl(ptc);
189
190 /* open, close, read, write, ioctl, tty, select */
191 #define cdev_ptc_init(c,n) { \
192 dev_init(c,n,open), dev_init(c,n,close), dev_init(c,n,read), \
193 dev_init(c,n,write), dev_init(c,n,ioctl), (dev_type_stop((*))) nullop, \
194 (dev_type_reset((*))) nullop, dev_tty_init(c,n), dev_init(c,n,select), \
195 (dev_type_map((*))) enodev, 0, D_TTY }
196
197 cdev_decl(log);
198 /* open, close, read, ioctl, select -- XXX should be a generic device */
199 #define cdev_log_init(c,n) { \
200 dev_init(c,n,open), dev_init(c,n,close), dev_init(c,n,read), \
201 (dev_type_write((*))) enodev, dev_init(c,n,ioctl), \
202 (dev_type_stop((*))) enodev, (dev_type_reset((*))) nullop, 0, \
203 dev_init(c,n,select), (dev_type_map((*))) enodev, 0 }
204
205 cdev_decl(ct);
206 cdev_decl(st);
207 cdev_decl(sd);
208 cdev_decl(rd);
209
210 #include "grf.h"
211 cdev_decl(grf);
212 /* open, close, ioctl, select, map -- XXX should be a map device */
213 #define cdev_grf_init(c,n) { \
214 dev_init(c,n,open), dev_init(c,n,close), (dev_type_read((*))) nullop, \
215 (dev_type_write((*))) nullop, dev_init(c,n,ioctl), \
216 (dev_type_stop((*))) enodev, (dev_type_reset((*))) nullop, 0, \
217 dev_init(c,n,select), dev_init(c,n,map), 0 }
218
219 #include "ppi.h"
220 cdev_decl(ppi);
221 /* open, close, read, write, ioctl -- XXX should be a generic device */
222 #define cdev_ppi_init(c,n) { \
223 dev_init(c,n,open), dev_init(c,n,close), dev_init(c,n,read), \
224 dev_init(c,n,write), dev_init(c,n,ioctl), (dev_type_stop((*))) nullop, \
225 (dev_type_reset((*))) nullop, 0, (dev_type_select((*))) enodev, \
226 (dev_type_map((*))) enodev, 0 }
227
228 #include "dca.h"
229 cdev_decl(dca);
230
231 #include "ite.h"
232 cdev_decl(ite);
233 /* open, close, read, write, ioctl, tty -- XXX should be a tty! */
234 #define cdev_ite_init(c,n) { \
235 dev_init(c,n,open), dev_init(c,n,close), dev_init(c,n,read), \
236 dev_init(c,n,write), dev_init(c,n,ioctl), (dev_type_stop((*))) enodev, \
237 (dev_type_reset((*))) nullop, dev_tty_init(c,n), ttselect, \
238 (dev_type_map((*))) enodev, 0, D_TTY }
239
240 /* XXX shouldn't this be optional? */
241 cdev_decl(hil);
242 /* open, close, read, ioctl, select, map -- XXX should be a map device */
243 #define cdev_hil_init(c,n) { \
244 dev_init(c,n,open), dev_init(c,n,close), dev_init(c,n,read), \
245 (dev_type_write((*))) nullop, dev_init(c,n,ioctl), \
246 (dev_type_stop((*))) enodev, (dev_type_reset((*))) nullop, 0, \
247 dev_init(c,n,select), dev_init(c,n,map), 0 }
248
249 #include "dcm.h"
250 cdev_decl(dcm);
251
252 cdev_decl(cd);
253
254 cdev_decl(vn);
255 /* open, read, write, ioctl -- XXX should be a disk */
256 #define cdev_vn_init(c,n) { \
257 dev_init(c,n,open), (dev_type_close((*))) nullop, dev_init(c,n,read), \
258 dev_init(c,n,write), dev_init(c,n,ioctl), (dev_type_stop((*))) enodev, \
259 (dev_type_reset((*))) nullop, 0, seltrue, (dev_type_map((*))) enodev, \
260 (dev_type_strategy((*))) nullop, D_DISK }
261
262 dev_type_open(fdopen);
263 /* open */
264 #define cdev_fd_init(c,n) { \
265 dev_init(c,n,open), (dev_type_close((*))) enodev, \
266 (dev_type_read((*))) enodev, (dev_type_write((*))) enodev, \
267 (dev_type_ioctl((*))) enodev, (dev_type_stop((*))) enodev, \
268 (dev_type_reset((*))) enodev, 0, (dev_type_select((*))) enodev, \
269 (dev_type_map((*))) enodev, 0 }
270
271 #include "bpfilter.h"
272 cdev_decl(bpf);
273 /* open, close, read, write, ioctl, select -- XXX should be generic device */
274 #define cdev_bpf_init(c,n) { \
275 dev_init(c,n,open), dev_init(c,n,close), dev_init(c,n,read), \
276 dev_init(c,n,write), dev_init(c,n,ioctl), (dev_type_stop((*))) enodev, \
277 (dev_type_reset((*))) enodev, 0, dev_init(c,n,select), \
278 (dev_type_map((*))) enodev, 0 }
279
280 struct cdevsw cdevsw[] =
281 {
282 cdev_cn_init(1,cn), /* 0: virtual console */
283 cdev_ctty_init(1,ctty), /* 1: controlling terminal */
284 cdev_mm_init(1,mm), /* 2: /dev/{null,mem,kmem,...} */
285 cdev_swap_init(1,sw), /* 3: /dev/drum (swap pseudo-device) */
286 cdev_tty_init(NPTY,pts), /* 4: pseudo-tty slave */
287 cdev_ptc_init(NPTY,ptc), /* 5: pseudo-tty master */
288 cdev_log_init(1,log), /* 6: /dev/klog */
289 cdev_tape_init(NCT,ct), /* 7: cs80 cartridge tape */
290 cdev_ldisk_init(NSD,sd), /* 8: scsi disk */
291 cdev_ldisk_init(NRD,rd), /* 9: hpib disk */
292 cdev_grf_init(NGRF,grf), /* 10: frame buffer */
293 cdev_ppi_init(NPPI,ppi), /* 11: printer/plotter interface */
294 cdev_tty_init(NDCA,dca), /* 12: built-in single-port serial */
295 cdev_ite_init(NITE,ite), /* 13: console terminal emulator */
296 cdev_hil_init(1,hil), /* 14: human interface loop */
297 cdev_tty_init(NDCM,dcm), /* 15: 4-port serial */
298 cdev_notdef(), /* 16 */
299 cdev_disk_init(NCD,cd), /* 17: concatenated disk */
300 cdev_notdef(), /* 18 */
301 cdev_vn_init(NVN,vn), /* 19: vnode disk */
302 cdev_tape_init(NST,st), /* 20: exabyte tape */
303 cdev_fd_init(1,fd), /* 21: file descriptor pseudo-dev */
304 cdev_bpf_init(NBPFILTER,bpf), /* 22: berkeley packet filter */
305 };
306
307 int nchrdev = sizeof (cdevsw) / sizeof (cdevsw[0]);
308
309 int mem_no = 2; /* major device number of memory special file */
310
311 /*
312 * Swapdev is a fake device implemented
313 * in sw.c used only internally to get to swstrategy.
314 * It cannot be provided to the users, because the
315 * swstrategy routine munches the b_dev and b_blkno entries
316 * before calling the appropriate driver. This would horribly
317 * confuse, e.g. the hashing routines. Instead, /dev/drum is
318 * provided as a character (raw) device.
319 */
320 dev_t swapdev = makedev(3, 0);
321
322 /*
323 * Routine that identifies /dev/mem and /dev/kmem.
324 *
325 * A minimal stub routine can always return 0.
326 */
iskmemdev(dev)327 iskmemdev(dev)
328 dev_t dev;
329 {
330
331 return (major(dev) == 2 && minor(dev) < 2);
332 }
333
iszerodev(dev)334 iszerodev(dev)
335 dev_t dev;
336 {
337
338 return (major(dev) == 2 && minor(dev) == 12);
339 }
340
341 #define MAXDEV 21
342 static int chrtoblktbl[MAXDEV] = {
343 /* VCHR */ /* VBLK */
344 /* 0 */ NODEV,
345 /* 1 */ NODEV,
346 /* 2 */ NODEV,
347 /* 3 */ NODEV,
348 /* 4 */ NODEV,
349 /* 5 */ NODEV,
350 /* 6 */ NODEV,
351 /* 7 */ 0,
352 /* 8 */ 4,
353 /* 9 */ 2,
354 /* 10 */ NODEV,
355 /* 11 */ NODEV,
356 /* 12 */ NODEV,
357 /* 13 */ NODEV,
358 /* 14 */ NODEV,
359 /* 15 */ NODEV,
360 /* 16 */ NODEV,
361 /* 17 */ 5,
362 /* 18 */ NODEV,
363 /* 19 */ 6,
364 /* 20 */ 7,
365 };
366 /*
367 * Routine to convert from character to block device number.
368 *
369 * A minimal stub routine can always return NODEV.
370 */
chrtoblk(dev)371 chrtoblk(dev)
372 dev_t dev;
373 {
374 int blkmaj;
375
376 if (major(dev) >= MAXDEV || (blkmaj = chrtoblktbl[major(dev)]) == NODEV)
377 return (NODEV);
378 return (makedev(blkmaj, minor(dev)));
379 }
380