--- /dev/null
+From e91914afc5896cf7c5e97eb3e1db1b14dd4f54f2 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 28 Dec 2020 11:40:22 -0800
+Subject: depmod: handle the case of /sbin/depmod without /sbin in PATH
+
+From: Linus Torvalds <torvalds@linux-foundation.org>
+
+[ Upstream commit cedd1862be7e666be87ec824dabc6a2b05618f36 ]
+
+Commit 436e980e2ed5 ("kbuild: don't hardcode depmod path") stopped
+hard-coding the path of depmod, but in the process caused trouble for
+distributions that had that /sbin location, but didn't have it in the
+PATH (generally because /sbin is limited to the super-user path).
+
+Work around it for now by just adding /sbin to the end of PATH in the
+depmod.sh script.
+
+Reported-and-tested-by: Sedat Dilek <sedat.dilek@gmail.com>
+Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ scripts/depmod.sh | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/scripts/depmod.sh b/scripts/depmod.sh
+index cf5b2b24b3cf1..c7b8f827c4b09 100755
+--- a/scripts/depmod.sh
++++ b/scripts/depmod.sh
+@@ -15,6 +15,8 @@ if ! test -r System.map ; then
+ exit 0
+ fi
+
++# legacy behavior: "depmod" in /sbin, no /sbin in PATH
++PATH="$PATH:/sbin"
+ if [ -z $(command -v $DEPMOD) ]; then
+ echo "Warning: 'make modules_install' requires $DEPMOD. Please install it." >&2
+ echo "This is probably in the kmod package." >&2
+--
+2.27.0
+
--- /dev/null
+From c6cd07605979bc7f38ff26f86de758eff2aeb46c Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Tue, 29 Dec 2020 15:14:58 -0800
+Subject: lib/genalloc: fix the overflow when size is too big
+
+From: Huang Shijie <sjhuang@iluvatar.ai>
+
+[ Upstream commit 36845663843fc59c5d794e3dc0641472e3e572da ]
+
+Some graphic card has very big memory on chip, such as 32G bytes.
+
+In the following case, it will cause overflow:
+
+ pool = gen_pool_create(PAGE_SHIFT, NUMA_NO_NODE);
+ ret = gen_pool_add(pool, 0x1000000, SZ_32G, NUMA_NO_NODE);
+
+ va = gen_pool_alloc(pool, SZ_4G);
+
+The overflow occurs in gen_pool_alloc_algo_owner():
+
+ ....
+ size = nbits << order;
+ ....
+
+The @nbits is "int" type, so it will overflow.
+Then the gen_pool_avail() will return the wrong value.
+
+This patch converts some "int" to "unsigned long", and
+changes the compare code in while.
+
+Link: https://lkml.kernel.org/r/20201229060657.3389-1-sjhuang@iluvatar.ai
+Signed-off-by: Huang Shijie <sjhuang@iluvatar.ai>
+Reported-by: Shi Jiasheng <jiasheng.shi@iluvatar.ai>
+Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
+Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ lib/genalloc.c | 25 +++++++++++++------------
+ 1 file changed, 13 insertions(+), 12 deletions(-)
+
+diff --git a/lib/genalloc.c b/lib/genalloc.c
+index 7e85d1e37a6ea..0b8ee173cf3a6 100644
+--- a/lib/genalloc.c
++++ b/lib/genalloc.c
+@@ -83,14 +83,14 @@ static int clear_bits_ll(unsigned long *addr, unsigned long mask_to_clear)
+ * users set the same bit, one user will return remain bits, otherwise
+ * return 0.
+ */
+-static int bitmap_set_ll(unsigned long *map, int start, int nr)
++static int bitmap_set_ll(unsigned long *map, unsigned long start, unsigned long nr)
+ {
+ unsigned long *p = map + BIT_WORD(start);
+- const int size = start + nr;
++ const unsigned long size = start + nr;
+ int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
+ unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
+
+- while (nr - bits_to_set >= 0) {
++ while (nr >= bits_to_set) {
+ if (set_bits_ll(p, mask_to_set))
+ return nr;
+ nr -= bits_to_set;
+@@ -118,14 +118,15 @@ static int bitmap_set_ll(unsigned long *map, int start, int nr)
+ * users clear the same bit, one user will return remain bits,
+ * otherwise return 0.
+ */
+-static int bitmap_clear_ll(unsigned long *map, int start, int nr)
++static unsigned long
++bitmap_clear_ll(unsigned long *map, unsigned long start, unsigned long nr)
+ {
+ unsigned long *p = map + BIT_WORD(start);
+- const int size = start + nr;
++ const unsigned long size = start + nr;
+ int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
+ unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
+
+- while (nr - bits_to_clear >= 0) {
++ while (nr >= bits_to_clear) {
+ if (clear_bits_ll(p, mask_to_clear))
+ return nr;
+ nr -= bits_to_clear;
+@@ -184,8 +185,8 @@ int gen_pool_add_virt(struct gen_pool *pool, unsigned long virt, phys_addr_t phy
+ size_t size, int nid)
+ {
+ struct gen_pool_chunk *chunk;
+- int nbits = size >> pool->min_alloc_order;
+- int nbytes = sizeof(struct gen_pool_chunk) +
++ unsigned long nbits = size >> pool->min_alloc_order;
++ unsigned long nbytes = sizeof(struct gen_pool_chunk) +
+ BITS_TO_LONGS(nbits) * sizeof(long);
+
+ chunk = vzalloc_node(nbytes, nid);
+@@ -242,7 +243,7 @@ void gen_pool_destroy(struct gen_pool *pool)
+ struct list_head *_chunk, *_next_chunk;
+ struct gen_pool_chunk *chunk;
+ int order = pool->min_alloc_order;
+- int bit, end_bit;
++ unsigned long bit, end_bit;
+
+ list_for_each_safe(_chunk, _next_chunk, &pool->chunks) {
+ chunk = list_entry(_chunk, struct gen_pool_chunk, next_chunk);
+@@ -293,7 +294,7 @@ unsigned long gen_pool_alloc_algo(struct gen_pool *pool, size_t size,
+ struct gen_pool_chunk *chunk;
+ unsigned long addr = 0;
+ int order = pool->min_alloc_order;
+- int nbits, start_bit, end_bit, remain;
++ unsigned long nbits, start_bit, end_bit, remain;
+
+ #ifndef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
+ BUG_ON(in_nmi());
+@@ -376,7 +377,7 @@ void gen_pool_free(struct gen_pool *pool, unsigned long addr, size_t size)
+ {
+ struct gen_pool_chunk *chunk;
+ int order = pool->min_alloc_order;
+- int start_bit, nbits, remain;
++ unsigned long start_bit, nbits, remain;
+
+ #ifndef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG
+ BUG_ON(in_nmi());
+@@ -638,7 +639,7 @@ unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size,
+ index = bitmap_find_next_zero_area(map, size, start, nr, 0);
+
+ while (index < size) {
+- int next_bit = find_next_bit(map, size, index + nr);
++ unsigned long next_bit = find_next_bit(map, size, index + nr);
+ if ((next_bit - index) < len) {
+ len = next_bit - index;
+ start_bit = index;
+--
+2.27.0
+
--- /dev/null
+From 220f3b553942e84a827758bd4d55b6b1eac6583d Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Tue, 8 Dec 2020 21:29:46 -0800
+Subject: scsi: ide: Do not set the RQF_PREEMPT flag for sense requests
+
+From: Bart Van Assche <bvanassche@acm.org>
+
+[ Upstream commit 96d86e6a80a3ab9aff81d12f9f1f2a0da2917d38 ]
+
+RQF_PREEMPT is used for two different purposes in the legacy IDE code:
+
+ 1. To mark power management requests.
+
+ 2. To mark requests that should preempt another request. An (old)
+ explanation of that feature is as follows: "The IDE driver in the Linux
+ kernel normally uses a series of busywait delays during its
+ initialization. When the driver executes these busywaits, the kernel
+ does nothing for the duration of the wait. The time spent in these
+ waits could be used for other initialization activities, if they could
+ be run concurrently with these waits.
+
+ More specifically, busywait-style delays such as udelay() in module
+ init functions inhibit kernel preemption because the Big Kernel Lock is
+ held, while yielding APIs such as schedule_timeout() allow
+ preemption. This is true because the kernel handles the BKL specially
+ and releases and reacquires it across reschedules allowed by the
+ current thread.
+
+ This IDE-preempt specification requires that the driver eliminate these
+ busywaits and replace them with a mechanism that allows other work to
+ proceed while the IDE driver is initializing."
+
+Since I haven't found an implementation of (2), do not set the PREEMPT flag
+for sense requests. This patch causes sense requests to be postponed while
+a drive is suspended instead of being submitted to ide_queue_rq().
+
+If it would ever be necessary to restore the IDE PREEMPT functionality,
+that can be done by introducing a new flag in struct ide_request.
+
+Link: https://lore.kernel.org/r/20201209052951.16136-4-bvanassche@acm.org
+Cc: David S. Miller <davem@davemloft.net>
+Cc: Alan Stern <stern@rowland.harvard.edu>
+Cc: Can Guo <cang@codeaurora.org>
+Cc: Stanley Chu <stanley.chu@mediatek.com>
+Cc: Ming Lei <ming.lei@redhat.com>
+Cc: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
+Reviewed-by: Christoph Hellwig <hch@lst.de>
+Reviewed-by: Hannes Reinecke <hare@suse.de>
+Reviewed-by: Jens Axboe <axboe@kernel.dk>
+Signed-off-by: Bart Van Assche <bvanassche@acm.org>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/ide/ide-atapi.c | 1 -
+ drivers/ide/ide-io.c | 5 -----
+ 2 files changed, 6 deletions(-)
+
+diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
+index 0e6bc631a1caf..215558c947def 100644
+--- a/drivers/ide/ide-atapi.c
++++ b/drivers/ide/ide-atapi.c
+@@ -213,7 +213,6 @@ void ide_prep_sense(ide_drive_t *drive, struct request *rq)
+ sense_rq->rq_disk = rq->rq_disk;
+ sense_rq->cmd_flags = REQ_OP_DRV_IN;
+ ide_req(sense_rq)->type = ATA_PRIV_SENSE;
+- sense_rq->rq_flags |= RQF_PREEMPT;
+
+ req->cmd[0] = GPCMD_REQUEST_SENSE;
+ req->cmd[4] = cmd_len;
+diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
+index 3a234701d92c4..7f34dc49c9b5f 100644
+--- a/drivers/ide/ide-io.c
++++ b/drivers/ide/ide-io.c
+@@ -531,11 +531,6 @@ repeat:
+ * above to return us whatever is in the queue. Since we call
+ * ide_do_request() ourselves, we end up taking requests while
+ * the queue is blocked...
+- *
+- * We let requests forced at head of queue with ide-preempt
+- * though. I hope that doesn't happen too much, hopefully not
+- * unless the subdriver triggers such a thing in its own PM
+- * state machine.
+ */
+ if ((drive->dev_flags & IDE_DFLAG_BLOCKED) &&
+ ata_pm_request(rq) == 0 &&
+--
+2.27.0
+
--- /dev/null
+From 25d3fae9fe5d796806b91b5a614fae26fbe2719e Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Mon, 7 Dec 2020 10:31:18 +0200
+Subject: scsi: ufs-pci: Ensure UFS device is in PowerDown mode for
+ suspend-to-disk ->poweroff()
+
+From: Adrian Hunter <adrian.hunter@intel.com>
+
+[ Upstream commit af423534d2de86cd0db729a5ac41f056ca8717de ]
+
+The expectation for suspend-to-disk is that devices will be powered-off, so
+the UFS device should be put in PowerDown mode. If spm_lvl is not 5, then
+that will not happen. Change the pm callbacks to force spm_lvl 5 for
+suspend-to-disk poweroff.
+
+Link: https://lore.kernel.org/r/20201207083120.26732-3-adrian.hunter@intel.com
+Signed-off-by: Adrian Hunter <adrian.hunter@intel.com>
+Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ drivers/scsi/ufs/ufshcd-pci.c | 34 ++++++++++++++++++++++++++++++++--
+ 1 file changed, 32 insertions(+), 2 deletions(-)
+
+diff --git a/drivers/scsi/ufs/ufshcd-pci.c b/drivers/scsi/ufs/ufshcd-pci.c
+index 925b0ec7ec54d..5253f089de4ee 100644
+--- a/drivers/scsi/ufs/ufshcd-pci.c
++++ b/drivers/scsi/ufs/ufshcd-pci.c
+@@ -97,6 +97,30 @@ static int ufshcd_pci_resume(struct device *dev)
+ {
+ return ufshcd_system_resume(dev_get_drvdata(dev));
+ }
++
++/**
++ * ufshcd_pci_poweroff - suspend-to-disk poweroff function
++ * @dev: pointer to PCI device handle
++ *
++ * Returns 0 if successful
++ * Returns non-zero otherwise
++ */
++static int ufshcd_pci_poweroff(struct device *dev)
++{
++ struct ufs_hba *hba = dev_get_drvdata(dev);
++ int spm_lvl = hba->spm_lvl;
++ int ret;
++
++ /*
++ * For poweroff we need to set the UFS device to PowerDown mode.
++ * Force spm_lvl to ensure that.
++ */
++ hba->spm_lvl = 5;
++ ret = ufshcd_system_suspend(hba);
++ hba->spm_lvl = spm_lvl;
++ return ret;
++}
++
+ #endif /* !CONFIG_PM_SLEEP */
+
+ #ifdef CONFIG_PM
+@@ -191,8 +215,14 @@ ufshcd_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+ }
+
+ static const struct dev_pm_ops ufshcd_pci_pm_ops = {
+- SET_SYSTEM_SLEEP_PM_OPS(ufshcd_pci_suspend,
+- ufshcd_pci_resume)
++#ifdef CONFIG_PM_SLEEP
++ .suspend = ufshcd_pci_suspend,
++ .resume = ufshcd_pci_resume,
++ .freeze = ufshcd_pci_suspend,
++ .thaw = ufshcd_pci_resume,
++ .poweroff = ufshcd_pci_poweroff,
++ .restore = ufshcd_pci_resume,
++#endif
+ SET_RUNTIME_PM_OPS(ufshcd_pci_runtime_suspend,
+ ufshcd_pci_runtime_resume,
+ ufshcd_pci_runtime_idle)
+--
+2.27.0
+
--- /dev/null
+workqueue-kick-a-worker-based-on-the-actual-activati.patch
+scsi-ufs-pci-ensure-ufs-device-is-in-powerdown-mode-.patch
+scsi-ide-do-not-set-the-rqf_preempt-flag-for-sense-r.patch
+lib-genalloc-fix-the-overflow-when-size-is-too-big.patch
+depmod-handle-the-case-of-sbin-depmod-without-sbin-i.patch
--- /dev/null
+From aa7e0e5565a21bd3f985121ccd04e0439caa02a8 Mon Sep 17 00:00:00 2001
+From: Sasha Levin <sashal@kernel.org>
+Date: Thu, 19 Nov 2020 14:21:25 +0800
+Subject: workqueue: Kick a worker based on the actual activation of delayed
+ works
+
+From: Yunfeng Ye <yeyunfeng@huawei.com>
+
+[ Upstream commit 01341fbd0d8d4e717fc1231cdffe00343088ce0b ]
+
+In realtime scenario, We do not want to have interference on the
+isolated cpu cores. but when invoking alloc_workqueue() for percpu wq
+on the housekeeping cpu, it kick a kworker on the isolated cpu.
+
+ alloc_workqueue
+ pwq_adjust_max_active
+ wake_up_worker
+
+The comment in pwq_adjust_max_active() said:
+ "Need to kick a worker after thawed or an unbound wq's
+ max_active is bumped"
+
+So it is unnecessary to kick a kworker for percpu's wq when invoking
+alloc_workqueue(). this patch only kick a worker based on the actual
+activation of delayed works.
+
+Signed-off-by: Yunfeng Ye <yeyunfeng@huawei.com>
+Reviewed-by: Lai Jiangshan <jiangshanlai@gmail.com>
+Signed-off-by: Tejun Heo <tj@kernel.org>
+Signed-off-by: Sasha Levin <sashal@kernel.org>
+---
+ kernel/workqueue.c | 13 ++++++++++---
+ 1 file changed, 10 insertions(+), 3 deletions(-)
+
+diff --git a/kernel/workqueue.c b/kernel/workqueue.c
+index 18fae55713b0a..79fcec674485f 100644
+--- a/kernel/workqueue.c
++++ b/kernel/workqueue.c
+@@ -3494,17 +3494,24 @@ static void pwq_adjust_max_active(struct pool_workqueue *pwq)
+ * is updated and visible.
+ */
+ if (!freezable || !workqueue_freezing) {
++ bool kick = false;
++
+ pwq->max_active = wq->saved_max_active;
+
+ while (!list_empty(&pwq->delayed_works) &&
+- pwq->nr_active < pwq->max_active)
++ pwq->nr_active < pwq->max_active) {
+ pwq_activate_first_delayed(pwq);
++ kick = true;
++ }
+
+ /*
+ * Need to kick a worker after thawed or an unbound wq's
+- * max_active is bumped. It's a slow path. Do it always.
++ * max_active is bumped. In realtime scenarios, always kicking a
++ * worker will cause interference on the isolated cpu cores, so
++ * let's kick iff work items were activated.
+ */
+- wake_up_worker(pwq->pool);
++ if (kick)
++ wake_up_worker(pwq->pool);
+ } else {
+ pwq->max_active = 0;
+ }
+--
+2.27.0
+
projects / thirdparty / kernel / stable-queue.git / commitdiff
