Index: arch/emips/ebus/ace_ebus.c =================================================================== RCS file: /cvsroot/src/sys/arch/emips/ebus/ace_ebus.c,v retrieving revision 1.5 diff -u -p -u -r1.5 ace_ebus.c --- arch/emips/ebus/ace_ebus.c 27 Oct 2012 17:17:45 -0000 1.5 +++ arch/emips/ebus/ace_ebus.c 29 May 2013 00:36:59 -0000 @@ -198,7 +198,7 @@ int acedetach(device_t, int); int aceactivate(device_t, enum devact); void acedone(struct ace_softc *); -static void ace_params_to_properties(struct ace_softc *ace); +static void ace_set_geometry(struct ace_softc *ace); CFATTACH_DECL_NEW(ace_ebus, sizeof(struct ace_softc), ace_ebus_match, ace_ebus_attach, acedetach, aceactivate); @@ -968,7 +968,7 @@ sysace_identify(struct ace_softc *sc) DBGME(DEBUG_PROBE, printf("Sysace::sc_capacity x%qx\n", sc->sc_capacity)); - ace_params_to_properties(sc); + ace_set_geometry(sc); } else { DBGME(DEBUG_ERRORS, printf("Sysace::Bad card signature?" @@ -2464,48 +2464,16 @@ bad144intern(struct ace_softc *ace) #endif static void -ace_params_to_properties(struct ace_softc *ace) +ace_set_geometry(struct ace_softc *ace) { - prop_dictionary_t disk_info, odisk_info, geom; - const char *cp; + struct disk_geom *dg = &ace->sc_dk.dk_geom; - disk_info = prop_dictionary_create(); + memset(dg, 0, sizeof(*dg)); - cp = ST506; + dg->dg_secperunit = ace->sc_capacity; + dg->dg_secsize = DEV_BSIZE /* XXX 512? */; + dg->dg_nsectors = ace->sc_params.CurrentSectorsPerTrack; + dg->dg_ntracks = ace->sc_params.CurrentNumberOfHeads; - prop_dictionary_set_cstring_nocopy(disk_info, "type", cp); - - geom = prop_dictionary_create(); - - prop_dictionary_set_uint64(geom, "sectors-per-unit", ace->sc_capacity); - - prop_dictionary_set_uint32(geom, "sector-size", - DEV_BSIZE /* XXX 512? */); - - prop_dictionary_set_uint16(geom, "sectors-per-track", - ace->sc_params.CurrentSectorsPerTrack); - - prop_dictionary_set_uint16(geom, "tracks-per-cylinder", - ace->sc_params.CurrentNumberOfHeads); - - prop_dictionary_set_uint64(geom, "cylinders-per-unit", - ace->sc_capacity / - (ace->sc_params.CurrentNumberOfHeads * - ace->sc_params.CurrentSectorsPerTrack)); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - - prop_dictionary_set(device_properties(ace->sc_dev), - "disk-info", disk_info); - - /* - * Don't release disk_info here; we keep a reference to it. - * disk_detach() will release it when we go away. - */ - - odisk_info = ace->sc_dk.dk_info; - ace->sc_dk.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); + disk_set_info(sc->sc_dev, &sc->sc_dk, ST506); } Index: arch/emips/ebus/flash_ebus.c =================================================================== RCS file: /cvsroot/src/sys/arch/emips/ebus/flash_ebus.c,v retrieving revision 1.5 diff -u -p -u -r1.5 flash_ebus.c --- arch/emips/ebus/flash_ebus.c 27 Oct 2012 17:17:45 -0000 1.5 +++ arch/emips/ebus/flash_ebus.c 29 May 2013 00:36:59 -0000 @@ -1414,7 +1414,7 @@ int eflashdetach(device_t, int); int eflashactivate(device_t, enum devact); void eflashdone(struct eflash_softc *); -static void eflash_params_to_properties(struct eflash_softc *sc); +static void eflash_set_geometry(struct eflash_softc *sc); struct dkdriver eflashdkdriver = { eflashstrategy, minphys }; @@ -1447,7 +1447,7 @@ eflashattach(struct eflash_softc *sc) device_xname(self), pbuf, 1, 1, sc->sc_capacity, DEV_BSIZE, (unsigned long long)sc->sc_capacity); - eflash_params_to_properties(sc); + eflash_set_geometry(sc); /* * Attach the disk structure. We fill in dk_info later. @@ -2293,45 +2293,17 @@ bad144intern(struct eflash_softc *sc) #endif static void -eflash_params_to_properties(struct eflash_softc *sc) +eflash_set_geometry(struct eflash_softc *sc) { - prop_dictionary_t disk_info, odisk_info, geom; - const char *cp; + struct disk_geom *dg = &sc->sc_dk.dk_geom; - disk_info = prop_dictionary_create(); + memset(dg, 0, sizeof(*dg)); - cp = ST506; + dg->dg_secperunit = sc->sc_capacity; + dg->dg_secsize = DEV_BSIZE /* XXX 512? */; + dg->dg_nsectors = sc->sc_capacity; + dg->dg_ntracks = 1; + dg->dg_ncylinders = sc->sc_capacity; - prop_dictionary_set_cstring_nocopy(disk_info, "type", cp); - - geom = prop_dictionary_create(); - - prop_dictionary_set_uint64(geom, "sectors-per-unit", sc->sc_capacity); - - prop_dictionary_set_uint32(geom, "sector-size", - DEV_BSIZE /* XXX 512? */); - - prop_dictionary_set_uint16(geom, "sectors-per-track", - sc->sc_capacity); - - prop_dictionary_set_uint16(geom, "tracks-per-cylinder", 1); - - prop_dictionary_set_uint64(geom, "cylinders-per-unit", sc->sc_capacity); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - - prop_dictionary_set(device_properties(sc->sc_dev), - "disk-info", disk_info); - - /* - * Don't release disk_info here; we keep a reference to it. - * disk_detach() will release it when we go away. - */ - - odisk_info = sc->sc_dk.dk_info; - sc->sc_dk.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); + disk_set_info(sc->sc_dev, &sc->sc_dk, ST506); } - Index: arch/sparc64/dev/fdc.c =================================================================== RCS file: /cvsroot/src/sys/arch/sparc64/dev/fdc.c,v retrieving revision 1.36 diff -u -p -u -r1.36 fdc.c --- arch/sparc64/dev/fdc.c 8 Aug 2011 14:49:06 -0000 1.36 +++ arch/sparc64/dev/fdc.c 29 May 2013 00:36:59 -0000 @@ -383,7 +383,7 @@ static void establish_chip_type( bus_addr_t, bus_size_t, bus_space_handle_t); -static void fd_set_properties(struct fd_softc *); +static void fd_set_geometry(struct fd_softc *); #ifdef MEMORY_DISK_HOOKS int fd_read_md_image(size_t *, void **); @@ -971,7 +971,7 @@ fdattach(device_t parent, device_t self, */ mountroothook_establish(fd_mountroot_hook, fd->sc_dev); - fd_set_properties(fd); + fd_set_geometry(fd); /* Make sure the drive motor gets turned off at shutdown time. */ if (!pmf_device_register1(self, fdsuspend, NULL, fdshutdown)) @@ -2564,57 +2564,33 @@ fd_read_md_image(size_t *sizep, void **a #endif /* MEMORY_DISK_HOOKS */ static void -fd_set_properties(struct fd_softc *fd) +fd_set_geometry(struct fd_softc *fd) { - prop_dictionary_t disk_info, odisk_info, geom; - struct fd_type *fdt; - int secsize; + const struct fd_type *fdt; - fdt = fd->sc_deftype; - - disk_info = prop_dictionary_create(); - - geom = prop_dictionary_create(); + fdt = fd->sc_type; + if (fdt == NULL) { + fdt = fd->sc_deftype; + if (fdt == NULL) + return; + } - prop_dictionary_set_uint64(geom, "sectors-per-unit", - fdt->size); + struct disk_geom *dg = &fd->sc_dkdev.dk_geom; + memset(dg, 0, sizeof(*dg)); + dg->dg_secperunit = fdt->size; + dg->dg_nsectors = fdt->sectrac; switch (fdt->secsize) { case 2: - secsize = 512; + dg->dg_secsize = 512; break; case 3: - secsize = 1024; + dg->dg_secsize = 1024; break; default: - secsize = 0; + break; } - - prop_dictionary_set_uint32(geom, "sector-size", - secsize); - - prop_dictionary_set_uint16(geom, "sectors-per-track", - fdt->sectrac); - - prop_dictionary_set_uint16(geom, "tracks-per-cylinder", - fdt->heads); - - prop_dictionary_set_uint64(geom, "cylinders-per-unit", - fdt->cylinders); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - - prop_dictionary_set(device_properties(fd->sc_dev), - "disk-info", disk_info); - - /* - * Don't release disk_info here; we keep a reference to it. - * disk_detach() will release it when we go away. - */ - - odisk_info = fd->sc_dk.dk_info; - fd->sc_dk.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); + dg->dg_ntracks = fdt->heads; + dg->dg_ncylinders = fdt->cyls; + disk_set_info(fd->sc_dev, &fd->sc_dkdev, NULL); } Index: arch/xen/xen/xbd_xenbus.c =================================================================== RCS file: /cvsroot/src/sys/arch/xen/xen/xbd_xenbus.c,v retrieving revision 1.57 diff -u -p -u -r1.57 xbd_xenbus.c --- arch/xen/xen/xbd_xenbus.c 25 May 2012 15:03:38 -0000 1.57 +++ arch/xen/xen/xbd_xenbus.c 29 May 2013 00:37:00 -0000 @@ -513,7 +513,6 @@ static void xbd_backend_changed(void *ar { struct xbd_xenbus_softc *sc = device_private((device_t)arg); struct dk_geom *pdg; - prop_dictionary_t disk_info, odisk_info, geom; char buf[9]; int s; @@ -576,30 +575,16 @@ static void xbd_backend_changed(void *ar /* Discover wedges on this disk. */ dkwedge_discover(&sc->sc_dksc.sc_dkdev); - disk_info = prop_dictionary_create(); - geom = prop_dictionary_create(); - prop_dictionary_set_uint64(geom, "sectors-per-unit", - sc->sc_dksc.sc_size); - prop_dictionary_set_uint32(geom, "sector-size", - pdg->pdg_secsize); - prop_dictionary_set_uint16(geom, "sectors-per-track", - pdg->pdg_nsectors); - prop_dictionary_set_uint16(geom, "tracks-per-cylinder", - pdg->pdg_ntracks); - prop_dictionary_set_uint64(geom, "cylinders-per-unit", - pdg->pdg_ncylinders); - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - prop_dictionary_set(device_properties(sc->sc_dksc.sc_dev), - "disk-info", disk_info); - /* - * Don't release disk_info here; we keep a reference to it. - * disk_detach() will release it when we go away. - */ - odisk_info = sc->sc_dksc.sc_dkdev.dk_info; - sc->sc_dksc.sc_dkdev.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); + struct disk_geom *dg = &sc->sc_dksc.sc_dkdev.dk_geom; + memset(dg, 0, sizeof(*dg)); + + dg->dg_secperunit = sc->sc_dksc.sc_size; + dg->dg_secsize = pdg->pdg_secsize; + dg->dg_nsectors = pdg->pdg_nsectors; + dg->dg_ntracks = pdg->pdg_ntracks; + dg->dg_ncylinders = pdg->pdg_ncylinders; + + disk_set_info(sc->sc_dksc.sc_dev, &sc->sc_dksc.sc_dkdev, NULL); /* the disk should be working now */ config_pending_decr(); Index: dev/ata/wd.c =================================================================== RCS file: /cvsroot/src/sys/dev/ata/wd.c,v retrieving revision 1.402 diff -u -p -u -r1.402 wd.c --- dev/ata/wd.c 9 Jan 2013 22:03:49 -0000 1.402 +++ dev/ata/wd.c 29 May 2013 00:37:01 -0000 @@ -1727,56 +1727,22 @@ bad144intern(struct wd_softc *wd) static void wd_params_to_properties(struct wd_softc *wd, struct ataparams *params) { - prop_dictionary_t disk_info, odisk_info, geom; - const char *cp; + struct disk_geom *dg = &wd->sc_dk.dk_geom; - disk_info = prop_dictionary_create(); + memset(dg, 0, sizeof(*dg)); - if (strcmp(wd->sc_params.atap_model, "ST506") == 0) - cp = "ST506"; - else { - /* XXX Should have a case for ATA here, too. */ - cp = "ESDI"; - } - prop_dictionary_set_cstring_nocopy(disk_info, "type", cp); - - geom = prop_dictionary_create(); - - prop_dictionary_set_uint64(geom, "sectors-per-unit", wd->sc_capacity); - - prop_dictionary_set_uint32(geom, "sector-size", - DEV_BSIZE /* XXX 512? */); - - prop_dictionary_set_uint16(geom, "sectors-per-track", - wd->sc_params.atap_sectors); - - prop_dictionary_set_uint16(geom, "tracks-per-cylinder", - wd->sc_params.atap_heads); - - if (wd->sc_flags & WDF_LBA) - prop_dictionary_set_uint64(geom, "cylinders-per-unit", - wd->sc_capacity / - (wd->sc_params.atap_heads * - wd->sc_params.atap_sectors)); - else - prop_dictionary_set_uint16(geom, "cylinders-per-unit", - wd->sc_params.atap_cylinders); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - - prop_dictionary_set(device_properties(wd->sc_dev), - "disk-info", disk_info); - - /* - * Don't release disk_info here; we keep a reference to it. - * disk_detach() will release it when we go away. - */ + dg->dg_secperunit = wd->sc_capacity; + dg->dg_secsize = DEV_BSIZE /* XXX 512? */; + dg->dg_nsectors = wd->sc_params.atap_sectors; + dg->dg_ntracks = wd->sc_params.atap_heads; + if ((wd->sc_flags & WDF_LBA) == 0) + dg->dg_ncylinders = wd->sc_params.atap_cylinders; + + /* XXX Should have a case for ATA here, too. */ + const char *cp = strcmp(wd->sc_params.atap_model, "ST506") ? + "ST506" : "ESDI"; - odisk_info = wd->sc_dk.dk_info; - wd->sc_dk.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); + disk_set_info(wd->sc_dev, &wd->sc_dk, cp); } int Index: dev/cgd.c =================================================================== RCS file: /cvsroot/src/sys/dev/cgd.c,v retrieving revision 1.78 diff -u -p -u -r1.78 cgd.c --- dev/cgd.c 5 Dec 2012 02:23:20 -0000 1.78 +++ dev/cgd.c 29 May 2013 00:37:01 -0000 @@ -694,7 +694,7 @@ cgd_ioctl_set(struct cgd_softc *cs, void cs->sc_dksc.sc_flags |= DKF_INITED; - dk_set_properties(di, &cs->sc_dksc); + dk_set_geometry(di, &cs->sc_dksc); /* Attach the disk. */ disk_attach(&cs->sc_dksc.sc_dkdev); Index: dev/dksubr.c =================================================================== RCS file: /cvsroot/src/sys/dev/dksubr.c,v retrieving revision 1.45 diff -u -p -u -r1.45 dksubr.c --- dev/dksubr.c 29 May 2012 10:20:33 -0000 1.45 +++ dev/dksubr.c 29 May 2013 00:37:01 -0000 @@ -627,43 +627,20 @@ dk_makedisklabel(struct dk_intf *di, str } void -dk_set_properties(struct dk_intf *di, struct dk_softc *dksc) +dk_set_geometry(struct dk_intf *di, struct dk_softc *dksc) { - prop_dictionary_t disk_info, odisk_info, geom; + struct disk_geom *dg = &dksc->sc_dkdev.dk_geom; - disk_info = prop_dictionary_create(); + memset(dg, 0, sizeof(*dg)); - geom = prop_dictionary_create(); + dg->dg_secperunit = dksc->sc_size; + dg->dg_secsize = dksc->sc_geom.pdg_secsize; + dg->dg_nsectors = dksc->sc_geom.pdg_nsectors; + dg->dg_ntracks = dksc->sc_geom.pdg_ntracks; + dg->dg_ncylinders = dksc->sc_geom.pdg_ncylinders; - prop_dictionary_set_uint64(geom, "sectors-per-unit", dksc->sc_size); + disk_set_info(dksc->sc_dev, &dksc->sc_dkdev, NULL); - prop_dictionary_set_uint32(geom, "sector-size", - dksc->sc_geom.pdg_secsize); - - prop_dictionary_set_uint16(geom, "sectors-per-track", - dksc->sc_geom.pdg_nsectors); - - prop_dictionary_set_uint16(geom, "tracks-per-cylinder", - dksc->sc_geom.pdg_ntracks); - - prop_dictionary_set_uint64(geom, "cylinders-per-unit", - dksc->sc_geom.pdg_ncylinders); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - - prop_dictionary_set(device_properties(dksc->sc_dev), - "disk-info", disk_info); - - /* - * Don't release disk_info here; we keep a reference to it. - * disk_detach() will release it when we go away. - */ - - odisk_info = dksc->sc_dkdev.dk_info; - dksc->sc_dkdev.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); } /* This function is taken from ccd.c:1.76 --rcd */ Index: dev/dkvar.h =================================================================== RCS file: /cvsroot/src/sys/dev/dkvar.h,v retrieving revision 1.16 diff -u -p -u -r1.16 dkvar.h --- dev/dkvar.h 25 May 2012 10:53:46 -0000 1.16 +++ dev/dkvar.h 29 May 2013 00:37:01 -0000 @@ -32,6 +32,7 @@ struct pathbuf; /* from namei.h */ +/* XXX: GC */ struct dk_geom { u_int32_t pdg_secsize; u_int32_t pdg_nsectors; @@ -112,6 +113,7 @@ int dk_dump(struct dk_intf *, struct dk_ void dk_getdisklabel(struct dk_intf *, struct dk_softc *, dev_t); void dk_getdefaultlabel(struct dk_intf *, struct dk_softc *, struct disklabel *); -void dk_set_properties(struct dk_intf *, struct dk_softc *); +/* XXX: GC use disk_set_info() */ +void dk_set_geometry(struct dk_intf *, struct dk_softc *); int dk_lookup(struct pathbuf *, struct lwp *, struct vnode **); Index: dev/ld.c =================================================================== RCS file: /cvsroot/src/sys/dev/ld.c,v retrieving revision 1.70 diff -u -p -u -r1.70 ld.c --- dev/ld.c 27 Oct 2012 17:18:14 -0000 1.70 +++ dev/ld.c 29 May 2013 00:37:01 -0000 @@ -66,7 +66,7 @@ static void ldminphys(struct buf *bp); static bool ld_suspend(device_t, const pmf_qual_t *); static bool ld_shutdown(device_t, int); static void ldstart(struct ld_softc *, struct buf *); -static void ld_set_properties(struct ld_softc *); +static void ld_set_geometry(struct ld_softc *); static void ld_config_interrupts (device_t); static int ldlastclose(device_t); @@ -143,7 +143,7 @@ ldattach(struct ld_softc *sc) sc->sc_nsectors, sc->sc_secsize, sc->sc_secperunit); sc->sc_disksize512 = sc->sc_secperunit * sc->sc_secsize / DEV_BSIZE; - ld_set_properties(sc); + ld_set_geometry(sc); /* Attach the device into the rnd source list. */ rnd_attach_source(&sc->sc_rnd_source, device_xname(sc->sc_dv), @@ -889,44 +889,19 @@ ldminphys(struct buf *bp) } static void -ld_set_properties(struct ld_softc *ld) +ld_set_geometry(struct ld_softc *ld) { - prop_dictionary_t disk_info, odisk_info, geom; + struct disk_geom *dg = &ld->sc_dk.dk_geom; - disk_info = prop_dictionary_create(); + memset(dg, 0, sizeof(*dg)); - geom = prop_dictionary_create(); + dg->dg_secperunit = ld->sc_secperunit; + dg->dg_secsize = ld->sc_secsize; + dg->dg_nsectors = ld->sc_nsectors; + dg->dg_ntracks = ld->sc_nheads; + dg->dg_ncylinders = ld->sc_ncylinders; - prop_dictionary_set_uint64(geom, "sectors-per-unit", - ld->sc_secperunit); - - prop_dictionary_set_uint32(geom, "sector-size", - ld->sc_secsize); - - prop_dictionary_set_uint16(geom, "sectors-per-track", - ld->sc_nsectors); - - prop_dictionary_set_uint16(geom, "tracks-per-cylinder", - ld->sc_nheads); - - prop_dictionary_set_uint64(geom, "cylinders-per-unit", - ld->sc_ncylinders); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - - prop_dictionary_set(device_properties(ld->sc_dv), - "disk-info", disk_info); - - /* - * Don't release disk_info here; we keep a reference to it. - * disk_detach() will release it when we go away. - */ - - odisk_info = ld->sc_dk.dk_info; - ld->sc_dk.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); + disk_set_info(ld->sc_dv, &ld->sc_dk, NULL); } static void Index: dev/vnd.c =================================================================== RCS file: /cvsroot/src/sys/dev/vnd.c,v retrieving revision 1.221 diff -u -p -u -r1.221 vnd.c --- dev/vnd.c 9 Jun 2012 06:20:45 -0000 1.221 +++ dev/vnd.c 29 May 2013 00:37:01 -0000 @@ -127,8 +127,6 @@ __KERNEL_RCSID(0, "$NetBSD: vnd.c,v 1.22 #include #include -#include - #if defined(VNDDEBUG) && !defined(DEBUG) #define DEBUG #endif @@ -187,7 +185,7 @@ static void handle_with_rdwr(struct vnd_ struct buf *); static void handle_with_strategy(struct vnd_softc *, const struct buf *, struct buf *); -static void vnd_set_properties(struct vnd_softc *); +static void vnd_set_geometry(struct vnd_softc *); static dev_type_open(vndopen); static dev_type_close(vndclose); @@ -1296,7 +1294,7 @@ vndioctl(dev_t dev, u_long cmd, void *da vnd->sc_geom.vng_ncylinders = vnd->sc_size; } - vnd_set_properties(vnd); + vnd_set_geometry(vnd); if (vio->vnd_flags & VNDIOF_READONLY) { vnd->sc_flags |= VNF_READONLY; @@ -1998,45 +1996,20 @@ vnd_free(void *aux, void *ptr) #endif /* VND_COMPRESSION */ static void -vnd_set_properties(struct vnd_softc *vnd) +vnd_set_geometry(struct vnd_softc *vnd) { - prop_dictionary_t disk_info, odisk_info, geom; - - disk_info = prop_dictionary_create(); - - geom = prop_dictionary_create(); - - prop_dictionary_set_uint64(geom, "sectors-per-unit", - vnd->sc_geom.vng_nsectors * vnd->sc_geom.vng_ntracks * - vnd->sc_geom.vng_ncylinders); - - prop_dictionary_set_uint32(geom, "sector-size", - vnd->sc_geom.vng_secsize); - - prop_dictionary_set_uint16(geom, "sectors-per-track", - vnd->sc_geom.vng_nsectors); + struct disk_geom *dg = &vnd->sc_dkdev.dk_geom; - prop_dictionary_set_uint16(geom, "tracks-per-cylinder", - vnd->sc_geom.vng_ntracks); + memset(dg, 0, sizeof(*dg)); - prop_dictionary_set_uint64(geom, "cylinders-per-unit", - vnd->sc_geom.vng_ncylinders); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - - prop_dictionary_set(device_properties(vnd->sc_dev), - "disk-info", disk_info); - - /* - * Don't release disk_info here; we keep a reference to it. - * disk_detach() will release it when we go away. - */ + dg->dg_secperunit = vnd->sc_geom.vng_nsectors * + vnd->sc_geom.vng_ntracks * vnd->sc_geom.vng_ncylinders; + dg->dg_secsize = vnd->sc_geom.vng_secsize; + dg->dg_nsectors = vnd->sc_geom.vng_nsectors; + dg->dg_ntracks = vnd->sc_geom.vng_ntracks; + dg->dg_ncylinders = vnd->sc_geom.vng_ncylinders; - odisk_info = vnd->sc_dkdev.dk_info; - vnd->sc_dkdev.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); + disk_set_info(vnd->sc_dev, &vnd->sc_dkdev, NULL); } #ifdef _MODULE Index: dev/dkwedge/dk.c =================================================================== RCS file: /cvsroot/src/sys/dev/dkwedge/dk.c,v retrieving revision 1.65 diff -u -p -u -r1.65 dk.c --- dev/dkwedge/dk.c 27 Oct 2012 17:18:15 -0000 1.65 +++ dev/dkwedge/dk.c 29 May 2013 00:37:01 -0000 @@ -228,35 +228,18 @@ dkwedge_array_expand(void) static void dkgetproperties(struct disk *disk, struct dkwedge_info *dkw) { - prop_dictionary_t disk_info, odisk_info, geom; + struct disk_geom *dg = &disk->dk_geom; - disk_info = prop_dictionary_create(); + memset(dg, 0, sizeof(*dg)); - prop_dictionary_set_cstring_nocopy(disk_info, "type", "ESDI"); + dg->dg_secperunit = dkw->dkw_size >> disk->dk_blkshift; + dg->dg_secsize = DEV_BSIZE << disk->dk_blkshift; + dg->dg_nsectors = 32; + dg->dg_ntracks = 64; + /* XXX: why is that dkw->dkw_size instead of secperunit?!?! */ + dg->dg_ncylinders = dkw->dkw_size / (dg->dg_nsectors * dg->dg_ntracks); - geom = prop_dictionary_create(); - - prop_dictionary_set_uint64(geom, "sectors-per-unit", - dkw->dkw_size >> disk->dk_blkshift); - - prop_dictionary_set_uint32(geom, "sector-size", - DEV_BSIZE << disk->dk_blkshift); - - prop_dictionary_set_uint32(geom, "sectors-per-track", 32); - - prop_dictionary_set_uint32(geom, "tracks-per-cylinder", 64); - - prop_dictionary_set_uint32(geom, "cylinders-per-unit", dkw->dkw_size / 2048); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - - odisk_info = disk->dk_info; - - disk->dk_info = disk_info; - - if (odisk_info != NULL) - prop_object_release(odisk_info); + disk_set_info(NULL, disk, "ESDI"); } /* Index: dev/dm/device-mapper.c =================================================================== RCS file: /cvsroot/src/sys/dev/dm/device-mapper.c,v retrieving revision 1.29 diff -u -p -u -r1.29 device-mapper.c --- dev/dm/device-mapper.c 13 Mar 2012 18:40:30 -0000 1.29 +++ dev/dm/device-mapper.c 29 May 2013 00:37:01 -0000 @@ -673,28 +673,20 @@ dmminphys(struct buf *bp) void dmgetproperties(struct disk *disk, dm_table_head_t *head) { - prop_dictionary_t disk_info, odisk_info, geom; uint64_t numsec; unsigned secsize; dm_table_disksize(head, &numsec, &secsize); - disk_info = prop_dictionary_create(); - geom = prop_dictionary_create(); - prop_dictionary_set_cstring_nocopy(disk_info, "type", "ESDI"); - prop_dictionary_set_uint64(geom, "sectors-per-unit", numsec); - prop_dictionary_set_uint32(geom, "sector-size", secsize); - prop_dictionary_set_uint32(geom, "sectors-per-track", 32); - prop_dictionary_set_uint32(geom, "tracks-per-cylinder", 64); - prop_dictionary_set_uint32(geom, "cylinders-per-unit", numsec / 2048); - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); + struct disk_geom *dg = &disk->dk_geom; - odisk_info = disk->dk_info; - disk->dk_info = disk_info; + memset(dg, 0, sizeof(*dg)); + dg->dg_secperunit = numsec; + dg->dg_secsize = secsize; + dg->dg_nsectors = 32; + dg->dg_ntracks = 64; - if (odisk_info != NULL) - prop_object_release(odisk_info); + disk_set_info(NULL, disk, "ESDI"); disk_blocksize(disk, secsize); } Index: dev/isa/fd.c =================================================================== RCS file: /cvsroot/src/sys/dev/isa/fd.c,v retrieving revision 1.100 diff -u -p -u -r1.100 fd.c --- dev/isa/fd.c 2 Feb 2012 19:43:04 -0000 1.100 +++ dev/isa/fd.c 29 May 2013 00:37:01 -0000 @@ -252,7 +252,7 @@ void fdcretry(struct fdc_softc *fdc); void fdfinish(struct fd_softc *fd, struct buf *bp); static const struct fd_type *fd_dev_to_type(struct fd_softc *, dev_t); int fdformat(dev_t, struct ne7_fd_formb *, struct lwp *); -static void fd_set_properties(struct fd_softc *fd); +static void fd_set_geometry(struct fd_softc *fd); void fd_mountroot_hook(device_t); @@ -572,7 +572,7 @@ fdattach(device_t parent, device_t self, rnd_attach_source(&fd->rnd_source, device_xname(fd->sc_dev), RND_TYPE_DISK, 0); - fd_set_properties(fd); + fd_set_geometry(fd); if (!pmf_device_register(self, NULL, NULL)) aprint_error_dev(self, "cannot set power mgmt handler\n"); @@ -600,7 +600,7 @@ fddetach(device_t self, int flags) pmf_device_deregister(self); #if 0 /* XXX need to undo at detach? */ - fd_set_properties(fd); + fd_set_geometry(fd); #endif rnd_detach_source(&fd->rnd_source); @@ -917,7 +917,7 @@ fdopen(dev_t dev, int flags, int mode, s fd->sc_cylin = -1; fd->sc_flags |= FD_OPEN; - fd_set_properties(fd); + fd_set_geometry(fd); return 0; } @@ -1651,11 +1651,9 @@ fd_mountroot_hook(device_t dev) } static void -fd_set_properties(struct fd_softc *fd) +fd_set_geometry(struct fd_softc *fd) { - prop_dictionary_t disk_info, odisk_info, geom; const struct fd_type *fdt; - int secsize; fdt = fd->sc_type; if (fdt == NULL) { @@ -1664,49 +1662,22 @@ fd_set_properties(struct fd_softc *fd) return; } - disk_info = prop_dictionary_create(); - - geom = prop_dictionary_create(); - - prop_dictionary_set_uint64(geom, "sectors-per-unit", - fdt->size); + struct disk_geom *dg = &fd->sc_dk.dk_geom; + memset(dg, 0, sizeof(*dg)); + dg->dg_secperunit = fdt->size; + dg->dg_nsectors = fdt->sectrac; switch (fdt->secsize) { case 2: - secsize = 512; + dg->dg_secsize = 512; break; case 3: - secsize = 1024; + dg->dg_secsize = 1024; break; default: - secsize = 0; + break; } - - prop_dictionary_set_uint32(geom, "sector-size", - secsize); - - prop_dictionary_set_uint16(geom, "sectors-per-track", - fdt->sectrac); - - prop_dictionary_set_uint16(geom, "tracks-per-cylinder", - fdt->heads); - - prop_dictionary_set_uint64(geom, "cylinders-per-unit", - fdt->cyls); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - - prop_dictionary_set(device_properties(fd->sc_dev), - "disk-info", disk_info); - - /* - * Don't release disk_info here; we keep a reference to it. - * disk_detach() will release it when we go away. - */ - - odisk_info = fd->sc_dk.dk_info; - fd->sc_dk.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); + dg->dg_ntracks = fdt->heads; + dg->dg_ncylinders = fdt->cyls; + disk_set_info(fd->sc_dev, &fd->sc_dk, NULL); } Index: dev/raidframe/rf_netbsdkintf.c =================================================================== RCS file: /cvsroot/src/sys/dev/raidframe/rf_netbsdkintf.c,v retrieving revision 1.303 diff -u -p -u -r1.303 rf_netbsdkintf.c --- dev/raidframe/rf_netbsdkintf.c 23 May 2013 14:15:52 -0000 1.303 +++ dev/raidframe/rf_netbsdkintf.c 29 May 2013 00:37:02 -0000 @@ -280,7 +280,7 @@ static void raidunlock(struct raid_softc static int raid_detach_unlocked(struct raid_softc *); static void rf_markalldirty(RF_Raid_t *); -static void rf_set_properties(struct raid_softc *, RF_Raid_t *); +static void rf_set_geometry(struct raid_softc *, RF_Raid_t *); void rf_ReconThread(struct rf_recon_req *); void rf_RewriteParityThread(RF_Raid_t *raidPtr); @@ -1961,7 +1961,7 @@ raidinit(struct raid_softc *rs) dkwedge_discover(&rs->sc_dkdev); - rf_set_properties(rs, raidPtr); + rf_set_geometry(rs, raidPtr); } #if (RF_INCLUDE_PARITY_DECLUSTERING_DS > 0) @@ -3859,33 +3859,18 @@ raid_detach(device_t self, int flags) } static void -rf_set_properties(struct raid_softc *rs, RF_Raid_t *raidPtr) +rf_set_geometry(struct raid_softc *rs, RF_Raid_t *raidPtr) { - prop_dictionary_t disk_info, odisk_info, geom; - disk_info = prop_dictionary_create(); - geom = prop_dictionary_create(); - prop_dictionary_set_uint64(geom, "sectors-per-unit", - raidPtr->totalSectors); - prop_dictionary_set_uint32(geom, "sector-size", - raidPtr->bytesPerSector); - - prop_dictionary_set_uint16(geom, "sectors-per-track", - raidPtr->Layout.dataSectorsPerStripe); - prop_dictionary_set_uint16(geom, "tracks-per-cylinder", - 4 * raidPtr->numCol); - - prop_dictionary_set_uint64(geom, "cylinders-per-unit", - raidPtr->totalSectors / (raidPtr->Layout.dataSectorsPerStripe * - (4 * raidPtr->numCol))); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - prop_dictionary_set(device_properties(rs->sc_dev), - "disk-info", disk_info); - odisk_info = rs->sc_dkdev.dk_info; - rs->sc_dkdev.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); + struct disk_geom *dg = &rs->sc_dkdev.dk_geom; + + memset(dg, 0, sizeof(*dg)); + + dg->dg_secperunit = raidPtr->totalSectors; + dg->dg_secsize = raidPtr->bytesPerSector; + dg->dg_nsectors = raidPtr->Layout.dataSectorsPerStripe; + dg->dg_ntracks = 4 * raidPtr->numCol; + + disk_set_info(rs->sc_dev, &rs->sc_dkdev, NULL); } /* Index: dev/scsipi/cd.c =================================================================== RCS file: /cvsroot/src/sys/dev/scsipi/cd.c,v retrieving revision 1.310 diff -u -p -u -r1.310 cd.c --- dev/scsipi/cd.c 15 Mar 2013 16:16:12 -0000 1.310 +++ dev/scsipi/cd.c 29 May 2013 00:37:02 -0000 @@ -174,7 +174,7 @@ static int mmc_gettrackinfo(struct scsip static int mmc_do_op(struct scsipi_periph *, struct mmc_op *); static int mmc_setup_writeparams(struct scsipi_periph *, struct mmc_writeparams *); -static void cd_set_properties(struct cd_softc *); +static void cd_set_geometry(struct cd_softc *); CFATTACH_DECL3_NEW(cd, sizeof(struct cd_softc), cdmatch, cdattach, cddetach, NULL, NULL, NULL, DVF_DETACH_SHUTDOWN); @@ -448,7 +448,7 @@ cdopen(dev_t dev, int flag, int fmt, str cdgetdisklabel(cd); SC_DEBUG(periph, SCSIPI_DB3, ("Disklabel fabricated ")); - cd_set_properties(cd); + cd_set_geometry(cd); } } @@ -3906,33 +3906,14 @@ mmc_setup_writeparams(struct scsipi_peri } static void -cd_set_properties(struct cd_softc *cd) +cd_set_geometry(struct cd_softc *cd) { - prop_dictionary_t disk_info, odisk_info, geom; + struct disk_geom *dg = &cd->sc_dk.dk_geom; - disk_info = prop_dictionary_create(); + memset(dg, 0, sizeof(*dg)); - geom = prop_dictionary_create(); + dg->dg_secperunit = cd->params.disksize; + dg->dg_secsize = cd->params.blksize; - prop_dictionary_set_uint64(geom, "sectors-per-unit", - cd->params.disksize); - - prop_dictionary_set_uint32(geom, "sector-size", - cd->params.blksize); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - - prop_dictionary_set(device_properties(cd->sc_dev), - "disk-info", disk_info); - - /* - * Don't release disk_info here; we keep a reference to it. - * disk_detach() will release it when we go away. - */ - - odisk_info = cd->sc_dk.dk_info; - cd->sc_dk.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); + disk_set_info(cd->sc_dev, &cd->sc_dk, NULL); } Index: dev/scsipi/sd.c =================================================================== RCS file: /cvsroot/src/sys/dev/scsipi/sd.c,v retrieving revision 1.299 diff -u -p -u -r1.299 sd.c --- dev/scsipi/sd.c 16 Apr 2013 21:01:09 -0000 1.299 +++ dev/scsipi/sd.c 29 May 2013 00:37:02 -0000 @@ -125,7 +125,7 @@ static int sd_setcache(struct sd_softc * static int sdmatch(device_t, cfdata_t, void *); static void sdattach(device_t, device_t, void *); static int sddetach(device_t, int); -static void sd_set_properties(struct sd_softc *); +static void sd_set_geometry(struct sd_softc *); CFATTACH_DECL3_NEW(sd, sizeof(struct sd_softc), sdmatch, sdattach, sddetach, NULL, NULL, NULL, DVF_DETACH_SHUTDOWN); @@ -2160,7 +2160,7 @@ page0: dp->rot_rate = 3600; setprops: - sd_set_properties(sd); + sd_set_geometry(sd); return (SDGP_RESULT_OK); } @@ -2298,42 +2298,17 @@ sd_setcache(struct sd_softc *sd, int bit } static void -sd_set_properties(struct sd_softc *sd) +sd_set_geometry(struct sd_softc *sd) { - prop_dictionary_t disk_info, odisk_info, geom; + struct disk_geom *dg = &sd->sc_dk.dk_geom; - disk_info = prop_dictionary_create(); + memset(dg, 0, sizeof(*dg)); - geom = prop_dictionary_create(); + dg->dg_secperunit = sd->params.disksize; + dg->dg_secsize = sd->params.blksize; + dg->dg_nsectors = sd->params.sectors; + dg->dg_ntracks = sd->params.heads; + dg->dg_ncylinders = sd->params.cyls; - prop_dictionary_set_uint64(geom, "sectors-per-unit", - sd->params.disksize); - - prop_dictionary_set_uint32(geom, "sector-size", - sd->params.blksize); - - prop_dictionary_set_uint16(geom, "sectors-per-track", - sd->params.sectors); - - prop_dictionary_set_uint16(geom, "tracks-per-cylinder", - sd->params.heads); - - prop_dictionary_set_uint64(geom, "cylinders-per-unit", - sd->params.cyls); - - prop_dictionary_set(disk_info, "geometry", geom); - prop_object_release(geom); - - prop_dictionary_set(device_properties(sd->sc_dev), - "disk-info", disk_info); - - /* - * Don't release disk_info here; we keep a reference to it. - * disk_detach() will release it when we go away. - */ - - odisk_info = sd->sc_dk.dk_info; - sd->sc_dk.dk_info = disk_info; - if (odisk_info) - prop_object_release(odisk_info); + disk_set_info(sd->sc_dev, &sd->sc_dk, NULL); } Index: kern/subr_disk.c =================================================================== RCS file: /cvsroot/src/sys/kern/subr_disk.c,v retrieving revision 1.101 diff -u -p -u -r1.101 subr_disk.c --- kern/subr_disk.c 9 Feb 2013 00:31:21 -0000 1.101 +++ kern/subr_disk.c 29 May 2013 00:37:02 -0000 @@ -508,3 +508,84 @@ disk_ioctl(struct disk *diskp, u_long cm return (error); } + +void +disk_set_info(device_t dev, struct disk *dk, const char *type) +{ + struct disk_geom *dg = &dk->dk_geom; + + if (dg->dg_secperunit == 0 && dg->dg_ncylinders == 0) { +#ifdef DIAGNOSTIC + printf("%s: secperunit and ncylinders are zero\n", dk->dk_name); +#endif + return; + } + + if (dg->dg_secperunit == 0) { + if (dg->dg_nsectors == 0 || dg->dg_ntracks == 0) { +#ifdef DIAGNOSTIC + printf("%s: secperunit and (sectors or tracks) " + "are zero\n", dk->dk_name); +#endif + return; + } + dg->dg_secperunit = dg->dg_nsectors * + dg->dg_ntracks * dg->dg_ncylinders; + } + + if (dg->dg_ncylinders == 0) { + if (dg->dg_ntracks && dg->dg_nsectors) + dg->dg_ncylinders = dg->dg_secperunit / + (dg->dg_ntracks * dg->dg_nsectors); + } + + if (dg->dg_secsize == 0) { +#ifdef DIAGNOSTIC + printf("%s: fixing 0 sector size\n", dk->dk_name); +#endif + dg->dg_secsize = DEV_BSIZE; + } + + prop_dictionary_t disk_info, odisk_info, geom; + + disk_info = prop_dictionary_create(); + geom = prop_dictionary_create(); + + prop_dictionary_set_uint64(geom, "sectors-per-unit", + dg->dg_secperunit); + + prop_dictionary_set_uint32(geom, "sector-size", dg->dg_secsize); + + if (dg->dg_nsectors) + prop_dictionary_set_uint16(geom, "sectors-per-track", + dg->dg_nsectors); + + if (dg->dg_ntracks) + prop_dictionary_set_uint16(geom, "tracks-per-cylinder", + dg->dg_ntracks); + + if (dg->dg_ncylinders) + prop_dictionary_set_uint64(geom, "cylinders-per-unit", + dg->dg_ncylinders); + + prop_dictionary_set(disk_info, "geometry", geom); + + if (type) + prop_dictionary_set_cstring_nocopy(disk_info, "type", type); + + prop_object_release(geom); + + odisk_info = dk->dk_info; + dk->dk_info = disk_info; + + if (dev) + prop_dictionary_set(device_properties(dev), "disk-info", + disk_info); + + /* + * Don't release disk_info here; we keep a reference to it. + * disk_detach() will release it when we go away. + */ + if (odisk_info) + prop_object_release(odisk_info); +} Index: sys/param.h =================================================================== RCS file: /cvsroot/src/sys/sys/param.h,v retrieving revision 1.429 diff -u -p -u -r1.429 param.h --- sys/param.h 21 May 2013 08:37:27 -0000 1.429 +++ sys/param.h 29 May 2013 00:37:02 -0000 @@ -63,7 +63,7 @@ * 2.99.9 (299000900) */ -#define __NetBSD_Version__ 699002000 /* NetBSD 6.99.20 */ +#define __NetBSD_Version__ 699002100 /* NetBSD 6.99.21 */ #define __NetBSD_Prereq__(M,m,p) (((((M) * 100000000) + \ (m) * 1000000) + (p) * 100) <= __NetBSD_Version__)