affs.h 10 KB

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