diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /fs/affs/affs.h |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'fs/affs/affs.h')
-rw-r--r-- | fs/affs/affs.h | 304 |
1 files changed, 304 insertions, 0 deletions
diff --git a/fs/affs/affs.h b/fs/affs/affs.h new file mode 100644 index 000000000000..0c6799f2137a --- /dev/null +++ b/fs/affs/affs.h | |||
@@ -0,0 +1,304 @@ | |||
1 | #include <linux/types.h> | ||
2 | #include <linux/fs.h> | ||
3 | #include <linux/buffer_head.h> | ||
4 | #include <linux/affs_fs.h> | ||
5 | #include <linux/amigaffs.h> | ||
6 | |||
7 | /* AmigaOS allows file names with up to 30 characters length. | ||
8 | * Names longer than that will be silently truncated. If you | ||
9 | * want to disallow this, comment out the following #define. | ||
10 | * Creating filesystem objects with longer names will then | ||
11 | * result in an error (ENAMETOOLONG). | ||
12 | */ | ||
13 | /*#define AFFS_NO_TRUNCATE */ | ||
14 | |||
15 | /* Ugly macros make the code more pretty. */ | ||
16 | |||
17 | #define GET_END_PTR(st,p,sz) ((st *)((char *)(p)+((sz)-sizeof(st)))) | ||
18 | #define AFFS_GET_HASHENTRY(data,hashkey) be32_to_cpu(((struct dir_front *)data)->hashtable[hashkey]) | ||
19 | #define AFFS_BLOCK(sb, bh, blk) (AFFS_HEAD(bh)->table[AFFS_SB(sb)->s_hashsize-1-(blk)]) | ||
20 | |||
21 | #ifdef __LITTLE_ENDIAN | ||
22 | #define BO_EXBITS 0x18UL | ||
23 | #elif defined(__BIG_ENDIAN) | ||
24 | #define BO_EXBITS 0x00UL | ||
25 | #else | ||
26 | #error Endianness must be known for affs to work. | ||
27 | #endif | ||
28 | |||
29 | #define AFFS_HEAD(bh) ((struct affs_head *)(bh)->b_data) | ||
30 | #define AFFS_TAIL(sb, bh) ((struct affs_tail *)((bh)->b_data+(sb)->s_blocksize-sizeof(struct affs_tail))) | ||
31 | #define AFFS_ROOT_HEAD(bh) ((struct affs_root_head *)(bh)->b_data) | ||
32 | #define AFFS_ROOT_TAIL(sb, bh) ((struct affs_root_tail *)((bh)->b_data+(sb)->s_blocksize-sizeof(struct affs_root_tail))) | ||
33 | #define AFFS_DATA_HEAD(bh) ((struct affs_data_head *)(bh)->b_data) | ||
34 | #define AFFS_DATA(bh) (((struct affs_data_head *)(bh)->b_data)->data) | ||
35 | |||
36 | #define AFFS_CACHE_SIZE PAGE_SIZE | ||
37 | |||
38 | #define AFFS_MAX_PREALLOC 32 | ||
39 | #define AFFS_LC_SIZE (AFFS_CACHE_SIZE/sizeof(u32)/2) | ||
40 | #define AFFS_AC_SIZE (AFFS_CACHE_SIZE/sizeof(struct affs_ext_key)/2) | ||
41 | #define AFFS_AC_MASK (AFFS_AC_SIZE-1) | ||
42 | |||
43 | struct affs_ext_key { | ||
44 | u32 ext; /* idx of the extended block */ | ||
45 | u32 key; /* block number */ | ||
46 | }; | ||
47 | |||
48 | /* | ||
49 | * affs fs inode data in memory | ||
50 | */ | ||
51 | struct affs_inode_info { | ||
52 | u32 i_opencnt; | ||
53 | struct semaphore i_link_lock; /* Protects internal inode access. */ | ||
54 | struct semaphore i_ext_lock; /* Protects internal inode access. */ | ||
55 | #define i_hash_lock i_ext_lock | ||
56 | u32 i_blkcnt; /* block count */ | ||
57 | u32 i_extcnt; /* extended block count */ | ||
58 | u32 *i_lc; /* linear cache of extended blocks */ | ||
59 | u32 i_lc_size; | ||
60 | u32 i_lc_shift; | ||
61 | u32 i_lc_mask; | ||
62 | struct affs_ext_key *i_ac; /* associative cache of extended blocks */ | ||
63 | u32 i_ext_last; /* last accessed extended block */ | ||
64 | struct buffer_head *i_ext_bh; /* bh of last extended block */ | ||
65 | loff_t mmu_private; | ||
66 | u32 i_protect; /* unused attribute bits */ | ||
67 | u32 i_lastalloc; /* last allocated block */ | ||
68 | int i_pa_cnt; /* number of preallocated blocks */ | ||
69 | struct inode vfs_inode; | ||
70 | }; | ||
71 | |||
72 | /* short cut to get to the affs specific inode data */ | ||
73 | static inline struct affs_inode_info *AFFS_I(struct inode *inode) | ||
74 | { | ||
75 | return list_entry(inode, struct affs_inode_info, vfs_inode); | ||
76 | } | ||
77 | |||
78 | /* | ||
79 | * super-block data in memory | ||
80 | * | ||
81 | * Block numbers are adjusted for their actual size | ||
82 | * | ||
83 | */ | ||
84 | |||
85 | struct affs_bm_info { | ||
86 | u32 bm_key; /* Disk block number */ | ||
87 | u32 bm_free; /* Free blocks in here */ | ||
88 | }; | ||
89 | |||
90 | struct affs_sb_info { | ||
91 | int s_partition_size; /* Partition size in blocks. */ | ||
92 | int s_reserved; /* Number of reserved blocks. */ | ||
93 | //u32 s_blksize; /* Initial device blksize */ | ||
94 | u32 s_data_blksize; /* size of the data block w/o header */ | ||
95 | u32 s_root_block; /* FFS root block number. */ | ||
96 | int s_hashsize; /* Size of hash table. */ | ||
97 | unsigned long s_flags; /* See below. */ | ||
98 | uid_t s_uid; /* uid to override */ | ||
99 | gid_t s_gid; /* gid to override */ | ||
100 | umode_t s_mode; /* mode to override */ | ||
101 | struct buffer_head *s_root_bh; /* Cached root block. */ | ||
102 | struct semaphore s_bmlock; /* Protects bitmap access. */ | ||
103 | struct affs_bm_info *s_bitmap; /* Bitmap infos. */ | ||
104 | u32 s_bmap_count; /* # of bitmap blocks. */ | ||
105 | u32 s_bmap_bits; /* # of bits in one bitmap blocks */ | ||
106 | u32 s_last_bmap; | ||
107 | struct buffer_head *s_bmap_bh; | ||
108 | char *s_prefix; /* Prefix for volumes and assigns. */ | ||
109 | int s_prefix_len; /* Length of prefix. */ | ||
110 | char s_volume[32]; /* Volume prefix for absolute symlinks. */ | ||
111 | }; | ||
112 | |||
113 | #define SF_INTL 0x0001 /* International filesystem. */ | ||
114 | #define SF_BM_VALID 0x0002 /* Bitmap is valid. */ | ||
115 | #define SF_IMMUTABLE 0x0004 /* Protection bits cannot be changed */ | ||
116 | #define SF_QUIET 0x0008 /* chmod errors will be not reported */ | ||
117 | #define SF_SETUID 0x0010 /* Ignore Amiga uid */ | ||
118 | #define SF_SETGID 0x0020 /* Ignore Amiga gid */ | ||
119 | #define SF_SETMODE 0x0040 /* Ignore Amiga protection bits */ | ||
120 | #define SF_MUFS 0x0100 /* Use MUFS uid/gid mapping */ | ||
121 | #define SF_OFS 0x0200 /* Old filesystem */ | ||
122 | #define SF_PREFIX 0x0400 /* Buffer for prefix is allocated */ | ||
123 | #define SF_VERBOSE 0x0800 /* Talk about fs when mounting */ | ||
124 | |||
125 | /* short cut to get to the affs specific sb data */ | ||
126 | static inline struct affs_sb_info *AFFS_SB(struct super_block *sb) | ||
127 | { | ||
128 | return sb->s_fs_info; | ||
129 | } | ||
130 | |||
131 | /* amigaffs.c */ | ||
132 | |||
133 | extern int affs_insert_hash(struct inode *inode, struct buffer_head *bh); | ||
134 | extern int affs_remove_hash(struct inode *dir, struct buffer_head *rem_bh); | ||
135 | extern int affs_remove_header(struct dentry *dentry); | ||
136 | extern u32 affs_checksum_block(struct super_block *sb, struct buffer_head *bh); | ||
137 | extern void affs_fix_checksum(struct super_block *sb, struct buffer_head *bh); | ||
138 | extern void secs_to_datestamp(time_t secs, struct affs_date *ds); | ||
139 | extern mode_t prot_to_mode(u32 prot); | ||
140 | extern void mode_to_prot(struct inode *inode); | ||
141 | extern void affs_error(struct super_block *sb, const char *function, const char *fmt, ...); | ||
142 | extern void affs_warning(struct super_block *sb, const char *function, const char *fmt, ...); | ||
143 | extern int affs_check_name(const unsigned char *name, int len); | ||
144 | extern int affs_copy_name(unsigned char *bstr, struct dentry *dentry); | ||
145 | |||
146 | /* bitmap. c */ | ||
147 | |||
148 | extern u32 affs_count_free_blocks(struct super_block *s); | ||
149 | extern void affs_free_block(struct super_block *sb, u32 block); | ||
150 | extern u32 affs_alloc_block(struct inode *inode, u32 goal); | ||
151 | extern int affs_init_bitmap(struct super_block *sb, int *flags); | ||
152 | extern void affs_free_bitmap(struct super_block *sb); | ||
153 | |||
154 | /* namei.c */ | ||
155 | |||
156 | extern int affs_hash_name(struct super_block *sb, const u8 *name, unsigned int len); | ||
157 | extern struct dentry *affs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *); | ||
158 | extern int affs_unlink(struct inode *dir, struct dentry *dentry); | ||
159 | extern int affs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *); | ||
160 | extern int affs_mkdir(struct inode *dir, struct dentry *dentry, int mode); | ||
161 | extern int affs_rmdir(struct inode *dir, struct dentry *dentry); | ||
162 | extern int affs_link(struct dentry *olddentry, struct inode *dir, | ||
163 | struct dentry *dentry); | ||
164 | extern int affs_symlink(struct inode *dir, struct dentry *dentry, | ||
165 | const char *symname); | ||
166 | extern int affs_rename(struct inode *old_dir, struct dentry *old_dentry, | ||
167 | struct inode *new_dir, struct dentry *new_dentry); | ||
168 | |||
169 | /* inode.c */ | ||
170 | |||
171 | extern unsigned long affs_parent_ino(struct inode *dir); | ||
172 | extern struct inode *affs_new_inode(struct inode *dir); | ||
173 | extern int affs_notify_change(struct dentry *dentry, struct iattr *attr); | ||
174 | extern void affs_put_inode(struct inode *inode); | ||
175 | extern void affs_delete_inode(struct inode *inode); | ||
176 | extern void affs_clear_inode(struct inode *inode); | ||
177 | extern void affs_read_inode(struct inode *inode); | ||
178 | extern int affs_write_inode(struct inode *inode, int); | ||
179 | extern int affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s32 type); | ||
180 | |||
181 | /* file.c */ | ||
182 | |||
183 | void affs_free_prealloc(struct inode *inode); | ||
184 | extern void affs_truncate(struct inode *); | ||
185 | |||
186 | /* dir.c */ | ||
187 | |||
188 | extern void affs_dir_truncate(struct inode *); | ||
189 | |||
190 | /* jump tables */ | ||
191 | |||
192 | extern struct inode_operations affs_file_inode_operations; | ||
193 | extern struct inode_operations affs_dir_inode_operations; | ||
194 | extern struct inode_operations affs_symlink_inode_operations; | ||
195 | extern struct file_operations affs_file_operations; | ||
196 | extern struct file_operations affs_file_operations_ofs; | ||
197 | extern struct file_operations affs_dir_operations; | ||
198 | extern struct address_space_operations affs_symlink_aops; | ||
199 | extern struct address_space_operations affs_aops; | ||
200 | extern struct address_space_operations affs_aops_ofs; | ||
201 | |||
202 | extern struct dentry_operations affs_dentry_operations; | ||
203 | extern struct dentry_operations affs_dentry_operations_intl; | ||
204 | |||
205 | static inline void | ||
206 | affs_set_blocksize(struct super_block *sb, int size) | ||
207 | { | ||
208 | sb_set_blocksize(sb, size); | ||
209 | } | ||
210 | static inline struct buffer_head * | ||
211 | affs_bread(struct super_block *sb, int block) | ||
212 | { | ||
213 | pr_debug("affs_bread: %d\n", block); | ||
214 | if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) | ||
215 | return sb_bread(sb, block); | ||
216 | return NULL; | ||
217 | } | ||
218 | static inline struct buffer_head * | ||
219 | affs_getblk(struct super_block *sb, int block) | ||
220 | { | ||
221 | pr_debug("affs_getblk: %d\n", block); | ||
222 | if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) | ||
223 | return sb_getblk(sb, block); | ||
224 | return NULL; | ||
225 | } | ||
226 | static inline struct buffer_head * | ||
227 | affs_getzeroblk(struct super_block *sb, int block) | ||
228 | { | ||
229 | struct buffer_head *bh; | ||
230 | pr_debug("affs_getzeroblk: %d\n", block); | ||
231 | if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) { | ||
232 | bh = sb_getblk(sb, block); | ||
233 | lock_buffer(bh); | ||
234 | memset(bh->b_data, 0 , sb->s_blocksize); | ||
235 | set_buffer_uptodate(bh); | ||
236 | unlock_buffer(bh); | ||
237 | return bh; | ||
238 | } | ||
239 | return NULL; | ||
240 | } | ||
241 | static inline struct buffer_head * | ||
242 | affs_getemptyblk(struct super_block *sb, int block) | ||
243 | { | ||
244 | struct buffer_head *bh; | ||
245 | pr_debug("affs_getemptyblk: %d\n", block); | ||
246 | if (block >= AFFS_SB(sb)->s_reserved && block < AFFS_SB(sb)->s_partition_size) { | ||
247 | bh = sb_getblk(sb, block); | ||
248 | wait_on_buffer(bh); | ||
249 | set_buffer_uptodate(bh); | ||
250 | return bh; | ||
251 | } | ||
252 | return NULL; | ||
253 | } | ||
254 | static inline void | ||
255 | affs_brelse(struct buffer_head *bh) | ||
256 | { | ||
257 | if (bh) | ||
258 | pr_debug("affs_brelse: %lld\n", (long long) bh->b_blocknr); | ||
259 | brelse(bh); | ||
260 | } | ||
261 | |||
262 | static inline void | ||
263 | affs_adjust_checksum(struct buffer_head *bh, u32 val) | ||
264 | { | ||
265 | u32 tmp = be32_to_cpu(((__be32 *)bh->b_data)[5]); | ||
266 | ((__be32 *)bh->b_data)[5] = cpu_to_be32(tmp - val); | ||
267 | } | ||
268 | static inline void | ||
269 | affs_adjust_bitmapchecksum(struct buffer_head *bh, u32 val) | ||
270 | { | ||
271 | u32 tmp = be32_to_cpu(((__be32 *)bh->b_data)[0]); | ||
272 | ((__be32 *)bh->b_data)[0] = cpu_to_be32(tmp - val); | ||
273 | } | ||
274 | |||
275 | static inline void | ||
276 | affs_lock_link(struct inode *inode) | ||
277 | { | ||
278 | down(&AFFS_I(inode)->i_link_lock); | ||
279 | } | ||
280 | static inline void | ||
281 | affs_unlock_link(struct inode *inode) | ||
282 | { | ||
283 | up(&AFFS_I(inode)->i_link_lock); | ||
284 | } | ||
285 | static inline void | ||
286 | affs_lock_dir(struct inode *inode) | ||
287 | { | ||
288 | down(&AFFS_I(inode)->i_hash_lock); | ||
289 | } | ||
290 | static inline void | ||
291 | affs_unlock_dir(struct inode *inode) | ||
292 | { | ||
293 | up(&AFFS_I(inode)->i_hash_lock); | ||
294 | } | ||
295 | static inline void | ||
296 | affs_lock_ext(struct inode *inode) | ||
297 | { | ||
298 | down(&AFFS_I(inode)->i_ext_lock); | ||
299 | } | ||
300 | static inline void | ||
301 | affs_unlock_ext(struct inode *inode) | ||
302 | { | ||
303 | up(&AFFS_I(inode)->i_ext_lock); | ||
304 | } | ||