fs/erofs/inode.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2017-2018 HUAWEI, Inc.
   4  *             https://www.huawei.com/
   5  * Copyright (C) 2021, Alibaba Cloud
   6  */
   7 #include "xattr.h"
   8
   9 #include <trace/events/erofs.h>
  10
  11 static void *erofs_read_inode(struct erofs_buf *buf,
  12                               struct inode *inode, unsigned int *ofs)
  13 {
  14         struct super_block *sb = inode->i_sb;
  15         struct erofs_sb_info *sbi = EROFS_SB(sb);
  16         struct erofs_inode *vi = EROFS_I(inode);
  17         const erofs_off_t inode_loc = iloc(sbi, vi->nid);
  18
  19         erofs_blk_t blkaddr, nblks = 0;
  20         void *kaddr;
  21         struct erofs_inode_compact *dic;
  22         struct erofs_inode_extended *die, *copied = NULL;
  23         unsigned int ifmt;
  24         int err;
  25
  26         blkaddr = erofs_blknr(inode_loc);
  27         *ofs = erofs_blkoff(inode_loc);
  28
  29         erofs_dbg("%s, reading inode nid %llu at %u of blkaddr %u",
  30                   __func__, vi->nid, *ofs, blkaddr);
  31
  32         kaddr = erofs_read_metabuf(buf, sb, blkaddr, EROFS_KMAP);
  33         if (IS_ERR(kaddr)) {
  34                 erofs_err(sb, "failed to get inode (nid: %llu) page, err %ld",
  35                           vi->nid, PTR_ERR(kaddr));
  36                 return kaddr;
  37         }
  38
  39         dic = kaddr + *ofs;
  40         ifmt = le16_to_cpu(dic->i_format);
  41
  42         if (ifmt & ~EROFS_I_ALL) {
  43                 erofs_err(inode->i_sb, "unsupported i_format %u of nid %llu",
  44                           ifmt, vi->nid);
  45                 err = -EOPNOTSUPP;
  46                 goto err_out;
  47         }
  48
  49         vi->datalayout = erofs_inode_datalayout(ifmt);
  50         if (vi->datalayout >= EROFS_INODE_DATALAYOUT_MAX) {
  51                 erofs_err(inode->i_sb, "unsupported datalayout %u of nid %llu",
  52                           vi->datalayout, vi->nid);
  53                 err = -EOPNOTSUPP;
  54                 goto err_out;
  55         }
  56
  57         switch (erofs_inode_version(ifmt)) {
  58         case EROFS_INODE_LAYOUT_EXTENDED:
  59                 vi->inode_isize = sizeof(struct erofs_inode_extended);
  60                 /* check if the extended inode acrosses block boundary */
  61                 if (*ofs + vi->inode_isize <= EROFS_BLKSIZ) {
  62                         *ofs += vi->inode_isize;
  63                         die = (struct erofs_inode_extended *)dic;
  64                 } else {
  65                         const unsigned int gotten = EROFS_BLKSIZ - *ofs;
  66
  67                         copied = kmalloc(vi->inode_isize, GFP_NOFS);
  68                         if (!copied) {
  69                                 err = -ENOMEM;
  70                                 goto err_out;
  71                         }
  72                         memcpy(copied, dic, gotten);
  73                         kaddr = erofs_read_metabuf(buf, sb, blkaddr + 1,
  74                                                    EROFS_KMAP);
  75                         if (IS_ERR(kaddr)) {
  76                                 erofs_err(sb, "failed to get inode payload block (nid: %llu), err %ld",
  77                                           vi->nid, PTR_ERR(kaddr));
  78                                 kfree(copied);
  79                                 return kaddr;
  80                         }
  81                         *ofs = vi->inode_isize - gotten;
  82                         memcpy((u8 *)copied + gotten, kaddr, *ofs);
  83                         die = copied;
  84                 }
  85                 vi->xattr_isize = erofs_xattr_ibody_size(die->i_xattr_icount);
  86
  87                 inode->i_mode = le16_to_cpu(die->i_mode);
  88                 switch (inode->i_mode & S_IFMT) {
  89                 case S_IFREG:
  90                 case S_IFDIR:
  91                 case S_IFLNK:
  92                         vi->raw_blkaddr = le32_to_cpu(die->i_u.raw_blkaddr);
  93                         break;
  94                 case S_IFCHR:
  95                 case S_IFBLK:
  96                         inode->i_rdev =
  97                                 new_decode_dev(le32_to_cpu(die->i_u.rdev));
  98                         break;
  99                 case S_IFIFO:
 100                 case S_IFSOCK:
 101                         inode->i_rdev = 0;
 102                         break;
 103                 default:
 104                         goto bogusimode;
 105                 }
 106                 i_uid_write(inode, le32_to_cpu(die->i_uid));
 107                 i_gid_write(inode, le32_to_cpu(die->i_gid));
 108                 set_nlink(inode, le32_to_cpu(die->i_nlink));
 109
 110                 /* extended inode has its own timestamp */
 111                 inode->i_ctime.tv_sec = le64_to_cpu(die->i_mtime);
 112                 inode->i_ctime.tv_nsec = le32_to_cpu(die->i_mtime_nsec);
 113
 114                 inode->i_size = le64_to_cpu(die->i_size);
 115
 116                 /* total blocks for compressed files */
 117                 if (erofs_inode_is_data_compressed(vi->datalayout))
 118                         nblks = le32_to_cpu(die->i_u.compressed_blocks);
 119                 else if (vi->datalayout == EROFS_INODE_CHUNK_BASED)
 120                         /* fill chunked inode summary info */
 121                         vi->chunkformat = le16_to_cpu(die->i_u.c.format);
 122                 kfree(copied);
 123                 copied = NULL;
 124                 break;
 125         case EROFS_INODE_LAYOUT_COMPACT:
 126                 vi->inode_isize = sizeof(struct erofs_inode_compact);
 127                 *ofs += vi->inode_isize;
 128                 vi->xattr_isize = erofs_xattr_ibody_size(dic->i_xattr_icount);
 129
 130                 inode->i_mode = le16_to_cpu(dic->i_mode);
 131                 switch (inode->i_mode & S_IFMT) {
 132                 case S_IFREG:
 133                 case S_IFDIR:
 134                 case S_IFLNK:
 135                         vi->raw_blkaddr = le32_to_cpu(dic->i_u.raw_blkaddr);
 136                         break;
 137                 case S_IFCHR:
 138                 case S_IFBLK:
 139                         inode->i_rdev =
 140                                 new_decode_dev(le32_to_cpu(dic->i_u.rdev));
 141                         break;
 142                 case S_IFIFO:
 143                 case S_IFSOCK:
 144                         inode->i_rdev = 0;
 145                         break;
 146                 default:
 147                         goto bogusimode;
 148                 }
 149                 i_uid_write(inode, le16_to_cpu(dic->i_uid));
 150                 i_gid_write(inode, le16_to_cpu(dic->i_gid));
 151                 set_nlink(inode, le16_to_cpu(dic->i_nlink));
 152
 153                 /* use build time for compact inodes */
 154                 inode->i_ctime.tv_sec = sbi->build_time;
 155                 inode->i_ctime.tv_nsec = sbi->build_time_nsec;
 156
 157                 inode->i_size = le32_to_cpu(dic->i_size);
 158                 if (erofs_inode_is_data_compressed(vi->datalayout))
 159                         nblks = le32_to_cpu(dic->i_u.compressed_blocks);
 160                 else if (vi->datalayout == EROFS_INODE_CHUNK_BASED)
 161                         vi->chunkformat = le16_to_cpu(dic->i_u.c.format);
 162                 break;
 163         default:
 164                 erofs_err(inode->i_sb,
 165                           "unsupported on-disk inode version %u of nid %llu",
 166                           erofs_inode_version(ifmt), vi->nid);
 167                 err = -EOPNOTSUPP;
 168                 goto err_out;
 169         }
 170
 171         if (vi->datalayout == EROFS_INODE_CHUNK_BASED) {
 172                 if (vi->chunkformat & ~EROFS_CHUNK_FORMAT_ALL) {
 173                         erofs_err(inode->i_sb,
 174                                   "unsupported chunk format %x of nid %llu",
 175                                   vi->chunkformat, vi->nid);
 176                         err = -EOPNOTSUPP;
 177                         goto err_out;
 178                 }
 179                 vi->chunkbits = LOG_BLOCK_SIZE +
 180                         (vi->chunkformat & EROFS_CHUNK_FORMAT_BLKBITS_MASK);
 181         }
 182         inode->i_mtime.tv_sec = inode->i_ctime.tv_sec;
 183         inode->i_atime.tv_sec = inode->i_ctime.tv_sec;
 184         inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec;
 185         inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec;
 186
 187         inode->i_flags &= ~S_DAX;
 188         if (test_opt(&sbi->opt, DAX_ALWAYS) && S_ISREG(inode->i_mode) &&
 189             vi->datalayout == EROFS_INODE_FLAT_PLAIN)
 190                 inode->i_flags |= S_DAX;
 191         if (!nblks)
 192                 /* measure inode.i_blocks as generic filesystems */
 193                 inode->i_blocks = roundup(inode->i_size, EROFS_BLKSIZ) >> 9;
 194         else
 195                 inode->i_blocks = nblks << LOG_SECTORS_PER_BLOCK;
 196         return kaddr;
 197
 198 bogusimode:
 199         erofs_err(inode->i_sb, "bogus i_mode (%o) @ nid %llu",
 200                   inode->i_mode, vi->nid);
 201         err = -EFSCORRUPTED;
 202 err_out:
 203         DBG_BUGON(1);
 204         kfree(copied);
 205         erofs_put_metabuf(buf);
 206         return ERR_PTR(err);
 207 }
 208
 209 static int erofs_fill_symlink(struct inode *inode, void *kaddr,
 210                               unsigned int m_pofs)
 211 {
 212         struct erofs_inode *vi = EROFS_I(inode);
 213         char *lnk;
 214
 215         /* if it cannot be handled with fast symlink scheme */
 216         if (vi->datalayout != EROFS_INODE_FLAT_INLINE ||
 217             inode->i_size >= EROFS_BLKSIZ) {
 218                 inode->i_op = &erofs_symlink_iops;
 219                 return 0;
 220         }
 221
 222         lnk = kmalloc(inode->i_size + 1, GFP_KERNEL);
 223         if (!lnk)
 224                 return -ENOMEM;
 225
 226         m_pofs += vi->xattr_isize;
 227         /* inline symlink data shouldn't cross block boundary */
 228         if (m_pofs + inode->i_size > EROFS_BLKSIZ) {
 229                 kfree(lnk);
 230                 erofs_err(inode->i_sb,
 231                           "inline data cross block boundary @ nid %llu",
 232                           vi->nid);
 233                 DBG_BUGON(1);
 234                 return -EFSCORRUPTED;
 235         }
 236         memcpy(lnk, kaddr + m_pofs, inode->i_size);
 237         lnk[inode->i_size] = '\0';
 238
 239         inode->i_link = lnk;
 240         inode->i_op = &erofs_fast_symlink_iops;
 241         return 0;
 242 }
 243
 244 static int erofs_fill_inode(struct inode *inode, int isdir)
 245 {
 246         struct erofs_inode *vi = EROFS_I(inode);
 247         struct erofs_buf buf = __EROFS_BUF_INITIALIZER;
 248         void *kaddr;
 249         unsigned int ofs;
 250         int err = 0;
 251
 252         trace_erofs_fill_inode(inode, isdir);
 253
 254         /* read inode base data from disk */
 255         kaddr = erofs_read_inode(&buf, inode, &ofs);
 256         if (IS_ERR(kaddr))
 257                 return PTR_ERR(kaddr);
 258
 259         /* setup the new inode */
 260         switch (inode->i_mode & S_IFMT) {
 261         case S_IFREG:
 262                 inode->i_op = &erofs_generic_iops;
 263                 if (erofs_inode_is_data_compressed(vi->datalayout))
 264                         inode->i_fop = &generic_ro_fops;
 265                 else
 266                         inode->i_fop = &erofs_file_fops;
 267                 break;
 268         case S_IFDIR:
 269                 inode->i_op = &erofs_dir_iops;
 270                 inode->i_fop = &erofs_dir_fops;
 271                 break;
 272         case S_IFLNK:
 273                 err = erofs_fill_symlink(inode, kaddr, ofs);
 274                 if (err)
 275                         goto out_unlock;
 276                 inode_nohighmem(inode);
 277                 break;
 278         case S_IFCHR:
 279         case S_IFBLK:
 280         case S_IFIFO:
 281         case S_IFSOCK:
 282                 inode->i_op = &erofs_generic_iops;
 283                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
 284                 goto out_unlock;
 285         default:
 286                 err = -EFSCORRUPTED;
 287                 goto out_unlock;
 288         }
 289
 290         if (erofs_inode_is_data_compressed(vi->datalayout)) {
 291                 if (!erofs_is_fscache_mode(inode->i_sb))
 292                         err = z_erofs_fill_inode(inode);
 293                 else
 294                         err = -EOPNOTSUPP;
 295                 goto out_unlock;
 296         }
 297         inode->i_mapping->a_ops = &erofs_raw_access_aops;
 298 #ifdef CONFIG_EROFS_FS_ONDEMAND
 299         if (erofs_is_fscache_mode(inode->i_sb))
 300                 inode->i_mapping->a_ops = &erofs_fscache_access_aops;
 301 #endif
 302
 303 out_unlock:
 304         erofs_put_metabuf(&buf);
 305         return err;
 306 }
 307
 308 /*
 309  * erofs nid is 64bits, but i_ino is 'unsigned long', therefore
 310  * we should do more for 32-bit platform to find the right inode.
 311  */
 312 static int erofs_ilookup_test_actor(struct inode *inode, void *opaque)
 313 {
 314         const erofs_nid_t nid = *(erofs_nid_t *)opaque;
 315
 316         return EROFS_I(inode)->nid == nid;
 317 }
 318
 319 static int erofs_iget_set_actor(struct inode *inode, void *opaque)
 320 {
 321         const erofs_nid_t nid = *(erofs_nid_t *)opaque;
 322
 323         inode->i_ino = erofs_inode_hash(nid);
 324         return 0;
 325 }
 326
 327 static inline struct inode *erofs_iget_locked(struct super_block *sb,
 328                                               erofs_nid_t nid)
 329 {
 330         const unsigned long hashval = erofs_inode_hash(nid);
 331
 332         return iget5_locked(sb, hashval, erofs_ilookup_test_actor,
 333                 erofs_iget_set_actor, &nid);
 334 }
 335
 336 struct inode *erofs_iget(struct super_block *sb,
 337                          erofs_nid_t nid,
 338                          bool isdir)
 339 {
 340         struct inode *inode = erofs_iget_locked(sb, nid);
 341
 342         if (!inode)
 343                 return ERR_PTR(-ENOMEM);
 344
 345         if (inode->i_state & I_NEW) {
 346                 int err;
 347                 struct erofs_inode *vi = EROFS_I(inode);
 348
 349                 vi->nid = nid;
 350
 351                 err = erofs_fill_inode(inode, isdir);
 352                 if (!err)
 353                         unlock_new_inode(inode);
 354                 else {
 355                         iget_failed(inode);
 356                         inode = ERR_PTR(err);
 357                 }
 358         }
 359         return inode;
 360 }
 361
 362 int erofs_getattr(struct user_namespace *mnt_userns, const struct path *path,
 363                   struct kstat *stat, u32 request_mask,
 364                   unsigned int query_flags)
 365 {
 366         struct inode *const inode = d_inode(path->dentry);
 367
 368         if (erofs_inode_is_data_compressed(EROFS_I(inode)->datalayout))
 369                 stat->attributes |= STATX_ATTR_COMPRESSED;
 370
 371         stat->attributes |= STATX_ATTR_IMMUTABLE;
 372         stat->attributes_mask |= (STATX_ATTR_COMPRESSED |
 373                                   STATX_ATTR_IMMUTABLE);
 374
 375         generic_fillattr(mnt_userns, inode, stat);
 376         return 0;
 377 }
 378
 379 const struct inode_operations erofs_generic_iops = {
 380         .getattr = erofs_getattr,
 381         .listxattr = erofs_listxattr,
 382         .get_acl = erofs_get_acl,
 383         .fiemap = erofs_fiemap,
 384 };
 385
 386 const struct inode_operations erofs_symlink_iops = {
 387         .get_link = page_get_link,
 388         .getattr = erofs_getattr,
 389         .listxattr = erofs_listxattr,
 390         .get_acl = erofs_get_acl,
 391 };
 392
 393 const struct inode_operations erofs_fast_symlink_iops = {
 394         .get_link = simple_get_link,
 395         .getattr = erofs_getattr,
 396         .listxattr = erofs_listxattr,
 397         .get_acl = erofs_get_acl,
 398 };