In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
IntheLinuxkernel,thefollowing vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs .To prevent double free asynchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs. To prevent double freea synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup codeexecuted from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs .To prevent double free asynchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs. To prevent double freea synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup codeexecuted from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs .To prevent double free asynchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs. To prevent double freea synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup codeexecuted from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs .To prevent double free asynchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs. To prevent double freea synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup codeexecuted from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
| linux | | https://git.kernel.org/linus/70fbfc47a392b98e5f8dba70c6efc6839205c982 | https://git.kernel.org/linus/1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 | ubuntu |
</details>
二、漏洞分析结构反馈
影响性分析说明：
In the Linux kernel, the following vulnerability has been resolved:nvme-fc: do not wait in vain when unloading moduleThe module exit path has race between deleting all controllers andfreeing left over IDs . To prevent double free a synchronizationbetween nvme_delete_ctrl and ida_destroy has been added by the initialcommit.There is some logic around trying to prevent from hanging forever inwait_for_completion, though it does not handling all cases. E.g.blktests is able to reproduce the situation where the module unloadhangs forever.If we completely rely on the cleanup code executed from thenvme_delete_ctrl path, all IDs will be freed eventually. This makescalling ida_destroy unnecessary. We only have to ensure that allnvme_delete_ctrl code has been executed before we leavenvme_fc_exit_module. This is done by flushing the nvme_delete_wqworkqueue.While at it, remove the unused nvme_fc_wq workqueue too.
