Merge branch 'linux-4.19.y' of https://github.com/erofs/erofs-backports into qcom/sm8250

source "drivers/staging/axis-fifo/Kconfig"

source "drivers/staging/erofs/Kconfig"

source "drivers/staging/qcacld-3.0/Kconfig"

endif # STAGING

obj-$(CONFIG_SOC_MT7621)	+= mt7621-dts/

obj-$(CONFIG_STAGING_GASKET_FRAMEWORK)	+= gasket/

obj-$(CONFIG_XIL_AXIS_FIFO)	+= axis-fifo/

obj-$(CONFIG_EROFS_FS)		+= erofs/

obj-$(CONFIG_QCA_CLD_WLAN)	+= qcacld-3.0/

# SPDX-License-Identifier: GPL-2.0

EROFS_VERSION = "1.0pre1"

ccflags-y += -Wall -DEROFS_VERSION=\"$(EROFS_VERSION)\"

obj-$(CONFIG_EROFS_FS) += erofs.o

# staging requirement: to be self-contained in its own directory

ccflags-y += -I$(src)/include

erofs-objs := super.o inode.o data.o namei.o dir.o utils.o

erofs-$(CONFIG_EROFS_FS_XATTR) += xattr.o

erofs-$(CONFIG_EROFS_FS_ZIP) += unzip_vle.o unzip_lz4.o unzip_vle_lz4.o

// SPDX-License-Identifier: GPL-2.0

/*

 * linux/drivers/staging/erofs/inode.c

 *

 * Copyright (C) 2017-2018 HUAWEI, Inc.

 *             http://www.huawei.com/

 * Created by Gao Xiang <gaoxiang25@huawei.com>

 *

 * This file is subject to the terms and conditions of the GNU General Public

 * License.  See the file COPYING in the main directory of the Linux

 * distribution for more details.

 */

#include "xattr.h"

#include <trace/events/erofs.h>

/*

 * if inode is successfully read, return its inode page (or sometimes

 * the inode payload page if it's an extended inode) in order to fill

 * inline data if possible.

 */

static struct page *read_inode(struct inode *inode, unsigned int *ofs)

{

	struct super_block *sb = inode->i_sb;

	struct erofs_sb_info *sbi = EROFS_SB(sb);

	struct erofs_vnode *vi = EROFS_V(inode);

	const erofs_off_t inode_loc = iloc(sbi, vi->nid);

	erofs_blk_t blkaddr;

	struct page *page;

	struct erofs_inode_v1 *v1;

	struct erofs_inode_v2 *v2, *copied = NULL;

	unsigned int ifmt;

	int err;

	blkaddr = erofs_blknr(inode_loc);

	*ofs = erofs_blkoff(inode_loc);

	debugln("%s, reading inode nid %llu at %u of blkaddr %u",

		__func__, vi->nid, *ofs, blkaddr);

	page = erofs_get_meta_page(sb, blkaddr, false);

	if (IS_ERR(page)) {

		errln("failed to get inode (nid: %llu) page, err %ld",

		      vi->nid, PTR_ERR(page));

		return page;

	}

	v1 = page_address(page) + *ofs;

	ifmt = le16_to_cpu(v1->i_advise);

	if (ifmt & ~EROFS_I_ALL) {

		errln("unsupported i_format %u of nid %llu", ifmt, vi->nid);

		err = -EOPNOTSUPP;

		goto err_out;

	}

	vi->data_mapping_mode = __inode_data_mapping(ifmt);

	if (unlikely(vi->data_mapping_mode >= EROFS_INODE_LAYOUT_MAX)) {

		errln("unknown data mapping mode %u of nid %llu",

			vi->data_mapping_mode, vi->nid);

		err = -EOPNOTSUPP;

		goto err_out;

	}

	switch (__inode_version(ifmt)) {

	case EROFS_INODE_LAYOUT_V2:

		vi->inode_isize = sizeof(struct erofs_inode_v2);

		/* check if the inode acrosses page boundary */

		if (*ofs + vi->inode_isize <= PAGE_SIZE) {

			*ofs += vi->inode_isize;

			v2 = (struct erofs_inode_v2 *)v1;

		} else {

			const unsigned int gotten = PAGE_SIZE - *ofs;

			copied = kmalloc(vi->inode_isize, GFP_NOFS);

			if (!copied) {

				err = -ENOMEM;

				goto err_out;

			}

			memcpy(copied, v1, gotten);

			unlock_page(page);

			put_page(page);

			page = erofs_get_meta_page(sb, blkaddr + 1, false);

			if (IS_ERR(page)) {

				errln("failed to get inode payload page (nid: %llu), err %ld",

				      vi->nid, PTR_ERR(page));

				kfree(copied);

				return page;

			}

			*ofs = vi->inode_isize - gotten;

			memcpy((u8 *)copied + gotten, page_address(page), *ofs);

			v2 = copied;

		}

		vi->xattr_isize = ondisk_xattr_ibody_size(v2->i_xattr_icount);

		inode->i_mode = le16_to_cpu(v2->i_mode);

		if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||

						S_ISLNK(inode->i_mode)) {

			vi->raw_blkaddr = le32_to_cpu(v2->i_u.raw_blkaddr);

		} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {

			inode->i_rdev =

				new_decode_dev(le32_to_cpu(v2->i_u.rdev));

		} else if (S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {

			inode->i_rdev = 0;

		} else {

			goto bogusimode;

		}

		i_uid_write(inode, le32_to_cpu(v2->i_uid));

		i_gid_write(inode, le32_to_cpu(v2->i_gid));

		set_nlink(inode, le32_to_cpu(v2->i_nlink));

		/* extended inode has its own timestamp */

		inode->i_ctime.tv_sec = le64_to_cpu(v2->i_ctime);

		inode->i_ctime.tv_nsec = le32_to_cpu(v2->i_ctime_nsec);

		inode->i_size = le64_to_cpu(v2->i_size);

		kfree(copied);

		break;

	case EROFS_INODE_LAYOUT_V1:

		vi->inode_isize = sizeof(struct erofs_inode_v1);

		*ofs += vi->inode_isize;

		vi->xattr_isize = ondisk_xattr_ibody_size(v1->i_xattr_icount);

		inode->i_mode = le16_to_cpu(v1->i_mode);

		if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||

						S_ISLNK(inode->i_mode)) {

			vi->raw_blkaddr = le32_to_cpu(v1->i_u.raw_blkaddr);

		} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {

			inode->i_rdev =

				new_decode_dev(le32_to_cpu(v1->i_u.rdev));

		} else if (S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {

			inode->i_rdev = 0;

		} else {

			goto bogusimode;

		}

		i_uid_write(inode, le16_to_cpu(v1->i_uid));

		i_gid_write(inode, le16_to_cpu(v1->i_gid));

		set_nlink(inode, le16_to_cpu(v1->i_nlink));

		/* use build time for compact inodes */

		inode->i_ctime.tv_sec = sbi->build_time;

		inode->i_ctime.tv_nsec = sbi->build_time_nsec;

		inode->i_size = le32_to_cpu(v1->i_size);

		break;

	default:

		errln("unsupported on-disk inode version %u of nid %llu",

		      __inode_version(ifmt), vi->nid);

		err = -EOPNOTSUPP;

		goto err_out;

	}

	inode->i_mtime.tv_sec = inode->i_ctime.tv_sec;

	inode->i_atime.tv_sec = inode->i_ctime.tv_sec;

	inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec;

	inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec;

	/* measure inode.i_blocks as the generic filesystem */

	inode->i_blocks = ((inode->i_size - 1) >> 9) + 1;

	return page;

bogusimode:

	errln("bogus i_mode (%o) @ nid %llu", inode->i_mode, vi->nid);

	err = -EIO;

err_out:

	DBG_BUGON(1);

	kfree(copied);

	unlock_page(page);

	put_page(page);

	return ERR_PTR(err);

}

/*

 * try_lock can be required since locking order is:

 *   file data(fs_inode)

 *        meta(bd_inode)

 * but the majority of the callers is "iget",

 * in that case we are pretty sure no deadlock since

 * no data operations exist. However I tend to

 * try_lock since it takes no much overhead and

 * will success immediately.

 */

static int fill_inline_data(struct inode *inode, void *data, unsigned m_pofs)

{

	struct erofs_vnode *vi = EROFS_V(inode);

	struct erofs_sb_info *sbi = EROFS_I_SB(inode);

	int mode = vi->data_mapping_mode;

	DBG_BUGON(mode >= EROFS_INODE_LAYOUT_MAX);

	/* should be inode inline C */

	if (mode != EROFS_INODE_LAYOUT_INLINE)

		return 0;

	/* fast symlink (following ext4) */

	if (S_ISLNK(inode->i_mode) && inode->i_size < PAGE_SIZE) {

		char *lnk = erofs_kmalloc(sbi, inode->i_size + 1, GFP_KERNEL);

		if (unlikely(lnk == NULL))

			return -ENOMEM;

		m_pofs += vi->xattr_isize;

		/* inline symlink data shouldn't across page boundary as well */

		if (unlikely(m_pofs + inode->i_size > PAGE_SIZE)) {

			DBG_BUGON(1);

			kfree(lnk);

			return -EIO;

		}

		/* get in-page inline data */

		memcpy(lnk, data + m_pofs, inode->i_size);

		lnk[inode->i_size] = '\0';

		inode->i_link = lnk;

		set_inode_fast_symlink(inode);

	}

	return -EAGAIN;

}

static int fill_inode(struct inode *inode, int isdir)

{

	struct page *page;

	unsigned int ofs;

	int err = 0;

	trace_erofs_fill_inode(inode, isdir);

	/* read inode base data from disk */

	page = read_inode(inode, &ofs);

	if (IS_ERR(page)) {

		return PTR_ERR(page);

	} else {

		/* setup the new inode */

		if (S_ISREG(inode->i_mode)) {

#ifdef CONFIG_EROFS_FS_XATTR

			inode->i_op = &erofs_generic_xattr_iops;

#endif

			inode->i_fop = &generic_ro_fops;

		} else if (S_ISDIR(inode->i_mode)) {

			inode->i_op =

#ifdef CONFIG_EROFS_FS_XATTR

				&erofs_dir_xattr_iops;

#else

				&erofs_dir_iops;

#endif

			inode->i_fop = &erofs_dir_fops;

		} else if (S_ISLNK(inode->i_mode)) {

			/* by default, page_get_link is used for symlink */

			inode->i_op =

#ifdef CONFIG_EROFS_FS_XATTR

				&erofs_symlink_xattr_iops,

#else

				&page_symlink_inode_operations;

#endif

			inode_nohighmem(inode);

		} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||

			S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {

#ifdef CONFIG_EROFS_FS_XATTR

			inode->i_op = &erofs_special_inode_operations;

#endif

			init_special_inode(inode, inode->i_mode, inode->i_rdev);

		} else {

			err = -EIO;

			goto out_unlock;

		}

		if (is_inode_layout_compression(inode)) {

#ifdef CONFIG_EROFS_FS_ZIP

			inode->i_mapping->a_ops =

				&z_erofs_vle_normalaccess_aops;

#else

			err = -ENOTSUPP;

#endif

			goto out_unlock;

		}

		inode->i_mapping->a_ops = &erofs_raw_access_aops;

		/* fill last page if inline data is available */

		fill_inline_data(inode, page_address(page), ofs);

	}

out_unlock:

	unlock_page(page);

	put_page(page);

	return err;

}

struct inode *erofs_iget(struct super_block *sb,

	erofs_nid_t nid, bool isdir)

{

	struct inode *inode = iget_locked(sb, nid);

	if (unlikely(inode == NULL))

		return ERR_PTR(-ENOMEM);

	if (inode->i_state & I_NEW) {

		int err;

		struct erofs_vnode *vi = EROFS_V(inode);

		vi->nid = nid;

		err = fill_inode(inode, isdir);

		if (likely(!err))

			unlock_new_inode(inode);

		else {

			iget_failed(inode);

			inode = ERR_PTR(err);

		}

	}

	return inode;

}

#ifdef CONFIG_EROFS_FS_XATTR

const struct inode_operations erofs_generic_xattr_iops = {

	.listxattr = erofs_listxattr,

};

#endif

#ifdef CONFIG_EROFS_FS_XATTR

const struct inode_operations erofs_symlink_xattr_iops = {

	.get_link = page_get_link,

	.listxattr = erofs_listxattr,

};

#endif

const struct inode_operations erofs_special_inode_operations = {

#ifdef CONFIG_EROFS_FS_XATTR

	.listxattr = erofs_listxattr,

#endif

};

#ifdef CONFIG_EROFS_FS_XATTR

const struct inode_operations erofs_fast_symlink_xattr_iops = {

	.get_link = simple_get_link,

	.listxattr = erofs_listxattr,

};

#endif

#ifndef __LZ4DEFS_H__

#define __LZ4DEFS_H__

/*

 * lz4defs.h -- common and architecture specific defines for the kernel usage

 * LZ4 - Fast LZ compression algorithm

 * Copyright (C) 2011-2016, Yann Collet.

 * BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are

 * met:

 *	* Redistributions of source code must retain the above copyright

 *	  notice, this list of conditions and the following disclaimer.

 *	* Redistributions in binary form must reproduce the above

 * copyright notice, this list of conditions and the following disclaimer

 * in the documentation and/or other materials provided with the

 * distribution.

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 * You can contact the author at :

 *	- LZ4 homepage : http://www.lz4.org

 *	- LZ4 source repository : https://github.com/lz4/lz4

 *

 *	Changed for kernel usage by:

 *	Sven Schmidt <4sschmid@informatik.uni-hamburg.de>

 */

#include <asm/unaligned.h>

#include <linux/string.h>	 /* memset, memcpy */

#define FORCE_INLINE __always_inline

/*-************************************

 *	Basic Types

 **************************************/

#include <linux/types.h>

typedef	uint8_t BYTE;

typedef uint16_t U16;

typedef uint32_t U32;

typedef	int32_t S32;

typedef uint64_t U64;

typedef uintptr_t uptrval;

/*-************************************

 *	Architecture specifics

 **************************************/

#if defined(CONFIG_64BIT)

#define LZ4_ARCH64 1

#else

#define LZ4_ARCH64 0

#endif

#if defined(__LITTLE_ENDIAN)

#define LZ4_LITTLE_ENDIAN 1

#else

#define LZ4_LITTLE_ENDIAN 0

#endif

/*-************************************

 *	Constants

 **************************************/

#define MINMATCH 4

#define WILDCOPYLENGTH 8

#define LASTLITERALS 5

#define MFLIMIT (WILDCOPYLENGTH + MINMATCH)

/* Increase this value ==> compression run slower on incompressible data */

#define LZ4_SKIPTRIGGER 6

#define HASH_UNIT sizeof(size_t)

#define KB (1 << 10)

#define MB (1 << 20)

#define GB (1U << 30)

#define MAXD_LOG 16

#define MAX_DISTANCE ((1 << MAXD_LOG) - 1)

#define STEPSIZE sizeof(size_t)

#define ML_BITS	4

#define ML_MASK	((1U << ML_BITS) - 1)

#define RUN_BITS (8 - ML_BITS)

#define RUN_MASK ((1U << RUN_BITS) - 1)

/*-************************************

 *	Reading and writing into memory

 **************************************/

static FORCE_INLINE U16 LZ4_read16(const void *ptr)

{

	return get_unaligned((const U16 *)ptr);

}

static FORCE_INLINE U32 LZ4_read32(const void *ptr)

{

	return get_unaligned((const U32 *)ptr);

}

static FORCE_INLINE size_t LZ4_read_ARCH(const void *ptr)

{

	return get_unaligned((const size_t *)ptr);

}

static FORCE_INLINE void LZ4_write16(void *memPtr, U16 value)

{

	put_unaligned(value, (U16 *)memPtr);

}

static FORCE_INLINE void LZ4_write32(void *memPtr, U32 value)

{

	put_unaligned(value, (U32 *)memPtr);

}

static FORCE_INLINE U16 LZ4_readLE16(const void *memPtr)

{

	return get_unaligned_le16(memPtr);

}

static FORCE_INLINE void LZ4_writeLE16(void *memPtr, U16 value)

{

	return put_unaligned_le16(value, memPtr);

}

static FORCE_INLINE void LZ4_copy8(void *dst, const void *src)

{

#if LZ4_ARCH64

	U64 a = get_unaligned((const U64 *)src);

	put_unaligned(a, (U64 *)dst);

#else

	U32 a = get_unaligned((const U32 *)src);

	U32 b = get_unaligned((const U32 *)src + 1);

	put_unaligned(a, (U32 *)dst);

	put_unaligned(b, (U32 *)dst + 1);

#endif

}

/*

 * customized variant of memcpy,

 * which can overwrite up to 7 bytes beyond dstEnd

 */

static FORCE_INLINE void LZ4_wildCopy(void *dstPtr,

	const void *srcPtr, void *dstEnd)

{

	BYTE *d = (BYTE *)dstPtr;

	const BYTE *s = (const BYTE *)srcPtr;

	BYTE *const e = (BYTE *)dstEnd;

	do {

		LZ4_copy8(d, s);

		d += 8;

		s += 8;

	} while (d < e);

}

static FORCE_INLINE unsigned int LZ4_NbCommonBytes(register size_t val)

{

#if LZ4_LITTLE_ENDIAN

	return __ffs(val) >> 3;

#else

	return (BITS_PER_LONG - 1 - __fls(val)) >> 3;

#endif

}

static FORCE_INLINE unsigned int LZ4_count(

	const BYTE *pIn,

	const BYTE *pMatch,

	const BYTE *pInLimit)

{

	const BYTE *const pStart = pIn;

	while (likely(pIn < pInLimit - (STEPSIZE - 1))) {

		size_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);

		if (!diff) {

			pIn += STEPSIZE;

			pMatch += STEPSIZE;

			continue;

		}

		pIn += LZ4_NbCommonBytes(diff);

		return (unsigned int)(pIn - pStart);

	}

#if LZ4_ARCH64

	if ((pIn < (pInLimit - 3))

		&& (LZ4_read32(pMatch) == LZ4_read32(pIn))) {

		pIn += 4;

		pMatch += 4;

	}

#endif

	if ((pIn < (pInLimit - 1))

		&& (LZ4_read16(pMatch) == LZ4_read16(pIn))) {

		pIn += 2;

		pMatch += 2;

	}

	if ((pIn < pInLimit) && (*pMatch == *pIn))

		pIn++;

	return (unsigned int)(pIn - pStart);

}

typedef enum { noLimit = 0, limitedOutput = 1 } limitedOutput_directive;

typedef enum { byPtr, byU32, byU16 } tableType_t;

typedef enum { noDict = 0, withPrefix64k, usingExtDict } dict_directive;

typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;

typedef enum { endOnOutputSize = 0, endOnInputSize = 1 } endCondition_directive;

typedef enum { full = 0, partial = 1 } earlyEnd_directive;

#endif