[linux.git] / fs / qnx6 / dir.c

// SPDX-License-Identifier: GPL-2.0
/*
 * QNX6 file system, Linux implementation.
 *
 * Version : 1.0.0
 *
 * History :
 *
 * 01-02-2012 by Kai Bankett ([email protected]) : first release.
 * 16-02-2012 pagemap extension by Al Viro
 *
 */

#include "qnx6.h"

static unsigned qnx6_lfile_checksum(char *name, unsigned size)
{
	unsigned crc = 0;
	char *end = name + size;
	while (name < end) {
		crc = ((crc >> 1) + *(name++)) ^
			((crc & 0x00000001) ? 0x80000000 : 0);
	}
	return crc;
}

static struct page *qnx6_get_page(struct inode *dir, unsigned long n)
{
	struct address_space *mapping = dir->i_mapping;
	struct page *page = read_mapping_page(mapping, n, NULL);
	if (!IS_ERR(page))
		kmap(page);
	return page;
}

static unsigned last_entry(struct inode *inode, unsigned long page_nr)
{
	unsigned long last_byte = inode->i_size;
	last_byte -= page_nr << PAGE_SHIFT;
	if (last_byte > PAGE_SIZE)
		last_byte = PAGE_SIZE;
	return last_byte / QNX6_DIR_ENTRY_SIZE;
}

static struct qnx6_long_filename *qnx6_longname(struct super_block *sb,
					 struct qnx6_long_dir_entry *de,
					 struct page **p)
{
	struct qnx6_sb_info *sbi = QNX6_SB(sb);
	u32 s = fs32_to_cpu(sbi, de->de_long_inode); /* in block units */
	u32 n = s >> (PAGE_SHIFT - sb->s_blocksize_bits); /* in pages */
	/* within page */
	u32 offs = (s << sb->s_blocksize_bits) & ~PAGE_MASK;
	struct address_space *mapping = sbi->longfile->i_mapping;
	struct page *page = read_mapping_page(mapping, n, NULL);
	if (IS_ERR(page))
		return ERR_CAST(page);
	kmap(*p = page);
	return (struct qnx6_long_filename *)(page_address(page) + offs);
}

static int qnx6_dir_longfilename(struct inode *inode,
			struct qnx6_long_dir_entry *de,
			struct dir_context *ctx,
			unsigned de_inode)
{
	struct qnx6_long_filename *lf;
	struct super_block *s = inode->i_sb;
	struct qnx6_sb_info *sbi = QNX6_SB(s);
	struct page *page;
	int lf_size;

	if (de->de_size != 0xff) {
		/* error - long filename entries always have size 0xff
		   in direntry */
		pr_err("invalid direntry size (%i).\n", de->de_size);
		return 0;
	}
	lf = qnx6_longname(s, de, &page);
	if (IS_ERR(lf)) {
		pr_err("Error reading longname\n");
		return 0;
	}

	lf_size = fs16_to_cpu(sbi, lf->lf_size);

	if (lf_size > QNX6_LONG_NAME_MAX) {
		pr_debug("file %s\n", lf->lf_fname);
		pr_err("Filename too long (%i)\n", lf_size);
		qnx6_put_page(page);
		return 0;
	}

	/* calc & validate longfilename checksum
	   mmi 3g filesystem does not have that checksum */
	if (!test_opt(s, MMI_FS) && fs32_to_cpu(sbi, de->de_checksum) !=
			qnx6_lfile_checksum(lf->lf_fname, lf_size))
		pr_info("long filename checksum error.\n");

	pr_debug("qnx6_readdir:%.*s inode:%u\n",
		 lf_size, lf->lf_fname, de_inode);
	if (!dir_emit(ctx, lf->lf_fname, lf_size, de_inode, DT_UNKNOWN)) {
		qnx6_put_page(page);
		return 0;
	}

	qnx6_put_page(page);
	/* success */
	return 1;
}

static int qnx6_readdir(struct file *file, struct dir_context *ctx)
{
	struct inode *inode = file_inode(file);
	struct super_block *s = inode->i_sb;
	struct qnx6_sb_info *sbi = QNX6_SB(s);
	loff_t pos = ctx->pos & ~(QNX6_DIR_ENTRY_SIZE - 1);
	unsigned long npages = dir_pages(inode);
	unsigned long n = pos >> PAGE_SHIFT;
	unsigned start = (pos & ~PAGE_MASK) / QNX6_DIR_ENTRY_SIZE;
	bool done = false;

	ctx->pos = pos;
	if (ctx->pos >= inode->i_size)
		return 0;

	for ( ; !done && n < npages; n++, start = 0) {
		struct page *page = qnx6_get_page(inode, n);
		int limit = last_entry(inode, n);
		struct qnx6_dir_entry *de;
		int i = start;

		if (IS_ERR(page)) {
			pr_err("%s(): read failed\n", __func__);
			ctx->pos = (n + 1) << PAGE_SHIFT;
			return PTR_ERR(page);
		}
		de = ((struct qnx6_dir_entry *)page_address(page)) + start;
		for (; i < limit; i++, de++, ctx->pos += QNX6_DIR_ENTRY_SIZE) {
			int size = de->de_size;
			u32 no_inode = fs32_to_cpu(sbi, de->de_inode);

			if (!no_inode || !size)
				continue;

			if (size > QNX6_SHORT_NAME_MAX) {
				/* long filename detected
				   get the filename from long filename
				   structure / block */
				if (!qnx6_dir_longfilename(inode,
					(struct qnx6_long_dir_entry *)de,
					ctx, no_inode)) {
					done = true;
					break;
				}
			} else {
				pr_debug("%s():%.*s inode:%u\n",
					 __func__, size, de->de_fname,
					 no_inode);
				if (!dir_emit(ctx, de->de_fname, size,
				      no_inode, DT_UNKNOWN)) {
					done = true;
					break;
				}
			}
		}
		qnx6_put_page(page);
	}
	return 0;
}

/*
 * check if the long filename is correct.
 */
static unsigned qnx6_long_match(int len, const char *name,
			struct qnx6_long_dir_entry *de, struct inode *dir)
{
	struct super_block *s = dir->i_sb;
	struct qnx6_sb_info *sbi = QNX6_SB(s);
	struct page *page;
	int thislen;
	struct qnx6_long_filename *lf = qnx6_longname(s, de, &page);

	if (IS_ERR(lf))
		return 0;

	thislen = fs16_to_cpu(sbi, lf->lf_size);
	if (len != thislen) {
		qnx6_put_page(page);
		return 0;
	}
	if (memcmp(name, lf->lf_fname, len) == 0) {
		qnx6_put_page(page);
		return fs32_to_cpu(sbi, de->de_inode);
	}
	qnx6_put_page(page);
	return 0;
}

/*
 * check if the filename is correct.
 */
static unsigned qnx6_match(struct super_block *s, int len, const char *name,
			struct qnx6_dir_entry *de)
{
	struct qnx6_sb_info *sbi = QNX6_SB(s);
	if (memcmp(name, de->de_fname, len) == 0)
		return fs32_to_cpu(sbi, de->de_inode);
	return 0;
}


unsigned qnx6_find_entry(int len, struct inode *dir, const char *name,
			 struct page **res_page)
{
	struct super_block *s = dir->i_sb;
	struct qnx6_inode_info *ei = QNX6_I(dir);
	struct page *page = NULL;
	unsigned long start, n;
	unsigned long npages = dir_pages(dir);
	unsigned ino;
	struct qnx6_dir_entry *de;
	struct qnx6_long_dir_entry *lde;

	*res_page = NULL;

	if (npages == 0)
		return 0;
	start = ei->i_dir_start_lookup;
	if (start >= npages)
		start = 0;
	n = start;

	do {
		page = qnx6_get_page(dir, n);
		if (!IS_ERR(page)) {
			int limit = last_entry(dir, n);
			int i;

			de = (struct qnx6_dir_entry *)page_address(page);
			for (i = 0; i < limit; i++, de++) {
				if (len <= QNX6_SHORT_NAME_MAX) {
					/* short filename */
					if (len != de->de_size)
						continue;
					ino = qnx6_match(s, len, name, de);
					if (ino)
						goto found;
				} else if (de->de_size == 0xff) {
					/* deal with long filename */
					lde = (struct qnx6_long_dir_entry *)de;
					ino = qnx6_long_match(len,
								name, lde, dir);
					if (ino)
						goto found;
				} else
					pr_err("undefined filename size in inode.\n");
			}
			qnx6_put_page(page);
		}

		if (++n >= npages)
			n = 0;
	} while (n != start);
	return 0;

found:
	*res_page = page;
	ei->i_dir_start_lookup = n;
	return ino;
}

const struct file_operations qnx6_dir_operations = {
	.llseek		= generic_file_llseek,
	.read		= generic_read_dir,
	.iterate_shared	= qnx6_readdir,
	.fsync		= generic_file_fsync,
};

const struct inode_operations qnx6_dir_inode_operations = {
	.lookup		= qnx6_lookup,
};
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
5d026c72 KB	2	/*
	3	* QNX6 file system, Linux implementation.
	4	*
	5	* Version : 1.0.0
	6	*
	7	* History :
	8	*
	9	* 01-02-2012 by Kai Bankett ([email protected]) : first release.
	10	* 16-02-2012 pagemap extension by Al Viro
	11	*
	12	*/
	13
	14	#include "qnx6.h"
	15
	16	static unsigned qnx6_lfile_checksum(char *name, unsigned size)
	17	{
	18	unsigned crc = 0;
	19	char *end = name + size;
	20	while (name < end) {
	21	crc = ((crc >> 1) + *(name++)) ^
	22	((crc & 0x00000001) ? 0x80000000 : 0);
	23	}
	24	return crc;
	25	}
	26
	27	static struct page qnx6_get_page(struct inode dir, unsigned long n)
	28	{
	29	struct address_space *mapping = dir->i_mapping;
	30	struct page *page = read_mapping_page(mapping, n, NULL);
	31	if (!IS_ERR(page))
	32	kmap(page);
	33	return page;
	34	}
	35
5d026c72 KB	36	static unsigned last_entry(struct inode *inode, unsigned long page_nr)
	37	{
	38	unsigned long last_byte = inode->i_size;
09cbfeaf KS	39	last_byte -= page_nr << PAGE_SHIFT;
	40	if (last_byte > PAGE_SIZE)
	41	last_byte = PAGE_SIZE;
5d026c72 KB	42	return last_byte / QNX6_DIR_ENTRY_SIZE;
	43	}
	44
	45	static struct qnx6_long_filename qnx6_longname(struct super_block sb,
	46	struct qnx6_long_dir_entry *de,
	47	struct page **p)
	48	{
	49	struct qnx6_sb_info *sbi = QNX6_SB(sb);
	50	u32 s = fs32_to_cpu(sbi, de->de_long_inode); /* in block units */
09cbfeaf	51	u32 n = s >> (PAGE_SHIFT - sb->s_blocksize_bits); /* in pages */
5d026c72	52	/* within page */
09cbfeaf	53	u32 offs = (s << sb->s_blocksize_bits) & ~PAGE_MASK;
5d026c72 KB	54	struct address_space *mapping = sbi->longfile->i_mapping;
	55	struct page *page = read_mapping_page(mapping, n, NULL);
	56	if (IS_ERR(page))
	57	return ERR_CAST(page);
	58	kmap(*p = page);
	59	return (struct qnx6_long_filename *)(page_address(page) + offs);
	60	}
	61
	62	static int qnx6_dir_longfilename(struct inode *inode,
	63	struct qnx6_long_dir_entry *de,
4deb398a AV	64	struct dir_context *ctx,
4deb398a AV	65	unsigned de_inode)
5d026c72 KB	66	{
	67	struct qnx6_long_filename *lf;
	68	struct super_block *s = inode->i_sb;
	69	struct qnx6_sb_info *sbi = QNX6_SB(s);
	70	struct page *page;
	71	int lf_size;
	72
	73	if (de->de_size != 0xff) {
	74	/* error - long filename entries always have size 0xff
	75	in direntry */
e6c32616	76	pr_err("invalid direntry size (%i).\n", de->de_size);
5d026c72 KB	77	return 0;
	78	}
	79	lf = qnx6_longname(s, de, &page);
	80	if (IS_ERR(lf)) {
e6c32616	81	pr_err("Error reading longname\n");
5d026c72 KB	82	return 0;
	83	}
	84
	85	lf_size = fs16_to_cpu(sbi, lf->lf_size);
	86
	87	if (lf_size > QNX6_LONG_NAME_MAX) {
fa5a7a41	88	pr_debug("file %s\n", lf->lf_fname);
e6c32616	89	pr_err("Filename too long (%i)\n", lf_size);
5d026c72 KB	90	qnx6_put_page(page);
	91	return 0;
	92	}
	93
	94	/* calc & validate longfilename checksum
	95	mmi 3g filesystem does not have that checksum */
	96	if (!test_opt(s, MMI_FS) && fs32_to_cpu(sbi, de->de_checksum) !=
	97	qnx6_lfile_checksum(lf->lf_fname, lf_size))
e6c32616	98	pr_info("long filename checksum error.\n");
5d026c72	99
fa5a7a41 FF	100	pr_debug("qnx6_readdir:%.*s inode:%u\n",
fa5a7a41 FF	101	lf_size, lf->lf_fname, de_inode);
4deb398a	102	if (!dir_emit(ctx, lf->lf_fname, lf_size, de_inode, DT_UNKNOWN)) {
5d026c72 KB	103	qnx6_put_page(page);
	104	return 0;
	105	}
	106
	107	qnx6_put_page(page);
	108	/* success */
	109	return 1;
	110	}
	111
4deb398a	112	static int qnx6_readdir(struct file file, struct dir_context ctx)
5d026c72	113	{
4deb398a	114	struct inode *inode = file_inode(file);
5d026c72 KB	115	struct super_block *s = inode->i_sb;
5d026c72 KB	116	struct qnx6_sb_info *sbi = QNX6_SB(s);
4deb398a	117	loff_t pos = ctx->pos & ~(QNX6_DIR_ENTRY_SIZE - 1);
5d026c72	118	unsigned long npages = dir_pages(inode);
09cbfeaf KS	119	unsigned long n = pos >> PAGE_SHIFT;
09cbfeaf KS	120	unsigned start = (pos & ~PAGE_MASK) / QNX6_DIR_ENTRY_SIZE;
5d026c72 KB	121	bool done = false;
5d026c72 KB	122
4deb398a AV	123	ctx->pos = pos;
4deb398a AV	124	if (ctx->pos >= inode->i_size)
5d026c72 KB	125	return 0;
	126
	127	for ( ; !done && n < npages; n++, start = 0) {
	128	struct page *page = qnx6_get_page(inode, n);
	129	int limit = last_entry(inode, n);
	130	struct qnx6_dir_entry *de;
	131	int i = start;
	132
	133	if (IS_ERR(page)) {
e6c32616	134	pr_err("%s(): read failed\n", __func__);
09cbfeaf	135	ctx->pos = (n + 1) << PAGE_SHIFT;
5d026c72 KB	136	return PTR_ERR(page);
	137	}
	138	de = ((struct qnx6_dir_entry *)page_address(page)) + start;
4deb398a	139	for (; i < limit; i++, de++, ctx->pos += QNX6_DIR_ENTRY_SIZE) {
5d026c72 KB	140	int size = de->de_size;
	141	u32 no_inode = fs32_to_cpu(sbi, de->de_inode);
	142
	143	if (!no_inode \|\| !size)
	144	continue;
	145
	146	if (size > QNX6_SHORT_NAME_MAX) {
	147	/* long filename detected
	148	get the filename from long filename
	149	structure / block */
	150	if (!qnx6_dir_longfilename(inode,
	151	(struct qnx6_long_dir_entry *)de,
4deb398a	152	ctx, no_inode)) {
5d026c72 KB	153	done = true;
	154	break;
	155	}
	156	} else {
fa5a7a41 FF	157	pr_debug("%s():%.*s inode:%u\n",
	158	__func__, size, de->de_fname,
	159	no_inode);
4deb398a AV	160	if (!dir_emit(ctx, de->de_fname, size,
4deb398a AV	161	no_inode, DT_UNKNOWN)) {
5d026c72 KB	162	done = true;
	163	break;
	164	}
	165	}
	166	}
	167	qnx6_put_page(page);
	168	}
5d026c72 KB	169	return 0;
	170	}
	171
	172	/*
	173	* check if the long filename is correct.
	174	*/
	175	static unsigned qnx6_long_match(int len, const char *name,
	176	struct qnx6_long_dir_entry de, struct inode dir)
	177	{
	178	struct super_block *s = dir->i_sb;
	179	struct qnx6_sb_info *sbi = QNX6_SB(s);
	180	struct page *page;
	181	int thislen;
	182	struct qnx6_long_filename *lf = qnx6_longname(s, de, &page);
	183
	184	if (IS_ERR(lf))
	185	return 0;
	186
	187	thislen = fs16_to_cpu(sbi, lf->lf_size);
	188	if (len != thislen) {
	189	qnx6_put_page(page);
	190	return 0;
	191	}
	192	if (memcmp(name, lf->lf_fname, len) == 0) {
	193	qnx6_put_page(page);
	194	return fs32_to_cpu(sbi, de->de_inode);
	195	}
	196	qnx6_put_page(page);
	197	return 0;
	198	}
	199
	200	/*
	201	* check if the filename is correct.
	202	*/
	203	static unsigned qnx6_match(struct super_block s, int len, const char name,
	204	struct qnx6_dir_entry *de)
	205	{
	206	struct qnx6_sb_info *sbi = QNX6_SB(s);
	207	if (memcmp(name, de->de_fname, len) == 0)
	208	return fs32_to_cpu(sbi, de->de_inode);
	209	return 0;
	210	}
	211
	212
	213	unsigned qnx6_find_entry(int len, struct inode dir, const char name,
	214	struct page **res_page)
	215	{
	216	struct super_block *s = dir->i_sb;
	217	struct qnx6_inode_info *ei = QNX6_I(dir);
	218	struct page *page = NULL;
	219	unsigned long start, n;
	220	unsigned long npages = dir_pages(dir);
	221	unsigned ino;
	222	struct qnx6_dir_entry *de;
	223	struct qnx6_long_dir_entry *lde;
	224
	225	*res_page = NULL;
	226
	227	if (npages == 0)
	228	return 0;
	229	start = ei->i_dir_start_lookup;
	230	if (start >= npages)
	231	start = 0;
	232	n = start;
233
234	do {
235	page = qnx6_get_page(dir, n);
236	if (!IS_ERR(page)) {
237	int limit = last_entry(dir, n);
238	int i;
239
240	de = (struct qnx6_dir_entry *)page_address(page);
241	for (i = 0; i < limit; i++, de++) {
242	if (len <= QNX6_SHORT_NAME_MAX) {
243	/* short filename */
244	if (len != de->de_size)
245	continue;
246	ino = qnx6_match(s, len, name, de);
247	if (ino)
248	goto found;
249	} else if (de->de_size == 0xff) {
250	/* deal with long filename */
251	lde = (struct qnx6_long_dir_entry *)de;
252	ino = qnx6_long_match(len,
253	name, lde, dir);
254	if (ino)
255	goto found;
256	} else
e6c32616	257	pr_err("undefined filename size in inode.\n");
5d026c72 KB	258	}
	259	qnx6_put_page(page);
	260	}
	261
	262	if (++n >= npages)
	263	n = 0;
	264	} while (n != start);
	265	return 0;
	266
	267	found:
	268	*res_page = page;
	269	ei->i_dir_start_lookup = n;
	270	return ino;
	271	}
	272
	273	const struct file_operations qnx6_dir_operations = {
	274	.llseek = generic_file_llseek,
	275	.read = generic_read_dir,
c51da20c	276	.iterate_shared = qnx6_readdir,
5d026c72 KB	277	.fsync = generic_file_fsync,
	278	};
	279
	280	const struct inode_operations qnx6_dir_inode_operations = {
	281	.lookup = qnx6_lookup,
	282	};