Since Linux 3.12, it has been possible use the "%pd" format specifier
to print a dentry name, so use that instead of "%.*s" and having
to pass both the length and the name.
Redhat's 3.10 kernels also have this functionality backported.
Test-Parameters: trivial
Signed-off-by: Mr NeilBrown <neilb@suse.de>
Change-Id: I70303a2c375d54825e89a0ba6703914528c54c05
Reviewed-on: https://review.whamcloud.com/38442
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: James Simmons <jsimmons@infradead.org>
Reviewed-by: Olaf Faaland-LLNL <faaland1@llnl.gov>
Reviewed-by: Oleg Drokin <green@whamcloud.com>
- CDEBUG(D_DENTRY, "%s dentry %.*s (%p, parent %p, inode %p) %s%s\n",
+ CDEBUG(D_DENTRY, "%s dentry %pd (%p, parent %p, inode %p) %s%s\n",
d_lustre_invalid((struct dentry *)de) ? "deleting" : "keeping",
d_lustre_invalid((struct dentry *)de) ? "deleting" : "keeping",
- de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
+ de, de, de->d_parent, de->d_inode,
d_unhashed((struct dentry *)de) ? "" : "hashed,",
list_empty(&de->d_subdirs) ? "" : "subdirs");
d_unhashed((struct dentry *)de) ? "" : "hashed,",
list_empty(&de->d_subdirs) ? "" : "subdirs");
ENTRY;
LASSERT(de != NULL);
ENTRY;
LASSERT(de != NULL);
- CDEBUG(D_DENTRY, "ldd on dentry %.*s (%p) parent %p inode %p refc %d\n",
- de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
- ll_d_count(de));
+ CDEBUG(D_DENTRY, "ldd on dentry %pd (%p) parent %p inode %p refc %d\n",
+ de, de, de->d_parent, de->d_inode,
+ ll_d_count(de));
if (de->d_fsdata == NULL) {
struct ll_dentry_data *lld;
if (de->d_fsdata == NULL) {
struct ll_dentry_data *lld;
spin_lock(&inode->i_lock);
hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
spin_lock(&inode->i_lock);
hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
- CDEBUG(D_DENTRY, "dentry in drop %.*s (%p) parent %p "
- "inode %p flags %d\n", dentry->d_name.len,
- dentry->d_name.name, dentry, dentry->d_parent,
+ CDEBUG(D_DENTRY,
+ "dentry in drop %pd (%p) parent %p inode %p flags %d\n",
+ dentry, dentry, dentry->d_parent,
dentry->d_inode, dentry->d_flags);
d_lustre_invalidate(dentry, 0);
dentry->d_inode, dentry->d_flags);
d_lustre_invalidate(dentry, 0);
- CDEBUG(D_VFSTRACE, "Lock request: file=%.*s, inode=%p, mode=%s "
- "start=%llu, end=%llu\n", dentry->d_name.len,
- dentry->d_name.name, dentry->d_inode,
+ CDEBUG(D_VFSTRACE,
+ "Lock request: file=%pd, inode=%p, mode=%s start=%llu, end=%llu\n",
+ dentry, dentry->d_inode,
user_lockname[ladvise->lla_lockahead_mode], (__u64) start,
(__u64) end);
user_lockname[ladvise->lla_lockahead_mode], (__u64) start,
(__u64) end);
*/
static inline void d_lustre_invalidate(struct dentry *dentry, int nested)
{
*/
static inline void d_lustre_invalidate(struct dentry *dentry, int nested)
{
- CDEBUG(D_DENTRY, "invalidate dentry %.*s (%p) parent %p inode %p "
- "refc %d\n", dentry->d_name.len, dentry->d_name.name, dentry,
+ CDEBUG(D_DENTRY, "invalidate dentry %pd (%p) parent %p inode %p refc %d\n",
+ dentry, dentry,
dentry->d_parent, dentry->d_inode, ll_d_count(dentry));
spin_lock_nested(&dentry->d_lock,
dentry->d_parent, dentry->d_inode, ll_d_count(dentry));
spin_lock_nested(&dentry->d_lock,
- if (dentry->d_name.len > ll_i2sbi(parent)->ll_namelen)
- RETURN(ERR_PTR(-ENAMETOOLONG));
+ if (dentry->d_name.len > ll_i2sbi(parent)->ll_namelen)
+ RETURN(ERR_PTR(-ENAMETOOLONG));
- CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), intent=%s\n",
- dentry->d_name.len, dentry->d_name.name,
- PFID(ll_inode2fid(parent)), parent, LL_IT2STR(it));
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p), intent=%s\n",
+ dentry, PFID(ll_inode2fid(parent)), parent, LL_IT2STR(it));
- if (d_mountpoint(dentry))
- CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
+ if (d_mountpoint(dentry))
+ CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
if (it == NULL || it->it_op == IT_GETXATTR)
it = &lookup_it;
if (it == NULL || it->it_op == IT_GETXATTR)
it = &lookup_it;
struct lookup_intent *itp, it = { .it_op = IT_GETATTR };
struct dentry *de;
struct lookup_intent *itp, it = { .it_op = IT_GETATTR };
struct dentry *de;
- CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), flags=%u\n",
- dentry->d_name.len, dentry->d_name.name,
- PFID(ll_inode2fid(parent)), parent, flags);
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p), flags=%u\n",
+ dentry, PFID(ll_inode2fid(parent)), parent, flags);
/*
* Optimize away (CREATE && !OPEN). Let .create handle the race.
/*
* Optimize away (CREATE && !OPEN). Let .create handle the race.
ENTRY;
CDEBUG(D_VFSTRACE,
ENTRY;
CDEBUG(D_VFSTRACE,
- "VFS Op:name=%.*s, dir="DFID"(%p), file %p, open_flags %x, mode %x opened %d\n",
- dentry->d_name.len, dentry->d_name.name,
- PFID(ll_inode2fid(dir)), dir, file, open_flags, mode,
+ "VFS Op:name=%pd, dir="DFID"(%p), file %p, open_flags %x, mode %x opened %d\n",
+ dentry, PFID(ll_inode2fid(dir)), dir, file, open_flags, mode,
ll_is_opened(opened, file));
/* Only negative dentries enter here */
ll_is_opened(opened, file));
/* Only negative dentries enter here */
- CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), intent=%s\n",
- dentry->d_name.len, dentry->d_name.name,
- PFID(ll_inode2fid(dir)), dir, LL_IT2STR(it));
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p), intent=%s\n",
+ dentry, PFID(ll_inode2fid(dir)), dir, LL_IT2STR(it));
rc = it_open_error(DISP_OPEN_CREATE, it);
if (rc)
rc = it_open_error(DISP_OPEN_CREATE, it);
if (rc)
static int ll_mknod(struct inode *dir, struct dentry *dchild, umode_t mode,
dev_t rdev)
{
static int ll_mknod(struct inode *dir, struct dentry *dchild, umode_t mode,
dev_t rdev)
{
- struct qstr *name = &dchild->d_name;
ktime_t kstart = ktime_get();
int err;
ENTRY;
ktime_t kstart = ktime_get();
int err;
ENTRY;
- CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p) mode %o dev %x\n",
- name->len, name->name, PFID(ll_inode2fid(dir)), dir,
- mode, rdev);
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p) mode %o dev %x\n",
+ dchild, PFID(ll_inode2fid(dir)), dir, mode, rdev);
if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
mode &= ~current_umask();
if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
mode &= ~current_umask();
CFS_FAIL_TIMEOUT(OBD_FAIL_LLITE_CREATE_FILE_PAUSE, cfs_fail_val);
CFS_FAIL_TIMEOUT(OBD_FAIL_LLITE_CREATE_FILE_PAUSE, cfs_fail_val);
- CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), "
- "flags=%u, excl=%d\n", dentry->d_name.len,
- dentry->d_name.name, PFID(ll_inode2fid(dir)),
- dir, mode, want_excl);
+ CDEBUG(D_VFSTRACE,
+ "VFS Op:name=%pd, dir="DFID"(%p), flags=%u, excl=%d\n",
+ dentry, PFID(ll_inode2fid(dir)), dir, mode, want_excl);
/* Using mknod(2) to create a regular file is designed to not recognize
* volatile file name, so we use ll_mknod() here. */
rc = ll_mknod(dir, dentry, mode, 0);
/* Using mknod(2) to create a regular file is designed to not recognize
* volatile file name, so we use ll_mknod() here. */
rc = ll_mknod(dir, dentry, mode, 0);
- CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, unhashed %d\n",
- dentry->d_name.len, dentry->d_name.name, d_unhashed(dentry));
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, unhashed %d\n",
+ dentry, d_unhashed(dentry));
if (!rc)
ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_CREATE,
if (!rc)
ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_CREATE,
static int ll_symlink(struct inode *dir, struct dentry *dchild,
const char *oldpath)
{
static int ll_symlink(struct inode *dir, struct dentry *dchild,
const char *oldpath)
{
- struct qstr *name = &dchild->d_name;
ktime_t kstart = ktime_get();
int err;
ENTRY;
ktime_t kstart = ktime_get();
int err;
ENTRY;
- CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), target=%.*s\n",
- name->len, name->name, PFID(ll_inode2fid(dir)),
- dir, 3000, oldpath);
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p), target=%.*s\n",
+ dchild, PFID(ll_inode2fid(dir)), dir, 3000, oldpath);
err = ll_new_node(dir, dchild, oldpath, S_IFLNK | S_IRWXUGO, 0,
LUSTRE_OPC_SYMLINK);
err = ll_new_node(dir, dchild, oldpath, S_IFLNK | S_IRWXUGO, 0,
LUSTRE_OPC_SYMLINK);
- CDEBUG(D_VFSTRACE, "VFS Op: inode="DFID"(%p), dir="DFID"(%p), "
- "target=%.*s\n", PFID(ll_inode2fid(src)), src,
- PFID(ll_inode2fid(dir)), dir, name->len, name->name);
+ CDEBUG(D_VFSTRACE,
+ "VFS Op: inode="DFID"(%p), dir="DFID"(%p), target=%pd\n",
+ PFID(ll_inode2fid(src)), src,
+ PFID(ll_inode2fid(dir)), dir, new_dentry);
op_data = ll_prep_md_op_data(NULL, src, dir, name->name, name->len,
0, LUSTRE_OPC_ANY, NULL);
op_data = ll_prep_md_op_data(NULL, src, dir, name->name, name->len,
0, LUSTRE_OPC_ANY, NULL);
static int ll_mkdir(struct inode *dir, struct dentry *dchild, umode_t mode)
{
static int ll_mkdir(struct inode *dir, struct dentry *dchild, umode_t mode)
{
- struct qstr *name = &dchild->d_name;
ktime_t kstart = ktime_get();
int err;
ENTRY;
ktime_t kstart = ktime_get();
int err;
ENTRY;
- CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n",
- name->len, name->name, PFID(ll_inode2fid(dir)), dir);
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p)\n",
+ dchild, PFID(ll_inode2fid(dir)), dir);
if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
mode &= ~current_umask();
if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
mode &= ~current_umask();
- CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n",
- name->len, name->name, PFID(ll_inode2fid(dir)), dir);
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p)\n",
+ dchild, PFID(ll_inode2fid(dir)), dir);
if (unlikely(d_mountpoint(dchild)))
RETURN(-EBUSY);
if (unlikely(d_mountpoint(dchild)))
RETURN(-EBUSY);
- op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, name->len,
- S_IFDIR, LUSTRE_OPC_ANY, NULL);
- if (IS_ERR(op_data))
- RETURN(PTR_ERR(op_data));
+ op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, name->len,
+ S_IFDIR, LUSTRE_OPC_ANY, NULL);
+ if (IS_ERR(op_data))
+ RETURN(PTR_ERR(op_data));
if (dchild->d_inode != NULL)
op_data->op_fid3 = *ll_inode2fid(dchild->d_inode);
if (dchild->d_inode != NULL)
op_data->op_fid3 = *ll_inode2fid(dchild->d_inode);
- CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n",
- name->len, name->name, PFID(ll_inode2fid(dir)), dir);
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p)\n",
+ dchild, PFID(ll_inode2fid(dir)), dir);
/*
* XXX: unlink bind mountpoint maybe call to here,
/*
* XXX: unlink bind mountpoint maybe call to here,
- CDEBUG(D_VFSTRACE, "VFS Op:oldname=%.*s, src_dir="DFID
- "(%p), newname=%.*s, tgt_dir="DFID"(%p)\n",
- src_name->len, src_name->name,
- PFID(ll_inode2fid(src)), src, tgt_name->len,
- tgt_name->name, PFID(ll_inode2fid(tgt)), tgt);
+ CDEBUG(D_VFSTRACE,
+ "VFS Op:oldname=%pd, src_dir="DFID"(%p), newname=%pd, tgt_dir="DFID"(%p)\n",
+ src_dchild, PFID(ll_inode2fid(src)), src,
+ tgt_dchild, PFID(ll_inode2fid(tgt)), tgt);
if (unlikely(d_mountpoint(src_dchild) || d_mountpoint(tgt_dchild)))
RETURN(-EBUSY);
if (unlikely(d_mountpoint(src_dchild) || d_mountpoint(tgt_dchild)))
RETURN(-EBUSY);
struct pcc_file *pccf = &fd->fd_pcc_file;
struct file *pcc_file;
struct path *path;
struct pcc_file *pccf = &fd->fd_pcc_file;
struct file *pcc_file;
struct path *path;
bool cached = false;
int rc = 0;
bool cached = false;
int rc = 0;
WARN_ON(pccf->pccf_file);
path = &pcci->pcci_path;
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));
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 ll_file_data *fd = file->private_data;
struct pcc_file *pccf;
struct path *path;
pcci = ll_i2pcci(inode);
LASSERT(pcci);
path = &pcci->pcci_path;
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;
pcc_inode_put(pcci);
fput(pccf->pccf_file);
pccf->pccf_file = NULL;
rc = ll_vfs_unlink(pcc_dentry->d_parent->d_inode, pcc_dentry);
if (rc)
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);
rc = ll_vfs_unlink(pca->pca_dentry->d_parent->d_inode,
pca->pca_dentry);
if (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);
/* ignore the unlink failure */
revert_creds(old_cred);
dput(pca->pca_dentry);
- CDEBUG(D_READA, "agl thread started: sai %p, parent %.*s\n",
- sai, parent->d_name.len, parent->d_name.name);
+ CDEBUG(D_READA, "agl thread started: sai %p, parent %pd\n",
+ sai, parent);
while (({set_current_state(TASK_IDLE);
!kthread_should_stop(); })) {
while (({set_current_state(TASK_IDLE);
!kthread_should_stop(); })) {
spin_lock(&plli->lli_agl_lock);
}
spin_unlock(&plli->lli_agl_lock);
spin_lock(&plli->lli_agl_lock);
}
spin_unlock(&plli->lli_agl_lock);
- CDEBUG(D_READA, "agl thread stopped: sai %p, parent %.*s\n",
- sai, parent->d_name.len, parent->d_name.name);
+ CDEBUG(D_READA, "agl thread stopped: sai %p, parent %pd\n",
+ sai, parent);
- CDEBUG(D_READA, "start agl thread: sai %p, parent %.*s\n",
- sai, parent->d_name.len, parent->d_name.name);
+ CDEBUG(D_READA, "start agl thread: sai %p, parent %pd\n",
+ sai, parent);
plli = ll_i2info(parent->d_inode);
task = kthread_create(ll_agl_thread, parent,
plli = ll_i2info(parent->d_inode);
task = kthread_create(ll_agl_thread, parent,
- CDEBUG(D_READA, "statahead thread starting: sai %p, parent %.*s\n",
- sai, parent->d_name.len, parent->d_name.name);
+ CDEBUG(D_READA, "statahead thread starting: sai %p, parent %pd\n",
+ sai, parent);
OBD_ALLOC_PTR(op_data);
if (!op_data)
OBD_ALLOC_PTR(op_data);
if (!op_data)
/* release resources held by statahead RPCs */
sa_handle_callback(sai);
/* release resources held by statahead RPCs */
sa_handle_callback(sai);
- CDEBUG(D_READA, "statahead thread stopped: sai %p, parent %.*s\n",
- sai, parent->d_name.len, parent->d_name.name);
+ CDEBUG(D_READA, "%s: statahead thread stopped: sai %p, parent %pd\n",
+ sbi->ll_fsname, sai, parent);
spin_lock(&lli->lli_sa_lock);
sai->sai_task = NULL;
spin_lock(&lli->lli_sa_lock);
sai->sai_task = NULL;
} else if ((*dentryp)->d_inode != inode) {
/* revalidate, but inode is recreated */
CDEBUG(D_READA,
} else if ((*dentryp)->d_inode != inode) {
/* revalidate, but inode is recreated */
CDEBUG(D_READA,
- "%s: stale dentry %.*s inode " DFID", statahead inode "DFID "\n",
- ll_i2sbi(inode)->ll_fsname,
- (*dentryp)->d_name.len,
- (*dentryp)->d_name.name,
+ "%s: stale dentry %pd inode " DFID", statahead inode "DFID "\n",
+ ll_i2sbi(inode)->ll_fsname, *dentryp,
PFID(ll_inode2fid((*dentryp)->d_inode)),
PFID(ll_inode2fid(inode)));
ll_intent_release(&it);
PFID(ll_inode2fid((*dentryp)->d_inode)),
PFID(ll_inode2fid(inode)));
ll_intent_release(&it);
lli->lli_sai = sai;
spin_unlock(&lli->lli_sa_lock);
lli->lli_sai = sai;
spin_unlock(&lli->lli_sa_lock);
- CDEBUG(D_READA, "start statahead thread: [pid %d] [parent %.*s]\n",
- current->pid, parent->d_name.len, parent->d_name.name);
+ CDEBUG(D_READA, "start statahead thread: [pid %d] [parent %pd]\n",
+ current->pid, parent);
task = kthread_create(ll_statahead_thread, parent, "ll_sa_%u",
lli->lli_opendir_pid);
task = kthread_create(ll_statahead_thread, parent, "ll_sa_%u",
lli->lli_opendir_pid);
int rc;
rc = revalidate_statahead_dentry(dir, sai, dentryp, unplug);
int rc;
rc = revalidate_statahead_dentry(dir, sai, dentryp, unplug);
- CDEBUG(D_READA, "revalidate statahead %.*s: %d.\n",
- (*dentryp)->d_name.len, (*dentryp)->d_name.name, rc);
+ CDEBUG(D_READA, "revalidate statahead %pd: rc = %d.\n",
+ *dentryp, rc);
ll_sai_put(sai);
return rc;
}
ll_sai_put(sai);
return rc;
}