/* SPDX-License-Identifier: GPL-2.0-only */
  /*

   * Copyright (C) 2017-2018 HUAWEI, Inc.
   *             http://www.huawei.com/
   * Created by Gao Xiang <gaoxiang25@huawei.com>

   */

  #ifndef __EROFS_INTERNAL_H
  #define __EROFS_INTERNAL_H

  
  #include <linux/fs.h>
  #include <linux/dcache.h>
  #include <linux/mm.h>
  #include <linux/pagemap.h>
  #include <linux/bio.h>
  #include <linux/buffer_head.h>

  #include <linux/magic.h>

  #include <linux/slab.h>
  #include <linux/vmalloc.h>
  #include "erofs_fs.h"
  
  /* redefine pr_fmt "erofs: " */
  #undef pr_fmt
  #define pr_fmt(fmt) "erofs: " fmt

  __printf(3, 4) void _erofs_err(struct super_block *sb,
  			       const char *function, const char *fmt, ...);
  #define erofs_err(sb, fmt, ...)	\
  	_erofs_err(sb, __func__, fmt "
  ", ##__VA_ARGS__)
  __printf(3, 4) void _erofs_info(struct super_block *sb,
  			       const char *function, const char *fmt, ...);
  #define erofs_info(sb, fmt, ...) \
  	_erofs_info(sb, __func__, fmt "
  ", ##__VA_ARGS__)

  #ifdef CONFIG_EROFS_FS_DEBUG

  #define erofs_dbg(x, ...)       pr_debug(x "
  ", ##__VA_ARGS__)

  #define DBG_BUGON               BUG_ON
  #else

  #define erofs_dbg(x, ...)       ((void)0)

  #define DBG_BUGON(x)            ((void)(x))

  #endif	/* !CONFIG_EROFS_FS_DEBUG */

  
  /* EROFS_SUPER_MAGIC_V1 to represent the whole file system */
  #define EROFS_SUPER_MAGIC   EROFS_SUPER_MAGIC_V1
  
  typedef u64 erofs_nid_t;

  typedef u64 erofs_off_t;
  /* data type for filesystem-wide blocks number */
  typedef u32 erofs_blk_t;

  
  struct erofs_sb_info {

  #ifdef CONFIG_EROFS_FS_ZIP

  	/* list for all registered superblocks, mainly for shrinker */
  	struct list_head list;

  	struct mutex umount_mutex;

  	/* the dedicated workstation for compression */
  	struct radix_tree_root workstn_tree;

  	/* threshold for decompression synchronously */
  	unsigned int max_sync_decompress_pages;

  	unsigned int shrinker_run_no;

  	/* current strategy of how to use managed cache */
  	unsigned char cache_strategy;

  	/* pseudo inode to manage cached pages */
  	struct inode *managed_cache;

  #endif	/* CONFIG_EROFS_FS_ZIP */
  	u32 blocks;
  	u32 meta_blkaddr;
  #ifdef CONFIG_EROFS_FS_XATTR
  	u32 xattr_blkaddr;

  #endif

  	/* inode slot unit size in bit shift */
  	unsigned char islotbits;

  	u32 build_time_nsec;
  	u64 build_time;
  
  	/* what we really care is nid, rather than ino.. */
  	erofs_nid_t root_nid;
  	/* used for statfs, f_files - f_favail */
  	u64 inos;
  
  	u8 uuid[16];                    /* 128-bit uuid for volume */
  	u8 volume_name[16];             /* volume name */

  	u32 feature_incompat;

  	unsigned int mount_opt;
  };
  
  #define EROFS_SB(sb) ((struct erofs_sb_info *)(sb)->s_fs_info)
  #define EROFS_I_SB(inode) ((struct erofs_sb_info *)(inode)->i_sb->s_fs_info)

  /* Mount flags set via mount options or defaults */
  #define EROFS_MOUNT_XATTR_USER		0x00000010
  #define EROFS_MOUNT_POSIX_ACL		0x00000020

  #define clear_opt(sbi, option)	((sbi)->mount_opt &= ~EROFS_MOUNT_##option)
  #define set_opt(sbi, option)	((sbi)->mount_opt |= EROFS_MOUNT_##option)
  #define test_opt(sbi, option)	((sbi)->mount_opt & EROFS_MOUNT_##option)

  #ifdef CONFIG_EROFS_FS_ZIP

  enum {
  	EROFS_ZIP_CACHE_DISABLED,
  	EROFS_ZIP_CACHE_READAHEAD,
  	EROFS_ZIP_CACHE_READAROUND
  };

  #define EROFS_LOCKED_MAGIC     (INT_MIN | 0xE0F510CCL)

  /* basic unit of the workstation of a super_block */
  struct erofs_workgroup {
  	/* the workgroup index in the workstation */
  	pgoff_t index;
  
  	/* overall workgroup reference count */
  	atomic_t refcount;
  };

  #if defined(CONFIG_SMP)
  static inline bool erofs_workgroup_try_to_freeze(struct erofs_workgroup *grp,
  						 int val)

  {

  	preempt_disable();

  	if (val != atomic_cmpxchg(&grp->refcount, val, EROFS_LOCKED_MAGIC)) {

  		preempt_enable();
  		return false;
  	}

  	return true;
  }

  static inline void erofs_workgroup_unfreeze(struct erofs_workgroup *grp,
  					    int orig_val)

  {

  	/*
  	 * other observers should notice all modifications
  	 * in the freezing period.
  	 */
  	smp_mb();

  	atomic_set(&grp->refcount, orig_val);

  	preempt_enable();
  }

  static inline int erofs_wait_on_workgroup_freezed(struct erofs_workgroup *grp)
  {
  	return atomic_cond_read_relaxed(&grp->refcount,
  					VAL != EROFS_LOCKED_MAGIC);
  }
  #else

  static inline bool erofs_workgroup_try_to_freeze(struct erofs_workgroup *grp,
  						 int val)
  {
  	preempt_disable();
  	/* no need to spin on UP platforms, let's just disable preemption. */
  	if (val != atomic_read(&grp->refcount)) {
  		preempt_enable();
  		return false;
  	}
  	return true;
  }
  
  static inline void erofs_workgroup_unfreeze(struct erofs_workgroup *grp,
  					    int orig_val)
  {
  	preempt_enable();
  }

  static inline int erofs_wait_on_workgroup_freezed(struct erofs_workgroup *grp)
  {
  	int v = atomic_read(&grp->refcount);
  
  	/* workgroup is never freezed on uniprocessor systems */
  	DBG_BUGON(v == EROFS_LOCKED_MAGIC);
  	return v;
  }

  #endif	/* !CONFIG_SMP */

  /* hard limit of pages per compressed cluster */
  #define Z_EROFS_CLUSTER_MAX_PAGES       (CONFIG_EROFS_FS_CLUSTER_PAGE_LIMIT)
  #define EROFS_PCPUBUF_NR_PAGES          Z_EROFS_CLUSTER_MAX_PAGES

  #else

  #define EROFS_PCPUBUF_NR_PAGES          0

  #endif	/* !CONFIG_EROFS_FS_ZIP */

  /* we strictly follow PAGE_SIZE and no buffer head yet */
  #define LOG_BLOCK_SIZE		PAGE_SHIFT
  
  #undef LOG_SECTORS_PER_BLOCK
  #define LOG_SECTORS_PER_BLOCK	(PAGE_SHIFT - 9)
  
  #undef SECTORS_PER_BLOCK
  #define SECTORS_PER_BLOCK	(1 << SECTORS_PER_BLOCK)
  
  #define EROFS_BLKSIZ		(1 << LOG_BLOCK_SIZE)
  
  #if (EROFS_BLKSIZ % 4096 || !EROFS_BLKSIZ)
  #error erofs cannot be used in this platform
  #endif
  
  #define ROOT_NID(sb)		((sb)->root_nid)

  #define erofs_blknr(addr)       ((addr) / EROFS_BLKSIZ)
  #define erofs_blkoff(addr)      ((addr) % EROFS_BLKSIZ)
  #define blknr_to_addr(nr)       ((erofs_off_t)(nr) * EROFS_BLKSIZ)
  
  static inline erofs_off_t iloc(struct erofs_sb_info *sbi, erofs_nid_t nid)
  {
  	return blknr_to_addr(sbi->meta_blkaddr) + (nid << sbi->islotbits);
  }

  /* atomic flag definitions */

  #define EROFS_I_EA_INITED_BIT	0
  #define EROFS_I_Z_INITED_BIT	1

  
  /* bitlock definitions (arranged in reverse order) */

  #define EROFS_I_BL_XATTR_BIT	(BITS_PER_LONG - 1)
  #define EROFS_I_BL_Z_BIT	(BITS_PER_LONG - 2)

  struct erofs_inode {

  	erofs_nid_t nid;

  
  	/* atomic flags (including bitlocks) */
  	unsigned long flags;

  	unsigned char datalayout;

  	unsigned char inode_isize;
  	unsigned short xattr_isize;

  	unsigned int xattr_shared_count;
  	unsigned int *xattr_shared_xattrs;

  	union {
  		erofs_blk_t raw_blkaddr;
  #ifdef CONFIG_EROFS_FS_ZIP
  		struct {
  			unsigned short z_advise;
  			unsigned char  z_algorithmtype[2];
  			unsigned char  z_logical_clusterbits;
  			unsigned char  z_physical_clusterbits[2];
  		};

  #endif	/* CONFIG_EROFS_FS_ZIP */

  	};

  	/* the corresponding vfs inode */
  	struct inode vfs_inode;
  };

  #define EROFS_I(ptr)	\
  	container_of(ptr, struct erofs_inode, vfs_inode)

  static inline unsigned long erofs_inode_datablocks(struct inode *inode)

  {
  	/* since i_size cannot be changed */
  	return DIV_ROUND_UP(inode->i_size, EROFS_BLKSIZ);
  }

  static inline unsigned int erofs_bitrange(unsigned int value, unsigned int bit,
  					  unsigned int bits)
  {
  
  	return (value >> bit) & ((1 << bits) - 1);
  }
  
  
  static inline unsigned int erofs_inode_version(unsigned int value)

  {

  	return erofs_bitrange(value, EROFS_I_VERSION_BIT,
  			      EROFS_I_VERSION_BITS);

  }

  static inline unsigned int erofs_inode_datalayout(unsigned int value)

  {

  	return erofs_bitrange(value, EROFS_I_DATALAYOUT_BIT,
  			      EROFS_I_DATALAYOUT_BITS);

  }
  
  extern const struct super_operations erofs_sops;

  
  extern const struct address_space_operations erofs_raw_access_aops;

  #ifdef CONFIG_EROFS_FS_ZIP
  extern const struct address_space_operations z_erofs_vle_normalaccess_aops;
  #endif

  
  /*
   * Logical to physical block mapping, used by erofs_map_blocks()
   *
   * Different with other file systems, it is used for 2 access modes:
   *
   * 1) RAW access mode:
   *
   * Users pass a valid (m_lblk, m_lofs -- usually 0) pair,
   * and get the valid m_pblk, m_pofs and the longest m_len(in bytes).
   *
   * Note that m_lblk in the RAW access mode refers to the number of
   * the compressed ondisk block rather than the uncompressed
   * in-memory block for the compressed file.
   *
   * m_pofs equals to m_lofs except for the inline data page.
   *
   * 2) Normal access mode:
   *
   * If the inode is not compressed, it has no difference with
   * the RAW access mode. However, if the inode is compressed,
   * users should pass a valid (m_lblk, m_lofs) pair, and get
   * the needed m_pblk, m_pofs, m_len to get the compressed data
   * and the updated m_lblk, m_lofs which indicates the start
   * of the corresponding uncompressed data in the file.
   */
  enum {
  	BH_Zipped = BH_PrivateStart,

  	BH_FullMapped,

  };
  
  /* Has a disk mapping */
  #define EROFS_MAP_MAPPED	(1 << BH_Mapped)
  /* Located in metadata (could be copied from bd_inode) */
  #define EROFS_MAP_META		(1 << BH_Meta)
  /* The extent has been compressed */
  #define EROFS_MAP_ZIPPED	(1 << BH_Zipped)

  /* The length of extent is full */
  #define EROFS_MAP_FULL_MAPPED	(1 << BH_FullMapped)

  
  struct erofs_map_blocks {
  	erofs_off_t m_pa, m_la;
  	u64 m_plen, m_llen;
  
  	unsigned int m_flags;

  
  	struct page *mpage;

  };
  
  /* Flags used by erofs_map_blocks() */
  #define EROFS_GET_BLOCKS_RAW    0x0001

  /* zmap.c */

  #ifdef CONFIG_EROFS_FS_ZIP

  int z_erofs_fill_inode(struct inode *inode);

  int z_erofs_map_blocks_iter(struct inode *inode,
  			    struct erofs_map_blocks *map,
  			    int flags);
  #else

  static inline int z_erofs_fill_inode(struct inode *inode) { return -EOPNOTSUPP; }

  static inline int z_erofs_map_blocks_iter(struct inode *inode,
  					  struct erofs_map_blocks *map,
  					  int flags)
  {

  	return -EOPNOTSUPP;

  }

  #endif	/* !CONFIG_EROFS_FS_ZIP */

  /* data.c */

  struct page *erofs_get_meta_page(struct super_block *sb, erofs_blk_t blkaddr);

  int erofs_map_blocks(struct inode *, struct erofs_map_blocks *, int);

  /* inode.c */

  static inline unsigned long erofs_inode_hash(erofs_nid_t nid)
  {
  #if BITS_PER_LONG == 32
  	return (nid >> 32) ^ (nid & 0xffffffff);
  #else
  	return nid;
  #endif
  }

  extern const struct inode_operations erofs_generic_iops;
  extern const struct inode_operations erofs_symlink_iops;
  extern const struct inode_operations erofs_fast_symlink_iops;

  struct inode *erofs_iget(struct super_block *sb, erofs_nid_t nid, bool dir);

  int erofs_getattr(const struct path *path, struct kstat *stat,
  		  u32 request_mask, unsigned int query_flags);

  /* namei.c */
  extern const struct inode_operations erofs_dir_iops;
  
  int erofs_namei(struct inode *dir, struct qstr *name,
  		erofs_nid_t *nid, unsigned int *d_type);
  
  /* dir.c */
  extern const struct file_operations erofs_dir_fops;

  /* utils.c / zdata.c */

  struct page *erofs_allocpage(struct list_head *pool, gfp_t gfp, bool nofail);

  
  #if (EROFS_PCPUBUF_NR_PAGES > 0)
  void *erofs_get_pcpubuf(unsigned int pagenr);
  #define erofs_put_pcpubuf(buf) do { \
  	(void)&(buf);	\
  	preempt_enable();	\
  } while (0)
  #else
  static inline void *erofs_get_pcpubuf(unsigned int pagenr)
  {

  	return ERR_PTR(-EOPNOTSUPP);

  }
  
  #define erofs_put_pcpubuf(buf) do {} while (0)
  #endif

  #ifdef CONFIG_EROFS_FS_ZIP

  int erofs_workgroup_put(struct erofs_workgroup *grp);
  struct erofs_workgroup *erofs_find_workgroup(struct super_block *sb,
  					     pgoff_t index, bool *tag);
  int erofs_register_workgroup(struct super_block *sb,
  			     struct erofs_workgroup *grp, bool tag);

  void erofs_workgroup_free_rcu(struct erofs_workgroup *grp);

  void erofs_shrinker_register(struct super_block *sb);
  void erofs_shrinker_unregister(struct super_block *sb);
  int __init erofs_init_shrinker(void);
  void erofs_exit_shrinker(void);
  int __init z_erofs_init_zip_subsystem(void);
  void z_erofs_exit_zip_subsystem(void);

  int erofs_try_to_free_all_cached_pages(struct erofs_sb_info *sbi,
  				       struct erofs_workgroup *egrp);
  int erofs_try_to_free_cached_page(struct address_space *mapping,
  				  struct page *page);

  #else
  static inline void erofs_shrinker_register(struct super_block *sb) {}
  static inline void erofs_shrinker_unregister(struct super_block *sb) {}
  static inline int erofs_init_shrinker(void) { return 0; }
  static inline void erofs_exit_shrinker(void) {}
  static inline int z_erofs_init_zip_subsystem(void) { return 0; }
  static inline void z_erofs_exit_zip_subsystem(void) {}
  #endif	/* !CONFIG_EROFS_FS_ZIP */

  #define EFSCORRUPTED    EUCLEAN         /* Filesystem is corrupted */

  #endif	/* __EROFS_INTERNAL_H */