[deliverable/linux.git] / fs / adfs / dir_fplus.c

/*
 *  linux/fs/adfs/dir_fplus.c
 *
 *  Copyright (C) 1997-1999 Russell King
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/buffer_head.h>
#include <linux/slab.h>
#include "adfs.h"
#include "dir_fplus.h"

static int
adfs_fplus_read(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir)
{
	struct adfs_bigdirheader *h;
	struct adfs_bigdirtail *t;
	unsigned long block;
	unsigned int blk, size;
	int i, ret = -EIO;

	dir->nr_buffers = 0;

	/* start off using fixed bh set - only alloc for big dirs */
	dir->bh_fplus = &dir->bh[0];

	block = __adfs_block_map(sb, id, 0);
	if (!block) {
		adfs_error(sb, "dir object %X has a hole at offset 0", id);
		goto out;
	}

	dir->bh_fplus[0] = sb_bread(sb, block);
	if (!dir->bh_fplus[0])
		goto out;
	dir->nr_buffers += 1;

	h = (struct adfs_bigdirheader *)dir->bh_fplus[0]->b_data;
	size = le32_to_cpu(h->bigdirsize);
	if (size != sz) {
		printk(KERN_WARNING "adfs: adfs_fplus_read:"
					" directory header size %X\n"
					" does not match directory size %X\n",
					size, sz);
	}

	if (h->bigdirversion[0] != 0 || h->bigdirversion[1] != 0 ||
	    h->bigdirversion[2] != 0 || size & 2047 ||
	    h->bigdirstartname != cpu_to_le32(BIGDIRSTARTNAME)) {
		printk(KERN_WARNING "adfs: dir object %X has"
					" malformed dir header\n", id);
		goto out;
	}

	size >>= sb->s_blocksize_bits;
	if (size > ARRAY_SIZE(dir->bh)) {
		/* this directory is too big for fixed bh set, must allocate */
		struct buffer_head **bh_fplus =
			kcalloc(size, sizeof(struct buffer_head *),
				GFP_KERNEL);
		if (!bh_fplus) {
			adfs_error(sb, "not enough memory for"
					" dir object %X (%d blocks)", id, size);
			goto out;
		}
		dir->bh_fplus = bh_fplus;
		/* copy over the pointer to the block that we've already read */
		dir->bh_fplus[0] = dir->bh[0];
	}

	for (blk = 1; blk < size; blk++) {
		block = __adfs_block_map(sb, id, blk);
		if (!block) {
			adfs_error(sb, "dir object %X has a hole at offset %d", id, blk);
			goto out;
		}

		dir->bh_fplus[blk] = sb_bread(sb, block);
		if (!dir->bh_fplus[blk]) {
			adfs_error(sb,	"dir object %x failed read for offset %d, mapped block %lX",
				   id, blk, block);
			goto out;
		}

		dir->nr_buffers += 1;
	}

	t = (struct adfs_bigdirtail *)
		(dir->bh_fplus[size - 1]->b_data + (sb->s_blocksize - 8));

	if (t->bigdirendname != cpu_to_le32(BIGDIRENDNAME) ||
	    t->bigdirendmasseq != h->startmasseq ||
	    t->reserved[0] != 0 || t->reserved[1] != 0) {
		printk(KERN_WARNING "adfs: dir object %X has "
					"malformed dir end\n", id);
		goto out;
	}

	dir->parent_id = le32_to_cpu(h->bigdirparent);
	dir->sb = sb;
	return 0;

out:
	if (dir->bh_fplus) {
		for (i = 0; i < dir->nr_buffers; i++)
			brelse(dir->bh_fplus[i]);

		if (&dir->bh[0] != dir->bh_fplus)
			kfree(dir->bh_fplus);

		dir->bh_fplus = NULL;
	}

	dir->nr_buffers = 0;
	dir->sb = NULL;
	return ret;
}

static int
adfs_fplus_setpos(struct adfs_dir *dir, unsigned int fpos)
{
	struct adfs_bigdirheader *h =
		(struct adfs_bigdirheader *) dir->bh_fplus[0]->b_data;
	int ret = -ENOENT;

	if (fpos <= le32_to_cpu(h->bigdirentries)) {
		dir->pos = fpos;
		ret = 0;
	}

	return ret;
}

static void
dir_memcpy(struct adfs_dir *dir, unsigned int offset, void *to, int len)
{
	struct super_block *sb = dir->sb;
	unsigned int buffer, partial, remainder;

	buffer = offset >> sb->s_blocksize_bits;
	offset &= sb->s_blocksize - 1;

	partial = sb->s_blocksize - offset;

	if (partial >= len)
		memcpy(to, dir->bh_fplus[buffer]->b_data + offset, len);
	else {
		char *c = (char *)to;

		remainder = len - partial;

		memcpy(c,
			dir->bh_fplus[buffer]->b_data + offset,
			partial);

		memcpy(c + partial,
			dir->bh_fplus[buffer + 1]->b_data,
			remainder);
	}
}

static int
adfs_fplus_getnext(struct adfs_dir *dir, struct object_info *obj)
{
	struct adfs_bigdirheader *h =
		(struct adfs_bigdirheader *) dir->bh_fplus[0]->b_data;
	struct adfs_bigdirentry bde;
	unsigned int offset;
	int i, ret = -ENOENT;

	if (dir->pos >= le32_to_cpu(h->bigdirentries))
		goto out;

	offset = offsetof(struct adfs_bigdirheader, bigdirname);
	offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3);
	offset += dir->pos * sizeof(struct adfs_bigdirentry);

	dir_memcpy(dir, offset, &bde, sizeof(struct adfs_bigdirentry));

	obj->loadaddr = le32_to_cpu(bde.bigdirload);
	obj->execaddr = le32_to_cpu(bde.bigdirexec);
	obj->size     = le32_to_cpu(bde.bigdirlen);
	obj->file_id  = le32_to_cpu(bde.bigdirindaddr);
	obj->attr     = le32_to_cpu(bde.bigdirattr);
	obj->name_len = le32_to_cpu(bde.bigdirobnamelen);

	offset = offsetof(struct adfs_bigdirheader, bigdirname);
	offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3);
	offset += le32_to_cpu(h->bigdirentries) * sizeof(struct adfs_bigdirentry);
	offset += le32_to_cpu(bde.bigdirobnameptr);

	dir_memcpy(dir, offset, obj->name, obj->name_len);
	for (i = 0; i < obj->name_len; i++)
		if (obj->name[i] == '/')
			obj->name[i] = '.';

	obj->filetype = -1;

	/*
	 * object is a file and is filetyped and timestamped?
	 * RISC OS 12-bit filetype is stored in load_address[19:8]
	 */
	if ((0 == (obj->attr & ADFS_NDA_DIRECTORY)) &&
		(0xfff00000 == (0xfff00000 & obj->loadaddr))) {
		obj->filetype = (__u16) ((0x000fff00 & obj->loadaddr) >> 8);

		/* optionally append the ,xyz hex filetype suffix */
		if (ADFS_SB(dir->sb)->s_ftsuffix)
			obj->name_len +=
				append_filetype_suffix(
					&obj->name[obj->name_len],
					obj->filetype);
	}

	dir->pos += 1;
	ret = 0;
out:
	return ret;
}

static int
adfs_fplus_sync(struct adfs_dir *dir)
{
	int err = 0;
	int i;

	for (i = dir->nr_buffers - 1; i >= 0; i--) {
		struct buffer_head *bh = dir->bh_fplus[i];
		sync_dirty_buffer(bh);
		if (buffer_req(bh) && !buffer_uptodate(bh))
			err = -EIO;
	}

	return err;
}

static void
adfs_fplus_free(struct adfs_dir *dir)
{
	int i;

	if (dir->bh_fplus) {
		for (i = 0; i < dir->nr_buffers; i++)
			brelse(dir->bh_fplus[i]);

		if (&dir->bh[0] != dir->bh_fplus)
			kfree(dir->bh_fplus);

		dir->bh_fplus = NULL;
	}

	dir->nr_buffers = 0;
	dir->sb = NULL;
}

struct adfs_dir_ops adfs_fplus_dir_ops = {
	.read		= adfs_fplus_read,
	.setpos		= adfs_fplus_setpos,
	.getnext	= adfs_fplus_getnext,
	.sync		= adfs_fplus_sync,
	.free		= adfs_fplus_free
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/adfs/dir_fplus.c
	3	*
	4	* Copyright (C) 1997-1999 Russell King
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*/
1da177e4	10	#include <linux/buffer_head.h>
2f09719a	11	#include <linux/slab.h>
1da177e4 LT	12	#include "adfs.h"
	13	#include "dir_fplus.h"
	14
	15	static int
	16	adfs_fplus_read(struct super_block sb, unsigned int id, unsigned int sz, struct adfs_dir dir)
	17	{
	18	struct adfs_bigdirheader *h;
	19	struct adfs_bigdirtail *t;
	20	unsigned long block;
	21	unsigned int blk, size;
	22	int i, ret = -EIO;
	23
	24	dir->nr_buffers = 0;
	25
2f09719a SS	26	/* start off using fixed bh set - only alloc for big dirs */
	27	dir->bh_fplus = &dir->bh[0];
	28
1da177e4 LT	29	block = __adfs_block_map(sb, id, 0);
	30	if (!block) {
	31	adfs_error(sb, "dir object %X has a hole at offset 0", id);
	32	goto out;
	33	}
	34
2f09719a SS	35	dir->bh_fplus[0] = sb_bread(sb, block);
2f09719a SS	36	if (!dir->bh_fplus[0])
1da177e4 LT	37	goto out;
	38	dir->nr_buffers += 1;
	39
2f09719a	40	h = (struct adfs_bigdirheader *)dir->bh_fplus[0]->b_data;
1da177e4 LT	41	size = le32_to_cpu(h->bigdirsize);
1da177e4 LT	42	if (size != sz) {
2f09719a SS	43	printk(KERN_WARNING "adfs: adfs_fplus_read:"
	44	" directory header size %X\n"
	45	" does not match directory size %X\n",
	46	size, sz);
1da177e4 LT	47	}
	48
	49	if (h->bigdirversion[0] != 0 \|\| h->bigdirversion[1] != 0 \|\|
	50	h->bigdirversion[2] != 0 \|\| size & 2047 \|\|
2f09719a SS	51	h->bigdirstartname != cpu_to_le32(BIGDIRSTARTNAME)) {
	52	printk(KERN_WARNING "adfs: dir object %X has"
	53	" malformed dir header\n", id);
1da177e4	54	goto out;
2f09719a	55	}
1da177e4 LT	56
1da177e4 LT	57	size >>= sb->s_blocksize_bits;
e2ffcf5c	58	if (size > ARRAY_SIZE(dir->bh)) {
2f09719a SS	59	/* this directory is too big for fixed bh set, must allocate */
2f09719a SS	60	struct buffer_head **bh_fplus =
b16214d4	61	kcalloc(size, sizeof(struct buffer_head *),
2f09719a SS	62	GFP_KERNEL);
	63	if (!bh_fplus) {
	64	adfs_error(sb, "not enough memory for"
	65	" dir object %X (%d blocks)", id, size);
	66	goto out;
	67	}
	68	dir->bh_fplus = bh_fplus;
	69	/* copy over the pointer to the block that we've already read */
	70	dir->bh_fplus[0] = dir->bh[0];
	71	}
	72
1da177e4 LT	73	for (blk = 1; blk < size; blk++) {
	74	block = __adfs_block_map(sb, id, blk);
	75	if (!block) {
	76	adfs_error(sb, "dir object %X has a hole at offset %d", id, blk);
	77	goto out;
	78	}
	79
2f09719a SS	80	dir->bh_fplus[blk] = sb_bread(sb, block);
2f09719a SS	81	if (!dir->bh_fplus[blk]) {
19bdd41a JP	82	adfs_error(sb, "dir object %x failed read for offset %d, mapped block %lX",
19bdd41a JP	83	id, blk, block);
1da177e4	84	goto out;
2f09719a SS	85	}
	86
	87	dir->nr_buffers += 1;
1da177e4 LT	88	}
1da177e4 LT	89
2f09719a SS	90	t = (struct adfs_bigdirtail *)
2f09719a SS	91	(dir->bh_fplus[size - 1]->b_data + (sb->s_blocksize - 8));
1da177e4 LT	92
	93	if (t->bigdirendname != cpu_to_le32(BIGDIRENDNAME) \|\|
	94	t->bigdirendmasseq != h->startmasseq \|\|
2f09719a SS	95	t->reserved[0] != 0 \|\| t->reserved[1] != 0) {
	96	printk(KERN_WARNING "adfs: dir object %X has "
	97	"malformed dir end\n", id);
1da177e4	98	goto out;
2f09719a	99	}
1da177e4 LT	100
	101	dir->parent_id = le32_to_cpu(h->bigdirparent);
	102	dir->sb = sb;
	103	return 0;
2f09719a	104
1da177e4	105	out:
2f09719a SS	106	if (dir->bh_fplus) {
	107	for (i = 0; i < dir->nr_buffers; i++)
	108	brelse(dir->bh_fplus[i]);
	109
	110	if (&dir->bh[0] != dir->bh_fplus)
	111	kfree(dir->bh_fplus);
	112
	113	dir->bh_fplus = NULL;
	114	}
	115
	116	dir->nr_buffers = 0;
1da177e4 LT	117	dir->sb = NULL;
	118	return ret;
	119	}
	120
	121	static int
	122	adfs_fplus_setpos(struct adfs_dir *dir, unsigned int fpos)
	123	{
2f09719a SS	124	struct adfs_bigdirheader *h =
2f09719a SS	125	(struct adfs_bigdirheader *) dir->bh_fplus[0]->b_data;
1da177e4 LT	126	int ret = -ENOENT;
	127
	128	if (fpos <= le32_to_cpu(h->bigdirentries)) {
	129	dir->pos = fpos;
	130	ret = 0;
	131	}
	132
	133	return ret;
	134	}
	135
	136	static void
	137	dir_memcpy(struct adfs_dir dir, unsigned int offset, void to, int len)
	138	{
	139	struct super_block *sb = dir->sb;
	140	unsigned int buffer, partial, remainder;
	141
	142	buffer = offset >> sb->s_blocksize_bits;
	143	offset &= sb->s_blocksize - 1;
	144
	145	partial = sb->s_blocksize - offset;
	146
	147	if (partial >= len)
2f09719a	148	memcpy(to, dir->bh_fplus[buffer]->b_data + offset, len);
1da177e4 LT	149	else {
	150	char c = (char )to;
	151
	152	remainder = len - partial;
	153
2f09719a SS	154	memcpy(c,
	155	dir->bh_fplus[buffer]->b_data + offset,
	156	partial);
	157
	158	memcpy(c + partial,
	159	dir->bh_fplus[buffer + 1]->b_data,
	160	remainder);
1da177e4 LT	161	}
	162	}
	163
	164	static int
	165	adfs_fplus_getnext(struct adfs_dir dir, struct object_info obj)
	166	{
2f09719a SS	167	struct adfs_bigdirheader *h =
2f09719a SS	168	(struct adfs_bigdirheader *) dir->bh_fplus[0]->b_data;
1da177e4 LT	169	struct adfs_bigdirentry bde;
	170	unsigned int offset;
	171	int i, ret = -ENOENT;
	172
	173	if (dir->pos >= le32_to_cpu(h->bigdirentries))
	174	goto out;
	175
	176	offset = offsetof(struct adfs_bigdirheader, bigdirname);
	177	offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3);
	178	offset += dir->pos * sizeof(struct adfs_bigdirentry);
	179
	180	dir_memcpy(dir, offset, &bde, sizeof(struct adfs_bigdirentry));
	181
	182	obj->loadaddr = le32_to_cpu(bde.bigdirload);
	183	obj->execaddr = le32_to_cpu(bde.bigdirexec);
	184	obj->size = le32_to_cpu(bde.bigdirlen);
	185	obj->file_id = le32_to_cpu(bde.bigdirindaddr);
	186	obj->attr = le32_to_cpu(bde.bigdirattr);
	187	obj->name_len = le32_to_cpu(bde.bigdirobnamelen);
	188
	189	offset = offsetof(struct adfs_bigdirheader, bigdirname);
	190	offset += ((le32_to_cpu(h->bigdirnamelen) + 4) & ~3);
	191	offset += le32_to_cpu(h->bigdirentries) * sizeof(struct adfs_bigdirentry);
	192	offset += le32_to_cpu(bde.bigdirobnameptr);
	193
	194	dir_memcpy(dir, offset, obj->name, obj->name_len);
	195	for (i = 0; i < obj->name_len; i++)
	196	if (obj->name[i] == '/')
	197	obj->name[i] = '.';
	198
da23ef05 SS	199	obj->filetype = -1;
	200
	201	/*
	202	* object is a file and is filetyped and timestamped?
	203	* RISC OS 12-bit filetype is stored in load_address[19:8]
	204	*/
	205	if ((0 == (obj->attr & ADFS_NDA_DIRECTORY)) &&
	206	(0xfff00000 == (0xfff00000 & obj->loadaddr))) {
	207	obj->filetype = (__u16) ((0x000fff00 & obj->loadaddr) >> 8);
	208
	209	/* optionally append the ,xyz hex filetype suffix */
	210	if (ADFS_SB(dir->sb)->s_ftsuffix)
	211	obj->name_len +=
	212	append_filetype_suffix(
	213	&obj->name[obj->name_len],
	214	obj->filetype);
	215	}
	216
1da177e4 LT	217	dir->pos += 1;
	218	ret = 0;
	219	out:
	220	return ret;
	221	}
	222
ffdc9064 AV	223	static int
	224	adfs_fplus_sync(struct adfs_dir *dir)
	225	{
	226	int err = 0;
	227	int i;
	228
	229	for (i = dir->nr_buffers - 1; i >= 0; i--) {
2f09719a	230	struct buffer_head *bh = dir->bh_fplus[i];
ffdc9064 AV	231	sync_dirty_buffer(bh);
	232	if (buffer_req(bh) && !buffer_uptodate(bh))
	233	err = -EIO;
	234	}
	235
	236	return err;
	237	}
	238
1da177e4 LT	239	static void
	240	adfs_fplus_free(struct adfs_dir *dir)
	241	{
	242	int i;
	243
2f09719a SS	244	if (dir->bh_fplus) {
	245	for (i = 0; i < dir->nr_buffers; i++)
	246	brelse(dir->bh_fplus[i]);
	247
	248	if (&dir->bh[0] != dir->bh_fplus)
	249	kfree(dir->bh_fplus);
	250
	251	dir->bh_fplus = NULL;
	252	}
	253
	254	dir->nr_buffers = 0;
1da177e4 LT	255	dir->sb = NULL;
	256	}
	257
	258	struct adfs_dir_ops adfs_fplus_dir_ops = {
	259	.read = adfs_fplus_read,
	260	.setpos = adfs_fplus_setpos,
	261	.getnext = adfs_fplus_getnext,
ffdc9064	262	.sync = adfs_fplus_sync,
1da177e4 LT	263	.free = adfs_fplus_free
1da177e4 LT	264	};