[linux-block.git] / fs / ntfs3 / dir.c

// SPDX-License-Identifier: GPL-2.0
/*
 *
 * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
 *
 *  Directory handling functions for NTFS-based filesystems.
 *
 */

#include <linux/fs.h>
#include <linux/nls.h>

#include "debug.h"
#include "ntfs.h"
#include "ntfs_fs.h"

/* Convert little endian UTF-16 to NLS string. */
int ntfs_utf16_to_nls(struct ntfs_sb_info *sbi, const __le16 *name, u32 len,
		      u8 *buf, int buf_len)
{
	int ret, warn;
	u8 *op;
	struct nls_table *nls = sbi->options->nls;

	static_assert(sizeof(wchar_t) == sizeof(__le16));

	if (!nls) {
		/* UTF-16 -> UTF-8 */
		ret = utf16s_to_utf8s((wchar_t *)name, len, UTF16_LITTLE_ENDIAN,
				      buf, buf_len);
		buf[ret] = '\0';
		return ret;
	}

	op = buf;
	warn = 0;

	while (len--) {
		u16 ec;
		int charlen;
		char dump[5];

		if (buf_len < NLS_MAX_CHARSET_SIZE) {
			ntfs_warn(sbi->sb,
				  "filename was truncated while converting.");
			break;
		}

		ec = le16_to_cpu(*name++);
		charlen = nls->uni2char(ec, op, buf_len);

		if (charlen > 0) {
			op += charlen;
			buf_len -= charlen;
			continue;
		}

		*op++ = '_';
		buf_len -= 1;
		if (warn)
			continue;

		warn = 1;
		hex_byte_pack(&dump[0], ec >> 8);
		hex_byte_pack(&dump[2], ec);
		dump[4] = 0;

		ntfs_err(sbi->sb, "failed to convert \"%s\" to %s", dump,
			 nls->charset);
	}

	*op = '\0';
	return op - buf;
}

// clang-format off
#define PLANE_SIZE	0x00010000

#define SURROGATE_PAIR	0x0000d800
#define SURROGATE_LOW	0x00000400
#define SURROGATE_BITS	0x000003ff
// clang-format on

/*
 * put_utf16 - Modified version of put_utf16 from fs/nls/nls_base.c
 *
 * Function is sparse warnings free.
 */
static inline void put_utf16(wchar_t *s, unsigned int c,
			     enum utf16_endian endian)
{
	static_assert(sizeof(wchar_t) == sizeof(__le16));
	static_assert(sizeof(wchar_t) == sizeof(__be16));

	switch (endian) {
	default:
		*s = (wchar_t)c;
		break;
	case UTF16_LITTLE_ENDIAN:
		*(__le16 *)s = __cpu_to_le16(c);
		break;
	case UTF16_BIG_ENDIAN:
		*(__be16 *)s = __cpu_to_be16(c);
		break;
	}
}

/*
 * _utf8s_to_utf16s
 *
 * Modified version of 'utf8s_to_utf16s' allows to
 * detect -ENAMETOOLONG without writing out of expected maximum.
 */
static int _utf8s_to_utf16s(const u8 *s, int inlen, enum utf16_endian endian,
			    wchar_t *pwcs, int maxout)
{
	u16 *op;
	int size;
	unicode_t u;

	op = pwcs;
	while (inlen > 0 && *s) {
		if (*s & 0x80) {
			size = utf8_to_utf32(s, inlen, &u);
			if (size < 0)
				return -EINVAL;
			s += size;
			inlen -= size;

			if (u >= PLANE_SIZE) {
				if (maxout < 2)
					return -ENAMETOOLONG;

				u -= PLANE_SIZE;
				put_utf16(op++,
					  SURROGATE_PAIR |
						  ((u >> 10) & SURROGATE_BITS),
					  endian);
				put_utf16(op++,
					  SURROGATE_PAIR | SURROGATE_LOW |
						  (u & SURROGATE_BITS),
					  endian);
				maxout -= 2;
			} else {
				if (maxout < 1)
					return -ENAMETOOLONG;

				put_utf16(op++, u, endian);
				maxout--;
			}
		} else {
			if (maxout < 1)
				return -ENAMETOOLONG;

			put_utf16(op++, *s++, endian);
			inlen--;
			maxout--;
		}
	}
	return op - pwcs;
}

/*
 * ntfs_nls_to_utf16 - Convert input string to UTF-16.
 * @name:	Input name.
 * @name_len:	Input name length.
 * @uni:	Destination memory.
 * @max_ulen:	Destination memory.
 * @endian:	Endian of target UTF-16 string.
 *
 * This function is called:
 * - to create NTFS name
 * - to create symlink
 *
 * Return: UTF-16 string length or error (if negative).
 */
int ntfs_nls_to_utf16(struct ntfs_sb_info *sbi, const u8 *name, u32 name_len,
		      struct cpu_str *uni, u32 max_ulen,
		      enum utf16_endian endian)
{
	int ret, slen;
	const u8 *end;
	struct nls_table *nls = sbi->options->nls;
	u16 *uname = uni->name;

	static_assert(sizeof(wchar_t) == sizeof(u16));

	if (!nls) {
		/* utf8 -> utf16 */
		ret = _utf8s_to_utf16s(name, name_len, endian, uname, max_ulen);
		uni->len = ret;
		return ret;
	}

	for (ret = 0, end = name + name_len; name < end; ret++, name += slen) {
		if (ret >= max_ulen)
			return -ENAMETOOLONG;

		slen = nls->char2uni(name, end - name, uname + ret);
		if (!slen)
			return -EINVAL;
		if (slen < 0)
			return slen;
	}

#ifdef __BIG_ENDIAN
	if (endian == UTF16_LITTLE_ENDIAN) {
		int i = ret;

		while (i--) {
			__cpu_to_le16s(uname);
			uname++;
		}
	}
#else
	if (endian == UTF16_BIG_ENDIAN) {
		int i = ret;

		while (i--) {
			__cpu_to_be16s(uname);
			uname++;
		}
	}
#endif

	uni->len = ret;
	return ret;
}

/*
 * dir_search_u - Helper function.
 */
struct inode *dir_search_u(struct inode *dir, const struct cpu_str *uni,
			   struct ntfs_fnd *fnd)
{
	int err = 0;
	struct super_block *sb = dir->i_sb;
	struct ntfs_sb_info *sbi = sb->s_fs_info;
	struct ntfs_inode *ni = ntfs_i(dir);
	struct NTFS_DE *e;
	int diff;
	struct inode *inode = NULL;
	struct ntfs_fnd *fnd_a = NULL;

	if (!fnd) {
		fnd_a = fnd_get();
		if (!fnd_a) {
			err = -ENOMEM;
			goto out;
		}
		fnd = fnd_a;
	}

	err = indx_find(&ni->dir, ni, NULL, uni, 0, sbi, &diff, &e, fnd);

	if (err)
		goto out;

	if (diff) {
		err = -ENOENT;
		goto out;
	}

	inode = ntfs_iget5(sb, &e->ref, uni);
	if (!IS_ERR(inode) && is_bad_inode(inode)) {
		iput(inode);
		err = -EINVAL;
	}
out:
	fnd_put(fnd_a);

	return err == -ENOENT ? NULL : err ? ERR_PTR(err) : inode;
}

static inline int ntfs_filldir(struct ntfs_sb_info *sbi, struct ntfs_inode *ni,
			       const struct NTFS_DE *e, u8 *name,
			       struct dir_context *ctx)
{
	const struct ATTR_FILE_NAME *fname;
	unsigned long ino;
	int name_len;
	u32 dt_type;

	fname = Add2Ptr(e, sizeof(struct NTFS_DE));

	if (fname->type == FILE_NAME_DOS)
		return 0;

	if (!mi_is_ref(&ni->mi, &fname->home))
		return 0;

	ino = ino_get(&e->ref);

	if (ino == MFT_REC_ROOT)
		return 0;

	/* Skip meta files. Unless option to show metafiles is set. */
	if (!sbi->options->showmeta && ntfs_is_meta_file(sbi, ino))
		return 0;

	if (sbi->options->nohidden && (fname->dup.fa & FILE_ATTRIBUTE_HIDDEN))
		return 0;

	name_len = ntfs_utf16_to_nls(sbi, fname->name, fname->name_len, name,
				     PATH_MAX);
	if (name_len <= 0) {
		ntfs_warn(sbi->sb, "failed to convert name for inode %lx.",
			  ino);
		return 0;
	}

	dt_type = (fname->dup.fa & FILE_ATTRIBUTE_DIRECTORY) ? DT_DIR : DT_REG;

	return !dir_emit(ctx, (s8 *)name, name_len, ino, dt_type);
}

/*
 * ntfs_read_hdr - Helper function for ntfs_readdir().
 */
static int ntfs_read_hdr(struct ntfs_sb_info *sbi, struct ntfs_inode *ni,
			 const struct INDEX_HDR *hdr, u64 vbo, u64 pos,
			 u8 *name, struct dir_context *ctx)
{
	int err;
	const struct NTFS_DE *e;
	u32 e_size;
	u32 end = le32_to_cpu(hdr->used);
	u32 off = le32_to_cpu(hdr->de_off);

	for (;; off += e_size) {
		if (off + sizeof(struct NTFS_DE) > end)
			return -1;

		e = Add2Ptr(hdr, off);
		e_size = le16_to_cpu(e->size);
		if (e_size < sizeof(struct NTFS_DE) || off + e_size > end)
			return -1;

		if (de_is_last(e))
			return 0;

		/* Skip already enumerated. */
		if (vbo + off < pos)
			continue;

		if (le16_to_cpu(e->key_size) < SIZEOF_ATTRIBUTE_FILENAME)
			return -1;

		ctx->pos = vbo + off;

		/* Submit the name to the filldir callback. */
		err = ntfs_filldir(sbi, ni, e, name, ctx);
		if (err)
			return err;
	}
}

/*
 * ntfs_readdir - file_operations::iterate_shared
 *
 * Use non sorted enumeration.
 * We have an example of broken volume where sorted enumeration
 * counts each name twice.
 */
static int ntfs_readdir(struct file *file, struct dir_context *ctx)
{
	const struct INDEX_ROOT *root;
	u64 vbo;
	size_t bit;
	loff_t eod;
	int err = 0;
	struct inode *dir = file_inode(file);
	struct ntfs_inode *ni = ntfs_i(dir);
	struct super_block *sb = dir->i_sb;
	struct ntfs_sb_info *sbi = sb->s_fs_info;
	loff_t i_size = i_size_read(dir);
	u32 pos = ctx->pos;
	u8 *name = NULL;
	struct indx_node *node = NULL;
	u8 index_bits = ni->dir.index_bits;

	/* Name is a buffer of PATH_MAX length. */
	static_assert(NTFS_NAME_LEN * 4 < PATH_MAX);

	eod = i_size + sbi->record_size;

	if (pos >= eod)
		return 0;

	if (!dir_emit_dots(file, ctx))
		return 0;

	/* Allocate PATH_MAX bytes. */
	name = __getname();
	if (!name)
		return -ENOMEM;

	if (!ni->mi_loaded && ni->attr_list.size) {
		/*
		 * Directory inode is locked for read.
		 * Load all subrecords to avoid 'write' access to 'ni' during
		 * directory reading.
		 */
		ni_lock(ni);
		if (!ni->mi_loaded && ni->attr_list.size) {
			err = ni_load_all_mi(ni);
			if (!err)
				ni->mi_loaded = true;
		}
		ni_unlock(ni);
		if (err)
			goto out;
	}

	root = indx_get_root(&ni->dir, ni, NULL, NULL);
	if (!root) {
		err = -EINVAL;
		goto out;
	}

	if (pos >= sbi->record_size) {
		bit = (pos - sbi->record_size) >> index_bits;
	} else {
		err = ntfs_read_hdr(sbi, ni, &root->ihdr, 0, pos, name, ctx);
		if (err)
			goto out;
		bit = 0;
	}

	if (!i_size) {
		ctx->pos = eod;
		goto out;
	}

	for (;;) {
		vbo = (u64)bit << index_bits;
		if (vbo >= i_size) {
			ctx->pos = eod;
			goto out;
		}

		err = indx_used_bit(&ni->dir, ni, &bit);
		if (err)
			goto out;

		if (bit == MINUS_ONE_T) {
			ctx->pos = eod;
			goto out;
		}

		vbo = (u64)bit << index_bits;
		if (vbo >= i_size) {
			ntfs_inode_err(dir, "Looks like your dir is corrupt");
			err = -EINVAL;
			goto out;
		}

		err = indx_read(&ni->dir, ni, bit << ni->dir.idx2vbn_bits,
				&node);
		if (err)
			goto out;

		err = ntfs_read_hdr(sbi, ni, &node->index->ihdr,
				    vbo + sbi->record_size, pos, name, ctx);
		if (err)
			goto out;

		bit += 1;
	}

out:

	__putname(name);
	put_indx_node(node);

	if (err == -ENOENT) {
		err = 0;
		ctx->pos = pos;
	}

	return err;
}

static int ntfs_dir_count(struct inode *dir, bool *is_empty, size_t *dirs,
			  size_t *files)
{
	int err = 0;
	struct ntfs_inode *ni = ntfs_i(dir);
	struct NTFS_DE *e = NULL;
	struct INDEX_ROOT *root;
	struct INDEX_HDR *hdr;
	const struct ATTR_FILE_NAME *fname;
	u32 e_size, off, end;
	u64 vbo = 0;
	size_t drs = 0, fles = 0, bit = 0;
	loff_t i_size = ni->vfs_inode.i_size;
	struct indx_node *node = NULL;
	u8 index_bits = ni->dir.index_bits;

	if (is_empty)
		*is_empty = true;

	root = indx_get_root(&ni->dir, ni, NULL, NULL);
	if (!root)
		return -EINVAL;

	hdr = &root->ihdr;

	for (;;) {
		end = le32_to_cpu(hdr->used);
		off = le32_to_cpu(hdr->de_off);

		for (; off + sizeof(struct NTFS_DE) <= end; off += e_size) {
			e = Add2Ptr(hdr, off);
			e_size = le16_to_cpu(e->size);
			if (e_size < sizeof(struct NTFS_DE) ||
			    off + e_size > end)
				break;

			if (de_is_last(e))
				break;

			fname = de_get_fname(e);
			if (!fname)
				continue;

			if (fname->type == FILE_NAME_DOS)
				continue;

			if (is_empty) {
				*is_empty = false;
				if (!dirs && !files)
					goto out;
			}

			if (fname->dup.fa & FILE_ATTRIBUTE_DIRECTORY)
				drs += 1;
			else
				fles += 1;
		}

		if (vbo >= i_size)
			goto out;

		err = indx_used_bit(&ni->dir, ni, &bit);
		if (err)
			goto out;

		if (bit == MINUS_ONE_T)
			goto out;

		vbo = (u64)bit << index_bits;
		if (vbo >= i_size)
			goto out;

		err = indx_read(&ni->dir, ni, bit << ni->dir.idx2vbn_bits,
				&node);
		if (err)
			goto out;

		hdr = &node->index->ihdr;
		bit += 1;
		vbo = (u64)bit << ni->dir.idx2vbn_bits;
	}

out:
	put_indx_node(node);
	if (dirs)
		*dirs = drs;
	if (files)
		*files = fles;

	return err;
}

bool dir_is_empty(struct inode *dir)
{
	bool is_empty = false;

	ntfs_dir_count(dir, &is_empty, NULL, NULL);

	return is_empty;
}

// clang-format off
const struct file_operations ntfs_dir_operations = {
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
	.iterate_shared	= ntfs_readdir,
	.fsync		= generic_file_fsync,
	.open		= ntfs_file_open,
};
// clang-format on
Commit	Line	Data
4342306f KK	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	*
	4	* Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
	5	*
e8b8e97f	6	* Directory handling functions for NTFS-based filesystems.
4342306f KK	7	*
4342306f KK	8	*/
e8b8e97f	9
4342306f	10	#include <linux/fs.h>
4342306f KK	11	#include <linux/nls.h>
	12
	13	#include "debug.h"
	14	#include "ntfs.h"
	15	#include "ntfs_fs.h"
	16
e8b8e97f	17	/* Convert little endian UTF-16 to NLS string. */
2c690788	18	int ntfs_utf16_to_nls(struct ntfs_sb_info sbi, const __le16 name, u32 len,
4342306f KK	19	u8 *buf, int buf_len)
4342306f KK	20	{
2c690788	21	int ret, warn;
4342306f	22	u8 *op;
564c97bd	23	struct nls_table *nls = sbi->options->nls;
4342306f KK	24
	25	static_assert(sizeof(wchar_t) == sizeof(__le16));
	26
	27	if (!nls) {
e8b8e97f	28	/* UTF-16 -> UTF-8 */
9144b438 KK	29	ret = utf16s_to_utf8s((wchar_t *)name, len, UTF16_LITTLE_ENDIAN,
9144b438 KK	30	buf, buf_len);
4342306f KK	31	buf[ret] = '\0';
	32	return ret;
	33	}
	34
4342306f	35	op = buf;
4342306f KK	36	warn = 0;
4342306f KK	37
2c690788	38	while (len--) {
4342306f KK	39	u16 ec;
	40	int charlen;
	41	char dump[5];
	42
	43	if (buf_len < NLS_MAX_CHARSET_SIZE) {
	44	ntfs_warn(sbi->sb,
	45	"filename was truncated while converting.");
	46	break;
	47	}
	48
2c690788	49	ec = le16_to_cpu(*name++);
4342306f KK	50	charlen = nls->uni2char(ec, op, buf_len);
	51
	52	if (charlen > 0) {
	53	op += charlen;
	54	buf_len -= charlen;
	55	continue;
	56	}
	57
	58	*op++ = '_';
	59	buf_len -= 1;
	60	if (warn)
	61	continue;
	62
	63	warn = 1;
	64	hex_byte_pack(&dump[0], ec >> 8);
	65	hex_byte_pack(&dump[2], ec);
	66	dump[4] = 0;
	67
	68	ntfs_err(sbi->sb, "failed to convert \"%s\" to %s", dump,
	69	nls->charset);
	70	}
	71
	72	*op = '\0';
	73	return op - buf;
	74	}
	75
	76	// clang-format off
	77	#define PLANE_SIZE 0x00010000
	78
	79	#define SURROGATE_PAIR 0x0000d800
	80	#define SURROGATE_LOW 0x00000400
	81	#define SURROGATE_BITS 0x000003ff
	82	// clang-format on
	83
	84	/*
e8b8e97f KA	85	* put_utf16 - Modified version of put_utf16 from fs/nls/nls_base.c
	86	*
	87	* Function is sparse warnings free.
4342306f KK	88	*/
	89	static inline void put_utf16(wchar_t *s, unsigned int c,
	90	enum utf16_endian endian)
	91	{
	92	static_assert(sizeof(wchar_t) == sizeof(__le16));
	93	static_assert(sizeof(wchar_t) == sizeof(__be16));
	94
	95	switch (endian) {
	96	default:
	97	*s = (wchar_t)c;
	98	break;
	99	case UTF16_LITTLE_ENDIAN:
	100	(__le16 )s = __cpu_to_le16(c);
	101	break;
	102	case UTF16_BIG_ENDIAN:
	103	(__be16 )s = __cpu_to_be16(c);
	104	break;
	105	}
	106	}
	107
	108	/*
e8b8e97f KA	109	* _utf8s_to_utf16s
	110	*
	111	* Modified version of 'utf8s_to_utf16s' allows to
	112	* detect -ENAMETOOLONG without writing out of expected maximum.
4342306f KK	113	*/
	114	static int _utf8s_to_utf16s(const u8 *s, int inlen, enum utf16_endian endian,
	115	wchar_t *pwcs, int maxout)
	116	{
	117	u16 *op;
	118	int size;
	119	unicode_t u;
	120
	121	op = pwcs;
	122	while (inlen > 0 && *s) {
	123	if (*s & 0x80) {
	124	size = utf8_to_utf32(s, inlen, &u);
	125	if (size < 0)
	126	return -EINVAL;
	127	s += size;
	128	inlen -= size;
	129
	130	if (u >= PLANE_SIZE) {
	131	if (maxout < 2)
	132	return -ENAMETOOLONG;
	133
	134	u -= PLANE_SIZE;
	135	put_utf16(op++,
	136	SURROGATE_PAIR \|
	137	((u >> 10) & SURROGATE_BITS),
	138	endian);
	139	put_utf16(op++,
	140	SURROGATE_PAIR \| SURROGATE_LOW \|
	141	(u & SURROGATE_BITS),
	142	endian);
	143	maxout -= 2;
	144	} else {
	145	if (maxout < 1)
	146	return -ENAMETOOLONG;
	147
	148	put_utf16(op++, u, endian);
	149	maxout--;
	150	}
	151	} else {
	152	if (maxout < 1)
	153	return -ENAMETOOLONG;
	154
	155	put_utf16(op++, *s++, endian);
	156	inlen--;
	157	maxout--;
	158	}
	159	}
	160	return op - pwcs;
	161	}
	162
	163	/*
e8b8e97f KA	164	* ntfs_nls_to_utf16 - Convert input string to UTF-16.
	165	* @name: Input name.
	166	* @name_len: Input name length.
	167	* @uni: Destination memory.
	168	* @max_ulen: Destination memory.
	169	* @endian: Endian of target UTF-16 string.
4342306f KK	170	*
4342306f KK	171	* This function is called:
e8b8e97f	172	* - to create NTFS name
4342306f KK	173	* - to create symlink
4342306f KK	174	*
e8b8e97f	175	* Return: UTF-16 string length or error (if negative).
4342306f KK	176	*/
	177	int ntfs_nls_to_utf16(struct ntfs_sb_info sbi, const u8 name, u32 name_len,
	178	struct cpu_str *uni, u32 max_ulen,
	179	enum utf16_endian endian)
	180	{
	181	int ret, slen;
	182	const u8 *end;
564c97bd	183	struct nls_table *nls = sbi->options->nls;
4342306f KK	184	u16 *uname = uni->name;
	185
	186	static_assert(sizeof(wchar_t) == sizeof(u16));
	187
	188	if (!nls) {
	189	/* utf8 -> utf16 */
	190	ret = _utf8s_to_utf16s(name, name_len, endian, uname, max_ulen);
	191	uni->len = ret;
	192	return ret;
	193	}
	194
	195	for (ret = 0, end = name + name_len; name < end; ret++, name += slen) {
	196	if (ret >= max_ulen)
	197	return -ENAMETOOLONG;
	198
	199	slen = nls->char2uni(name, end - name, uname + ret);
	200	if (!slen)
	201	return -EINVAL;
	202	if (slen < 0)
	203	return slen;
	204	}
	205
	206	#ifdef __BIG_ENDIAN
	207	if (endian == UTF16_LITTLE_ENDIAN) {
	208	int i = ret;
	209
	210	while (i--) {
	211	__cpu_to_le16s(uname);
	212	uname++;
	213	}
	214	}
	215	#else
	216	if (endian == UTF16_BIG_ENDIAN) {
	217	int i = ret;
	218
	219	while (i--) {
	220	__cpu_to_be16s(uname);
	221	uname++;
	222	}
	223	}
	224	#endif
	225
	226	uni->len = ret;
	227	return ret;
	228	}
	229
e8b8e97f KA	230	/*
	231	* dir_search_u - Helper function.
	232	*/
4342306f KK	233	struct inode dir_search_u(struct inode dir, const struct cpu_str *uni,
	234	struct ntfs_fnd *fnd)
	235	{
	236	int err = 0;
	237	struct super_block *sb = dir->i_sb;
	238	struct ntfs_sb_info *sbi = sb->s_fs_info;
	239	struct ntfs_inode *ni = ntfs_i(dir);
	240	struct NTFS_DE *e;
	241	int diff;
	242	struct inode *inode = NULL;
	243	struct ntfs_fnd *fnd_a = NULL;
	244
	245	if (!fnd) {
	246	fnd_a = fnd_get();
	247	if (!fnd_a) {
	248	err = -ENOMEM;
	249	goto out;
	250	}
	251	fnd = fnd_a;
	252	}
	253
	254	err = indx_find(&ni->dir, ni, NULL, uni, 0, sbi, &diff, &e, fnd);
	255
	256	if (err)
	257	goto out;
	258
	259	if (diff) {
	260	err = -ENOENT;
	261	goto out;
	262	}
	263
	264	inode = ntfs_iget5(sb, &e->ref, uni);
	265	if (!IS_ERR(inode) && is_bad_inode(inode)) {
	266	iput(inode);
	267	err = -EINVAL;
	268	}
	269	out:
	270	fnd_put(fnd_a);
	271
	272	return err == -ENOENT ? NULL : err ? ERR_PTR(err) : inode;
	273	}
	274
	275	static inline int ntfs_filldir(struct ntfs_sb_info sbi, struct ntfs_inode ni,
	276	const struct NTFS_DE e, u8 name,
	277	struct dir_context *ctx)
	278	{
	279	const struct ATTR_FILE_NAME *fname;
	280	unsigned long ino;
	281	int name_len;
	282	u32 dt_type;
	283
	284	fname = Add2Ptr(e, sizeof(struct NTFS_DE));
	285
	286	if (fname->type == FILE_NAME_DOS)
	287	return 0;
	288
	289	if (!mi_is_ref(&ni->mi, &fname->home))
	290	return 0;
	291
	292	ino = ino_get(&e->ref);
	293
	294	if (ino == MFT_REC_ROOT)
	295	return 0;
	296
e8b8e97f	297	/* Skip meta files. Unless option to show metafiles is set. */
564c97bd	298	if (!sbi->options->showmeta && ntfs_is_meta_file(sbi, ino))
4342306f KK	299	return 0;
4342306f KK	300
564c97bd	301	if (sbi->options->nohidden && (fname->dup.fa & FILE_ATTRIBUTE_HIDDEN))
4342306f KK	302	return 0;
4342306f KK	303
2c690788 KK	304	name_len = ntfs_utf16_to_nls(sbi, fname->name, fname->name_len, name,
2c690788 KK	305	PATH_MAX);
4342306f KK	306	if (name_len <= 0) {
	307	ntfs_warn(sbi->sb, "failed to convert name for inode %lx.",
	308	ino);
	309	return 0;
	310	}
	311
	312	dt_type = (fname->dup.fa & FILE_ATTRIBUTE_DIRECTORY) ? DT_DIR : DT_REG;
	313
	314	return !dir_emit(ctx, (s8 *)name, name_len, ino, dt_type);
	315	}
	316
	317	/*
e8b8e97f	318	* ntfs_read_hdr - Helper function for ntfs_readdir().
4342306f KK	319	*/
	320	static int ntfs_read_hdr(struct ntfs_sb_info sbi, struct ntfs_inode ni,
	321	const struct INDEX_HDR *hdr, u64 vbo, u64 pos,
	322	u8 name, struct dir_context ctx)
	323	{
	324	int err;
	325	const struct NTFS_DE *e;
	326	u32 e_size;
	327	u32 end = le32_to_cpu(hdr->used);
	328	u32 off = le32_to_cpu(hdr->de_off);
	329
	330	for (;; off += e_size) {
	331	if (off + sizeof(struct NTFS_DE) > end)
	332	return -1;
	333
	334	e = Add2Ptr(hdr, off);
	335	e_size = le16_to_cpu(e->size);
	336	if (e_size < sizeof(struct NTFS_DE) \|\| off + e_size > end)
	337	return -1;
	338
	339	if (de_is_last(e))
	340	return 0;
	341
e8b8e97f	342	/* Skip already enumerated. */
4342306f KK	343	if (vbo + off < pos)
	344	continue;
	345
	346	if (le16_to_cpu(e->key_size) < SIZEOF_ATTRIBUTE_FILENAME)
	347	return -1;
	348
	349	ctx->pos = vbo + off;
	350
	351	/* Submit the name to the filldir callback. */
	352	err = ntfs_filldir(sbi, ni, e, name, ctx);
	353	if (err)
	354	return err;
	355	}
	356	}
	357
	358	/*
e8b8e97f	359	* ntfs_readdir - file_operations::iterate_shared
4342306f KK	360	*
	361	* Use non sorted enumeration.
	362	* We have an example of broken volume where sorted enumeration
e8b8e97f	363	* counts each name twice.
4342306f KK	364	*/
	365	static int ntfs_readdir(struct file file, struct dir_context ctx)
	366	{
	367	const struct INDEX_ROOT *root;
	368	u64 vbo;
	369	size_t bit;
	370	loff_t eod;
	371	int err = 0;
	372	struct inode *dir = file_inode(file);
	373	struct ntfs_inode *ni = ntfs_i(dir);
	374	struct super_block *sb = dir->i_sb;
	375	struct ntfs_sb_info *sbi = sb->s_fs_info;
	376	loff_t i_size = i_size_read(dir);
	377	u32 pos = ctx->pos;
	378	u8 *name = NULL;
	379	struct indx_node *node = NULL;
	380	u8 index_bits = ni->dir.index_bits;
	381
e8b8e97f	382	/* Name is a buffer of PATH_MAX length. */
4342306f KK	383	static_assert(NTFS_NAME_LEN * 4 < PATH_MAX);
	384
	385	eod = i_size + sbi->record_size;
	386
	387	if (pos >= eod)
	388	return 0;
	389
	390	if (!dir_emit_dots(file, ctx))
	391	return 0;
	392
e8b8e97f	393	/* Allocate PATH_MAX bytes. */
4342306f KK	394	name = __getname();
	395	if (!name)
	396	return -ENOMEM;
	397
	398	if (!ni->mi_loaded && ni->attr_list.size) {
	399	/*
e8b8e97f KA	400	* Directory inode is locked for read.
	401	* Load all subrecords to avoid 'write' access to 'ni' during
	402	* directory reading.
4342306f KK	403	*/
	404	ni_lock(ni);
	405	if (!ni->mi_loaded && ni->attr_list.size) {
	406	err = ni_load_all_mi(ni);
	407	if (!err)
	408	ni->mi_loaded = true;
	409	}
	410	ni_unlock(ni);
	411	if (err)
	412	goto out;
	413	}
	414
	415	root = indx_get_root(&ni->dir, ni, NULL, NULL);
	416	if (!root) {
	417	err = -EINVAL;
	418	goto out;
	419	}
	420
	421	if (pos >= sbi->record_size) {
	422	bit = (pos - sbi->record_size) >> index_bits;
	423	} else {
	424	err = ntfs_read_hdr(sbi, ni, &root->ihdr, 0, pos, name, ctx);
	425	if (err)
	426	goto out;
	427	bit = 0;
	428	}
	429
	430	if (!i_size) {
	431	ctx->pos = eod;
	432	goto out;
	433	}
	434
	435	for (;;) {
	436	vbo = (u64)bit << index_bits;
	437	if (vbo >= i_size) {
	438	ctx->pos = eod;
	439	goto out;
	440	}
	441
	442	err = indx_used_bit(&ni->dir, ni, &bit);
	443	if (err)
	444	goto out;
	445
	446	if (bit == MINUS_ONE_T) {
	447	ctx->pos = eod;
	448	goto out;
	449	}
	450
	451	vbo = (u64)bit << index_bits;
	452	if (vbo >= i_size) {
	453	ntfs_inode_err(dir, "Looks like your dir is corrupt");
	454	err = -EINVAL;
	455	goto out;
	456	}
	457
	458	err = indx_read(&ni->dir, ni, bit << ni->dir.idx2vbn_bits,
	459	&node);
	460	if (err)
	461	goto out;
	462
	463	err = ntfs_read_hdr(sbi, ni, &node->index->ihdr,
	464	vbo + sbi->record_size, pos, name, ctx);
	465	if (err)
	466	goto out;
467
468	bit += 1;
469	}
470
471	out:
472
473	__putname(name);
474	put_indx_node(node);
475
476	if (err == -ENOENT) {
477	err = 0;
478	ctx->pos = pos;
479	}
480
481	return err;
482	}
483
484	static int ntfs_dir_count(struct inode dir, bool is_empty, size_t *dirs,
485	size_t *files)
486	{
487	int err = 0;
488	struct ntfs_inode *ni = ntfs_i(dir);
489	struct NTFS_DE *e = NULL;
490	struct INDEX_ROOT *root;
491	struct INDEX_HDR *hdr;
492	const struct ATTR_FILE_NAME *fname;
493	u32 e_size, off, end;
494	u64 vbo = 0;
495	size_t drs = 0, fles = 0, bit = 0;
496	loff_t i_size = ni->vfs_inode.i_size;
497	struct indx_node *node = NULL;
498	u8 index_bits = ni->dir.index_bits;
499
500	if (is_empty)
501	*is_empty = true;
502
503	root = indx_get_root(&ni->dir, ni, NULL, NULL);
504	if (!root)
505	return -EINVAL;
506
507	hdr = &root->ihdr;
508
509	for (;;) {
510	end = le32_to_cpu(hdr->used);
511	off = le32_to_cpu(hdr->de_off);
512
513	for (; off + sizeof(struct NTFS_DE) <= end; off += e_size) {
514	e = Add2Ptr(hdr, off);
515	e_size = le16_to_cpu(e->size);
516	if (e_size < sizeof(struct NTFS_DE) \|\|
517	off + e_size > end)
518	break;
519
520	if (de_is_last(e))
521	break;
522
523	fname = de_get_fname(e);
524	if (!fname)
525	continue;
526
527	if (fname->type == FILE_NAME_DOS)
528	continue;
529
530	if (is_empty) {
531	*is_empty = false;
532	if (!dirs && !files)
533	goto out;
534	}
535
536	if (fname->dup.fa & FILE_ATTRIBUTE_DIRECTORY)
537	drs += 1;
538	else
539	fles += 1;
540	}
541
542	if (vbo >= i_size)
543	goto out;
544
545	err = indx_used_bit(&ni->dir, ni, &bit);
546	if (err)
547	goto out;
548
549	if (bit == MINUS_ONE_T)
550	goto out;
551
552	vbo = (u64)bit << index_bits;
553	if (vbo >= i_size)
554	goto out;
555
556	err = indx_read(&ni->dir, ni, bit << ni->dir.idx2vbn_bits,
557	&node);
558	if (err)
559	goto out;
560
561	hdr = &node->index->ihdr;
562	bit += 1;
563	vbo = (u64)bit << ni->dir.idx2vbn_bits;
564	}
565
566	out:
567	put_indx_node(node);
568	if (dirs)
569	*dirs = drs;
570	if (files)
571	*files = fles;
572
573	return err;
574	}
575
576	bool dir_is_empty(struct inode *dir)
577	{
578	bool is_empty = false;
579
580	ntfs_dir_count(dir, &is_empty, NULL, NULL);
581
582	return is_empty;
583	}
584
585	// clang-format off
586	const struct file_operations ntfs_dir_operations = {
587	.llseek = generic_file_llseek,
588	.read = generic_read_dir,
589	.iterate_shared = ntfs_readdir,
590	.fsync = generic_file_fsync,
591	.open = ntfs_file_open,
592	};
593	// clang-format on