|
| 1 | +// SPDX-License-Identifier: GPL-2.0-or-later |
| 2 | +/* |
| 3 | + * Copyright (C) 2024, Alibaba Cloud |
| 4 | + */ |
| 5 | +#include <linux/xxhash.h> |
| 6 | +#include <linux/mount.h> |
| 7 | +#include "internal.h" |
| 8 | +#include "xattr.h" |
| 9 | + |
| 10 | +#include "../internal.h" |
| 11 | + |
| 12 | +static struct vfsmount *erofs_ishare_mnt; |
| 13 | + |
| 14 | +static int erofs_ishare_iget5_eq(struct inode *inode, void *data) |
| 15 | +{ |
| 16 | + struct erofs_inode_fingerprint *fp1 = &EROFS_I(inode)->fingerprint; |
| 17 | + struct erofs_inode_fingerprint *fp2 = data; |
| 18 | + |
| 19 | + return fp1->size == fp2->size && |
| 20 | + !memcmp(fp1->opaque, fp2->opaque, fp2->size); |
| 21 | +} |
| 22 | + |
| 23 | +static int erofs_ishare_iget5_set(struct inode *inode, void *data) |
| 24 | +{ |
| 25 | + struct erofs_inode *vi = EROFS_I(inode); |
| 26 | + |
| 27 | + vi->fingerprint = *(struct erofs_inode_fingerprint *)data; |
| 28 | + INIT_LIST_HEAD(&vi->ishare_list); |
| 29 | + spin_lock_init(&vi->ishare_lock); |
| 30 | + return 0; |
| 31 | +} |
| 32 | + |
| 33 | +bool erofs_ishare_fill_inode(struct inode *inode) |
| 34 | +{ |
| 35 | + struct erofs_sb_info *sbi = EROFS_SB(inode->i_sb); |
| 36 | + struct erofs_inode *vi = EROFS_I(inode); |
| 37 | + struct erofs_inode_fingerprint fp; |
| 38 | + struct inode *sharedinode; |
| 39 | + unsigned long hash; |
| 40 | + |
| 41 | + if (erofs_xattr_fill_inode_fingerprint(&fp, inode, sbi->domain_id)) |
| 42 | + return false; |
| 43 | + hash = xxh32(fp.opaque, fp.size, 0); |
| 44 | + sharedinode = iget5_locked(erofs_ishare_mnt->mnt_sb, hash, |
| 45 | + erofs_ishare_iget5_eq, erofs_ishare_iget5_set, |
| 46 | + &fp); |
| 47 | + if (!sharedinode) { |
| 48 | + kfree(fp.opaque); |
| 49 | + return false; |
| 50 | + } |
| 51 | + |
| 52 | + if (inode_state_read_once(sharedinode) & I_NEW) { |
| 53 | + if (erofs_inode_set_aops(sharedinode, inode, true)) { |
| 54 | + iget_failed(sharedinode); |
| 55 | + kfree(fp.opaque); |
| 56 | + return false; |
| 57 | + } |
| 58 | + sharedinode->i_size = vi->vfs_inode.i_size; |
| 59 | + unlock_new_inode(sharedinode); |
| 60 | + } else { |
| 61 | + kfree(fp.opaque); |
| 62 | + if (sharedinode->i_size != vi->vfs_inode.i_size) { |
| 63 | + _erofs_printk(inode->i_sb, KERN_WARNING |
| 64 | + "size(%lld:%lld) not matches for the same fingerprint\n", |
| 65 | + vi->vfs_inode.i_size, sharedinode->i_size); |
| 66 | + iput(sharedinode); |
| 67 | + return false; |
| 68 | + } |
| 69 | + } |
| 70 | + vi->sharedinode = sharedinode; |
| 71 | + INIT_LIST_HEAD(&vi->ishare_list); |
| 72 | + spin_lock(&EROFS_I(sharedinode)->ishare_lock); |
| 73 | + list_add(&vi->ishare_list, &EROFS_I(sharedinode)->ishare_list); |
| 74 | + spin_unlock(&EROFS_I(sharedinode)->ishare_lock); |
| 75 | + return true; |
| 76 | +} |
| 77 | + |
| 78 | +void erofs_ishare_free_inode(struct inode *inode) |
| 79 | +{ |
| 80 | + struct erofs_inode *vi = EROFS_I(inode); |
| 81 | + struct inode *sharedinode = vi->sharedinode; |
| 82 | + |
| 83 | + if (!sharedinode) |
| 84 | + return; |
| 85 | + spin_lock(&EROFS_I(sharedinode)->ishare_lock); |
| 86 | + list_del(&vi->ishare_list); |
| 87 | + spin_unlock(&EROFS_I(sharedinode)->ishare_lock); |
| 88 | + iput(sharedinode); |
| 89 | + vi->sharedinode = NULL; |
| 90 | +} |
| 91 | + |
| 92 | +static int erofs_ishare_file_open(struct inode *inode, struct file *file) |
| 93 | +{ |
| 94 | + struct inode *sharedinode = EROFS_I(inode)->sharedinode; |
| 95 | + struct file *realfile; |
| 96 | + |
| 97 | + if (file->f_flags & O_DIRECT) |
| 98 | + return -EINVAL; |
| 99 | + realfile = alloc_empty_backing_file(O_RDONLY|O_NOATIME, current_cred()); |
| 100 | + if (IS_ERR(realfile)) |
| 101 | + return PTR_ERR(realfile); |
| 102 | + ihold(sharedinode); |
| 103 | + realfile->f_op = &erofs_file_fops; |
| 104 | + realfile->f_inode = sharedinode; |
| 105 | + realfile->f_mapping = sharedinode->i_mapping; |
| 106 | + path_get(&file->f_path); |
| 107 | + backing_file_set_user_path(realfile, &file->f_path); |
| 108 | + |
| 109 | + file_ra_state_init(&realfile->f_ra, file->f_mapping); |
| 110 | + realfile->private_data = EROFS_I(inode); |
| 111 | + file->private_data = realfile; |
| 112 | + return 0; |
| 113 | +} |
| 114 | + |
| 115 | +static int erofs_ishare_file_release(struct inode *inode, struct file *file) |
| 116 | +{ |
| 117 | + struct file *realfile = file->private_data; |
| 118 | + |
| 119 | + iput(realfile->f_inode); |
| 120 | + fput(realfile); |
| 121 | + file->private_data = NULL; |
| 122 | + return 0; |
| 123 | +} |
| 124 | + |
| 125 | +static ssize_t erofs_ishare_file_read_iter(struct kiocb *iocb, |
| 126 | + struct iov_iter *to) |
| 127 | +{ |
| 128 | + struct file *realfile = iocb->ki_filp->private_data; |
| 129 | + struct kiocb dedup_iocb; |
| 130 | + ssize_t nread; |
| 131 | + |
| 132 | + if (!iov_iter_count(to)) |
| 133 | + return 0; |
| 134 | + kiocb_clone(&dedup_iocb, iocb, realfile); |
| 135 | + nread = filemap_read(&dedup_iocb, to, 0); |
| 136 | + iocb->ki_pos = dedup_iocb.ki_pos; |
| 137 | + return nread; |
| 138 | +} |
| 139 | + |
| 140 | +static int erofs_ishare_mmap(struct file *file, struct vm_area_struct *vma) |
| 141 | +{ |
| 142 | + struct file *realfile = file->private_data; |
| 143 | + |
| 144 | + vma_set_file(vma, realfile); |
| 145 | + return generic_file_readonly_mmap(file, vma); |
| 146 | +} |
| 147 | + |
| 148 | +const struct file_operations erofs_ishare_fops = { |
| 149 | + .open = erofs_ishare_file_open, |
| 150 | + .llseek = generic_file_llseek, |
| 151 | + .read_iter = erofs_ishare_file_read_iter, |
| 152 | + .mmap = erofs_ishare_mmap, |
| 153 | + .release = erofs_ishare_file_release, |
| 154 | + .get_unmapped_area = thp_get_unmapped_area, |
| 155 | + .splice_read = filemap_splice_read, |
| 156 | +}; |
| 157 | + |
| 158 | +int __init erofs_init_ishare(void) |
| 159 | +{ |
| 160 | + erofs_ishare_mnt = kern_mount(&erofs_anon_fs_type); |
| 161 | + return PTR_ERR_OR_ZERO(erofs_ishare_mnt); |
| 162 | +} |
| 163 | + |
| 164 | +void erofs_exit_ishare(void) |
| 165 | +{ |
| 166 | + kern_unmount(erofs_ishare_mnt); |
| 167 | +} |
0 commit comments