lp 66 arch/i386/i386/disksubr.c struct disklabel *lp, int spoofonly)
lp 73 arch/i386/i386/disksubr.c if ((msg = initdisklabel(lp)))
lp 85 arch/i386/i386/disksubr.c lp->d_ntracks, lp->d_nsectors, lp->d_ncylinders,
lp 87 arch/i386/i386/disksubr.c DL_GETDSIZE(lp) / (pdi->bios_heads * pdi->bios_sectors));
lp 89 arch/i386/i386/disksubr.c lp->d_ntracks = pdi->bios_heads;
lp 90 arch/i386/i386/disksubr.c lp->d_nsectors = pdi->bios_sectors;
lp 91 arch/i386/i386/disksubr.c lp->d_secpercyl = pdi->bios_sectors * pdi->bios_heads;
lp 92 arch/i386/i386/disksubr.c lp->d_ncylinders = DL_GETDSIZE(lp) / lp->d_secpercyl;
lp 96 arch/i386/i386/disksubr.c bp = geteblk((int)lp->d_secsize);
lp 99 arch/i386/i386/disksubr.c msg = readdoslabel(bp, strat, lp, NULL, spoofonly);
lp 104 arch/i386/i386/disksubr.c if (iso_disklabelspoof(dev, strat, lp) == 0) {
lp 110 arch/i386/i386/disksubr.c if (udf_disklabelspoof(dev, strat, lp) == 0) {
lp 128 arch/i386/i386/disksubr.c writedisklabel(dev_t dev, void (*strat)(struct buf *), struct disklabel *lp)
lp 135 arch/i386/i386/disksubr.c bp = geteblk((int)lp->d_secsize);
lp 138 arch/i386/i386/disksubr.c if (readdoslabel(bp, strat, lp, &partoff, 1) != NULL)
lp 143 arch/i386/i386/disksubr.c bp->b_bcount = lp->d_secsize;
lp 150 arch/i386/i386/disksubr.c *dlp = *lp;
lp 97 arch/i386/i386/sys_machdep.c union descriptor *lp, *cp;
lp 123 arch/i386/i386/sys_machdep.c lp = pmap->pm_ldt;
lp 126 arch/i386/i386/sys_machdep.c lp = ldt;
lp 135 arch/i386/i386/sys_machdep.c lp += ua.start;
lp 141 arch/i386/i386/sys_machdep.c i386_print_ldt(i, &lp[i].sd);
lp 145 arch/i386/i386/sys_machdep.c memcpy(cp, lp, num * sizeof(union descriptor));
lp 481 arch/i386/stand/installboot/installboot.c u_int32_t *lp;
lp 509 arch/i386/stand/installboot/installboot.c lp = (u_int32_t *) vp;
lp 510 arch/i386/stand/installboot/installboot.c *lp = sym->sym_value;
lp 114 compat/linux/linux_sched.c struct linux_sched_param lp;
lp 124 compat/linux/linux_sched.c error = copyin(SCARG(uap, sp), &lp, sizeof(lp));
lp 156 compat/linux/linux_sched.c struct linux_sched_param lp;
lp 179 compat/linux/linux_sched.c lp.sched_priority = 0;
lp 180 compat/linux/linux_sched.c return (copyout(&lp, SCARG(uap, sp), sizeof lp));
lp 195 compat/linux/linux_sched.c struct linux_sched_param lp;
lp 205 compat/linux/linux_sched.c error = copyin(SCARG(uap, sp), &lp, sizeof(lp));
lp 226 compat/linux/linux_sched.c if (SCARG(uap, policy) != LINUX_SCHED_OTHER || lp.sched_priority != 0)
lp 108 ddb/db_command.c char *lp;
lp 112 ddb/db_command.c lp = name;
lp 114 ddb/db_command.c while ((c = *lp) == *rp) {
lp 120 ddb/db_command.c lp++;
lp 239 dev/ata/ata_wdc.c nblks = xfer->c_bcount / ata_bio->lp->d_secsize;
lp 247 dev/ata/ata_wdc.c sect = blkno % ata_bio->lp->d_nsectors;
lp 249 dev/ata/ata_wdc.c blkno /= ata_bio->lp->d_nsectors;
lp 250 dev/ata/ata_wdc.c head = blkno % ata_bio->lp->d_ntracks;
lp 251 dev/ata/ata_wdc.c blkno /= ata_bio->lp->d_ntracks;
lp 293 dev/ata/ata_wdc.c ata_bio->nbytes = ata_bio->nblks * ata_bio->lp->d_secsize;
lp 319 dev/ata/ata_wdc.c (ata_bio->lp->d_type == DTYPE_ST506) ?
lp 320 dev/ata/ata_wdc.c ata_bio->lp->d_precompcyl / 4 : 0);
lp 324 dev/ata/ata_wdc.c nblks = xfer->c_bcount / ata_bio->lp->d_secsize;
lp 616 dev/ata/ata_wdc.c ata_bio->lp->d_ncylinders,
lp 617 dev/ata/ata_wdc.c ata_bio->lp->d_ntracks - 1, 0, ata_bio->lp->d_nsectors,
lp 618 dev/ata/ata_wdc.c (ata_bio->lp->d_type == DTYPE_ST506) ?
lp 619 dev/ata/ata_wdc.c ata_bio->lp->d_precompcyl / 4 : 0);
lp 348 dev/ata/wd.c wd->sc_wdc_bio.lp = wd->sc_dk.dk_label;
lp 766 dev/ata/wd.c wdgetdefaultlabel(struct wd_softc *wd, struct disklabel *lp)
lp 769 dev/ata/wd.c bzero(lp, sizeof(struct disklabel));
lp 771 dev/ata/wd.c lp->d_secsize = DEV_BSIZE;
lp 772 dev/ata/wd.c DL_SETDSIZE(lp, wd->sc_capacity);
lp 773 dev/ata/wd.c lp->d_ntracks = wd->sc_params.atap_heads;
lp 774 dev/ata/wd.c lp->d_nsectors = wd->sc_params.atap_sectors;
lp 775 dev/ata/wd.c lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
lp 776 dev/ata/wd.c lp->d_ncylinders = DL_GETDSIZE(lp) / lp->d_secpercyl;
lp 778 dev/ata/wd.c lp->d_type = DTYPE_ST506;
lp 779 dev/ata/wd.c strncpy(lp->d_typename, "ST506/MFM/RLL", sizeof lp->d_typename);
lp 781 dev/ata/wd.c lp->d_type = DTYPE_ESDI;
lp 782 dev/ata/wd.c strncpy(lp->d_typename, "ESDI/IDE disk", sizeof lp->d_typename);
lp 785 dev/ata/wd.c strncpy(lp->d_packname, wd->sc_params.atap_model, sizeof lp->d_packname);
lp 786 dev/ata/wd.c lp->d_rpm = 3600;
lp 787 dev/ata/wd.c lp->d_interleave = 1;
lp 788 dev/ata/wd.c lp->d_flags = 0;
lp 789 dev/ata/wd.c lp->d_version = 1;
lp 791 dev/ata/wd.c lp->d_magic = DISKMAGIC;
lp 792 dev/ata/wd.c lp->d_magic2 = DISKMAGIC;
lp 793 dev/ata/wd.c lp->d_checksum = dkcksum(lp);
lp 800 dev/ata/wd.c wdgetdisklabel(dev_t dev, struct wd_softc *wd, struct disklabel *lp,
lp 807 dev/ata/wd.c wdgetdefaultlabel(wd, lp);
lp 811 dev/ata/wd.c errstring = readdisklabel(DISKLABELDEV(dev), wdstrategy, lp,
lp 824 dev/ata/wd.c struct disklabel *lp;
lp 840 dev/ata/wd.c lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
lp 841 dev/ata/wd.c wdgetdisklabel(dev, wd, lp, 0);
lp 842 dev/ata/wd.c bcopy(lp, wd->sc_dk.dk_label, sizeof(*lp));
lp 843 dev/ata/wd.c free(lp, M_TEMP);
lp 992 dev/ata/wd.c struct disklabel *lp; /* disk's disklabel */
lp 1015 dev/ata/wd.c lp = wd->sc_dk.dk_label;
lp 1016 dev/ata/wd.c if ((size % lp->d_secsize) != 0)
lp 1018 dev/ata/wd.c nblks = size / lp->d_secsize;
lp 1019 dev/ata/wd.c blkno = blkno / (lp->d_secsize / DEV_BSIZE);
lp 1022 dev/ata/wd.c if ((blkno < 0) || ((blkno + nblks) > DL_GETPSIZE(&lp->d_partitions[part])))
lp 1026 dev/ata/wd.c blkno += DL_GETPOFFSET(&lp->d_partitions[part]);
lp 1046 dev/ata/wd.c min(nblks, wddumpmulti) * lp->d_secsize;
lp 1105 dev/ata/wd.c va += min(nblks, wddumpmulti) * lp->d_secsize;
lp 50 dev/ata/wdvar.h struct disklabel *lp; /* pointer to drive's label info */
lp 568 dev/ccd.c struct disklabel *lp;
lp 580 dev/ccd.c lp = cs->sc_dkdev.dk_label;
lp 591 dev/ccd.c ccdgetdisklabel(dev, cs, lp, 0);
lp 596 dev/ccd.c ((part >= lp->d_npartitions) ||
lp 597 dev/ccd.c (lp->d_partitions[part].p_fstype == FS_UNUSED))) {
lp 664 dev/ccd.c struct disklabel *lp;
lp 679 dev/ccd.c lp = cs->sc_dkdev.dk_label;
lp 687 dev/ccd.c bounds_check_with_label(bp, lp, wlabel) <= 0)
lp 1356 dev/ccd.c ccdgetdisklabel(dev_t dev, struct ccd_softc *cs, struct disklabel *lp,
lp 1362 dev/ccd.c bzero(lp, sizeof(*lp));
lp 1364 dev/ccd.c DL_SETDSIZE(lp, cs->sc_size);
lp 1365 dev/ccd.c lp->d_secsize = ccg->ccg_secsize;
lp 1366 dev/ccd.c lp->d_nsectors = ccg->ccg_nsectors;
lp 1367 dev/ccd.c lp->d_ntracks = ccg->ccg_ntracks;
lp 1368 dev/ccd.c lp->d_ncylinders = ccg->ccg_ncylinders;
lp 1369 dev/ccd.c lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
lp 1370 dev/ccd.c lp->d_rpm = ccg->ccg_rpm;
lp 1372 dev/ccd.c strncpy(lp->d_typename, "ccd", sizeof(lp->d_typename));
lp 1373 dev/ccd.c lp->d_type = DTYPE_CCD;
lp 1374 dev/ccd.c strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
lp 1375 dev/ccd.c lp->d_interleave = 1;
lp 1376 dev/ccd.c lp->d_flags = 0;
lp 1377 dev/ccd.c lp->d_version = 1;
lp 1379 dev/ccd.c lp->d_magic = DISKMAGIC;
lp 1380 dev/ccd.c lp->d_magic2 = DISKMAGIC;
lp 1381 dev/ccd.c lp->d_checksum = dkcksum(cs->sc_dkdev.dk_label);
lp 961 dev/flash.c struct disklabel *lp)
lp 965 dev/flash.c bzero(lp, sizeof(struct disklabel));
lp 967 dev/flash.c lp->d_type = 0;
lp 968 dev/flash.c lp->d_subtype = 0;
lp 969 dev/flash.c strncpy(lp->d_typename, "NAND flash", sizeof(lp->d_typename));
lp 972 dev/flash.c strncpy(lp->d_packname, sc->sc_flashdev->longname,
lp 973 dev/flash.c sizeof(lp->d_packname));
lp 974 dev/flash.c for (len = 0; len < sizeof(lp->d_packname); len++)
lp 975 dev/flash.c if (lp->d_packname[len] == ' ') {
lp 976 dev/flash.c lp->d_packname[len] = '\0';
lp 981 dev/flash.c lp->d_ncylinders = 1;
lp 982 dev/flash.c lp->d_ntracks = 16;
lp 983 dev/flash.c lp->d_secsize = sc->sc_flashdev->pagesize;
lp 984 dev/flash.c lp->d_nsectors = sc->sc_flashdev->capacity / lp->d_ntracks
lp 985 dev/flash.c / lp->d_ncylinders;
lp 986 dev/flash.c lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
lp 987 dev/flash.c DL_SETDSIZE(lp, (daddr64_t)lp->d_ncylinders * lp->d_secpercyl);
lp 990 dev/flash.c lp->d_rpm = 3600;
lp 991 dev/flash.c lp->d_interleave = 1;
lp 992 dev/flash.c lp->d_version = 1;
lp 995 dev/flash.c lp->d_bbsize = BBSIZE;
lp 996 dev/flash.c lp->d_sbsize = SBSIZE;
lp 999 dev/flash.c lp->d_magic = DISKMAGIC;
lp 1000 dev/flash.c lp->d_magic2 = DISKMAGIC;
lp 1001 dev/flash.c lp->d_checksum = dkcksum(lp);
lp 1006 dev/flash.c struct disklabel *lp, int spoofonly)
lp 1011 dev/flash.c flashgetdefaultlabel(dev, sc, lp);
lp 1014 dev/flash.c sc->sc_tag->default_disklabel(sc->sc_cookie, dev, lp);
lp 1018 dev/flash.c errstring = readdisklabel(labeldev, flashstrategy, lp, spoofonly);
lp 1533 dev/ic/isp.c struct lportdb *lp;
lp 1673 dev/ic/isp.c lp = &fcp->portdb[loopid];
lp 1674 dev/ic/isp.c lp->node_wwn =
lp 1683 dev/ic/isp.c lp->port_wwn =
lp 1692 dev/ic/isp.c lp->roles =
lp 1694 dev/ic/isp.c lp->portid = BITS2WORD(pdb.pdb_portid_bits);
lp 1695 dev/ic/isp.c lp->loopid = pdb.pdb_loopid;
lp 1696 dev/ic/isp.c lp->loggedin = lp->valid = 1;
lp 1729 dev/ic/isp.c lp = &fcp->portdb[fcp->isp_iid];
lp 1731 dev/ic/isp.c lp = &fcp->portdb[fcp->isp_iid];
lp 1732 dev/ic/isp.c if (fcp->isp_portid != lp->portid ||
lp 1733 dev/ic/isp.c fcp->isp_loopid != lp->loopid ||
lp 1736 dev/ic/isp.c lp->valid = 0;
lp 1741 dev/ic/isp.c lp->loopid = fcp->isp_loopid;
lp 1742 dev/ic/isp.c lp->portid = fcp->isp_portid;
lp 1743 dev/ic/isp.c lp->node_wwn = ISP_NODEWWN(isp);
lp 1744 dev/ic/isp.c lp->port_wwn = ISP_PORTWWN(isp);
lp 1747 dev/ic/isp.c lp->roles = 0;
lp 1750 dev/ic/isp.c lp->roles = SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT;
lp 1753 dev/ic/isp.c lp->roles = SVC3_INI_ROLE >> SVC3_ROLE_SHIFT;
lp 1756 dev/ic/isp.c lp->roles = (SVC3_INI_ROLE|SVC3_TGT_ROLE) >> SVC3_ROLE_SHIFT;
lp 1759 dev/ic/isp.c lp->loggedin = lp->valid = 1;
lp 1789 dev/ic/isp.c struct lportdb *lp;
lp 1828 dev/ic/isp.c for (lp = &fcp->portdb[0]; lp < &fcp->portdb[MAX_FC_TARG]; lp++) {
lp 1829 dev/ic/isp.c if (lp->was_fabric_dev && lp->fabric_dev == 0) {
lp 1830 dev/ic/isp.c loopid = lp - fcp->portdb;
lp 1831 dev/ic/isp.c lp->valid = 0; /* should already be set */
lp 1833 dev/ic/isp.c MEMZERO((void *) lp, sizeof (*lp));
lp 1836 dev/ic/isp.c lp->was_fabric_dev = lp->fabric_dev;
lp 1854 dev/ic/isp.c for (lp = &fcp->portdb[base]; lp < &fcp->portdb[lim]; lp++) {
lp 1858 dev/ic/isp.c loopid = lp - fcp->portdb;
lp 1866 dev/ic/isp.c if (lp->port_wwn == 0) {
lp 1873 dev/ic/isp.c if ((portid = lp->portid) == fcp->isp_portid) {
lp 1887 dev/ic/isp.c if (lp->loggedin && lp->force_logout == 0 &&
lp 1888 dev/ic/isp.c isp_getpdb(isp, lp->loopid, &pdb) == 0) {
lp 1911 dev/ic/isp.c if (pdb.pdb_loopid == lp->loopid && lp->portid ==
lp 1913 dev/ic/isp.c nwwnn == lp->node_wwn && nwwpn == lp->port_wwn &&
lp 1914 dev/ic/isp.c lp->roles == nrole && lp->force_logout == 0) {
lp 1915 dev/ic/isp.c lp->loggedin = lp->valid = 1;
lp 1917 dev/ic/isp.c (int) (lp - fcp->portdb),
lp 1918 dev/ic/isp.c (int) lp->loopid, lp->portid);
lp 1931 dev/ic/isp.c if (lp->loggedin) {
lp 1932 dev/ic/isp.c if (lp->force_logout ||
lp 1933 dev/ic/isp.c isp_getpdb(isp, lp->loopid, &pdb) == 0) {
lp 1935 dev/ic/isp.c mbs.param[1] = lp->loopid << 8;
lp 1940 dev/ic/isp.c (int) (lp - fcp->portdb), lp->loopid,
lp 1941 dev/ic/isp.c lp->portid);
lp 1943 dev/ic/isp.c lp->force_logout = lp->loggedin = 0;
lp 1953 dev/ic/isp.c loopid = lp - fcp->portdb;
lp 1954 dev/ic/isp.c lp->loopid = FL_PORT_ID;
lp 1982 dev/ic/isp.c loopid, (int) (lp - fcp->portdb),
lp 1983 dev/ic/isp.c lp->portid);
lp 1990 dev/ic/isp.c lp->loggedin = 1;
lp 1991 dev/ic/isp.c lp->loopid = loopid;
lp 2002 dev/ic/isp.c } while (lp->loopid == FL_PORT_ID && loopid < MAX_FC_TARG);
lp 2009 dev/ic/isp.c if (lp->loopid == FL_PORT_ID) {
lp 2010 dev/ic/isp.c lp->loopid = 0;
lp 2017 dev/ic/isp.c if (isp_getpdb(isp, lp->loopid, &pdb) != 0) {
lp 2018 dev/ic/isp.c isp_prt(isp, ISP_LOGWARN, nopdb, lp->portid);
lp 2027 dev/ic/isp.c if (pdb.pdb_loopid != lp->loopid) {
lp 2029 dev/ic/isp.c lp->portid, pdb.pdb_loopid);
lp 2033 dev/ic/isp.c if (lp->portid != (u_int32_t) BITS2WORD(pdb.pdb_portid_bits)) {
lp 2035 dev/ic/isp.c lp->portid, BITS2WORD(pdb.pdb_portid_bits));
lp 2039 dev/ic/isp.c lp->roles =
lp 2041 dev/ic/isp.c lp->node_wwn =
lp 2050 dev/ic/isp.c lp->port_wwn =
lp 2062 dev/ic/isp.c if (lp->node_wwn && lp->port_wwn) {
lp 2063 dev/ic/isp.c lp->valid = 1;
lp 2064 dev/ic/isp.c loopid = lp - fcp->portdb;
lp 2069 dev/ic/isp.c lp->valid = 0;
lp 2071 dev/ic/isp.c ldumped, loopid, lp->loopid, lp->portid);
lp 2073 dev/ic/isp.c mbs.param[1] = lp->loopid << 8;
lp 2095 dev/ic/isp.c struct lportdb *lp;
lp 2130 dev/ic/isp.c lp = &fcp->tport[loopid];
lp 2138 dev/ic/isp.c lp->node_wwn = isp_get_portname(isp, loopid, 1);
lp 2141 dev/ic/isp.c if (lp->node_wwn == 0)
lp 2143 dev/ic/isp.c lp->port_wwn = isp_get_portname(isp, loopid, 0);
lp 2146 dev/ic/isp.c if (lp->port_wwn == 0) {
lp 2147 dev/ic/isp.c lp->node_wwn = 0;
lp 2180 dev/ic/isp.c lp->node_wwn =
lp 2189 dev/ic/isp.c lp->port_wwn =
lp 2198 dev/ic/isp.c lp->roles =
lp 2200 dev/ic/isp.c lp->portid = BITS2WORD(pdb.pdb_portid_bits);
lp 2201 dev/ic/isp.c lp->loopid = pdb.pdb_loopid;
lp 2345 dev/ic/isp.c for (lp = &fcp->portdb[0]; lp < &fcp->portdb[hival]; lp++) {
lp 2346 dev/ic/isp.c if (lp->valid || lp->port_wwn == 0) {
lp 2355 dev/ic/isp.c loopid = lp - fcp->portdb;
lp 2357 dev/ic/isp.c MEMZERO((void *) lp, sizeof (*lp));
lp 2974 dev/ic/isp.c struct lportdb *lp;
lp 3135 dev/ic/isp.c lp = &fcp->portdb[target];
lp 3136 dev/ic/isp.c if (lp->valid == 0) {
lp 3140 dev/ic/isp.c if ((lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT)) == 0) {
lp 3149 dev/ic/isp.c target = lp->loopid;
lp 3150 dev/ic/isp.c xs->sc_link->node_wwn = lp->node_wwn;
lp 3151 dev/ic/isp.c xs->sc_link->port_wwn = lp->port_wwn;
lp 791 dev/ic/isp_openbsd.c struct lportdb *lp = &fcp->portdb[tgt];
lp 793 dev/ic/isp_openbsd.c isp_prt(isp, ISP_LOGINFO, fmt, tgt, lp->loopid, lp->portid,
lp 794 dev/ic/isp_openbsd.c roles[lp->roles & 0x3],
lp 795 dev/ic/isp_openbsd.c (lp->valid)? "Arrived" : "Departed",
lp 796 dev/ic/isp_openbsd.c (u_int32_t) (lp->port_wwn >> 32),
lp 797 dev/ic/isp_openbsd.c (u_int32_t) (lp->port_wwn & 0xffffffffLL),
lp 798 dev/ic/isp_openbsd.c (u_int32_t) (lp->node_wwn >> 32),
lp 799 dev/ic/isp_openbsd.c (u_int32_t) (lp->node_wwn & 0xffffffffLL));
lp 815 dev/ic/isp_openbsd.c struct lportdb *lp = NULL;
lp 891 dev/ic/isp_openbsd.c lp = &fcp->portdb[target];
lp 892 dev/ic/isp_openbsd.c if (lp->port_wwn == clp->port_wwn &&
lp 893 dev/ic/isp_openbsd.c lp->node_wwn == clp->node_wwn) {
lp 894 dev/ic/isp_openbsd.c lp->fabric_dev = 1;
lp 905 dev/ic/isp_openbsd.c lp = &fcp->portdb[target];
lp 906 dev/ic/isp_openbsd.c if (lp->port_wwn == 0) {
lp 915 dev/ic/isp_openbsd.c lp->port_type = clp->port_type;
lp 916 dev/ic/isp_openbsd.c lp->fc4_type = clp->fc4_type;
lp 917 dev/ic/isp_openbsd.c lp->node_wwn = clp->node_wwn;
lp 918 dev/ic/isp_openbsd.c lp->port_wwn = clp->port_wwn;
lp 919 dev/ic/isp_openbsd.c lp->portid = clp->portid;
lp 920 dev/ic/isp_openbsd.c lp->fabric_dev = 1;
lp 962 dev/isa/fd.c struct disklabel dl, *lp = &dl;
lp 972 dev/isa/fd.c bzero(lp, sizeof(*lp));
lp 974 dev/isa/fd.c lp->d_secsize = FD_BSIZE(fd);
lp 975 dev/isa/fd.c lp->d_secpercyl = fd->sc_type->seccyl;
lp 976 dev/isa/fd.c lp->d_ntracks = fd->sc_type->heads;
lp 977 dev/isa/fd.c lp->d_nsectors = fd->sc_type->sectrac;
lp 978 dev/isa/fd.c lp->d_ncylinders = fd->sc_type->tracks;
lp 980 dev/isa/fd.c strncpy(lp->d_typename, "floppy disk", sizeof lp->d_typename);
lp 981 dev/isa/fd.c lp->d_type = DTYPE_FLOPPY;
lp 982 dev/isa/fd.c strncpy(lp->d_packname, "fictitious", sizeof lp->d_packname);
lp 983 dev/isa/fd.c DL_SETDSIZE(lp, fd->sc_type->size);
lp 984 dev/isa/fd.c lp->d_rpm = 300;
lp 985 dev/isa/fd.c lp->d_interleave = 1;
lp 986 dev/isa/fd.c lp->d_version = 1;
lp 988 dev/isa/fd.c lp->d_magic = DISKMAGIC;
lp 989 dev/isa/fd.c lp->d_magic2 = DISKMAGIC;
lp 990 dev/isa/fd.c lp->d_checksum = dkcksum(lp);
lp 992 dev/isa/fd.c errstring = readdisklabel(DISKLABELDEV(dev), fdstrategy, lp, 0);
lp 997 dev/isa/fd.c *(struct disklabel *)addr = *lp;
lp 1010 dev/isa/fd.c error = setdisklabel(lp, (struct disklabel *)addr, 0);
lp 1014 dev/isa/fd.c error = writedisklabel(DISKLABELDEV(dev), fdstrategy, lp);
lp 621 dev/isa/mcd.c struct disklabel *lp;
lp 631 dev/isa/mcd.c lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
lp 632 dev/isa/mcd.c mcdgetdisklabel(dev, sc, lp, 0);
lp 633 dev/isa/mcd.c bcopy(lp, sc->sc_dk.dk_label, sizeof(*lp));
lp 634 dev/isa/mcd.c free(lp, M_TEMP);
lp 732 dev/isa/mcd.c mcdgetdisklabel(dev, sc, lp, spoofonly)
lp 735 dev/isa/mcd.c struct disklabel *lp;
lp 740 dev/isa/mcd.c bzero(lp, sizeof(struct disklabel));
lp 742 dev/isa/mcd.c lp->d_secsize = sc->blksize;
lp 743 dev/isa/mcd.c lp->d_ntracks = 1;
lp 744 dev/isa/mcd.c lp->d_nsectors = 100;
lp 745 dev/isa/mcd.c lp->d_ncylinders = (sc->disksize / 100) + 1;
lp 746 dev/isa/mcd.c lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
lp 747 dev/isa/mcd.c if (lp->d_secpercyl == 0) {
lp 748 dev/isa/mcd.c lp->d_secpercyl = 100;
lp 752 dev/isa/mcd.c strncpy(lp->d_typename, "Mitsumi CD-ROM", sizeof lp->d_typename);
lp 753 dev/isa/mcd.c lp->d_type = DTYPE_SCSI; /* XXX */
lp 754 dev/isa/mcd.c strncpy(lp->d_packname, "fictitious", sizeof lp->d_packname);
lp 755 dev/isa/mcd.c DL_SETDSIZE(lp, sc->disksize);
lp 756 dev/isa/mcd.c lp->d_rpm = 300;
lp 757 dev/isa/mcd.c lp->d_interleave = 1;
lp 758 dev/isa/mcd.c lp->d_version = 1;
lp 760 dev/isa/mcd.c lp->d_magic = DISKMAGIC;
lp 761 dev/isa/mcd.c lp->d_magic2 = DISKMAGIC;
lp 762 dev/isa/mcd.c lp->d_checksum = dkcksum(lp);
lp 767 dev/isa/mcd.c errstring = readdisklabel(DISKLABELDEV(dev), mcdstrategy, lp, spoofonly);
lp 554 dev/pci/cz.c const u_int32_t *lp;
lp 557 dev/pci/cz.c lp = (const u_int32_t *)
lp 559 dev/pci/cz.c for (j = 0; j < nbytes; j += 4, lp++) {
lp 561 dev/pci/cz.c ro + j, letoh32(*lp));
lp 183 dev/raidframe/rf_fifo.c RF_DiskQueueData_t *lp = q->lq_head, *pt = NULL;
lp 186 dev/raidframe/rf_fifo.c while (lp) {
lp 191 dev/raidframe/rf_fifo.c if (lp->parityStripeID == parityStripeID &&
lp 192 dev/raidframe/rf_fifo.c lp->which_ru == which_ru) {
lp 197 dev/raidframe/rf_fifo.c pt->next = lp->next;
lp 200 dev/raidframe/rf_fifo.c q->lq_head = lp->next;
lp 206 dev/raidframe/rf_fifo.c if (lp == q->lq_tail)
lp 210 dev/raidframe/rf_fifo.c lp->next = NULL;
lp 214 dev/raidframe/rf_fifo.c q->hq_tail->next = lp;
lp 215 dev/raidframe/rf_fifo.c q->hq_tail = lp;
lp 219 dev/raidframe/rf_fifo.c q->hq_head = q->hq_tail = lp;
lp 228 dev/raidframe/rf_fifo.c lp = (pt) ? pt->next : q->lq_head;
lp 232 dev/raidframe/rf_fifo.c pt = lp;
lp 233 dev/raidframe/rf_fifo.c lp = lp->next;
lp 581 dev/raidframe/rf_openbsdkintf.c struct disklabel *lp;
lp 594 dev/raidframe/rf_openbsdkintf.c lp = rs->sc_dkdev.dk_label;
lp 599 dev/raidframe/rf_openbsdkintf.c if (lp->d_partitions[part].p_fstype != FS_SWAP)
lp 602 dev/raidframe/rf_openbsdkintf.c size = DL_GETPSIZE(&lp->d_partitions[part]) *
lp 603 dev/raidframe/rf_openbsdkintf.c (lp->d_secsize / DEV_BSIZE);
lp 752 dev/raidframe/rf_openbsdkintf.c struct disklabel *lp;
lp 784 dev/raidframe/rf_openbsdkintf.c lp = rs->sc_dkdev.dk_label;
lp 792 dev/raidframe/rf_openbsdkintf.c if (bounds_check_with_label(bp, lp, wlabel) <= 0) {
lp 1568 dev/raidframe/rf_openbsdkintf.c struct disklabel *lp;
lp 1569 dev/raidframe/rf_openbsdkintf.c lp = (struct disklabel *)data;
lp 1576 dev/raidframe/rf_openbsdkintf.c error = setdisklabel(rs->sc_dkdev.dk_label, lp, 0);
lp 2088 dev/raidframe/rf_openbsdkintf.c struct disklabel *lp)
lp 2091 dev/raidframe/rf_openbsdkintf.c bzero(lp, sizeof(*lp));
lp 2094 dev/raidframe/rf_openbsdkintf.c DL_SETDSIZE(lp, raidPtr->totalSectors);
lp 2095 dev/raidframe/rf_openbsdkintf.c lp->d_secsize = raidPtr->bytesPerSector;
lp 2096 dev/raidframe/rf_openbsdkintf.c lp->d_nsectors = raidPtr->Layout.dataSectorsPerStripe;
lp 2097 dev/raidframe/rf_openbsdkintf.c lp->d_ntracks = 4 * raidPtr->numCol;
lp 2098 dev/raidframe/rf_openbsdkintf.c lp->d_ncylinders = raidPtr->totalSectors /
lp 2099 dev/raidframe/rf_openbsdkintf.c (lp->d_nsectors * lp->d_ntracks);
lp 2100 dev/raidframe/rf_openbsdkintf.c lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
lp 2102 dev/raidframe/rf_openbsdkintf.c strncpy(lp->d_typename, "raid", sizeof(lp->d_typename));
lp 2103 dev/raidframe/rf_openbsdkintf.c lp->d_type = DTYPE_RAID;
lp 2104 dev/raidframe/rf_openbsdkintf.c strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
lp 2105 dev/raidframe/rf_openbsdkintf.c lp->d_rpm = 3600;
lp 2106 dev/raidframe/rf_openbsdkintf.c lp->d_flags = 0;
lp 2107 dev/raidframe/rf_openbsdkintf.c lp->d_interleave = 1;
lp 2108 dev/raidframe/rf_openbsdkintf.c lp->d_version = 1;
lp 2110 dev/raidframe/rf_openbsdkintf.c DL_SETPOFFSET(&lp->d_partitions[RAW_PART], 0);
lp 2111 dev/raidframe/rf_openbsdkintf.c DL_SETPSIZE(&lp->d_partitions[RAW_PART], raidPtr->totalSectors);
lp 2112 dev/raidframe/rf_openbsdkintf.c lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
lp 2113 dev/raidframe/rf_openbsdkintf.c lp->d_npartitions = RAW_PART + 1;
lp 2115 dev/raidframe/rf_openbsdkintf.c lp->d_magic = DISKMAGIC;
lp 2116 dev/raidframe/rf_openbsdkintf.c lp->d_magic2 = DISKMAGIC;
lp 2117 dev/raidframe/rf_openbsdkintf.c lp->d_checksum = dkcksum(rs->sc_dkdev.dk_label);
lp 2125 dev/raidframe/rf_openbsdkintf.c raidgetdisklabel(dev_t dev, struct disklabel *lp, int spoofonly)
lp 2136 dev/raidframe/rf_openbsdkintf.c bzero(lp, sizeof(*lp));
lp 2140 dev/raidframe/rf_openbsdkintf.c raidgetdefaultlabel(raidPtr, rs, lp);
lp 2145 dev/raidframe/rf_openbsdkintf.c errstring = readdisklabel(DISKLABELDEV(dev), raidstrategy, lp,
lp 2161 dev/raidframe/rf_openbsdkintf.c if (DL_GETDSIZE(lp) != rs->sc_size)
lp 2165 dev/raidframe/rf_openbsdkintf.c DL_GETDSIZE(lp), (long) rs->sc_size);
lp 2167 dev/raidframe/rf_openbsdkintf.c for (i = 0; i < lp->d_npartitions; i++) {
lp 2168 dev/raidframe/rf_openbsdkintf.c pp = &lp->d_partitions[i];
lp 146 dev/raidframe/rf_parityscan.c RF_LayoutSW_t *lp;
lp 149 dev/raidframe/rf_parityscan.c lp = raidPtr->Layout.map;
lp 150 dev/raidframe/rf_parityscan.c if (lp->faultsTolerated == 0) {
lp 157 dev/raidframe/rf_parityscan.c if (lp->VerifyParity) {
lp 161 dev/raidframe/rf_parityscan.c lrc = lp->VerifyParity(raidPtr,
lp 109 dev/raidframe/rf_reconbuffer.c RF_LayoutSW_t *lp;
lp 112 dev/raidframe/rf_reconbuffer.c lp = rbuf->raidPtr->Layout.map;
lp 113 dev/raidframe/rf_reconbuffer.c rc = lp->SubmitReconBuffer(rbuf, keep_it, use_committed);
lp 335 dev/raidframe/rf_reconstruct.c RF_LayoutSW_t *lp;
lp 338 dev/raidframe/rf_reconstruct.c lp = raidPtr->Layout.map;
lp 339 dev/raidframe/rf_reconstruct.c if (lp->SubmitReconBuffer) {
lp 356 dev/raidframe/rf_reconstruct.c " arch %c.\n", lp->parityConfig);
lp 470 dev/raidframe/rf_reconstruct.c RF_LayoutSW_t *lp;
lp 481 dev/raidframe/rf_reconstruct.c lp = raidPtr->Layout.map;
lp 482 dev/raidframe/rf_reconstruct.c if (lp->SubmitReconBuffer) {
lp 671 dev/raidframe/rf_reconstruct.c " arch %c.\n", lp->parityConfig);
lp 66 dev/raidframe/rf_reconutil.c RF_LayoutSW_t *lp;
lp 70 dev/raidframe/rf_reconutil.c lp = raidPtr->Layout.map;
lp 102 dev/raidframe/rf_reconutil.c if (lp->GetNumSpareRUs) {
lp 103 dev/raidframe/rf_reconutil.c numSpareRUs = lp->GetNumSpareRUs(raidPtr);
lp 111 dev/raidframe/rf_reconutil.c if (lp->InstallSpareTable) {
lp 210 dev/raidframe/rf_reconutil.c RF_LayoutSW_t *lp;
lp 212 dev/raidframe/rf_reconutil.c lp = raidPtr->Layout.map;
lp 213 dev/raidframe/rf_reconutil.c if (lp->GetDefaultHeadSepLimit == NULL)
lp 215 dev/raidframe/rf_reconutil.c hsl = lp->GetDefaultHeadSepLimit(raidPtr);
lp 226 dev/raidframe/rf_reconutil.c RF_LayoutSW_t *lp;
lp 229 dev/raidframe/rf_reconutil.c lp = raidPtr->Layout.map;
lp 230 dev/raidframe/rf_reconutil.c if (lp->GetDefaultNumFloatingReconBuffers == NULL)
lp 232 dev/raidframe/rf_reconutil.c nrb = lp->GetDefaultNumFloatingReconBuffers(raidPtr);
lp 396 dev/ramdisk.c struct disklabel *lp;
lp 409 dev/ramdisk.c lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
lp 410 dev/ramdisk.c rdgetdisklabel(dev, sc, lp, 0);
lp 411 dev/ramdisk.c bcopy(lp, sc->sc_dkdev.dk_label, sizeof(*lp));
lp 412 dev/ramdisk.c free(lp, M_TEMP);
lp 493 dev/ramdisk.c rdgetdisklabel(dev_t dev, struct rd_softc *sc, struct disklabel *lp,
lp 496 dev/ramdisk.c bzero(lp, sizeof(struct disklabel));
lp 498 dev/ramdisk.c lp->d_secsize = DEV_BSIZE;
lp 499 dev/ramdisk.c lp->d_ntracks = 1;
lp 500 dev/ramdisk.c lp->d_nsectors = sc->sc_size >> DEV_BSHIFT;
lp 501 dev/ramdisk.c lp->d_ncylinders = 1;
lp 502 dev/ramdisk.c lp->d_secpercyl = lp->d_nsectors;
lp 503 dev/ramdisk.c if (lp->d_secpercyl == 0) {
lp 504 dev/ramdisk.c lp->d_secpercyl = 100;
lp 508 dev/ramdisk.c strncpy(lp->d_typename, "RAM disk", sizeof(lp->d_typename));
lp 509 dev/ramdisk.c lp->d_type = DTYPE_SCSI;
lp 510 dev/ramdisk.c strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
lp 511 dev/ramdisk.c DL_SETDSIZE(lp, lp->d_nsectors);
lp 512 dev/ramdisk.c lp->d_rpm = 3600;
lp 513 dev/ramdisk.c lp->d_interleave = 1;
lp 514 dev/ramdisk.c lp->d_version = 1;
lp 516 dev/ramdisk.c lp->d_magic = DISKMAGIC;
lp 517 dev/ramdisk.c lp->d_magic2 = DISKMAGIC;
lp 518 dev/ramdisk.c lp->d_checksum = dkcksum(lp);
lp 523 dev/ramdisk.c readdisklabel(DISKLABELDEV(dev), rdstrategy, lp, spoofonly);
lp 297 dev/vnd.c struct disklabel *lp = sc->sc_dk.dk_label;
lp 300 dev/vnd.c bzero(lp, sizeof(struct disklabel));
lp 302 dev/vnd.c lp->d_secsize = 512;
lp 303 dev/vnd.c lp->d_ntracks = 1;
lp 304 dev/vnd.c lp->d_nsectors = 100;
lp 305 dev/vnd.c lp->d_ncylinders = sc->sc_size / 100;
lp 306 dev/vnd.c lp->d_secpercyl = 100; /* lp->d_ntracks * lp->d_nsectors */
lp 308 dev/vnd.c strncpy(lp->d_typename, "vnd device", sizeof(lp->d_typename));
lp 309 dev/vnd.c lp->d_type = DTYPE_VND;
lp 310 dev/vnd.c strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
lp 311 dev/vnd.c DL_SETDSIZE(lp, sc->sc_size);
lp 312 dev/vnd.c lp->d_rpm = 3600;
lp 313 dev/vnd.c lp->d_interleave = 1;
lp 314 dev/vnd.c lp->d_flags = 0;
lp 315 dev/vnd.c lp->d_version = 1;
lp 317 dev/vnd.c lp->d_magic = DISKMAGIC;
lp 318 dev/vnd.c lp->d_magic2 = DISKMAGIC;
lp 319 dev/vnd.c lp->d_checksum = dkcksum(lp);
lp 322 dev/vnd.c errstring = readdisklabel(VNDLABELDEV(dev), vndstrategy, lp, 0);
lp 86 isofs/cd9660/cd9660_vfsops.c struct disklabel *lp);
lp 460 isofs/cd9660/cd9660_vfsops.c iso_disklabelspoof(dev, strat, lp)
lp 463 isofs/cd9660/cd9660_vfsops.c register struct disklabel *lp;
lp 480 isofs/cd9660/cd9660_vfsops.c bp->b_cylinder = bp->b_blkno / lp->d_secpercyl;
lp 513 isofs/cd9660/cd9660_vfsops.c strncpy(lp->d_typename, pri->volume_id, sizeof lp->d_typename);
lp 514 isofs/cd9660/cd9660_vfsops.c strncpy(lp->d_packname, pri->volume_id+16, sizeof lp->d_packname);
lp 516 isofs/cd9660/cd9660_vfsops.c DL_SETPSIZE(&lp->d_partitions[i], 0);
lp 517 isofs/cd9660/cd9660_vfsops.c DL_SETPOFFSET(&lp->d_partitions[i], 0);
lp 519 isofs/cd9660/cd9660_vfsops.c DL_SETPOFFSET(&lp->d_partitions[0], 0);
lp 520 isofs/cd9660/cd9660_vfsops.c DL_SETPSIZE(&lp->d_partitions[0], DL_GETDSIZE(lp));
lp 521 isofs/cd9660/cd9660_vfsops.c lp->d_partitions[0].p_fstype = FS_ISO9660;
lp 522 isofs/cd9660/cd9660_vfsops.c DL_SETPOFFSET(&lp->d_partitions[RAW_PART], 0);
lp 523 isofs/cd9660/cd9660_vfsops.c DL_SETPSIZE(&lp->d_partitions[RAW_PART], DL_GETDSIZE(lp));
lp 524 isofs/cd9660/cd9660_vfsops.c lp->d_partitions[RAW_PART].p_fstype = FS_ISO9660;
lp 525 isofs/cd9660/cd9660_vfsops.c lp->d_npartitions = RAW_PART + 1;
lp 526 isofs/cd9660/cd9660_vfsops.c lp->d_bbsize = 8192; /* fake */
lp 527 isofs/cd9660/cd9660_vfsops.c lp->d_sbsize = 64*1024; /* fake */
lp 528 isofs/cd9660/cd9660_vfsops.c lp->d_version = 1;
lp 530 isofs/cd9660/cd9660_vfsops.c lp->d_magic = DISKMAGIC;
lp 531 isofs/cd9660/cd9660_vfsops.c lp->d_magic2 = DISKMAGIC;
lp 532 isofs/cd9660/cd9660_vfsops.c lp->d_checksum = dkcksum(lp);
lp 93 isofs/udf/udf_subr.c struct disklabel *lp)
lp 114 isofs/udf/udf_subr.c bp->b_resid = bp->b_blkno / lp->d_secpercyl;
lp 134 isofs/udf/udf_subr.c bp->b_resid = bp->b_blkno / lp->d_secpercyl;
lp 155 isofs/udf/udf_subr.c strlcpy(lp->d_typename, vid, sizeof(lp->d_typename));
lp 158 isofs/udf/udf_subr.c DL_SETPSIZE(&lp->d_partitions[i], 0);
lp 159 isofs/udf/udf_subr.c DL_SETPOFFSET(&lp->d_partitions[i], 0);
lp 165 isofs/udf/udf_subr.c DL_SETPSIZE(&lp->d_partitions[0], DL_GETDSIZE(lp));
lp 166 isofs/udf/udf_subr.c lp->d_partitions[0].p_fstype = FS_UDF;
lp 167 isofs/udf/udf_subr.c DL_SETPSIZE(&lp->d_partitions[RAW_PART], DL_GETDSIZE(lp));
lp 168 isofs/udf/udf_subr.c lp->d_partitions[RAW_PART].p_fstype = FS_UDF;
lp 169 isofs/udf/udf_subr.c lp->d_npartitions = RAW_PART + 1;
lp 170 isofs/udf/udf_subr.c lp->d_version = 1;
lp 172 isofs/udf/udf_subr.c lp->d_bbsize = 8192; /* Fake. */
lp 173 isofs/udf/udf_subr.c lp->d_sbsize = 64*1024; /* Fake. */
lp 174 isofs/udf/udf_subr.c lp->d_magic = DISKMAGIC;
lp 175 isofs/udf/udf_subr.c lp->d_magic2 = DISKMAGIC;
lp 176 isofs/udf/udf_subr.c lp->d_checksum = dkcksum(lp);
lp 740 kern/kern_lock.c simple_lock_only_held(volatile struct simplelock *lp, const char *where)
lp 746 kern/kern_lock.c if (lp) {
lp 747 kern/kern_lock.c LOCK_ASSERT(simple_lock_held(lp));
lp 752 kern/kern_lock.c if (alp == lp)
lp 149 kern/kern_malloc.c int32_t *end, *lp;
lp 251 kern/kern_malloc.c for (lp = (int32_t *)cp; lp < end; lp++)
lp 252 kern/kern_malloc.c *lp = WEIRD_ADDR;
lp 297 kern/kern_malloc.c for (lp = (int32_t *)&freep->next; lp < end; lp++)
lp 298 kern/kern_malloc.c *lp = WEIRD_ADDR;
lp 302 kern/kern_malloc.c for (lp = (int32_t *)va; lp < end; lp++) {
lp 303 kern/kern_malloc.c if (*lp == WEIRD_ADDR)
lp 306 kern/kern_malloc.c "Data modified on freelist: word", lp - (int32_t *)va,
lp 307 kern/kern_malloc.c va, size, "previous type", savedtype, *lp, WEIRD_ADDR);
lp 348 kern/kern_malloc.c int32_t *end, *lp;
lp 422 kern/kern_malloc.c for (lp = (int32_t *)addr; lp < end; lp++)
lp 423 kern/kern_malloc.c *lp = WEIRD_ADDR;
lp 172 kern/subr_disk.c dkcksum(struct disklabel *lp)
lp 177 kern/subr_disk.c start = (u_int16_t *)lp;
lp 178 kern/subr_disk.c end = (u_int16_t *)&lp->d_partitions[lp->d_npartitions];
lp 185 kern/subr_disk.c initdisklabel(struct disklabel *lp)
lp 190 kern/subr_disk.c if (lp->d_secsize < DEV_BSIZE)
lp 191 kern/subr_disk.c lp->d_secsize = DEV_BSIZE;
lp 192 kern/subr_disk.c if (DL_GETDSIZE(lp) == 0)
lp 193 kern/subr_disk.c DL_SETDSIZE(lp, MAXDISKSIZE);
lp 194 kern/subr_disk.c if (lp->d_secpercyl == 0)
lp 196 kern/subr_disk.c lp->d_npartitions = RAW_PART + 1;
lp 198 kern/subr_disk.c DL_SETPSIZE(&lp->d_partitions[i], 0);
lp 199 kern/subr_disk.c DL_SETPOFFSET(&lp->d_partitions[i], 0);
lp 201 kern/subr_disk.c if (DL_GETPSIZE(&lp->d_partitions[RAW_PART]) == 0)
lp 202 kern/subr_disk.c DL_SETPSIZE(&lp->d_partitions[RAW_PART], DL_GETDSIZE(lp));
lp 203 kern/subr_disk.c DL_SETPOFFSET(&lp->d_partitions[RAW_PART], 0);
lp 204 kern/subr_disk.c lp->d_version = 1;
lp 205 kern/subr_disk.c lp->d_bbsize = 8192;
lp 206 kern/subr_disk.c lp->d_sbsize = 64*1024; /* XXX ? */
lp 215 kern/subr_disk.c checkdisklabel(void *rlp, struct disklabel *lp)
lp 319 kern/subr_disk.c disksize = DL_GETDSIZE(lp);
lp 321 kern/subr_disk.c if (lp != dlp)
lp 322 kern/subr_disk.c *lp = *dlp;
lp 324 kern/subr_disk.c if (lp->d_version == 0) {
lp 325 kern/subr_disk.c lp->d_version = 1;
lp 326 kern/subr_disk.c lp->d_secperunith = 0;
lp 328 kern/subr_disk.c v0pp = (struct __partitionv0 *)lp->d_partitions;
lp 329 kern/subr_disk.c pp = lp->d_partitions;
lp 330 kern/subr_disk.c for (i = 0; i < lp->d_npartitions; i++, pp++, v0pp++) {
lp 339 kern/subr_disk.c if (DL_GETDSIZE(lp) != disksize)
lp 341 kern/subr_disk.c DL_GETDSIZE(lp));
lp 342 kern/subr_disk.c if (DL_GETPSIZE(&lp->d_partitions[RAW_PART]) != disksize)
lp 344 kern/subr_disk.c DL_GETPSIZE(&lp->d_partitions[RAW_PART]));
lp 345 kern/subr_disk.c if (DL_GETPOFFSET(&lp->d_partitions[RAW_PART]) != 0)
lp 347 kern/subr_disk.c DL_GETPOFFSET(&lp->d_partitions[RAW_PART]));
lp 349 kern/subr_disk.c DL_SETDSIZE(lp, disksize);
lp 350 kern/subr_disk.c DL_SETPSIZE(&lp->d_partitions[RAW_PART], disksize);
lp 351 kern/subr_disk.c DL_SETPOFFSET(&lp->d_partitions[RAW_PART], 0);
lp 353 kern/subr_disk.c lp->d_checksum = 0;
lp 354 kern/subr_disk.c lp->d_checksum = dkcksum(lp);
lp 369 kern/subr_disk.c struct disklabel *lp, int *partoffp, int spoofonly)
lp 377 kern/subr_disk.c if (lp->d_secpercyl == 0)
lp 379 kern/subr_disk.c if (lp->d_secsize == 0)
lp 396 kern/subr_disk.c bp->b_bcount = lp->d_secsize;
lp 428 kern/subr_disk.c if (lp->d_ntracks == 0)
lp 429 kern/subr_disk.c lp->d_ntracks = dp2->dp_ehd + 1;
lp 430 kern/subr_disk.c if (lp->d_nsectors == 0)
lp 431 kern/subr_disk.c lp->d_nsectors = DPSECT(dp2->dp_esect);
lp 432 kern/subr_disk.c if (lp->d_secpercyl == 0)
lp 433 kern/subr_disk.c lp->d_secpercyl = lp->d_ntracks *
lp 434 kern/subr_disk.c lp->d_nsectors;
lp 442 kern/subr_disk.c struct partition *pp = &lp->d_partitions[8+n];
lp 446 kern/subr_disk.c if (letoh32(dp2->dp_size) > DL_GETDSIZE(lp))
lp 448 kern/subr_disk.c if (letoh32(dp2->dp_start) > DL_GETDSIZE(lp))
lp 494 kern/subr_disk.c lp->d_npartitions = MAXPARTITIONS;
lp 518 kern/subr_disk.c DL_SETPSIZE(&lp->d_partitions['i' - 'a'],
lp 519 kern/subr_disk.c DL_GETPSIZE(&lp->d_partitions[RAW_PART]));
lp 520 kern/subr_disk.c DL_SETPOFFSET(&lp->d_partitions['i' - 'a'], 0);
lp 521 kern/subr_disk.c lp->d_partitions['i' - 'a'].p_fstype = FS_MSDOS;
lp 534 kern/subr_disk.c bp->b_bcount = lp->d_secsize;
lp 541 kern/subr_disk.c return checkdisklabel(bp->b_data, lp);
lp 603 kern/subr_disk.c bounds_check_with_label(struct buf *bp, struct disklabel *lp, int wlabel)
lp 605 kern/subr_disk.c #define blockpersec(count, lp) ((count) * (((lp)->d_secsize) / DEV_BSIZE))
lp 606 kern/subr_disk.c struct partition *p = &lp->d_partitions[DISKPART(bp->b_dev)];
lp 610 kern/subr_disk.c if (lp->d_secpercyl == 0)
lp 614 kern/subr_disk.c if (bp->b_blkno + sz > blockpersec(DL_GETPSIZE(p), lp)) {
lp 615 kern/subr_disk.c sz = blockpersec(DL_GETPSIZE(p), lp) - bp->b_blkno;
lp 630 kern/subr_disk.c bp->b_cylinder = (bp->b_blkno + blockpersec(DL_GETPOFFSET(p), lp)) /
lp 631 kern/subr_disk.c blockpersec(lp->d_secpercyl, lp);
lp 656 kern/subr_disk.c struct disklabel *lp)
lp 682 kern/subr_disk.c if (lp && (blkdone >= 0 || bp->b_bcount <= lp->d_secsize)) {
lp 683 kern/subr_disk.c sn += DL_GETPOFFSET(&lp->d_partitions[part]);
lp 685 kern/subr_disk.c sn / lp->d_secpercyl);
lp 686 kern/subr_disk.c sn %= lp->d_secpercyl;
lp 687 kern/subr_disk.c (*pr)(" tn %lld sn %lld)", sn / lp->d_nsectors,
lp 688 kern/subr_disk.c sn % lp->d_nsectors);
lp 37 lib/libkern/getsn.c char *lp = cp;
lp 45 lib/libkern/getsn.c *lp++ = '\0';
lp 51 lib/libkern/getsn.c --lp;
lp 58 lib/libkern/getsn.c --lp;
lp 71 lib/libkern/getsn.c *lp++ = c;
lp 40 lib/libsa/disklabel.c getdisklabel(const char *buf, struct disklabel *lp)
lp 55 lib/libsa/disklabel.c *lp = *dlp;
lp 43 lib/libsa/dkcksum.c dkcksum(struct disklabel *lp)
lp 48 lib/libsa/dkcksum.c start = (u_short *)lp;
lp 49 lib/libsa/dkcksum.c end = (u_short *)&lp->d_partitions[lp->d_npartitions];
lp 41 lib/libsa/gets.c char *lp;
lp 43 lib/libsa/gets.c for (lp = buf;;)
lp 47 lib/libsa/gets.c *lp = '\0';
lp 52 lib/libsa/gets.c if (lp > buf) {
lp 53 lib/libsa/gets.c lp--;
lp 61 lib/libsa/gets.c if (lp > buf)
lp 62 lib/libsa/gets.c --lp;
lp 69 lib/libsa/gets.c for (p = buf; p < lp; ++p)
lp 78 lib/libsa/gets.c lp = buf;
lp 82 lib/libsa/gets.c *lp++ = c;
lp 160 net/if_media.c ifmedia_list_add(struct ifmedia *ifm, struct ifmedia_entry *lp, int count)
lp 165 net/if_media.c ifmedia_add(ifm, lp[i].ifm_media, lp[i].ifm_data,
lp 166 net/if_media.c lp[i].ifm_aux);
lp 4265 netinet/tcp_input.c u_int32_t *lp = (u_int32_t *)(optp);
lp 4267 netinet/tcp_input.c *lp++ = htonl(TCPOPT_TSTAMP_HDR);
lp 4268 netinet/tcp_input.c *lp++ = htonl(SYN_CACHE_TIMESTAMP(sc));
lp 4269 netinet/tcp_input.c *lp = htonl(sc->sc_timestamp);
lp 593 netinet/tcp_output.c u_int32_t *lp = (u_int32_t *)(opt + optlen);
lp 596 netinet/tcp_output.c *lp++ = htonl(TCPOPT_TSTAMP_HDR);
lp 597 netinet/tcp_output.c *lp++ = htonl(tcp_now + tp->ts_modulate);
lp 598 netinet/tcp_output.c *lp = htonl(tp->ts_recent);
lp 638 netinet/tcp_output.c u_int32_t *lp = (u_int32_t *)(opt + optlen);
lp 639 netinet/tcp_output.c u_int32_t *olp = lp++;
lp 649 netinet/tcp_output.c *lp++ = htonl(sack.start);
lp 650 netinet/tcp_output.c *lp++ = htonl(sack.end);
lp 771 scsi/cd.c struct disklabel *lp;
lp 825 scsi/cd.c lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
lp 826 scsi/cd.c cdgetdisklabel(dev, cd, lp, 0);
lp 827 scsi/cd.c bcopy(lp, cd->sc_dk.dk_label, sizeof(*lp));
lp 828 scsi/cd.c free(lp, M_TEMP);
lp 1151 scsi/cd.c cdgetdisklabel(dev_t dev, struct cd_softc *cd, struct disklabel *lp,
lp 1158 scsi/cd.c bzero(lp, sizeof(struct disklabel));
lp 1163 scsi/cd.c lp->d_secsize = cd->params.blksize;
lp 1164 scsi/cd.c lp->d_ntracks = 1;
lp 1165 scsi/cd.c lp->d_nsectors = 100;
lp 1166 scsi/cd.c lp->d_secpercyl = 100;
lp 1167 scsi/cd.c lp->d_ncylinders = (cd->params.disksize / 100) + 1;
lp 1170 scsi/cd.c strncpy(lp->d_typename, "ATAPI CD-ROM", sizeof(lp->d_typename));
lp 1171 scsi/cd.c lp->d_type = DTYPE_ATAPI;
lp 1173 scsi/cd.c strncpy(lp->d_typename, "SCSI CD-ROM", sizeof(lp->d_typename));
lp 1174 scsi/cd.c lp->d_type = DTYPE_SCSI;
lp 1177 scsi/cd.c strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
lp 1178 scsi/cd.c DL_SETDSIZE(lp, cd->params.disksize);
lp 1179 scsi/cd.c lp->d_rpm = 300;
lp 1180 scsi/cd.c lp->d_interleave = 1;
lp 1181 scsi/cd.c lp->d_version = 1;
lp 1184 scsi/cd.c lp->d_bbsize = BBSIZE;
lp 1185 scsi/cd.c lp->d_sbsize = SBSIZE;
lp 1187 scsi/cd.c lp->d_magic = DISKMAGIC;
lp 1188 scsi/cd.c lp->d_magic2 = DISKMAGIC;
lp 1189 scsi/cd.c lp->d_checksum = dkcksum(lp);
lp 1207 scsi/cd.c errstring = readdisklabel(DISKLABELDEV(dev), cdstrategy, lp,
lp 824 scsi/sd.c struct disklabel *lp;
lp 861 scsi/sd.c lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
lp 862 scsi/sd.c sdgetdisklabel(dev, sd, lp, 0);
lp 863 scsi/sd.c bcopy(lp, sd->sc_dk.dk_label, sizeof(*lp));
lp 864 scsi/sd.c free(lp, M_TEMP);
lp 978 scsi/sd.c sdgetdisklabel(dev_t dev, struct sd_softc *sd, struct disklabel *lp,
lp 982 scsi/sd.c char *errstring, packname[sizeof(lp->d_packname) + 1];
lp 985 scsi/sd.c bzero(lp, sizeof(struct disklabel));
lp 987 scsi/sd.c lp->d_secsize = sd->params.blksize;
lp 988 scsi/sd.c lp->d_ntracks = sd->params.heads;
lp 989 scsi/sd.c lp->d_nsectors = sd->params.sectors;
lp 990 scsi/sd.c lp->d_ncylinders = sd->params.cyls;
lp 991 scsi/sd.c lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
lp 992 scsi/sd.c if (lp->d_secpercyl == 0) {
lp 993 scsi/sd.c lp->d_secpercyl = 100;
lp 997 scsi/sd.c lp->d_type = DTYPE_SCSI;
lp 999 scsi/sd.c strncpy(lp->d_typename, "SCSI optical",
lp 1000 scsi/sd.c sizeof(lp->d_typename));
lp 1002 scsi/sd.c strncpy(lp->d_typename, "SCSI disk",
lp 1003 scsi/sd.c sizeof(lp->d_typename));
lp 1013 scsi/sd.c if (len > sizeof(lp->d_packname)) {
lp 1023 scsi/sd.c bcopy(packname, lp->d_packname, len);
lp 1025 scsi/sd.c DL_SETDSIZE(lp, sd->params.disksize);
lp 1026 scsi/sd.c lp->d_rpm = sd->params.rot_rate;
lp 1027 scsi/sd.c lp->d_interleave = 1;
lp 1028 scsi/sd.c lp->d_version = 1;
lp 1029 scsi/sd.c lp->d_flags = 0;
lp 1032 scsi/sd.c lp->d_bbsize = BBSIZE;
lp 1033 scsi/sd.c lp->d_sbsize = SBSIZE;
lp 1035 scsi/sd.c lp->d_magic = DISKMAGIC;
lp 1036 scsi/sd.c lp->d_magic2 = DISKMAGIC;
lp 1037 scsi/sd.c lp->d_checksum = dkcksum(lp);
lp 1042 scsi/sd.c errstring = readdisklabel(DISKLABELDEV(dev), sdstrategy, lp, spoofonly);
lp 1178 scsi/sd.c struct disklabel *lp; /* disk's disklabel */
lp 1215 scsi/sd.c lp = sd->sc_dk.dk_label;
lp 1216 scsi/sd.c sectorsize = lp->d_secsize;
lp 1222 scsi/sd.c nsects = DL_GETPSIZE(&lp->d_partitions[part]);
lp 1223 scsi/sd.c sectoff = DL_GETPOFFSET(&lp->d_partitions[part]);
lp 464 sys/disklabel.h struct disklabel *lp);
lp 468 sys/disklabel.h struct disklabel *lp);
lp 1422 ufs/ffs/ffs_alloc.c int32_t *lp;
lp 1437 ufs/ffs/ffs_alloc.c lp = &cg_clustersum(cgp)[len];
lp 1439 ufs/ffs/ffs_alloc.c if (*lp++ > 0)
lp 1449 ufs/ffs/ffs_alloc.c lp = &cg_clustersum(cgp)[len - 1];
lp 1451 ufs/ffs/ffs_alloc.c if (*lp-- > 0)
lp 1982 ufs/ffs/ffs_alloc.c int32_t *lp;
lp 2054 ufs/ffs/ffs_alloc.c lp = &sump[fs->fs_contigsumsize];
lp 2056 ufs/ffs/ffs_alloc.c if (*lp-- > 0)
lp 532 ufs/ffs/ffs_vfsops.c int32_t *lp;
lp 612 ufs/ffs/ffs_vfsops.c lp = fs->fs_maxcluster;
lp 614 ufs/ffs/ffs_vfsops.c *lp++ = fs->fs_contigsumsize;
lp 675 ufs/ffs/ffs_vfsops.c int32_t *lp;
lp 836 ufs/ffs/ffs_vfsops.c fs->fs_maxcluster = lp = (int32_t *)space;
lp 838 ufs/ffs/ffs_vfsops.c *lp++ = fs->fs_contigsumsize;
lp 1462 ufs/ffs/ffs_vfsops.c int32_t *lp, tmp; /* XXX */
lp 1464 ufs/ffs/ffs_vfsops.c lp = (int32_t *)&dfs->fs_qbmask; /* XXX */
lp 1465 ufs/ffs/ffs_vfsops.c tmp = lp[4]; /* XXX */
lp 1467 ufs/ffs/ffs_vfsops.c lp[i] = lp[i-1]; /* XXX */
lp 1468 ufs/ffs/ffs_vfsops.c lp[0] = tmp; /* XXX */