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.

Revert "devcoredump: remove the useless gfp_t parameter in dev_coredumpv and dev_coredumpm"

This reverts commit 77515ebaf01920e2db49e04672ef669a7c2907f2 as it
causes build problems in linux-next. It needs to be reintroduced in a
way that can allow the api to evolve and not require a "flag day" to
catch all users.

Link: https://lore.kernel.org/r/20220623160723.7a44b573@canb.auug.org.au
Cc: Duoming Zhou <duoming@zju.edu.cn>
Cc: Brian Norris <briannorris@chromium.org>
Cc: Johannes Berg <johannes@sipsolutions.net>
Reported-by: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

+50 -40
+10 -6
drivers/base/devcoredump.c
··· 173 173 * @dev: the struct device for the crashed device 174 174 * @data: vmalloc data containing the device coredump 175 175 * @datalen: length of the data 176 + * @gfp: allocation flags 176 177 * 177 178 * This function takes ownership of the vmalloc'ed data and will free 178 179 * it when it is no longer used. See dev_coredumpm() for more information. 179 180 */ 180 - void dev_coredumpv(struct device *dev, void *data, size_t datalen) 181 + void dev_coredumpv(struct device *dev, void *data, size_t datalen, 182 + gfp_t gfp) 181 183 { 182 - dev_coredumpm(dev, NULL, data, datalen, devcd_readv, devcd_freev); 184 + dev_coredumpm(dev, NULL, data, datalen, gfp, devcd_readv, devcd_freev); 183 185 } 184 186 EXPORT_SYMBOL_GPL(dev_coredumpv); 185 187 ··· 236 234 * @owner: the module that contains the read/free functions, use %THIS_MODULE 237 235 * @data: data cookie for the @read/@free functions 238 236 * @datalen: length of the data 237 + * @gfp: allocation flags 239 238 * @read: function to read from the given buffer 240 239 * @free: function to free the given buffer 241 240 * ··· 246 243 * function will be called to free the data. 247 244 */ 248 245 void dev_coredumpm(struct device *dev, struct module *owner, 249 - void *data, size_t datalen, 246 + void *data, size_t datalen, gfp_t gfp, 250 247 ssize_t (*read)(char *buffer, loff_t offset, size_t count, 251 248 void *data, size_t datalen), 252 249 void (*free)(void *data)) ··· 268 265 if (!try_module_get(owner)) 269 266 goto free; 270 267 271 - devcd = kzalloc(sizeof(*devcd), GFP_KERNEL); 268 + devcd = kzalloc(sizeof(*devcd), gfp); 272 269 if (!devcd) 273 270 goto put_module; 274 271 ··· 318 315 * @dev: the struct device for the crashed device 319 316 * @table: the dump data 320 317 * @datalen: length of the data 318 + * @gfp: allocation flags 321 319 * 322 320 * Creates a new device coredump for the given device. If a previous one hasn't 323 321 * been read yet, the new coredump is discarded. The data lifetime is determined ··· 326 322 * it will free the data. 327 323 */ 328 324 void dev_coredumpsg(struct device *dev, struct scatterlist *table, 329 - size_t datalen) 325 + size_t datalen, gfp_t gfp) 330 326 { 331 - dev_coredumpm(dev, NULL, table, datalen, devcd_read_from_sgtable, 327 + dev_coredumpm(dev, NULL, table, datalen, gfp, devcd_read_from_sgtable, 332 328 devcd_free_sgtable); 333 329 } 334 330 EXPORT_SYMBOL_GPL(dev_coredumpsg);
+1 -1
drivers/bluetooth/btmrvl_sdio.c
··· 1515 1515 /* fw_dump_data will be free in device coredump release function 1516 1516 * after 5 min 1517 1517 */ 1518 - dev_coredumpv(&card->func->dev, fw_dump_data, fw_dump_len); 1518 + dev_coredumpv(&card->func->dev, fw_dump_data, fw_dump_len, GFP_KERNEL); 1519 1519 BT_INFO("== btmrvl firmware dump to /sys/class/devcoredump end"); 1520 1520 } 1521 1521
+1 -1
drivers/bluetooth/hci_qca.c
··· 1120 1120 qca_memdump->ram_dump_size); 1121 1121 memdump_buf = qca_memdump->memdump_buf_head; 1122 1122 dev_coredumpv(&hu->serdev->dev, memdump_buf, 1123 - qca_memdump->received_dump); 1123 + qca_memdump->received_dump, GFP_KERNEL); 1124 1124 cancel_delayed_work(&qca->ctrl_memdump_timeout); 1125 1125 kfree(qca->qca_memdump); 1126 1126 qca->qca_memdump = NULL;
+1 -1
drivers/gpu/drm/etnaviv/etnaviv_dump.c
··· 225 225 226 226 etnaviv_core_dump_header(&iter, ETDUMP_BUF_END, iter.data); 227 227 228 - dev_coredumpv(gpu->dev, iter.start, iter.data - iter.start); 228 + dev_coredumpv(gpu->dev, iter.start, iter.data - iter.start, GFP_KERNEL); 229 229 }
+2 -2
drivers/gpu/drm/msm/disp/msm_disp_snapshot.c
··· 74 74 * If there is a codedump pending for the device, the dev_coredumpm() 75 75 * will also free new coredump state. 76 76 */ 77 - dev_coredumpm(disp_state->dev, THIS_MODULE, disp_state, 0, 78 - disp_devcoredump_read, msm_disp_state_free); 77 + dev_coredumpm(disp_state->dev, THIS_MODULE, disp_state, 0, GFP_KERNEL, 78 + disp_devcoredump_read, msm_disp_state_free); 79 79 } 80 80 81 81 void msm_disp_snapshot_state(struct drm_device *drm_dev)
+2 -2
drivers/gpu/drm/msm/msm_gpu.c
··· 317 317 gpu->crashstate = state; 318 318 319 319 /* FIXME: Release the crashstate if this errors out? */ 320 - dev_coredumpm(gpu->dev->dev, THIS_MODULE, gpu, 0, 321 - msm_gpu_devcoredump_read, msm_gpu_devcoredump_free); 320 + dev_coredumpm(gpu->dev->dev, THIS_MODULE, gpu, 0, GFP_KERNEL, 321 + msm_gpu_devcoredump_read, msm_gpu_devcoredump_free); 322 322 } 323 323 #else 324 324 static void msm_gpu_crashstate_capture(struct msm_gpu *gpu,
+1 -1
drivers/media/platform/qcom/venus/core.c
··· 49 49 50 50 memcpy(data, mem_va, mem_size); 51 51 memunmap(mem_va); 52 - dev_coredumpv(dev, data, mem_size); 52 + dev_coredumpv(dev, data, mem_size, GFP_KERNEL); 53 53 } 54 54 55 55 static void venus_event_notify(struct venus_core *core, u32 event)
+1 -1
drivers/net/can/spi/mcp251xfd/mcp251xfd-dump.c
··· 281 281 mcp251xfd_dump_end(priv, &iter); 282 282 283 283 dev_coredumpv(&priv->spi->dev, iter.start, 284 - iter.data - iter.start); 284 + iter.data - iter.start, GFP_KERNEL); 285 285 }
+1 -1
drivers/net/wireless/ath/ath10k/coredump.c
··· 1607 1607 return -ENODATA; 1608 1608 } 1609 1609 1610 - dev_coredumpv(ar->dev, dump, le32_to_cpu(dump->len)); 1610 + dev_coredumpv(ar->dev, dump, le32_to_cpu(dump->len), GFP_KERNEL); 1611 1611 1612 1612 return 0; 1613 1613 }
+1 -1
drivers/net/wireless/ath/wil6210/wil_crash_dump.c
··· 117 117 /* fw_dump_data will be free in device coredump release function 118 118 * after 5 min 119 119 */ 120 - dev_coredumpv(wil_to_dev(wil), fw_dump_data, fw_dump_size); 120 + dev_coredumpv(wil_to_dev(wil), fw_dump_data, fw_dump_size, GFP_KERNEL); 121 121 wil_info(wil, "fw core dumped, size %d bytes\n", fw_dump_size); 122 122 }
+1 -1
drivers/net/wireless/broadcom/brcm80211/brcmfmac/debug.c
··· 37 37 return err; 38 38 } 39 39 40 - dev_coredumpv(bus->dev, dump, len + ramsize); 40 + dev_coredumpv(bus->dev, dump, len + ramsize, GFP_KERNEL); 41 41 42 42 return 0; 43 43 }
+4 -2
drivers/net/wireless/intel/iwlwifi/fw/dbg.c
··· 2601 2601 fw_error_dump.trans_ptr->data, 2602 2602 fw_error_dump.trans_ptr->len, 2603 2603 fw_error_dump.fwrt_len); 2604 - dev_coredumpsg(fwrt->trans->dev, sg_dump_data, file_len); 2604 + dev_coredumpsg(fwrt->trans->dev, sg_dump_data, file_len, 2605 + GFP_KERNEL); 2605 2606 } 2606 2607 vfree(fw_error_dump.fwrt_ptr); 2607 2608 vfree(fw_error_dump.trans_ptr); ··· 2647 2646 entry->data, entry->size, offs); 2648 2647 offs += entry->size; 2649 2648 } 2650 - dev_coredumpsg(fwrt->trans->dev, sg_dump_data, file_len); 2649 + dev_coredumpsg(fwrt->trans->dev, sg_dump_data, file_len, 2650 + GFP_KERNEL); 2651 2651 } 2652 2652 iwl_dump_ini_list_free(&dump_list); 2653 2653 }
+2 -1
drivers/net/wireless/marvell/mwifiex/main.c
··· 1115 1115 */ 1116 1116 mwifiex_dbg(adapter, MSG, 1117 1117 "== mwifiex dump information to /sys/class/devcoredump start\n"); 1118 - dev_coredumpv(adapter->dev, adapter->devdump_data, adapter->devdump_len); 1118 + dev_coredumpv(adapter->dev, adapter->devdump_data, adapter->devdump_len, 1119 + GFP_KERNEL); 1119 1120 mwifiex_dbg(adapter, MSG, 1120 1121 "== mwifiex dump information to /sys/class/devcoredump end\n"); 1121 1122
+2 -1
drivers/net/wireless/mediatek/mt76/mt7615/mac.c
··· 2421 2421 2422 2422 dev_kfree_skb(skb); 2423 2423 } 2424 - dev_coredumpv(dev->mt76.dev, dump, MT76_CONNAC_COREDUMP_SZ); 2424 + dev_coredumpv(dev->mt76.dev, dump, MT76_CONNAC_COREDUMP_SZ, 2425 + GFP_KERNEL); 2425 2426 }
+2 -1
drivers/net/wireless/mediatek/mt76/mt7921/mac.c
··· 1630 1630 } 1631 1631 1632 1632 if (dump) 1633 - dev_coredumpv(dev->mt76.dev, dump, MT76_CONNAC_COREDUMP_SZ); 1633 + dev_coredumpv(dev->mt76.dev, dump, MT76_CONNAC_COREDUMP_SZ, 1634 + GFP_KERNEL); 1634 1635 1635 1636 mt7921_reset(&dev->mt76); 1636 1637 }
+1 -1
drivers/net/wireless/realtek/rtw88/main.c
··· 414 414 * framework. Note that a new dump will be discarded if a previous one 415 415 * hasn't been released yet. 416 416 */ 417 - dev_coredumpv(rtwdev->dev, desc->data, desc->size); 417 + dev_coredumpv(rtwdev->dev, desc->data, desc->size, GFP_KERNEL); 418 418 } 419 419 420 420 static void rtw_fwcd_free(struct rtw_dev *rtwdev, bool free_self)
+1 -1
drivers/net/wireless/realtek/rtw89/ser.c
··· 127 127 * will be discarded if a previous one hasn't been released by 128 128 * framework yet. 129 129 */ 130 - dev_coredumpv(rtwdev->dev, buf, sizeof(*buf)); 130 + dev_coredumpv(rtwdev->dev, buf, sizeof(*buf), GFP_KERNEL); 131 131 } 132 132 133 133 static void rtw89_ser_cd_free(struct rtw89_dev *rtwdev,
+1 -1
drivers/remoteproc/qcom_q6v5_mss.c
··· 597 597 data = vmalloc(MBA_LOG_SIZE); 598 598 if (data) { 599 599 memcpy(data, mba_region, MBA_LOG_SIZE); 600 - dev_coredumpv(&rproc->dev, data, MBA_LOG_SIZE); 600 + dev_coredumpv(&rproc->dev, data, MBA_LOG_SIZE, GFP_KERNEL); 601 601 } 602 602 memunmap(mba_region); 603 603 }
+4 -4
drivers/remoteproc/remoteproc_coredump.c
··· 309 309 phdr += elf_size_of_phdr(class); 310 310 } 311 311 if (dump_conf == RPROC_COREDUMP_ENABLED) { 312 - dev_coredumpv(&rproc->dev, data, data_size); 312 + dev_coredumpv(&rproc->dev, data, data_size, GFP_KERNEL); 313 313 return; 314 314 } 315 315 ··· 318 318 dump_state.header = data; 319 319 init_completion(&dump_state.dump_done); 320 320 321 - dev_coredumpm(&rproc->dev, NULL, &dump_state, data_size, 321 + dev_coredumpm(&rproc->dev, NULL, &dump_state, data_size, GFP_KERNEL, 322 322 rproc_coredump_read, rproc_coredump_free); 323 323 324 324 /* ··· 449 449 } 450 450 451 451 if (dump_conf == RPROC_COREDUMP_ENABLED) { 452 - dev_coredumpv(&rproc->dev, data, data_size); 452 + dev_coredumpv(&rproc->dev, data, data_size, GFP_KERNEL); 453 453 return; 454 454 } 455 455 ··· 458 458 dump_state.header = data; 459 459 init_completion(&dump_state.dump_done); 460 460 461 - dev_coredumpm(&rproc->dev, NULL, &dump_state, data_size, 461 + dev_coredumpm(&rproc->dev, NULL, &dump_state, data_size, GFP_KERNEL, 462 462 rproc_coredump_read, rproc_coredump_free); 463 463 464 464 /* Wait until the dump is read and free is called. Data is freed
+1 -1
include/drm/drm_print.h
··· 162 162 * void makecoredump(...) 163 163 * { 164 164 * ... 165 - * dev_coredumpm(dev, THIS_MODULE, data, 0, 165 + * dev_coredumpm(dev, THIS_MODULE, data, 0, GFP_KERNEL, 166 166 * coredump_read, ...) 167 167 * } 168 168 *
+7 -6
include/linux/devcoredump.h
··· 52 52 53 53 54 54 #ifdef CONFIG_DEV_COREDUMP 55 - void dev_coredumpv(struct device *dev, void *data, size_t datalen); 55 + void dev_coredumpv(struct device *dev, void *data, size_t datalen, 56 + gfp_t gfp); 56 57 57 58 void dev_coredumpm(struct device *dev, struct module *owner, 58 - void *data, size_t datalen, 59 + void *data, size_t datalen, gfp_t gfp, 59 60 ssize_t (*read)(char *buffer, loff_t offset, size_t count, 60 61 void *data, size_t datalen), 61 62 void (*free)(void *data)); 62 63 63 64 void dev_coredumpsg(struct device *dev, struct scatterlist *table, 64 - size_t datalen); 65 + size_t datalen, gfp_t gfp); 65 66 #else 66 67 static inline void dev_coredumpv(struct device *dev, void *data, 67 - size_t datalen) 68 + size_t datalen, gfp_t gfp) 68 69 { 69 70 vfree(data); 70 71 } 71 72 72 73 static inline void 73 74 dev_coredumpm(struct device *dev, struct module *owner, 74 - void *data, size_t datalen, 75 + void *data, size_t datalen, gfp_t gfp, 75 76 ssize_t (*read)(char *buffer, loff_t offset, size_t count, 76 77 void *data, size_t datalen), 77 78 void (*free)(void *data)) ··· 81 80 } 82 81 83 82 static inline void dev_coredumpsg(struct device *dev, struct scatterlist *table, 84 - size_t datalen) 83 + size_t datalen, gfp_t gfp) 85 84 { 86 85 _devcd_free_sgtable(table); 87 86 }
+1 -1
sound/soc/intel/avs/apl.c
··· 164 164 } while (offset < msg->ext.coredump.stack_dump_size); 165 165 166 166 exit: 167 - dev_coredumpv(adev->dev, dump, dump_size); 167 + dev_coredumpv(adev->dev, dump, dump_size, GFP_KERNEL); 168 168 169 169 return 0; 170 170 }
+1 -1
sound/soc/intel/avs/skl.c
··· 88 88 return -ENOMEM; 89 89 90 90 memcpy_fromio(dump, avs_sram_addr(adev, AVS_FW_REGS_WINDOW), AVS_FW_REGS_SIZE); 91 - dev_coredumpv(adev->dev, dump, AVS_FW_REGS_SIZE); 91 + dev_coredumpv(adev->dev, dump, AVS_FW_REGS_SIZE, GFP_KERNEL); 92 92 93 93 return 0; 94 94 }
+1 -1
sound/soc/intel/catpt/dsp.c
··· 539 539 pos += CATPT_DMA_REGS_SIZE; 540 540 } 541 541 542 - dev_coredumpv(cdev->dev, dump, dump_size); 542 + dev_coredumpv(cdev->dev, dump, dump_size, GFP_KERNEL); 543 543 544 544 return 0; 545 545 }