| 1 |
/* SPDX-License-Identifier: GPL-2.0 */ |
| 2 |
#include <linux/buffer_head.h> |
| 3 |
#include <linux/fs.h> |
| 4 |
#include <linux/adfs_fs.h> |
| 5 |
|
| 6 |
/* Internal data structures for ADFS */ |
| 7 |
|
| 8 |
#define ADFS_FREE_FRAG 0 |
| 9 |
#define ADFS_BAD_FRAG 1 |
| 10 |
#define ADFS_ROOT_FRAG 2 |
| 11 |
|
| 12 |
#define ADFS_FILETYPE_NONE ((u16)~0) |
| 13 |
|
| 14 |
/* RISC OS 12-bit filetype is stored in load_address[19:8] */ |
| 15 |
static inline u16 adfs_filetype(u32 loadaddr) |
| 16 |
{ |
| 17 |
return (loadaddr & 0xfff00000) == 0xfff00000 ? |
| 18 |
(loadaddr >> 8) & 0xfff : ADFS_FILETYPE_NONE; |
| 19 |
} |
| 20 |
|
| 21 |
#define ADFS_NDA_OWNER_READ (1 << 0) |
| 22 |
#define ADFS_NDA_OWNER_WRITE (1 << 1) |
| 23 |
#define ADFS_NDA_LOCKED (1 << 2) |
| 24 |
#define ADFS_NDA_DIRECTORY (1 << 3) |
| 25 |
#define ADFS_NDA_EXECUTE (1 << 4) |
| 26 |
#define ADFS_NDA_PUBLIC_READ (1 << 5) |
| 27 |
#define ADFS_NDA_PUBLIC_WRITE (1 << 6) |
| 28 |
|
| 29 |
/* |
| 30 |
* adfs file system inode data in memory |
| 31 |
*/ |
| 32 |
struct adfs_inode_info { |
| 33 |
loff_t mmu_private; |
| 34 |
__u32 parent_id; /* parent indirect disc address */ |
| 35 |
__u32 indaddr; /* object indirect disc address */ |
| 36 |
__u32 loadaddr; /* RISC OS load address */ |
| 37 |
__u32 execaddr; /* RISC OS exec address */ |
| 38 |
unsigned int attr; /* RISC OS permissions */ |
| 39 |
struct inode vfs_inode; |
| 40 |
}; |
| 41 |
|
| 42 |
static inline struct adfs_inode_info *ADFS_I(struct inode *inode) |
| 43 |
{ |
| 44 |
return container_of(inode, struct adfs_inode_info, vfs_inode); |
| 45 |
} |
| 46 |
|
| 47 |
static inline bool adfs_inode_is_stamped(struct inode *inode) |
| 48 |
{ |
| 49 |
return (ADFS_I(inode)->loadaddr & 0xfff00000) == 0xfff00000; |
| 50 |
} |
| 51 |
|
| 52 |
/* |
| 53 |
* Forward-declare this |
| 54 |
*/ |
| 55 |
struct adfs_discmap; |
| 56 |
struct adfs_dir_ops; |
| 57 |
|
| 58 |
/* |
| 59 |
* ADFS file system superblock data in memory |
| 60 |
*/ |
| 61 |
struct adfs_sb_info { |
| 62 |
union { struct { |
| 63 |
struct adfs_discmap *s_map; /* bh list containing map */ |
| 64 |
const struct adfs_dir_ops *s_dir; /* directory operations */ |
| 65 |
}; |
| 66 |
struct rcu_head rcu; /* used only at shutdown time */ |
| 67 |
}; |
| 68 |
kuid_t s_uid; /* owner uid */ |
| 69 |
kgid_t s_gid; /* owner gid */ |
| 70 |
umode_t s_owner_mask; /* ADFS owner perm -> unix perm */ |
| 71 |
umode_t s_other_mask; /* ADFS other perm -> unix perm */ |
| 72 |
int s_ftsuffix; /* ,xyz hex filetype suffix option */ |
| 73 |
|
| 74 |
__u32 s_ids_per_zone; /* max. no ids in one zone */ |
| 75 |
__u32 s_idlen; /* length of ID in map */ |
| 76 |
__u32 s_map_size; /* sector size of a map */ |
| 77 |
signed int s_map2blk; /* shift left by this for map->sector*/ |
| 78 |
unsigned int s_log2sharesize;/* log2 share size */ |
| 79 |
unsigned int s_namelen; /* maximum number of characters in name */ |
| 80 |
}; |
| 81 |
|
| 82 |
static inline struct adfs_sb_info *ADFS_SB(struct super_block *sb) |
| 83 |
{ |
| 84 |
return sb->s_fs_info; |
| 85 |
} |
| 86 |
|
| 87 |
/* |
| 88 |
* Directory handling |
| 89 |
*/ |
| 90 |
struct adfs_dir { |
| 91 |
struct super_block *sb; |
| 92 |
|
| 93 |
int nr_buffers; |
| 94 |
struct buffer_head *bh[4]; |
| 95 |
struct buffer_head **bhs; |
| 96 |
|
| 97 |
unsigned int pos; |
| 98 |
__u32 parent_id; |
| 99 |
|
| 100 |
union { |
| 101 |
struct adfs_dirheader *dirhead; |
| 102 |
struct adfs_bigdirheader *bighead; |
| 103 |
}; |
| 104 |
union { |
| 105 |
struct adfs_newdirtail *newtail; |
| 106 |
struct adfs_bigdirtail *bigtail; |
| 107 |
}; |
| 108 |
}; |
| 109 |
|
| 110 |
/* |
| 111 |
* This is the overall maximum name length |
| 112 |
*/ |
| 113 |
#define ADFS_MAX_NAME_LEN (256 + 4) /* +4 for ,xyz hex filetype suffix */ |
| 114 |
struct object_info { |
| 115 |
__u32 parent_id; /* parent object id */ |
| 116 |
__u32 indaddr; /* indirect disc addr */ |
| 117 |
__u32 loadaddr; /* load address */ |
| 118 |
__u32 execaddr; /* execution address */ |
| 119 |
__u32 size; /* size */ |
| 120 |
__u8 attr; /* RISC OS attributes */ |
| 121 |
unsigned int name_len; /* name length */ |
| 122 |
char name[ADFS_MAX_NAME_LEN];/* file name */ |
| 123 |
}; |
| 124 |
|
| 125 |
struct adfs_dir_ops { |
| 126 |
int (*read)(struct super_block *sb, unsigned int indaddr, |
| 127 |
unsigned int size, struct adfs_dir *dir); |
| 128 |
int (*iterate)(struct adfs_dir *dir, struct dir_context *ctx); |
| 129 |
int (*setpos)(struct adfs_dir *dir, unsigned int fpos); |
| 130 |
int (*getnext)(struct adfs_dir *dir, struct object_info *obj); |
| 131 |
int (*update)(struct adfs_dir *dir, struct object_info *obj); |
| 132 |
int (*create)(struct adfs_dir *dir, struct object_info *obj); |
| 133 |
int (*remove)(struct adfs_dir *dir, struct object_info *obj); |
| 134 |
int (*commit)(struct adfs_dir *dir); |
| 135 |
}; |
| 136 |
|
| 137 |
struct adfs_discmap { |
| 138 |
struct buffer_head *dm_bh; |
| 139 |
__u32 dm_startblk; |
| 140 |
unsigned int dm_startbit; |
| 141 |
unsigned int dm_endbit; |
| 142 |
}; |
| 143 |
|
| 144 |
/* Inode stuff */ |
| 145 |
struct inode *adfs_iget(struct super_block *sb, struct object_info *obj); |
| 146 |
int adfs_write_inode(struct inode *inode, struct writeback_control *wbc); |
| 147 |
int adfs_notify_change(struct mnt_idmap *idmap, struct dentry *dentry, |
| 148 |
struct iattr *attr); |
| 149 |
|
| 150 |
/* map.c */ |
| 151 |
int adfs_map_lookup(struct super_block *sb, u32 frag_id, unsigned int offset); |
| 152 |
void adfs_map_statfs(struct super_block *sb, struct kstatfs *buf); |
| 153 |
struct adfs_discmap *adfs_read_map(struct super_block *sb, struct adfs_discrecord *dr); |
| 154 |
void adfs_free_map(struct super_block *sb); |
| 155 |
|
| 156 |
/* Misc */ |
| 157 |
__printf(3, 4) |
| 158 |
void __adfs_error(struct super_block *sb, const char *function, |
| 159 |
const char *fmt, ...); |
| 160 |
#define adfs_error(sb, fmt...) __adfs_error(sb, __func__, fmt) |
| 161 |
void adfs_msg(struct super_block *sb, const char *pfx, const char *fmt, ...); |
| 162 |
|
| 163 |
/* super.c */ |
| 164 |
|
| 165 |
/* |
| 166 |
* Inodes and file operations |
| 167 |
*/ |
| 168 |
|
| 169 |
/* dir_*.c */ |
| 170 |
extern const struct inode_operations adfs_dir_inode_operations; |
| 171 |
extern const struct file_operations adfs_dir_operations; |
| 172 |
extern const struct dentry_operations adfs_dentry_operations; |
| 173 |
extern const struct adfs_dir_ops adfs_f_dir_ops; |
| 174 |
extern const struct adfs_dir_ops adfs_fplus_dir_ops; |
| 175 |
|
| 176 |
int adfs_dir_copyfrom(void *dst, struct adfs_dir *dir, unsigned int offset, |
| 177 |
size_t len); |
| 178 |
int adfs_dir_copyto(struct adfs_dir *dir, unsigned int offset, const void *src, |
| 179 |
size_t len); |
| 180 |
void adfs_dir_relse(struct adfs_dir *dir); |
| 181 |
int adfs_dir_read_buffers(struct super_block *sb, u32 indaddr, |
| 182 |
unsigned int size, struct adfs_dir *dir); |
| 183 |
void adfs_object_fixup(struct adfs_dir *dir, struct object_info *obj); |
| 184 |
extern int adfs_dir_update(struct super_block *sb, struct object_info *obj, |
| 185 |
int wait); |
| 186 |
|
| 187 |
/* file.c */ |
| 188 |
extern const struct inode_operations adfs_file_inode_operations; |
| 189 |
extern const struct file_operations adfs_file_operations; |
| 190 |
|
| 191 |
static inline __u32 signed_asl(__u32 val, signed int shift) |
| 192 |
{ |
| 193 |
if (shift >= 0) |
| 194 |
val <<= shift; |
| 195 |
else |
| 196 |
val >>= -shift; |
| 197 |
return val; |
| 198 |
} |
| 199 |
|
| 200 |
/* |
| 201 |
* Calculate the address of a block in an object given the block offset |
| 202 |
* and the object identity. |
| 203 |
* |
| 204 |
* The root directory ID should always be looked up in the map [3.4] |
| 205 |
*/ |
| 206 |
static inline int __adfs_block_map(struct super_block *sb, u32 indaddr, |
| 207 |
unsigned int block) |
| 208 |
{ |
| 209 |
if (indaddr & 255) { |
| 210 |
unsigned int off; |
| 211 |
|
| 212 |
off = (indaddr & 255) - 1; |
| 213 |
block += off << ADFS_SB(sb)->s_log2sharesize; |
| 214 |
} |
| 215 |
|
| 216 |
return adfs_map_lookup(sb, indaddr >> 8, block); |
| 217 |
} |
| 218 |
|
| 219 |
/* Return the disc record from the map */ |
| 220 |
static inline |
| 221 |
struct adfs_discrecord *adfs_map_discrecord(struct adfs_discmap *dm) |
| 222 |
{ |
| 223 |
return (void *)(dm[0].dm_bh->b_data + 4); |
| 224 |
} |
| 225 |
|
| 226 |
static inline u64 adfs_disc_size(const struct adfs_discrecord *dr) |
| 227 |
{ |
| 228 |
return (u64)le32_to_cpu(dr->disc_size_high) << 32 | |
| 229 |
le32_to_cpu(dr->disc_size); |
| 230 |
} |