[linux.git] / fs / adfs / adfs.h

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

/* Internal data structures for ADFS */

#define ADFS_FREE_FRAG		 0
#define ADFS_BAD_FRAG		 1
#define ADFS_ROOT_FRAG		 2

#define ADFS_NDA_OWNER_READ	(1 << 0)
#define ADFS_NDA_OWNER_WRITE	(1 << 1)
#define ADFS_NDA_LOCKED		(1 << 2)
#define ADFS_NDA_DIRECTORY	(1 << 3)
#define ADFS_NDA_EXECUTE	(1 << 4)
#define ADFS_NDA_PUBLIC_READ	(1 << 5)
#define ADFS_NDA_PUBLIC_WRITE	(1 << 6)

#include "dir_f.h"

struct buffer_head;

/*
 * adfs file system inode data in memory
 */
struct adfs_inode_info {
	loff_t		mmu_private;
	unsigned long	parent_id;	/* object id of parent		*/
	__u32		loadaddr;	/* RISC OS load address		*/
	__u32		execaddr;	/* RISC OS exec address		*/
	unsigned int	filetype;	/* RISC OS file type		*/
	unsigned int	attr;		/* RISC OS permissions		*/
	unsigned int	stamped:1;	/* RISC OS file has date/time	*/
	struct inode vfs_inode;
};

/*
 * Forward-declare this
 */
struct adfs_discmap;
struct adfs_dir_ops;

/*
 * ADFS file system superblock data in memory
 */
struct adfs_sb_info {
	struct adfs_discmap *s_map;	/* bh list containing map		 */
	struct adfs_dir_ops *s_dir;	/* directory operations			 */

	uid_t		s_uid;		/* owner uid				 */
	gid_t		s_gid;		/* owner gid				 */
	umode_t		s_owner_mask;	/* ADFS owner perm -> unix perm		 */
	umode_t		s_other_mask;	/* ADFS other perm -> unix perm		 */
	int		s_ftsuffix;	/* ,xyz hex filetype suffix option */

	__u32		s_ids_per_zone;	/* max. no ids in one zone		 */
	__u32		s_idlen;	/* length of ID in map			 */
	__u32		s_map_size;	/* sector size of a map			 */
	unsigned long	s_size;		/* total size (in blocks) of this fs	 */
	signed int	s_map2blk;	/* shift left by this for map->sector	 */
	unsigned int	s_log2sharesize;/* log2 share size			 */
	__le32		s_version;	/* disc format version			 */
	unsigned int	s_namelen;	/* maximum number of characters in name	 */
};

static inline struct adfs_sb_info *ADFS_SB(struct super_block *sb)
{
	return sb->s_fs_info;
}

static inline struct adfs_inode_info *ADFS_I(struct inode *inode)
{
	return container_of(inode, struct adfs_inode_info, vfs_inode);
}

/*
 * Directory handling
 */
struct adfs_dir {
	struct super_block	*sb;

	int			nr_buffers;
	struct buffer_head	*bh[4];

	/* big directories need allocated buffers */
	struct buffer_head	**bh_fplus;

	unsigned int		pos;
	unsigned int		parent_id;

	struct adfs_dirheader	dirhead;
	union  adfs_dirtail	dirtail;
};

/*
 * This is the overall maximum name length
 */
#define ADFS_MAX_NAME_LEN	(256 + 4) /* +4 for ,xyz hex filetype suffix */
struct object_info {
	__u32		parent_id;		/* parent object id	*/
	__u32		file_id;		/* object id		*/
	__u32		loadaddr;		/* load address		*/
	__u32		execaddr;		/* execution address	*/
	__u32		size;			/* size			*/
	__u8		attr;			/* RISC OS attributes	*/
	unsigned int	name_len;		/* name length		*/
	char		name[ADFS_MAX_NAME_LEN];/* file name		*/

	/* RISC OS file type (12-bit: derived from loadaddr) */
	__u16		filetype;
};

/* RISC OS 12-bit filetype converts to ,xyz hex filename suffix */
static inline int append_filetype_suffix(char *buf, __u16 filetype)
{
	if (filetype == 0xffff)	/* no explicit 12-bit file type was set */
		return 0;

	*buf++ = ',';
	*buf++ = hex_asc_lo(filetype >> 8);
	*buf++ = hex_asc_lo(filetype >> 4);
	*buf++ = hex_asc_lo(filetype >> 0);
	return 4;
}

struct adfs_dir_ops {
	int	(*read)(struct super_block *sb, unsigned int id, unsigned int sz, struct adfs_dir *dir);
	int	(*setpos)(struct adfs_dir *dir, unsigned int fpos);
	int	(*getnext)(struct adfs_dir *dir, struct object_info *obj);
	int	(*update)(struct adfs_dir *dir, struct object_info *obj);
	int	(*create)(struct adfs_dir *dir, struct object_info *obj);
	int	(*remove)(struct adfs_dir *dir, struct object_info *obj);
	int	(*sync)(struct adfs_dir *dir);
	void	(*free)(struct adfs_dir *dir);
};

struct adfs_discmap {
	struct buffer_head	*dm_bh;
	__u32			dm_startblk;
	unsigned int		dm_startbit;
	unsigned int		dm_endbit;
};

/* Inode stuff */
struct inode *adfs_iget(struct super_block *sb, struct object_info *obj);
int adfs_write_inode(struct inode *inode, struct writeback_control *wbc);
int adfs_notify_change(struct dentry *dentry, struct iattr *attr);

/* map.c */
extern int adfs_map_lookup(struct super_block *sb, unsigned int frag_id, unsigned int offset);
extern unsigned int adfs_map_free(struct super_block *sb);

/* Misc */
void __adfs_error(struct super_block *sb, const char *function,
		  const char *fmt, ...);
#define adfs_error(sb, fmt...) __adfs_error(sb, __func__, fmt)

/* super.c */

/*
 * Inodes and file operations
 */

/* dir_*.c */
extern const struct inode_operations adfs_dir_inode_operations;
extern const struct file_operations adfs_dir_operations;
extern const struct dentry_operations adfs_dentry_operations;
extern struct adfs_dir_ops adfs_f_dir_ops;
extern struct adfs_dir_ops adfs_fplus_dir_ops;

extern int adfs_dir_update(struct super_block *sb, struct object_info *obj,
			   int wait);

/* file.c */
extern const struct inode_operations adfs_file_inode_operations;
extern const struct file_operations adfs_file_operations;

static inline __u32 signed_asl(__u32 val, signed int shift)
{
	if (shift >= 0)
		val <<= shift;
	else
		val >>= -shift;
	return val;
}

/*
 * Calculate the address of a block in an object given the block offset
 * and the object identity.
 *
 * The root directory ID should always be looked up in the map [3.4]
 */
static inline int
__adfs_block_map(struct super_block *sb, unsigned int object_id,
		 unsigned int block)
{
	if (object_id & 255) {
		unsigned int off;

		off = (object_id & 255) - 1;
		block += off << ADFS_SB(sb)->s_log2sharesize;
	}

	return adfs_map_lookup(sb, object_id >> 8, block);
}
Commit	Line	Data
608ba50b AV	1	#include <linux/fs.h>
	2	#include <linux/adfs_fs.h>
	3
1da177e4 LT	4	/* Internal data structures for ADFS */
	5
	6	#define ADFS_FREE_FRAG 0
	7	#define ADFS_BAD_FRAG 1
	8	#define ADFS_ROOT_FRAG 2
	9
	10	#define ADFS_NDA_OWNER_READ (1 << 0)
	11	#define ADFS_NDA_OWNER_WRITE (1 << 1)
	12	#define ADFS_NDA_LOCKED (1 << 2)
	13	#define ADFS_NDA_DIRECTORY (1 << 3)
	14	#define ADFS_NDA_EXECUTE (1 << 4)
	15	#define ADFS_NDA_PUBLIC_READ (1 << 5)
	16	#define ADFS_NDA_PUBLIC_WRITE (1 << 6)
	17
1da177e4 LT	18	#include "dir_f.h"
	19
	20	struct buffer_head;
	21
608ba50b AV	22	/*
	23	* adfs file system inode data in memory
	24	*/
	25	struct adfs_inode_info {
	26	loff_t mmu_private;
	27	unsigned long parent_id; /* object id of parent */
	28	__u32 loadaddr; /* RISC OS load address */
	29	__u32 execaddr; /* RISC OS exec address */
	30	unsigned int filetype; /* RISC OS file type */
	31	unsigned int attr; /* RISC OS permissions */
	32	unsigned int stamped:1; /* RISC OS file has date/time */
	33	struct inode vfs_inode;
	34	};
	35
	36	/*
	37	* Forward-declare this
	38	*/
	39	struct adfs_discmap;
	40	struct adfs_dir_ops;
	41
	42	/*
	43	* ADFS file system superblock data in memory
	44	*/
	45	struct adfs_sb_info {
	46	struct adfs_discmap s_map; / bh list containing map */
	47	struct adfs_dir_ops s_dir; / directory operations */
	48
	49	uid_t s_uid; /* owner uid */
	50	gid_t s_gid; /* owner gid */
	51	umode_t s_owner_mask; /* ADFS owner perm -> unix perm */
	52	umode_t s_other_mask; /* ADFS other perm -> unix perm */
da23ef05	53	int s_ftsuffix; /* ,xyz hex filetype suffix option */
608ba50b AV	54
	55	__u32 s_ids_per_zone; /* max. no ids in one zone */
	56	__u32 s_idlen; /* length of ID in map */
	57	__u32 s_map_size; /* sector size of a map */
	58	unsigned long s_size; /* total size (in blocks) of this fs */
	59	signed int s_map2blk; /* shift left by this for map->sector */
	60	unsigned int s_log2sharesize;/* log2 share size */
	61	__le32 s_version; /* disc format version */
	62	unsigned int s_namelen; /* maximum number of characters in name */
	63	};
	64
	65	static inline struct adfs_sb_info ADFS_SB(struct super_block sb)
	66	{
	67	return sb->s_fs_info;
	68	}
	69
	70	static inline struct adfs_inode_info ADFS_I(struct inode inode)
	71	{
	72	return container_of(inode, struct adfs_inode_info, vfs_inode);
	73	}
	74
1da177e4 LT	75	/*
	76	* Directory handling
	77	*/
	78	struct adfs_dir {
	79	struct super_block *sb;
	80
	81	int nr_buffers;
	82	struct buffer_head *bh[4];
2f09719a SS	83
	84	/* big directories need allocated buffers */
	85	struct buffer_head **bh_fplus;
	86
1da177e4 LT	87	unsigned int pos;
	88	unsigned int parent_id;
	89
	90	struct adfs_dirheader dirhead;
	91	union adfs_dirtail dirtail;
	92	};
	93
	94	/*
	95	* This is the overall maximum name length
	96	*/
da23ef05	97	#define ADFS_MAX_NAME_LEN (256 + 4) /* +4 for ,xyz hex filetype suffix */
1da177e4 LT	98	struct object_info {
	99	__u32 parent_id; /* parent object id */
	100	__u32 file_id; /* object id */
	101	__u32 loadaddr; /* load address */
	102	__u32 execaddr; /* execution address */
	103	__u32 size; /* size */
	104	__u8 attr; /* RISC OS attributes */
da23ef05	105	unsigned int name_len; /* name length */
1da177e4	106	char name[ADFS_MAX_NAME_LEN];/* file name */
da23ef05 SS	107
	108	/* RISC OS file type (12-bit: derived from loadaddr) */
	109	__u16 filetype;
1da177e4 LT	110	};
1da177e4 LT	111
da23ef05 SS	112	/* RISC OS 12-bit filetype converts to ,xyz hex filename suffix */
	113	static inline int append_filetype_suffix(char *buf, __u16 filetype)
	114	{
135a9fcf	115	if (filetype == 0xffff) /* no explicit 12-bit file type was set */
da23ef05 SS	116	return 0;
	117
	118	*buf++ = ',';
	119	*buf++ = hex_asc_lo(filetype >> 8);
	120	*buf++ = hex_asc_lo(filetype >> 4);
	121	*buf++ = hex_asc_lo(filetype >> 0);
	122	return 4;
	123	}
	124
1da177e4 LT	125	struct adfs_dir_ops {
	126	int (read)(struct super_block sb, unsigned int id, unsigned int sz, struct adfs_dir *dir);
	127	int (setpos)(struct adfs_dir dir, unsigned int fpos);
	128	int (getnext)(struct adfs_dir dir, struct object_info *obj);
	129	int (update)(struct adfs_dir dir, struct object_info *obj);
	130	int (create)(struct adfs_dir dir, struct object_info *obj);
	131	int (remove)(struct adfs_dir dir, struct object_info *obj);
ffdc9064	132	int (sync)(struct adfs_dir dir);
1da177e4 LT	133	void (free)(struct adfs_dir dir);
	134	};
	135
	136	struct adfs_discmap {
	137	struct buffer_head *dm_bh;
	138	__u32 dm_startblk;
	139	unsigned int dm_startbit;
	140	unsigned int dm_endbit;
	141	};
	142
	143	/* Inode stuff */
	144	struct inode adfs_iget(struct super_block sb, struct object_info *obj);
a9185b41	145	int adfs_write_inode(struct inode inode, struct writeback_control wbc);
1da177e4 LT	146	int adfs_notify_change(struct dentry dentry, struct iattr attr);
	147
	148	/* map.c */
	149	extern int adfs_map_lookup(struct super_block *sb, unsigned int frag_id, unsigned int offset);
	150	extern unsigned int adfs_map_free(struct super_block *sb);
	151
	152	/* Misc */
	153	void __adfs_error(struct super_block sb, const char function,
	154	const char *fmt, ...);
8e24eea7	155	#define adfs_error(sb, fmt...) __adfs_error(sb, __func__, fmt)
1da177e4 LT	156
	157	/* super.c */
	158
	159	/*
	160	* Inodes and file operations
	161	*/
	162
	163	/* dir_.c /
754661f1	164	extern const struct inode_operations adfs_dir_inode_operations;
4b6f5d20	165	extern const struct file_operations adfs_dir_operations;
e16404ed	166	extern const struct dentry_operations adfs_dentry_operations;
1da177e4 LT	167	extern struct adfs_dir_ops adfs_f_dir_ops;
	168	extern struct adfs_dir_ops adfs_fplus_dir_ops;
	169
ffdc9064 AV	170	extern int adfs_dir_update(struct super_block sb, struct object_info obj,
ffdc9064 AV	171	int wait);
1da177e4 LT	172
1da177e4 LT	173	/* file.c */
754661f1	174	extern const struct inode_operations adfs_file_inode_operations;
4b6f5d20	175	extern const struct file_operations adfs_file_operations;
1da177e4	176
e0c93142	177	static inline __u32 signed_asl(__u32 val, signed int shift)
1da177e4 LT	178	{
	179	if (shift >= 0)
	180	val <<= shift;
	181	else
	182	val >>= -shift;
	183	return val;
	184	}
	185
	186	/*
	187	* Calculate the address of a block in an object given the block offset
	188	* and the object identity.
	189	*
	190	* The root directory ID should always be looked up in the map [3.4]
	191	*/
e0c93142	192	static inline int
1da177e4 LT	193	__adfs_block_map(struct super_block *sb, unsigned int object_id,
	194	unsigned int block)
	195	{
	196	if (object_id & 255) {
	197	unsigned int off;
	198
	199	off = (object_id & 255) - 1;
	200	block += off << ADFS_SB(sb)->s_log2sharesize;
	201	}
	202
	203	return adfs_map_lookup(sb, object_id >> 8, block);
	204	}