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

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/io/fibre-channel/fca/qlc/ql_xioctl.c
          +++ new/usr/src/uts/common/io/fibre-channel/fca/qlc/ql_xioctl.c
↓ open down ↓ 177 lines elided ↑ open up ↑
 178  178  
 179  179          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
 180  180  
 181  181          if (ha->xioctl != NULL) {
 182  182                  QL_PRINT_9(CE_CONT, "(%d): already allocated done\n",
 183  183                      ha->instance);
 184  184                  return (0);
 185  185          }
 186  186  
 187  187          xp = kmem_zalloc(sizeof (ql_xioctl_t), KM_SLEEP);
 188      -        if (xp == NULL) {
 189      -                EL(ha, "failed, kmem_zalloc\n");
 190      -                return (ENOMEM);
 191      -        }
 192  188          ha->xioctl = xp;
 193  189  
 194  190          /* Allocate AEN tracking buffer */
 195  191          xp->aen_tracking_queue = kmem_zalloc(EXT_DEF_MAX_AEN_QUEUE *
 196  192              sizeof (EXT_ASYNC_EVENT), KM_SLEEP);
 197      -        if (xp->aen_tracking_queue == NULL) {
 198      -                EL(ha, "failed, kmem_zalloc-2\n");
 199      -                ql_free_xioctl_resource(ha);
 200      -                return (ENOMEM);
 201      -        }
 202  193  
 203  194          QL_PRINT_9(CE_CONT, "(%d): done\n", ha->instance);
 204  195  
 205  196          return (0);
 206  197  }
 207  198  
 208  199  /*
 209  200   * ql_free_xioctl_resource
 210  201   *      Frees resources used by module code.
 211  202   *
↓ open down ↓ 1311 lines elided ↑ open up ↑
1523 1514          /* Determine maximum buffer size. */
1524 1515          if (cmd->RequestLen < cmd->ResponseLen) {
1525 1516                  pld_byte_cnt = cmd->ResponseLen;
1526 1517          } else {
1527 1518                  pld_byte_cnt = cmd->RequestLen;
1528 1519          }
1529 1520  
1530 1521          /* Allocate command block. */
1531 1522          pkt_size = (uint32_t)(sizeof (ql_mbx_iocb_t) + pld_byte_cnt);
1532 1523          pkt = kmem_zalloc(pkt_size, KM_SLEEP);
1533      -        if (pkt == NULL) {
1534      -                EL(ha, "failed, kmem_zalloc\n");
1535      -                cmd->Status = EXT_STATUS_NO_MEMORY;
1536      -                cmd->ResponseLen = 0;
1537      -                return;
1538      -        }
1539 1524          pld = (caddr_t)pkt + sizeof (ql_mbx_iocb_t);
1540 1525  
1541 1526          /* Get command payload data. */
1542 1527          if (ql_get_buffer_data((caddr_t)(uintptr_t)cmd->RequestAdr, pld,
1543 1528              cmd->RequestLen, mode) != cmd->RequestLen) {
1544 1529                  EL(ha, "failed, get_buffer_data\n");
1545 1530                  kmem_free(pkt, pkt_size);
1546 1531                  cmd->Status = EXT_STATUS_COPY_ERR;
1547 1532                  cmd->ResponseLen = 0;
1548 1533                  return;
↓ open down ↓ 584 lines elided ↑ open up ↑
2133 2118                  return;
2134 2119          }
2135 2120  
2136 2121          /* Allocate command block. */
2137 2122          if ((scsi_req.direction == EXT_DEF_SCSI_PASSTHRU_DATA_IN ||
2138 2123              scsi_req.direction == EXT_DEF_SCSI_PASSTHRU_DATA_OUT) &&
2139 2124              cmd->ResponseLen) {
2140 2125                  pld_size = cmd->ResponseLen;
2141 2126                  pkt_size = (uint32_t)(sizeof (ql_mbx_iocb_t) + pld_size);
2142 2127                  pkt = kmem_zalloc(pkt_size, KM_SLEEP);
2143      -                if (pkt == NULL) {
2144      -                        EL(ha, "failed, kmem_zalloc\n");
2145      -                        cmd->Status = EXT_STATUS_NO_MEMORY;
2146      -                        cmd->ResponseLen = 0;
2147      -                        return;
2148      -                }
2149 2128                  pld = (caddr_t)pkt + sizeof (ql_mbx_iocb_t);
2150 2129  
2151 2130                  /* Get DMA memory for the IOCB */
2152 2131                  if (ql_get_dma_mem(ha, dma_mem, pld_size, LITTLE_ENDIAN_DMA,
2153 2132                      QL_DMA_DATA_ALIGN) != QL_SUCCESS) {
2154 2133                          cmn_err(CE_WARN, "%s(%d): request queue DMA memory "
2155 2134                              "alloc failed", QL_NAME, ha->instance);
2156 2135                          kmem_free(pkt, pkt_size);
2157 2136                          cmd->Status = EXT_STATUS_MS_NO_RESPONSE;
2158 2137                          cmd->ResponseLen = 0;
↓ open down ↓ 32 lines elided ↑ open up ↑
2191 2170                          (void) ddi_dma_sync(dma_mem->dma_handle, 0,
2192 2171                              dma_mem->size, DDI_DMA_SYNC_FORDEV);
2193 2172                  }
2194 2173          } else {
2195 2174                  scsi_req.direction = (uint8_t)
2196 2175                      (CFG_IST(ha, CFG_CTRL_24258081) ? 0 : CF_STAG);
2197 2176                  cmd->ResponseLen = 0;
2198 2177  
2199 2178                  pkt_size = sizeof (ql_mbx_iocb_t);
2200 2179                  pkt = kmem_zalloc(pkt_size, KM_SLEEP);
2201      -                if (pkt == NULL) {
2202      -                        EL(ha, "failed, kmem_zalloc-2\n");
2203      -                        cmd->Status = EXT_STATUS_NO_MEMORY;
2204      -                        return;
2205      -                }
2206 2180                  pld = NULL;
2207 2181                  pld_size = 0;
2208 2182          }
2209 2183  
2210 2184          /* retries = ha->port_down_retry_count; */
2211 2185          retries = 1;
2212 2186          cmd->Status = EXT_STATUS_OK;
2213 2187          cmd->DetailStatus = EXT_DSTATUS_NOADNL_INFO;
2214 2188  
2215 2189          QL_PRINT_9(CE_CONT, "(%d): SCSI cdb\n", ha->instance);
↓ open down ↓ 1139 lines elided ↑ open up ↑
3355 3329                  EL(ha, "failed, BufferLength=%d, xfercnt=%d, "
3356 3330                      "mailbox_buffer_size=%d\n", plbreq.BufferLength,
3357 3331                      plbreq.TransferCount, MAILBOX_BUFFER_SIZE);
3358 3332                  cmd->Status = EXT_STATUS_INVALID_PARAM;
3359 3333                  cmd->ResponseLen = 0;
3360 3334                  return;
3361 3335          }
3362 3336  
3363 3337          /* Allocate command memory. */
3364 3338          bp = kmem_zalloc(plbreq.TransferCount, KM_SLEEP);
3365      -        if (bp == NULL) {
3366      -                EL(ha, "failed, kmem_zalloc\n");
3367      -                cmd->Status = EXT_STATUS_NO_MEMORY;
3368      -                cmd->ResponseLen = 0;
3369      -                return;
3370      -        }
3371 3339  
3372 3340          /* Get loopback data. */
3373 3341          if (ql_get_buffer_data((caddr_t)(uintptr_t)plbreq.BufferAddress,
3374 3342              bp, plbreq.TransferCount, mode) != plbreq.TransferCount) {
3375 3343                  EL(ha, "failed, ddi_copyin-2\n");
3376 3344                  kmem_free(bp, plbreq.TransferCount);
3377 3345                  cmd->Status = EXT_STATUS_COPY_ERR;
3378 3346                  cmd->ResponseLen = 0;
3379 3347                  return;
3380 3348          }
↓ open down ↓ 272 lines elided ↑ open up ↑
3653 3621                      EXT_DEF_PORTID_SIZE_ACTUAL) == 0) {
3654 3622                          local_hba = 1;
3655 3623                  } else {
3656 3624                          tq = ql_find_port(ha, (uint8_t *)tmp_fcid.r.d_id,
3657 3625                              QLNT_PID);
3658 3626                  }
3659 3627          }
3660 3628  
3661 3629          /* Allocate memory for command. */
3662 3630          tmp_buf = kmem_zalloc(SEND_RNID_RSP_SIZE, KM_SLEEP);
3663      -        if (tmp_buf == NULL) {
3664      -                EL(ha, "failed, kmem_zalloc\n");
3665      -                cmd->Status = EXT_STATUS_NO_MEMORY;
3666      -                cmd->ResponseLen = 0;
3667      -                return;
3668      -        }
3669 3631  
3670 3632          if (local_hba) {
3671 3633                  rval = ql_get_rnid_params(ha, SEND_RNID_RSP_SIZE, tmp_buf);
3672 3634                  if (rval != QL_SUCCESS) {
3673 3635                          EL(ha, "failed, get_rnid_params_mbx=%xh\n", rval);
3674 3636                          kmem_free(tmp_buf, SEND_RNID_RSP_SIZE);
3675 3637                          cmd->Status = EXT_STATUS_ERR;
3676 3638                          cmd->ResponseLen = 0;
3677 3639                          return;
3678 3640                  }
↓ open down ↓ 345 lines elided ↑ open up ↑
4024 3986  
4025 3987          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
4026 3988  
4027 3989          if (DRIVER_SUSPENDED(ha)) {
4028 3990                  EL(ha, "failed, LOOP_NOT_READY\n");
4029 3991                  return (0);
4030 3992          }
4031 3993  
4032 3994          pkt_size = sizeof (ql_mbx_iocb_t) + sizeof (ql_rpt_lun_lst_t);
4033 3995          pkt = kmem_zalloc(pkt_size, KM_SLEEP);
4034      -        if (pkt == NULL) {
4035      -                EL(ha, "failed, kmem_zalloc\n");
4036      -                return (0);
4037      -        }
4038 3996          rpt = (ql_rpt_lun_lst_t *)((caddr_t)pkt + sizeof (ql_mbx_iocb_t));
4039 3997  
4040 3998          /* Get DMA memory for the IOCB */
4041 3999          if (ql_get_dma_mem(ha, &dma_mem, sizeof (ql_rpt_lun_lst_t),
4042 4000              LITTLE_ENDIAN_DMA, QL_DMA_RING_ALIGN) != QL_SUCCESS) {
4043 4001                  cmn_err(CE_WARN, "%s(%d): DMA memory "
4044 4002                      "alloc failed", QL_NAME, ha->instance);
4045 4003                  kmem_free(pkt, pkt_size);
4046 4004                  return (0);
4047 4005          }
↓ open down ↓ 220 lines elided ↑ open up ↑
4268 4226  {
4269 4227          int             lun, cnt, rval;
4270 4228          ql_mbx_iocb_t   *pkt;
4271 4229          uint8_t         *inq;
4272 4230          uint32_t        pkt_size;
4273 4231  
4274 4232          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
4275 4233  
4276 4234          pkt_size = sizeof (ql_mbx_iocb_t) + INQ_DATA_SIZE;
4277 4235          pkt = kmem_zalloc(pkt_size, KM_SLEEP);
4278      -        if (pkt == NULL) {
4279      -                EL(ha, "failed, kmem_zalloc\n");
4280      -                return (0);
4281      -        }
4282 4236          inq = (uint8_t *)((caddr_t)pkt + sizeof (ql_mbx_iocb_t));
4283 4237  
4284 4238          cnt = 0;
4285 4239          for (lun = 0; lun < MAX_LUNS; lun++) {
4286 4240  
4287 4241                  if (DRIVER_SUSPENDED(ha)) {
4288 4242                          rval = QL_LOOP_DOWN;
4289 4243                          cnt = 0;
4290 4244                          break;
4291 4245                  }
↓ open down ↓ 399 lines elided ↑ open up ↑
4691 4645          flash_desc_t    *fdesc;
4692 4646          ql_xioctl_t     *xp = ha->xioctl;
4693 4647  
4694 4648          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
4695 4649  
4696 4650          if (ha->flash_desc_addr == 0) {
4697 4651                  QL_PRINT_9(CE_CONT, "(%d): desc ptr=0\n", ha->instance);
4698 4652                  return (QL_FUNCTION_FAILED);
4699 4653          }
4700 4654  
4701      -        if ((fdesc = kmem_zalloc(sizeof (flash_desc_t), KM_SLEEP)) == NULL) {
4702      -                EL(ha, "kmem_zalloc=null\n");
4703      -                return (QL_MEMORY_ALLOC_FAILED);
4704      -        }
     4655 +        fdesc = kmem_zalloc(sizeof (flash_desc_t), KM_SLEEP);
4705 4656          rval = ql_dump_fcode(ha, (uint8_t *)fdesc, sizeof (flash_desc_t),
4706 4657              ha->flash_desc_addr << 2);
4707 4658          if (rval != QL_SUCCESS) {
4708 4659                  EL(ha, "read status=%xh\n", rval);
4709 4660                  kmem_free(fdesc, sizeof (flash_desc_t));
4710 4661                  return (rval);
4711 4662          }
4712 4663  
4713 4664          chksum = 0;
4714 4665          bp = (uint16_t *)fdesc;
↓ open down ↓ 713 lines elided ↑ open up ↑
5428 5379              cmd->RequestLen, mode);
5429 5380          if (rval != 0) {
5430 5381                  EL(ha, "failed, ddi_copyin\n");
5431 5382                  cmd->Status = EXT_STATUS_COPY_ERR;
5432 5383                  cmd->ResponseLen = 0;
5433 5384                  return;
5434 5385          }
5435 5386  
5436 5387          /* Allocate memory for command. */
5437 5388          tmp_buf = kmem_zalloc(sizeof (EXT_RNID_DATA), KM_SLEEP);
5438      -        if (tmp_buf == NULL) {
5439      -                EL(ha, "failed, kmem_zalloc\n");
5440      -                cmd->Status = EXT_STATUS_NO_MEMORY;
5441      -                cmd->ResponseLen = 0;
5442      -                return;
5443      -        }
5444 5389  
5445 5390          rval = ql_get_rnid_params(ha, sizeof (EXT_RNID_DATA),
5446 5391              (caddr_t)tmp_buf);
5447 5392          if (rval != QL_SUCCESS) {
5448 5393                  /* error */
5449 5394                  EL(ha, "failed, get_rnid_params_mbx=%xh\n", rval);
5450 5395                  kmem_free(tmp_buf, sizeof (EXT_RNID_DATA));
5451 5396                  cmd->Status = EXT_STATUS_ERR;
5452 5397                  cmd->ResponseLen = 0;
5453 5398                  return;
↓ open down ↓ 37 lines elided ↑ open up ↑
5491 5436  
5492 5437          if (DRIVER_SUSPENDED(ha)) {
5493 5438                  EL(ha, "failed, LOOP_NOT_READY\n");
5494 5439                  cmd->Status = EXT_STATUS_BUSY;
5495 5440                  cmd->ResponseLen = 0;
5496 5441                  return;
5497 5442          }
5498 5443  
5499 5444          /* Allocate memory for command. */
5500 5445          tmp_buf = kmem_zalloc(sizeof (EXT_RNID_DATA), KM_SLEEP);
5501      -        if (tmp_buf == NULL) {
5502      -                EL(ha, "failed, kmem_zalloc\n");
5503      -                cmd->Status = EXT_STATUS_NO_MEMORY;
5504      -                cmd->ResponseLen = 0;
5505      -                return;
5506      -        }
5507 5446  
5508 5447          /* Send command */
5509 5448          rval = ql_get_rnid_params(ha, sizeof (EXT_RNID_DATA),
5510 5449              (caddr_t)tmp_buf);
5511 5450          if (rval != QL_SUCCESS) {
5512 5451                  /* error */
5513 5452                  EL(ha, "failed, get_rnid_params_mbx=%xh\n", rval);
5514 5453                  kmem_free(tmp_buf, sizeof (EXT_RNID_DATA));
5515 5454                  cmd->Status = EXT_STATUS_ERR;
5516 5455                  cmd->ResponseLen = 0;
↓ open down ↓ 111 lines elided ↑ open up ↑
5628 5567                  if (retry == 0) { /* effectively 100 seconds */
5629 5568                          EL(ha, "failed, LOOP_NOT_READY\n");
5630 5569                          cmd->Status = EXT_STATUS_BUSY;
5631 5570                          cmd->ResponseLen = 0;
5632 5571                          return;
5633 5572                  }
5634 5573          }
5635 5574  
5636 5575          /* Allocate memory for command. */
5637 5576          ls = kmem_zalloc(sizeof (ql_link_stats_t), KM_SLEEP);
5638      -        if (ls == NULL) {
5639      -                EL(ha, "failed, kmem_zalloc\n");
5640      -                cmd->Status = EXT_STATUS_NO_MEMORY;
5641      -                cmd->ResponseLen = 0;
5642      -                return;
5643      -        }
5644 5577  
5645 5578          /*
5646 5579           * I think these are supposed to be port statistics
5647 5580           * the loop ID or port ID should be in cmd->Instance.
5648 5581           */
5649 5582          rval = ql_get_status_counts(ha, (uint16_t)
5650 5583              (ha->task_daemon_flags & LOOP_DOWN ? 0xFF : ha->loop_id),
5651 5584              sizeof (ql_link_stats_t), (caddr_t)ls, 0);
5652 5585          if (rval != QL_SUCCESS) {
5653 5586                  EL(ha, "failed, get_link_status=%xh, id=%xh\n", rval,
↓ open down ↓ 96 lines elided ↑ open up ↑
5750 5683                  if (retry == 0) { /* effectively 100 seconds */
5751 5684                          EL(ha, "failed, LOOP_NOT_READY\n");
5752 5685                          cmd->Status = EXT_STATUS_BUSY;
5753 5686                          cmd->ResponseLen = 0;
5754 5687                          return;
5755 5688                  }
5756 5689          }
5757 5690  
5758 5691          /* Allocate memory for command. */
5759 5692          ls = kmem_zalloc(sizeof (ql_link_stats_t), KM_SLEEP);
5760      -        if (ls == NULL) {
5761      -                EL(ha, "failed, kmem_zalloc\n");
5762      -                cmd->Status = EXT_STATUS_NO_MEMORY;
5763      -                cmd->ResponseLen = 0;
5764      -                return;
5765      -        }
5766 5693  
5767 5694          rval = ql_get_link_status(ha, tq->loop_id, sizeof (ql_link_stats_t),
5768 5695              (caddr_t)ls, 0);
5769 5696          if (rval != QL_SUCCESS) {
5770 5697                  EL(ha, "failed, get_link_status=%xh, d_id=%xh\n", rval,
5771 5698                      tq->d_id.b24);
5772 5699                  cmd->Status = EXT_STATUS_MAILBOX;
5773 5700                  cmd->DetailStatus = rval;
5774 5701                  cmd->ResponseLen = 0;
5775 5702          } else {
↓ open down ↓ 1189 lines elided ↑ open up ↑
6965 6892          ql_flt_ptr_t    *fptr;
6966 6893          uint8_t         *bp;
6967 6894          int             rval;
6968 6895          uint32_t        len, faddr, cnt;
6969 6896          uint16_t        chksum, w16;
6970 6897  
6971 6898          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
6972 6899  
6973 6900          /* Process flash layout table header */
6974 6901          len = sizeof (ql_flt_ptr_t);
6975      -        if ((bp = kmem_zalloc(len, KM_SLEEP)) == NULL) {
6976      -                EL(ha, "kmem_zalloc=null\n");
6977      -                return;
6978      -        }
     6902 +        bp = kmem_zalloc(len, KM_SLEEP);
6979 6903  
6980 6904          /* Process pointer to flash layout table */
6981 6905          if ((rval = ql_dump_fcode(ha, bp, len, flt_paddr)) != QL_SUCCESS) {
6982 6906                  EL(ha, "fptr dump_flash pos=%xh, status=%xh\n", flt_paddr,
6983 6907                      rval);
6984 6908                  kmem_free(bp, len);
6985 6909                  return;
6986 6910          }
6987 6911          fptr = (ql_flt_ptr_t *)bp;
6988 6912  
↓ open down ↓ 36 lines elided ↑ open up ↑
7025 6949          ql_flt_hdr_t    *fhdr;
7026 6950          ql_flt_region_t *frgn;
7027 6951          uint8_t         *bp, *eaddr, nv_rg, vpd_rg;
7028 6952          int             rval;
7029 6953          uint32_t        len, cnt, fe_addr;
7030 6954          uint16_t        chksum, w16;
7031 6955  
7032 6956          QL_PRINT_9(CE_CONT, "(%d): started faddr=%xh\n", ha->instance, faddr);
7033 6957  
7034 6958          /* Process flash layout table header */
7035      -        if ((bp = kmem_zalloc(FLASH_LAYOUT_TABLE_SIZE, KM_SLEEP)) == NULL) {
7036      -                EL(ha, "kmem_zalloc=null\n");
7037      -                return;
7038      -        }
     6959 +        bp = kmem_zalloc(FLASH_LAYOUT_TABLE_SIZE, KM_SLEEP);
7039 6960          fhdr = (ql_flt_hdr_t *)bp;
7040 6961  
7041 6962          /* Process flash layout table. */
7042 6963          if ((rval = ql_dump_fcode(ha, bp, FLASH_LAYOUT_TABLE_SIZE, faddr)) !=
7043 6964              QL_SUCCESS) {
7044 6965                  EL(ha, "fhdr dump_flash pos=%xh, status=%xh\n", faddr, rval);
7045 6966                  kmem_free(bp, FLASH_LAYOUT_TABLE_SIZE);
7046 6967                  return;
7047 6968          }
7048 6969  
↓ open down ↓ 655 lines elided ↑ open up ↑
7704 7625          rval = ql_fw_etrace(ha, &ha->fwexttracebuf, FTO_EXT_TRACE_DISABLE);
7705 7626          if (rval != QL_SUCCESS) {
7706 7627                  EL(ha, "f/w extended trace disable failed: %xh\n", rval);
7707 7628                  cmd->Status = EXT_STATUS_ERR;
7708 7629                  cmd->ResponseLen = 0;
7709 7630                  return;
7710 7631          }
7711 7632  
7712 7633          /* Allocate payload buffer */
7713 7634          payload = kmem_zalloc(FWEXTSIZE, KM_SLEEP);
7714      -        if (payload == NULL) {
7715      -                EL(ha, "failed, kmem_zalloc\n");
7716      -                cmd->Status = EXT_STATUS_NO_MEMORY;
7717      -                cmd->ResponseLen = 0;
7718      -                return;
7719      -        }
7720 7635  
7721 7636          /* Sync DMA buffer. */
7722 7637          (void) ddi_dma_sync(ha->fwexttracebuf.dma_handle, 0,
7723 7638              FWEXTSIZE, DDI_DMA_SYNC_FORKERNEL);
7724 7639  
7725 7640          /* Copy trace buffer data. */
7726 7641          ddi_rep_get8(ha->fwexttracebuf.acc_handle, (uint8_t *)payload,
7727 7642              (uint8_t *)ha->fwexttracebuf.bp, FWEXTSIZE,
7728 7643              DDI_DEV_AUTOINCR);
7729 7644  
↓ open down ↓ 63 lines elided ↑ open up ↑
7793 7708          rval = ql_fw_etrace(ha, &ha->fwfcetracebuf, FTO_FCE_TRACE_DISABLE);
7794 7709          if (rval != QL_SUCCESS) {
7795 7710                  EL(ha, "f/w FCE trace disable failed: %xh\n", rval);
7796 7711                  cmd->Status = EXT_STATUS_ERR;
7797 7712                  cmd->ResponseLen = 0;
7798 7713                  return;
7799 7714          }
7800 7715  
7801 7716          /* Allocate payload buffer */
7802 7717          payload = kmem_zalloc(FWEXTSIZE, KM_SLEEP);
7803      -        if (payload == NULL) {
7804      -                EL(ha, "failed, kmem_zalloc\n");
7805      -                cmd->Status = EXT_STATUS_NO_MEMORY;
7806      -                cmd->ResponseLen = 0;
7807      -                return;
7808      -        }
7809 7718  
7810 7719          /* Sync DMA buffer. */
7811 7720          (void) ddi_dma_sync(ha->fwfcetracebuf.dma_handle, 0,
7812 7721              FWFCESIZE, DDI_DMA_SYNC_FORKERNEL);
7813 7722  
7814 7723          /* Copy trace buffer data. */
7815 7724          ddi_rep_get8(ha->fwfcetracebuf.acc_handle, (uint8_t *)payload,
7816 7725              (uint8_t *)ha->fwfcetracebuf.bp, FWFCESIZE,
7817 7726              DDI_DEV_AUTOINCR);
7818 7727  
↓ open down ↓ 96 lines elided ↑ open up ↑
7915 7824   */
7916 7825  int
7917 7826  ql_pci_dump(ql_adapter_state_t *ha, uint32_t *bp, uint32_t pci_size, int mode)
7918 7827  {
7919 7828          uint32_t        pci_os;
7920 7829          uint32_t        *ptr32, *org_ptr32;
7921 7830  
7922 7831          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
7923 7832  
7924 7833          ptr32 = kmem_zalloc(pci_size, KM_SLEEP);
7925      -        if (ptr32 == NULL) {
7926      -                EL(ha, "failed kmem_zalloc\n");
7927      -                return (ENOMEM);
7928      -        }
7929 7834  
7930 7835          /* store the initial value of ptr32 */
7931 7836          org_ptr32 = ptr32;
7932 7837          for (pci_os = 0; pci_os < pci_size; pci_os += 4) {
7933 7838                  *ptr32 = (uint32_t)ql_pci_config_get32(ha, pci_os);
7934 7839                  LITTLE_ENDIAN_32(ptr32);
7935 7840                  ptr32++;
7936 7841          }
7937 7842  
7938 7843          if (ddi_copyout((void *)org_ptr32, (void *)bp, pci_size, mode) !=
↓ open down ↓ 127 lines elided ↑ open up ↑
8066 7971                  cmd->Status = EXT_STATUS_BUFFER_TOO_SMALL;
8067 7972                  cmd->DetailStatus = sizeof (EXT_MENLO_GET_FW_VERSION);
8068 7973                  EL(ha, "ResponseLen=%d < %d\n", cmd->ResponseLen,
8069 7974                      sizeof (EXT_MENLO_GET_FW_VERSION));
8070 7975                  cmd->ResponseLen = 0;
8071 7976                  return;
8072 7977          }
8073 7978  
8074 7979          /* Allocate packet. */
8075 7980          pkt = kmem_zalloc(sizeof (ql_mbx_iocb_t), KM_SLEEP);
8076      -        if (pkt == NULL) {
8077      -                EL(ha, "failed, kmem_zalloc\n");
8078      -                cmd->Status = EXT_STATUS_NO_MEMORY;
8079      -                cmd->ResponseLen = 0;
8080      -                return;
8081      -        }
8082 7981  
8083 7982          pkt->mvfy.entry_type = VERIFY_MENLO_TYPE;
8084 7983          pkt->mvfy.entry_count = 1;
8085 7984          pkt->mvfy.options_status = LE_16(VMF_DO_NOT_UPDATE_FW);
8086 7985  
8087 7986          rval = ql_issue_mbx_iocb(ha, (caddr_t)pkt, sizeof (ql_mbx_iocb_t));
8088 7987          LITTLE_ENDIAN_16(&pkt->mvfy.options_status);
8089 7988          LITTLE_ENDIAN_16(&pkt->mvfy.failure_code);
8090 7989          ver.FwVersion = LE_32(pkt->mvfy.fw_version);
8091 7990  
↓ open down ↓ 89 lines elided ↑ open up ↑
8181 8080  
8182 8081          /* Allocate packet. */
8183 8082          dma_mem = (dma_mem_t *)kmem_zalloc(sizeof (dma_mem_t), KM_SLEEP);
8184 8083          if (dma_mem == NULL) {
8185 8084                  EL(ha, "failed, kmem_zalloc\n");
8186 8085                  cmd->Status = EXT_STATUS_NO_MEMORY;
8187 8086                  cmd->ResponseLen = 0;
8188 8087                  return;
8189 8088          }
8190 8089          pkt = kmem_zalloc(sizeof (ql_mbx_iocb_t), KM_SLEEP);
8191      -        if (pkt == NULL) {
8192      -                EL(ha, "failed, kmem_zalloc\n");
8193      -                kmem_free(dma_mem, sizeof (dma_mem_t));
8194      -                ql_restart_hba(ha);
8195      -                cmd->Status = EXT_STATUS_NO_MEMORY;
8196      -                cmd->ResponseLen = 0;
8197      -                return;
8198      -        }
8199 8090  
8200 8091          /* Get DMA memory for the IOCB */
8201 8092          if (ql_get_dma_mem(ha, dma_mem, fw.TotalByteCount, LITTLE_ENDIAN_DMA,
8202 8093              QL_DMA_DATA_ALIGN) != QL_SUCCESS) {
8203 8094                  cmn_err(CE_WARN, "%s(%d): request queue DMA memory "
8204 8095                      "alloc failed", QL_NAME, ha->instance);
8205 8096                  kmem_free(pkt, sizeof (ql_mbx_iocb_t));
8206 8097                  kmem_free(dma_mem, sizeof (dma_mem_t));
8207 8098                  ql_restart_hba(ha);
8208 8099                  cmd->Status = EXT_STATUS_MS_NO_RESPONSE;
↓ open down ↓ 111 lines elided ↑ open up ↑
8320 8211          if (ddi_copyin((caddr_t)(uintptr_t)cmd->RequestAdr,
8321 8212              (caddr_t)&info, sizeof (EXT_MENLO_MANAGE_INFO), mode) != 0) {
8322 8213                  EL(ha, "failed, ddi_copyin\n");
8323 8214                  cmd->Status = EXT_STATUS_COPY_ERR;
8324 8215                  cmd->ResponseLen = 0;
8325 8216                  return;
8326 8217          }
8327 8218  
8328 8219          /* Allocate packet. */
8329 8220          pkt = kmem_zalloc(sizeof (ql_mbx_iocb_t), KM_SLEEP);
8330      -        if (pkt == NULL) {
8331      -                EL(ha, "failed, kmem_zalloc\n");
8332      -                ql_restart_driver(ha);
8333      -                cmd->Status = EXT_STATUS_NO_MEMORY;
8334      -                cmd->ResponseLen = 0;
8335      -                return;
8336      -        }
8337 8221  
8338 8222          pkt->mdata.entry_type = MENLO_DATA_TYPE;
8339 8223          pkt->mdata.entry_count = 1;
8340 8224          pkt->mdata.options_status = (uint16_t)LE_16(info.Operation);
8341 8225  
8342 8226          /* Get DMA memory for the IOCB */
8343 8227          if (info.Operation == MENLO_OP_READ_MEM ||
8344 8228              info.Operation == MENLO_OP_WRITE_MEM) {
8345 8229                  pkt->mdata.total_byte_count = LE_32(info.TotalByteCount);
8346 8230                  pkt->mdata.parameter_1 =
↓ open down ↓ 469 lines elided ↑ open up ↑
8816 8700  
8817 8701          if (!(CFG_IST(ha, CFG_CTRL_8081))) {
8818 8702                  EL(ha, "invalid request for HBA\n");
8819 8703                  cmd->Status = EXT_STATUS_INVALID_REQUEST;
8820 8704                  cmd->ResponseLen = 0;
8821 8705                  return;
8822 8706          }
8823 8707  
8824 8708          /* Allocate memory for command. */
8825 8709          tmp_buf = kmem_zalloc(EXT_DEF_DCBX_PARAM_BUF_SIZE, KM_SLEEP);
8826      -        if (tmp_buf == NULL) {
8827      -                EL(ha, "failed, kmem_zalloc\n");
8828      -                cmd->Status = EXT_STATUS_NO_MEMORY;
8829      -                cmd->ResponseLen = 0;
8830      -                return;
8831      -        }
8832 8710          /* Send command */
8833 8711          rval = ql_get_dcbx_params(ha, EXT_DEF_DCBX_PARAM_BUF_SIZE,
8834 8712              (caddr_t)tmp_buf);
8835 8713          if (rval != QL_SUCCESS) {
8836 8714                  /* error */
8837 8715                  EL(ha, "failed, get_dcbx_params_mbx=%xh\n", rval);
8838 8716                  kmem_free(tmp_buf, EXT_DEF_DCBX_PARAM_BUF_SIZE);
8839 8717                  cmd->Status = EXT_STATUS_ERR;
8840 8718                  cmd->ResponseLen = 0;
8841 8719                  return;
↓ open down ↓ 222 lines elided ↑ open up ↑
9064 8942                  /* parameter error */
9065 8943                  cmd->Status = EXT_STATUS_INVALID_PARAM;
9066 8944                  cmd->DetailStatus = 0;
9067 8945                  EL(ha, "failed, size=%xh\n", size);
9068 8946                  cmd->ResponseLen = 0;
9069 8947                  return;
9070 8948          }
9071 8949  
9072 8950          /* Allocate memory for command. */
9073 8951          tmp_buf = kmem_zalloc(size, KM_SLEEP);
9074      -        if (tmp_buf == NULL) {
9075      -                EL(ha, "failed, kmem_zalloc\n");
9076      -                cmd->Status = EXT_STATUS_NO_MEMORY;
9077      -                cmd->ResponseLen = 0;
9078      -                return;
9079      -        }
9080 8952  
9081 8953          if (!(info.Operation & MENLO_OP_GET_INFO)) {
9082 8954                  EL(ha, "Invalid request for 81XX\n");
9083 8955                  kmem_free(tmp_buf, size);
9084 8956                  cmd->Status = EXT_STATUS_ERR;
9085 8957                  cmd->ResponseLen = 0;
9086 8958                  return;
9087 8959          }
9088 8960  
9089 8961          rval = ql_get_xgmac_stats(ha, size, (caddr_t)tmp_buf);
↓ open down ↓ 57 lines elided ↑ open up ↑
9147 9019          if (!(fcf_list.BufSize)) {
9148 9020                  /* Return error */
9149 9021                  EL(ha, "failed, fcf_list BufSize is=%xh\n",
9150 9022                      fcf_list.BufSize);
9151 9023                  cmd->Status = EXT_STATUS_INVALID_PARAM;
9152 9024                  cmd->ResponseLen = 0;
9153 9025                  return;
9154 9026          }
9155 9027          /* Allocate memory for command. */
9156 9028          tmp_buf = kmem_zalloc(fcf_list.BufSize, KM_SLEEP);
9157      -        if (tmp_buf == NULL) {
9158      -                EL(ha, "failed, kmem_zalloc\n");
9159      -                cmd->Status = EXT_STATUS_NO_MEMORY;
9160      -                cmd->ResponseLen = 0;
9161      -                return;
9162      -        }
9163 9029          /* build the descriptor */
9164 9030          if (fcf_list.Options) {
9165 9031                  mb_fcf_list.options = FCF_LIST_RETURN_ONE;
9166 9032          } else {
9167 9033                  mb_fcf_list.options = FCF_LIST_RETURN_ALL;
9168 9034          }
9169 9035          mb_fcf_list.fcf_index = (uint16_t)fcf_list.FcfIndex;
9170 9036          mb_fcf_list.buffer_size = fcf_list.BufSize;
9171 9037  
9172 9038          /* Send command */
↓ open down ↓ 88 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX