Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d8ca2109 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

Merge d2a6844b ("ASoC: meson: spdifin: start hw on dai probe") into android11-5.4-lts 



Steps on the way to 5.4.258

Change-Id: I85f1c8953f850461246d7be38934a6c11e7137fa
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@google.com>
parents 432ea675 d2a6844b

drivers/ata/libahci.c

+23 −12
Original line number Diff line number Diff line
@@ -1199,6 +1199,26 @@ static ssize_t ahci_activity_show(struct ata_device *dev, char *buf) 
	return sprintf(buf, "%d\n", emp->blink_policy);

}



static void ahci_port_clear_pending_irq(struct ata_port *ap)

{

	struct ahci_host_priv *hpriv = ap->host->private_data;

	void __iomem *port_mmio = ahci_port_base(ap);

	u32 tmp;



	/* clear SError */

	tmp = readl(port_mmio + PORT_SCR_ERR);

	dev_dbg(ap->host->dev, "PORT_SCR_ERR 0x%x\n", tmp);

	writel(tmp, port_mmio + PORT_SCR_ERR);



	/* clear port IRQ */

	tmp = readl(port_mmio + PORT_IRQ_STAT);

	dev_dbg(ap->host->dev, "PORT_IRQ_STAT 0x%x\n", tmp);

	if (tmp)

		writel(tmp, port_mmio + PORT_IRQ_STAT);



	writel(1 << ap->port_no, hpriv->mmio + HOST_IRQ_STAT);

}



static void ahci_port_init(struct device *dev, struct ata_port *ap,

			   int port_no, void __iomem *mmio,

			   void __iomem *port_mmio)
@@ -1213,18 +1233,7 @@ static void ahci_port_init(struct device *dev, struct ata_port *ap, 
	if (rc)

		dev_warn(dev, "%s (%d)\n", emsg, rc);



	/* clear SError */

	tmp = readl(port_mmio + PORT_SCR_ERR);

	VPRINTK("PORT_SCR_ERR 0x%x\n", tmp);

	writel(tmp, port_mmio + PORT_SCR_ERR);



	/* clear port IRQ */

	tmp = readl(port_mmio + PORT_IRQ_STAT);

	VPRINTK("PORT_IRQ_STAT 0x%x\n", tmp);

	if (tmp)

		writel(tmp, port_mmio + PORT_IRQ_STAT);



	writel(1 << port_no, mmio + HOST_IRQ_STAT);

	ahci_port_clear_pending_irq(ap);



	/* mark esata ports */

	tmp = readl(port_mmio + PORT_CMD);
@@ -1554,6 +1563,8 @@ int ahci_do_hardreset(struct ata_link *link, unsigned int *class, 
	tf.command = ATA_BUSY;

	ata_tf_to_fis(&tf, 0, 0, d2h_fis);



	ahci_port_clear_pending_irq(ap);



	rc = sata_link_hardreset(link, timing, deadline, online,

				 ahci_check_ready);

fs/ext4/ext4.h

+1 −1
Original line number Diff line number Diff line
@@ -1517,7 +1517,7 @@ struct ext4_sb_info { 
	struct task_struct *s_mmp_tsk;



	/* record the last minlen when FITRIM is called. */

	atomic_t s_last_trim_minblks;

	unsigned long s_last_trim_minblks;



	/* Reference to checksum algorithm driver via cryptoapi */

	struct crypto_shash *s_chksum_driver;

fs/ext4/mballoc.c

+82 −56
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 
#include <linux/slab.h>

#include <linux/nospec.h>

#include <linux/backing-dev.h>

#include <linux/freezer.h>

#include <trace/events/ext4.h>



#ifdef CONFIG_EXT4_DEBUG
@@ -5159,19 +5160,19 @@ int ext4_group_add_blocks(handle_t *handle, struct super_block *sb, 
 * @sb:		super block for the file system

 * @start:	starting block of the free extent in the alloc. group

 * @count:	number of blocks to TRIM

 * @group:	alloc. group we are working with

 * @e4b:	ext4 buddy for the group

 *

 * Trim "count" blocks starting at "start" in the "group". To assure that no

 * one will allocate those blocks, mark it as used in buddy bitmap. This must

 * be called with under the group lock.

 */

static int ext4_trim_extent(struct super_block *sb, int start, int count,

			     ext4_group_t group, struct ext4_buddy *e4b)

static int ext4_trim_extent(struct super_block *sb,

		int start, int count, struct ext4_buddy *e4b)

__releases(bitlock)

__acquires(bitlock)

{

	struct ext4_free_extent ex;

	ext4_group_t group = e4b->bd_group;

	int ret = 0;



	trace_ext4_trim_extent(sb, group, start, count);
@@ -5194,6 +5195,71 @@ __acquires(bitlock) 
	return ret;

}



static ext4_grpblk_t ext4_last_grp_cluster(struct super_block *sb,

					   ext4_group_t grp)

{

	if (grp < ext4_get_groups_count(sb))

		return EXT4_CLUSTERS_PER_GROUP(sb) - 1;

	return (ext4_blocks_count(EXT4_SB(sb)->s_es) -

		ext4_group_first_block_no(sb, grp) - 1) >>

					EXT4_CLUSTER_BITS(sb);

}



static bool ext4_trim_interrupted(void)

{

	return fatal_signal_pending(current) || freezing(current);

}



static int ext4_try_to_trim_range(struct super_block *sb,

		struct ext4_buddy *e4b, ext4_grpblk_t start,

		ext4_grpblk_t max, ext4_grpblk_t minblocks)

{

	ext4_grpblk_t next, count, free_count;

	bool set_trimmed = false;

	void *bitmap;



	bitmap = e4b->bd_bitmap;

	if (start == 0 && max >= ext4_last_grp_cluster(sb, e4b->bd_group))

		set_trimmed = true;

	start = max(e4b->bd_info->bb_first_free, start);

	count = 0;

	free_count = 0;



	while (start <= max) {

		start = mb_find_next_zero_bit(bitmap, max + 1, start);

		if (start > max)

			break;

		next = mb_find_next_bit(bitmap, max + 1, start);



		if ((next - start) >= minblocks) {

			int ret = ext4_trim_extent(sb, start, next - start, e4b);



			if (ret && ret != -EOPNOTSUPP)

				return count;

			count += next - start;

		}

		free_count += next - start;

		start = next + 1;



		if (ext4_trim_interrupted())

			return count;



		if (need_resched()) {

			ext4_unlock_group(sb, e4b->bd_group);

			cond_resched();

			ext4_lock_group(sb, e4b->bd_group);

		}



		if ((e4b->bd_info->bb_free - free_count) < minblocks)

			break;

	}



	if (set_trimmed)

		EXT4_MB_GRP_SET_TRIMMED(e4b->bd_info);



	return count;

}



/**

 * ext4_trim_all_free -- function to trim all free space in alloc. group

 * @sb:			super block for file system
@@ -5217,10 +5283,8 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group, 
		   ext4_grpblk_t start, ext4_grpblk_t max,

		   ext4_grpblk_t minblocks)

{

	void *bitmap;

	ext4_grpblk_t next, count = 0, free_count = 0;

	struct ext4_buddy e4b;

	int ret = 0;

	int ret;



	trace_ext4_trim_all_free(sb, group, start, max);
@@ -5230,58 +5294,20 @@ ext4_trim_all_free(struct super_block *sb, ext4_group_t group, 
			     ret, group);

		return ret;

	}

	bitmap = e4b.bd_bitmap;



	ext4_lock_group(sb, group);

	if (EXT4_MB_GRP_WAS_TRIMMED(e4b.bd_info) &&

	    minblocks >= atomic_read(&EXT4_SB(sb)->s_last_trim_minblks))

		goto out;



	start = (e4b.bd_info->bb_first_free > start) ?

		e4b.bd_info->bb_first_free : start;



	while (start <= max) {

		start = mb_find_next_zero_bit(bitmap, max + 1, start);

		if (start > max)

			break;

		next = mb_find_next_bit(bitmap, max + 1, start);



		if ((next - start) >= minblocks) {

			ret = ext4_trim_extent(sb, start,

					       next - start, group, &e4b);

			if (ret && ret != -EOPNOTSUPP)

				break;

	if (!EXT4_MB_GRP_WAS_TRIMMED(e4b.bd_info) ||

	    minblocks < EXT4_SB(sb)->s_last_trim_minblks)

		ret = ext4_try_to_trim_range(sb, &e4b, start, max, minblocks);

	else

		ret = 0;

			count += next - start;

		}

		free_count += next - start;

		start = next + 1;



		if (fatal_signal_pending(current)) {

			count = -ERESTARTSYS;

			break;

		}



		if (need_resched()) {

			ext4_unlock_group(sb, group);

			cond_resched();

			ext4_lock_group(sb, group);

		}



		if ((e4b.bd_info->bb_free - free_count) < minblocks)

			break;

	}



	if (!ret) {

		ret = count;

		EXT4_MB_GRP_SET_TRIMMED(e4b.bd_info);

	}

out:

	ext4_unlock_group(sb, group);

	ext4_mb_unload_buddy(&e4b);



	ext4_debug("trimmed %d blocks in the group %d\n",

		count, group);

		ret, group);



	return ret;

}
@@ -5326,7 +5352,7 @@ int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range) 
		if (minlen > EXT4_CLUSTERS_PER_GROUP(sb))

			goto out;

	}

	if (end >= max_blks)

	if (end >= max_blks - 1)

		end = max_blks - 1;

	if (end <= first_data_blk)

		goto out;
@@ -5343,6 +5369,8 @@ int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range) 
	end = EXT4_CLUSTERS_PER_GROUP(sb) - 1;



	for (group = first_group; group <= last_group; group++) {

		if (ext4_trim_interrupted())

			break;

		grp = ext4_get_group_info(sb, group);

		/* We only do this if the grp has never been initialized */

		if (unlikely(EXT4_MB_GRP_NEED_INIT(grp))) {
@@ -5359,7 +5387,6 @@ int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range) 
		 */

		if (group == last_group)

			end = last_cluster;



		if (grp->bb_free >= minlen) {

			cnt = ext4_trim_all_free(sb, group, first_cluster,

						 end, minlen);
@@ -5378,7 +5405,7 @@ int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range) 
	}



	if (!ret)

		atomic_set(&EXT4_SB(sb)->s_last_trim_minblks, minlen);

		EXT4_SB(sb)->s_last_trim_minblks = minlen;



out:

	range->len = EXT4_C2B(EXT4_SB(sb), trimmed) << sb->s_blocksize_bits;
@@ -5407,8 +5434,7 @@ ext4_mballoc_query_range( 


	ext4_lock_group(sb, group);



	start = (e4b.bd_info->bb_first_free > start) ?

		e4b.bd_info->bb_first_free : start;

	start = max(e4b.bd_info->bb_first_free, start);

	if (end >= EXT4_CLUSTERS_PER_GROUP(sb))

		end = EXT4_CLUSTERS_PER_GROUP(sb) - 1;

fs/nfs/flexfilelayout/flexfilelayout.c

+1 −0
Original line number Diff line number Diff line
@@ -1280,6 +1280,7 @@ static void ff_layout_io_track_ds_error(struct pnfs_layout_segment *lseg, 
		case -EPFNOSUPPORT:

		case -EPROTONOSUPPORT:

		case -EOPNOTSUPP:

		case -EINVAL:

		case -ECONNREFUSED:

		case -ECONNRESET:

		case -EHOSTDOWN:

kernel/trace/trace.c

+27 −0
Original line number Diff line number Diff line
@@ -4244,6 +4244,33 @@ int tracing_open_generic_tr(struct inode *inode, struct file *filp) 
	return 0;

}



/*

 * The private pointer of the inode is the trace_event_file.

 * Update the tr ref count associated to it.

 */

int tracing_open_file_tr(struct inode *inode, struct file *filp)

{

	struct trace_event_file *file = inode->i_private;

	int ret;



	ret = tracing_check_open_get_tr(file->tr);

	if (ret)

		return ret;



	filp->private_data = inode->i_private;



	return 0;

}



int tracing_release_file_tr(struct inode *inode, struct file *filp)

{

	struct trace_event_file *file = inode->i_private;



	trace_array_put(file->tr);



	return 0;

}



static int tracing_release(struct inode *inode, struct file *file)

{

	struct trace_array *tr = inode->i_private;