fs/adfs/adfs.h

   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 dentry *dentry, struct iattr *attr);
 148
 149 /* map.c */
 150 int adfs_map_lookup(struct super_block *sb, u32 frag_id, unsigned int offset);
 151 void adfs_map_statfs(struct super_block *sb, struct kstatfs *buf);
 152 struct adfs_discmap *adfs_read_map(struct super_block *sb, struct adfs_discrecord *dr);
 153 void adfs_free_map(struct super_block *sb);
 154
 155 /* Misc */
 156 __printf(3, 4)
 157 void __adfs_error(struct super_block *sb, const char *function,
 158                   const char *fmt, ...);
 159 #define adfs_error(sb, fmt...) __adfs_error(sb, __func__, fmt)
 160 void adfs_msg(struct super_block *sb, const char *pfx, const char *fmt, ...);
 161
 162 /* super.c */
 163
 164 /*
 165  * Inodes and file operations
 166  */
 167
 168 /* dir_*.c */
 169 extern const struct inode_operations adfs_dir_inode_operations;
 170 extern const struct file_operations adfs_dir_operations;
 171 extern const struct dentry_operations adfs_dentry_operations;
 172 extern const struct adfs_dir_ops adfs_f_dir_ops;
 173 extern const struct adfs_dir_ops adfs_fplus_dir_ops;
 174
 175 int adfs_dir_copyfrom(void *dst, struct adfs_dir *dir, unsigned int offset,
 176                       size_t len);
 177 int adfs_dir_copyto(struct adfs_dir *dir, unsigned int offset, const void *src,
 178                     size_t len);
 179 void adfs_dir_relse(struct adfs_dir *dir);
 180 int adfs_dir_read_buffers(struct super_block *sb, u32 indaddr,
 181                           unsigned int size, struct adfs_dir *dir);
 182 void adfs_object_fixup(struct adfs_dir *dir, struct object_info *obj);
 183 extern int adfs_dir_update(struct super_block *sb, struct object_info *obj,
 184                            int wait);
 185
 186 /* file.c */
 187 extern const struct inode_operations adfs_file_inode_operations;
 188 extern const struct file_operations adfs_file_operations;
 189
 190 static inline __u32 signed_asl(__u32 val, signed int shift)
 191 {
 192         if (shift >= 0)
 193                 val <<= shift;
 194         else
 195                 val >>= -shift;
 196         return val;
 197 }
 198
 199 /*
 200  * Calculate the address of a block in an object given the block offset
 201  * and the object identity.
 202  *
 203  * The root directory ID should always be looked up in the map [3.4]
 204  */
 205 static inline int __adfs_block_map(struct super_block *sb, u32 indaddr,
 206                                    unsigned int block)
 207 {
 208         if (indaddr & 255) {
 209                 unsigned int off;
 210
 211                 off = (indaddr & 255) - 1;
 212                 block += off << ADFS_SB(sb)->s_log2sharesize;
 213         }
 214
 215         return adfs_map_lookup(sb, indaddr >> 8, block);
 216 }
 217
 218 /* Return the disc record from the map */
 219 static inline
 220 struct adfs_discrecord *adfs_map_discrecord(struct adfs_discmap *dm)
 221 {
 222         return (void *)(dm[0].dm_bh->b_data + 4);
 223 }
 224
 225 static inline u64 adfs_disc_size(const struct adfs_discrecord *dr)
 226 {
 227         return (u64)le32_to_cpu(dr->disc_size_high) << 32 |
 228                     le32_to_cpu(dr->disc_size);
 229 }