157 dp->d_flags |= DISKFLAG_OPEN;
158 if (dp->d_maxsize == 0) {
159 printf("WARNING: Disk drive %s%d has no d_maxsize\n",
160 dp->d_name, dp->d_unit);
161 dp->d_maxsize = DFLTPHYS;
162 }
163 } else if ((pp->acr + pp->acw + pp->ace) > 0 && (r + w + e) == 0) {
164 if (dp->d_close != NULL) {
165 g_disk_lock_giant(dp);
166 error = dp->d_close(dp);
167 if (error != 0)
168 printf("Closed disk %s -> %d\n",
169 pp->name, error);
170 g_disk_unlock_giant(dp);
171 }
172 sc->state = G_STATE_ACTIVE;
173 if (sc->led[0] != 0)
174 led_set(sc->led, "0");
175 dp->d_flags &= ~DISKFLAG_OPEN;
176 }
177 return (error);
178}
179
180static void
181g_disk_kerneldump(struct bio *bp, struct disk *dp)
182{
183 struct g_kerneldump *gkd;
184 struct g_geom *gp;
185
186 gkd = (struct g_kerneldump*)bp->bio_data;
187 gp = bp->bio_to->geom;
188 g_trace(G_T_TOPOLOGY, "g_disk_kernedump(%s, %jd, %jd)",
189 gp->name, (intmax_t)gkd->offset, (intmax_t)gkd->length);
190 if (dp->d_dump == NULL) {
191 g_io_deliver(bp, ENODEV);
192 return;
193 }
194 gkd->di.dumper = dp->d_dump;
195 gkd->di.priv = dp;
196 gkd->di.blocksize = dp->d_sectorsize;
197 gkd->di.maxiosize = dp->d_maxsize;
198 gkd->di.mediaoffset = gkd->offset;
199 if ((gkd->offset + gkd->length) > dp->d_mediasize)
200 gkd->length = dp->d_mediasize - gkd->offset;
201 gkd->di.mediasize = gkd->length;
202 g_io_deliver(bp, 0);
203}
204
205static void
206g_disk_setstate(struct bio *bp, struct g_disk_softc *sc)
207{
208 const char *cmd;
209
210 memcpy(&sc->state, bp->bio_data, sizeof(sc->state));
211 if (sc->led[0] != 0) {
212 switch (sc->state) {
213 case G_STATE_FAILED:
214 cmd = "1";
215 break;
216 case G_STATE_REBUILD:
217 cmd = "f5";
218 break;
219 case G_STATE_RESYNC:
220 cmd = "f1";
221 break;
222 default:
223 cmd = "0";
224 break;
225 }
226 led_set(sc->led, cmd);
227 }
228 g_io_deliver(bp, 0);
229}
230
231static void
232g_disk_done(struct bio *bp)
233{
234 struct bio *bp2;
235 struct disk *dp;
236 struct g_disk_softc *sc;
237
238 /* See "notes" for why we need a mutex here */
239 /* XXX: will witness accept a mix of Giant/unGiant drivers here ? */
240 mtx_lock(&g_disk_done_mtx);
241 bp->bio_completed = bp->bio_length - bp->bio_resid;
242
243 bp2 = bp->bio_parent;
244 if (bp2->bio_error == 0)
245 bp2->bio_error = bp->bio_error;
246 bp2->bio_completed += bp->bio_completed;
247 if ((bp->bio_cmd & (BIO_READ|BIO_WRITE|BIO_DELETE)) &&
248 (sc = bp2->bio_to->geom->softc) &&
249 (dp = sc->dp)) {
250 devstat_end_transaction_bio(dp->d_devstat, bp);
251 }
252 g_destroy_bio(bp);
253 bp2->bio_inbed++;
254 if (bp2->bio_children == bp2->bio_inbed) {
255 bp2->bio_resid = bp2->bio_bcount - bp2->bio_completed;
256 g_io_deliver(bp2, bp2->bio_error);
257 }
258 mtx_unlock(&g_disk_done_mtx);
259}
260
261static int
262g_disk_ioctl(struct g_provider *pp, u_long cmd, void * data, int fflag, struct thread *td)
263{
264 struct g_geom *gp;
265 struct disk *dp;
266 struct g_disk_softc *sc;
267 int error;
268
269 gp = pp->geom;
270 sc = gp->softc;
271 dp = sc->dp;
272
273 if (dp->d_ioctl == NULL)
274 return (ENOIOCTL);
275 g_disk_lock_giant(dp);
276 error = dp->d_ioctl(dp, cmd, data, fflag, td);
277 g_disk_unlock_giant(dp);
278 return(error);
279}
280
281static void
282g_disk_start(struct bio *bp)
283{
284 struct bio *bp2, *bp3;
285 struct disk *dp;
286 struct g_disk_softc *sc;
287 int error;
288 off_t off;
289
290 sc = bp->bio_to->geom->softc;
291 if (sc == NULL || (dp = sc->dp) == NULL || dp->d_destroyed) {
292 g_io_deliver(bp, ENXIO);
293 return;
294 }
295 error = EJUSTRETURN;
296 switch(bp->bio_cmd) {
297 case BIO_DELETE:
298 if (!(dp->d_flags & DISKFLAG_CANDELETE)) {
299 error = 0;
300 break;
301 }
302 /* fall-through */
303 case BIO_READ:
304 case BIO_WRITE:
305 off = 0;
306 bp3 = NULL;
307 bp2 = g_clone_bio(bp);
308 if (bp2 == NULL) {
309 error = ENOMEM;
310 break;
311 }
312 do {
313 bp2->bio_offset += off;
314 bp2->bio_length -= off;
315 bp2->bio_data += off;
316 if (bp2->bio_length > dp->d_maxsize) {
317 /*
318 * XXX: If we have a stripesize we should really
319 * use it here.
320 */
321 bp2->bio_length = dp->d_maxsize;
322 off += dp->d_maxsize;
323 /*
324 * To avoid a race, we need to grab the next bio
325 * before we schedule this one. See "notes".
326 */
327 bp3 = g_clone_bio(bp);
328 if (bp3 == NULL)
329 bp->bio_error = ENOMEM;
330 }
331 bp2->bio_done = g_disk_done;
332 bp2->bio_pblkno = bp2->bio_offset / dp->d_sectorsize;
333 bp2->bio_bcount = bp2->bio_length;
334 bp2->bio_disk = dp;
335 devstat_start_transaction_bio(dp->d_devstat, bp2);
336 g_disk_lock_giant(dp);
337 dp->d_strategy(bp2);
338 g_disk_unlock_giant(dp);
339 bp2 = bp3;
340 bp3 = NULL;
341 } while (bp2 != NULL);
342 break;
343 case BIO_GETATTR:
344 if (g_handleattr_int(bp, "GEOM::candelete",
345 (dp->d_flags & DISKFLAG_CANDELETE) != 0))
346 break;
347 else if (g_handleattr_int(bp, "GEOM::fwsectors",
348 dp->d_fwsectors))
349 break;
350 else if (g_handleattr_int(bp, "GEOM::fwheads", dp->d_fwheads))
351 break;
352 else if (g_handleattr_off_t(bp, "GEOM::frontstuff", 0))
353 break;
354 else if (g_handleattr_str(bp, "GEOM::ident", dp->d_ident))
355 break;
356 else if (g_handleattr(bp, "GEOM::hba_vendor",
357 &dp->d_hba_vendor, 2))
358 break;
359 else if (g_handleattr(bp, "GEOM::hba_device",
360 &dp->d_hba_device, 2))
361 break;
362 else if (g_handleattr(bp, "GEOM::hba_subvendor",
363 &dp->d_hba_subvendor, 2))
364 break;
365 else if (g_handleattr(bp, "GEOM::hba_subdevice",
366 &dp->d_hba_subdevice, 2))
367 break;
368 else if (!strcmp(bp->bio_attribute, "GEOM::kerneldump"))
369 g_disk_kerneldump(bp, dp);
370 else if (!strcmp(bp->bio_attribute, "GEOM::setstate"))
371 g_disk_setstate(bp, sc);
372 else
373 error = ENOIOCTL;
374 break;
375 case BIO_FLUSH:
376 g_trace(G_T_TOPOLOGY, "g_disk_flushcache(%s)",
377 bp->bio_to->name);
378 if (!(dp->d_flags & DISKFLAG_CANFLUSHCACHE)) {
379 g_io_deliver(bp, ENODEV);
380 return;
381 }
382 bp2 = g_clone_bio(bp);
383 if (bp2 == NULL) {
384 g_io_deliver(bp, ENOMEM);
385 return;
386 }
387 bp2->bio_done = g_disk_done;
388 bp2->bio_disk = dp;
389 g_disk_lock_giant(dp);
390 dp->d_strategy(bp2);
391 g_disk_unlock_giant(dp);
392 break;
393 default:
394 error = EOPNOTSUPP;
395 break;
396 }
397 if (error != EJUSTRETURN)
398 g_io_deliver(bp, error);
399 return;
400}
401
402static void
403g_disk_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp, struct g_consumer *cp, struct g_provider *pp)
404{
405 struct disk *dp;
406 struct g_disk_softc *sc;
407
408 sc = gp->softc;
409 if (sc == NULL || (dp = sc->dp) == NULL)
410 return;
411 if (indent == NULL) {
412 sbuf_printf(sb, " hd %u", dp->d_fwheads);
413 sbuf_printf(sb, " sc %u", dp->d_fwsectors);
414 return;
415 }
416 if (pp != NULL) {
417 sbuf_printf(sb, "%s<fwheads>%u</fwheads>\n",
418 indent, dp->d_fwheads);
419 sbuf_printf(sb, "%s<fwsectors>%u</fwsectors>\n",
420 indent, dp->d_fwsectors);
421 sbuf_printf(sb, "%s<ident>%s</ident>\n", indent, dp->d_ident);
422 sbuf_printf(sb, "%s<descr>%s</descr>\n", indent, dp->d_descr);
423 }
424}
425
426static void
427g_disk_create(void *arg, int flag)
428{
429 struct g_geom *gp;
430 struct g_provider *pp;
431 struct disk *dp;
432 struct g_disk_softc *sc;
433 char tmpstr[80];
434
435 if (flag == EV_CANCEL)
436 return;
437 g_topology_assert();
438 dp = arg;
439 sc = g_malloc(sizeof(*sc), M_WAITOK | M_ZERO);
440 sc->dp = dp;
441 gp = g_new_geomf(&g_disk_class, "%s%d", dp->d_name, dp->d_unit);
442 gp->softc = sc;
443 pp = g_new_providerf(gp, "%s", gp->name);
444 pp->mediasize = dp->d_mediasize;
445 pp->sectorsize = dp->d_sectorsize;
446 if (dp->d_flags & DISKFLAG_CANDELETE)
447 pp->flags |= G_PF_CANDELETE;
448 pp->stripeoffset = dp->d_stripeoffset;
449 pp->stripesize = dp->d_stripesize;
450 if (bootverbose)
451 printf("GEOM: new disk %s\n", gp->name);
452 sysctl_ctx_init(&sc->sysctl_ctx);
453 snprintf(tmpstr, sizeof(tmpstr), "GEOM disk %s", gp->name);
454 sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
455 SYSCTL_STATIC_CHILDREN(_kern_geom_disk), OID_AUTO, gp->name,
456 CTLFLAG_RD, 0, tmpstr);
457 if (sc->sysctl_tree != NULL) {
458 snprintf(tmpstr, sizeof(tmpstr),
459 "kern.geom.disk.%s.led", gp->name);
460 TUNABLE_STR_FETCH(tmpstr, sc->led, sizeof(sc->led));
461 SYSCTL_ADD_STRING(&sc->sysctl_ctx,
462 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, "led",
463 CTLFLAG_RW | CTLFLAG_TUN, sc->led, sizeof(sc->led),
464 "LED name");
465 }
466 pp->private = sc;
467 dp->d_geom = gp;
468 g_error_provider(pp, 0);
469}
470
471static void
472g_disk_destroy(void *ptr, int flag)
473{
474 struct disk *dp;
475 struct g_geom *gp;
476 struct g_disk_softc *sc;
477
478 g_topology_assert();
479 dp = ptr;
480 gp = dp->d_geom;
481 if (gp != NULL) {
482 sc = gp->softc;
483 if (sc->sysctl_tree != NULL) {
484 sysctl_ctx_free(&sc->sysctl_ctx);
485 sc->sysctl_tree = NULL;
486 }
487 if (sc->led[0] != 0) {
488 led_set(sc->led, "0");
489 sc->led[0] = 0;
490 }
491 g_free(sc);
492 gp->softc = NULL;
493 g_wither_geom(gp, ENXIO);
494 }
495 g_free(dp);
496}
497
498/*
499 * We only allow printable characters in disk ident,
500 * the rest is converted to 'x<HH>'.
501 */
502static void
503g_disk_ident_adjust(char *ident, size_t size)
504{
505 char *p, tmp[4], newid[DISK_IDENT_SIZE];
506
507 newid[0] = '\0';
508 for (p = ident; *p != '\0'; p++) {
509 if (isprint(*p)) {
510 tmp[0] = *p;
511 tmp[1] = '\0';
512 } else {
513 snprintf(tmp, sizeof(tmp), "x%02hhx",
514 *(unsigned char *)p);
515 }
516 if (strlcat(newid, tmp, sizeof(newid)) >= sizeof(newid))
517 break;
518 }
519 bzero(ident, size);
520 strlcpy(ident, newid, size);
521}
522
523struct disk *
524disk_alloc()
525{
526 struct disk *dp;
527
528 dp = g_malloc(sizeof *dp, M_WAITOK | M_ZERO);
529 return (dp);
530}
531
532void
533disk_create(struct disk *dp, int version)
534{
535 if (version != DISK_VERSION_00 && version != DISK_VERSION_01) {
536 printf("WARNING: Attempt to add disk %s%d %s",
537 dp->d_name, dp->d_unit,
538 " using incompatible ABI version of disk(9)\n");
539 printf("WARNING: Ignoring disk %s%d\n",
540 dp->d_name, dp->d_unit);
541 return;
542 }
543 KASSERT(dp->d_strategy != NULL, ("disk_create need d_strategy"));
544 KASSERT(dp->d_name != NULL, ("disk_create need d_name"));
545 KASSERT(*dp->d_name != 0, ("disk_create need d_name"));
546 KASSERT(strlen(dp->d_name) < SPECNAMELEN - 4, ("disk name too long"));
547 if (dp->d_devstat == NULL)
548 dp->d_devstat = devstat_new_entry(dp->d_name, dp->d_unit,
549 dp->d_sectorsize, DEVSTAT_ALL_SUPPORTED,
550 DEVSTAT_TYPE_DIRECT, DEVSTAT_PRIORITY_MAX);
551 dp->d_geom = NULL;
552 g_disk_ident_adjust(dp->d_ident, sizeof(dp->d_ident));
553 g_post_event(g_disk_create, dp, M_WAITOK, dp, NULL);
554}
555
556void
557disk_destroy(struct disk *dp)
558{
559
560 g_cancel_event(dp);
561 dp->d_destroyed = 1;
562 if (dp->d_devstat != NULL)
563 devstat_remove_entry(dp->d_devstat);
564 g_post_event(g_disk_destroy, dp, M_WAITOK, NULL);
565}
566
567void
568disk_gone(struct disk *dp)
569{
570 struct g_geom *gp;
571 struct g_provider *pp;
572
573 gp = dp->d_geom;
574 if (gp != NULL)
575 LIST_FOREACH(pp, &gp->provider, provider)
576 g_wither_provider(pp, ENXIO);
577}
578
579static void
580g_kern_disks(void *p, int flag __unused)
581{
582 struct sbuf *sb;
583 struct g_geom *gp;
584 char *sp;
585
586 sb = p;
587 sp = "";
588 g_topology_assert();
589 LIST_FOREACH(gp, &g_disk_class.geom, geom) {
590 sbuf_printf(sb, "%s%s", sp, gp->name);
591 sp = " ";
592 }
593 sbuf_finish(sb);
594}
595
596static int
597sysctl_disks(SYSCTL_HANDLER_ARGS)
598{
599 int error;
600 struct sbuf *sb;
601
602 sb = sbuf_new_auto();
603 g_waitfor_event(g_kern_disks, sb, M_WAITOK, NULL);
604 error = SYSCTL_OUT(req, sbuf_data(sb), sbuf_len(sb) + 1);
605 sbuf_delete(sb);
606 return error;
607}
608
609SYSCTL_PROC(_kern, OID_AUTO, disks,
610 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
611 sysctl_disks, "A", "names of available disks");
612
| 163 dp->d_flags |= DISKFLAG_OPEN;
164 if (dp->d_maxsize == 0) {
165 printf("WARNING: Disk drive %s%d has no d_maxsize\n",
166 dp->d_name, dp->d_unit);
167 dp->d_maxsize = DFLTPHYS;
168 }
169 } else if ((pp->acr + pp->acw + pp->ace) > 0 && (r + w + e) == 0) {
170 if (dp->d_close != NULL) {
171 g_disk_lock_giant(dp);
172 error = dp->d_close(dp);
173 if (error != 0)
174 printf("Closed disk %s -> %d\n",
175 pp->name, error);
176 g_disk_unlock_giant(dp);
177 }
178 sc->state = G_STATE_ACTIVE;
179 if (sc->led[0] != 0)
180 led_set(sc->led, "0");
181 dp->d_flags &= ~DISKFLAG_OPEN;
182 }
183 return (error);
184}
185
186static void
187g_disk_kerneldump(struct bio *bp, struct disk *dp)
188{
189 struct g_kerneldump *gkd;
190 struct g_geom *gp;
191
192 gkd = (struct g_kerneldump*)bp->bio_data;
193 gp = bp->bio_to->geom;
194 g_trace(G_T_TOPOLOGY, "g_disk_kernedump(%s, %jd, %jd)",
195 gp->name, (intmax_t)gkd->offset, (intmax_t)gkd->length);
196 if (dp->d_dump == NULL) {
197 g_io_deliver(bp, ENODEV);
198 return;
199 }
200 gkd->di.dumper = dp->d_dump;
201 gkd->di.priv = dp;
202 gkd->di.blocksize = dp->d_sectorsize;
203 gkd->di.maxiosize = dp->d_maxsize;
204 gkd->di.mediaoffset = gkd->offset;
205 if ((gkd->offset + gkd->length) > dp->d_mediasize)
206 gkd->length = dp->d_mediasize - gkd->offset;
207 gkd->di.mediasize = gkd->length;
208 g_io_deliver(bp, 0);
209}
210
211static void
212g_disk_setstate(struct bio *bp, struct g_disk_softc *sc)
213{
214 const char *cmd;
215
216 memcpy(&sc->state, bp->bio_data, sizeof(sc->state));
217 if (sc->led[0] != 0) {
218 switch (sc->state) {
219 case G_STATE_FAILED:
220 cmd = "1";
221 break;
222 case G_STATE_REBUILD:
223 cmd = "f5";
224 break;
225 case G_STATE_RESYNC:
226 cmd = "f1";
227 break;
228 default:
229 cmd = "0";
230 break;
231 }
232 led_set(sc->led, cmd);
233 }
234 g_io_deliver(bp, 0);
235}
236
237static void
238g_disk_done(struct bio *bp)
239{
240 struct bio *bp2;
241 struct disk *dp;
242 struct g_disk_softc *sc;
243
244 /* See "notes" for why we need a mutex here */
245 /* XXX: will witness accept a mix of Giant/unGiant drivers here ? */
246 mtx_lock(&g_disk_done_mtx);
247 bp->bio_completed = bp->bio_length - bp->bio_resid;
248
249 bp2 = bp->bio_parent;
250 if (bp2->bio_error == 0)
251 bp2->bio_error = bp->bio_error;
252 bp2->bio_completed += bp->bio_completed;
253 if ((bp->bio_cmd & (BIO_READ|BIO_WRITE|BIO_DELETE)) &&
254 (sc = bp2->bio_to->geom->softc) &&
255 (dp = sc->dp)) {
256 devstat_end_transaction_bio(dp->d_devstat, bp);
257 }
258 g_destroy_bio(bp);
259 bp2->bio_inbed++;
260 if (bp2->bio_children == bp2->bio_inbed) {
261 bp2->bio_resid = bp2->bio_bcount - bp2->bio_completed;
262 g_io_deliver(bp2, bp2->bio_error);
263 }
264 mtx_unlock(&g_disk_done_mtx);
265}
266
267static int
268g_disk_ioctl(struct g_provider *pp, u_long cmd, void * data, int fflag, struct thread *td)
269{
270 struct g_geom *gp;
271 struct disk *dp;
272 struct g_disk_softc *sc;
273 int error;
274
275 gp = pp->geom;
276 sc = gp->softc;
277 dp = sc->dp;
278
279 if (dp->d_ioctl == NULL)
280 return (ENOIOCTL);
281 g_disk_lock_giant(dp);
282 error = dp->d_ioctl(dp, cmd, data, fflag, td);
283 g_disk_unlock_giant(dp);
284 return(error);
285}
286
287static void
288g_disk_start(struct bio *bp)
289{
290 struct bio *bp2, *bp3;
291 struct disk *dp;
292 struct g_disk_softc *sc;
293 int error;
294 off_t off;
295
296 sc = bp->bio_to->geom->softc;
297 if (sc == NULL || (dp = sc->dp) == NULL || dp->d_destroyed) {
298 g_io_deliver(bp, ENXIO);
299 return;
300 }
301 error = EJUSTRETURN;
302 switch(bp->bio_cmd) {
303 case BIO_DELETE:
304 if (!(dp->d_flags & DISKFLAG_CANDELETE)) {
305 error = 0;
306 break;
307 }
308 /* fall-through */
309 case BIO_READ:
310 case BIO_WRITE:
311 off = 0;
312 bp3 = NULL;
313 bp2 = g_clone_bio(bp);
314 if (bp2 == NULL) {
315 error = ENOMEM;
316 break;
317 }
318 do {
319 bp2->bio_offset += off;
320 bp2->bio_length -= off;
321 bp2->bio_data += off;
322 if (bp2->bio_length > dp->d_maxsize) {
323 /*
324 * XXX: If we have a stripesize we should really
325 * use it here.
326 */
327 bp2->bio_length = dp->d_maxsize;
328 off += dp->d_maxsize;
329 /*
330 * To avoid a race, we need to grab the next bio
331 * before we schedule this one. See "notes".
332 */
333 bp3 = g_clone_bio(bp);
334 if (bp3 == NULL)
335 bp->bio_error = ENOMEM;
336 }
337 bp2->bio_done = g_disk_done;
338 bp2->bio_pblkno = bp2->bio_offset / dp->d_sectorsize;
339 bp2->bio_bcount = bp2->bio_length;
340 bp2->bio_disk = dp;
341 devstat_start_transaction_bio(dp->d_devstat, bp2);
342 g_disk_lock_giant(dp);
343 dp->d_strategy(bp2);
344 g_disk_unlock_giant(dp);
345 bp2 = bp3;
346 bp3 = NULL;
347 } while (bp2 != NULL);
348 break;
349 case BIO_GETATTR:
350 if (g_handleattr_int(bp, "GEOM::candelete",
351 (dp->d_flags & DISKFLAG_CANDELETE) != 0))
352 break;
353 else if (g_handleattr_int(bp, "GEOM::fwsectors",
354 dp->d_fwsectors))
355 break;
356 else if (g_handleattr_int(bp, "GEOM::fwheads", dp->d_fwheads))
357 break;
358 else if (g_handleattr_off_t(bp, "GEOM::frontstuff", 0))
359 break;
360 else if (g_handleattr_str(bp, "GEOM::ident", dp->d_ident))
361 break;
362 else if (g_handleattr(bp, "GEOM::hba_vendor",
363 &dp->d_hba_vendor, 2))
364 break;
365 else if (g_handleattr(bp, "GEOM::hba_device",
366 &dp->d_hba_device, 2))
367 break;
368 else if (g_handleattr(bp, "GEOM::hba_subvendor",
369 &dp->d_hba_subvendor, 2))
370 break;
371 else if (g_handleattr(bp, "GEOM::hba_subdevice",
372 &dp->d_hba_subdevice, 2))
373 break;
374 else if (!strcmp(bp->bio_attribute, "GEOM::kerneldump"))
375 g_disk_kerneldump(bp, dp);
376 else if (!strcmp(bp->bio_attribute, "GEOM::setstate"))
377 g_disk_setstate(bp, sc);
378 else
379 error = ENOIOCTL;
380 break;
381 case BIO_FLUSH:
382 g_trace(G_T_TOPOLOGY, "g_disk_flushcache(%s)",
383 bp->bio_to->name);
384 if (!(dp->d_flags & DISKFLAG_CANFLUSHCACHE)) {
385 g_io_deliver(bp, ENODEV);
386 return;
387 }
388 bp2 = g_clone_bio(bp);
389 if (bp2 == NULL) {
390 g_io_deliver(bp, ENOMEM);
391 return;
392 }
393 bp2->bio_done = g_disk_done;
394 bp2->bio_disk = dp;
395 g_disk_lock_giant(dp);
396 dp->d_strategy(bp2);
397 g_disk_unlock_giant(dp);
398 break;
399 default:
400 error = EOPNOTSUPP;
401 break;
402 }
403 if (error != EJUSTRETURN)
404 g_io_deliver(bp, error);
405 return;
406}
407
408static void
409g_disk_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp, struct g_consumer *cp, struct g_provider *pp)
410{
411 struct disk *dp;
412 struct g_disk_softc *sc;
413
414 sc = gp->softc;
415 if (sc == NULL || (dp = sc->dp) == NULL)
416 return;
417 if (indent == NULL) {
418 sbuf_printf(sb, " hd %u", dp->d_fwheads);
419 sbuf_printf(sb, " sc %u", dp->d_fwsectors);
420 return;
421 }
422 if (pp != NULL) {
423 sbuf_printf(sb, "%s<fwheads>%u</fwheads>\n",
424 indent, dp->d_fwheads);
425 sbuf_printf(sb, "%s<fwsectors>%u</fwsectors>\n",
426 indent, dp->d_fwsectors);
427 sbuf_printf(sb, "%s<ident>%s</ident>\n", indent, dp->d_ident);
428 sbuf_printf(sb, "%s<descr>%s</descr>\n", indent, dp->d_descr);
429 }
430}
431
432static void
433g_disk_create(void *arg, int flag)
434{
435 struct g_geom *gp;
436 struct g_provider *pp;
437 struct disk *dp;
438 struct g_disk_softc *sc;
439 char tmpstr[80];
440
441 if (flag == EV_CANCEL)
442 return;
443 g_topology_assert();
444 dp = arg;
445 sc = g_malloc(sizeof(*sc), M_WAITOK | M_ZERO);
446 sc->dp = dp;
447 gp = g_new_geomf(&g_disk_class, "%s%d", dp->d_name, dp->d_unit);
448 gp->softc = sc;
449 pp = g_new_providerf(gp, "%s", gp->name);
450 pp->mediasize = dp->d_mediasize;
451 pp->sectorsize = dp->d_sectorsize;
452 if (dp->d_flags & DISKFLAG_CANDELETE)
453 pp->flags |= G_PF_CANDELETE;
454 pp->stripeoffset = dp->d_stripeoffset;
455 pp->stripesize = dp->d_stripesize;
456 if (bootverbose)
457 printf("GEOM: new disk %s\n", gp->name);
458 sysctl_ctx_init(&sc->sysctl_ctx);
459 snprintf(tmpstr, sizeof(tmpstr), "GEOM disk %s", gp->name);
460 sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
461 SYSCTL_STATIC_CHILDREN(_kern_geom_disk), OID_AUTO, gp->name,
462 CTLFLAG_RD, 0, tmpstr);
463 if (sc->sysctl_tree != NULL) {
464 snprintf(tmpstr, sizeof(tmpstr),
465 "kern.geom.disk.%s.led", gp->name);
466 TUNABLE_STR_FETCH(tmpstr, sc->led, sizeof(sc->led));
467 SYSCTL_ADD_STRING(&sc->sysctl_ctx,
468 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, "led",
469 CTLFLAG_RW | CTLFLAG_TUN, sc->led, sizeof(sc->led),
470 "LED name");
471 }
472 pp->private = sc;
473 dp->d_geom = gp;
474 g_error_provider(pp, 0);
475}
476
477static void
478g_disk_destroy(void *ptr, int flag)
479{
480 struct disk *dp;
481 struct g_geom *gp;
482 struct g_disk_softc *sc;
483
484 g_topology_assert();
485 dp = ptr;
486 gp = dp->d_geom;
487 if (gp != NULL) {
488 sc = gp->softc;
489 if (sc->sysctl_tree != NULL) {
490 sysctl_ctx_free(&sc->sysctl_ctx);
491 sc->sysctl_tree = NULL;
492 }
493 if (sc->led[0] != 0) {
494 led_set(sc->led, "0");
495 sc->led[0] = 0;
496 }
497 g_free(sc);
498 gp->softc = NULL;
499 g_wither_geom(gp, ENXIO);
500 }
501 g_free(dp);
502}
503
504/*
505 * We only allow printable characters in disk ident,
506 * the rest is converted to 'x<HH>'.
507 */
508static void
509g_disk_ident_adjust(char *ident, size_t size)
510{
511 char *p, tmp[4], newid[DISK_IDENT_SIZE];
512
513 newid[0] = '\0';
514 for (p = ident; *p != '\0'; p++) {
515 if (isprint(*p)) {
516 tmp[0] = *p;
517 tmp[1] = '\0';
518 } else {
519 snprintf(tmp, sizeof(tmp), "x%02hhx",
520 *(unsigned char *)p);
521 }
522 if (strlcat(newid, tmp, sizeof(newid)) >= sizeof(newid))
523 break;
524 }
525 bzero(ident, size);
526 strlcpy(ident, newid, size);
527}
528
529struct disk *
530disk_alloc()
531{
532 struct disk *dp;
533
534 dp = g_malloc(sizeof *dp, M_WAITOK | M_ZERO);
535 return (dp);
536}
537
538void
539disk_create(struct disk *dp, int version)
540{
541 if (version != DISK_VERSION_00 && version != DISK_VERSION_01) {
542 printf("WARNING: Attempt to add disk %s%d %s",
543 dp->d_name, dp->d_unit,
544 " using incompatible ABI version of disk(9)\n");
545 printf("WARNING: Ignoring disk %s%d\n",
546 dp->d_name, dp->d_unit);
547 return;
548 }
549 KASSERT(dp->d_strategy != NULL, ("disk_create need d_strategy"));
550 KASSERT(dp->d_name != NULL, ("disk_create need d_name"));
551 KASSERT(*dp->d_name != 0, ("disk_create need d_name"));
552 KASSERT(strlen(dp->d_name) < SPECNAMELEN - 4, ("disk name too long"));
553 if (dp->d_devstat == NULL)
554 dp->d_devstat = devstat_new_entry(dp->d_name, dp->d_unit,
555 dp->d_sectorsize, DEVSTAT_ALL_SUPPORTED,
556 DEVSTAT_TYPE_DIRECT, DEVSTAT_PRIORITY_MAX);
557 dp->d_geom = NULL;
558 g_disk_ident_adjust(dp->d_ident, sizeof(dp->d_ident));
559 g_post_event(g_disk_create, dp, M_WAITOK, dp, NULL);
560}
561
562void
563disk_destroy(struct disk *dp)
564{
565
566 g_cancel_event(dp);
567 dp->d_destroyed = 1;
568 if (dp->d_devstat != NULL)
569 devstat_remove_entry(dp->d_devstat);
570 g_post_event(g_disk_destroy, dp, M_WAITOK, NULL);
571}
572
573void
574disk_gone(struct disk *dp)
575{
576 struct g_geom *gp;
577 struct g_provider *pp;
578
579 gp = dp->d_geom;
580 if (gp != NULL)
581 LIST_FOREACH(pp, &gp->provider, provider)
582 g_wither_provider(pp, ENXIO);
583}
584
585static void
586g_kern_disks(void *p, int flag __unused)
587{
588 struct sbuf *sb;
589 struct g_geom *gp;
590 char *sp;
591
592 sb = p;
593 sp = "";
594 g_topology_assert();
595 LIST_FOREACH(gp, &g_disk_class.geom, geom) {
596 sbuf_printf(sb, "%s%s", sp, gp->name);
597 sp = " ";
598 }
599 sbuf_finish(sb);
600}
601
602static int
603sysctl_disks(SYSCTL_HANDLER_ARGS)
604{
605 int error;
606 struct sbuf *sb;
607
608 sb = sbuf_new_auto();
609 g_waitfor_event(g_kern_disks, sb, M_WAITOK, NULL);
610 error = SYSCTL_OUT(req, sbuf_data(sb), sbuf_len(sb) + 1);
611 sbuf_delete(sb);
612 return error;
613}
614
615SYSCTL_PROC(_kern, OID_AUTO, disks,
616 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, 0,
617 sysctl_disks, "A", "names of available disks");
618
|