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$ 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 25 static MALLOC_DEFINE(M_DISK, "disk", "disk data"); 26 27 static d_strategy_t diskstrategy; 28 static d_open_t diskopen; 29 static d_close_t diskclose; 30 static d_ioctl_t diskioctl; 31 static d_psize_t diskpsize; 32 33 static LIST_HEAD(, disk) disklist = LIST_HEAD_INITIALIZER(&disklist); 34 35 static void 36 disk_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 94 static void 95 inherit_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 105 dev_t 106 disk_create(int unit, struct disk *dp, int flags, struct cdevsw *cdevsw, struct cdevsw *proto) 107 { 108 static int once; 109 dev_t dev; 110 111 if (!once) { 112 EVENTHANDLER_REGISTER(dev_clone, disk_clone, 0, 1000); 113 once++; 114 } 115 116 bzero(dp, sizeof(*dp)); 117 118 if (proto->d_open != diskopen) { 119 *proto = *cdevsw; 120 proto->d_open = diskopen; 121 proto->d_close = diskclose; 122 proto->d_ioctl = diskioctl; 123 proto->d_strategy = diskstrategy; 124 proto->d_psize = diskpsize; 125 cdevsw_add(proto); 126 } 127 128 if (bootverbose) 129 printf("Creating DISK %s%d\n", cdevsw->d_name, unit); 130 dev = make_dev(proto, dkmakeminor(unit, WHOLE_DISK_SLICE, RAW_PART), 131 UID_ROOT, GID_OPERATOR, 0640, "%s%d", cdevsw->d_name, unit); 132 133 dev->si_disk = dp; 134 dp->d_dev = dev; 135 dp->d_dsflags = flags; 136 dp->d_devsw = cdevsw; 137 LIST_INSERT_HEAD(&disklist, dp, d_list); 138 139 return (dev); 140 } 141 142 int 143 disk_dumpcheck(dev_t dev, u_int *count, u_int *blkno, u_int *secsize) 144 { 145 struct disk *dp; 146 struct disklabel *dl; 147 u_int boff; 148 149 dp = dev->si_disk; 150 if (!dp) 151 return (ENXIO); 152 if (!dp->d_slice) 153 return (ENXIO); 154 dl = dsgetlabel(dev, dp->d_slice); 155 if (!dl) 156 return (ENXIO); 157 *count = (u_long)Maxmem * PAGE_SIZE / dl->d_secsize; 158 if (dumplo < 0 || 159 (dumplo + *count > dl->d_partitions[dkpart(dev)].p_size)) 160 return (EINVAL); 161 boff = dl->d_partitions[dkpart(dev)].p_offset + 162 dp->d_slice->dss_slices[dkslice(dev)].ds_offset; 163 *blkno = boff + dumplo; 164 *secsize = dl->d_secsize; 165 return (0); 166 167 } 168 169 void 170 disk_invalidate (struct disk *disk) 171 { 172 if (disk->d_slice) 173 dsgone(&disk->d_slice); 174 } 175 176 void 177 disk_destroy(dev_t dev) 178 { 179 LIST_REMOVE(dev->si_disk, d_list); 180 bzero(dev->si_disk, sizeof(*dev->si_disk)); 181 dev->si_disk = NULL; 182 destroy_dev(dev); 183 return; 184 } 185 186 struct disk * 187 disk_enumerate(struct disk *disk) 188 { 189 if (!disk) 190 return (LIST_FIRST(&disklist)); 191 else 192 return (LIST_NEXT(disk, d_list)); 193 } 194 195 static int 196 sysctl_disks(SYSCTL_HANDLER_ARGS) 197 { 198 struct disk *disk; 199 int error, first; 200 201 disk = NULL; 202 first = 1; 203 204 while ((disk = disk_enumerate(disk))) { 205 if (!first) { 206 error = SYSCTL_OUT(req, " ", 1); 207 if (error) 208 return error; 209 } else { 210 first = 0; 211 } 212 error = SYSCTL_OUT(req, disk->d_dev->si_name, strlen(disk->d_dev->si_name)); 213 if (error) 214 return error; 215 } 216 error = SYSCTL_OUT(req, "", 1); 217 return error; 218 } 219 220 SYSCTL_PROC(_kern, OID_AUTO, disks, CTLTYPE_STRING | CTLFLAG_RD, 0, NULL, 221 sysctl_disks, "A", "names of available disks"); 222 223 /* 224 * The cdevsw functions 225 */ 226 227 static int 228 diskopen(dev_t dev, int oflags, int devtype, struct proc *p) 229 { 230 dev_t pdev; 231 struct disk *dp; 232 int error; 233 234 error = 0; 235 pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART); 236 237 dp = pdev->si_disk; 238 if (!dp) 239 return (ENXIO); 240 241 while (dp->d_flags & DISKFLAG_LOCK) { 242 dp->d_flags |= DISKFLAG_WANTED; 243 error = tsleep(dp, PRIBIO | PCATCH, "diskopen", hz); 244 if (error) 245 return (error); 246 } 247 dp->d_flags |= DISKFLAG_LOCK; 248 249 if (!dsisopen(dp->d_slice)) { 250 if (!pdev->si_iosize_max) 251 pdev->si_iosize_max = dev->si_iosize_max; 252 error = dp->d_devsw->d_open(pdev, oflags, devtype, p); 253 } 254 255 /* Inherit properties from the whole/raw dev_t */ 256 inherit_raw(pdev, dev); 257 258 if (error) 259 goto out; 260 261 error = dsopen(dev, devtype, dp->d_dsflags, &dp->d_slice, &dp->d_label); 262 263 if (!dsisopen(dp->d_slice)) 264 dp->d_devsw->d_close(pdev, oflags, devtype, p); 265 out: 266 dp->d_flags &= ~DISKFLAG_LOCK; 267 if (dp->d_flags & DISKFLAG_WANTED) { 268 dp->d_flags &= ~DISKFLAG_WANTED; 269 wakeup(dp); 270 } 271 272 return(error); 273 } 274 275 static int 276 diskclose(dev_t dev, int fflag, int devtype, struct proc *p) 277 { 278 struct disk *dp; 279 int error; 280 dev_t pdev; 281 282 error = 0; 283 pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART); 284 dp = pdev->si_disk; 285 if (!dp) 286 return (ENXIO); 287 dsclose(dev, devtype, dp->d_slice); 288 if (!dsisopen(dp->d_slice)) 289 error = dp->d_devsw->d_close(dp->d_dev, fflag, devtype, p); 290 return (error); 291 } 292 293 static void 294 diskstrategy(struct bio *bp) 295 { 296 dev_t pdev; 297 struct disk *dp; 298 299 pdev = dkmodpart(dkmodslice(bp->bio_dev, WHOLE_DISK_SLICE), RAW_PART); 300 dp = pdev->si_disk; 301 bp->bio_resid = bp->bio_bcount; 302 if (dp != bp->bio_dev->si_disk) 303 inherit_raw(pdev, bp->bio_dev); 304 305 if (!dp) { 306 biofinish(bp, NULL, ENXIO); 307 return; 308 } 309 310 if (dscheck(bp, dp->d_slice) <= 0) { 311 biodone(bp); 312 return; 313 } 314 315 if (bp->bio_bcount == 0) { 316 biodone(bp); 317 return; 318 } 319 320 KASSERT(dp->d_devsw != NULL, ("NULL devsw")); 321 KASSERT(dp->d_devsw->d_strategy != NULL, ("NULL d_strategy")); 322 dp->d_devsw->d_strategy(bp); 323 return; 324 325 } 326 327 static int 328 diskioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p) 329 { 330 struct disk *dp; 331 int error; 332 dev_t pdev; 333 334 pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART); 335 dp = pdev->si_disk; 336 if (!dp) 337 return (ENXIO); 338 error = dsioctl(dev, cmd, data, fflag, &dp->d_slice); 339 if (error == ENOIOCTL) 340 error = dp->d_devsw->d_ioctl(dev, cmd, data, fflag, p); 341 return (error); 342 } 343 344 static int 345 diskpsize(dev_t dev) 346 { 347 struct disk *dp; 348 dev_t pdev; 349 350 pdev = dkmodpart(dkmodslice(dev, WHOLE_DISK_SLICE), RAW_PART); 351 dp = pdev->si_disk; 352 if (!dp) 353 return (-1); 354 if (dp != dev->si_disk) { 355 dev->si_drv1 = pdev->si_drv1; 356 dev->si_drv2 = pdev->si_drv2; 357 /* XXX: don't set bp->b_dev->si_disk (?) */ 358 } 359 return (dssize(dev, &dp->d_slice)); 360 } 361 362 SYSCTL_DECL(_debug_sizeof); 363 364 SYSCTL_INT(_debug_sizeof, OID_AUTO, disklabel, CTLFLAG_RD, 365 0, sizeof(struct disklabel), "sizeof(struct disklabel)"); 366 367 SYSCTL_INT(_debug_sizeof, OID_AUTO, diskslices, CTLFLAG_RD, 368 0, sizeof(struct diskslices), "sizeof(struct diskslices)"); 369 370 SYSCTL_INT(_debug_sizeof, OID_AUTO, disk, CTLFLAG_RD, 371 0, sizeof(struct disk), "sizeof(struct disk)"); 372