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

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

Merge 4.14.55 into android-4.14 



Changes in 4.14.55
	userfaultfd: hugetlbfs: fix userfaultfd_huge_must_wait() pte access
	mm: hugetlb: yield when prepping struct pages
	tracing: Fix missing return symbol in function_graph output
	scsi: sg: mitigate read/write abuse
	scsi: target: Fix truncated PR-in ReadKeys response
	s390: Correct register corruption in critical section cleanup
	drbd: fix access after free
	vfio: Use get_user_pages_longterm correctly
	cifs: Fix use after free of a mid_q_entry
	cifs: Fix memory leak in smb2_set_ea()
	cifs: Fix infinite loop when using hard mount option
	cifs: Fix slab-out-of-bounds in send_set_info() on SMB2 ACE setting
	drm: Use kvzalloc for allocating blob property memory
	drm/udl: fix display corruption of the last line
	jbd2: don't mark block as modified if the handle is out of credits
	ext4: add corruption check in ext4_xattr_set_entry()
	ext4: always verify the magic number in xattr blocks
	ext4: make sure bitmaps and the inode table don't overlap with bg descriptors
	ext4: always check block group bounds in ext4_init_block_bitmap()
	ext4: only look at the bg_flags field if it is valid
	ext4: verify the depth of extent tree in ext4_find_extent()
	ext4: include the illegal physical block in the bad map ext4_error msg
	ext4: clear i_data in ext4_inode_info when removing inline data
	ext4: never move the system.data xattr out of the inode body
	ext4: avoid running out of journal credits when appending to an inline file
	ext4: add more inode number paranoia checks
	ext4: add more mount time checks of the superblock
	ext4: check superblock mapped prior to committing
	block: factor out __blkdev_issue_zero_pages()
	block: cope with WRITE ZEROES failing in blkdev_issue_zeroout()
	HID: i2c-hid: Fix "incomplete report" noise
	HID: hiddev: fix potential Spectre v1
	HID: debug: check length before copy_to_user()
	irq/core: Fix boot crash when the irqaffinity= boot parameter is passed on CPUMASK_OFFSTACK=y kernels(v1)
	mm: hwpoison: disable memory error handling on 1GB hugepage
	media: vb2: core: Finish buffers at the end of the stream
	f2fs: truncate preallocated blocks in error case
	Revert "dpaa_eth: fix error in dpaa_remove()"
	Kbuild: fix # escaping in .cmd files for future Make
	media: cx25840: Use subdev host data for PLL override
	mtd: rawnand: mxc: set spare area size register explicitly
	fs: allow per-device dax status checking for filesystems
	dax: change bdev_dax_supported() to support boolean returns
	dax: check for QUEUE_FLAG_DAX in bdev_dax_supported()
	dm: set QUEUE_FLAG_DAX accordingly in dm_table_set_restrictions()
	dm: prevent DAX mounts if not supported
	mtd: cfi_cmdset_0002: Change definition naming to retry write operation
	mtd: cfi_cmdset_0002: Change erase functions to retry for error
	mtd: cfi_cmdset_0002: Change erase functions to check chip good only
	netfilter: nf_log: don't hold nf_log_mutex during user access
	staging: comedi: quatech_daqp_cs: fix no-op loop daqp_ao_insn_write()
	sched, tracing: Fix trace_sched_pi_setprio() for deboosting
	Revert mm/vmstat.c: fix vmstat_update() preemption BUG
	Linux 4.14.55

Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@google.com>
parents ebe8b41e 1e92e813

Makefile

+1 −1
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

VERSION = 4

PATCHLEVEL = 14

SUBLEVEL = 54

SUBLEVEL = 55

EXTRAVERSION =

NAME = Petit Gorille

arch/s390/kernel/entry.S

+2 −2
Original line number Diff line number Diff line
@@ -1244,7 +1244,7 @@ cleanup_critical: 
	jl	0f

	clg	%r9,BASED(.Lcleanup_table+104)	# .Lload_fpu_regs_end

	jl	.Lcleanup_load_fpu_regs

0:	BR_EX	%r14

0:	BR_EX	%r14,%r11



	.align	8

.Lcleanup_table:
@@ -1280,7 +1280,7 @@ cleanup_critical: 
	ni	__SIE_PROG0C+3(%r9),0xfe	# no longer in SIE

	lctlg	%c1,%c1,__LC_USER_ASCE		# load primary asce

	larl	%r9,sie_exit			# skip forward to sie_exit

	BR_EX	%r14

	BR_EX	%r14,%r11

#endif



.Lcleanup_system_call:

block/blk-lib.c

+72 −36
Original line number Diff line number Diff line
@@ -275,6 +275,40 @@ static unsigned int __blkdev_sectors_to_bio_pages(sector_t nr_sects) 
	return min(pages, (sector_t)BIO_MAX_PAGES);

}



static int __blkdev_issue_zero_pages(struct block_device *bdev,

		sector_t sector, sector_t nr_sects, gfp_t gfp_mask,

		struct bio **biop)

{

	struct request_queue *q = bdev_get_queue(bdev);

	struct bio *bio = *biop;

	int bi_size = 0;

	unsigned int sz;



	if (!q)

		return -ENXIO;



	while (nr_sects != 0) {

		bio = next_bio(bio, __blkdev_sectors_to_bio_pages(nr_sects),

			       gfp_mask);

		bio->bi_iter.bi_sector = sector;

		bio_set_dev(bio, bdev);

		bio_set_op_attrs(bio, REQ_OP_WRITE, 0);



		while (nr_sects != 0) {

			sz = min((sector_t) PAGE_SIZE, nr_sects << 9);

			bi_size = bio_add_page(bio, ZERO_PAGE(0), sz, 0);

			nr_sects -= bi_size >> 9;

			sector += bi_size >> 9;

			if (bi_size < sz)

				break;

		}

		cond_resched();

	}



	*biop = bio;

	return 0;

}



/**

 * __blkdev_issue_zeroout - generate number of zero filed write bios

 * @bdev:	blockdev to issue
@@ -288,12 +322,6 @@ static unsigned int __blkdev_sectors_to_bio_pages(sector_t nr_sects) 
 *  Zero-fill a block range, either using hardware offload or by explicitly

 *  writing zeroes to the device.

 *

 *  Note that this function may fail with -EOPNOTSUPP if the driver signals

 *  zeroing offload support, but the device fails to process the command (for

 *  some devices there is no non-destructive way to verify whether this

 *  operation is actually supported).  In this case the caller should call

 *  retry the call to blkdev_issue_zeroout() and the fallback path will be used.

 *

 *  If a device is using logical block provisioning, the underlying space will

 *  not be released if %flags contains BLKDEV_ZERO_NOUNMAP.

 *
@@ -305,9 +333,6 @@ int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, 
		unsigned flags)

{

	int ret;

	int bi_size = 0;

	struct bio *bio = *biop;

	unsigned int sz;

	sector_t bs_mask;



	bs_mask = (bdev_logical_block_size(bdev) >> 9) - 1;
@@ -317,30 +342,10 @@ int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, 
	ret = __blkdev_issue_write_zeroes(bdev, sector, nr_sects, gfp_mask,

			biop, flags);

	if (ret != -EOPNOTSUPP || (flags & BLKDEV_ZERO_NOFALLBACK))

		goto out;



	ret = 0;

	while (nr_sects != 0) {

		bio = next_bio(bio, __blkdev_sectors_to_bio_pages(nr_sects),

			       gfp_mask);

		bio->bi_iter.bi_sector = sector;

		bio_set_dev(bio, bdev);

		bio_set_op_attrs(bio, REQ_OP_WRITE, 0);



		while (nr_sects != 0) {

			sz = min((sector_t) PAGE_SIZE, nr_sects << 9);

			bi_size = bio_add_page(bio, ZERO_PAGE(0), sz, 0);

			nr_sects -= bi_size >> 9;

			sector += bi_size >> 9;

			if (bi_size < sz)

				break;

		}

		cond_resched();

	}



	*biop = bio;

out:

		return ret;



	return __blkdev_issue_zero_pages(bdev, sector, nr_sects, gfp_mask,

					 biop);

}

EXPORT_SYMBOL(__blkdev_issue_zeroout);
@@ -360,18 +365,49 @@ EXPORT_SYMBOL(__blkdev_issue_zeroout); 
int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,

		sector_t nr_sects, gfp_t gfp_mask, unsigned flags)

{

	int ret;

	struct bio *bio = NULL;

	int ret = 0;

	sector_t bs_mask;

	struct bio *bio;

	struct blk_plug plug;

	bool try_write_zeroes = !!bdev_write_zeroes_sectors(bdev);



	bs_mask = (bdev_logical_block_size(bdev) >> 9) - 1;

	if ((sector | nr_sects) & bs_mask)

		return -EINVAL;



retry:

	bio = NULL;

	blk_start_plug(&plug);

	ret = __blkdev_issue_zeroout(bdev, sector, nr_sects, gfp_mask,

			&bio, flags);

	if (try_write_zeroes) {

		ret = __blkdev_issue_write_zeroes(bdev, sector, nr_sects,

						  gfp_mask, &bio, flags);

	} else if (!(flags & BLKDEV_ZERO_NOFALLBACK)) {

		ret = __blkdev_issue_zero_pages(bdev, sector, nr_sects,

						gfp_mask, &bio);

	} else {

		/* No zeroing offload support */

		ret = -EOPNOTSUPP;

	}

	if (ret == 0 && bio) {

		ret = submit_bio_wait(bio);

		bio_put(bio);

	}

	blk_finish_plug(&plug);

	if (ret && try_write_zeroes) {

		if (!(flags & BLKDEV_ZERO_NOFALLBACK)) {

			try_write_zeroes = false;

			goto retry;

		}

		if (!bdev_write_zeroes_sectors(bdev)) {

			/*

			 * Zeroing offload support was indicated, but the

			 * device reported ILLEGAL REQUEST (for some devices

			 * there is no non-destructive way to verify whether

			 * WRITE ZEROES is actually supported).

			 */

			ret = -EOPNOTSUPP;

		}

	}



	return ret;

}

drivers/block/drbd/drbd_worker.c

+1 −1
Original line number Diff line number Diff line
@@ -282,8 +282,8 @@ void drbd_request_endio(struct bio *bio) 
		what = COMPLETED_OK;

	}



	bio_put(req->private_bio);

	req->private_bio = ERR_PTR(blk_status_to_errno(bio->bi_status));

	bio_put(bio);



	/* not req_mod(), we need irqsave here! */

	spin_lock_irqsave(&device->resource->req_lock, flags);

drivers/dax/super.c

+25 −17
Original line number Diff line number Diff line
@@ -73,42 +73,50 @@ EXPORT_SYMBOL_GPL(fs_dax_get_by_bdev); 


/**

 * __bdev_dax_supported() - Check if the device supports dax for filesystem

 * @sb: The superblock of the device

 * @bdev: block device to check

 * @blocksize: The block size of the device

 *

 * This is a library function for filesystems to check if the block device

 * can be mounted with dax option.

 *

 * Return: negative errno if unsupported, 0 if supported.

 * Return: true if supported, false if unsupported

 */

int __bdev_dax_supported(struct super_block *sb, int blocksize)

bool __bdev_dax_supported(struct block_device *bdev, int blocksize)

{

	struct block_device *bdev = sb->s_bdev;

	struct dax_device *dax_dev;

	struct request_queue *q;

	pgoff_t pgoff;

	int err, id;

	void *kaddr;

	pfn_t pfn;

	long len;

	char buf[BDEVNAME_SIZE];



	if (blocksize != PAGE_SIZE) {

		pr_err("VFS (%s): error: unsupported blocksize for dax\n",

				sb->s_id);

		return -EINVAL;

		pr_debug("%s: error: unsupported blocksize for dax\n",

				bdevname(bdev, buf));

		return false;

	}



	q = bdev_get_queue(bdev);

	if (!q || !blk_queue_dax(q)) {

		pr_debug("%s: error: request queue doesn't support dax\n",

				bdevname(bdev, buf));

		return false;

	}



	err = bdev_dax_pgoff(bdev, 0, PAGE_SIZE, &pgoff);

	if (err) {

		pr_err("VFS (%s): error: unaligned partition for dax\n",

				sb->s_id);

		return err;

		pr_debug("%s: error: unaligned partition for dax\n",

				bdevname(bdev, buf));

		return false;

	}



	dax_dev = dax_get_by_host(bdev->bd_disk->disk_name);

	if (!dax_dev) {

		pr_err("VFS (%s): error: device does not support dax\n",

				sb->s_id);

		return -EOPNOTSUPP;

		pr_debug("%s: error: device does not support dax\n",

				bdevname(bdev, buf));

		return false;

	}



	id = dax_read_lock();
@@ -118,12 +126,12 @@ int __bdev_dax_supported(struct super_block *sb, int blocksize) 
	put_dax(dax_dev);



	if (len < 1) {

		pr_err("VFS (%s): error: dax access failed (%ld)",

				sb->s_id, len);

		return len < 0 ? len : -EIO;

		pr_debug("%s: error: dax access failed (%ld)\n",

				bdevname(bdev, buf), len);

		return false;

	}



	return 0;

	return true;

}

EXPORT_SYMBOL_GPL(__bdev_dax_supported);

#endif