#define MAX_PCC_DATABASE_PATH (6 * 5 + FID_NOBRACE_LEN + 1)
static int pcc_fid2dataset_path(char *buf, int sz, struct lu_fid *fid)
{
- return snprintf(buf, sz, "%04x/%04x/%04x/%04x/%04x/%04x/"
- DFID_NOBRACE,
- (fid)->f_oid & 0xFFFF,
- (fid)->f_oid >> 16 & 0xFFFF,
- (unsigned int)((fid)->f_seq & 0xFFFF),
- (unsigned int)((fid)->f_seq >> 16 & 0xFFFF),
- (unsigned int)((fid)->f_seq >> 32 & 0xFFFF),
- (unsigned int)((fid)->f_seq >> 48 & 0xFFFF),
- PFID(fid));
+ return scnprintf(buf, sz, "%04x/%04x/%04x/%04x/%04x/%04x/"
+ DFID_NOBRACE,
+ (fid)->f_oid & 0xFFFF,
+ (fid)->f_oid >> 16 & 0xFFFF,
+ (unsigned int)((fid)->f_seq & 0xFFFF),
+ (unsigned int)((fid)->f_seq >> 16 & 0xFFFF),
+ (unsigned int)((fid)->f_seq >> 32 & 0xFFFF),
+ (unsigned int)((fid)->f_seq >> 48 & 0xFFFF),
+ PFID(fid));
}
static inline const struct cred *pcc_super_cred(struct super_block *sb)
RETURN(PTR_ERR(env));
rc = cl_object_layout_get(env, lli->lli_clob, clt);
- if (rc)
+ if (rc < 0)
CDEBUG(D_INODE, "Cannot get layout for "DFID"\n",
PFID(ll_inode2fid(inode)));
cl_env_put(env, &refcheck);
- RETURN(rc);
+ RETURN(rc < 0 ? rc : 0);
}
static int pcc_fid2dataset_fullpath(char *buf, int sz, struct lu_fid *fid,
struct pcc_dataset *dataset)
{
- return snprintf(buf, sz, "%s/%04x/%04x/%04x/%04x/%04x/%04x/"
- DFID_NOBRACE,
- dataset->pccd_pathname,
- (fid)->f_oid & 0xFFFF,
- (fid)->f_oid >> 16 & 0xFFFF,
- (unsigned int)((fid)->f_seq & 0xFFFF),
- (unsigned int)((fid)->f_seq >> 16 & 0xFFFF),
- (unsigned int)((fid)->f_seq >> 32 & 0xFFFF),
- (unsigned int)((fid)->f_seq >> 48 & 0xFFFF),
- PFID(fid));
+ return scnprintf(buf, sz, "%s/%04x/%04x/%04x/%04x/%04x/%04x/"
+ DFID_NOBRACE,
+ dataset->pccd_pathname,
+ (fid)->f_oid & 0xFFFF,
+ (fid)->f_oid >> 16 & 0xFFFF,
+ (unsigned int)((fid)->f_seq & 0xFFFF),
+ (unsigned int)((fid)->f_seq >> 16 & 0xFFFF),
+ (unsigned int)((fid)->f_seq >> 32 & 0xFFFF),
+ (unsigned int)((fid)->f_seq >> 48 & 0xFFFF),
+ PFID(fid));
}
/* Must be called with pcci->pcci_lock held */
struct pcc_file *pccf = &fd->fd_pcc_file;
struct file *pcc_file;
struct path *path;
- struct qstr *dname;
bool cached = false;
int rc = 0;
if (!S_ISREG(inode->i_mode))
RETURN(0);
+ if (IS_ENCRYPTED(inode))
+ RETURN(0);
+
pcc_inode_lock(inode);
pcci = ll_i2pcci(inode);
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);
pcc_file = dentry_open(path, file->f_flags,
pcc_super_cred(inode->i_sb));
struct ll_file_data *fd = file->private_data;
struct pcc_file *pccf;
struct path *path;
- struct qstr *dname;
ENTRY;
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;
LASSERT(pcci && atomic_read(&pcci->pcci_active_ios) > 0);
if (atomic_dec_and_test(&pcci->pcci_active_ios))
- wake_up_all(&pcci->pcci_waitq);
+ wake_up(&pcci->pcci_waitq);
}
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;
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 (ll_file_test_and_clear_flag(lli, LLIF_UPDATE_ATIME) ||
+ if (test_and_clear_bit(LLIF_UPDATE_ATIME, &lli->lli_flags) ||
inode->i_atime.tv_sec < lli->lli_atime)
inode->i_atime.tv_sec = lli->lli_atime;
RETURN(rc);
}
+#ifdef HAVE_DEFAULT_FILE_SPLICE_READ_EXPORT
ssize_t pcc_file_splice_read(struct file *in_file, loff_t *ppos,
struct pipe_inode_info *pipe,
- size_t count, unsigned int flags,
- bool *cached)
+ size_t count, unsigned int flags)
{
struct inode *inode = file_inode(in_file);
struct ll_file_data *fd = in_file->private_data;
struct file *pcc_file = fd->fd_pcc_file.pccf_file;
+ bool cached = false;
ssize_t result;
ENTRY;
- *cached = false;
if (!pcc_file)
- RETURN(0);
-
- if (!file_inode(pcc_file)->i_fop->splice_read)
- RETURN(-ENOTSUPP);
+ RETURN(default_file_splice_read(in_file, ppos, pipe,
+ count, flags));
- pcc_io_init(inode, PIT_SPLICE_READ, cached);
- if (!*cached)
- RETURN(0);
+ pcc_io_init(inode, PIT_SPLICE_READ, &cached);
+ if (!cached)
+ RETURN(default_file_splice_read(in_file, ppos, pipe,
+ count, flags));
- result = file_inode(pcc_file)->i_fop->splice_read(pcc_file,
- ppos, pipe, count,
- flags);
+ result = default_file_splice_read(pcc_file, ppos, pipe, count, flags);
pcc_io_fini(inode);
RETURN(result);
}
+#endif /* HAVE_DEFAULT_FILE_SPLICE_READ_EXPORT */
int pcc_fsync(struct file *file, loff_t start, loff_t end,
int datasync, bool *cached)
"%s: PCC backend fs not support ->page_mkwrite()\n",
ll_i2sbi(inode)->ll_fsname);
pcc_ioctl_detach(inode, PCC_DETACH_OPT_UNCACHE);
- up_read(&mm->mmap_sem);
+ mmap_read_unlock(mm);
*cached = true;
RETURN(VM_FAULT_RETRY | VM_FAULT_NOPAGE);
}
*/
if (page->mapping == pcc_file->f_mapping) {
*cached = true;
- up_read(&mm->mmap_sem);
+ mmap_read_unlock(mm);
RETURN(VM_FAULT_RETRY | VM_FAULT_NOPAGE);
}
if (OBD_FAIL_CHECK(OBD_FAIL_LLITE_PCC_DETACH_MKWRITE)) {
pcc_io_fini(inode);
pcc_ioctl_detach(inode, PCC_DETACH_OPT_UNCACHE);
- up_read(&mm->mmap_sem);
+ mmap_read_unlock(mm);
RETURN(VM_FAULT_RETRY | VM_FAULT_NOPAGE);
}
RETURN(rc);
}
-static void pcc_layout_wait(struct pcc_inode *pcci)
-{
-
- while (atomic_read(&pcci->pcci_active_ios) > 0) {
- 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);
- }
-}
-
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)
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;
}
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);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff