mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
377 lines
9.3 KiB
377 lines
9.3 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Copyright (C) 2017-2018 HUAWEI, Inc. |
|
* https://www.huawei.com/ |
|
* Created by Gao Xiang <[email protected]> |
|
*/ |
|
#include "xattr.h" |
|
|
|
#include <trace/events/erofs.h> |
|
|
|
/* |
|
* if inode is successfully read, return its inode page (or sometimes |
|
* the inode payload page if it's an extended inode) in order to fill |
|
* inline data if possible. |
|
*/ |
|
static struct page *erofs_read_inode(struct inode *inode, |
|
unsigned int *ofs) |
|
{ |
|
struct super_block *sb = inode->i_sb; |
|
struct erofs_sb_info *sbi = EROFS_SB(sb); |
|
struct erofs_inode *vi = EROFS_I(inode); |
|
const erofs_off_t inode_loc = iloc(sbi, vi->nid); |
|
|
|
erofs_blk_t blkaddr, nblks = 0; |
|
struct page *page; |
|
struct erofs_inode_compact *dic; |
|
struct erofs_inode_extended *die, *copied = NULL; |
|
unsigned int ifmt; |
|
int err; |
|
|
|
blkaddr = erofs_blknr(inode_loc); |
|
*ofs = erofs_blkoff(inode_loc); |
|
|
|
erofs_dbg("%s, reading inode nid %llu at %u of blkaddr %u", |
|
__func__, vi->nid, *ofs, blkaddr); |
|
|
|
page = erofs_get_meta_page(sb, blkaddr); |
|
if (IS_ERR(page)) { |
|
erofs_err(sb, "failed to get inode (nid: %llu) page, err %ld", |
|
vi->nid, PTR_ERR(page)); |
|
return page; |
|
} |
|
|
|
dic = page_address(page) + *ofs; |
|
ifmt = le16_to_cpu(dic->i_format); |
|
|
|
if (ifmt & ~EROFS_I_ALL) { |
|
erofs_err(inode->i_sb, "unsupported i_format %u of nid %llu", |
|
ifmt, vi->nid); |
|
err = -EOPNOTSUPP; |
|
goto err_out; |
|
} |
|
|
|
vi->datalayout = erofs_inode_datalayout(ifmt); |
|
if (vi->datalayout >= EROFS_INODE_DATALAYOUT_MAX) { |
|
erofs_err(inode->i_sb, "unsupported datalayout %u of nid %llu", |
|
vi->datalayout, vi->nid); |
|
err = -EOPNOTSUPP; |
|
goto err_out; |
|
} |
|
|
|
switch (erofs_inode_version(ifmt)) { |
|
case EROFS_INODE_LAYOUT_EXTENDED: |
|
vi->inode_isize = sizeof(struct erofs_inode_extended); |
|
/* check if the inode acrosses page boundary */ |
|
if (*ofs + vi->inode_isize <= PAGE_SIZE) { |
|
*ofs += vi->inode_isize; |
|
die = (struct erofs_inode_extended *)dic; |
|
} else { |
|
const unsigned int gotten = PAGE_SIZE - *ofs; |
|
|
|
copied = kmalloc(vi->inode_isize, GFP_NOFS); |
|
if (!copied) { |
|
err = -ENOMEM; |
|
goto err_out; |
|
} |
|
memcpy(copied, dic, gotten); |
|
unlock_page(page); |
|
put_page(page); |
|
|
|
page = erofs_get_meta_page(sb, blkaddr + 1); |
|
if (IS_ERR(page)) { |
|
erofs_err(sb, "failed to get inode payload page (nid: %llu), err %ld", |
|
vi->nid, PTR_ERR(page)); |
|
kfree(copied); |
|
return page; |
|
} |
|
*ofs = vi->inode_isize - gotten; |
|
memcpy((u8 *)copied + gotten, page_address(page), *ofs); |
|
die = copied; |
|
} |
|
vi->xattr_isize = erofs_xattr_ibody_size(die->i_xattr_icount); |
|
|
|
inode->i_mode = le16_to_cpu(die->i_mode); |
|
switch (inode->i_mode & S_IFMT) { |
|
case S_IFREG: |
|
case S_IFDIR: |
|
case S_IFLNK: |
|
vi->raw_blkaddr = le32_to_cpu(die->i_u.raw_blkaddr); |
|
break; |
|
case S_IFCHR: |
|
case S_IFBLK: |
|
inode->i_rdev = |
|
new_decode_dev(le32_to_cpu(die->i_u.rdev)); |
|
break; |
|
case S_IFIFO: |
|
case S_IFSOCK: |
|
inode->i_rdev = 0; |
|
break; |
|
default: |
|
goto bogusimode; |
|
} |
|
i_uid_write(inode, le32_to_cpu(die->i_uid)); |
|
i_gid_write(inode, le32_to_cpu(die->i_gid)); |
|
set_nlink(inode, le32_to_cpu(die->i_nlink)); |
|
|
|
/* extended inode has its own timestamp */ |
|
inode->i_ctime.tv_sec = le64_to_cpu(die->i_ctime); |
|
inode->i_ctime.tv_nsec = le32_to_cpu(die->i_ctime_nsec); |
|
|
|
inode->i_size = le64_to_cpu(die->i_size); |
|
|
|
/* total blocks for compressed files */ |
|
if (erofs_inode_is_data_compressed(vi->datalayout)) |
|
nblks = le32_to_cpu(die->i_u.compressed_blocks); |
|
|
|
kfree(copied); |
|
break; |
|
case EROFS_INODE_LAYOUT_COMPACT: |
|
vi->inode_isize = sizeof(struct erofs_inode_compact); |
|
*ofs += vi->inode_isize; |
|
vi->xattr_isize = erofs_xattr_ibody_size(dic->i_xattr_icount); |
|
|
|
inode->i_mode = le16_to_cpu(dic->i_mode); |
|
switch (inode->i_mode & S_IFMT) { |
|
case S_IFREG: |
|
case S_IFDIR: |
|
case S_IFLNK: |
|
vi->raw_blkaddr = le32_to_cpu(dic->i_u.raw_blkaddr); |
|
break; |
|
case S_IFCHR: |
|
case S_IFBLK: |
|
inode->i_rdev = |
|
new_decode_dev(le32_to_cpu(dic->i_u.rdev)); |
|
break; |
|
case S_IFIFO: |
|
case S_IFSOCK: |
|
inode->i_rdev = 0; |
|
break; |
|
default: |
|
goto bogusimode; |
|
} |
|
i_uid_write(inode, le16_to_cpu(dic->i_uid)); |
|
i_gid_write(inode, le16_to_cpu(dic->i_gid)); |
|
set_nlink(inode, le16_to_cpu(dic->i_nlink)); |
|
|
|
/* use build time for compact inodes */ |
|
inode->i_ctime.tv_sec = sbi->build_time; |
|
inode->i_ctime.tv_nsec = sbi->build_time_nsec; |
|
|
|
inode->i_size = le32_to_cpu(dic->i_size); |
|
if (erofs_inode_is_data_compressed(vi->datalayout)) |
|
nblks = le32_to_cpu(dic->i_u.compressed_blocks); |
|
break; |
|
default: |
|
erofs_err(inode->i_sb, |
|
"unsupported on-disk inode version %u of nid %llu", |
|
erofs_inode_version(ifmt), vi->nid); |
|
err = -EOPNOTSUPP; |
|
goto err_out; |
|
} |
|
|
|
inode->i_mtime.tv_sec = inode->i_ctime.tv_sec; |
|
inode->i_atime.tv_sec = inode->i_ctime.tv_sec; |
|
inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec; |
|
inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec; |
|
|
|
if (!nblks) |
|
/* measure inode.i_blocks as generic filesystems */ |
|
inode->i_blocks = roundup(inode->i_size, EROFS_BLKSIZ) >> 9; |
|
else |
|
inode->i_blocks = nblks << LOG_SECTORS_PER_BLOCK; |
|
return page; |
|
|
|
bogusimode: |
|
erofs_err(inode->i_sb, "bogus i_mode (%o) @ nid %llu", |
|
inode->i_mode, vi->nid); |
|
err = -EFSCORRUPTED; |
|
err_out: |
|
DBG_BUGON(1); |
|
kfree(copied); |
|
unlock_page(page); |
|
put_page(page); |
|
return ERR_PTR(err); |
|
} |
|
|
|
static int erofs_fill_symlink(struct inode *inode, void *data, |
|
unsigned int m_pofs) |
|
{ |
|
struct erofs_inode *vi = EROFS_I(inode); |
|
char *lnk; |
|
|
|
/* if it cannot be handled with fast symlink scheme */ |
|
if (vi->datalayout != EROFS_INODE_FLAT_INLINE || |
|
inode->i_size >= PAGE_SIZE) { |
|
inode->i_op = &erofs_symlink_iops; |
|
return 0; |
|
} |
|
|
|
lnk = kmalloc(inode->i_size + 1, GFP_KERNEL); |
|
if (!lnk) |
|
return -ENOMEM; |
|
|
|
m_pofs += vi->xattr_isize; |
|
/* inline symlink data shouldn't cross page boundary as well */ |
|
if (m_pofs + inode->i_size > PAGE_SIZE) { |
|
kfree(lnk); |
|
erofs_err(inode->i_sb, |
|
"inline data cross block boundary @ nid %llu", |
|
vi->nid); |
|
DBG_BUGON(1); |
|
return -EFSCORRUPTED; |
|
} |
|
|
|
memcpy(lnk, data + m_pofs, inode->i_size); |
|
lnk[inode->i_size] = '\0'; |
|
|
|
inode->i_link = lnk; |
|
inode->i_op = &erofs_fast_symlink_iops; |
|
return 0; |
|
} |
|
|
|
static int erofs_fill_inode(struct inode *inode, int isdir) |
|
{ |
|
struct erofs_inode *vi = EROFS_I(inode); |
|
struct page *page; |
|
unsigned int ofs; |
|
int err = 0; |
|
|
|
trace_erofs_fill_inode(inode, isdir); |
|
|
|
/* read inode base data from disk */ |
|
page = erofs_read_inode(inode, &ofs); |
|
if (IS_ERR(page)) |
|
return PTR_ERR(page); |
|
|
|
/* setup the new inode */ |
|
switch (inode->i_mode & S_IFMT) { |
|
case S_IFREG: |
|
inode->i_op = &erofs_generic_iops; |
|
inode->i_fop = &generic_ro_fops; |
|
break; |
|
case S_IFDIR: |
|
inode->i_op = &erofs_dir_iops; |
|
inode->i_fop = &erofs_dir_fops; |
|
break; |
|
case S_IFLNK: |
|
err = erofs_fill_symlink(inode, page_address(page), ofs); |
|
if (err) |
|
goto out_unlock; |
|
inode_nohighmem(inode); |
|
break; |
|
case S_IFCHR: |
|
case S_IFBLK: |
|
case S_IFIFO: |
|
case S_IFSOCK: |
|
inode->i_op = &erofs_generic_iops; |
|
init_special_inode(inode, inode->i_mode, inode->i_rdev); |
|
goto out_unlock; |
|
default: |
|
err = -EFSCORRUPTED; |
|
goto out_unlock; |
|
} |
|
|
|
if (erofs_inode_is_data_compressed(vi->datalayout)) { |
|
err = z_erofs_fill_inode(inode); |
|
goto out_unlock; |
|
} |
|
inode->i_mapping->a_ops = &erofs_raw_access_aops; |
|
|
|
out_unlock: |
|
unlock_page(page); |
|
put_page(page); |
|
return err; |
|
} |
|
|
|
/* |
|
* erofs nid is 64bits, but i_ino is 'unsigned long', therefore |
|
* we should do more for 32-bit platform to find the right inode. |
|
*/ |
|
static int erofs_ilookup_test_actor(struct inode *inode, void *opaque) |
|
{ |
|
const erofs_nid_t nid = *(erofs_nid_t *)opaque; |
|
|
|
return EROFS_I(inode)->nid == nid; |
|
} |
|
|
|
static int erofs_iget_set_actor(struct inode *inode, void *opaque) |
|
{ |
|
const erofs_nid_t nid = *(erofs_nid_t *)opaque; |
|
|
|
inode->i_ino = erofs_inode_hash(nid); |
|
return 0; |
|
} |
|
|
|
static inline struct inode *erofs_iget_locked(struct super_block *sb, |
|
erofs_nid_t nid) |
|
{ |
|
const unsigned long hashval = erofs_inode_hash(nid); |
|
|
|
return iget5_locked(sb, hashval, erofs_ilookup_test_actor, |
|
erofs_iget_set_actor, &nid); |
|
} |
|
|
|
struct inode *erofs_iget(struct super_block *sb, |
|
erofs_nid_t nid, |
|
bool isdir) |
|
{ |
|
struct inode *inode = erofs_iget_locked(sb, nid); |
|
|
|
if (!inode) |
|
return ERR_PTR(-ENOMEM); |
|
|
|
if (inode->i_state & I_NEW) { |
|
int err; |
|
struct erofs_inode *vi = EROFS_I(inode); |
|
|
|
vi->nid = nid; |
|
|
|
err = erofs_fill_inode(inode, isdir); |
|
if (!err) |
|
unlock_new_inode(inode); |
|
else { |
|
iget_failed(inode); |
|
inode = ERR_PTR(err); |
|
} |
|
} |
|
return inode; |
|
} |
|
|
|
int erofs_getattr(struct user_namespace *mnt_userns, const struct path *path, |
|
struct kstat *stat, u32 request_mask, |
|
unsigned int query_flags) |
|
{ |
|
struct inode *const inode = d_inode(path->dentry); |
|
|
|
if (erofs_inode_is_data_compressed(EROFS_I(inode)->datalayout)) |
|
stat->attributes |= STATX_ATTR_COMPRESSED; |
|
|
|
stat->attributes |= STATX_ATTR_IMMUTABLE; |
|
stat->attributes_mask |= (STATX_ATTR_COMPRESSED | |
|
STATX_ATTR_IMMUTABLE); |
|
|
|
generic_fillattr(&init_user_ns, inode, stat); |
|
return 0; |
|
} |
|
|
|
const struct inode_operations erofs_generic_iops = { |
|
.getattr = erofs_getattr, |
|
.listxattr = erofs_listxattr, |
|
.get_acl = erofs_get_acl, |
|
}; |
|
|
|
const struct inode_operations erofs_symlink_iops = { |
|
.get_link = page_get_link, |
|
.getattr = erofs_getattr, |
|
.listxattr = erofs_listxattr, |
|
.get_acl = erofs_get_acl, |
|
}; |
|
|
|
const struct inode_operations erofs_fast_symlink_iops = { |
|
.get_link = simple_get_link, |
|
.getattr = erofs_getattr, |
|
.listxattr = erofs_listxattr, |
|
.get_acl = erofs_get_acl, |
|
}; |
|
|
|
|