X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fllite%2Fpcc.c;h=b80173e768ec9f76240f1ceab4df5cc69fab0b4d;hb=8a1334626ec2f3dba954d5a7e2162eb3fe966c47;hp=c779c72aeb1301fc90d793d4a68f356b202ac0af;hpb=b5a6ec93ce565b092034a858214bf7596ddc4414;p=fs%2Flustre-release.git diff --git a/lustre/llite/pcc.c b/lustre/llite/pcc.c index c779c72..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; @@ -459,12 +460,30 @@ pcc_parse_value_pair(struct pcc_cmd *cmd, char *buffer) if (id <= 0) return -EINVAL; cmd->u.pccc_add.pccc_roid = id; + } else if (strcmp(key, "auto_attach") == 0) { + rc = kstrtoul(val, 10, &id); + if (rc) + return rc; + if (id == 0) + cmd->u.pccc_add.pccc_flags &= ~PCC_DATASET_AUTO_ATTACH; } else if (strcmp(key, "open_attach") == 0) { rc = kstrtoul(val, 10, &id); if (rc) return rc; - if (id > 0) - cmd->u.pccc_add.pccc_flags |= PCC_DATASET_OPEN_ATTACH; + if (id == 0) + cmd->u.pccc_add.pccc_flags &= ~PCC_DATASET_OPEN_ATTACH; + } else if (strcmp(key, "io_attach") == 0) { + rc = kstrtoul(val, 10, &id); + if (rc) + return rc; + if (id == 0) + cmd->u.pccc_add.pccc_flags &= ~PCC_DATASET_IO_ATTACH; + } else if (strcmp(key, "stat_attach") == 0) { + rc = kstrtoul(val, 10, &id); + if (rc) + return rc; + if (id == 0) + cmd->u.pccc_add.pccc_flags &= ~PCC_DATASET_STAT_ATTACH; } else if (strcmp(key, "rwpcc") == 0) { rc = kstrtoul(val, 10, &id); if (rc) @@ -491,6 +510,18 @@ pcc_parse_value_pairs(struct pcc_cmd *cmd, char *buffer) char *token; int rc; + switch (cmd->pccc_cmd) { + case PCC_ADD_DATASET: + /* Enable auto attach by default */ + cmd->u.pccc_add.pccc_flags |= PCC_DATASET_AUTO_ATTACH; + break; + case PCC_DEL_DATASET: + case PCC_CLEAR_ALL: + break; + default: + return -EINVAL; + } + val = buffer; while (val != NULL && strlen(val) != 0) { token = strsep(&val, " "); @@ -510,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: @@ -796,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; } @@ -836,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); } @@ -974,7 +1013,6 @@ static void pcc_inode_init(struct pcc_inode *pcci, struct ll_inode_info *lli) { pcci->pcci_lli = lli; lli->lli_pcc_inode = pcci; - lli->lli_pcc_state = PCC_STATE_FL_NONE; atomic_set(&pcci->pcci_refcount, 0); pcci->pcci_type = LU_PCC_NONE; pcci->pcci_layout_gen = CL_LAYOUT_GEN_NONE; @@ -1044,9 +1082,15 @@ void pcc_file_init(struct pcc_file *pccf) pccf->pccf_type = LU_PCC_NONE; } -static inline bool pcc_open_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_OPEN_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"; @@ -1059,19 +1103,12 @@ static int pcc_layout_xattr_set(struct pcc_inode *pcci, __u32 gen) ENTRY; - if (!(lli->lli_pcc_state & PCC_STATE_FL_OPEN_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); } @@ -1127,12 +1164,27 @@ static void pcc_inode_attach_init(struct pcc_dataset *dataset, atomic_set(&pcci->pcci_refcount, 1); pcci->pcci_type = type; pcci->pcci_attr_valid = false; +} - if (pcc_open_attach_enabled(dataset)) { - struct ll_inode_info *lli = pcci->pcci_lli; +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; +} - lli->lli_pcc_state |= PCC_STATE_FL_OPEN_ATTACH; - } +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, @@ -1179,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); @@ -1221,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; } @@ -1232,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; @@ -1244,24 +1289,76 @@ 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_open_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_open_attach(struct inode *inode, bool *cached) +/* + * 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 = { .cl_layout_gen = 0, .cl_is_released = false, }; + struct ll_inode_info *lli = ll_i2info(inode); + __u32 gen; int rc; ENTRY; @@ -1277,29 +1374,75 @@ static int pcc_try_open_attach(struct inode *inode, bool *cached) * obtain valid layout lock from MDT (i.e. the file is being * HSM restoring). */ - if (ll_layout_version_get(ll_i2info(inode)) == CL_LAYOUT_GEN_NONE) - RETURN(0); + if (iot == PIT_OPEN) { + if (ll_layout_version_get(lli) == CL_LAYOUT_GEN_NONE) + RETURN(0); + } else { + rc = ll_layout_refresh(inode, &gen); + if (rc) + RETURN(rc); + } rc = pcc_get_layout_info(inode, &clt); if (rc) RETURN(rc); + 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; @@ -1315,7 +1458,9 @@ int pcc_file_open(struct inode *inode, struct file *file) GOTO(out_unlock, rc = 0); if (!pcci || !pcc_inode_has_layout(pcci)) { - rc = pcc_try_open_attach(inode, &cached); + 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); @@ -1327,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); @@ -1354,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; @@ -1372,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; @@ -1383,7 +1518,7 @@ out: RETURN_EXIT; } -static void pcc_io_init(struct inode *inode, bool *cached) +static void pcc_io_init(struct inode *inode, enum pcc_io_type iot, bool *cached) { struct pcc_inode *pcci; @@ -1395,6 +1530,14 @@ static void pcc_io_init(struct inode *inode, bool *cached) *cached = true; } else { *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); + atomic_inc(&pcci->pcci_active_ios); + } + } } pcc_inode_unlock(inode); } @@ -1448,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; @@ -1460,7 +1603,7 @@ ssize_t pcc_file_read_iter(struct kiocb *iocb, RETURN(0); } - pcc_io_init(inode, cached); + pcc_io_init(inode, PIT_READ, cached); if (!*cached) RETURN(0); @@ -1515,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; @@ -1532,7 +1675,7 @@ ssize_t pcc_file_write_iter(struct kiocb *iocb, RETURN(-EAGAIN); } - pcc_io_init(inode, cached); + pcc_io_init(inode, PIT_WRITE, cached); if (!*cached) RETURN(0); @@ -1568,7 +1711,7 @@ int pcc_inode_setattr(struct inode *inode, struct iattr *attr, RETURN(0); } - pcc_io_init(inode, cached); + pcc_io_init(inode, PIT_SETATTR, cached); if (!*cached) RETURN(0); @@ -1587,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; @@ -1604,22 +1748,22 @@ int pcc_inode_getattr(struct inode *inode, bool *cached) RETURN(0); } - pcc_io_init(inode, cached); + pcc_io_init(inode, PIT_GETATTR, cached); if (!*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; @@ -1655,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; @@ -1668,7 +1812,7 @@ ssize_t pcc_file_splice_read(struct file *in_file, loff_t *ppos, if (!file_inode(pcc_file)->i_fop->splice_read) RETURN(-ENOTSUPP); - pcc_io_init(inode, cached); + pcc_io_init(inode, PIT_SPLICE_READ, cached); if (!*cached) RETURN(0); @@ -1684,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; @@ -1695,19 +1839,12 @@ int pcc_fsync(struct file *file, loff_t start, loff_t end, RETURN(0); } - pcc_io_init(inode, cached); + pcc_io_init(inode, PIT_FSYNC, cached); if (!*cached) RETURN(0); -#ifdef HAVE_FILE_FSYNC_4ARGS rc = file_inode(pcc_file)->i_fop->fsync(pcc_file, start, end, datasync); -#elif defined(HAVE_FILE_FSYNC_2ARGS) - rc = file_inode(pcc_file)->i_fop->fsync(pcc_file, datasync); -#else - rc = file_inode(pcc_file)->i_fop->fsync(pcc_file, - file_dentry(dentry), datasync); -#endif pcc_io_fini(inode); RETURN(rc); @@ -1717,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; @@ -1752,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; @@ -1776,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; @@ -1801,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; @@ -1818,7 +1955,7 @@ int pcc_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf, CDEBUG(D_MMAP, "%s: PCC backend fs not support ->page_mkwrite()\n", ll_i2sbi(inode)->ll_fsname); - pcc_ioctl_detach(inode, PCC_DETACH_OPT_NONE); + pcc_ioctl_detach(inode, PCC_DETACH_OPT_UNCACHE); up_read(&mm->mmap_sem); *cached = true; RETURN(VM_FAULT_RETRY | VM_FAULT_NOPAGE); @@ -1826,7 +1963,7 @@ int pcc_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf, /* Pause to allow for a race with concurrent detach */ OBD_FAIL_TIMEOUT(OBD_FAIL_LLITE_PCC_MKWRITE_PAUSE, cfs_fail_val); - pcc_io_init(inode, cached); + pcc_io_init(inode, PIT_PAGE_MKWRITE, cached); if (!*cached) { /* This happens when the file is detached from PCC after got * the fault page via ->fault() on the inode of the PCC copy. @@ -1859,7 +1996,7 @@ int pcc_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf, */ if (OBD_FAIL_CHECK(OBD_FAIL_LLITE_PCC_DETACH_MKWRITE)) { pcc_io_fini(inode); - pcc_ioctl_detach(inode, PCC_DETACH_OPT_NONE); + pcc_ioctl_detach(inode, PCC_DETACH_OPT_UNCACHE); up_read(&mm->mmap_sem); RETURN(VM_FAULT_RETRY | VM_FAULT_NOPAGE); } @@ -1881,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; @@ -1893,7 +2030,7 @@ int pcc_fault(struct vm_area_struct *vma, struct vm_fault *vmf, RETURN(0); } - pcc_io_init(inode, cached); + pcc_io_init(inode, PIT_FAULT, cached); if (!*cached) RETURN(0); @@ -1909,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) @@ -1956,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; } @@ -2035,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); @@ -2082,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; @@ -2091,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); @@ -2114,29 +2249,38 @@ int pcc_inode_create(struct super_block *sb, struct pcc_dataset *dataset, return rc; } -int pcc_inode_create_fini(struct pcc_dataset *dataset, struct inode *inode, - struct dentry *pcc_dentry) +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 = 0; + int rc; ENTRY; - old_cred = override_creds(pcc_super_cred(inode->i_sb)); + if (!pca->pca_dataset) + RETURN(0); + + if (!inode) + GOTO(out_dataset_put, rc = 0); + + LASSERT(pcc_dentry); + + 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(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) { @@ -2159,9 +2303,35 @@ out_put: out_unlock: pcc_inode_unlock(inode); revert_creds(old_cred); +out_dataset_put: + pcc_dataset_put(pca->pca_dataset); RETURN(rc); } +void pcc_create_attach_cleanup(struct super_block *sb, + struct pcc_create_attach *pca) +{ + if (!pca->pca_dataset) + return; + + if (pca->pca_dentry) { + const struct cred *old_cred; + int rc; + + old_cred = override_creds(pcc_super_cred(sb)); + rc = ll_vfs_unlink(pca->pca_dentry->d_parent->d_inode, + pca->pca_dentry); + if (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); + } + + pcc_dataset_put(pca->pca_dataset); +} + static int pcc_filp_write(struct file *filp, const void *buf, ssize_t count, loff_t *offset) { @@ -2177,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; @@ -2192,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) @@ -2206,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); @@ -2238,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; @@ -2256,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); @@ -2298,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); } @@ -2330,7 +2506,6 @@ int pcc_readwrite_attach_fini(struct file *file, struct inode *inode, old_cred = override_creds(pcc_super_cred(inode->i_sb)); pcc_inode_lock(inode); pcci = ll_i2pcci(inode); - lli->lli_pcc_state &= ~PCC_STATE_FL_ATTACHING; if (rc || lease_broken) { if (attached && pcci) pcc_inode_put(pcci); @@ -2347,6 +2522,7 @@ int pcc_readwrite_attach_fini(struct file *file, struct inode *inode, if (rc) GOTO(out_put, rc); + LASSERT(lli->lli_pcc_state & PCC_STATE_FL_ATTACHING); rc = ll_layout_refresh(inode, &gen2); if (!rc) { if (gen2 == gen) { @@ -2365,6 +2541,7 @@ out_put: pcc_inode_put(pcci); } out_unlock: + lli->lli_pcc_state &= ~PCC_STATE_FL_ATTACHING; pcc_inode_unlock(inode); revert_creds(old_cred); RETURN(rc); @@ -2430,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); @@ -2458,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; @@ -2492,13 +2676,9 @@ int pcc_ioctl_state(struct file *file, struct inode *inode, state->pccs_type = pcci->pcci_type; state->pccs_open_count = count; state->pccs_flags = ll_i2info(inode)->lli_pcc_state; -#ifdef HAVE_DENTRY_PATH_RAW path = dentry_path_raw(pcci->pcci_path.dentry, buf, buf_len); if (IS_ERR(path)) GOTO(out_unlock, rc = PTR_ERR(path)); -#else - path = "UNKNOWN"; -#endif if (strlcpy(state->pccs_path, path, buf_len) >= buf_len) GOTO(out_unlock, rc = -ENAMETOOLONG);