From: kbuild test robot <lkp@intel.com>
To: kbuild-all@lists.01.org
Subject: Re: [PATCH] iwlwifi: actually check allocated conf_tlv pointer
Date: Thu, 02 Apr 2020 17:41:00 +0800 [thread overview]
Message-ID: <202004021740.oe608hk0%lkp@intel.com> (raw)
In-Reply-To: <20200402050219.4842-1-chris@rorvick.com>
[-- Attachment #1: Type: text/plain, Size: 13447 bytes --]
Hi Chris,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on wireless-drivers/master]
[also build test ERROR on v5.6 next-20200402]
[cannot apply to wireless-drivers-next/master]
[if your patch is applied to the wrong git tree, please drop us a note to help
improve the system. BTW, we also suggest to use '--base' option to specify the
base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/Chris-Rorvick/iwlwifi-actually-check-allocated-conf_tlv-pointer/20200402-145204
base: https://git.kernel.org/pub/scm/linux/kernel/git/kvalo/wireless-drivers.git master
config: mips-ip27_defconfig (attached as .config)
compiler: mips64-linux-gcc (GCC) 9.3.0
reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
GCC_VERSION=9.3.0 make.cross ARCH=mips
If you fix the issue, kindly add following tag
Reported-by: kbuild test robot <lkp@intel.com>
All errors (new ones prefixed by >>):
drivers/net/wireless/intel/iwlwifi/iwl-drv.c: In function 'iwl_req_fw_callback':
>> drivers/net/wireless/intel/iwlwifi/iwl-drv.c:1470:16: error: 'struct iwl_fw' has no member named 'dbg_conf_tlv'
1470 | if (!drv->fw.dbg_conf_tlv[i])
| ^
vim +1470 drivers/net/wireless/intel/iwlwifi/iwl-drv.c
1323
1324 /**
1325 * iwl_req_fw_callback - callback when firmware was loaded
1326 *
1327 * If loaded successfully, copies the firmware into buffers
1328 * for the card to fetch (via DMA).
1329 */
1330 static void iwl_req_fw_callback(const struct firmware *ucode_raw, void *context)
1331 {
1332 struct iwl_drv *drv = context;
1333 struct iwl_fw *fw = &drv->fw;
1334 struct iwl_ucode_header *ucode;
1335 struct iwlwifi_opmode_table *op;
1336 int err;
1337 struct iwl_firmware_pieces *pieces;
1338 const unsigned int api_max = drv->trans->cfg->ucode_api_max;
1339 const unsigned int api_min = drv->trans->cfg->ucode_api_min;
1340 size_t trigger_tlv_sz[FW_DBG_TRIGGER_MAX];
1341 u32 api_ver;
1342 int i;
1343 bool load_module = false;
1344 bool usniffer_images = false;
1345
1346 fw->ucode_capa.max_probe_length = IWL_DEFAULT_MAX_PROBE_LENGTH;
1347 fw->ucode_capa.standard_phy_calibration_size =
1348 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1349 fw->ucode_capa.n_scan_channels = IWL_DEFAULT_SCAN_CHANNELS;
1350 /* dump all fw memory areas by default */
1351 fw->dbg.dump_mask = 0xffffffff;
1352
1353 pieces = kzalloc(sizeof(*pieces), GFP_KERNEL);
1354 if (!pieces)
1355 goto out_free_fw;
1356
1357 if (!ucode_raw)
1358 goto try_again;
1359
1360 IWL_DEBUG_FW_INFO(drv, "Loaded firmware file '%s' (%zd bytes).\n",
1361 drv->firmware_name, ucode_raw->size);
1362
1363 /* Make sure that we got at least the API version number */
1364 if (ucode_raw->size < 4) {
1365 IWL_ERR(drv, "File size way too small!\n");
1366 goto try_again;
1367 }
1368
1369 /* Data from ucode file: header followed by uCode images */
1370 ucode = (struct iwl_ucode_header *)ucode_raw->data;
1371
1372 if (ucode->ver)
1373 err = iwl_parse_v1_v2_firmware(drv, ucode_raw, pieces);
1374 else
1375 err = iwl_parse_tlv_firmware(drv, ucode_raw, pieces,
1376 &fw->ucode_capa, &usniffer_images);
1377
1378 if (err)
1379 goto try_again;
1380
1381 if (fw_has_api(&drv->fw.ucode_capa, IWL_UCODE_TLV_API_NEW_VERSION))
1382 api_ver = drv->fw.ucode_ver;
1383 else
1384 api_ver = IWL_UCODE_API(drv->fw.ucode_ver);
1385
1386 /*
1387 * api_ver should match the api version forming part of the
1388 * firmware filename ... but we don't check for that and only rely
1389 * on the API version read from firmware header from here on forward
1390 */
1391 if (api_ver < api_min || api_ver > api_max) {
1392 IWL_ERR(drv,
1393 "Driver unable to support your firmware API. "
1394 "Driver supports v%u, firmware is v%u.\n",
1395 api_max, api_ver);
1396 goto try_again;
1397 }
1398
1399 /*
1400 * In mvm uCode there is no difference between data and instructions
1401 * sections.
1402 */
1403 if (fw->type == IWL_FW_DVM && validate_sec_sizes(drv, pieces,
1404 drv->trans->cfg))
1405 goto try_again;
1406
1407 /* Allocate ucode buffers for card's bus-master loading ... */
1408
1409 /* Runtime instructions and 2 copies of data:
1410 * 1) unmodified from disk
1411 * 2) backup cache for save/restore during power-downs
1412 */
1413 for (i = 0; i < IWL_UCODE_TYPE_MAX; i++)
1414 if (iwl_alloc_ucode(drv, pieces, i))
1415 goto out_free_fw;
1416
1417 if (pieces->dbg_dest_tlv_init) {
1418 size_t dbg_dest_size = sizeof(*drv->fw.dbg.dest_tlv) +
1419 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) *
1420 drv->fw.dbg.n_dest_reg;
1421
1422 drv->fw.dbg.dest_tlv = kmalloc(dbg_dest_size, GFP_KERNEL);
1423
1424 if (!drv->fw.dbg.dest_tlv)
1425 goto out_free_fw;
1426
1427 if (*pieces->dbg_dest_ver == 0) {
1428 memcpy(drv->fw.dbg.dest_tlv, pieces->dbg_dest_tlv_v1,
1429 dbg_dest_size);
1430 } else {
1431 struct iwl_fw_dbg_dest_tlv_v1 *dest_tlv =
1432 drv->fw.dbg.dest_tlv;
1433
1434 dest_tlv->version = pieces->dbg_dest_tlv->version;
1435 dest_tlv->monitor_mode =
1436 pieces->dbg_dest_tlv->monitor_mode;
1437 dest_tlv->size_power =
1438 pieces->dbg_dest_tlv->size_power;
1439 dest_tlv->wrap_count =
1440 pieces->dbg_dest_tlv->wrap_count;
1441 dest_tlv->write_ptr_reg =
1442 pieces->dbg_dest_tlv->write_ptr_reg;
1443 dest_tlv->base_shift =
1444 pieces->dbg_dest_tlv->base_shift;
1445 memcpy(dest_tlv->reg_ops,
1446 pieces->dbg_dest_tlv->reg_ops,
1447 sizeof(drv->fw.dbg.dest_tlv->reg_ops[0]) *
1448 drv->fw.dbg.n_dest_reg);
1449
1450 /* In version 1 of the destination tlv, which is
1451 * relevant for internal buffer exclusively,
1452 * the base address is part of given with the length
1453 * of the buffer, and the size shift is give instead of
1454 * end shift. We now store these values in base_reg,
1455 * and end shift, and when dumping the data we'll
1456 * manipulate it for extracting both the length and
1457 * base address */
1458 dest_tlv->base_reg = pieces->dbg_dest_tlv->cfg_reg;
1459 dest_tlv->end_shift =
1460 pieces->dbg_dest_tlv->size_shift;
1461 }
1462 }
1463
1464 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.conf_tlv); i++) {
1465 if (pieces->dbg_conf_tlv[i]) {
1466 drv->fw.dbg.conf_tlv[i] =
1467 kmemdup(pieces->dbg_conf_tlv[i],
1468 pieces->dbg_conf_tlv_len[i],
1469 GFP_KERNEL);
> 1470 if (!drv->fw.dbg_conf_tlv[i])
1471 goto out_free_fw;
1472 }
1473 }
1474
1475 memset(&trigger_tlv_sz, 0xff, sizeof(trigger_tlv_sz));
1476
1477 trigger_tlv_sz[FW_DBG_TRIGGER_MISSED_BEACONS] =
1478 sizeof(struct iwl_fw_dbg_trigger_missed_bcon);
1479 trigger_tlv_sz[FW_DBG_TRIGGER_CHANNEL_SWITCH] = 0;
1480 trigger_tlv_sz[FW_DBG_TRIGGER_FW_NOTIF] =
1481 sizeof(struct iwl_fw_dbg_trigger_cmd);
1482 trigger_tlv_sz[FW_DBG_TRIGGER_MLME] =
1483 sizeof(struct iwl_fw_dbg_trigger_mlme);
1484 trigger_tlv_sz[FW_DBG_TRIGGER_STATS] =
1485 sizeof(struct iwl_fw_dbg_trigger_stats);
1486 trigger_tlv_sz[FW_DBG_TRIGGER_RSSI] =
1487 sizeof(struct iwl_fw_dbg_trigger_low_rssi);
1488 trigger_tlv_sz[FW_DBG_TRIGGER_TXQ_TIMERS] =
1489 sizeof(struct iwl_fw_dbg_trigger_txq_timer);
1490 trigger_tlv_sz[FW_DBG_TRIGGER_TIME_EVENT] =
1491 sizeof(struct iwl_fw_dbg_trigger_time_event);
1492 trigger_tlv_sz[FW_DBG_TRIGGER_BA] =
1493 sizeof(struct iwl_fw_dbg_trigger_ba);
1494 trigger_tlv_sz[FW_DBG_TRIGGER_TDLS] =
1495 sizeof(struct iwl_fw_dbg_trigger_tdls);
1496
1497 for (i = 0; i < ARRAY_SIZE(drv->fw.dbg.trigger_tlv); i++) {
1498 if (pieces->dbg_trigger_tlv[i]) {
1499 /*
1500 * If the trigger isn't long enough, WARN and exit.
1501 * Someone is trying to debug something and he won't
1502 * be able to catch the bug he is trying to chase.
1503 * We'd better be noisy to be sure he knows what's
1504 * going on.
1505 */
1506 if (WARN_ON(pieces->dbg_trigger_tlv_len[i] <
1507 (trigger_tlv_sz[i] +
1508 sizeof(struct iwl_fw_dbg_trigger_tlv))))
1509 goto out_free_fw;
1510 drv->fw.dbg.trigger_tlv_len[i] =
1511 pieces->dbg_trigger_tlv_len[i];
1512 drv->fw.dbg.trigger_tlv[i] =
1513 kmemdup(pieces->dbg_trigger_tlv[i],
1514 drv->fw.dbg.trigger_tlv_len[i],
1515 GFP_KERNEL);
1516 if (!drv->fw.dbg.trigger_tlv[i])
1517 goto out_free_fw;
1518 }
1519 }
1520
1521 /* Now that we can no longer fail, copy information */
1522
1523 drv->fw.dbg.mem_tlv = pieces->dbg_mem_tlv;
1524 pieces->dbg_mem_tlv = NULL;
1525 drv->fw.dbg.n_mem_tlv = pieces->n_mem_tlv;
1526
1527 /*
1528 * The (size - 16) / 12 formula is based on the information recorded
1529 * for each event, which is of mode 1 (including timestamp) for all
1530 * new microcodes that include this information.
1531 */
1532 fw->init_evtlog_ptr = pieces->init_evtlog_ptr;
1533 if (pieces->init_evtlog_size)
1534 fw->init_evtlog_size = (pieces->init_evtlog_size - 16)/12;
1535 else
1536 fw->init_evtlog_size =
1537 drv->trans->trans_cfg->base_params->max_event_log_size;
1538 fw->init_errlog_ptr = pieces->init_errlog_ptr;
1539 fw->inst_evtlog_ptr = pieces->inst_evtlog_ptr;
1540 if (pieces->inst_evtlog_size)
1541 fw->inst_evtlog_size = (pieces->inst_evtlog_size - 16)/12;
1542 else
1543 fw->inst_evtlog_size =
1544 drv->trans->trans_cfg->base_params->max_event_log_size;
1545 fw->inst_errlog_ptr = pieces->inst_errlog_ptr;
1546
1547 /*
1548 * figure out the offset of chain noise reset and gain commands
1549 * base on the size of standard phy calibration commands table size
1550 */
1551 if (fw->ucode_capa.standard_phy_calibration_size >
1552 IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
1553 fw->ucode_capa.standard_phy_calibration_size =
1554 IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1555
1556 /* We have our copies now, allow OS release its copies */
1557 release_firmware(ucode_raw);
1558
1559 mutex_lock(&iwlwifi_opmode_table_mtx);
1560 switch (fw->type) {
1561 case IWL_FW_DVM:
1562 op = &iwlwifi_opmode_table[DVM_OP_MODE];
1563 break;
1564 default:
1565 WARN(1, "Invalid fw type %d\n", fw->type);
1566 /* fall through */
1567 case IWL_FW_MVM:
1568 op = &iwlwifi_opmode_table[MVM_OP_MODE];
1569 break;
1570 }
1571
1572 IWL_INFO(drv, "loaded firmware version %s op_mode %s\n",
1573 drv->fw.fw_version, op->name);
1574
1575 iwl_dbg_tlv_load_bin(drv->trans->dev, drv->trans);
1576
1577 /* add this device to the list of devices using this op_mode */
1578 list_add_tail(&drv->list, &op->drv);
1579
1580 if (op->ops) {
1581 drv->op_mode = _iwl_op_mode_start(drv, op);
1582
1583 if (!drv->op_mode) {
1584 mutex_unlock(&iwlwifi_opmode_table_mtx);
1585 goto out_unbind;
1586 }
1587 } else {
1588 load_module = true;
1589 }
1590 mutex_unlock(&iwlwifi_opmode_table_mtx);
1591
1592 /*
1593 * Complete the firmware request last so that
1594 * a driver unbind (stop) doesn't run while we
1595 * are doing the start() above.
1596 */
1597 complete(&drv->request_firmware_complete);
1598
1599 /*
1600 * Load the module last so we don't block anything
1601 * else from proceeding if the module fails to load
1602 * or hangs loading.
1603 */
1604 if (load_module) {
1605 request_module("%s", op->name);
1606 #ifdef CONFIG_IWLWIFI_OPMODE_MODULAR
1607 if (err)
1608 IWL_ERR(drv,
1609 "failed to load module %s (error %d), is dynamic loading enabled?\n",
1610 op->name, err);
1611 #endif
1612 }
1613 goto free;
1614
1615 try_again:
1616 /* try next, if any */
1617 release_firmware(ucode_raw);
1618 if (iwl_request_firmware(drv, false))
1619 goto out_unbind;
1620 goto free;
1621
1622 out_free_fw:
1623 release_firmware(ucode_raw);
1624 out_unbind:
1625 complete(&drv->request_firmware_complete);
1626 device_release_driver(drv->trans->dev);
1627 free:
1628 if (pieces) {
1629 for (i = 0; i < ARRAY_SIZE(pieces->img); i++)
1630 kfree(pieces->img[i].sec);
1631 kfree(pieces->dbg_mem_tlv);
1632 kfree(pieces);
1633 }
1634 }
1635
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
[-- Attachment #2: config.gz --]
[-- Type: application/gzip, Size: 17481 bytes --]
next prev parent reply other threads:[~2020-04-02 9:41 UTC|newest]
Thread overview: 9+ messages / expand[flat|nested] mbox.gz Atom feed top
2020-04-02 5:02 [PATCH] iwlwifi: actually check allocated conf_tlv pointer Chris Rorvick
2020-04-02 9:41 ` kbuild test robot [this message]
2020-04-05 8:44 ` Kalle Valo
2020-04-05 8:51 ` Luca Coelho
2020-04-05 9:13 ` Kalle Valo
2020-04-14 12:14 ` Sedat Dilek
2020-04-06 14:10 ` Kalle Valo
2020-04-06 19:53 ` Sedat Dilek
2020-04-08 9:07 ` Sedat Dilek
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=202004021740.oe608hk0%lkp@intel.com \
--to=lkp@intel.com \
--cc=kbuild-all@lists.01.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.