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_ioctl.c
          +++ new/usr/src/uts/common/io/fibre-channel/fca/qlc/ql_ioctl.c
↓ open down ↓ 496 lines elided ↑ open up ↑
 497  497          uint32_t        start_addr;
 498  498  
 499  499          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
 500  500  
 501  501          if (CFG_IST(ha, CFG_CTRL_24258081)) {
 502  502                  EL(ha, "Not supported for 24xx\n");
 503  503                  return (EINVAL);
 504  504          }
 505  505  
 506  506          nv = kmem_zalloc(sizeof (*nv), KM_SLEEP);
 507      -        if (nv == NULL) {
 508      -                EL(ha, "failed, kmem_zalloc\n");
 509      -                return (ENOMEM);
 510      -        }
 511  507  
 512  508          rval = ql_lock_nvram(ha, &start_addr, LNF_NVRAM_DATA);
 513  509          if (rval != QL_SUCCESS) {
 514  510                  EL(ha, "failed, ql_lock_nvram=%xh\n", rval);
 515  511                  kmem_free(nv, sizeof (*nv));
 516  512                  return (EIO);
 517  513          }
 518  514          rval = 0;
 519  515  
 520  516          /*
↓ open down ↓ 83 lines elided ↑ open up ↑
 604  600                  return (EIO);
 605  601          }
 606  602          rval = 0;
 607  603  
 608  604          if (CFG_IST(ha, CFG_CTRL_24258081)) {
 609  605                  nvram_24xx_t    *nv;
 610  606                  uint32_t        *longptr;
 611  607                  uint32_t        csum = 0;
 612  608  
 613  609                  nv = kmem_zalloc(sizeof (*nv), KM_SLEEP);
 614      -                if (nv == NULL) {
 615      -                        EL(ha, "failed, kmem_zalloc\n");
 616      -                        return (ENOMEM);
 617      -                }
 618  610  
 619  611                  nv->nvram_version[0] = LSB(ICB_24XX_VERSION);
 620  612                  nv->nvram_version[1] = MSB(ICB_24XX_VERSION);
 621  613  
 622  614                  nv->version[0] = 1;
 623  615                  nv->max_frame_length[1] = 8;
 624  616                  nv->execution_throttle[0] = 16;
 625  617                  nv->login_retry_count[0] = 8;
 626  618  
 627  619                  nv->firmware_options_1[0] = BIT_2 | BIT_1;
↓ open down ↓ 53 lines elided ↑ open up ↑
 681  673                          rval = EINVAL;
 682  674                  }
 683  675                  kmem_free(nv, sizeof (nvram_24xx_t));
 684  676          } else {
 685  677                  nvram_t         *nv;
 686  678                  uint16_t        *wptr;
 687  679                  uint8_t         *bptr;
 688  680                  uint8_t         csum;
 689  681  
 690  682                  nv = kmem_zalloc(sizeof (*nv), KM_SLEEP);
 691      -                if (nv == NULL) {
 692      -                        EL(ha, "failed, kmem_zalloc\n");
 693      -                        return (ENOMEM);
 694      -                }
 695  683                  /*
 696  684                   * Set default initialization control block.
 697  685                   */
 698  686                  nv->parameter_block_version = ICB_VERSION;
 699  687                  nv->firmware_options[0] = BIT_4 | BIT_3 | BIT_2 | BIT_1;
 700  688                  nv->firmware_options[1] = BIT_7 | BIT_5 | BIT_2;
 701  689  
 702  690                  nv->max_frame_length[1] = 4;
 703  691                  nv->max_iocb_allocation[1] = 1;
 704  692                  nv->execution_throttle[0] = 16;
↓ open down ↓ 228 lines elided ↑ open up ↑
 933  921          uint8_t         cnt;
 934  922          void            *nv;
 935  923          uint16_t        *wptr;
 936  924          uint16_t        data;
 937  925          uint32_t        start_addr, *lptr, data32;
 938  926          nvram_t         *nptr;
 939  927          int             rval;
 940  928  
 941  929          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
 942  930  
 943      -        if ((nv = kmem_zalloc(ha->nvram_cache->size, KM_SLEEP)) == NULL) {
 944      -                EL(ha, "failed, kmem_zalloc\n");
 945      -                return (ENOMEM);
 946      -        }
      931 +        nv = kmem_zalloc(ha->nvram_cache->size, KM_SLEEP);
 947  932  
 948  933          if (ddi_copyin(bp, nv, ha->nvram_cache->size, mode) != 0) {
 949  934                  EL(ha, "Buffer copy failed\n");
 950  935                  kmem_free(nv, ha->nvram_cache->size);
 951  936                  return (EFAULT);
 952  937          }
 953  938  
 954  939          /* See if the buffer passed to us looks sane */
 955  940          nptr = (nvram_t *)nv;
 956  941          if (nptr->id[0] != 'I' || nptr->id[1] != 'S' || nptr->id[2] != 'P' ||
↓ open down ↓ 198 lines elided ↑ open up ↑
1155 1140  
1156 1141          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
1157 1142  
1158 1143          if ((CFG_IST(ha, CFG_CTRL_24258081)) == 0) {
1159 1144                  EL(ha, "unsupported adapter feature\n");
1160 1145                  return (ENOTSUP);
1161 1146          }
1162 1147  
1163 1148          vpd_size = QL_24XX_VPD_SIZE;
1164 1149  
1165      -        if ((vpd = kmem_zalloc(vpd_size, KM_SLEEP)) == NULL) {
1166      -                EL(ha, "failed, kmem_zalloc\n");
1167      -                return (ENOMEM);
1168      -        }
     1150 +        vpd = kmem_zalloc(vpd_size, KM_SLEEP);
1169 1151  
1170 1152          if (ddi_copyin(bp, vpd, vpd_size, mode) != 0) {
1171 1153                  EL(ha, "Buffer copy failed\n");
1172 1154                  kmem_free(vpd, vpd_size);
1173 1155                  return (EFAULT);
1174 1156          }
1175 1157  
1176 1158          /* Sanity check the user supplied data via checksum */
1177 1159          if ((vpdptr = ql_vpd_findtag(ha, vpd, "RV")) == NULL) {
1178 1160                  EL(ha, "vpd RV tag missing\n");
↓ open down ↓ 118 lines elided ↑ open up ↑
1297 1279          if (ha->vcache != NULL) {
1298 1280                  /* copy back the vpd cache data */
1299 1281                  if (ddi_copyout(ha->vcache, bp, vpd_size, mode) != 0) {
1300 1282                          EL(ha, "Buffer copy failed\n");
1301 1283                          rval = EFAULT;
1302 1284                  }
1303 1285                  CACHE_UNLOCK(ha);
1304 1286                  return (rval);
1305 1287          }
1306 1288  
1307      -        if ((vpd = kmem_zalloc(vpd_size, KM_SLEEP)) == NULL) {
1308      -                CACHE_UNLOCK(ha);
1309      -                EL(ha, "failed, kmem_zalloc\n");
1310      -                return (ENOMEM);
1311      -        }
     1289 +        vpd = kmem_zalloc(vpd_size, KM_SLEEP);
1312 1290  
1313 1291          /* Quiesce I/O */
1314 1292          if (ql_stall_driver(ha, 0) != QL_SUCCESS) {
1315 1293                  CACHE_UNLOCK(ha);
1316 1294                  EL(ha, "ql_stall_driver failed\n");
1317 1295                  kmem_free(vpd, vpd_size);
1318 1296                  return (EBUSY);
1319 1297          }
1320 1298  
1321 1299          rval = ql_lock_nvram(ha, &start_addr, LNF_VPD_DATA);
↓ open down ↓ 247 lines elided ↑ open up ↑
1569 1547          uint32_t        xfer, bsize, saddr, ofst;
1570 1548          int             rval = 0;
1571 1549  
1572 1550          QL_PRINT_9(CE_CONT, "(%d): started, dp=%ph, faddr=%xh, bc=%xh\n",
1573 1551              ha->instance, (void *)dp, faddr, bc);
1574 1552  
1575 1553          bsize = ha->xioctl->fdesc.block_size;
1576 1554          saddr = faddr & ~(bsize - 1);
1577 1555          ofst = faddr & (bsize - 1);
1578 1556  
1579      -        if ((bp = kmem_zalloc(bsize, KM_SLEEP)) == NULL) {
1580      -                EL(ha, "kmem_zalloc=null\n");
1581      -                return (QL_MEMORY_ALLOC_FAILED);
1582      -        }
     1557 +        bp = kmem_zalloc(bsize, KM_SLEEP);
1583 1558  
1584 1559          while (bc) {
1585 1560                  xfer = bc > bsize ? bsize : bc;
1586 1561                  if (ofst + xfer > bsize) {
1587 1562                          xfer = bsize - ofst;
1588 1563                  }
1589 1564                  QL_PRINT_9(CE_CONT, "(%d): dp=%ph, saddr=%xh, bc=%xh, "
1590 1565                      "ofst=%xh, xfer=%xh\n", ha->instance, (void *)dp, saddr,
1591 1566                      bc, ofst, xfer);
1592 1567  
↓ open down ↓ 435 lines elided ↑ open up ↑
2028 2003   */
2029 2004  static int
2030 2005  ql_adm_prop_update_int(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
2031 2006  {
2032 2007          char    *prop_name;
2033 2008          int     rval;
2034 2009  
2035 2010          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2036 2011  
2037 2012          prop_name = kmem_zalloc(dop->length, KM_SLEEP);
2038      -        if (prop_name == NULL) {
2039      -                EL(ha, "failed, kmem_zalloc\n");
2040      -                return (ENOMEM);
2041      -        }
2042 2013  
2043 2014          if (ddi_copyin((void *)(uintptr_t)dop->buffer, prop_name, dop->length,
2044 2015              mode) != 0) {
2045 2016                  EL(ha, "failed, prop_name ddi_copyin\n");
2046 2017                  kmem_free(prop_name, dop->length);
2047 2018                  return (EFAULT);
2048 2019          }
2049 2020  
2050 2021          /*LINTED [Solaris DDI_DEV_T_ANY Lint warning]*/
2051 2022          if ((rval = ddi_prop_update_int(DDI_DEV_T_NONE, ha->dip, prop_name,
↓ open down ↓ 33 lines elided ↑ open up ↑
2085 2056          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2086 2057  
2087 2058          if (dop->length < ha->risc_dump_size) {
2088 2059                  EL(ha, "failed, incorrect length=%xh, size=%xh\n",
2089 2060                      dop->length, ha->risc_dump_size);
2090 2061                  return (EINVAL);
2091 2062          }
2092 2063  
2093 2064          if (ha->ql_dump_state & QL_DUMP_VALID) {
2094 2065                  dmp = kmem_zalloc(ha->risc_dump_size, KM_SLEEP);
2095      -                if (dmp == NULL) {
2096      -                        EL(ha, "failed, kmem_zalloc\n");
2097      -                        return (ENOMEM);
2098      -                }
2099 2066  
2100 2067                  dop->length = (uint32_t)ql_ascii_fw_dump(ha, dmp);
2101 2068                  if (ddi_copyout((void *)dmp, (void *)(uintptr_t)dop->buffer,
2102 2069                      dop->length, mode) != 0) {
2103 2070                          EL(ha, "failed, ddi_copyout\n");
2104 2071                          kmem_free(dmp, ha->risc_dump_size);
2105 2072                          return (EFAULT);
2106 2073                  }
2107 2074  
2108 2075                  kmem_free(dmp, ha->risc_dump_size);
↓ open down ↓ 105 lines elided ↑ open up ↑
2214 2181   *      Kernel context.
2215 2182   */
2216 2183  static int
2217 2184  ql_adm_flash_load(ql_adapter_state_t *ha, ql_adm_op_t *dop, int mode)
2218 2185  {
2219 2186          uint8_t *dp;
2220 2187          int     rval;
2221 2188  
2222 2189          QL_PRINT_9(CE_CONT, "(%d): started\n", ha->instance);
2223 2190  
2224      -        if ((dp = kmem_zalloc(dop->length, KM_SLEEP)) == NULL) {
2225      -                EL(ha, "failed, kmem_zalloc\n");
2226      -                return (ENOMEM);
2227      -        }
     2191 +        dp = kmem_zalloc(dop->length, KM_SLEEP);
2228 2192  
2229 2193          if (ddi_copyin((void *)(uintptr_t)dop->buffer, dp, dop->length,
2230 2194              mode) != 0) {
2231 2195                  EL(ha, "ddi_copyin failed\n");
2232 2196                  kmem_free(dp, dop->length);
2233 2197                  return (EFAULT);
2234 2198          }
2235 2199  
2236 2200          if (ql_stall_driver(ha, 0) != QL_SUCCESS) {
2237 2201                  EL(ha, "ql_stall_driver failed\n");
↓ open down ↓ 231 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX