spi: stm32: clear only asserted irq flags on interrupt
Subsystems (14)
Sasha Levin
maintainerPATCH 1/54 spi: stm32: clear only asserted irq flags on interrupt
From: Tobias Schramm <[email protected]>
[ Upstream commit ae1ba50f1e706dfd7ce402ac52c1f1f10becad68 ]
Previously the stm32h7 interrupt thread cleared all non-masked interrupts. If an interrupt was to occur during the handling of another interrupt its flag would be unset, resulting in a lost interrupt.
This patches fixes the issue by clearing only the currently set interrupt flags.
--- drivers/spi/spi-stm32.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/spi/spi-stm32.c +1 -1
@@ -964,7 +964,7 @@ static irqreturn_t stm32h7_spi_irq_thread(int irq, void *dev_id)if (!spi->cur_usedma && (spi->rx_buf && (spi->rx_len >0 )))stm32h7_spi_read_rxfifo (spi, false); -writel_relaxed (mask, spi->base +STM32H7_SPI_IFCR ); +writel_relaxed (sr & mask, spi->base +STM32H7_SPI_IFCR );spin_unlock_irqrestore (&spi->lock, flags);
Signature · 7 lines
2.25.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Sasha Levin
maintainerPATCH 2/54 jbd2: make sure jh have b_transaction set in refile/unfile_buffer
From: Lukas Czerner <[email protected]>
[ Upstream commit 24dc9864914eb5813173cfa53313fcd02e4aea7d ]
Callers of __jbd2_journal_unfile_buffer() and __jbd2_journal_refile_buffer() assume that the b_transaction is set. In fact if it's not, we can end up with journal_head refcounting errors leading to crash much later that might be very hard to track down. Add asserts to make sure that is the case.
We also make sure that b_next_transaction is NULL in __jbd2_journal_unfile_buffer() since the callers expect that as well and we should not get into that stage in this state anyway, leading to problems later on if we do.
Tested with fstests.
--- fs/jbd2/transaction.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
fs/jbd2/transaction.c +10 -0
@@ -2026,6 +2026,9 @@ static void __jbd2_journal_temp_unlink_buffer(struct journal_head *jh)*/ static void __jbd2_journal_unfile_buffer (struct journal_head *jh) { +J_ASSERT_JH (jh, jh->b_transaction !=NULL ); +J_ASSERT_JH (jh, jh->b_next_transaction ==NULL ); +__jbd2_journal_temp_unlink_buffer (jh); jh->b_transaction =NULL ; }
@@ -2572,6 +2575,13 @@ bool __jbd2_journal_refile_buffer(struct journal_head *jh) was_dirty =test_clear_buffer_jbddirty (bh);__jbd2_journal_temp_unlink_buffer (jh); + +/* +* b_transaction must be set, otherwise the new b_transaction won't +* be holding jh reference +*/ +J_ASSERT_JH (jh, jh->b_transaction !=NULL ); +/* * We set b_transaction here because b_next_transaction will inherit * our jh reference and thus __jbd2_journal_file_buffer() must not
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 3/54 ext4: don't BUG on inconsistent journal feature
In reply to Sasha LevinFrom: Jan Kara <[email protected]>
[ Upstream commit 11215630aada28307ba555a43138db6ac54fa825 ]
A customer has reported a BUG_ON in ext4_clear_journal_err() hitting during an LTP testing. Either this has been caused by a test setup issue where the filesystem was being overwritten while LTP was mounting it or the journal replay has overwritten the superblock with invalid data. In either case it is preferable we don't take the machine down with a BUG_ON. So handle the situation of unexpectedly missing has_journal feature more gracefully. We issue warning and fail the mount in the cases where the race window is narrow and the failed check is most likely a programming error. In cases where fs corruption is more likely, we do full ext4_error() handling before failing mount / remount.
--- fs/ext4/super.c | 68 ++++++++++++++++++++++++++++++++++--------------- 1 file changed, 47 insertions(+), 21 deletions(-)
fs/ext4/super.c +47 -21
@@ -66,10 +66,10 @@ static int ext4_load_journal(struct super_block *, struct ext4_super_block *, unsigned long journal_devnum);static int ext4_show_options (struct seq_file *seq,struct dentry *root);static int ext4_commit_super (struct super_block *sb,int sync); -static void ext4_mark_recovery_complete (struct super_block *sb, +static int ext4_mark_recovery_complete (struct super_block *sb,struct ext4_super_block *es); -static void ext4_clear_journal_err (struct super_block *sb, -struct ext4_super_block *es); +static int ext4_clear_journal_err (struct super_block *sb, +struct ext4_super_block *es);static int ext4_sync_fs (struct super_block *sb,int wait);static int ext4_remount (struct super_block *sb,int *flags,char *data);static int ext4_statfs (struct dentry *dentry,struct kstatfs *buf);
@@ -4675,7 +4675,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)EXT4_SB (sb)->s_mount_state &= ~EXT4_ORPHAN_FS ;if (needs_recovery) {ext4_msg (sb,KERN_INFO ,"recovery complete" ); -ext4_mark_recovery_complete (sb, es); + err =ext4_mark_recovery_complete (sb, es); +if (err) + goto failed_mount8; }if (EXT4_SB (sb)->s_journal) {if (test_opt (sb,DATA_FLAGS ) ==EXT4_MOUNT_JOURNAL_DATA )
@@ -4718,10 +4720,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)ext4_msg (sb,KERN_ERR ,"VFS: Can't find ext4 filesystem" ); goto failed_mount; -#ifdef CONFIG_QUOTA failed_mount8:ext4_unregister_sysfs (sb); -#endif failed_mount7:ext4_unregister_li_request (sb); failed_mount6:
@@ -4860,7 +4860,8 @@ static journal_t *ext4_get_journal(struct super_block *sb,struct inode *journal_inode;journal_t *journal; -BUG_ON (!ext4_has_feature_journal (sb)); +if (WARN_ON_ONCE (!ext4_has_feature_journal (sb))) +return NULL ; journal_inode =ext4_get_journal_inode (sb, journal_inum);if (!journal_inode)
@@ -4890,7 +4891,8 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,struct ext4_super_block *es;struct block_device *bdev; -BUG_ON (!ext4_has_feature_journal (sb)); +if (WARN_ON_ONCE (!ext4_has_feature_journal (sb))) +return NULL ; bdev =ext4_blkdev_get (j_dev, sb);if (bdev ==NULL )
@@ -4982,7 +4984,8 @@ static int ext4_load_journal(struct super_block *sb,int err =0 ;int really_read_only; -BUG_ON (!ext4_has_feature_journal (sb)); +if (WARN_ON_ONCE (!ext4_has_feature_journal (sb))) +return -EFSCORRUPTED ;if (journal_devnum && journal_devnum !=le32_to_cpu (es->s_journal_dev)) {
@@ -5052,7 +5055,12 @@ static int ext4_load_journal(struct super_block *sb, }EXT4_SB (sb)->s_journal = journal; -ext4_clear_journal_err (sb, es); + err =ext4_clear_journal_err (sb, es); +if (err) { +EXT4_SB (sb)->s_journal =NULL ; +jbd2_journal_destroy (journal); +return err; + }if (!really_read_only && journal_devnum && journal_devnum !=le32_to_cpu (es->s_journal_dev)) {
@@ -5148,26 +5156,32 @@ static int ext4_commit_super(struct super_block *sb, int sync)* remounting) the filesystem readonly, then we will end up with a * consistent fs on disk. Record that fact. */ -static void ext4_mark_recovery_complete (struct super_block *sb, -struct ext4_super_block *es) +static int ext4_mark_recovery_complete (struct super_block *sb, +struct ext4_super_block *es) { +int err;journal_t *journal =EXT4_SB (sb)->s_journal;if (!ext4_has_feature_journal (sb)) { -BUG_ON (journal !=NULL ); -return ; +if (journal !=NULL ) { +ext4_error (sb,"Journal got removed while the fs was " +"mounted!" ); +return -EFSCORRUPTED ; + } +return 0 ; }jbd2_journal_lock_updates (journal); -if (jbd2_journal_flush (journal) <0 ) + err =jbd2_journal_flush (journal); +if (err <0 ) goto out;if (ext4_has_feature_journal_needs_recovery (sb) &&sb_rdonly (sb)) {ext4_clear_feature_journal_needs_recovery (sb);ext4_commit_super (sb,1 ); } - out:jbd2_journal_unlock_updates (journal); +return err; }/*
@@ -5175,14 +5189,17 @@ static void ext4_mark_recovery_complete(struct super_block *sb,* has recorded an error from a previous lifetime, move that error to the * main filesystem now. */ -static void ext4_clear_journal_err (struct super_block *sb, +static int ext4_clear_journal_err (struct super_block *sb,struct ext4_super_block *es) {journal_t *journal;int j_errno;const char *errstr; -BUG_ON (!ext4_has_feature_journal (sb)); +if (!ext4_has_feature_journal (sb)) { +ext4_error (sb,"Journal got removed while the fs was mounted!" ); +return -EFSCORRUPTED ; + } journal =EXT4_SB (sb)->s_journal;
@@ -5207,6 +5224,7 @@ static void ext4_clear_journal_err(struct super_block *sb,jbd2_journal_clear_err (journal);jbd2_journal_update_sb_errno (journal); } +return 0 ; }/*
@@ -5477,8 +5495,13 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) (sbi->s_mount_state & EXT4_VALID_FS)) es->s_state =cpu_to_le16 (sbi->s_mount_state); -if (sbi->s_journal) +if (sbi->s_journal) { +/* +* We let remount-ro finish even if marking fs +* as clean failed... +*/ ext4_mark_recovery_complete (sb, es); + }if (sbi->s_mmp_tsk)kthread_stop (sbi->s_mmp_tsk); }else {
@@ -5526,8 +5549,11 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)* been changed by e2fsck since we originally mounted * the partition.) */ -if (sbi->s_journal) -ext4_clear_journal_err (sb, es); +if (sbi->s_journal) { + err =ext4_clear_journal_err (sb, es); +if (err) + goto restore_opts; + } sbi->s_mount_state =le16_to_cpu (es->s_state); err =ext4_setup_super (sb, es,0 );
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 4/54 ext4: handle read only external journal device
In reply to Sasha LevinFrom: Lukas Czerner <[email protected]>
[ Upstream commit 273108fa5015eeffc4bacfa5ce272af3434b96e4 ]
Ext4 uses blkdev_get_by_dev() to get the block_device for journal device which does check to see if the read-only block device was opened read-only.
As a result ext4 will hapily proceed mounting the file system with external journal on read-only device. This is bad as we would not be able to use the journal leading to errors later on.
Instead of simply failing to mount file system in this case, treat it in a similar way we treat internal journal on read-only device. Allow to mount with -o noload in read-only mode.
This can be reproduced easily like this:
mke2fs -F -O journal_dev $JOURNAL_DEV 100M
mkfs.$FSTYPE -F -J device=$JOURNAL_DEV $FS_DEV
blockdev --setro $JOURNAL_DEV
mount $FS_DEV $MNT
touch $MNT/file
umount $MNT
leading to error like this
[ 1307.318713] ------------[ cut here ]------------ [ 1307.323362] generic_make_request: Trying to write to read-only block-device dm-2 (partno 0) [ 1307.331741] WARNING: CPU: 36 PID: 3224 at block/blk-core.c:855 generic_make_request_checks+0x2c3/0x580 [ 1307.341041] Modules linked in: ext4 mbcache jbd2 rfkill intel_rapl_msr intel_rapl_common isst_if_commd [ 1307.419445] CPU: 36 PID: 3224 Comm: jbd2/dm-2 Tainted: G W I 5.8.0-rc5 #2 [ 1307.427359] Hardware name: Dell Inc. PowerEdge R740/01KPX8, BIOS 2.3.10 08/15/2019 [ 1307.434932] RIP: 0010:generic_make_request_checks+0x2c3/0x580 [ 1307.440676] Code: 94 03 00 00 48 89 df 48 8d 74 24 08 c6 05 cf 2b 18 01 01 e8 7f a4 ff ff 48 c7 c7 50e [ 1307.459420] RSP: 0018:ffffc0d70eb5fb48 EFLAGS: 00010286 [ 1307.464646] RAX: 0000000000000000 RBX: ffff9b33b2978300 RCX: 0000000000000000 [ 1307.471780] RDX: ffff9b33e12a81e0 RSI: ffff9b33e1298000 RDI: ffff9b33e1298000 [ 1307.478913] RBP: ffff9b7b9679e0c0 R08: 0000000000000837 R09: 0000000000000024 [ 1307.486044] R10: 0000000000000000 R11: ffffc0d70eb5f9f0 R12: 0000000000000400 [ 1307.493177] R13: 0000000000000000 R14: 0000000000000001 R15: 0000000000000000 [ 1307.500308] FS: 0000000000000000(0000) GS:ffff9b33e1280000(0000) knlGS:0000000000000000 [ 1307.508396] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 1307.514142] CR2: 000055eaf4109000 CR3: 0000003dee40a006 CR4: 00000000007606e0 [ 1307.521273] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [ 1307.528407] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 [ 1307.535538] PKRU: 55555554 [ 1307.538250] Call Trace: [ 1307.540708] generic_make_request+0x30/0x340 [ 1307.544985] submit_bio+0x43/0x190 [ 1307.548393] ? bio_add_page+0x62/0x90 [ 1307.552068] submit_bh_wbc+0x16a/0x190 [ 1307.555833] jbd2_write_superblock+0xec/0x200 [jbd2] [ 1307.560803] jbd2_journal_update_sb_log_tail+0x65/0xc0 [jbd2] [ 1307.566557] jbd2_journal_commit_transaction+0x2ae/0x1860 [jbd2] [ 1307.572566] ? check_preempt_curr+0x7a/0x90 [ 1307.576756] ? update_curr+0xe1/0x1d0 [ 1307.580421] ? account_entity_dequeue+0x7b/0xb0 [ 1307.584955] ? newidle_balance+0x231/0x3d0 [ 1307.589056] ? __switch_to_asm+0x42/0x70 [ 1307.592986] ? __switch_to_asm+0x36/0x70 [ 1307.596918] ? lock_timer_base+0x67/0x80 [ 1307.600851] kjournald2+0xbd/0x270 [jbd2] [ 1307.604873] ? finish_wait+0x80/0x80 [ 1307.608460] ? commit_timeout+0x10/0x10 [jbd2] [ 1307.612915] kthread+0x114/0x130 [ 1307.616152] ? kthread_park+0x80/0x80 [ 1307.619816] ret_from_fork+0x22/0x30 [ 1307.623400] ---[ end trace 27490236265b1630 ]---
--- fs/ext4/super.c | 51 ++++++++++++++++++++++++++++++++----------------- 1 file changed, 33 insertions(+), 18 deletions(-)
fs/ext4/super.c +33 -18
@@ -4983,6 +4983,7 @@ static int ext4_load_journal(struct super_block *sb,dev_t journal_dev;int err =0 ;int really_read_only; +int journal_dev_ro;if (WARN_ON_ONCE (!ext4_has_feature_journal (sb)))return -EFSCORRUPTED ;
@@ -4995,7 +4996,31 @@ static int ext4_load_journal(struct super_block *sb, }else journal_dev =new_decode_dev (le32_to_cpu (es->s_journal_dev)); - really_read_only =bdev_read_only (sb->s_bdev); +if (journal_inum && journal_dev) { +ext4_msg (sb,KERN_ERR , +"filesystem has both journal inode and journal device!" ); +return -EINVAL ; + } + +if (journal_inum) { + journal =ext4_get_journal (sb, journal_inum); +if (!journal) +return -EINVAL ; + }else { + journal =ext4_get_dev_journal (sb, journal_dev); +if (!journal) +return -EINVAL ; + } + + journal_dev_ro =bdev_read_only (journal->j_dev); + really_read_only =bdev_read_only (sb->s_bdev) | journal_dev_ro; + +if (journal_dev_ro && !sb_rdonly (sb)) { +ext4_msg (sb,KERN_ERR , +"journal device read-only, try mounting with '-o ro'" ); + err = -EROFS ; + goto err_out; + }/* * Are we loading a blank journal or performing recovery after a
@@ -5010,27 +5035,14 @@ static int ext4_load_journal(struct super_block *sb,ext4_msg (sb,KERN_ERR ,"write access " "unavailable, cannot proceed " "(try mounting with noload)" ); -return -EROFS ; + err = -EROFS ; + goto err_out; }ext4_msg (sb,KERN_INFO ,"write access will " "be enabled during recovery" ); } } -if (journal_inum && journal_dev) { -ext4_msg (sb,KERN_ERR ,"filesystem has both journal " -"and inode journals!" ); -return -EINVAL ; - } - -if (journal_inum) { -if (!(journal =ext4_get_journal (sb, journal_inum))) -return -EINVAL ; - }else { -if (!(journal =ext4_get_dev_journal (sb, journal_dev))) -return -EINVAL ; - } -if (!(journal->j_flags &JBD2_BARRIER ))ext4_msg (sb,KERN_INFO ,"barriers disabled" );
@@ -5050,8 +5062,7 @@ static int ext4_load_journal(struct super_block *sb,if (err) {ext4_msg (sb,KERN_ERR ,"error loading journal" ); -jbd2_journal_destroy (journal); -return err; + goto err_out; }EXT4_SB (sb)->s_journal = journal;
@@ -5071,6 +5082,10 @@ static int ext4_load_journal(struct super_block *sb, }return 0 ; + +err_out: +jbd2_journal_destroy (journal); +return err; }static int ext4_commit_super (struct super_block *sb,int sync)
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 5/54 drm/virtio: fix memory leak in virtio_gpu_cleanup_object()
In reply to Sasha LevinFrom: Xin He <[email protected]>
[ Upstream commit 836b194d65782aaec4485a07d2aab52d3f698505 ]
Before setting shmem->pages to NULL, kfree() should be called.
--- drivers/gpu/drm/virtio/virtgpu_object.c | 1 + 1 file changed, 1 insertion(+)
drivers/gpu/drm/virtio/virtgpu_object.c +1 -0
@@ -79,6 +79,7 @@ void virtio_gpu_cleanup_object(struct virtio_gpu_object *bo) }sg_free_table (shmem->pages); +kfree (shmem->pages); shmem->pages =NULL ;drm_gem_shmem_unpin (&bo->base.base); }
Signature · 6 lines
2.25.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 6/54 ext4: abort the filesystem if failed to async write metadata buffer
In reply to Sasha LevinFrom: "zhangyi (F)" <[email protected]>
[ Upstream commit bc71726c725767205757821df364acff87f92ac5 ]
There is a risk of filesystem inconsistency if we failed to async write back metadata buffer in the background. Because of current buffer's end io procedure is handled by end_buffer_async_write() in the block layer, and it only clear the buffer's uptodate flag and mark the write_io_error flag, so ext4 cannot detect such failure immediately. In most cases of getting metadata buffer (e.g. ext4_read_inode_bitmap()), although the buffer's data is actually uptodate, it may still read data from disk because the buffer's uptodate flag has been cleared. Finally, it may lead to on-disk filesystem inconsistency if reading old data from the disk successfully and write them out again.
This patch detect bdev mapping->wb_err when getting journal's write access and mark the filesystem error if bdev's mapping->wb_err was increased, this could prevent further writing and potential inconsistency.
--- fs/ext4/ext4.h | 3 +++ fs/ext4/ext4_jbd2.c | 25 +++++++++++++++++++++++++ fs/ext4/super.c | 17 +++++++++++++++++ 3 files changed, 45 insertions(+)
fs/ext4/ext4.h +3 -0
@@ -1560,6 +1560,9 @@ struct ext4_sb_info {#ifdef CONFIG_EXT4_DEBUG unsigned long s_simulate_fail;#endif +/* Record the errseq of the backing block device */ +errseq_t s_bdev_wb_err; +spinlock_t s_bdev_wb_lock; };static inline struct ext4_sb_info *EXT4_SB (struct super_block *sb)
fs/ext4/ext4_jbd2.c +25 -0
@@ -195,6 +195,28 @@ static void ext4_journal_abort_handle(const char *caller, unsigned int line,jbd2_journal_abort_handle (handle); } +static void ext4_check_bdev_write_error (struct super_block *sb) +{ +struct address_space *mapping = sb->s_bdev->bd_inode->i_mapping; +struct ext4_sb_info *sbi =EXT4_SB (sb); +int err; + +/* +* If the block device has write error flag, it may have failed to +* async write out metadata buffers in the background. In this case, +* we could read old data from disk and write it out again, which +* may lead to on-disk filesystem inconsistency. +*/ +if (errseq_check (&mapping->wb_err,READ_ONCE (sbi->s_bdev_wb_err))) { +spin_lock (&sbi->s_bdev_wb_lock); + err =errseq_check_and_advance (&mapping->wb_err, &sbi->s_bdev_wb_err); +spin_unlock (&sbi->s_bdev_wb_lock); +if (err) +ext4_error_err (sb, -err, +"Error while async write back metadata" ); + } +} +int __ext4_journal_get_write_access (const char *where,unsigned int line,handle_t *handle,struct buffer_head *bh) {
@@ -202,6 +224,9 @@ int __ext4_journal_get_write_access(const char *where, unsigned int line,might_sleep (); +if (bh->b_bdev->bd_super) +ext4_check_bdev_write_error (bh->b_bdev->bd_super); +if (ext4_handle_valid (handle)) { err =jbd2_journal_get_write_access (handle, bh);if (err)
fs/ext4/super.c +17 -0
@@ -4670,6 +4670,15 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) }#endif /* CONFIG_QUOTA */ +/* +* Save the original bdev mapping's wb_err value which could be +* used to detect the metadata async write error. +*/ +spin_lock_init (&sbi->s_bdev_wb_lock); +if (!sb_rdonly (sb)) +errseq_check_and_advance (&sb->s_bdev->bd_inode->i_mapping->wb_err, + &sbi->s_bdev_wb_err); + sb->s_bdev->bd_super = sb;EXT4_SB (sb)->s_mount_state |=EXT4_ORPHAN_FS ;ext4_orphan_cleanup (sb, es);EXT4_SB (sb)->s_mount_state &= ~EXT4_ORPHAN_FS ;
@@ -5558,6 +5567,14 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) goto restore_opts; } +/* +* Update the original bdev mapping's wb_err value +* which could be used to detect the metadata async +* write error. +*/ +errseq_check_and_advance (&sb->s_bdev->bd_inode->i_mapping->wb_err, + &sbi->s_bdev_wb_err); +/* * Mounting a RDONLY partition read-write, so reread * and store the current valid flag. (It may have
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 7/54 jbd2: abort journal if free a async write error metadata buffer
In reply to Sasha LevinFrom: "zhangyi (F)" <[email protected]>
[ Upstream commit c044f3d8360d2ecf831ba2cc9f08cf9fb2c699fb ]
If we free a metadata buffer which has been failed to async write out in the background, the jbd2 checkpoint procedure will not detect this failure in jbd2_log_do_checkpoint(), so it may lead to filesystem inconsistency after cleanup journal tail. This patch abort the journal if free a buffer has write_io_error flag to prevent potential further inconsistency.
--- fs/jbd2/transaction.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
fs/jbd2/transaction.c +16 -0
@@ -2120,6 +2120,7 @@ int jbd2_journal_try_to_free_buffers(journal_t *journal, {struct buffer_head *head;struct buffer_head *bh; +bool has_write_io_error = false;int ret =0 ;J_ASSERT (PageLocked (page));
@@ -2144,11 +2145,26 @@ int jbd2_journal_try_to_free_buffers(journal_t *journal,jbd2_journal_put_journal_head (jh);if (buffer_jbd (bh)) goto busy; + +/* +* If we free a metadata buffer which has been failed to +* write out, the jbd2 checkpoint procedure will not detect +* this failure and may lead to filesystem inconsistency +* after cleanup journal tail. +*/ +if (buffer_write_io_error (bh)) { +pr_err ("JBD2: Error while async write back metadata bh %llu." , + (unsigned long long )bh->b_blocknr); + has_write_io_error = true; + } }while ((bh = bh->b_this_page) != head); ret =try_to_free_buffers (page); busy: +if (has_write_io_error) +jbd2_journal_abort (journal, -EIO ); +return ret; }
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 8/54 ext4: handle option set by mount flags correctly
In reply to Sasha LevinFrom: Lukas Czerner <[email protected]>
[ Upstream commit f25391ebb475d3ffb3aa61bb90e3594c841749ef ]
Currently there is a problem with mount options that can be both set by vfs using mount flags or by a string parsing in ext4.
i_version/iversion options gets lost after remount, for example
$ mount -o i_version /dev/pmem0 /mnt $ grep pmem0 /proc/self/mountinfo | grep i_version 310 95 259:0 / /mnt rw,relatime shared:163 - ext4 /dev/pmem0 rw,seclabel,i_version $ mount -o remount,ro /mnt $ grep pmem0 /proc/self/mountinfo | grep i_version
nolazytime gets ignored by ext4 on remount, for example
$ mount -o lazytime /dev/pmem0 /mnt $ grep pmem0 /proc/self/mountinfo | grep lazytime 310 95 259:0 / /mnt rw,relatime shared:163 - ext4 /dev/pmem0 rw,lazytime,seclabel $ mount -o remount,nolazytime /mnt $ grep pmem0 /proc/self/mountinfo | grep lazytime 310 95 259:0 / /mnt rw,relatime shared:163 - ext4 /dev/pmem0 rw,lazytime,seclabel
Fix it by applying the SB_LAZYTIME and SB_I_VERSION flags from *flags to s_flags before we parse the option and use the resulting state of the same flags in *flags at the end of successful remount.
--- fs/ext4/super.c | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-)
fs/ext4/super.c +16 -5
@@ -5391,7 +5391,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) {struct ext4_super_block *es;struct ext4_sb_info *sbi =EXT4_SB (sb); -unsigned long old_sb_flags; +unsigned long old_sb_flags, vfs_flags;struct ext4_mount_options old_opts;int enable_quota =0 ;ext4_group_t g;
@@ -5434,6 +5434,14 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)if (sbi->s_journal && sbi->s_journal->j_task->io_context) journal_ioprio = sbi->s_journal->j_task->io_context->ioprio; +/* +* Some options can be enabled by ext4 and/or by VFS mount flag +* either way we need to make sure it matches in both *flags and +* s_flags. Copy those selected flags from *flags to s_flags +*/ + vfs_flags =SB_LAZYTIME |SB_I_VERSION ; + sb->s_flags = (sb->s_flags & ~vfs_flags) | (*flags & vfs_flags); +if (!parse_options (data, sb,NULL , &journal_ioprio,1 )) { err = -EINVAL ; goto restore_opts;
@@ -5487,9 +5495,6 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)set_task_ioprio (sbi->s_journal->j_task, journal_ioprio); } -if (*flags &SB_LAZYTIME ) - sb->s_flags |=SB_LAZYTIME ; -if ((bool )(*flags &SB_RDONLY ) !=sb_rdonly (sb)) {if (sbi->s_mount_flags &EXT4_MF_FS_ABORTED ) { err = -EROFS ;
@@ -5637,7 +5642,13 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) }#endif - *flags = (*flags & ~SB_LAZYTIME ) | (sb->s_flags &SB_LAZYTIME ); +/* +* Some options can be enabled by ext4 and/or by VFS mount flag +* either way we need to make sure it matches in both *flags and +* s_flags. Copy those selected flags from s_flags to *flags +*/ + *flags = (*flags & ~vfs_flags) | (sb->s_flags & vfs_flags); +ext4_msg (sb,KERN_INFO ,"re-mounted. Opts: %s" , orig_data);kfree (orig_data);return 0 ;
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 9/54 ext4: handle error of ext4_setup_system_zone() on remount
In reply to Sasha LevinFrom: Jan Kara <[email protected]>
[ Upstream commit d176b1f62f242ab259ff665a26fbac69db1aecba ]
ext4_setup_system_zone() can fail. Handle the failure in ext4_remount().
--- fs/ext4/super.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
fs/ext4/super.c +4 -1
@@ -5620,7 +5620,10 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)ext4_register_li_request (sb, first_not_zeroed); } -ext4_setup_system_zone (sb); + err =ext4_setup_system_zone (sb); +if (err) + goto restore_opts; +if (sbi->s_journal ==NULL && !(old_sb_flags &SB_RDONLY )) { err =ext4_commit_super (sb,1 );if (err)
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 10/54 ext4: correctly restore system zone info when remount fails
In reply to Sasha LevinFrom: Jan Kara <[email protected]>
[ Upstream commit 0f5bde1db174f6c471f0bd27198575719dabe3e5 ]
When remounting filesystem fails late during remount handling and block_validity mount option is also changed during the remount, we fail to restore system zone information to a state matching the mount option. This is mostly harmless, just the block validity checking will not match the situation described by the mount option. Make sure these two are always consistent.
--- fs/ext4/block_validity.c | 8 -------- fs/ext4/super.c | 29 +++++++++++++++++++++-------- 2 files changed, 21 insertions(+), 16 deletions(-)
fs/ext4/block_validity.c +0 -8
@@ -262,14 +262,6 @@ int ext4_setup_system_zone(struct super_block *sb)int flex_size =ext4_flex_bg_size (sbi);int ret; -if (!test_opt (sb,BLOCK_VALIDITY )) { -if (sbi->system_blks) -ext4_release_system_zone (sb); -return 0 ; - } -if (sbi->system_blks) -return 0 ; - system_blks =kzalloc (sizeof (*system_blks),GFP_KERNEL );if (!system_blks)return -ENOMEM ;
fs/ext4/super.c +21 -8
@@ -4603,11 +4603,13 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)ext4_set_resv_clusters (sb); - err =ext4_setup_system_zone (sb); -if (err) { -ext4_msg (sb,KERN_ERR ,"failed to initialize system " -"zone (%d)" , err); - goto failed_mount4a; +if (test_opt (sb,BLOCK_VALIDITY )) { + err =ext4_setup_system_zone (sb); +if (err) { +ext4_msg (sb,KERN_ERR ,"failed to initialize system " +"zone (%d)" , err); + goto failed_mount4a; + } }ext4_ext_init (sb);
@@ -5620,9 +5622,16 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)ext4_register_li_request (sb, first_not_zeroed); } - err =ext4_setup_system_zone (sb); -if (err) - goto restore_opts; +/* +* Handle creation of system zone data early because it can fail. +* Releasing of existing data is done when we are sure remount will +* succeed. +*/ +if (test_opt (sb,BLOCK_VALIDITY ) && !sbi->system_blks) { + err =ext4_setup_system_zone (sb); +if (err) + goto restore_opts; + }if (sbi->s_journal ==NULL && !(old_sb_flags &SB_RDONLY )) { err =ext4_commit_super (sb,1 );
@@ -5644,6 +5653,8 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) } }#endif +if (!test_opt (sb,BLOCK_VALIDITY ) && sbi->system_blks) +ext4_release_system_zone (sb);/* * Some options can be enabled by ext4 and/or by VFS mount flag
@@ -5665,6 +5676,8 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data) sbi->s_commit_interval = old_opts.s_commit_interval; sbi->s_min_batch_time = old_opts.s_min_batch_time; sbi->s_max_batch_time = old_opts.s_max_batch_time; +if (!test_opt (sb,BLOCK_VALIDITY ) && sbi->system_blks) +ext4_release_system_zone (sb);#ifdef CONFIG_QUOTA sbi->s_jquota_fmt = old_opts.s_jquota_fmt;for (i =0 ; i <EXT4_MAXQUOTAS ; i++) {
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 11/54 fs: prevent BUG_ON in submit_bh_wbc()
In reply to Sasha LevinFrom: Xianting Tian <[email protected]>
[ Upstream commit 377254b2cd2252c7c3151b113cbdf93a7736c2e9 ]
If a device is hot-removed --- for example, when a physical device is unplugged from pcie slot or a nbd device's network is shutdown --- this can result in a BUG_ON() crash in submit_bh_wbc(). This is because the when the block device dies, the buffer heads will have their Buffer_Mapped flag get cleared, leading to the crash in submit_bh_wbc.
We had attempted to work around this problem in commit a17712c8 ("ext4: check superblock mapped prior to committing"). Unfortunately, it's still possible to hit the BUG_ON(!buffer_mapped(bh)) if the device dies between when the work-around check in ext4_commit_super() and when submit_bh_wbh() is finally called:
Code path:ext4_commit_super
judge if 'buffer_mapped(sbh)' is false, return <== commit a17712c8
lock_buffer(sbh)
...
unlock_buffer(sbh)
__sync_dirty_buffer(sbh,...
lock_buffer(sbh)
judge if 'buffer_mapped(sbh))' is false, return <== added by this patch
submit_bh(...,sbh)
submit_bh_wbc(...,sbh,...)[100722.966497] kernel BUG at fs/buffer.c:3095! <== BUG_ON(!buffer_mapped(bh))' in submit_bh_wbc() [100722.966503] invalid opcode: 0000 [#1] SMP [100722.966566] task: ffff8817e15a9e40 task.stack: ffffc90024744000 [100722.966574] RIP: 0010:submit_bh_wbc+0x180/0x190 [100722.966575] RSP: 0018:ffffc90024747a90 EFLAGS: 00010246 [100722.966576] RAX: 0000000000620005 RBX: ffff8818a80603a8 RCX: 0000000000000000 [100722.966576] RDX: ffff8818a80603a8 RSI: 0000000000020800 RDI: 0000000000000001 [100722.966577] RBP: ffffc90024747ac0 R08: 0000000000000000 R09: ffff88207f94170d [100722.966578] R10: 00000000000437c8 R11: 0000000000000001 R12: 0000000000020800 [100722.966578] R13: 0000000000000001 R14: 000000000bf9a438 R15: ffff88195f333000 [100722.966580] FS: 00007fa2eee27700(0000) GS:ffff88203d840000(0000) knlGS:0000000000000000 [100722.966580] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [100722.966581] CR2: 0000000000f0b008 CR3: 000000201a622003 CR4: 00000000007606e0 [100722.966582] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 [100722.966583] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 [100722.966583] PKRU: 55555554 [100722.966583] Call Trace: [100722.966588] __sync_dirty_buffer+0x6e/0xd0 [100722.966614] ext4_commit_super+0x1d8/0x290 [ext4] [100722.966626] __ext4_std_error+0x78/0x100 [ext4] [100722.966635] ? __ext4_journal_get_write_access+0xca/0x120 [ext4] [100722.966646] ext4_reserve_inode_write+0x58/0xb0 [ext4] [100722.966655] ? ext4_dirty_inode+0x48/0x70 [ext4] [100722.966663] ext4_mark_inode_dirty+0x53/0x1e0 [ext4] [100722.966671] ? __ext4_journal_start_sb+0x6d/0xf0 [ext4] [100722.966679] ext4_dirty_inode+0x48/0x70 [ext4] [100722.966682] __mark_inode_dirty+0x17f/0x350 [100722.966686] generic_update_time+0x87/0xd0 [100722.966687] touch_atime+0xa9/0xd0 [100722.966690] generic_file_read_iter+0xa09/0xcd0 [100722.966694] ? page_cache_tree_insert+0xb0/0xb0 [100722.966704] ext4_file_read_iter+0x4a/0x100 [ext4] [100722.966707] ? __inode_security_revalidate+0x4f/0x60 [100722.966709] __vfs_read+0xec/0x160 [100722.966711] vfs_read+0x8c/0x130 [100722.966712] SyS_pread64+0x87/0xb0 [100722.966716] do_syscall_64+0x67/0x1b0 [100722.966719] entry_SYSCALL64_slow_path+0x25/0x25
To address this, add the check of 'buffer_mapped(bh)' to __sync_dirty_buffer(). This also has the benefit of fixing this for other file systems.
With this addition, we can drop the workaround in ext4_commit_supper().
[ Commit description rewritten by tytso. ]
--- fs/buffer.c | 9 +++++++++ fs/ext4/super.c | 7 ------- 2 files changed, 9 insertions(+), 7 deletions(-)
fs/buffer.c +9 -0
@@ -3161,6 +3161,15 @@ int __sync_dirty_buffer(struct buffer_head *bh, int op_flags)WARN_ON (atomic_read (&bh->b_count) <1 );lock_buffer (bh);if (test_clear_buffer_dirty (bh)) { +/* +* The bh should be mapped, but it might not be if the +* device was hot-removed. Not much we can do but fail the I/O. +*/ +if (!buffer_mapped (bh)) { +unlock_buffer (bh); +return -EIO ; + } +get_bh (bh); bh->b_end_io = end_buffer_write_sync; ret =submit_bh (REQ_OP_WRITE , op_flags, bh);
fs/ext4/super.c +0 -7
@@ -5108,13 +5108,6 @@ static int ext4_commit_super(struct super_block *sb, int sync)if (!sbh ||block_device_ejected (sb))return error; -/* -* The superblock bh should be mapped, but it might not be if the -* device was hot-removed. Not much we can do but fail the I/O. -*/ -if (!buffer_mapped (sbh)) -return error; -/* * If the file system is mounted read-only, don't update the * superblock write time. This avoids updating the superblock
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 12/54 spi: stm32h7: fix race condition at end of transfer
In reply to Sasha LevinFrom: Antonio Borneo <[email protected]>
[ Upstream commit 135dd873d3c76d812ae64c668adef3f2c59ed27f ]
The caller of stm32_spi_transfer_one(), spi_transfer_one_message(), is waiting for us to call spi_finalize_current_transfer() and will eventually schedule a new transfer, if available.
We should guarantee that the spi controller is really available before calling spi_finalize_current_transfer().
Move the call to spi_finalize_current_transfer() _after_ the call to stm32_spi_disable().
--- drivers/spi/spi-stm32.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/spi/spi-stm32.c +1 -1
@@ -969,8 +969,8 @@ static irqreturn_t stm32h7_spi_irq_thread(int irq, void *dev_id)spin_unlock_irqrestore (&spi->lock, flags);if (end) { -spi_finalize_current_transfer (master);stm32h7_spi_disable (spi); +spi_finalize_current_transfer (master); }return IRQ_HANDLED ;
Signature · 7 lines
2.25.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Sasha Levin
maintainerPATCH 13/54 spi: stm32: fix fifo threshold level in case of short transfer
In reply to Sasha LevinFrom: Amelie Delaunay <[email protected]>
[ Upstream commit 3373e9004acc0603242622b4378c64bc01d21b5f ]
When transfer is shorter than half of the fifo, set the data packet size up to transfer size instead of up to half of the fifo.
Check also that threshold is set at least to 1 data frame.
--- drivers/spi/spi-stm32.c | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-)
drivers/spi/spi-stm32.c +18 -8
@@ -467,20 +467,27 @@ static int stm32_spi_prepare_mbr(struct stm32_spi *spi, u32 speed_hz,/** * stm32h7_spi_prepare_fthlv - Determine FIFO threshold level * @spi: pointer to the spi controller data structure +* @xfer_len: length of the message to be transferred */ -static u32 stm32h7_spi_prepare_fthlv (struct stm32_spi *spi) +static u32 stm32h7_spi_prepare_fthlv (struct stm32_spi *spi,u32 xfer_len) { -u32 fthlv, half_fifo; +u32 fthlv, half_fifo, packet;/* data packet should not exceed 1/2 of fifo space */ half_fifo = (spi->fifo_size /2 ); +/* data_packet should not exceed transfer length */ +if (half_fifo > xfer_len) + packet = xfer_len; +else + packet = half_fifo; +if (spi->cur_bpw <=8 ) - fthlv = half_fifo; + fthlv = packet;else if (spi->cur_bpw <=16 ) - fthlv = half_fifo /2 ; + fthlv = packet /2 ;else - fthlv = half_fifo /4 ; + fthlv = packet /4 ;/* align packet size with data registers access */ if (spi->cur_bpw >8 )
@@ -488,6 +495,9 @@ static u32 stm32h7_spi_prepare_fthlv(struct stm32_spi *spi)else fthlv -= (fthlv %4 );/* multiple of 4 */ +if (!fthlv) + fthlv =1 ; +return fthlv; }
@@ -1389,7 +1399,7 @@ static void stm32h7_spi_set_bpw(struct stm32_spi *spi) cfg1_setb |= (bpw <<STM32H7_SPI_CFG1_DSIZE_SHIFT ) &STM32H7_SPI_CFG1_DSIZE ; - spi->cur_fthlv =stm32h7_spi_prepare_fthlv (spi); + spi->cur_fthlv =stm32h7_spi_prepare_fthlv (spi, spi->cur_xferlen); fthlv = spi->cur_fthlv -1 ; cfg1_clrb |=STM32H7_SPI_CFG1_FTHLV ;
@@ -1578,6 +1588,8 @@ static int stm32_spi_transfer_one_setup(struct stm32_spi *spi,spin_lock_irqsave (&spi->lock, flags); + spi->cur_xferlen = transfer->len; +if (spi->cur_bpw != transfer->bits_per_word) { spi->cur_bpw = transfer->bits_per_word; spi->cfg->set_bpw (spi);
@@ -1625,8 +1637,6 @@ static int stm32_spi_transfer_one_setup(struct stm32_spi *spi, goto out; } - spi->cur_xferlen = transfer->len; -dev_dbg (spi->dev,"transfer communication mode set to %d\n" , spi->cur_comm); dev_dbg(spi->dev,
Signature · 7 lines
2.25.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Sasha Levin
maintainerPATCH 14/54 spi: stm32: fix stm32_spi_prepare_mbr in case of odd clk_rate
In reply to Sasha LevinFrom: Amelie Delaunay <[email protected]>
[ Upstream commit 9cc61973bf9385b19ff5dda4a2a7e265fcba85e4 ]
Fix spi->clk_rate when it is odd to the nearest lowest even value because minimum SPI divider is 2.
--- drivers/spi/spi-stm32.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/spi/spi-stm32.c +2 -1
@@ -441,7 +441,8 @@ static int stm32_spi_prepare_mbr(struct stm32_spi *spi, u32 speed_hz, {u32 div, mbrdiv; - div =DIV_ROUND_UP (spi->clk_rate, speed_hz); +/* Ensure spi->clk_rate is even */ + div =DIV_ROUND_UP (spi->clk_rate & ~0x1 , speed_hz);/* * SPI framework set xfer->speed_hz to master->max_speed_hz if
Signature · 7 lines
2.25.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Sasha Levin
maintainerPATCH 15/54 spi: stm32: always perform registers configuration prior to transfer
In reply to Sasha LevinFrom: Alain Volmat <[email protected]>
[ Upstream commit 60ccb3515fc61a0124c70aa37317f75b67560024 ]
SPI registers content may have been lost upon suspend/resume sequence. So, always compute and apply the necessary configuration in stm32_spi_transfer_one_setup routine.
--- drivers/spi/spi-stm32.c | 42 +++++++++++++++++------------------------ 1 file changed, 17 insertions(+), 25 deletions(-)
drivers/spi/spi-stm32.c +17 -25
@@ -1586,41 +1586,33 @@ static int stm32_spi_transfer_one_setup(struct stm32_spi *spi,unsigned long flags;unsigned int comm_type;int nb_words, ret =0 ; +int mbr;spin_lock_irqsave (&spi->lock, flags); spi->cur_xferlen = transfer->len; -if (spi->cur_bpw != transfer->bits_per_word) { - spi->cur_bpw = transfer->bits_per_word; - spi->cfg->set_bpw (spi); - } - -if (spi->cur_speed != transfer->speed_hz) { -int mbr; - -/* Update spi->cur_speed with real clock speed */ - mbr =stm32_spi_prepare_mbr (spi, transfer->speed_hz, - spi->cfg->baud_rate_div_min, - spi->cfg->baud_rate_div_max); -if (mbr <0 ) { - ret = mbr; - goto out; - } + spi->cur_bpw = transfer->bits_per_word; + spi->cfg->set_bpw (spi); - transfer->speed_hz = spi->cur_speed; -stm32_spi_set_mbr (spi, mbr); +/* Update spi->cur_speed with real clock speed */ + mbr =stm32_spi_prepare_mbr (spi, transfer->speed_hz, + spi->cfg->baud_rate_div_min, + spi->cfg->baud_rate_div_max); +if (mbr <0 ) { + ret = mbr; + goto out; } - comm_type =stm32_spi_communication_type (spi_dev, transfer); -if (spi->cur_comm != comm_type) { - ret = spi->cfg->set_mode (spi, comm_type); + transfer->speed_hz = spi->cur_speed; +stm32_spi_set_mbr (spi, mbr); -if (ret <0 ) - goto out; + comm_type =stm32_spi_communication_type (spi_dev, transfer); + ret = spi->cfg->set_mode (spi, comm_type); +if (ret <0 ) + goto out; - spi->cur_comm = comm_type; - } + spi->cur_comm = comm_type;if (spi->cfg->set_data_idleness) spi->cfg->set_data_idleness (spi, transfer->len);
Signature · 7 lines
2.25.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Sasha Levin
maintainerPATCH 16/54 drm/amd/powerplay: correct Vega20 cached smu feature state
In reply to Sasha LevinFrom: Evan Quan <[email protected]>
[ Upstream commit 266d81d9eed30f4994d76a2b237c63ece062eefe ]
Correct the cached smu feature state on pp_features sysfs setting.
--- .../drm/amd/powerplay/hwmgr/vega20_hwmgr.c | 38 +++++++++---------- 1 file changed, 19 insertions(+), 19 deletions(-)
drivers/gpu/drm/amd/powerplay/hwmgr/vega20_hwmgr.c +19 -19
@@ -985,27 +985,15 @@ static int vega20_disable_all_smu_features(struct pp_hwmgr *hwmgr) {struct vega20_hwmgr *data = (struct vega20_hwmgr *)(hwmgr->backend); -uint64_t features_enabled; -int i; -bool enabled; -int ret =0 ; +int i, ret =0 ;PP_ASSERT_WITH_CODE ((ret =smum_send_msg_to_smc (hwmgr, PPSMC_MSG_DisableAllSmuFeatures)) ==0 ,"[DisableAllSMUFeatures] Failed to disable all smu features!" , return ret); - ret =vega20_get_enabled_smc_features (hwmgr, &features_enabled); -PP_ASSERT_WITH_CODE (!ret, -"[DisableAllSMUFeatures] Failed to get enabled smc features!" , - return ret); - -for (i =0 ; i <GNLD_FEATURES_MAX ; i++) { - enabled = (features_enabled & data->smu_features[i].smu_feature_bitmap) ? - true : false; - data->smu_features[i].enabled = enabled; - data->smu_features[i].supported = enabled; - } +for (i =0 ; i <GNLD_FEATURES_MAX ; i++) + data->smu_features[i].enabled =0 ;return 0 ; }
@@ -3215,10 +3203,11 @@ static int vega20_get_ppfeature_status(struct pp_hwmgr *hwmgr, char *buf)static int vega20_set_ppfeature_status (struct pp_hwmgr *hwmgr,uint64_t new_ppfeature_masks) { -uint64_t features_enabled; -uint64_t features_to_enable; -uint64_t features_to_disable; -int ret =0 ; +struct vega20_hwmgr *data = + (struct vega20_hwmgr *)(hwmgr->backend); +uint64_t features_enabled, features_to_enable, features_to_disable; +int i, ret =0 ; +bool enabled;if (new_ppfeature_masks >= (1ULL <<GNLD_FEATURES_MAX ))return -EINVAL ;
@@ -3247,6 +3236,17 @@ static int vega20_set_ppfeature_status(struct pp_hwmgr *hwmgr, uint64_t new_ppfereturn ret; } +/* Update the cached feature enablement state */ + ret =vega20_get_enabled_smc_features (hwmgr, &features_enabled); +if (ret) +return ret; + +for (i =0 ; i <GNLD_FEATURES_MAX ; i++) { + enabled = (features_enabled & data->smu_features[i].smu_feature_bitmap) ? + true : false; + data->smu_features[i].enabled = enabled; + } +return 0 ; }
Signature · 6 lines
2.25.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Sasha Levin
maintainerPATCH 17/54 drm/amd/powerplay: correct UVD/VCE PG state on custom pptable uploading
In reply to Sasha LevinFrom: Evan Quan <[email protected]>
[ Upstream commit 2c5b8080d810d98e3e59617680218499b17c84a1 ]
The UVD/VCE PG state is managed by UVD and VCE IP. It's error-prone to assume the bootup state in SMU based on the dpm status.
--- drivers/gpu/drm/amd/powerplay/hwmgr/vega20_hwmgr.c | 6 ------ 1 file changed, 6 deletions(-)
drivers/gpu/drm/amd/powerplay/hwmgr/vega20_hwmgr.c +0 -6
@@ -1644,12 +1644,6 @@ static void vega20_init_powergate_state(struct pp_hwmgr *hwmgr) data->uvd_power_gated = true; data->vce_power_gated = true; - -if (data->smu_features[GNLD_DPM_UVD ].enabled) - data->uvd_power_gated = false; - -if (data->smu_features[GNLD_DPM_VCE ].enabled) - data->vce_power_gated = false; }static int vega20_enable_dpm_tasks (struct pp_hwmgr *hwmgr)
Signature · 6 lines
2.25.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Sasha Levin
maintainerPATCH 18/54 drm/amd/display: Fix LFC multiplier changing erratically
In reply to Sasha LevinFrom: Anthony Koo <[email protected]>
[ Upstream commit e4ed4dbbc8383d42a197da8fe7ca6434b0f14def ]
[Why]
1. There is a calculation that is using frame_time_in_us instead of last_render_time_in_us to calculate whether choosing an LFC multiplier would cause the inserted frame duration to be outside of range.
2. We do not handle unsigned integer subtraction correctly and it underflows to a really large value, which causes some logic errors.
[How]
1. Fix logic to calculate 'within range' using last_render_time_in_us
2. Split out delta_from_mid_point_delta_in_us calculation to ensure we don't underflow and wrap around
--- .../amd/display/modules/freesync/freesync.c | 36 +++++++++++++++---- 1 file changed, 29 insertions(+), 7 deletions(-)
drivers/gpu/drm/amd/display/modules/freesync/freesync.c +29 -7
@@ -324,22 +324,44 @@ static void apply_below_the_range(struct core_freesync *core_freesync,/* Choose number of frames to insert based on how close it * can get to the mid point of the variable range. +* - Delta for CEIL: delta_from_mid_point_in_us_1 +* - Delta for FLOOR: delta_from_mid_point_in_us_2 */ -if ((frame_time_in_us / mid_point_frames_ceil) > in_out_vrr->min_duration_in_us && - (delta_from_mid_point_in_us_1 < delta_from_mid_point_in_us_2 || - mid_point_frames_floor <2 )) { +if ((last_render_time_in_us / mid_point_frames_ceil) < in_out_vrr->min_duration_in_us) { +/* Check for out of range. +* If using CEIL produces a value that is out of range, +* then we are forced to use FLOOR. +*/ + frames_to_insert = mid_point_frames_floor; + }else if (mid_point_frames_floor <2 ) { +/* Check if FLOOR would result in non-LFC. In this case +* choose to use CEIL +*/ + frames_to_insert = mid_point_frames_ceil; + }else if (delta_from_mid_point_in_us_1 < delta_from_mid_point_in_us_2) { +/* If choosing CEIL results in a frame duration that is +* closer to the mid point of the range. +* Choose CEIL +*/ frames_to_insert = mid_point_frames_ceil; - delta_from_mid_point_delta_in_us = delta_from_mid_point_in_us_2 - - delta_from_mid_point_in_us_1; }else { +/* If choosing FLOOR results in a frame duration that is +* closer to the mid point of the range. +* Choose FLOOR +*/ frames_to_insert = mid_point_frames_floor; - delta_from_mid_point_delta_in_us = delta_from_mid_point_in_us_1 - - delta_from_mid_point_in_us_2; }/* Prefer current frame multiplier when BTR is enabled unless it drifts * too far from the midpoint */ +if (delta_from_mid_point_in_us_1 < delta_from_mid_point_in_us_2) { + delta_from_mid_point_delta_in_us = delta_from_mid_point_in_us_2 - + delta_from_mid_point_in_us_1; + }else { + delta_from_mid_point_delta_in_us = delta_from_mid_point_in_us_1 - + delta_from_mid_point_in_us_2; + }if (in_out_vrr->btr.frames_to_insert !=0 && delta_from_mid_point_delta_in_us <BTR_DRIFT_MARGIN ) { if (((last_render_time_in_us / in_out_vrr->btr.frames_to_insert) <
Signature · 6 lines
2.25.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 19/54 drm/amd/display: Switch to immediate mode for updating infopackets
In reply to Sasha LevinFrom: Anthony Koo <[email protected]>
[ Upstream commit abba907c7a20032c2d504fd5afe3af7d440a09d0 ]
[Why]
Using FRAME_UPDATE will result in infopacket to be potentially updated one frame late.
In commit stream scenarios for previously active stream, some stale infopacket data from previous config might be erroneously sent out on initial frame after stream is re-enabled.
[How]
Switch to using IMMEDIATE_UPDATE mode
--- .../amd/display/dc/dcn10/dcn10_stream_encoder.c | 16 ++++++++-------- .../amd/display/dc/dcn10/dcn10_stream_encoder.h | 14 ++++++++++++++ 2 files changed, 22 insertions(+), 8 deletions(-)
drivers/gpu/drm/amd/display/dc/dcn10/dcn10_stream_encoder.c +8 -8
@@ -121,35 +121,35 @@ void enc1_update_generic_info_packet(switch (packet_index) {case 0 :REG_UPDATE (AFMT_VBI_PACKET_CONTROL1 , -AFMT_GENERIC0_FRAME_UPDATE ,1 ); +AFMT_GENERIC0_IMMEDIATE_UPDATE ,1 );break ;case 1 :REG_UPDATE (AFMT_VBI_PACKET_CONTROL1 , -AFMT_GENERIC1_FRAME_UPDATE ,1 ); +AFMT_GENERIC1_IMMEDIATE_UPDATE ,1 );break ;case 2 :REG_UPDATE (AFMT_VBI_PACKET_CONTROL1 , -AFMT_GENERIC2_FRAME_UPDATE ,1 ); +AFMT_GENERIC2_IMMEDIATE_UPDATE ,1 );break ;case 3 :REG_UPDATE (AFMT_VBI_PACKET_CONTROL1 , -AFMT_GENERIC3_FRAME_UPDATE ,1 ); +AFMT_GENERIC3_IMMEDIATE_UPDATE ,1 );break ;case 4 :REG_UPDATE (AFMT_VBI_PACKET_CONTROL1 , -AFMT_GENERIC4_FRAME_UPDATE ,1 ); +AFMT_GENERIC4_IMMEDIATE_UPDATE ,1 );break ;case 5 :REG_UPDATE (AFMT_VBI_PACKET_CONTROL1 , -AFMT_GENERIC5_FRAME_UPDATE ,1 ); +AFMT_GENERIC5_IMMEDIATE_UPDATE ,1 );break ;case 6 :REG_UPDATE (AFMT_VBI_PACKET_CONTROL1 , -AFMT_GENERIC6_FRAME_UPDATE ,1 ); +AFMT_GENERIC6_IMMEDIATE_UPDATE ,1 );break ;case 7 :REG_UPDATE (AFMT_VBI_PACKET_CONTROL1 , -AFMT_GENERIC7_FRAME_UPDATE ,1 ); +AFMT_GENERIC7_IMMEDIATE_UPDATE ,1 );break ;default :break ;
drivers/gpu/drm/amd/display/dc/dcn10/dcn10_stream_encoder.h +14 -0
@@ -273,7 +273,14 @@ struct dcn10_stream_enc_registers {SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC2_FRAME_UPDATE , mask_sh),\SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC3_FRAME_UPDATE , mask_sh),\SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC4_FRAME_UPDATE , mask_sh),\ +SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC0_IMMEDIATE_UPDATE , mask_sh),\ +SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC1_IMMEDIATE_UPDATE , mask_sh),\ +SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC2_IMMEDIATE_UPDATE , mask_sh),\ +SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC3_IMMEDIATE_UPDATE , mask_sh),\SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC4_IMMEDIATE_UPDATE , mask_sh),\ +SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC5_IMMEDIATE_UPDATE , mask_sh),\ +SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC6_IMMEDIATE_UPDATE , mask_sh),\ +SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC7_IMMEDIATE_UPDATE , mask_sh),\SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC5_FRAME_UPDATE , mask_sh),\SE_SF (DIG0_AFMT_VBI_PACKET_CONTROL1 ,AFMT_GENERIC6_FRAME_UPDATE , mask_sh),\ SE_SF(DIG0_AFMT_VBI_PACKET_CONTROL1, AFMT_GENERIC7_FRAME_UPDATE, mask_sh),\
@@ -337,7 +344,14 @@ struct dcn10_stream_enc_registers {type AFMT_GENERIC2_FRAME_UPDATE ;\type AFMT_GENERIC3_FRAME_UPDATE ;\type AFMT_GENERIC4_FRAME_UPDATE ;\ +type AFMT_GENERIC0_IMMEDIATE_UPDATE ;\ +type AFMT_GENERIC1_IMMEDIATE_UPDATE ;\ +type AFMT_GENERIC2_IMMEDIATE_UPDATE ;\ +type AFMT_GENERIC3_IMMEDIATE_UPDATE ;\type AFMT_GENERIC4_IMMEDIATE_UPDATE ;\ +type AFMT_GENERIC5_IMMEDIATE_UPDATE ;\ +type AFMT_GENERIC6_IMMEDIATE_UPDATE ;\ +type AFMT_GENERIC7_IMMEDIATE_UPDATE ;\type AFMT_GENERIC5_FRAME_UPDATE ;\type AFMT_GENERIC6_FRAME_UPDATE ;\type AFMT_GENERIC7_FRAME_UPDATE ;\
Signature · 6 lines
2.25.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Sasha Levin
maintainerPATCH 20/54 selftests/bpf: Fix segmentation fault in test_progs
In reply to Sasha LevinFrom: Jianlin Lv <[email protected]>
[ Upstream commit 0390c429dbed4068bd2cd8dded937d9a5ec24cd2 ]
test_progs reports the segmentation fault as below:
$ sudo ./test_progs -t mmap --verbose test_mmap:PASS:skel_open_and_load 0 nsec [...] test_mmap:PASS:adv_mmap1 0 nsec test_mmap:PASS:adv_mmap2 0 nsec test_mmap:PASS:adv_mmap3 0 nsec test_mmap:PASS:adv_mmap4 0 nsec Segmentation fault
This issue was triggered because mmap() and munmap() used inconsistent length parameters; mmap() creates a new mapping of 3 * page_size, but the length parameter set in the subsequent re-map and munmap() functions is 4 * page_size; this leads to the destruction of the process space.
To fix this issue, first create 4 pages of anonymous mapping, then do all the mmap() with MAP_FIXED.
Another issue is that when unmap the second page fails, the length parameter to delete tmp1 mappings should be 4 * page_size.
--- tools/testing/selftests/bpf/prog_tests/mmap.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)
tools/testing/selftests/bpf/prog_tests/mmap.c +13 -6
@@ -21,7 +21,7 @@ void test_mmap(void)const long page_size =sysconf (_SC_PAGE_SIZE);int err, duration =0 , i, data_map_fd, data_map_id, tmp_fd, rdmap_fd;struct bpf_map *data_map, *bss_map; -void *bss_mmaped =NULL , *map_mmaped =NULL , *tmp1, *tmp2; +void *bss_mmaped =NULL , *map_mmaped =NULL , *tmp0, *tmp1, *tmp2;struct test_mmap__bss *bss_data;struct bpf_map_info map_info;__u32 map_info_sz =sizeof (map_info);
@@ -183,16 +183,23 @@ void test_mmap(void)/* check some more advanced mmap() manipulations */ + tmp0 =mmap (NULL ,4 * page_size,PROT_READ ,MAP_SHARED |MAP_ANONYMOUS , +-1 ,0 ); +if (CHECK (tmp0 ==MAP_FAILED ,"adv_mmap0" ,"errno %d\n" , errno)) + goto cleanup; +/* map all but last page: pages 1-3 mapped */ - tmp1 =mmap (NULL ,3 * page_size,PROT_READ ,MAP_SHARED , + tmp1 =mmap (tmp0,3 * page_size,PROT_READ ,MAP_SHARED |MAP_FIXED , data_map_fd,0 ); -if (CHECK (tmp1 ==MAP_FAILED ,"adv_mmap1" ,"errno %d\n" , errno)) +if (CHECK (tmp0 != tmp1,"adv_mmap1" ,"tmp0: %p, tmp1: %p\n" , tmp0, tmp1)) { +munmap (tmp0,4 * page_size); goto cleanup; + }/* unmap second page: pages 1, 3 mapped */ err =munmap (tmp1 + page_size, page_size);if (CHECK (err,"adv_mmap2" ,"errno %d\n" , errno)) { -munmap (tmp1, map_sz); +munmap (tmp1,4 * page_size); goto cleanup; }
@@ -201,7 +208,7 @@ void test_mmap(void) MAP_SHARED | MAP_FIXED, data_map_fd, 0);if (CHECK (tmp2 ==MAP_FAILED ,"adv_mmap3" ,"errno %d\n" , errno)) {munmap (tmp1, page_size); -munmap (tmp1 +2 *page_size, page_size); +munmap (tmp1 +2 *page_size,2 * page_size); goto cleanup; } CHECK(tmp1 + page_size != tmp2, "adv_mmap4",
@@ -211,7 +218,7 @@ void test_mmap(void) tmp2 =mmap (tmp1,4 * page_size,PROT_READ ,MAP_SHARED |MAP_FIXED , data_map_fd,0 );if (CHECK (tmp2 ==MAP_FAILED ,"adv_mmap5" ,"errno %d\n" , errno)) { -munmap (tmp1,3 * page_size);/* unmap page 1 */ +munmap (tmp1,4 * page_size);/* unmap page 1 */ goto cleanup; }CHECK (tmp1 != tmp2,"adv_mmap6" ,"tmp1: %p, tmp2: %p\n" , tmp1, tmp2);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 21/54 libbpf: Handle GCC built-in types for Arm NEON
In reply to Sasha LevinFrom: Jean-Philippe Brucker <[email protected]>
[ Upstream commit 702eddc77a905782083b14ccd05b23840675fd18 ]
When building Arm NEON (SIMD) code from lib/raid6/neon.uc, GCC emits DWARF information using a base type "__Poly8_t", which is internal to GCC and not recognized by Clang. This causes build failures when building with Clang a vmlinux.h generated from an arm64 kernel that was built with GCC.
vmlinux.h:47284:9: error: unknown type name '__Poly8_t' typedef __Poly8_t poly8x16_t[16]; ^~~~~~~~~
The polyX_t types are defined as unsigned integers in the "Arm C Language Extension" document (101028_Q220_00_en). Emit typedefs based on standard integer types for the GCC internal types, similar to those emitted by Clang.
Including linux/kernel.h to use ARRAY_SIZE() incidentally redefined max(), causing a build bug due to different types, hence the seemingly unrelated change.
--- tools/lib/bpf/btf_dump.c | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-)
tools/lib/bpf/btf_dump.c +34 -1
@@ -13,6 +13,7 @@#include <errno.h> #include <linux/err.h> #include <linux/btf.h> +#include <linux/kernel.h> #include "btf.h" #include "hashmap.h" #include "libbpf.h"
@@ -548,6 +549,9 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr) } } +static void btf_dump_emit_missing_aliases (struct btf_dump *d,__u32 id, +const struct btf_type *t); +static void btf_dump_emit_struct_fwd (struct btf_dump *d,__u32 id,const struct btf_type *t); static void btf_dump_emit_struct_def(struct btf_dump *d, __u32 id,
@@ -670,6 +674,9 @@ static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id)switch (kind) {case BTF_KIND_INT : +/* Emit type alias definitions if necessary */ +btf_dump_emit_missing_aliases (d, id, t); + tstate->emit_state =EMITTED ;break ;case BTF_KIND_ENUM :
@@ -869,7 +876,7 @@ static void btf_dump_emit_struct_def(struct btf_dump *d,btf_dump_printf (d,": %d" , m_sz); off = m_off + m_sz; }else { - m_sz =max (0 ,btf__resolve_size (d->btf, m->type)); + m_sz =max (0LL ,btf__resolve_size (d->btf, m->type)); off = m_off + m_sz *8 ; }btf_dump_printf (d,";" );
@@ -889,6 +896,32 @@ static void btf_dump_emit_struct_def(struct btf_dump *d,btf_dump_printf (d," __attribute__((packed))" ); } +static const char *missing_base_types[][2 ] = { +/* +* GCC emits typedefs to its internal __PolyX_t types when compiling Arm +* SIMD intrinsics. Alias them to standard base types. +*/ + {"__Poly8_t" ,"unsigned char" }, + {"__Poly16_t" ,"unsigned short" }, + {"__Poly64_t" ,"unsigned long long" }, + {"__Poly128_t" ,"unsigned __int128" }, +}; + +static void btf_dump_emit_missing_aliases (struct btf_dump *d,__u32 id, +const struct btf_type *t) +{ +const char *name =btf_dump_type_name (d, id); +int i; + +for (i =0 ; i <ARRAY_SIZE (missing_base_types); i++) { +if (strcmp (name, missing_base_types[i][0 ]) ==0 ) { +btf_dump_printf (d,"typedef %s %s;\n\n" , + missing_base_types[i][1 ], name); +break ; + } + } +} +static void btf_dump_emit_enum_fwd (struct btf_dump *d,__u32 id,const struct btf_type *t) {
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 22/54 netfilter: avoid ipv6 -> nf_defrag_ipv6 module dependency
In reply to Sasha LevinFrom: Florian Westphal <[email protected]>
[ Upstream commit 2404b73c3f1a5f15726c6ecd226b56f6f992767f ]
nf_ct_frag6_gather is part of nf_defrag_ipv6.ko, not ipv6 core.
The current use of the netfilter ipv6 stub indirections causes a module dependency between ipv6 and nf_defrag_ipv6.
This prevents nf_defrag_ipv6 module from being removed because ipv6 can't be unloaded.
Remove the indirection and always use a direct call. This creates a depency from nf_conntrack_bridge to nf_defrag_ipv6 instead:
modinfo nf_conntrack
depends: nf_conntrack,nf_defrag_ipv6,bridge
.. and nf_conntrack already depends on nf_defrag_ipv6 anyway.
--- include/linux/netfilter_ipv6.h | 18 ------------------ net/bridge/netfilter/nf_conntrack_bridge.c | 8 ++++++-- net/ipv6/netfilter.c | 3 --- 3 files changed, 6 insertions(+), 23 deletions(-)
include/linux/netfilter_ipv6.h +0 -18
@@ -58,7 +58,6 @@ struct nf_ipv6_ops { int (*output)(struct net *, struct sock *, struct sk_buff *));int (*reroute)(struct sk_buff *skb,const struct nf_queue_entry *entry);#if IS_MODULE (CONFIG_IPV6 ) -int (*br_defrag)(struct net *net,struct sk_buff *skb,u32 user); int (*br_fragment)(struct net *net, struct sock *sk, struct sk_buff *skb, struct nf_bridge_frag_data *data,
@@ -117,23 +116,6 @@ static inline int nf_ip6_route(struct net *net, struct dst_entry **dst,#include <net/netfilter/ipv6/nf_defrag_ipv6.h> -static inline int nf_ipv6_br_defrag (struct net *net,struct sk_buff *skb, -u32 user) -{ -#if IS_MODULE (CONFIG_IPV6 ) -const struct nf_ipv6_ops *v6_ops =nf_get_ipv6_ops (); - -if (!v6_ops) -return 1 ; - -return v6_ops->br_defrag (net, skb, user); -#elif IS_BUILTIN (CONFIG_IPV6 ) -return nf_ct_frag6_gather (net, skb, user); -#else -return 1 ; -#endif -} - int br_ip6_fragment(struct net *net, struct sock *sk, struct sk_buff *skb, struct nf_bridge_frag_data *data, int (*output)(struct net *, struct sock *sk,
net/bridge/netfilter/nf_conntrack_bridge.c +6 -2
@@ -168,6 +168,7 @@ static unsigned int nf_ct_br_defrag4(struct sk_buff *skb,static unsigned int nf_ct_br_defrag6 (struct sk_buff *skb,const struct nf_hook_state *state) { +#if IS_ENABLED (CONFIG_NF_DEFRAG_IPV6 )u16 zone_id =NF_CT_DEFAULT_ZONE_ID ;enum ip_conntrack_info ctinfo;struct br_input_skb_cb cb;
@@ -180,14 +181,17 @@ static unsigned int nf_ct_br_defrag6(struct sk_buff *skb,br_skb_cb_save (skb, &cb,sizeof (struct inet6_skb_parm )); - err =nf_ipv6_br_defrag (state->net, skb, -IP_DEFRAG_CONNTRACK_BRIDGE_IN + zone_id); + err =nf_ct_frag6_gather (state->net, skb, +IP_DEFRAG_CONNTRACK_BRIDGE_IN + zone_id);/* queued */ if (err == -EINPROGRESS )return NF_STOLEN ;br_skb_cb_restore (skb, &cb,IP6CB (skb)->frag_max_size);return err ==0 ?NF_ACCEPT :NF_DROP ; +#else +return NF_ACCEPT ; +#endif }static int nf_ct_br_ip_check (const struct sk_buff *skb)
net/ipv6/netfilter.c +0 -3
@@ -245,9 +245,6 @@ static const struct nf_ipv6_ops ipv6ops = { .route_input = ip6_route_input, .fragment = ip6_fragment, .reroute = nf_ip6_reroute, -#if IS_MODULE (CONFIG_IPV6 ) &&IS_ENABLED (CONFIG_NF_DEFRAG_IPV6 ) - .br_defrag = nf_ct_frag6_gather, -#endif #if IS_MODULE (CONFIG_IPV6 ) .br_fragment = br_ip6_fragment,#endif
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 23/54 libbpf: Prevent overriding errno when logging errors
In reply to Sasha LevinFrom: Toke Høiland-Jørgensen <[email protected]>
[ Upstream commit 23ab656be263813acc3c20623757d3cd1496d9e1 ]
Turns out there were a few more instances where libbpf didn't save the errno before writing an error message, causing errno to be overridden by the printf() return and the error disappearing if logging is enabled.
--- tools/lib/bpf/libbpf.c | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-)
tools/lib/bpf/libbpf.c +7 -5
@@ -3210,10 +3210,11 @@ bpf_object__probe_global_data(struct bpf_object *obj) map =bpf_create_map_xattr (&map_attr);if (map <0 ) { - cp =libbpf_strerror_r (errno, errmsg,sizeof (errmsg)); + ret = -errno; + cp =libbpf_strerror_r (ret, errmsg,sizeof (errmsg));pr_warn ("Error in %s():%s(%d). Couldn't create simple array map.\n" , - __func__, cp, errno); -return -errno; + __func__, cp, -ret); +return ret; } insns[0 ].imm = map;
@@ -5508,9 +5509,10 @@ int bpf_program__pin_instance(struct bpf_program *prog, const char *path, }if (bpf_obj_pin (prog->instances.fds[instance], path)) { - cp =libbpf_strerror_r (errno, errmsg,sizeof (errmsg)); + err = -errno; + cp =libbpf_strerror_r (err, errmsg,sizeof (errmsg));pr_warn ("failed to pin program: %s\n" , cp); -return -errno; +return err; }pr_debug ("pinned program '%s'\n" , path);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 24/54 selftests/bpf: Fix btf_dump test cases on 32-bit arches
In reply to Sasha LevinFrom: Andrii Nakryiko <[email protected]>
[ Upstream commit eed7818adf03e874994b966aa33bc00204dd275a ]
Fix btf_dump test cases by hard-coding BPF's pointer size of 8 bytes for cases where it's impossible to deterimne the pointer size (no long type in BTF). In cases where it's known, validate libbpf correctly determines it as 8.
--- .../selftests/bpf/prog_tests/btf_dump.c | 27 ++++++++++++++----- 1 file changed, 20 insertions(+), 7 deletions(-)
tools/testing/selftests/bpf/prog_tests/btf_dump.c +20 -7
@@ -12,15 +12,16 @@ void btf_dump_printf(void *ctx, const char *fmt, va_list args)static struct btf_dump_test_case {const char *name;const char *file; +bool known_ptr_sz;struct btf_dump_opts opts; } btf_dump_test_cases[] = { - {"btf_dump: syntax" ,"btf_dump_test_case_syntax" , {}}, - {"btf_dump: ordering" ,"btf_dump_test_case_ordering" , {}}, - {"btf_dump: padding" ,"btf_dump_test_case_padding" , {}}, - {"btf_dump: packing" ,"btf_dump_test_case_packing" , {}}, - {"btf_dump: bitfields" ,"btf_dump_test_case_bitfields" , {}}, - {"btf_dump: multidim" ,"btf_dump_test_case_multidim" , {}}, - {"btf_dump: namespacing" ,"btf_dump_test_case_namespacing" , {}}, + {"btf_dump: syntax" ,"btf_dump_test_case_syntax" , true, {}}, + {"btf_dump: ordering" ,"btf_dump_test_case_ordering" , false, {}}, + {"btf_dump: padding" ,"btf_dump_test_case_padding" , true, {}}, + {"btf_dump: packing" ,"btf_dump_test_case_packing" , true, {}}, + {"btf_dump: bitfields" ,"btf_dump_test_case_bitfields" , true, {}}, + {"btf_dump: multidim" ,"btf_dump_test_case_multidim" , false, {}}, + {"btf_dump: namespacing" ,"btf_dump_test_case_namespacing" , false, {}}, }; static int btf_dump_all_types(const struct btf *btf,
@@ -62,6 +63,18 @@ static int test_btf_dump_case(int n, struct btf_dump_test_case *t) goto done; } +/* tests with t->known_ptr_sz have no "long" or "unsigned long" type, +* so it's impossible to determine correct pointer size; but if they +* do, it should be 8 regardless of host architecture, becaues BPF +* target is always 64-bit +*/ +if (!t->known_ptr_sz) { +btf__set_pointer_size (btf,8 ); + }else { +CHECK (btf__pointer_size (btf) !=8 ,"ptr_sz" ,"exp %d, got %zu\n" , +8 ,btf__pointer_size (btf)); + } +snprintf (out_file,sizeof (out_file),"/tmp/%s.output.XXXXXX" , t->file); fd =mkstemp (out_file);if (CHECK (fd <0 ,"create_tmp" ,"failed to create file: %d\n" , fd)) {
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 25/54 selftests/bpf: Correct various core_reloc 64-bit assumptions
In reply to Sasha LevinFrom: Andrii Nakryiko <[email protected]>
[ Upstream commit 5705d705832f74395c5465ce93192688f543006a ]
Ensure that types are memory layout- and field alignment-compatible regardless of 32/64-bitness mix of libbpf and BPF architecture.
--- .../selftests/bpf/prog_tests/core_reloc.c | 20 +++--- .../selftests/bpf/progs/core_reloc_types.h | 69 ++++++++++--------- 2 files changed, 47 insertions(+), 42 deletions(-)
tools/testing/selftests/bpf/prog_tests/core_reloc.c +10 -10
@@ -237,8 +237,8 @@ .union_sz = sizeof(((type *)0)->union_field), \ .arr_sz = sizeof(((type *)0)->arr_field), \ .arr_elem_sz = sizeof(((type *)0)->arr_field[0]), \ - .ptr_sz = sizeof(((type *)0)->ptr_field), \ - .enum_sz = sizeof(((type *)0)->enum_field), \ + .ptr_sz = 8, /* always 8-byte pointer for BPF */ \ + .enum_sz = sizeof(((type *)0)->enum_field), \ }#define SIZE_CASE (name) { \
@@ -432,20 +432,20 @@ static struct core_reloc_test_case test_cases[] = { .sb4 = -1, .sb20 = -0x17654321, .u32 = 0xBEEF, - .s32 =-0x3FEDCBA987654321 , + .s32 =-0x3FEDCBA987654321LL , }),BITFIELDS_CASE (bitfields___bitfield_vs_int, { - .ub1 = 0xFEDCBA9876543210, + .ub1 = 0xFEDCBA9876543210LL, .ub2 = 0xA6, - .ub7 = -0x7EDCBA987654321, - .sb4 = -0x6123456789ABCDE, - .sb20 = 0xD00D, + .ub7 = -0x7EDCBA987654321LL, + .sb4 = -0x6123456789ABCDELL, + .sb20 = 0xD00DLL, .u32 = -0x76543, - .s32 = 0x0ADEADBEEFBADB0B, + .s32 = 0x0ADEADBEEFBADB0BLL, }),BITFIELDS_CASE (bitfields___just_big_enough, { - .ub1 = 0xF, - .ub2 = 0x0812345678FEDCBA, + .ub1 = 0xFLL, + .ub2 = 0x0812345678FEDCBALL, }), BITFIELDS_ERR_CASE(bitfields___err_too_big_bitfield),
tools/testing/selftests/bpf/progs/core_reloc_types.h +37 -32
158 lines not on this page · raw message
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 26/54 can: j1939: transport: j1939_xtp_rx_dat_one(): compare own packets to detect corruptions
In reply to Sasha LevinFrom: Oleksij Rempel <[email protected]>
[ Upstream commit e052d0540298bfe0f6cbbecdc7e2ea9b859575b2 ]
Since the stack relays on receiving own packets, it was overwriting own transmit buffer from received packets.
At least theoretically, the received echo buffer can be corrupt or changed and the session partner can request to resend previous data. In this case we will re-send bad data.
With this patch we will stop to overwrite own TX buffer and use it for sanity checking.
--- net/can/j1939/transport.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-)
net/can/j1939/transport.c +14 -1
@@ -1769,7 +1769,20 @@ static void j1939_xtp_rx_dat_one(struct j1939_session *session, } tpdat = se_skb->data; -memcpy (&tpdat[offset], &dat[1 ], nbytes); +if (!session->transmission) { +memcpy (&tpdat[offset], &dat[1 ], nbytes); + }else { +int err; + + err =memcmp (&tpdat[offset], &dat[1 ], nbytes); +if (err) +netdev_err_once (priv->ndev, +"%s: 0x%p: Data of RX-looped back packet (%*ph) doesn't match TX data (%*ph)!\n" , + __func__, session, + nbytes, &dat[1 ], + nbytes, &tpdat[offset]); + } +if (packet == session->pkt.rx) session->pkt.rx++;
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 27/54 drivers/net/wan/hdlc_x25: Added needed_headroom and a skb->len check
In reply to Sasha LevinFrom: Xie He <[email protected]>
[ Upstream commit 77b981c82c1df7c7ad32a046f17f007450b46954 ]
1. Added a skb->len check
This driver expects upper layers to include a pseudo header of 1 byte when passing down a skb for transmission. This driver will read this 1-byte header. This patch added a skb->len check before reading the header to make sure the header exists.
2. Added needed_headroom and set hard_header_len to 0
When this driver transmits data,
first this driver will remove a pseudo header of 1 byte, then the lapb module will prepend the LAPB header of 2 or 3 bytes.
So the value of needed_headroom in this driver should be 3 - 1.
Because this driver has no header_ops, according to the logic of af_packet.c, the value of hard_header_len should be 0.
Reason of setting needed_headroom and hard_header_len at this place:
This driver is written using the API of the hdlc module, the hdlc module enables this driver (the protocol driver) to run on any hardware that has a driver (the hardware driver) written using the API of the hdlc module.
Two other hdlc protocol drivers - hdlc_ppp and hdlc_raw_eth, also set things like hard_header_len at this place. In hdlc_ppp, it sets hard_header_len after attach_hdlc_protocol and before setting dev->type. In hdlc_raw_eth, it sets hard_header_len by calling ether_setup after attach_hdlc_protocol and after memcpy the settings.
3. Reset needed_headroom when detaching protocols (in hdlc.c)
When detaching a protocol from a hardware device, the hdlc module will reset various parameters of the device (including hard_header_len) to the default values. We add needed_headroom here so that needed_headroom will also be reset.
--- drivers/net/wan/hdlc.c | 1 + drivers/net/wan/hdlc_x25.c | 17 ++++++++++++++++- 2 files changed, 17 insertions(+), 1 deletion(-)
drivers/net/wan/hdlc.c +1 -0
@@ -230,6 +230,7 @@ static void hdlc_setup_dev(struct net_device *dev) dev->max_mtu =HDLC_MAX_MTU ; dev->type =ARPHRD_RAWHDLC ; dev->hard_header_len =16 ; + dev->needed_headroom =0 ; dev->addr_len =0 ; dev->header_ops = &hdlc_null_ops; }
drivers/net/wan/hdlc_x25.c +16 -1
@@ -107,8 +107,14 @@ static netdev_tx_t x25_xmit(struct sk_buff *skb, struct net_device *dev) {int result; +/* There should be a pseudo header of 1 byte added by upper layers. +* Check to make sure it is there before reading it. +*/ +if (skb->len <1 ) { +kfree_skb (skb); +return NETDEV_TX_OK ; + } -/* X.25 to LAPB */ switch (skb->data[0 ]) {case X25_IFACE_DATA :/* Data to be transmitted */ skb_pull (skb,1 );
@@ -294,6 +300,15 @@ static int x25_ioctl(struct net_device *dev, struct ifreq *ifr)return result;memcpy (&state (hdlc)->settings, &new_settings, size); + +/* There's no header_ops so hard_header_len should be 0. */ + dev->hard_header_len =0 ; +/* When transmitting data: +* first we'll remove a pseudo header of 1 byte, +* then we'll prepend an LAPB header of at most 3 bytes. +*/ + dev->needed_headroom =3 -1 ; + dev->type =ARPHRD_X25 ;call_netdevice_notifiers (NETDEV_POST_TYPE_CHANGE , dev);netif_dormant_off (dev);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 28/54 ALSA: hda/realtek: Add model alc298-samsung-headphone
In reply to Sasha LevinFrom: Mike Pozulp <[email protected]>
[ Upstream commit 23dc958689449be85e39351a8c809c3d344b155b ]
The very quiet and distorted headphone output bug that afflicted my Samsung Notebook 9 is appearing in many other Samsung laptops. Expose the quirk which fixed my laptop as a model so other users can try it.
--- sound/pci/hda/patch_realtek.c | 1 + 1 file changed, 1 insertion(+)
sound/pci/hda/patch_realtek.c +1 -0
@@ -7926,6 +7926,7 @@ static const struct hda_model_fixup alc269_fixup_models[] = { {.id = ALC299_FIXUP_PREDATOR_SPK, .name = "predator-spk"}, {.id = ALC298_FIXUP_HUAWEI_MBX_STEREO, .name = "huawei-mbx-stereo"}, {.id = ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE, .name = "alc256-medion-headset"}, + {.id = ALC298_FIXUP_SAMSUNG_HEADPHONE_VERY_QUIET, .name = "alc298-samsung-headphone"}, {} };#define ALC225_STANDARD_PINS \
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 29/54 s390/cio: add cond_resched() in the slow_eval_known_fn() loop
In reply to Sasha LevinFrom: Vineeth Vijayan <[email protected]>
[ Upstream commit 0b8eb2ee9da1e8c9b8082f404f3948aa82a057b2 ]
The scanning through subchannels during the time of an event could take significant amount of time in case of platforms with lots of known subchannels. This might result in higher scheduling latencies for other tasks especially on systems with a single CPU. Add cond_resched() call, as the loop in slow_eval_known_fn() can be executed for a longer duration.
--- drivers/s390/cio/css.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/s390/cio/css.c +5 -0
@@ -677,6 +677,11 @@ static int slow_eval_known_fn(struct subchannel *sch, void *data) rc =css_evaluate_known_subchannel (sch,1 );if (rc == -EAGAIN )css_schedule_eval (sch->schid); +/* +* The loop might take long time for platforms with lots of +* known devices. Allow scheduling here. +*/ +cond_resched (); }return 0 ; }
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 30/54 ASoC: wm8994: Avoid attempts to read unreadable registers
In reply to Sasha LevinFrom: Sylwester Nawrocki <[email protected]>
[ Upstream commit f082bb59b72039a2326ec1a44496899fb8aa6d0e ]
The driver supports WM1811, WM8994, WM8958 devices but according to documentation and the regmap definitions the WM8958_DSP2_* registers are only available on WM8958. In current code these registers are being accessed as if they were available on all the three chips.
When starting playback on WM1811 CODEC multiple errors like:
"wm8994-codec wm8994-codec: ASoC: error at soc_component_read_no_lock on wm8994-codec: -5" can be seen, which is caused by attempts to read an unavailable WM8958_DSP2_PROGRAM register. The issue has been uncovered by recent
commit "e2329ee ASoC: soc-component: add soc_component_err()".
This patch adds a check in wm8958_aif_ev() callback so the DSP2 handling is only done for WM8958.
--- sound/soc/codecs/wm8958-dsp2.c | 4 ++++ 1 file changed, 4 insertions(+)
sound/soc/codecs/wm8958-dsp2.c +4 -0
@@ -412,8 +412,12 @@ int wm8958_aif_ev(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol, int event) {struct snd_soc_component *component =snd_soc_dapm_to_component (w->dapm); +struct wm8994 *control =dev_get_drvdata (component->dev->parent);int i; +if (control->type !=WM8958 ) +return 0 ; +switch (event) {case SND_SOC_DAPM_POST_PMU :case SND_SOC_DAPM_PRE_PMU :
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 31/54 ALSA: usb-audio: ignore broken processing/extension unit
In reply to Sasha LevinFrom: Tom Yan <[email protected]>
[ Upstream commit d8d0db7bb358ef65d60726a61bfcd08eccff0bc0 ]
Some devices have broken extension unit where getting current value doesn't work. Attempt that once when creating mixer control for it. If it fails, just ignore it, so that it won't cripple the device entirely (and/or make the error floods).
--- sound/usb/mixer.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
sound/usb/mixer.c +7 -1
@@ -2367,7 +2367,7 @@ static int build_audio_procunit(struct mixer_build *state, int unitid,int num_ins;struct usb_mixer_elem_info *cval;struct snd_kcontrol *kctl; -int i, err, nameid, type, len; +int i, err, nameid, type, len, val;const struct procunit_info *info;const struct procunit_value_info *valinfo;const struct usbmix_name_map *map;
@@ -2470,6 +2470,12 @@ static int build_audio_procunit(struct mixer_build *state, int unitid,break ; } + err =get_cur_ctl_value (cval, cval->control <<8 , &val); +if (err <0 ) { +usb_mixer_elem_info_free (cval); +return -EINVAL ; + } + kctl =snd_ctl_new1 (&mixer_procunit_ctl, cval);if (!kctl) {usb_mixer_elem_info_free (cval);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 32/54 selftests: disable rp_filter for icmp_redirect.sh
In reply to Sasha LevinFrom: David Ahern <[email protected]>
[ Upstream commit bcf7ddb0186d366f761f86196b480ea6dd2dc18c ]
h1 is initially configured to reach h2 via r1 rather than the more direct path through r2. If rp_filter is set and inherited for r2, forwarding fails since the source address of h1 is reachable from eth0 vs the packet coming to it via r1 and eth1. Since rp_filter setting affects the test, explicitly reset it.
--- tools/testing/selftests/net/icmp_redirect.sh | 2 ++ 1 file changed, 2 insertions(+)
tools/testing/selftests/net/icmp_redirect.sh +2 -0
@@ -180,6 +180,8 @@ setup() ;; r[12]) ip netns exec $ns sysctl -q -w net.ipv4.ip_forward=1 ip netns exec $ns sysctl -q -w net.ipv4.conf.all.send_redirects=1 + ip netns exec $ns sysctl -q -w net.ipv4.conf.default.rp_filter=0 + ip netns exec $ns sysctl -q -w net.ipv4.conf.all.rp_filter=0 ip netns exec $ns sysctl -q -w net.ipv6.conf.all.forwarding=1 ip netns exec $ns sysctl -q -w net.ipv6.route.mtu_expires=10
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 33/54 scsi: fcoe: Fix I/O path allocation
In reply to Sasha LevinFrom: Mike Christie <[email protected]>
[ Upstream commit fa39ab5184d64563cd36f2fb5f0d3fbad83a432c ]
ixgbe_fcoe_ddp_setup() can be called from the main I/O path and is called with a spin_lock held, so we have to use GFP_ATOMIC allocation instead of GFP_KERNEL.
--- drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/net/ethernet/intel/ixgbe/ixgbe_fcoe.c +1 -1
@@ -192,7 +192,7 @@ static int ixgbe_fcoe_ddp_setup(struct net_device *netdev, u16 xid, }/* alloc the udl from per cpu ddp pool */ - ddp->udl =dma_pool_alloc (ddp_pool->pool,GFP_KERNEL , &ddp->udp); + ddp->udl =dma_pool_alloc (ddp_pool->pool,GFP_ATOMIC , &ddp->udp);if (!ddp->udl) {e_err (drv,"failed allocated ddp context\n" ); goto out_noddp_unmap;
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 34/54 scsi: ufs: Fix possible infinite loop in ufshcd_hold
In reply to Sasha LevinFrom: Stanley Chu <[email protected]>
[ Upstream commit 93b6c5db06028a3b55122bbb74d0715dd8ca4ae0 ]
In ufshcd_suspend(), after clk-gating is suspended and link is set as Hibern8 state, ufshcd_hold() is still possibly invoked before ufshcd_suspend() returns. For example, MediaTek's suspend vops may issue UIC commands which would call ufshcd_hold() during the command issuing flow.
Now if UFSHCD_CAP_HIBERN8_WITH_CLK_GATING capability is enabled, then ufshcd_hold() may enter infinite loops because there is no clk-ungating work scheduled or pending. In this case, ufshcd_hold() shall just bypass, and keep the link as Hibern8 state.
--- drivers/scsi/ufs/ufshcd.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
drivers/scsi/ufs/ufshcd.c +4 -1
@@ -1540,6 +1540,7 @@ static void ufshcd_ungate_work(struct work_struct *work)int ufshcd_hold (struct ufs_hba *hba,bool async) {int rc =0 ; +bool flush_result;unsigned long flags;if (!ufshcd_is_clkgating_allowed (hba))
@@ -1571,7 +1572,9 @@ int ufshcd_hold(struct ufs_hba *hba, bool async)break ; }spin_unlock_irqrestore (hba->host->host_lock, flags); -flush_work (&hba->clk_gating.ungate_work); + flush_result =flush_work (&hba->clk_gating.ungate_work); +if (hba->clk_gating.is_suspended && !flush_result) + goto out;spin_lock_irqsave (hba->host->host_lock, flags); goto start; }
Signature · 7 lines
2.25.1 _______________________________________________ Linux-mediatek mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-mediatek
Sasha Levin
maintainerPATCH 35/54 scsi: ufs: Improve interrupt handling for shared interrupts
In reply to Sasha LevinFrom: Adrian Hunter <[email protected]>
[ Upstream commit 127d5f7c4b653b8be5eb3b2c7bbe13728f9003ff ]
For shared interrupts, the interrupt status might be zero, so check that first.
--- drivers/scsi/ufs/ufshcd.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/scsi/ufs/ufshcd.c +3 -3
@@ -5677,7 +5677,7 @@ static irqreturn_t ufshcd_sl_intr(struct ufs_hba *hba, u32 intr_status)*/ static irqreturn_t ufshcd_intr (int irq,void *__hba) { -u32 intr_status, enabled_intr_status; +u32 intr_status, enabled_intr_status =0 ;irqreturn_t retval =IRQ_NONE ;struct ufs_hba *hba = __hba;int retries = hba->nutrs;
@@ -5691,7 +5691,7 @@ static irqreturn_t ufshcd_intr(int irq, void *__hba)* read, make sure we handle them by checking the interrupt status * again in a loop until we process all of the reqs before returning. */ - do { +while (intr_status && retries--) { enabled_intr_status = intr_status &ufshcd_readl (hba,REG_INTERRUPT_ENABLE );if (intr_status)
@@ -5700,7 +5700,7 @@ static irqreturn_t ufshcd_intr(int irq, void *__hba) retval |=ufshcd_sl_intr (hba, enabled_intr_status); intr_status =ufshcd_readl (hba,REG_INTERRUPT_STATUS ); - }while (intr_status && --retries); + }if (retval ==IRQ_NONE ) { dev_err(hba->dev, "%s: Unhandled interrupt 0x%08x\n",
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 36/54 scsi: ufs: Clean up completed request without interrupt notification
In reply to Sasha LevinFrom: Stanley Chu <[email protected]>
[ Upstream commit b10178ee7fa88b68a9e8adc06534d2605cb0ec23 ]
If somehow no interrupt notification is raised for a completed request and its doorbell bit is cleared by host, UFS driver needs to cleanup its outstanding bit in ufshcd_abort(). Otherwise, system may behave abnormally in the following scenario:
After ufshcd_abort() returns, this request will be requeued by SCSI layer with its outstanding bit set. Any future completed request will trigger ufshcd_transfer_req_compl() to handle all "completed outstanding bits". At this time the "abnormal outstanding bit" will be detected and the "requeued request" will be chosen to execute request post-processing flow. This is wrong because this request is still "alive".
--- drivers/scsi/ufs/ufshcd.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/scsi/ufs/ufshcd.c +2 -1
@@ -6227,7 +6227,7 @@ static int ufshcd_abort(struct scsi_cmnd *cmd)/* command completed already */ dev_err (hba->dev,"%s: cmd at tag %d successfully cleared from DB.\n" , __func__, tag); - goto out; + goto cleanup; }else { dev_err(hba->dev, "%s: no response from device. tag = %d, err %d\n",
@@ -6261,6 +6261,7 @@ static int ufshcd_abort(struct scsi_cmnd *cmd) goto out; } +cleanup:scsi_dma_unmap (cmd);spin_lock_irqsave (host->host_lock, flags);
Signature · 7 lines
2.25.1 _______________________________________________ Linux-mediatek mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-mediatek
Sasha Levin
maintainerPATCH 37/54 scsi: qla2xxx: Flush all sessions on zone disable
In reply to Sasha LevinFrom: Quinn Tran <[email protected]>
[ Upstream commit 10ae30ba664822f62de169a61628e31c999c7cc8 ]
On Zone Disable, certain switches would ignore all commands. This causes timeout for both switch scan command and abort of that command. On detection of this condition, all sessions will be shutdown.
--- drivers/scsi/qla2xxx/qla_gs.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
drivers/scsi/qla2xxx/qla_gs.c +12 -0
@@ -3736,6 +3736,18 @@ static void qla2x00_async_gpnft_gnnft_sp_done(srb_t *sp, int res)unsigned long flags;const char *name = sp->name; +if (res ==QLA_OS_TIMER_EXPIRED ) { +/* switch is ignoring all commands. +* This might be a zone disable behavior. +* This means we hit 64s timeout. +* 22s GPNFT + 44s Abort = 64s +*/ +ql_dbg (ql_dbg_disc, vha,0xffff , +"%s: Switch Zone check please .\n" , + name); +qla2x00_mark_all_devices_lost (vha); + } +/* * We are in an Interrupt context, queue up this * sp for GNNFT_DONE work. This will allow all
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 38/54 scsi: qla2xxx: Flush I/O on zone disable
In reply to Sasha LevinFrom: Quinn Tran <[email protected]>
[ Upstream commit a117579d0205b5a0592a3a98493e2b875e4da236 ]
Perform implicit logout to flush I/O on zone disable.
--- drivers/scsi/qla2xxx/qla_gs.c | 1 - 1 file changed, 1 deletion(-)
drivers/scsi/qla2xxx/qla_gs.c +0 -1
@@ -3436,7 +3436,6 @@ void qla24xx_async_gnnft_done(scsi_qla_host_t *vha, srb_t *sp)list_for_each_entry (fcport, &vha->vp_fcports, list) {if ((fcport->flags &FCF_FABRIC_DEVICE ) !=0 ) { fcport->scan_state =QLA_FCPORT_SCAN ; - fcport->logout_on_delete =0 ; } } goto login_logout;
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 39/54 scsi: qla2xxx: Indicate correct supported speeds for Mezz card
In reply to Sasha LevinFrom: Quinn Tran <[email protected]>
[ Upstream commit 4709272f6327cc4a8ee1dc55771bcf9718346980 ]
Correct the supported speeds for 16G Mezz card.
--- drivers/scsi/qla2xxx/qla_gs.c | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-)
drivers/scsi/qla2xxx/qla_gs.c +12 -5
@@ -1505,11 +1505,11 @@ qla2x00_prep_ct_fdmi_req(struct ct_sns_pkt *p, uint16_t cmd,static uint qla25xx_fdmi_port_speed_capability (struct qla_hw_data *ha) { +uint speeds =0 ; +if (IS_CNA_CAPABLE (ha))return FDMI_PORT_SPEED_10GB ;if (IS_QLA28XX (ha) ||IS_QLA27XX (ha)) { -uint speeds =0 ; -if (ha->max_supported_speed ==2 ) {if (ha->min_supported_speed <=6 ) speeds |=FDMI_PORT_SPEED_64GB ;
@@ -1536,9 +1536,16 @@ qla25xx_fdmi_port_speed_capability(struct qla_hw_data *ha) }return speeds; } -if (IS_QLA2031 (ha)) -return FDMI_PORT_SPEED_16GB |FDMI_PORT_SPEED_8GB | -FDMI_PORT_SPEED_4GB ; +if (IS_QLA2031 (ha)) { +if ((ha->pdev->subsystem_vendor ==0x103C ) && + (ha->pdev->subsystem_device ==0x8002 )) { + speeds =FDMI_PORT_SPEED_16GB ; + }else { + speeds =FDMI_PORT_SPEED_16GB |FDMI_PORT_SPEED_8GB | +FDMI_PORT_SPEED_4GB ; + } +return speeds; + }if (IS_QLA25XX (ha))return FDMI_PORT_SPEED_8GB |FDMI_PORT_SPEED_4GB |FDMI_PORT_SPEED_2GB |FDMI_PORT_SPEED_1GB ;
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 40/54 scsi: qla2xxx: Fix login timeout
In reply to Sasha LevinFrom: Quinn Tran <[email protected]>
[ Upstream commit abb31aeaa9b20680b0620b23fea5475ea4591e31 ]
Multipath errors were seen during failback due to login timeout. The remote device sent LOGO, the local host tore down the session and did relogin. The RSCN arrived indicates remote device is going through failover after which the relogin is in a 20s timeout phase. At this point the driver is stuck in the relogin process. Add a fix to delete the session as part of abort/flush the login.
--- drivers/scsi/qla2xxx/qla_gs.c | 18 +++++++++++++++--- drivers/scsi/qla2xxx/qla_target.c | 2 +- 2 files changed, 16 insertions(+), 4 deletions(-)
drivers/scsi/qla2xxx/qla_gs.c +15 -3
@@ -3538,10 +3538,22 @@ void qla24xx_async_gnnft_done(scsi_qla_host_t *vha, srb_t *sp) }if (fcport->scan_state !=QLA_FCPORT_FOUND ) { +bool do_delete = false; + +if (fcport->scan_needed && + fcport->disc_state ==DSC_LOGIN_PEND ) { +/* Cable got disconnected after we sent +* a login. Do delete to prevent timeout. +*/ + fcport->logout_on_delete =1 ; + do_delete = true; + } + fcport->scan_needed =0 ; -if ((qla_dual_mode_enabled (vha) || -qla_ini_mode_enabled (vha)) && -atomic_read (&fcport->state) ==FCS_ONLINE ) { +if (((qla_dual_mode_enabled (vha) || +qla_ini_mode_enabled (vha)) && +atomic_read (&fcport->state) ==FCS_ONLINE ) || + do_delete) {if (fcport->loop_id !=FC_NO_LOOP_ID ) {if (fcport->flags &FCF_FCP2_DEVICE ) fcport->logout_on_delete =0 ;
drivers/scsi/qla2xxx/qla_target.c +1 -1
@@ -1270,7 +1270,7 @@ void qlt_schedule_sess_for_deletion(struct fc_port *sess)qla24xx_chk_fcp_state (sess); -ql_dbg (ql_dbg_tgt, sess->vha,0xe001 , +ql_dbg (ql_dbg_disc, sess->vha,0xe001 ,"Scheduling sess %p for deletion %8phC\n" , sess, sess->port_name);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 41/54 scsi: qla2xxx: Check if FW supports MQ before enabling
In reply to Sasha LevinFrom: Saurav Kashyap <[email protected]>
[ Upstream commit dffa11453313a115157b19021cc2e27ea98e624c ]
OS boot during Boot from SAN was stuck at dracut emergency shell after enabling NVMe driver parameter. For non-MQ support the driver was enabling MQ. Add a check to confirm if FW supports MQ.
--- drivers/scsi/qla2xxx/qla_os.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/scsi/qla2xxx/qla_os.c +5 -0
@@ -2017,6 +2017,11 @@ qla2x00_iospace_config(struct qla_hw_data *ha)/* Determine queue resources */ ha->max_req_queues = ha->max_rsp_queues =1 ; ha->msix_count =QLA_BASE_VECTORS ; + +/* Check if FW supports MQ or not */ +if (!(ha->fw_attributes &BIT_6 )) + goto mqiobase_exit; +if (!ql2xmqsupport || !ql2xnvmeenable || (!IS_QLA25XX (ha) && !IS_QLA81XX (ha))) goto mqiobase_exit;
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 42/54 scsi: qla2xxx: Fix null pointer access during disconnect from subsystem
In reply to Sasha LevinFrom: Quinn Tran <[email protected]>
[ Upstream commit 83949613fac61e8e37eadf8275bf072342302f4e ]
NVMEAsync command is being submitted to QLA while the same NVMe controller is in the middle of reset. The reset path has deleted the association and freed aen_op->fcp_req.private. Add a check for this private pointer before issuing the command.
...
6 [ffffb656ca11fce0] page_fault at ffffffff8c00114e
[exception RIP: qla_nvme_post_cmd+394]
RIP: ffffffffc0d012ba RSP: ffffb656ca11fd98 RFLAGS: 00010206
RAX: ffff8fb039eda228 RBX: ffff8fb039eda200 RCX: 00000000000da161
RDX: ffffffffc0d4d0f0 RSI: ffffffffc0d26c9b RDI: ffff8fb039eda220
RBP: 0000000000000013 R8: ffff8fb47ff6aa80 R9: 0000000000000002
R10: 0000000000000000 R11: ffffb656ca11fdc8 R12: ffff8fb27d04a3b0
R13: ffff8fc46dd98a58 R14: 0000000000000000 R15: ffff8fc4540f0000
ORIG_RAX: ffffffffffffffff CS: 0010 SS: 0018 7 [ffffb656ca11fe08] nvme_fc_start_fcp_op at ffffffffc0241568 [nvme_fc] 8 [ffffb656ca11fe50] nvme_fc_submit_async_event at ffffffffc0241901 [nvme_fc] 9 [ffffb656ca11fe68] nvme_async_event_work at ffffffffc014543d [nvme_core]
10 [ffffb656ca11fe98] process_one_work at ffffffff8b6cd437
11 [ffffb656ca11fed8] worker_thread at ffffffff8b6cdcef
12 [ffffb656ca11ff10] kthread at ffffffff8b6d3402
13 [ffffb656ca11ff50] ret_from_fork at ffffffff8c000255
--
PID: 37824 TASK: ffff8fb033063d80 CPU: 20 COMMAND: "kworker/u97:451"
0 [ffffb656ce1abc28] __schedule at ffffffff8be629e3
1 [ffffb656ce1abcc8] schedule at ffffffff8be62fe8
2 [ffffb656ce1abcd0] schedule_timeout at ffffffff8be671ed
3 [ffffb656ce1abd70] wait_for_completion at ffffffff8be639cf
4 [ffffb656ce1abdd0] flush_work at ffffffff8b6ce2d5
5 [ffffb656ce1abe70] nvme_stop_ctrl at ffffffffc0144900 [nvme_core] 6 [ffffb656ce1abe80] nvme_fc_reset_ctrl_work at ffffffffc0243445 [nvme_fc] 7 [ffffb656ce1abe98] process_one_work at ffffffff8b6cd437
8 [ffffb656ce1abed8] worker_thread at ffffffff8b6cdb50
9 [ffffb656ce1abf10] kthread at ffffffff8b6d3402
10 [ffffb656ce1abf50] ret_from_fork at ffffffff8c000255
--- drivers/scsi/qla2xxx/qla_nvme.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/scsi/qla2xxx/qla_nvme.c +5 -0
@@ -535,6 +535,11 @@ static int qla_nvme_post_cmd(struct nvme_fc_local_port *lport,struct nvme_private *priv = fd->private;struct qla_nvme_rport *qla_rport = rport->private; +if (!priv) { +/* nvme association has been torn down */ +return rval; + } + fcport = qla_rport->fcport; if (!qpair || !fcport || (qpair && !qpair->fw_started) ||
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 43/54 Revert "scsi: qla2xxx: Fix crash on qla2x00_mailbox_command"
In reply to Sasha LevinFrom: Saurav Kashyap <[email protected]>
[ Upstream commit de7e6194301ad31c4ce95395eb678e51a1b907e5 ]
FCoE adapter initialization failed for ISP8021 with the following patch applied. In addition, reproduction of the issue the patch originally tried to address has been unsuccessful.
This reverts commit 3cb182b3fa8b7a61f05c671525494697cba39c6a.
--- drivers/scsi/qla2xxx/qla_mbx.c | 8 -------- 1 file changed, 8 deletions(-)
drivers/scsi/qla2xxx/qla_mbx.c +0 -8
@@ -334,14 +334,6 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)if (time_after (jiffies, wait_time))break ; -/* -* Check if it's UNLOADING, cause we cannot poll in -* this case, or else a NULL pointer dereference -* is triggered. -*/ -if (unlikely (test_bit (UNLOADING , &base_vha->dpc_flags))) -return QLA_FUNCTION_TIMEOUT ; -/* Check for pending interrupts. */ qla2x00_poll (ha->rsp_q_map[0 ]);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 44/54 macvlan: validate setting of multiple remote source MAC addresses
In reply to Sasha LevinFrom: Alvin Šipraga <[email protected]>
[ Upstream commit 8b61fba503904acae24aeb2bd5569b4d6544d48f ]
Remote source MAC addresses can be set on a 'source mode' macvlan interface via the IFLA_MACVLAN_MACADDR_DATA attribute. This commit tightens the validation of these MAC addresses to match the validation already performed when setting or adding a single MAC address via the IFLA_MACVLAN_MACADDR attribute.
iproute2 uses IFLA_MACVLAN_MACADDR_DATA for its 'macvlan macaddr set' command, and IFLA_MACVLAN_MACADDR for its 'macvlan macaddr add' command, which demonstrates the inconsistent behaviour that this commit addresses:
# ip link add link eth0 name macvlan0 type macvlan mode source
# ip link set link dev macvlan0 type macvlan macaddr add 01:00:00:00:00:00
RTNETLINK answers: Cannot assign requested address
# ip link set link dev macvlan0 type macvlan macaddr set 01:00:00:00:00:00
# ip -d link show macvlan0
5: macvlan0@eth0: <BROADCAST,MULTICAST,DYNAMIC,UP,LOWER_UP> mtu 1500 ...
link/ether 2e:ac:fd:2d:69:f8 brd ff:ff:ff:ff:ff:ff promiscuity 0
macvlan mode source remotes (1) 01:00:00:00:00:00 numtxqueues 1 ...With this change, the 'set' command will (rightly) fail in the same way as the 'add' command.
--- drivers/net/macvlan.c | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-)
drivers/net/macvlan.c +17 -4
@@ -1259,6 +1259,9 @@ static void macvlan_port_destroy(struct net_device *dev)static int macvlan_validate (struct nlattr *tb[],struct nlattr *data[],struct netlink_ext_ack *extack) { +struct nlattr *nla, *head; +int rem, len; +if (tb[IFLA_ADDRESS ]) {if (nla_len (tb[IFLA_ADDRESS ]) !=ETH_ALEN )return -EINVAL ;
@@ -1306,6 +1309,20 @@ static int macvlan_validate(struct nlattr *tb[], struct nlattr *data[],return -EADDRNOTAVAIL ; } +if (data[IFLA_MACVLAN_MACADDR_DATA ]) { + head =nla_data (data[IFLA_MACVLAN_MACADDR_DATA ]); + len =nla_len (data[IFLA_MACVLAN_MACADDR_DATA ]); + +nla_for_each_attr (nla, head, len, rem) { +if (nla_type (nla) !=IFLA_MACVLAN_MACADDR || +nla_len (nla) !=ETH_ALEN ) +return -EINVAL ; + +if (!is_valid_ether_addr (nla_data (nla))) +return -EADDRNOTAVAIL ; + } + } +if (data[IFLA_MACVLAN_MACADDR_COUNT ])return -EINVAL ;
@@ -1362,10 +1379,6 @@ static int macvlan_changelink_sources(struct macvlan_dev *vlan, u32 mode, len =nla_len (data[IFLA_MACVLAN_MACADDR_DATA ]);nla_for_each_attr (nla, head, len, rem) { -if (nla_type (nla) !=IFLA_MACVLAN_MACADDR || -nla_len (nla) !=ETH_ALEN ) -continue ; - addr =nla_data (nla); ret =macvlan_hash_add_source (vlan, addr);if (ret)
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 45/54 net: gianfar: Add of_node_put() before goto statement
In reply to Sasha LevinFrom: Sumera Priyadarsini <[email protected]>
[ Upstream commit 989e4da042ca4a56bbaca9223d1a93639ad11e17 ]
Every iteration of for_each_available_child_of_node() decrements reference count of the previous node, however when control is transferred from the middle of the loop, as in the case of a return or break or goto, there is no decrement thus ultimately resulting in a memory leak.
Fix a potential memory leak in gianfar.c by inserting of_node_put() before the goto statement.
Issue found with Coccinelle.
--- drivers/net/ethernet/freescale/gianfar.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/net/ethernet/freescale/gianfar.c +3 -1
@@ -750,8 +750,10 @@ static int gfar_of_init(struct platform_device *ofdev, struct net_device **pdev)continue ; err =gfar_parse_group (child, priv, model); -if (err) +if (err) { +of_node_put (child); goto err_grp_init; + } } }else {/* SQ_SG_MODE */ err =gfar_parse_group (np, priv, model);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 46/54 drm/amdgpu: disable gfxoff for navy_flounder
In reply to Sasha LevinFrom: Jiansong Chen <[email protected]>
[ Upstream commit 9c9b17a7d19a8e21db2e378784fff1128b46c9d3 ]
gfxoff is temporarily disabled for navy_flounder, since at present the feature has broken some basic amdgpu test.
--- drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c +3 -0
@@ -681,6 +681,9 @@ static void gfx_v10_0_check_gfxoff_flag(struct amdgpu_device *adev)if (!gfx_v10_0_navi10_gfxoff_should_enable (adev)) adev->pm.pp_feature &= ~PP_GFXOFF_MASK ;break ; +case CHIP_NAVY_FLOUNDER : + adev->pm.pp_feature &= ~PP_GFXOFF_MASK ; +break ;default :break ; }
Signature · 6 lines
2.25.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Re: [PATCH AUTOSEL 5.7 46/54] drm/amdgpu: disable gfxoff for navy_flounder
Quoted 5 lines · Sasha Levin
From: Jiansong Chen <[email protected]>
[ Upstream commit
9c9b17a7d19a8e21db2e378784fff1128b46c9d3]
Quoted 8 lines
gfxoff is temporarily disabled for
navy_flounder, since at present the feature has broken some basic amdgpu test.Signed-off-by Jiansong Chen <[email protected]>Reviewed-by Tao Zhou <[email protected]>Signed-off-by Alex Deucher <[email protected]>Signed-off-by Sasha Levin <[email protected]>
Support for this chip does not exist in 5.7 or any other older trees. Please drop this.
Alex
Quoted 21 lines
--- drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c | 3 +++ 1 file changed, 3 insertions(+)drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c +3
-1@@ -681,6 +681,9 @@ static void gfx_v10_0_check_gfxoff_flag(struct amdgpu_device *adev)if (!gfx_v10_0_navi10_gfxoff_should_enable (adev)) adev->pm.pp_feature &= ~PP_GFXOFF_MASK ;break ; +case CHIP_NAVY_FLOUNDER : + adev->pm.pp_feature &= ~PP_GFXOFF_MASK ; +break ;default :break ; } --2.25.1
Quoted 4 lines
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 47/54 drm/amdgpu: fix NULL pointer access issue when unloading driver
In reply to Sasha LevinFrom: Guchun Chen <[email protected]>
[ Upstream commit 1a68d96f81b8e7eb2a121fbf9abf9e5974e58832 ]
When unloading driver by "modprobe -r amdgpu", one NULL pointer dereference bug occurs in ras debugfs releasing. The cause is the duplicated debugfs_remove, as drm debugfs_root dir has been cleaned up already by drm_minor_unregister.
BUG: kernel NULL pointer dereference, address: 00000000000000a0 PGD 0 P4D 0 Oops: 0002 [#1] SMP PTI CPU: 11 PID: 1526 Comm: modprobe Tainted: G OE 5.6.0-guchchen #1 Hardware name: System manufacturer System Product Name/TUF Z370-PLUS GAMING II, BIOS 0411 09/21/2018 RIP: 0010:down_write+0x15/0x40 Code: eb de e8 7e 17 72 ff cc cc cc cc cc cc cc cc cc cc cc cc cc cc 0f 1f 44 00 00 53 48 89 fb e8 92 d8 ff ff 31 c0 ba 01 00 00 00 <f0> 48 0f b1 13 75 0f 65 48 8b 04 25 c0 8b 01 00 48 89 43 08 5b c3 RSP: 0018:ffffb1590386fcd0 EFLAGS: 00010246 RAX: 0000000000000000 RBX: 00000000000000a0 RCX: 0000000000000000 RDX: 0000000000000001 RSI: ffffffff85b2fcc2 RDI: 00000000000000a0 RBP: ffffb1590386fd30 R08: ffffffff85b2fcc2 R09: 000000000002b3c0 R10: ffff97a330618c40 R11: 00000000000005f6 R12: ffff97a3481beb40 R13: 00000000000000a0 R14: ffff97a3481beb40 R15: 0000000000000000 FS: 00007fb11a717540(0000) GS:ffff97a376cc0000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 00000000000000a0 CR3: 00000004066d6006 CR4: 00000000003606e0 DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400 Call Trace: simple_recursive_removal+0x63/0x370 ? debugfs_remove+0x60/0x60 debugfs_remove+0x40/0x60 amdgpu_ras_fini+0x82/0x230 [amdgpu] ? __kernfs_remove.part.17+0x101/0x1f0 ? kernfs_name_hash+0x12/0x80 amdgpu_device_fini+0x1c0/0x580 [amdgpu] amdgpu_driver_unload_kms+0x3e/0x70 [amdgpu] amdgpu_pci_remove+0x36/0x60 [amdgpu] pci_device_remove+0x3b/0xb0 device_release_driver_internal+0xe5/0x1c0 driver_detach+0x46/0x90 bus_remove_driver+0x58/0xd0 pci_unregister_driver+0x29/0x90 amdgpu_exit+0x11/0x25 [amdgpu] __x64_sys_delete_module+0x13d/0x210 do_syscall_64+0x5f/0x250 entry_SYSCALL_64_after_hwframe+0x44/0xa9
--- drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c | 2 -- 1 file changed, 2 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c +0 -2
@@ -1170,7 +1170,6 @@ void amdgpu_ras_debugfs_remove(struct amdgpu_device *adev,if (!obj || !obj->ent)return ; -debugfs_remove (obj->ent); obj->ent =NULL ;put_obj (obj); }
@@ -1184,7 +1183,6 @@ static void amdgpu_ras_debugfs_remove_all(struct amdgpu_device *adev)amdgpu_ras_debugfs_remove (adev, &obj->head); } -debugfs_remove_recursive (con->dir); con->dir =NULL ; }/* debugfs end */
Signature · 6 lines
2.25.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Sasha Levin
maintainerPATCH 48/54 drm/amdkfd: fix the wrong sdma instance query for renoir
In reply to Sasha LevinFrom: Huang Rui <[email protected]>
[ Upstream commit 34174b89bfa495bed9cddcc504fb38feca90fab7 ]
Renoir only has one sdma instance, it will get failed once query the sdma1 registers. So use switch-case instead of static register array.
--- .../gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c | 31 +++++++++++++------ 1 file changed, 22 insertions(+), 9 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gfx_v9.c +22 -9
@@ -197,19 +197,32 @@ static uint32_t get_sdma_rlc_reg_offset(struct amdgpu_device *adev,unsigned int engine_id, unsigned int queue_id) { - uint32_t sdma_engine_reg_base[2] = { -SOC15_REG_OFFSET (SDMA0 ,0 , - mmSDMA0_RLC0_RB_CNTL) - mmSDMA0_RLC0_RB_CNTL, -SOC15_REG_OFFSET (SDMA1 ,0 , - mmSDMA1_RLC0_RB_CNTL) - mmSDMA1_RLC0_RB_CNTL - }; -uint32_t retval = sdma_engine_reg_base[engine_id] + uint32_t sdma_engine_reg_base = 0; +uint32_t sdma_rlc_reg_offset; + +switch (engine_id) { +default : +dev_warn (adev->dev, +"Invalid sdma engine id (%d), using engine id 0\n" , + engine_id); + fallthrough; +case 0 : + sdma_engine_reg_base =SOC15_REG_OFFSET (SDMA0 ,0 , + mmSDMA0_RLC0_RB_CNTL) - mmSDMA0_RLC0_RB_CNTL; +break ; +case 1 : + sdma_engine_reg_base =SOC15_REG_OFFSET (SDMA1 ,0 , + mmSDMA1_RLC0_RB_CNTL) - mmSDMA0_RLC0_RB_CNTL; +break ; + } + + sdma_rlc_reg_offset = sdma_engine_reg_base + queue_id * (mmSDMA0_RLC1_RB_CNTL - mmSDMA0_RLC0_RB_CNTL);pr_debug ("RLC register offset for SDMA%d RLC%d: 0x%x\n" , engine_id, - queue_id, retval); + queue_id, sdma_rlc_reg_offset); -return retval; +return sdma_rlc_reg_offset; }static inline struct v9_mqd *get_mqd (void *mqd)
Signature · 6 lines
2.25.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Sasha Levin
maintainerPATCH 49/54 Revert "drm/amdgpu: disable gfxoff for navy_flounder"
In reply to Sasha LevinFrom: Jiansong Chen <[email protected]>
[ Upstream commit da2446b66b5e2c7f3ab63912c8d999810e35e8b3 ]
This reverts commit 9c9b17a7d19a8e21db2e378784fff1128b46c9d3. Newly released sdma fw (51.52) provides a fix for the issue.
--- drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c | 3 --- 1 file changed, 3 deletions(-)
drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c +0 -3
@@ -681,9 +681,6 @@ static void gfx_v10_0_check_gfxoff_flag(struct amdgpu_device *adev)if (!gfx_v10_0_navi10_gfxoff_should_enable (adev)) adev->pm.pp_feature &= ~PP_GFXOFF_MASK ;break ; -case CHIP_NAVY_FLOUNDER : - adev->pm.pp_feature &= ~PP_GFXOFF_MASK ; -break ;default :break ; }
Signature · 6 lines
2.25.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Re: [PATCH AUTOSEL 5.7 49/54] Revert "drm/amdgpu: disable gfxoff for navy_flounder"
Quoted 8 lines · Sasha Levin
From: Jiansong Chen <[email protected]>
[ Upstream commit
da2446b66b5e2c7f3ab63912c8d999810e35e8b3]This reverts commit
9c9b17a7d19a8e21db2e378784fff1128b46c9d3. Newly released sdma fw (51.52) provides a fix for the issue.
Quoted 6 lines
Signed-off-by Jiansong Chen <[email protected]>Reviewed-by Kenneth Feng <[email protected]>Reviewed-by Tao Zhou <[email protected]>Acked-by Alex Deucher <[email protected]>Signed-off-by Alex Deucher <[email protected]>Signed-off-by Sasha Levin <[email protected]>
Support for this chip does not exist in 5.7 or any other older trees. Please drop this.
Alex
Quoted 21 lines
--- drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c | 3 --- 1 file changed, 3 deletions(-)drivers/gpu/drm/amd/amdgpu/gfx_v10_0.c +0
-4@@ -681,9 +681,6 @@ static void gfx_v10_0_check_gfxoff_flag(struct amdgpu_device *adev)if (!gfx_v10_0_navi10_gfxoff_should_enable (adev)) adev->pm.pp_feature &= ~PP_GFXOFF_MASK ;break ; -case CHIP_NAVY_FLOUNDER : - adev->pm.pp_feature &= ~PP_GFXOFF_MASK ; -break ;default :break ; } --2.25.1
Quoted 4 lines
_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx
_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Sasha Levin
maintainerPATCH 50/54 powerpc/perf: Fix soft lockups due to missed interrupt accounting
In reply to Sasha LevinFrom: Athira Rajeev <[email protected]>
[ Upstream commit 17899eaf88d689529b866371344c8f269ba79b5f ]
Performance monitor interrupt handler checks if any counter has overflown and calls record_and_restart() in core-book3s which invokes perf_event_overflow() to record the sample information. Apart from creating sample, perf_event_overflow() also does the interrupt and period checks via perf_event_account_interrupt().
Currently we record information only if the SIAR (Sampled Instruction Address Register) valid bit is set (using siar_valid() check) and hence the interrupt check.
But it is possible that we do sampling for some events that are not generating valid SIAR, and hence there is no chance to disable the event if interrupts are more than max_samples_per_tick. This leads to soft lockup.
Fix this by adding perf_event_account_interrupt() in the invalid SIAR code path for a sampling event. ie if SIAR is invalid, just do interrupt check and don't record the sample information.
--- arch/powerpc/perf/core-book3s.c | 4 ++++ 1 file changed, 4 insertions(+)
arch/powerpc/perf/core-book3s.c +4 -0
@@ -2099,6 +2099,10 @@ static void record_and_restart(struct perf_event *event, unsigned long val,if (perf_event_overflow (event, &data, regs))power_pmu_stop (event,0 ); + }else if (period) { +/* Account for interrupt in case of invalid SIAR */ +if (perf_event_account_interrupt (event)) +power_pmu_stop (event,0 ); } }
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 51/54 libbpf: Fix map index used in error message
In reply to Sasha LevinFrom: Toke Høiland-Jørgensen <[email protected]>
[ Upstream commit 1e891e513e16c145cc9b45b1fdb8bf4a4f2f9557 ]
The error message emitted by bpf_object__init_user_btf_maps() was using the wrong section ID.
--- tools/lib/bpf/libbpf.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
tools/lib/bpf/libbpf.c +1 -1
@@ -2151,7 +2151,7 @@ static int bpf_object__init_user_btf_maps(struct bpf_object *obj, bool strict, data =elf_getdata (scn,NULL );if (!scn || !data) {pr_warn ("failed to get Elf_Data from map section %d (%s)\n" , - obj->efile.maps_shndx,MAPS_ELF_SEC ); + obj->efile.btf_maps_shndx,MAPS_ELF_SEC );return -EINVAL ; }
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 52/54 bpf: selftests: global_funcs: Check err_str before strstr
In reply to Sasha LevinFrom: Yauheni Kaliuta <[email protected]>
[ Upstream commit c210773d6c6f595f5922d56b7391fe343bc7310e ]
The error path in libbpf.c:load_program() has calls to pr_warn() which ends up for global_funcs tests to test_global_funcs.c:libbpf_debug_print().
For the tests with no struct test_def::err_str initialized with a string, it causes call of strstr() with NULL as the second argument and it segfaults.
Fix it by calling strstr() only for non-NULL err_str.
--- tools/testing/selftests/bpf/prog_tests/test_global_funcs.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
tools/testing/selftests/bpf/prog_tests/test_global_funcs.c +1 -1
@@ -19,7 +19,7 @@ static int libbpf_debug_print(enum libbpf_print_level level, log_buf = va_arg(args, char *);if (!log_buf) goto out; -if (strstr (log_buf, err_str) ==0 ) +if (err_str &&strstr (log_buf, err_str) ==0 ) found = true; out:printf (format, log_buf);
Signature · 1 line
2.25.1
Sasha Levin
maintainerPATCH 53/54 arm64: Move handling of erratum 1418040 into C code
In reply to Sasha LevinFrom: Marc Zyngier <[email protected]>
[ Upstream commit d49f7d7376d0c0daf8680984a37bd07581ac7d38 ]
Instead of dealing with erratum 1418040 on each entry and exit, let's move the handling to __switch_to() instead, which has several advantages:
- It can be applied when it matters (switching between 32 and 64 bit tasks).
- It is written in C (yay!)
- It can rely on static keys rather than alternatives
--- arch/arm64/kernel/process.c | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+)
arch/arm64/kernel/process.c +34 -0
@@ -500,6 +500,39 @@ static void entry_task_switch(struct task_struct *next)__this_cpu_write (__entry_task, next); } +/* +* ARM erratum 1418040 handling, affecting the 32bit view of CNTVCT. +* Assuming the virtual counter is enabled at the beginning of times: +* +* - disable access when switching from a 64bit task to a 32bit task +* - enable access when switching from a 32bit task to a 64bit task +*/ +static void erratum_1418040_thread_switch (struct task_struct *prev, +struct task_struct *next) +{ +bool prev32, next32; +u64 val; + +if (!(IS_ENABLED (CONFIG_ARM64_ERRATUM_1418040 ) && +cpus_have_const_cap (ARM64_WORKAROUND_1418040 ))) +return ; + + prev32 =is_compat_thread (task_thread_info (prev)); + next32 =is_compat_thread (task_thread_info (next)); + +if (prev32 == next32) +return ; + + val =read_sysreg (cntkctl_el1); + +if (!next32) + val |=ARCH_TIMER_USR_VCT_ACCESS_EN ; +else + val &= ~ARCH_TIMER_USR_VCT_ACCESS_EN ; + +write_sysreg (val, cntkctl_el1); +} +/* * Thread switching. */
@@ -515,6 +548,7 @@ __notrace_funcgraph struct task_struct *__switch_to(struct task_struct *prev,entry_task_switch (next);uao_thread_switch (next);ssbs_thread_switch (next); +erratum_1418040_thread_switch (prev, next);/* * Complete any pending TLB or cache maintenance on this CPU in case
Signature · 7 lines
2.25.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Sasha Levin
maintainerPATCH 54/54 arm64: Allow booting of late CPUs affected by erratum 1418040
In reply to Sasha LevinFrom: Marc Zyngier <[email protected]>
[ Upstream commit bf87bb0881d0f59181fe3bbcf29c609f36483ff8 ]
As we can now switch from a system that isn't affected by 1418040 to a system that globally is affected, let's allow affected CPUs to come in at a later time.
--- arch/arm64/kernel/cpu_errata.c | 2 ++ 1 file changed, 2 insertions(+)
arch/arm64/kernel/cpu_errata.c +2 -0
@@ -906,6 +906,8 @@ const struct arm64_cpu_capabilities arm64_errata[] = { .desc = "ARM erratum 1418040", .capability =ARM64_WORKAROUND_1418040 ,ERRATA_MIDR_RANGE_LIST (erratum_1418040_list), + .type = (ARM64_CPUCAP_SCOPE_LOCAL_CPU | +ARM64_CPUCAP_PERMITTED_FOR_LATE_CPU ), }, #endif #ifdef CONFIG_ARM64_WORKAROUND_SPECULATIVE_AT_VHE
Signature · 7 lines
2.25.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel