tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

staging: rtl8723bs: replace rtw_zmalloc() with kzalloc()

Replace the wrapper function rtw_zmalloc() with standard kzalloc().
Use kzalloc() for rtw_malloc() calls that were followed by manual
zero initialization.

About GFP Flags:
- GFP_ATOMIC is used for allocations in atomic contexts such as
spinlock-protected sections, tasklets, and timer handlers.
- GFP_KERNEL is used for process contexts where sleeping is allowed.

Additionally, use array_size() and size_add() to prevent potential
integer overflows during allocation size calculation.

Signed-off-by: Minu Jin <s9430939@naver.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@intel.com>
Link: https://patch.msgid.link/20260204131347.3515949-4-s9430939@naver.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

authored by

Minu Jin and committed by
Greg Kroah-Hartman 980cd426 9577f3b3

+90 -103
+4 -4
drivers/staging/rtl8723bs/core/rtw_ap.c
··· 1229 1229 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1230 1230 u8 res = _SUCCESS; 1231 1231 1232 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1232 + ph2c = kzalloc(sizeof(*ph2c), GFP_KERNEL); 1233 1233 if (!ph2c) { 1234 1234 res = _FAIL; 1235 1235 goto exit; 1236 1236 } 1237 1237 1238 - psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm)); 1238 + psetstakey_para = kzalloc(sizeof(*psetstakey_para), GFP_KERNEL); 1239 1239 if (!psetstakey_para) { 1240 1240 kfree(ph2c); 1241 1241 res = _FAIL; ··· 1269 1269 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1270 1270 int res = _SUCCESS; 1271 1271 1272 - pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 1272 + pcmd = kzalloc(sizeof(*pcmd), GFP_KERNEL); 1273 1273 if (!pcmd) { 1274 1274 res = _FAIL; 1275 1275 goto exit; 1276 1276 } 1277 - psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm)); 1277 + psetkeyparm = kzalloc(sizeof(*psetkeyparm), GFP_KERNEL); 1278 1278 if (!psetkeyparm) { 1279 1279 kfree(pcmd); 1280 1280 res = _FAIL;
+39 -42
drivers/staging/rtl8723bs/core/rtw_cmd.c
··· 171 171 172 172 pcmdpriv->cmd_seq = 1; 173 173 174 - pcmdpriv->cmd_allocated_buf = rtw_zmalloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ); 175 - 174 + pcmdpriv->cmd_allocated_buf = kzalloc(MAX_CMDSZ + CMDBUFF_ALIGN_SZ, GFP_ATOMIC); 176 175 if (!pcmdpriv->cmd_allocated_buf) 177 176 return -ENOMEM; 178 177 179 178 pcmdpriv->cmd_buf = PTR_ALIGN(pcmdpriv->cmd_allocated_buf, CMDBUFF_ALIGN_SZ); 180 179 181 - pcmdpriv->rsp_allocated_buf = rtw_zmalloc(MAX_RSPSZ + 4); 182 - 180 + pcmdpriv->rsp_allocated_buf = kzalloc(MAX_RSPSZ + 4, GFP_ATOMIC); 183 181 if (!pcmdpriv->rsp_allocated_buf) { 184 182 kfree(pcmdpriv->cmd_allocated_buf); 185 183 return -ENOMEM; ··· 533 535 if (check_fwstate(pmlmepriv, _FW_LINKED)) 534 536 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SCAN, 1); 535 537 536 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 538 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 537 539 if (!ph2c) 538 540 return _FAIL; 539 541 540 - psurveyPara = rtw_zmalloc(sizeof(struct sitesurvey_parm)); 542 + psurveyPara = kzalloc(sizeof(*psurveyPara), GFP_ATOMIC); 541 543 if (!psurveyPara) { 542 544 kfree(ph2c); 543 545 return _FAIL; ··· 601 603 struct wlan_bssid_ex *pdev_network = &padapter->registrypriv.dev_network; 602 604 u8 res = _SUCCESS; 603 605 604 - pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 606 + pcmd = kzalloc(sizeof(*pcmd), GFP_ATOMIC); 605 607 if (!pcmd) { 606 608 res = _FAIL; 607 609 goto exit; ··· 634 636 start_bss_network(padapter); 635 637 } else { 636 638 /* need enqueue, prepare cmd_obj and enqueue */ 637 - pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 639 + pcmd = kzalloc(sizeof(*pcmd), GFP_KERNEL); 638 640 if (!pcmd) { 639 641 res = _FAIL; 640 642 goto exit; ··· 686 688 u32 tmp_len; 687 689 u8 *ptmp = NULL; 688 690 689 - pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 691 + pcmd = kzalloc(sizeof(*pcmd), GFP_KERNEL); 690 692 if (!pcmd) { 691 693 res = _FAIL; 692 694 goto exit; ··· 795 797 u8 res = _SUCCESS; 796 798 797 799 /* prepare cmd parameter */ 798 - param = rtw_zmalloc(sizeof(*param)); 800 + param = kzalloc(sizeof(*param), GFP_KERNEL); 799 801 if (!param) { 800 802 res = _FAIL; 801 803 goto exit; ··· 804 806 805 807 if (enqueue) { 806 808 /* need enqueue, prepare cmd_obj and enqueue */ 807 - cmdobj = rtw_zmalloc(sizeof(*cmdobj)); 809 + cmdobj = kzalloc(sizeof(*cmdobj), GFP_KERNEL); 808 810 if (!cmdobj) { 809 811 res = _FAIL; 810 812 kfree(param); ··· 831 833 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 832 834 u8 res = _SUCCESS; 833 835 834 - psetop = rtw_zmalloc(sizeof(struct setopmode_parm)); 835 - 836 + psetop = kzalloc(sizeof(*psetop), GFP_KERNEL); 836 837 if (!psetop) { 837 838 res = _FAIL; 838 839 goto exit; ··· 839 842 psetop->mode = (u8)networktype; 840 843 841 844 if (enqueue) { 842 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 845 + ph2c = kzalloc(sizeof(*ph2c), GFP_KERNEL); 843 846 if (!ph2c) { 844 847 kfree(psetop); 845 848 res = _FAIL; ··· 866 869 struct security_priv *psecuritypriv = &padapter->securitypriv; 867 870 u8 res = _SUCCESS; 868 871 869 - psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm)); 872 + psetstakey_para = kzalloc(sizeof(*psetstakey_para), GFP_KERNEL); 870 873 if (!psetstakey_para) { 871 874 res = _FAIL; 872 875 goto exit; ··· 888 891 padapter->securitypriv.busetkipkey = true; 889 892 890 893 if (enqueue) { 891 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 894 + ph2c = kzalloc(sizeof(*ph2c), GFP_KERNEL); 892 895 if (!ph2c) { 893 896 kfree(psetstakey_para); 894 897 res = _FAIL; 895 898 goto exit; 896 899 } 897 900 898 - psetstakey_rsp = rtw_zmalloc(sizeof(struct set_stakey_rsp)); 901 + psetstakey_rsp = kzalloc(sizeof(*psetstakey_rsp), GFP_KERNEL); 899 902 if (!psetstakey_rsp) { 900 903 kfree(ph2c); 901 904 kfree(psetstakey_para); ··· 933 936 rtw_camid_free(padapter, cam_id); 934 937 } 935 938 } else { 936 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 939 + ph2c = kzalloc(sizeof(*ph2c), GFP_KERNEL); 937 940 if (!ph2c) { 938 941 res = _FAIL; 939 942 goto exit; 940 943 } 941 944 942 - psetstakey_para = rtw_zmalloc(sizeof(struct set_stakey_parm)); 945 + psetstakey_para = kzalloc(sizeof(*psetstakey_para), GFP_KERNEL); 943 946 if (!psetstakey_para) { 944 947 kfree(ph2c); 945 948 res = _FAIL; 946 949 goto exit; 947 950 } 948 951 949 - psetstakey_rsp = rtw_zmalloc(sizeof(struct set_stakey_rsp)); 952 + psetstakey_rsp = kzalloc(sizeof(*psetstakey_rsp), GFP_KERNEL); 950 953 if (!psetstakey_rsp) { 951 954 kfree(ph2c); 952 955 kfree(psetstakey_para); ··· 976 979 977 980 u8 res = _SUCCESS; 978 981 979 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 982 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 980 983 if (!ph2c) { 981 984 res = _FAIL; 982 985 goto exit; 983 986 } 984 987 985 - paddbareq_parm = rtw_zmalloc(sizeof(struct addBaReq_parm)); 988 + paddbareq_parm = kzalloc(sizeof(*paddbareq_parm), GFP_ATOMIC); 986 989 if (!paddbareq_parm) { 987 990 kfree(ph2c); 988 991 res = _FAIL; ··· 1009 1012 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1010 1013 u8 res = _SUCCESS; 1011 1014 1012 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1015 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 1013 1016 if (!ph2c) { 1014 1017 res = _FAIL; 1015 1018 goto exit; 1016 1019 } 1017 1020 1018 - pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1021 + pdrvextra_cmd_parm = kzalloc(sizeof(*pdrvextra_cmd_parm), GFP_ATOMIC); 1019 1022 if (!pdrvextra_cmd_parm) { 1020 1023 kfree(ph2c); 1021 1024 res = _FAIL; ··· 1042 1045 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1043 1046 u8 res = _SUCCESS; 1044 1047 1045 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1048 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 1046 1049 if (!ph2c) { 1047 1050 res = _FAIL; 1048 1051 goto exit; 1049 1052 } 1050 1053 1051 - pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1054 + pdrvextra_cmd_parm = kzalloc(sizeof(*pdrvextra_cmd_parm), GFP_ATOMIC); 1052 1055 if (!pdrvextra_cmd_parm) { 1053 1056 kfree(ph2c); 1054 1057 res = _FAIL; ··· 1076 1079 u8 res = _SUCCESS; 1077 1080 1078 1081 /* only primary padapter does this cmd */ 1079 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1082 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 1080 1083 if (!ph2c) { 1081 1084 res = _FAIL; 1082 1085 goto exit; 1083 1086 } 1084 1087 1085 - pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1088 + pdrvextra_cmd_parm = kzalloc(sizeof(*pdrvextra_cmd_parm), GFP_ATOMIC); 1086 1089 if (!pdrvextra_cmd_parm) { 1087 1090 kfree(ph2c); 1088 1091 res = _FAIL; ··· 1316 1319 u8 res = _SUCCESS; 1317 1320 1318 1321 if (enqueue) { 1319 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1322 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 1320 1323 if (!ph2c) { 1321 1324 res = _FAIL; 1322 1325 goto exit; 1323 1326 } 1324 1327 1325 - pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1328 + pdrvextra_cmd_parm = kzalloc(sizeof(*pdrvextra_cmd_parm), GFP_ATOMIC); 1326 1329 if (!pdrvextra_cmd_parm) { 1327 1330 kfree(ph2c); 1328 1331 res = _FAIL; ··· 1357 1360 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1358 1361 u8 res = _SUCCESS; 1359 1362 1360 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1363 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 1361 1364 if (!ph2c) { 1362 1365 res = _FAIL; 1363 1366 goto exit; 1364 1367 } 1365 1368 1366 - pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1369 + pdrvextra_cmd_parm = kzalloc(sizeof(*pdrvextra_cmd_parm), GFP_ATOMIC); 1367 1370 if (!pdrvextra_cmd_parm) { 1368 1371 kfree(ph2c); 1369 1372 res = _FAIL; ··· 1419 1422 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1420 1423 u8 res = _SUCCESS; 1421 1424 1422 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1425 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 1423 1426 if (!ph2c) { 1424 1427 res = _FAIL; 1425 1428 goto exit; 1426 1429 } 1427 1430 1428 - pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1431 + pdrvextra_cmd_parm = kzalloc(sizeof(*pdrvextra_cmd_parm), GFP_ATOMIC); 1429 1432 if (!pdrvextra_cmd_parm) { 1430 1433 kfree(ph2c); 1431 1434 res = _FAIL; ··· 1453 1456 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1454 1457 u8 res = _SUCCESS; 1455 1458 1456 - ppscmd = rtw_zmalloc(sizeof(struct cmd_obj)); 1459 + ppscmd = kzalloc(sizeof(*ppscmd), GFP_ATOMIC); 1457 1460 if (!ppscmd) { 1458 1461 res = _FAIL; 1459 1462 goto exit; 1460 1463 } 1461 1464 1462 - pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1465 + pdrvextra_cmd_parm = kzalloc(sizeof(*pdrvextra_cmd_parm), GFP_ATOMIC); 1463 1466 if (!pdrvextra_cmd_parm) { 1464 1467 kfree(ppscmd); 1465 1468 res = _FAIL; ··· 1523 1526 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1524 1527 u8 res = _SUCCESS; 1525 1528 1526 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1529 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 1527 1530 if (!ph2c) { 1528 1531 res = _FAIL; 1529 1532 goto exit; 1530 1533 } 1531 1534 1532 - pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1535 + pdrvextra_cmd_parm = kzalloc(sizeof(*pdrvextra_cmd_parm), GFP_ATOMIC); 1533 1536 if (!pdrvextra_cmd_parm) { 1534 1537 kfree(ph2c); 1535 1538 res = _FAIL; ··· 1615 1618 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1616 1619 u8 res = _SUCCESS; 1617 1620 1618 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1621 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 1619 1622 if (!ph2c) { 1620 1623 res = _FAIL; 1621 1624 goto exit; 1622 1625 } 1623 1626 1624 - pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1627 + pdrvextra_cmd_parm = kzalloc(sizeof(*pdrvextra_cmd_parm), GFP_ATOMIC); 1625 1628 if (!pdrvextra_cmd_parm) { 1626 1629 kfree(ph2c); 1627 1630 res = _FAIL; ··· 1650 1653 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 1651 1654 u8 res = _SUCCESS; 1652 1655 1653 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 1656 + ph2c = kzalloc(sizeof(*ph2c), GFP_KERNEL); 1654 1657 if (!ph2c) { 1655 1658 res = _FAIL; 1656 1659 goto exit; 1657 1660 } 1658 1661 1659 - pdrvextra_cmd_parm = rtw_zmalloc(sizeof(struct drvextra_cmd_parm)); 1662 + pdrvextra_cmd_parm = kzalloc(sizeof(*pdrvextra_cmd_parm), GFP_KERNEL); 1660 1663 if (!pdrvextra_cmd_parm) { 1661 1664 kfree(ph2c); 1662 1665 res = _FAIL;
+5 -5
drivers/staging/rtl8723bs/core/rtw_mlme.c
··· 1875 1875 struct cmd_priv *pcmdpriv = &adapter->cmdpriv; 1876 1876 signed int res = _SUCCESS; 1877 1877 1878 - pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 1878 + pcmd = kzalloc(sizeof(*pcmd), GFP_KERNEL); 1879 1879 if (!pcmd) { 1880 1880 res = _FAIL; /* try again */ 1881 1881 goto exit; 1882 1882 } 1883 1883 1884 - psetauthparm = rtw_zmalloc(sizeof(struct setauth_parm)); 1884 + psetauthparm = kzalloc(sizeof(*psetauthparm), GFP_KERNEL); 1885 1885 if (!psetauthparm) { 1886 1886 kfree(pcmd); 1887 1887 res = _FAIL; ··· 1912 1912 struct cmd_priv *pcmdpriv = &adapter->cmdpriv; 1913 1913 signed int res = _SUCCESS; 1914 1914 1915 - psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm)); 1915 + psetkeyparm = kzalloc(sizeof(*psetkeyparm), GFP_KERNEL); 1916 1916 if (!psetkeyparm) { 1917 1917 res = _FAIL; 1918 1918 goto exit; ··· 1954 1954 } 1955 1955 1956 1956 if (enqueue) { 1957 - pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 1957 + pcmd = kzalloc(sizeof(*pcmd), GFP_KERNEL); 1958 1958 if (!pcmd) { 1959 1959 kfree(psetkeyparm); 1960 1960 res = _FAIL; /* try again */ ··· 2061 2061 2062 2062 buff = NULL; 2063 2063 if (authmode == WLAN_EID_VENDOR_SPECIFIC) { 2064 - buff = rtw_zmalloc(IW_CUSTOM_MAX); 2064 + buff = kzalloc(IW_CUSTOM_MAX, GFP_ATOMIC); 2065 2065 if (!buff) 2066 2066 return; 2067 2067
+18 -18
drivers/staging/rtl8723bs/core/rtw_mlme_ext.c
··· 2327 2327 u8 *buf; 2328 2328 u8 *ies = pmgntframe->buf_addr+TXDESC_OFFSET+sizeof(struct ieee80211_hdr_3addr); 2329 2329 2330 - buf = rtw_zmalloc(MAX_IE_SZ); 2330 + buf = kzalloc(MAX_IE_SZ, GFP_ATOMIC); 2331 2331 if (!buf) 2332 2332 return; 2333 2333 ··· 4376 4376 pmlmeext = &padapter->mlmeextpriv; 4377 4377 pcmdpriv = &padapter->cmdpriv; 4378 4378 4379 - pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj)); 4379 + pcmd_obj = kzalloc(sizeof(*pcmd_obj), GFP_ATOMIC); 4380 4380 if (!pcmd_obj) 4381 4381 return; 4382 4382 4383 4383 cmdsz = (sizeof(struct survey_event) + sizeof(struct C2HEvent_Header)); 4384 - pevtcmd = rtw_zmalloc(cmdsz); 4384 + pevtcmd = kzalloc(cmdsz, GFP_ATOMIC); 4385 4385 if (!pevtcmd) { 4386 4386 kfree(pcmd_obj); 4387 4387 return; ··· 4429 4429 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 4430 4430 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 4431 4431 4432 - pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj)); 4432 + pcmd_obj = kzalloc(sizeof(*pcmd_obj), GFP_ATOMIC); 4433 4433 if (!pcmd_obj) 4434 4434 return; 4435 4435 4436 4436 cmdsz = (sizeof(struct surveydone_event) + sizeof(struct C2HEvent_Header)); 4437 - pevtcmd = rtw_zmalloc(cmdsz); 4437 + pevtcmd = kzalloc(cmdsz, GFP_ATOMIC); 4438 4438 if (!pevtcmd) { 4439 4439 kfree(pcmd_obj); 4440 4440 return; ··· 4474 4474 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info; 4475 4475 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 4476 4476 4477 - pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj)); 4477 + pcmd_obj = kzalloc(sizeof(*pcmd_obj), GFP_ATOMIC); 4478 4478 if (!pcmd_obj) 4479 4479 return; 4480 4480 4481 4481 cmdsz = (sizeof(struct joinbss_event) + sizeof(struct C2HEvent_Header)); 4482 - pevtcmd = rtw_zmalloc(cmdsz); 4482 + pevtcmd = kzalloc(cmdsz, GFP_ATOMIC); 4483 4483 if (!pevtcmd) { 4484 4484 kfree(pcmd_obj); 4485 4485 return; ··· 4523 4523 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 4524 4524 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 4525 4525 4526 - pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj)); 4526 + pcmd_obj = kzalloc(sizeof(*pcmd_obj), GFP_ATOMIC); 4527 4527 if (!pcmd_obj) 4528 4528 return; 4529 4529 4530 4530 cmdsz = (sizeof(struct wmm_event) + sizeof(struct C2HEvent_Header)); 4531 - pevtcmd = rtw_zmalloc(cmdsz); 4531 + pevtcmd = kzalloc(cmdsz, GFP_ATOMIC); 4532 4532 if (!pevtcmd) { 4533 4533 kfree(pcmd_obj); 4534 4534 return; ··· 4569 4569 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 4570 4570 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 4571 4571 4572 - pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj)); 4572 + pcmd_obj = kzalloc(sizeof(*pcmd_obj), GFP_ATOMIC); 4573 4573 if (!pcmd_obj) 4574 4574 return; 4575 4575 4576 4576 cmdsz = (sizeof(struct stadel_event) + sizeof(struct C2HEvent_Header)); 4577 - pevtcmd = rtw_zmalloc(cmdsz); 4577 + pevtcmd = kzalloc(cmdsz, GFP_ATOMIC); 4578 4578 if (!pevtcmd) { 4579 4579 kfree(pcmd_obj); 4580 4580 return; ··· 4620 4620 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 4621 4621 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 4622 4622 4623 - pcmd_obj = rtw_zmalloc(sizeof(struct cmd_obj)); 4623 + pcmd_obj = kzalloc(sizeof(*pcmd_obj), GFP_ATOMIC); 4624 4624 if (!pcmd_obj) 4625 4625 return; 4626 4626 4627 4627 cmdsz = (sizeof(struct stassoc_event) + sizeof(struct C2HEvent_Header)); 4628 - pevtcmd = rtw_zmalloc(cmdsz); 4628 + pevtcmd = kzalloc(cmdsz, GFP_ATOMIC); 4629 4629 if (!pevtcmd) { 4630 4630 kfree(pcmd_obj); 4631 4631 return; ··· 5074 5074 pmlmeext->scan_abort = false;/* reset */ 5075 5075 } 5076 5076 5077 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 5077 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 5078 5078 if (!ph2c) 5079 5079 return; 5080 5080 5081 - psurveyPara = rtw_zmalloc(sizeof(struct sitesurvey_parm)); 5081 + psurveyPara = kzalloc(sizeof(*psurveyPara), GFP_ATOMIC); 5082 5082 if (!psurveyPara) { 5083 5083 kfree(ph2c); 5084 5084 return; ··· 5689 5689 struct cmd_priv *pcmdpriv = &(padapter->cmdpriv); 5690 5690 u8 res = _SUCCESS; 5691 5691 5692 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 5692 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 5693 5693 if (!ph2c) { 5694 5694 res = _FAIL; 5695 5695 goto exit; ··· 5713 5713 u8 res = _SUCCESS; 5714 5714 int len_diff = 0; 5715 5715 5716 - ph2c = rtw_zmalloc(sizeof(struct cmd_obj)); 5716 + ph2c = kzalloc(sizeof(*ph2c), GFP_ATOMIC); 5717 5717 if (!ph2c) { 5718 5718 res = _FAIL; 5719 5719 goto exit; 5720 5720 } 5721 5721 5722 - ptxBeacon_parm = rtw_zmalloc(sizeof(struct Tx_Beacon_param)); 5722 + ptxBeacon_parm = kzalloc(sizeof(*ptxBeacon_parm), GFP_ATOMIC); 5723 5723 if (!ptxBeacon_parm) { 5724 5724 kfree(ph2c); 5725 5725 res = _FAIL;
+1 -1
drivers/staging/rtl8723bs/core/rtw_recv.c
··· 1425 1425 memcpy(pattrib->ta, GetAddr2Ptr(ptr), ETH_ALEN); 1426 1426 /* actual management data frame body */ 1427 1427 data_len = pattrib->pkt_len - pattrib->hdrlen - pattrib->iv_len - pattrib->icv_len; 1428 - mgmt_DATA = rtw_zmalloc(data_len); 1428 + mgmt_DATA = kzalloc(data_len, GFP_ATOMIC); 1429 1429 if (!mgmt_DATA) 1430 1430 goto validate_80211w_fail; 1431 1431 precv_frame = decryptor(adapter, precv_frame);
+1 -2
drivers/staging/rtl8723bs/core/rtw_security.c
··· 1294 1294 __le64 le_tmp64; 1295 1295 1296 1296 ori_len = pattrib->pkt_len - WLAN_HDR_A3_LEN + BIP_AAD_SIZE; 1297 - BIP_AAD = rtw_zmalloc(ori_len); 1298 - 1297 + BIP_AAD = kzalloc(ori_len, GFP_KERNEL); 1299 1298 if (!BIP_AAD) 1300 1299 return _FAIL; 1301 1300
+1 -1
drivers/staging/rtl8723bs/core/rtw_wlan_util.c
··· 1131 1131 if (memcmp(cur_network->network.mac_address, pbssid, 6)) 1132 1132 return true; 1133 1133 1134 - bssid = rtw_zmalloc(sizeof(struct wlan_bssid_ex)); 1134 + bssid = kzalloc(sizeof(*bssid), GFP_KERNEL); 1135 1135 if (!bssid) 1136 1136 return true; 1137 1137
+3 -5
drivers/staging/rtl8723bs/core/rtw_xmit.c
··· 1194 1194 pwlanhdr = (struct ieee80211_hdr *)pframe; 1195 1195 1196 1196 ori_len = BIP_AAD_SIZE + pattrib->pktlen; 1197 - tmp_buf = BIP_AAD = rtw_zmalloc(ori_len); 1197 + tmp_buf = BIP_AAD = kzalloc(ori_len, GFP_ATOMIC); 1198 1198 subtype = GetFrameSubType(pframe); /* bit(7)~bit(2) */ 1199 1199 1200 1200 if (!BIP_AAD) ··· 1698 1698 struct xmit_frame *pxframe = NULL; 1699 1699 u8 *alloc_addr; 1700 1700 1701 - alloc_addr = rtw_zmalloc(sizeof(struct xmit_frame) + 4); 1702 - 1701 + alloc_addr = kzalloc(sizeof(*pxframe) + 4, GFP_ATOMIC); 1703 1702 if (!alloc_addr) 1704 1703 goto exit; 1705 1704 ··· 1869 1870 1870 1871 pxmitpriv->hwxmits = NULL; 1871 1872 1872 - pxmitpriv->hwxmits = rtw_zmalloc(sizeof(struct hw_xmit) * pxmitpriv->hwxmit_entry); 1873 - 1873 + pxmitpriv->hwxmits = kcalloc(pxmitpriv->hwxmit_entry, sizeof(*hwxmits), GFP_ATOMIC); 1874 1874 if (!pxmitpriv->hwxmits) 1875 1875 return _FAIL; 1876 1876
+1 -1
drivers/staging/rtl8723bs/hal/rtl8723bs_recv.c
··· 380 380 spin_lock_init(&precvpriv->recv_buf_pending_queue.lock); 381 381 382 382 n = NR_RECVBUFF * sizeof(struct recv_buf) + 4; 383 - precvpriv->pallocated_recv_buf = rtw_zmalloc(n); 383 + precvpriv->pallocated_recv_buf = kzalloc(n, GFP_KERNEL); 384 384 if (!precvpriv->pallocated_recv_buf) { 385 385 res = _FAIL; 386 386 goto exit;
+1 -1
drivers/staging/rtl8723bs/hal/sdio_ops.c
··· 896 896 if (hal->sdio_hisr & SDIO_HISR_C2HCMD) { 897 897 struct c2h_evt_hdr_88xx *c2h_evt; 898 898 899 - c2h_evt = rtw_zmalloc(16); 899 + c2h_evt = kzalloc(16, GFP_ATOMIC); 900 900 if (c2h_evt) { 901 901 if (c2h_evt_read_88xx(adapter, (u8 *)c2h_evt) == _SUCCESS) { 902 902 if (c2h_id_filter_ccx_8723b((u8 *)c2h_evt)) {
+12 -14
drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c
··· 111 111 { 112 112 struct ieee80211_supported_band *spt_band = NULL; 113 113 int n_channels, n_bitrates; 114 + size_t alloc_sz; 114 115 115 116 if (band == NL80211_BAND_2GHZ) { 116 117 n_channels = RTW_2G_CHANNELS_NUM; ··· 120 119 goto exit; 121 120 } 122 121 123 - spt_band = rtw_zmalloc(sizeof(struct ieee80211_supported_band) + 124 - sizeof(struct ieee80211_channel) * n_channels + 125 - sizeof(struct ieee80211_rate) * n_bitrates); 122 + alloc_sz = sizeof(*spt_band); 123 + alloc_sz = size_add(alloc_sz, array_size(n_channels, sizeof(struct ieee80211_channel))); 124 + alloc_sz = size_add(alloc_sz, array_size(n_bitrates, sizeof(struct ieee80211_rate))); 125 + spt_band = kzalloc(alloc_sz, GFP_KERNEL); 126 126 if (!spt_band) 127 127 goto exit; 128 128 ··· 843 841 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 844 842 845 843 param_len = sizeof(struct ieee_param) + params->key_len; 846 - param = rtw_malloc(param_len); 844 + param = kzalloc(param_len, GFP_KERNEL); 847 845 if (!param) 848 - return -1; 849 - 850 - memset(param, 0, param_len); 846 + return -ENOMEM; 851 847 852 848 param->cmd = IEEE_CMD_SET_ENCRYPTION; 853 849 eth_broadcast_addr(param->sta_addr); ··· 1430 1430 goto exit; 1431 1431 } 1432 1432 1433 - buf = rtw_zmalloc(ielen); 1433 + buf = kzalloc(ielen, GFP_KERNEL); 1434 1434 if (!buf) { 1435 1435 ret = -ENOMEM; 1436 1436 goto exit; ··· 1714 1714 wep_key_len = wep_key_len <= 5 ? 5 : 13; 1715 1715 wep_total_len = wep_key_len + 1716 1716 offsetof(struct ndis_802_11_wep, key_material); 1717 - pwep = rtw_malloc(wep_total_len); 1717 + pwep = kzalloc(wep_total_len, GFP_KERNEL); 1718 1718 if (!pwep) { 1719 1719 ret = -ENOMEM; 1720 1720 goto exit; 1721 1721 } 1722 - 1723 - memset(pwep, 0, wep_total_len); 1724 1722 1725 1723 pwep->key_length = wep_key_len; 1726 1724 pwep->length = wep_total_len; ··· 2145 2147 pnpi->sizeof_priv = sizeof(struct adapter); 2146 2148 2147 2149 /* wdev */ 2148 - mon_wdev = rtw_zmalloc(sizeof(struct wireless_dev)); 2150 + mon_wdev = kzalloc(sizeof(*mon_wdev), GFP_KERNEL); 2149 2151 if (!mon_wdev) { 2150 2152 ret = -ENOMEM; 2151 2153 goto out; ··· 2255 2257 if (head_len < 24) 2256 2258 return -EINVAL; 2257 2259 2258 - pbuf = rtw_zmalloc(head_len + tail_len); 2260 + pbuf = kzalloc(head_len + tail_len, GFP_KERNEL); 2259 2261 if (!pbuf) 2260 2262 return -ENOMEM; 2261 2263 ··· 2726 2728 goto free_wiphy; 2727 2729 2728 2730 /* wdev */ 2729 - wdev = rtw_zmalloc(sizeof(struct wireless_dev)); 2731 + wdev = kzalloc(sizeof(*wdev), GFP_KERNEL); 2730 2732 if (!wdev) { 2731 2733 ret = -ENOMEM; 2732 2734 goto unregister_wiphy;
+1 -1
drivers/staging/rtl8723bs/os_dep/os_intfs.c
··· 568 568 { 569 569 struct dvobj_priv *pdvobj = NULL; 570 570 571 - pdvobj = rtw_zmalloc(sizeof(*pdvobj)); 571 + pdvobj = kzalloc(sizeof(*pdvobj), GFP_KERNEL); 572 572 if (!pdvobj) 573 573 return NULL; 574 574
+2 -7
drivers/staging/rtl8723bs/os_dep/osdep_service.c
··· 218 218 { 219 219 struct rtw_cbuf *cbuf; 220 220 221 - cbuf = rtw_malloc(struct_size(cbuf, bufs, size)); 222 - 223 - if (cbuf) { 224 - cbuf->write = 0; 225 - cbuf->read = 0; 226 - cbuf->size = size; 227 - } 221 + cbuf = kzalloc(struct_size(cbuf, bufs, size), GFP_KERNEL); 222 + cbuf->size = size; 228 223 229 224 return cbuf; 230 225 }
+1 -1
drivers/staging/rtl8723bs/os_dep/xmit_linux.c
··· 49 49 int rtw_os_xmit_resource_alloc(struct adapter *padapter, struct xmit_buf *pxmitbuf, u32 alloc_sz, u8 flag) 50 50 { 51 51 if (alloc_sz > 0) { 52 - pxmitbuf->pallocated_buf = rtw_zmalloc(alloc_sz); 52 + pxmitbuf->pallocated_buf = kzalloc(alloc_sz, GFP_KERNEL); 53 53 if (!pxmitbuf->pallocated_buf) 54 54 return _FAIL; 55 55