[mirror_ubuntu-zesty-kernel.git] / fs / qnx6 / dir.c

/*
 * QNX6 file system, Linux implementation.
 *
 * Version : 1.0.0
 *
 * History :
 *
 * 01-02-2012 by Kai Bankett (chaosman@ontika.net) : 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 inline unsigned long dir_pages(struct inode *inode)
{
	return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
}

static unsigned last_entry(struct inode *inode, unsigned long page_nr)
{
	unsigned long last_byte = inode->i_size;
	last_byte -= page_nr << PAGE_CACHE_SHIFT;
	if (last_byte > PAGE_CACHE_SIZE)
		last_byte = PAGE_CACHE_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_CACHE_SHIFT - sb->s_blocksize_bits); /* in pages */
	/* within page */
	u32 offs = (s << sb->s_blocksize_bits) & ~PAGE_CACHE_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 */
		printk(KERN_ERR "qnx6: invalid direntry size (%i).\n",
				de->de_size);
		return 0;
	}
	lf = qnx6_longname(s, de, &page);
	if (IS_ERR(lf)) {
		printk(KERN_ERR "qnx6:Error reading longname\n");
		return 0;
	}

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

	if (lf_size > QNX6_LONG_NAME_MAX) {
		QNX6DEBUG((KERN_INFO "file %s\n", lf->lf_fname));
		printk(KERN_ERR "qnx6: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))
		printk(KERN_INFO "qnx6: long filename checksum error.\n");

	QNX6DEBUG((KERN_INFO "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_CACHE_SHIFT;
	unsigned start = (pos & ~PAGE_CACHE_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)) {
			printk(KERN_ERR "qnx6_readdir: read failed\n");
			ctx->pos = (n + 1) << PAGE_CACHE_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 {
				QNX6DEBUG((KERN_INFO "qnx6_readdir:%.*s"
				   " inode:%u\n", 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
					printk(KERN_ERR "qnx6: 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	= qnx6_readdir,
	.fsync		= generic_file_fsync,
};

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