Print this page
5253 kmem_alloc/kmem_zalloc won't fail with KM_SLEEP
5254 getrbuf won't fail with KM_SLEEP


 724         case DKIOCGETDEF:
 725                 {
 726                 struct buf      *bp;
 727                 int             err, head;
 728                 unsigned char   *secbuf;
 729                 STRUCT_DECL(defect_header, adh);
 730 
 731                 STRUCT_INIT(adh, flag & FMODELS);
 732 
 733                 /*
 734                  * copyin header ....
 735                  * yields head number and buffer address
 736                  */
 737                 if (ddi_copyin((caddr_t)arg, STRUCT_BUF(adh), STRUCT_SIZE(adh),
 738                     flag))
 739                         return (EFAULT);
 740                 head = STRUCT_FGET(adh, head);
 741                 if (head < 0 || head >= dadkp->dad_phyg.g_head)
 742                         return (ENXIO);
 743                 secbuf = kmem_zalloc(NBPSCTR, KM_SLEEP);
 744                 if (!secbuf)
 745                         return (ENOMEM);
 746                 bp = getrbuf(KM_SLEEP);
 747                 if (!bp) {
 748                         kmem_free(secbuf, NBPSCTR);
 749                         return (ENOMEM);
 750                 }
 751 
 752                 bp->b_edev = dev;
 753                 bp->b_dev  = cmpdev(dev);
 754                 bp->b_flags = B_BUSY;
 755                 bp->b_resid = 0;
 756                 bp->b_bcount = NBPSCTR;
 757                 bp->b_un.b_addr = (caddr_t)secbuf;
 758                 bp->b_blkno = head; /* I had to put it somwhere! */
 759                 bp->b_forw = (struct buf *)dadkp;
 760                 bp->b_back = (struct buf *)DCMD_GETDEF;
 761 
 762                 mutex_enter(&dadkp->dad_cmd_mutex);
 763                 dadkp->dad_cmd_count++;
 764                 mutex_exit(&dadkp->dad_cmd_mutex);
 765                 FLC_ENQUE(dadkp->dad_flcobjp, bp);
 766                 err = biowait(bp);
 767                 if (!err) {
 768                         if (ddi_copyout((caddr_t)secbuf,
 769                             STRUCT_FGETP(adh, buffer), NBPSCTR, flag))
 770                                 err = ENXIO;


1674 {
1675         struct dadk *dadkp = (struct dadk *)objp;
1676         struct scsi_inquiry **sinqpp = (struct scsi_inquiry **)inqpp;
1677 
1678         if (dadkp && dadkp->dad_sd && dadkp->dad_sd->sd_inq) {
1679                 *sinqpp = dadkp->dad_sd->sd_inq;
1680                 return (DDI_SUCCESS);
1681         }
1682 
1683         return (DDI_FAILURE);
1684 }
1685 
1686 static int
1687 dadk_rmb_ioctl(struct dadk *dadkp, int cmd, intptr_t arg, int flags, int silent)
1688 
1689 {
1690         struct buf *bp;
1691         int err;
1692         struct cmpkt *pktp;
1693 
1694         if ((bp = getrbuf(KM_SLEEP)) == NULL) {
1695                 return (ENOMEM);
1696         }
1697         pktp = dadk_pktprep(dadkp, NULL, bp, dadk_rmb_iodone, NULL, NULL);
1698         if (!pktp) {
1699                 freerbuf(bp);
1700                 return (ENOMEM);
1701         }
1702         bp->b_back  = (struct buf *)arg;
1703         bp->b_forw  = (struct buf *)dadkp->dad_flcobjp;
1704         pktp->cp_passthru = (opaque_t)(intptr_t)silent;
1705 
1706         err = dadk_ctl_ioctl(dadkp, cmd, (uintptr_t)pktp, flags);
1707         freerbuf(bp);
1708         gda_free(dadkp->dad_ctlobjp, pktp, NULL);
1709         return (err);
1710 
1711 
1712 }
1713 
1714 static void
1715 dadk_rmb_iodone(struct buf *bp)
1716 {




 724         case DKIOCGETDEF:
 725                 {
 726                 struct buf      *bp;
 727                 int             err, head;
 728                 unsigned char   *secbuf;
 729                 STRUCT_DECL(defect_header, adh);
 730 
 731                 STRUCT_INIT(adh, flag & FMODELS);
 732 
 733                 /*
 734                  * copyin header ....
 735                  * yields head number and buffer address
 736                  */
 737                 if (ddi_copyin((caddr_t)arg, STRUCT_BUF(adh), STRUCT_SIZE(adh),
 738                     flag))
 739                         return (EFAULT);
 740                 head = STRUCT_FGET(adh, head);
 741                 if (head < 0 || head >= dadkp->dad_phyg.g_head)
 742                         return (ENXIO);
 743                 secbuf = kmem_zalloc(NBPSCTR, KM_SLEEP);
 744 

 745                 bp = getrbuf(KM_SLEEP);




 746 
 747                 bp->b_edev = dev;
 748                 bp->b_dev  = cmpdev(dev);
 749                 bp->b_flags = B_BUSY;
 750                 bp->b_resid = 0;
 751                 bp->b_bcount = NBPSCTR;
 752                 bp->b_un.b_addr = (caddr_t)secbuf;
 753                 bp->b_blkno = head; /* I had to put it somwhere! */
 754                 bp->b_forw = (struct buf *)dadkp;
 755                 bp->b_back = (struct buf *)DCMD_GETDEF;
 756 
 757                 mutex_enter(&dadkp->dad_cmd_mutex);
 758                 dadkp->dad_cmd_count++;
 759                 mutex_exit(&dadkp->dad_cmd_mutex);
 760                 FLC_ENQUE(dadkp->dad_flcobjp, bp);
 761                 err = biowait(bp);
 762                 if (!err) {
 763                         if (ddi_copyout((caddr_t)secbuf,
 764                             STRUCT_FGETP(adh, buffer), NBPSCTR, flag))
 765                                 err = ENXIO;


1669 {
1670         struct dadk *dadkp = (struct dadk *)objp;
1671         struct scsi_inquiry **sinqpp = (struct scsi_inquiry **)inqpp;
1672 
1673         if (dadkp && dadkp->dad_sd && dadkp->dad_sd->sd_inq) {
1674                 *sinqpp = dadkp->dad_sd->sd_inq;
1675                 return (DDI_SUCCESS);
1676         }
1677 
1678         return (DDI_FAILURE);
1679 }
1680 
1681 static int
1682 dadk_rmb_ioctl(struct dadk *dadkp, int cmd, intptr_t arg, int flags, int silent)
1683 
1684 {
1685         struct buf *bp;
1686         int err;
1687         struct cmpkt *pktp;
1688 
1689         bp = getrbuf(KM_SLEEP);


1690         pktp = dadk_pktprep(dadkp, NULL, bp, dadk_rmb_iodone, NULL, NULL);
1691         if (!pktp) {
1692                 freerbuf(bp);
1693                 return (ENOMEM);
1694         }
1695         bp->b_back  = (struct buf *)arg;
1696         bp->b_forw  = (struct buf *)dadkp->dad_flcobjp;
1697         pktp->cp_passthru = (opaque_t)(intptr_t)silent;
1698 
1699         err = dadk_ctl_ioctl(dadkp, cmd, (uintptr_t)pktp, flags);
1700         freerbuf(bp);
1701         gda_free(dadkp->dad_ctlobjp, pktp, NULL);
1702         return (err);
1703 
1704 
1705 }
1706 
1707 static void
1708 dadk_rmb_iodone(struct buf *bp)
1709 {