| 1 | |
| 2 | |
| 3 | * linux/fs/adfs/inode.c
|
| 4 | *
|
| 5 | * Copyright (C) 1997-1999 Russell King
|
| 6 |
|
| 7 | #include <linux/buffer_head.h>
|
| 8 | #include <linux/mpage.h>
|
| 9 | #include <linux/writeback.h>
|
| 10 | #include "adfs.h"
|
| 11 |
|
| 12 | |
| 13 | * Lookup/Create a block at offset 'block' into 'inode'. We currently do
|
| 14 | * not support creation of new blocks, so we return -EIO for this case.
|
| 15 |
|
| 16 | static int
|
| 17 | adfs_get_block(struct inode *inode, sector_t block, struct buffer_head *bh,
|
| 18 | int create)
|
| 19 | {
|
| 20 | if (!create) {
|
| 21 | if (block >= inode->i_blocks)
|
| 22 | goto abort_toobig;
|
| 23 |
|
| 24 | block = __adfs_block_map(inode->i_sb, ADFS_I(inode)->indaddr,
|
| 25 | block);
|
| 26 | if (block)
|
| 27 | map_bh(bh, inode->i_sb, block);
|
| 28 | return 0;
|
| 29 | }
|
| 30 |
|
| 31 | return -EIO;
|
| 32 |
|
| 33 | abort_toobig:
|
| 34 | return 0;
|
| 35 | }
|
| 36 |
|
| 37 | static int adfs_writepages(struct address_space *mapping,
|
| 38 | struct writeback_control *wbc)
|
| 39 | {
|
| 40 | return mpage_writepages(mapping, wbc, adfs_get_block);
|
| 41 | }
|
| 42 |
|
| 43 | static int adfs_read_folio(struct file *file, struct folio *folio)
|
| 44 | {
|
| 45 | return block_read_full_folio(folio, adfs_get_block);
|
| 46 | }
|
| 47 |
|
| 48 | static void adfs_write_failed(struct address_space *mapping, loff_t to)
|
| 49 | {
|
| 50 | struct inode *inode = mapping->host;
|
| 51 |
|
| 52 | if (to > inode->i_size)
|
| 53 | truncate_pagecache(inode, inode->i_size);
|
| 54 | }
|
| 55 |
|
| 56 | static int adfs_write_begin(const struct kiocb *iocb,
|
| 57 | struct address_space *mapping,
|
| 58 | loff_t pos, unsigned len,
|
| 59 | struct folio **foliop, void **fsdata)
|
| 60 | {
|
| 61 | int ret;
|
| 62 |
|
| 63 | ret = cont_write_begin(iocb, mapping, pos, len, foliop, fsdata,
|
| 64 | adfs_get_block,
|
| 65 | &ADFS_I(mapping->host)->mmu_private);
|
| 66 | if (unlikely(ret))
|
| 67 | adfs_write_failed(mapping, pos + len);
|
| 68 |
|
| 69 | return ret;
|
| 70 | }
|
| 71 |
|
| 72 | static sector_t _adfs_bmap(struct address_space *mapping, sector_t block)
|
| 73 | {
|
| 74 | return generic_block_bmap(mapping, block, adfs_get_block);
|
| 75 | }
|
| 76 |
|
| 77 | static const struct address_space_operations adfs_aops = {
|
| 78 | .dirty_folio = block_dirty_folio,
|
| 79 | .invalidate_folio = block_invalidate_folio,
|
| 80 | .read_folio = adfs_read_folio,
|
| 81 | .writepages = adfs_writepages,
|
| 82 | .write_begin = adfs_write_begin,
|
| 83 | .write_end = generic_write_end,
|
| 84 | .migrate_folio = buffer_migrate_folio,
|
| 85 | .bmap = _adfs_bmap,
|
| 86 | };
|
| 87 |
|
| 88 | |
| 89 | * Convert ADFS attributes and filetype to Linux permission.
|
| 90 |
|
| 91 | static umode_t
|
| 92 | adfs_atts2mode(struct super_block *sb, struct inode *inode)
|
| 93 | {
|
| 94 | unsigned int attr = ADFS_I(inode)->attr;
|
| 95 | umode_t mode, rmask;
|
| 96 | struct adfs_sb_info *asb = ADFS_SB(sb);
|
| 97 |
|
| 98 | if (attr & ADFS_NDA_DIRECTORY) {
|
| 99 | mode = S_IRUGO & asb->s_owner_mask;
|
| 100 | return S_IFDIR | S_IXUGO | mode;
|
| 101 | }
|
| 102 |
|
| 103 | switch (adfs_filetype(ADFS_I(inode)->loadaddr)) {
|
| 104 | case 0xfc0:
|
| 105 | return S_IFLNK|S_IRWXUGO;
|
| 106 |
|
| 107 | case 0xfe6:
|
| 108 | rmask = S_IRUGO | S_IXUGO;
|
| 109 | break;
|
| 110 |
|
| 111 | default:
|
| 112 | rmask = S_IRUGO;
|
| 113 | }
|
| 114 |
|
| 115 | mode = S_IFREG;
|
| 116 |
|
| 117 | if (attr & ADFS_NDA_OWNER_READ)
|
| 118 | mode |= rmask & asb->s_owner_mask;
|
| 119 |
|
| 120 | if (attr & ADFS_NDA_OWNER_WRITE)
|
| 121 | mode |= S_IWUGO & asb->s_owner_mask;
|
| 122 |
|
| 123 | if (attr & ADFS_NDA_PUBLIC_READ)
|
| 124 | mode |= rmask & asb->s_other_mask;
|
| 125 |
|
| 126 | if (attr & ADFS_NDA_PUBLIC_WRITE)
|
| 127 | mode |= S_IWUGO & asb->s_other_mask;
|
| 128 | return mode;
|
| 129 | }
|
| 130 |
|
| 131 | |
| 132 | * Convert Linux permission to ADFS attribute. We try to do the reverse
|
| 133 | * of atts2mode, but there is not a 1:1 translation.
|
| 134 |
|
| 135 | static int adfs_mode2atts(struct super_block *sb, struct inode *inode,
|
| 136 | umode_t ia_mode)
|
| 137 | {
|
| 138 | struct adfs_sb_info *asb = ADFS_SB(sb);
|
| 139 | umode_t mode;
|
| 140 | int attr;
|
| 141 |
|
| 142 |
|
| 143 | if (S_ISLNK(inode->i_mode))
|
| 144 | return ADFS_I(inode)->attr;
|
| 145 |
|
| 146 |
|
| 147 | if (S_ISDIR(inode->i_mode))
|
| 148 | return ADFS_NDA_DIRECTORY;
|
| 149 |
|
| 150 | attr = 0;
|
| 151 | mode = ia_mode & asb->s_owner_mask;
|
| 152 | if (mode & S_IRUGO)
|
| 153 | attr |= ADFS_NDA_OWNER_READ;
|
| 154 | if (mode & S_IWUGO)
|
| 155 | attr |= ADFS_NDA_OWNER_WRITE;
|
| 156 |
|
| 157 | mode = ia_mode & asb->s_other_mask;
|
| 158 | mode &= ~asb->s_owner_mask;
|
| 159 | if (mode & S_IRUGO)
|
| 160 | attr |= ADFS_NDA_PUBLIC_READ;
|
| 161 | if (mode & S_IWUGO)
|
| 162 | attr |= ADFS_NDA_PUBLIC_WRITE;
|
| 163 |
|
| 164 | return attr;
|
| 165 | }
|
| 166 |
|
| 167 | static const s64 nsec_unix_epoch_diff_risc_os_epoch = 2208988800000000000LL;
|
| 168 |
|
| 169 | |
| 170 | * Convert an ADFS time to Unix time. ADFS has a 40-bit centi-second time
|
| 171 | * referenced to 1 Jan 1900 (til 2248) so we need to discard 2208988800 seconds
|
| 172 | * of time to convert from RISC OS epoch to Unix epoch.
|
| 173 |
|
| 174 | static void
|
| 175 | adfs_adfs2unix_time(struct timespec64 *tv, struct inode *inode)
|
| 176 | {
|
| 177 | unsigned int high, low;
|
| 178 | |
| 179 | * 01 Jan 1900 00:00:00 (RISC OS epoch)
|
| 180 |
|
| 181 | s64 nsec;
|
| 182 |
|
| 183 | if (!adfs_inode_is_stamped(inode))
|
| 184 | goto cur_time;
|
| 185 |
|
| 186 | high = ADFS_I(inode)->loadaddr & 0xFF;
|
| 187 | low = ADFS_I(inode)->execaddr;
|
| 188 |
|
| 189 | |
| 190 | * going via nanoseconds to retain precision
|
| 191 |
|
| 192 | nsec = (((s64) high << 32) | (s64) low) * 10000000;
|
| 193 |
|
| 194 |
|
| 195 | if (nsec < nsec_unix_epoch_diff_risc_os_epoch)
|
| 196 | goto too_early;
|
| 197 |
|
| 198 |
|
| 199 | nsec -= nsec_unix_epoch_diff_risc_os_epoch;
|
| 200 |
|
| 201 | *tv = ns_to_timespec64(nsec);
|
| 202 | return;
|
| 203 |
|
| 204 | cur_time:
|
| 205 | *tv = current_time(inode);
|
| 206 | return;
|
| 207 |
|
| 208 | too_early:
|
| 209 | tv->tv_sec = tv->tv_nsec = 0;
|
| 210 | return;
|
| 211 | }
|
| 212 |
|
| 213 |
|
| 214 | static void adfs_unix2adfs_time(struct inode *inode,
|
| 215 | const struct timespec64 *ts)
|
| 216 | {
|
| 217 | s64 cs, nsec = timespec64_to_ns(ts);
|
| 218 |
|
| 219 |
|
| 220 | nsec += nsec_unix_epoch_diff_risc_os_epoch;
|
| 221 |
|
| 222 |
|
| 223 | cs = div_s64(nsec, 10000000);
|
| 224 |
|
| 225 | cs = clamp_t(s64, cs, 0, 0xffffffffff);
|
| 226 |
|
| 227 | ADFS_I(inode)->loadaddr &= ~0xff;
|
| 228 | ADFS_I(inode)->loadaddr |= (cs >> 32) & 0xff;
|
| 229 | ADFS_I(inode)->execaddr = cs;
|
| 230 | }
|
| 231 |
|
| 232 | |
| 233 | * Fill in the inode information from the object information.
|
| 234 | *
|
| 235 | * Note that this is an inode-less filesystem, so we can't use the inode
|
| 236 | * number to reference the metadata on the media. Instead, we use the
|
| 237 | * inode number to hold the object ID, which in turn will tell us where
|
| 238 | * the data is held. We also save the parent object ID, and with these
|
| 239 | * two, we can locate the metadata.
|
| 240 | *
|
| 241 | * This does mean that we rely on an objects parent remaining the same at
|
| 242 | * all times - we cannot cope with a cross-directory rename (yet).
|
| 243 |
|
| 244 | struct inode *
|
| 245 | adfs_iget(struct super_block *sb, struct object_info *obj)
|
| 246 | {
|
| 247 | struct inode *inode;
|
| 248 | struct timespec64 ts;
|
| 249 |
|
| 250 | inode = new_inode(sb);
|
| 251 | if (!inode)
|
| 252 | goto out;
|
| 253 |
|
| 254 | inode->i_uid = ADFS_SB(sb)->s_uid;
|
| 255 | inode->i_gid = ADFS_SB(sb)->s_gid;
|
| 256 | inode->i_ino = obj->indaddr;
|
| 257 | inode->i_size = obj->size;
|
| 258 | set_nlink(inode, 2);
|
| 259 | inode->i_blocks = (inode->i_size + sb->s_blocksize - 1) >>
|
| 260 | sb->s_blocksize_bits;
|
| 261 |
|
| 262 | |
| 263 | * we need to save the parent directory ID so that
|
| 264 | * write_inode can update the directory information
|
| 265 | * for this file. This will need special handling
|
| 266 | * for cross-directory renames.
|
| 267 |
|
| 268 | ADFS_I(inode)->parent_id = obj->parent_id;
|
| 269 | ADFS_I(inode)->indaddr = obj->indaddr;
|
| 270 | ADFS_I(inode)->loadaddr = obj->loadaddr;
|
| 271 | ADFS_I(inode)->execaddr = obj->execaddr;
|
| 272 | ADFS_I(inode)->attr = obj->attr;
|
| 273 |
|
| 274 | inode->i_mode = adfs_atts2mode(sb, inode);
|
| 275 | adfs_adfs2unix_time(&ts, inode);
|
| 276 | inode_set_atime_to_ts(inode, ts);
|
| 277 | inode_set_mtime_to_ts(inode, ts);
|
| 278 | inode_set_ctime_to_ts(inode, ts);
|
| 279 |
|
| 280 | if (S_ISDIR(inode->i_mode)) {
|
| 281 | inode->i_op = &adfs_dir_inode_operations;
|
| 282 | inode->i_fop = &adfs_dir_operations;
|
| 283 | } else if (S_ISREG(inode->i_mode)) {
|
| 284 | inode->i_op = &adfs_file_inode_operations;
|
| 285 | inode->i_fop = &adfs_file_operations;
|
| 286 | inode->i_mapping->a_ops = &adfs_aops;
|
| 287 | ADFS_I(inode)->mmu_private = inode->i_size;
|
| 288 | }
|
| 289 |
|
| 290 | inode_fake_hash(inode);
|
| 291 |
|
| 292 | out:
|
| 293 | return inode;
|
| 294 | }
|
| 295 |
|
| 296 | |
| 297 | * Validate and convert a changed access mode/time to their ADFS equivalents.
|
| 298 | * adfs_write_inode will actually write the information back to the directory
|
| 299 | * later.
|
| 300 |
|
| 301 | int
|
| 302 | adfs_setattr(const struct mnt_idmap *idmap, struct dentry *dentry, struct iattr *attr)
|
| 303 | {
|
| 304 | struct inode *inode = d_inode(dentry);
|
| 305 | struct super_block *sb = inode->i_sb;
|
| 306 | unsigned int ia_valid = attr->ia_valid;
|
| 307 | int error;
|
| 308 |
|
| 309 | error = setattr_prepare(&nop_mnt_idmap, dentry, attr);
|
| 310 |
|
| 311 | |
| 312 | * we can't change the UID or GID of any file -
|
| 313 | * we have a global UID/GID in the superblock
|
| 314 |
|
| 315 | if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, ADFS_SB(sb)->s_uid)) ||
|
| 316 | (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, ADFS_SB(sb)->s_gid)))
|
| 317 | error = -EPERM;
|
| 318 |
|
| 319 | if (error)
|
| 320 | goto out;
|
| 321 |
|
| 322 |
|
| 323 | if (ia_valid & ATTR_SIZE)
|
| 324 | truncate_setsize(inode, attr->ia_size);
|
| 325 |
|
| 326 | if (ia_valid & ATTR_MTIME && adfs_inode_is_stamped(inode)) {
|
| 327 | adfs_unix2adfs_time(inode, &attr->ia_mtime);
|
| 328 | adfs_adfs2unix_time(&attr->ia_mtime, inode);
|
| 329 | inode_set_mtime_to_ts(inode, attr->ia_mtime);
|
| 330 | }
|
| 331 |
|
| 332 | |
| 333 | * FIXME: should we make these == to i_mtime since we don't
|
| 334 | * have the ability to represent them in our filesystem?
|
| 335 |
|
| 336 | if (ia_valid & ATTR_ATIME)
|
| 337 | inode_set_atime_to_ts(inode, attr->ia_atime);
|
| 338 | if (ia_valid & ATTR_CTIME)
|
| 339 | inode_set_ctime_to_ts(inode, attr->ia_ctime);
|
| 340 | if (ia_valid & ATTR_MODE) {
|
| 341 | ADFS_I(inode)->attr = adfs_mode2atts(sb, inode, attr->ia_mode);
|
| 342 | inode->i_mode = adfs_atts2mode(sb, inode);
|
| 343 | }
|
| 344 |
|
| 345 | |
| 346 | * FIXME: should we be marking this inode dirty even if
|
| 347 | * we don't have any metadata to write back?
|
| 348 |
|
| 349 | if (ia_valid & (ATTR_SIZE | ATTR_MTIME | ATTR_MODE))
|
| 350 | mark_inode_dirty(inode);
|
| 351 | out:
|
| 352 | return error;
|
| 353 | }
|
| 354 |
|
| 355 | |
| 356 | * write an existing inode back to the directory, and therefore the disk.
|
| 357 | * The adfs-specific inode data has already been updated by * adfs_setattr().
|
| 358 |
|
| 359 | int adfs_write_inode(struct inode *inode, struct writeback_control *wbc)
|
| 360 | {
|
| 361 | struct super_block *sb = inode->i_sb;
|
| 362 | struct object_info obj;
|
| 363 |
|
| 364 | obj.indaddr = ADFS_I(inode)->indaddr;
|
| 365 | obj.name_len = 0;
|
| 366 | obj.parent_id = ADFS_I(inode)->parent_id;
|
| 367 | obj.loadaddr = ADFS_I(inode)->loadaddr;
|
| 368 | obj.execaddr = ADFS_I(inode)->execaddr;
|
| 369 | obj.attr = ADFS_I(inode)->attr;
|
| 370 | obj.size = inode->i_size;
|
| 371 |
|
| 372 | return adfs_dir_update(sb, &obj, wbc->sync_mode == WB_SYNC_ALL);
|
| 373 | }
|