Release 4.10 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 {
	union { struct {
		
struct adfs_discmap *s_map;	/* bh list containing map */
		
const struct adfs_dir_ops *s_dir; /* directory operations */
		};
		
struct rcu_head rcu;	/* used only at shutdown time    */
	};
	
kuid_t		s_uid;		/* owner uid */
	
kgid_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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
al viro
al viro
19
100.00%
1
100.00%
Total
19
100.00%
1
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
al viro
al viro
25
100.00%
1
100.00%
Total
25
100.00%
1
100.00%

/*
 * 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
stuart swales
stuart swales
64
96.97%
1
50.00%
andrew morton
andrew morton
2
3.03%
1
50.00%
Total
66
100.00%
2
100.00%


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 */
__printf(3, 4)
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 const struct adfs_dir_ops adfs_f_dir_ops;
extern const 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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
32
96.97%
1
50.00%
adrian bunk
adrian bunk
1
3.03%
1
50.00%
Total
33
100.00%
2
100.00%

/*
 * 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);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
61
93.85%
1
33.33%
dave jones
dave jones
3
4.62%
1
33.33%
adrian bunk
adrian bunk
1
1.54%
1
33.33%
Total
65
100.00%
3
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
520
62.42%
4
16.67%
al viro
al viro
184
22.09%
4
16.67%
stuart swales
stuart swales
83
9.96%
2
8.33%
andrew morton
andrew morton
15
1.80%
2
8.33%
christoph hellwig
christoph hellwig
7
0.84%
2
8.33%
joe perches
joe perches
6
0.72%
1
4.17%
arjan van de ven
arjan van de ven
4
0.48%
2
8.33%
dave jones
dave jones
3
0.36%
1
4.17%
julia lawall
julia lawall
3
0.36%
1
4.17%
russell king
russell king
2
0.24%
1
4.17%
eric w. biederman
eric w. biederman
2
0.24%
1
4.17%
adrian bunk
adrian bunk
2
0.24%
1
4.17%
andrey v. savochkin
andrey v. savochkin
1
0.12%
1
4.17%
harvey harrison
harvey harrison
1
0.12%
1
4.17%
Total
833
100.00%
24
100.00%
Directory: fs/adfs

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.