X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fllite%2Fpcc.c;h=b80173e768ec9f76240f1ceab4df5cc69fab0b4d;hb=7e0208da21f9358d96feebce5124f8587778c318;hp=e6f9d8fb33a3a4f55040d978e25dac558c070605;hpb=a120bb13525727654713f008ffcaf0e3aec7cb65;p=fs%2Flustre-release.git diff --git a/lustre/llite/pcc.c b/lustre/llite/pcc.c index e6f9d8f..b80173e 100644 --- a/lustre/llite/pcc.c +++ b/lustre/llite/pcc.c @@ -124,6 +124,7 @@ int pcc_super_init(struct pcc_super *super) cap_lower(cred->cap_effective, CAP_SYS_RESOURCE); init_rwsem(&super->pccs_rw_sem); INIT_LIST_HEAD(&super->pccs_datasets); + super->pccs_generation = 1; return 0; } @@ -213,13 +214,13 @@ pcc_fname_list_add(struct cfs_lstr *id, struct list_head *fname_list) { struct pcc_match_fname *fname; - OBD_ALLOC(fname, sizeof(struct pcc_match_fname)); + OBD_ALLOC_PTR(fname); if (fname == NULL) return -ENOMEM; OBD_ALLOC(fname->pmf_name, id->ls_len + 1); if (fname->pmf_name == NULL) { - OBD_FREE(fname, sizeof(struct pcc_match_fname)); + OBD_FREE_PTR(fname); return -ENOMEM; } @@ -312,7 +313,7 @@ pcc_expression_parse(struct cfs_lstr *src, struct list_head *cond_list) struct cfs_lstr field; int rc = 0; - OBD_ALLOC(expr, sizeof(struct pcc_expression)); + OBD_ALLOC_PTR(expr); if (expr == NULL) return -ENOMEM; @@ -370,7 +371,7 @@ pcc_conjunction_parse(struct cfs_lstr *src, struct list_head *cond_list) struct cfs_lstr expr; int rc = 0; - OBD_ALLOC(conjunction, sizeof(struct pcc_conjunction)); + OBD_ALLOC_PTR(conjunction); if (conjunction == NULL) return -ENOMEM; @@ -540,6 +541,12 @@ pcc_parse_value_pairs(struct pcc_cmd *cmd, char *buffer) */ if ((cmd->u.pccc_add.pccc_flags & PCC_DATASET_PCC_ALL) == 0) cmd->u.pccc_add.pccc_flags |= PCC_DATASET_PCC_ALL; + + /* For RW-PCC, the value of @rwid must be non zero. */ + if (cmd->u.pccc_add.pccc_flags & PCC_DATASET_RWPCC && + cmd->u.pccc_add.pccc_rwid == 0) + return -EINVAL; + break; case PCC_DEL_DATASET: case PCC_CLEAR_ALL: @@ -826,6 +833,7 @@ pcc_dataset_del(struct pcc_super *super, char *pathname) if (strcmp(dataset->pccd_pathname, pathname) == 0) { list_del_init(&dataset->pccd_linkage); pcc_dataset_put(dataset); + super->pccs_generation++; rc = 0; break; } @@ -866,6 +874,7 @@ static void pcc_remove_datasets(struct pcc_super *super) list_del(&dataset->pccd_linkage); pcc_dataset_put(dataset); } + super->pccs_generation++; up_write(&super->pccs_rw_sem); } @@ -1073,9 +1082,15 @@ void pcc_file_init(struct pcc_file *pccf) pccf->pccf_type = LU_PCC_NONE; } -static inline bool pcc_auto_attach_enabled(struct pcc_dataset *dataset) +static inline bool pcc_auto_attach_enabled(enum pcc_dataset_flags flags, + enum pcc_io_type iot) { - return dataset->pccd_flags & PCC_DATASET_AUTO_ATTACH; + if (iot == PIT_OPEN) + return flags & PCC_DATASET_OPEN_ATTACH; + if (iot == PIT_GETATTR) + return flags & PCC_DATASET_STAT_ATTACH; + else + return flags & PCC_DATASET_AUTO_ATTACH; } static const char pcc_xattr_layout[] = XATTR_USER_PREFIX "PCC.layout"; @@ -1088,19 +1103,12 @@ static int pcc_layout_xattr_set(struct pcc_inode *pcci, __u32 gen) ENTRY; - if (!(lli->lli_pcc_state & PCC_STATE_FL_AUTO_ATTACH)) + if (!(lli->lli_pcc_dsflags & PCC_DATASET_AUTO_ATTACH)) RETURN(0); -#ifndef HAVE_VFS_SETXATTR - if (!pcc_dentry->d_inode->i_op->setxattr) - RETURN(-ENOTSUPP); + rc = ll_vfs_setxattr(pcc_dentry, pcc_dentry->d_inode, pcc_xattr_layout, + &gen, sizeof(gen), 0); - rc = pcc_dentry->d_inode->i_op->setxattr(pcc_dentry, pcc_xattr_layout, - &gen, sizeof(gen), 0); -#else - rc = __vfs_setxattr(pcc_dentry, pcc_dentry->d_inode, pcc_xattr_layout, - &gen, sizeof(gen), 0); -#endif RETURN(rc); } @@ -1150,21 +1158,33 @@ static void pcc_inode_attach_init(struct pcc_dataset *dataset, struct dentry *dentry, enum lu_pcc_type type) { - struct ll_inode_info *lli = pcci->pcci_lli; - pcci->pcci_path.mnt = mntget(dataset->pccd_path.mnt); pcci->pcci_path.dentry = dentry; LASSERT(atomic_read(&pcci->pcci_refcount) == 0); atomic_set(&pcci->pcci_refcount, 1); pcci->pcci_type = type; pcci->pcci_attr_valid = false; +} - if (dataset->pccd_flags & PCC_DATASET_OPEN_ATTACH) - lli->lli_pcc_state |= PCC_STATE_FL_OPEN_ATTACH; - if (dataset->pccd_flags & PCC_DATASET_IO_ATTACH) - lli->lli_pcc_state |= PCC_STATE_FL_IO_ATTACH; - if (dataset->pccd_flags & PCC_DATASET_STAT_ATTACH) - lli->lli_pcc_state |= PCC_STATE_FL_STAT_ATTACH; +static inline void pcc_inode_dsflags_set(struct ll_inode_info *lli, + struct pcc_dataset *dataset) +{ + lli->lli_pcc_generation = ll_info2pccs(lli)->pccs_generation; + lli->lli_pcc_dsflags = dataset->pccd_flags; +} + +static void pcc_inode_attach_set(struct pcc_super *super, + struct pcc_dataset *dataset, + struct ll_inode_info *lli, + struct pcc_inode *pcci, + struct dentry *dentry, + enum lu_pcc_type type) +{ + pcc_inode_init(pcci, lli); + pcc_inode_attach_init(dataset, pcci, dentry, type); + down_read(&super->pccs_rw_sem); + pcc_inode_dsflags_set(lli, dataset); + up_read(&super->pccs_rw_sem); } static inline void pcc_layout_gen_set(struct pcc_inode *pcci, @@ -1211,18 +1231,8 @@ static int pcc_try_dataset_attach(struct inode *inode, __u32 gen, GOTO(out, rc = 0); pcc_dentry = path.dentry; -#ifndef HAVE_VFS_SETXATTR - if (!pcc_dentry->d_inode->i_op->getxattr) - /* ignore this error */ - GOTO(out_put_path, rc = 0); - - rc = pcc_dentry->d_inode->i_op->getxattr(pcc_dentry, pcc_xattr_layout, - &pcc_gen, sizeof(pcc_gen)); -#else - rc = __vfs_getxattr(pcc_dentry, pcc_dentry->d_inode, pcc_xattr_layout, - &pcc_gen, sizeof(pcc_gen)); -#endif - + rc = ll_vfs_getxattr(pcc_dentry, pcc_dentry->d_inode, pcc_xattr_layout, + &pcc_gen, sizeof(pcc_gen)); if (rc < 0) /* ignore this error */ GOTO(out_put_path, rc = 0); @@ -1253,6 +1263,7 @@ static int pcc_try_dataset_attach(struct inode *inode, __u32 gen, pcc_inode_get(pcci); pcci->pcci_type = type; } + pcc_inode_dsflags_set(lli, dataset); pcc_layout_gen_set(pcci, gen); *cached = true; } @@ -1264,11 +1275,13 @@ out: RETURN(rc); } -static int pcc_try_datasets_attach(struct inode *inode, __u32 gen, - enum lu_pcc_type type, bool *cached) +static int pcc_try_datasets_attach(struct inode *inode, enum pcc_io_type iot, + __u32 gen, enum lu_pcc_type type, + bool *cached) { - struct pcc_dataset *dataset, *tmp; struct pcc_super *super = &ll_i2sbi(inode)->ll_pcc_super; + struct ll_inode_info *lli = ll_i2info(inode); + struct pcc_dataset *dataset = NULL, *tmp; int rc = 0; ENTRY; @@ -1276,18 +1289,68 @@ static int pcc_try_datasets_attach(struct inode *inode, __u32 gen, down_read(&super->pccs_rw_sem); list_for_each_entry_safe(dataset, tmp, &super->pccs_datasets, pccd_linkage) { - if (!pcc_auto_attach_enabled(dataset)) - continue; + if (!pcc_auto_attach_enabled(dataset->pccd_flags, iot)) + break; + rc = pcc_try_dataset_attach(inode, gen, type, dataset, cached); if (rc < 0 || (!rc && *cached)) break; } + + /* + * Update the saved dataset flags for the inode accordingly if failed. + */ + if (!rc && !*cached) { + /* + * Currently auto attach strategy for a PCC backend is + * unchangeable once once it was added into the PCC datasets on + * a client as the support to change auto attach strategy is + * not implemented yet. + */ + /* + * If tried to attach from one PCC backend: + * @lli_pcc_generation > 0: + * 1) The file was once attached into PCC, but now the + * corresponding PCC backend should be removed from the client; + * 2) The layout generation was changed, the data has been + * restored; + * 3) The corresponding PCC copy is not existed on PCC + * @lli_pcc_generation == 0: + * The file is never attached into PCC but in a HSM released + * state, or once attached into PCC but the inode was evicted + * from icache later. + * Set the saved dataset flags with PCC_DATASET_NONE. Then this + * file will skip from the candidates to try auto attach until + * the file is attached into PCC again. + * + * If the file was never attached into PCC, or once attached but + * its inode was evicted from icache (lli_pcc_generation == 0), + * or the corresponding dataset was removed from the client, + * set the saved dataset flags with PCC_DATASET_NONE. + * + * TODO: If the file was once attached into PCC but not try to + * auto attach due to the change of the configuration parameters + * for this dataset (i.e. change from auto attach enabled to + * auto attach disabled for this dataset), update the saved + * dataset flags with the found one. + */ + lli->lli_pcc_dsflags = PCC_DATASET_NONE; + } up_read(&super->pccs_rw_sem); RETURN(rc); } -static int pcc_try_auto_attach(struct inode *inode, bool *cached, bool is_open) +/* + * TODO: For RW-PCC, it is desirable to store HSM info as a layout (LU-10606). + * Thus the client can get archive ID from the layout directly. When try to + * attach the file automatically which is in HSM released state (according to + * LOV_PATTERN_F_RELEASED in the layout), it can determine whether the file is + * valid cached on PCC more precisely according to the @rwid (archive ID) in + * the PCC dataset and the archive ID in HSM attrs. + */ +static int pcc_try_auto_attach(struct inode *inode, bool *cached, + enum pcc_io_type iot) { struct pcc_super *super = &ll_i2sbi(inode)->ll_pcc_super; struct cl_layout clt = { @@ -1311,7 +1374,7 @@ static int pcc_try_auto_attach(struct inode *inode, bool *cached, bool is_open) * obtain valid layout lock from MDT (i.e. the file is being * HSM restoring). */ - if (is_open) { + if (iot == PIT_OPEN) { if (ll_layout_version_get(lli) == CL_LAYOUT_GEN_NONE) RETURN(0); } else { @@ -1324,28 +1387,62 @@ static int pcc_try_auto_attach(struct inode *inode, bool *cached, bool is_open) if (rc) RETURN(rc); - if (!is_open && gen != clt.cl_layout_gen) { + if (iot != PIT_OPEN && gen != clt.cl_layout_gen) { CDEBUG(D_CACHE, DFID" layout changed from %d to %d.\n", PFID(ll_inode2fid(inode)), gen, clt.cl_layout_gen); RETURN(-EINVAL); } if (clt.cl_is_released) - rc = pcc_try_datasets_attach(inode, clt.cl_layout_gen, + rc = pcc_try_datasets_attach(inode, iot, clt.cl_layout_gen, LU_PCC_READWRITE, cached); RETURN(rc); } +static inline bool pcc_may_auto_attach(struct inode *inode, + enum pcc_io_type iot) +{ + struct ll_inode_info *lli = ll_i2info(inode); + struct pcc_super *super = ll_i2pccs(inode); + + /* Known the file was not in any PCC backend. */ + if (lli->lli_pcc_dsflags & PCC_DATASET_NONE) + return false; + + /* + * lli_pcc_generation == 0 means that the file was never attached into + * PCC, or may be once attached into PCC but detached as the inode is + * evicted from icache (i.e. "echo 3 > /proc/sys/vm/drop_caches" or + * icache shrinking due to the memory pressure), which will cause the + * file detach from PCC when releasing the inode from icache. + * In either case, we still try to attach. + */ + /* lli_pcc_generation == 0, or the PCC setting was changed, + * or there is no PCC setup on the client and the try will return + * immediately in pcc_try_auto_attach(). + */ + if (super->pccs_generation != lli->lli_pcc_generation) + return true; + + /* The cached setting @lli_pcc_dsflags is valid */ + if (iot == PIT_OPEN) + return lli->lli_pcc_dsflags & PCC_DATASET_OPEN_ATTACH; + + if (iot == PIT_GETATTR) + return lli->lli_pcc_dsflags & PCC_DATASET_STAT_ATTACH; + + return lli->lli_pcc_dsflags & PCC_DATASET_IO_ATTACH; +} + int pcc_file_open(struct inode *inode, struct file *file) { struct pcc_inode *pcci; struct ll_inode_info *lli = ll_i2info(inode); - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ll_file_data *fd = file->private_data; struct pcc_file *pccf = &fd->fd_pcc_file; struct file *pcc_file; struct path *path; - struct qstr *dname; bool cached = false; int rc = 0; @@ -1361,8 +1458,8 @@ int pcc_file_open(struct inode *inode, struct file *file) GOTO(out_unlock, rc = 0); if (!pcci || !pcc_inode_has_layout(pcci)) { - if (lli->lli_pcc_state & PCC_STATE_FL_OPEN_ATTACH) - rc = pcc_try_auto_attach(inode, &cached, true); + if (pcc_may_auto_attach(inode, PIT_OPEN)) + rc = pcc_try_auto_attach(inode, &cached, PIT_OPEN); if (rc < 0 || !cached) GOTO(out_unlock, rc); @@ -1375,17 +1472,10 @@ int pcc_file_open(struct inode *inode, struct file *file) WARN_ON(pccf->pccf_file); path = &pcci->pcci_path; - dname = &path->dentry->d_name; - CDEBUG(D_CACHE, "opening pcc file '%.*s'\n", dname->len, - dname->name); + CDEBUG(D_CACHE, "opening pcc file '%pd'\n", path->dentry); -#ifdef HAVE_DENTRY_OPEN_USE_PATH pcc_file = dentry_open(path, file->f_flags, pcc_super_cred(inode->i_sb)); -#else - pcc_file = dentry_open(path->dentry, path->mnt, file->f_flags, - pcc_super_cred(inode->i_sb)); -#endif if (IS_ERR_OR_NULL(pcc_file)) { rc = pcc_file == NULL ? -EINVAL : PTR_ERR(pcc_file); pcc_inode_put(pcci); @@ -1402,10 +1492,9 @@ out_unlock: void pcc_file_release(struct inode *inode, struct file *file) { struct pcc_inode *pcci; - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ll_file_data *fd = file->private_data; struct pcc_file *pccf; struct path *path; - struct qstr *dname; ENTRY; @@ -1420,9 +1509,7 @@ void pcc_file_release(struct inode *inode, struct file *file) pcci = ll_i2pcci(inode); LASSERT(pcci); path = &pcci->pcci_path; - dname = &path->dentry->d_name; - CDEBUG(D_CACHE, "releasing pcc file \"%.*s\"\n", dname->len, - dname->name); + CDEBUG(D_CACHE, "releasing pcc file \"%pd\"\n", path->dentry); pcc_inode_put(pcci); fput(pccf->pccf_file); pccf->pccf_file = NULL; @@ -1433,7 +1520,6 @@ out: static void pcc_io_init(struct inode *inode, enum pcc_io_type iot, bool *cached) { - struct ll_inode_info *lli = ll_i2info(inode); struct pcc_inode *pcci; pcc_inode_lock(inode); @@ -1444,11 +1530,8 @@ static void pcc_io_init(struct inode *inode, enum pcc_io_type iot, bool *cached) *cached = true; } else { *cached = false; - if ((lli->lli_pcc_state & PCC_STATE_FL_IO_ATTACH && - iot != PIT_GETATTR) || - (iot == PIT_GETATTR && - lli->lli_pcc_state & PCC_STATE_FL_STAT_ATTACH)) { - (void) pcc_try_auto_attach(inode, cached, false); + if (pcc_may_auto_attach(inode, iot)) { + (void) pcc_try_auto_attach(inode, cached, iot); if (*cached) { pcci = ll_i2pcci(inode); LASSERT(atomic_read(&pcci->pcci_refcount) > 0); @@ -1508,7 +1591,7 @@ ssize_t pcc_file_read_iter(struct kiocb *iocb, struct iov_iter *iter, bool *cached) { struct file *file = iocb->ki_filp; - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ll_file_data *fd = file->private_data; struct pcc_file *pccf = &fd->fd_pcc_file; struct inode *inode = file_inode(file); ssize_t result; @@ -1575,7 +1658,7 @@ ssize_t pcc_file_write_iter(struct kiocb *iocb, struct iov_iter *iter, bool *cached) { struct file *file = iocb->ki_filp; - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ll_file_data *fd = file->private_data; struct pcc_file *pccf = &fd->fd_pcc_file; struct inode *inode = file_inode(file); ssize_t result; @@ -1647,7 +1730,8 @@ int pcc_inode_setattr(struct inode *inode, struct iattr *attr, RETURN(rc); } -int pcc_inode_getattr(struct inode *inode, bool *cached) +int pcc_inode_getattr(struct inode *inode, u32 request_mask, + unsigned int flags, bool *cached) { struct ll_inode_info *lli = ll_i2info(inode); const struct cred *old_cred; @@ -1669,17 +1753,17 @@ int pcc_inode_getattr(struct inode *inode, bool *cached) RETURN(0); old_cred = override_creds(pcc_super_cred(inode->i_sb)); - rc = ll_vfs_getattr(&ll_i2pcci(inode)->pcci_path, &stat); + rc = ll_vfs_getattr(&ll_i2pcci(inode)->pcci_path, &stat, request_mask, + flags); revert_creds(old_cred); if (rc) GOTO(out, rc); ll_inode_size_lock(inode); - if (inode->i_atime.tv_sec < lli->lli_atime || - lli->lli_update_atime) { + if (ll_file_test_and_clear_flag(lli, LLIF_UPDATE_ATIME) || + inode->i_atime.tv_sec < lli->lli_atime) inode->i_atime.tv_sec = lli->lli_atime; - lli->lli_update_atime = 0; - } + inode->i_mtime.tv_sec = lli->lli_mtime; inode->i_ctime.tv_sec = lli->lli_ctime; @@ -1715,7 +1799,7 @@ ssize_t pcc_file_splice_read(struct file *in_file, loff_t *ppos, bool *cached) { struct inode *inode = file_inode(in_file); - struct ll_file_data *fd = LUSTRE_FPRIVATE(in_file); + struct ll_file_data *fd = in_file->private_data; struct file *pcc_file = fd->fd_pcc_file.pccf_file; ssize_t result; @@ -1744,7 +1828,7 @@ int pcc_fsync(struct file *file, loff_t start, loff_t end, int datasync, bool *cached) { struct inode *inode = file_inode(file); - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ll_file_data *fd = file->private_data; struct file *pcc_file = fd->fd_pcc_file.pccf_file; int rc; @@ -1770,7 +1854,7 @@ int pcc_file_mmap(struct file *file, struct vm_area_struct *vma, bool *cached) { struct inode *inode = file_inode(file); - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ll_file_data *fd = file->private_data; struct file *pcc_file = fd->fd_pcc_file.pccf_file; struct pcc_inode *pcci; int rc = 0; @@ -1805,7 +1889,7 @@ void pcc_vm_open(struct vm_area_struct *vma) struct pcc_inode *pcci; struct file *file = vma->vm_file; struct inode *inode = file_inode(file); - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ll_file_data *fd = file->private_data; struct file *pcc_file = fd->fd_pcc_file.pccf_file; struct vm_operations_struct *pcc_vm_ops = vma->vm_private_data; @@ -1829,7 +1913,7 @@ void pcc_vm_close(struct vm_area_struct *vma) { struct file *file = vma->vm_file; struct inode *inode = file_inode(file); - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ll_file_data *fd = file->private_data; struct file *pcc_file = fd->fd_pcc_file.pccf_file; struct vm_operations_struct *pcc_vm_ops = vma->vm_private_data; @@ -1854,7 +1938,7 @@ int pcc_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf, struct mm_struct *mm = vma->vm_mm; struct file *file = vma->vm_file; struct inode *inode = file_inode(file); - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ll_file_data *fd = file->private_data; struct file *pcc_file = fd->fd_pcc_file.pccf_file; struct vm_operations_struct *pcc_vm_ops = vma->vm_private_data; int rc; @@ -1934,7 +2018,7 @@ int pcc_fault(struct vm_area_struct *vma, struct vm_fault *vmf, { struct file *file = vma->vm_file; struct inode *inode = file_inode(file); - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ll_file_data *fd = file->private_data; struct file *pcc_file = fd->fd_pcc_file.pccf_file; struct vm_operations_struct *pcc_vm_ops = vma->vm_private_data; int rc; @@ -1962,23 +2046,17 @@ int pcc_fault(struct vm_area_struct *vma, struct vm_fault *vmf, RETURN(rc); } -static void pcc_layout_wait(struct pcc_inode *pcci) -{ - struct l_wait_info lwi = { 0 }; - - while (atomic_read(&pcci->pcci_active_ios) > 0) { - CDEBUG(D_CACHE, "Waiting for IO completion: %d\n", - atomic_read(&pcci->pcci_active_ios)); - l_wait_event(pcci->pcci_waitq, - atomic_read(&pcci->pcci_active_ios) == 0, &lwi); - } -} - static void __pcc_layout_invalidate(struct pcc_inode *pcci) { pcci->pcci_type = LU_PCC_NONE; pcc_layout_gen_set(pcci, CL_LAYOUT_GEN_NONE); - pcc_layout_wait(pcci); + if (atomic_read(&pcci->pcci_active_ios) == 0) + return; + + CDEBUG(D_CACHE, "Waiting for IO completion: %d\n", + atomic_read(&pcci->pcci_active_ios)); + wait_event_idle(pcci->pcci_waitq, + atomic_read(&pcci->pcci_active_ios) == 0); } void pcc_layout_invalidate(struct inode *inode) @@ -2009,9 +2087,8 @@ static int pcc_inode_remove(struct inode *inode, struct dentry *pcc_dentry) rc = ll_vfs_unlink(pcc_dentry->d_parent->d_inode, pcc_dentry); if (rc) - CWARN("%s: failed to unlink PCC file %.*s, rc = %d\n", - ll_i2sbi(inode)->ll_fsname, pcc_dentry->d_name.len, - pcc_dentry->d_name.name, rc); + CWARN("%s: failed to unlink PCC file %pd, rc = %d\n", + ll_i2sbi(inode)->ll_fsname, pcc_dentry, rc); return rc; } @@ -2088,7 +2165,7 @@ pcc_create(struct dentry *base, const char *name, umode_t mode) if (d_is_positive(dentry)) goto out; - rc = vfs_create(dir, dentry, mode, LL_VFS_CREATE_FALSE); + rc = vfs_create(dir, dentry, mode, false); if (rc) { dput(dentry); dentry = ERR_PTR(rc); @@ -2135,8 +2212,12 @@ out: return rc; } -/* TODO: Set the project ID for PCC copy */ -int pcc_inode_store_ugpid(struct dentry *dentry, kuid_t uid, kgid_t gid) +/* + * Reset uid, gid or size for the PCC copy masked by @valid. + * TODO: Set the project ID for PCC copy. + */ +int pcc_inode_reset_iattr(struct dentry *dentry, unsigned int valid, + kuid_t uid, kgid_t gid, loff_t size) { struct inode *inode = dentry->d_inode; struct iattr attr; @@ -2144,9 +2225,10 @@ int pcc_inode_store_ugpid(struct dentry *dentry, kuid_t uid, kgid_t gid) ENTRY; - attr.ia_valid = ATTR_UID | ATTR_GID; + attr.ia_valid = valid; attr.ia_uid = uid; attr.ia_gid = gid; + attr.ia_size = size; inode_lock(inode); rc = notify_change(dentry, &attr, NULL); @@ -2170,6 +2252,7 @@ int pcc_inode_create(struct super_block *sb, struct pcc_dataset *dataset, int pcc_inode_create_fini(struct inode *inode, struct pcc_create_attach *pca) { struct dentry *pcc_dentry = pca->pca_dentry; + struct pcc_super *super = ll_i2pccs(inode); const struct cred *old_cred; struct pcc_inode *pcci; int rc; @@ -2184,21 +2267,20 @@ int pcc_inode_create_fini(struct inode *inode, struct pcc_create_attach *pca) LASSERT(pcc_dentry); - old_cred = override_creds(pcc_super_cred(inode->i_sb)); + old_cred = override_creds(super->pccs_cred); pcc_inode_lock(inode); LASSERT(ll_i2pcci(inode) == NULL); OBD_SLAB_ALLOC_PTR_GFP(pcci, pcc_inode_slab, GFP_NOFS); if (pcci == NULL) GOTO(out_put, rc = -ENOMEM); - rc = pcc_inode_store_ugpid(pcc_dentry, old_cred->suid, - old_cred->sgid); + rc = pcc_inode_reset_iattr(pcc_dentry, ATTR_UID | ATTR_GID, + old_cred->suid, old_cred->sgid, 0); if (rc) GOTO(out_put, rc); - pcc_inode_init(pcci, ll_i2info(inode)); - pcc_inode_attach_init(pca->pca_dataset, pcci, pcc_dentry, - LU_PCC_READWRITE); + pcc_inode_attach_set(super, pca->pca_dataset, ll_i2info(inode), + pcci, pcc_dentry, LU_PCC_READWRITE); rc = pcc_layout_xattr_set(pcci, 0); if (rc) { @@ -2240,9 +2322,8 @@ void pcc_create_attach_cleanup(struct super_block *sb, rc = ll_vfs_unlink(pca->pca_dentry->d_parent->d_inode, pca->pca_dentry); if (rc) - CWARN("failed to unlink PCC file %.*s, rc = %d\n", - pca->pca_dentry->d_name.len, - pca->pca_dentry->d_name.name, rc); + CWARN("%s: failed to unlink PCC file %pd: rc = %d\n", + ll_s2sbi(sb)->ll_fsname, pca->pca_dentry, rc); /* ignore the unlink failure */ revert_creds(old_cred); dput(pca->pca_dentry); @@ -2266,9 +2347,9 @@ static int pcc_filp_write(struct file *filp, const void *buf, ssize_t count, return 0; } -static int pcc_copy_data(struct file *src, struct file *dst) +static ssize_t pcc_copy_data(struct file *src, struct file *dst) { - int rc = 0; + ssize_t rc = 0; ssize_t rc2; loff_t pos, offset = 0; size_t buf_len = 1048576; @@ -2281,6 +2362,9 @@ static int pcc_copy_data(struct file *src, struct file *dst) RETURN(-ENOMEM); while (1) { + if (signal_pending(current)) + GOTO(out_free, rc = -EINTR); + pos = offset; rc2 = cfs_kernel_read(src, buf, buf_len, &pos); if (rc2 < 0) @@ -2295,6 +2379,7 @@ static int pcc_copy_data(struct file *src, struct file *dst) offset += rc2; } + rc = offset; out_free: OBD_FREE_LARGE(buf, buf_len); RETURN(rc); @@ -2327,11 +2412,13 @@ int pcc_readwrite_attach(struct file *file, struct inode *inode, { struct pcc_dataset *dataset; struct ll_inode_info *lli = ll_i2info(inode); + struct pcc_super *super = ll_i2pccs(inode); struct pcc_inode *pcci; const struct cred *old_cred; struct dentry *dentry; struct file *pcc_filp; struct path path; + ssize_t ret; int rc; ENTRY; @@ -2345,35 +2432,35 @@ int pcc_readwrite_attach(struct file *file, struct inode *inode, if (dataset == NULL) RETURN(-ENOENT); - old_cred = override_creds(pcc_super_cred(inode->i_sb)); + old_cred = override_creds(super->pccs_cred); rc = __pcc_inode_create(dataset, &lli->lli_fid, &dentry); - if (rc) { - revert_creds(old_cred); + if (rc) GOTO(out_dataset_put, rc); - } path.mnt = dataset->pccd_path.mnt; path.dentry = dentry; -#ifdef HAVE_DENTRY_OPEN_USE_PATH - pcc_filp = dentry_open(&path, O_TRUNC | O_WRONLY | O_LARGEFILE, - current_cred()); -#else - pcc_filp = dentry_open(path.dentry, path.mnt, - O_TRUNC | O_WRONLY | O_LARGEFILE, - current_cred()); -#endif + pcc_filp = dentry_open(&path, O_WRONLY | O_LARGEFILE, current_cred()); if (IS_ERR_OR_NULL(pcc_filp)) { rc = pcc_filp == NULL ? -EINVAL : PTR_ERR(pcc_filp); - revert_creds(old_cred); GOTO(out_dentry, rc); } - rc = pcc_inode_store_ugpid(dentry, old_cred->uid, old_cred->gid); - revert_creds(old_cred); + rc = pcc_inode_reset_iattr(dentry, ATTR_UID | ATTR_GID, + old_cred->uid, old_cred->gid, 0); if (rc) GOTO(out_fput, rc); - rc = pcc_copy_data(file, pcc_filp); + ret = pcc_copy_data(file, pcc_filp); + if (ret < 0) + GOTO(out_fput, rc = ret); + + /* + * It must to truncate the PCC copy to the same size of the Lustre + * copy after copy data. Otherwise, it may get wrong file size after + * re-attach a file. See LU-13023 for details. + */ + rc = pcc_inode_reset_iattr(dentry, ATTR_SIZE, KUIDT_INIT(0), + KGIDT_INIT(0), ret); if (rc) GOTO(out_fput, rc); @@ -2387,21 +2474,21 @@ int pcc_readwrite_attach(struct file *file, struct inode *inode, if (pcci == NULL) GOTO(out_unlock, rc = -ENOMEM); - pcc_inode_init(pcci, lli); - pcc_inode_attach_init(dataset, pcci, dentry, LU_PCC_READWRITE); + pcc_inode_attach_set(super, dataset, lli, pcci, + dentry, LU_PCC_READWRITE); out_unlock: pcc_inode_unlock(inode); out_fput: fput(pcc_filp); out_dentry: if (rc) { - old_cred = override_creds(pcc_super_cred(inode->i_sb)); (void) pcc_inode_remove(inode, dentry); - revert_creds(old_cred); dput(dentry); } out_dataset_put: pcc_dataset_put(dataset); + revert_creds(old_cred); + RETURN(rc); } @@ -2520,8 +2607,15 @@ int pcc_ioctl_detach(struct inode *inode, __u32 opt) LASSERT(atomic_read(&pcci->pcci_refcount) > 0); if (pcci->pcci_type == LU_PCC_READWRITE) { - if (opt == PCC_DETACH_OPT_UNCACHE) + if (opt == PCC_DETACH_OPT_UNCACHE) { hsm_remove = true; + /* + * The file will be removed from PCC, set the flags + * with PCC_DATASET_NONE even the later removal of the + * PCC copy fails. + */ + lli->lli_pcc_dsflags = PCC_DATASET_NONE; + } __pcc_layout_invalidate(pcci); pcc_inode_put(pcci); @@ -2548,7 +2642,7 @@ int pcc_ioctl_state(struct file *file, struct inode *inode, char *buf; char *path; int buf_len = sizeof(state->pccs_path); - struct ll_file_data *fd = LUSTRE_FPRIVATE(file); + struct ll_file_data *fd = file->private_data; struct pcc_file *pccf = &fd->fd_pcc_file; struct pcc_inode *pcci;