LU-18810 llite: apply filename encoding to llite/*

Apply filename encoding feature to the files under llite.

This is a port of
Lustre-change: https://review.whamcloud.com/58124
Lustre-commit: TBD (from b00f33574f6fbb3cbad290c3eb6bf63d97b27bb0)
EX-bug-id: EX-11415

Signed-off-by: Emoly Liu <emoly@whamcloud.com>
Change-Id: I38c4e5b62b8bc72cb3990a80792dd2907b8b26a8
Reviewed-on: https://review.whamcloud.com/c/fs/lustre-release/+/58434
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Reviewed-by: Sebastien Buisson <sbuisson@ddn.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/llite/dcache.c b/lustre/llite/dcache.c
index 205920d..dfc0127 100644 (file)
--- a/lustre/llite/dcache.c
+++ b/lustre/llite/dcache.c
@@ -90,8 +90,8 @@ static int ll_dcompare(const struct dentry *dentry, unsigned int len,
        if (memcmp(str, name->name, len))
                RETURN(1);
 
-       CDEBUG(D_DENTRY, "found name %.*s(%p) flags %#x refc %d\n",
-              name->len, name->name, dentry, dentry->d_flags,
+       CDEBUG(D_DENTRY, "found name "DNAME"(%p) flags %#x refc %d\n",
+              encode_fn_qstr(*name), dentry, dentry->d_flags,
               ll_d_count(dentry));
 
        /* mountpoint is always valid */
@@ -128,9 +128,9 @@ static int ll_ddelete(const struct dentry *de)
        ENTRY;
        LASSERT(de);
 
-       CDEBUG(D_DENTRY, "%s dentry %pd (%p, parent %p, inode %p) %s%s\n",
+       CDEBUG(D_DENTRY, "%s dentry "DNAME" (%p, parent %p, inode %p) %s%s\n",
               d_lustre_invalid(de) ? "deleting" : "keeping",
-              de, de, de->d_parent, de->d_inode,
+              encode_fn_dentry(de), de, de->d_parent, de->d_inode,
               d_unhashed((struct dentry *)de) ? "" : "hashed,",
               d_no_children(de) ? "" : "subdirs");
 
@@ -311,8 +311,8 @@ static int ll_revalidate_dentry(struct dentry *dentry,
        struct inode *dir;
        int rc;
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%s, flags=%u\n",
-              dentry->d_name.name, lookup_flags);
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", flags=%u\n",
+              encode_fn_dentry(dentry), lookup_flags);
 
        rc = llcrypt_d_revalidate(dentry, lookup_flags);
        if (rc != 1)

diff --git a/lustre/llite/dir.c b/lustre/llite/dir.c
index f762656..35eb508 100644 (file)
--- a/lustre/llite/dir.c
+++ b/lustre/llite/dir.c
@@ -467,17 +467,18 @@ static int ll_dir_setdirstripe(struct dentry *dparent, struct lmv_user_md *lump,
 
        if (lump->lum_magic != LMV_MAGIC_FOREIGN) {
                CDEBUG(D_VFSTRACE,
-                      "VFS Op:inode="DFID"(%p) name=%s stripe_offset=%d stripe_count=%u, hash_type=%x\n",
-                      PFID(ll_inode2fid(parent)), parent, dirname,
-                      (int)lump->lum_stripe_offset, lump->lum_stripe_count,
-                      lump->lum_hash_type);
+                      "VFS Op:inode="DFID"(%p) name="DNAME" stripe_offset=%d stripe_count=%u, hash_type=%x\n",
+                      PFID(ll_inode2fid(parent)), parent,
+                      encode_fn_dentry(&dentry), (int)lump->lum_stripe_offset,
+                      lump->lum_stripe_count, lump->lum_hash_type);
        } else {
                struct lmv_foreign_md *lfm = (struct lmv_foreign_md *)lump;
 
                CDEBUG(D_VFSTRACE,
-                      "VFS Op:inode="DFID"(%p) name %s foreign, length %u, value '%.*s'\n",
-                      PFID(ll_inode2fid(parent)), parent, dirname,
-                      lfm->lfm_length, lfm->lfm_length, lfm->lfm_value);
+                      "VFS Op:inode="DFID"(%p) name "DNAME" foreign, length %u, value '"DNAME"'\n",
+                      PFID(ll_inode2fid(parent)), parent,
+                      encode_fn_dentry(&dentry), lfm->lfm_length,
+                      lfm->lfm_length, lfm->lfm_value);
        }
 
        if (lump->lum_stripe_count > 1 &&
@@ -2024,8 +2025,9 @@ static long ll_dir_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
                rc = ll_get_fid_by_name(inode, filename, namelen, NULL, NULL);
                if (rc < 0) {
-                       CERROR("%s: lookup %.*s failed: rc = %d\n",
-                              sbi->ll_fsname, namelen, filename, rc);
+                       CERROR("%s: lookup "DNAME" failed: rc = %d\n",
+                              sbi->ll_fsname,
+                              encode_fn_dname(namelen, filename), rc);
                        GOTO(out_free, rc);
                }
 out_free:
@@ -2061,7 +2063,8 @@ out_free:
                lumlen = data->ioc_inllen2;
 
                if (!lmv_user_magic_supported(lum->lum_magic)) {
-                       CERROR("%s: wrong lum magic %x : rc = %d\n", filename,
+                       CERROR("%s: wrong lum magic %x : rc = %d\n",
+                              encode_fn_len(filename, namelen),
                               lum->lum_magic, -EINVAL);
                        GOTO(lmv_out_free, rc = -EINVAL);
                }
@@ -2070,14 +2073,16 @@ out_free:
                     lum->lum_magic == LMV_USER_MAGIC_SPECIFIC) &&
                    lumlen < sizeof(*lum)) {
                        CERROR("%s: wrong lum size %d for magic %x : rc = %d\n",
-                              filename, lumlen, lum->lum_magic, -EINVAL);
+                              encode_fn_len(filename, namelen), lumlen,
+                              lum->lum_magic, -EINVAL);
                        GOTO(lmv_out_free, rc = -EINVAL);
                }
 
                if (lum->lum_magic == LMV_MAGIC_FOREIGN &&
                    lumlen < sizeof(struct lmv_foreign_md)) {
                        CERROR("%s: wrong lum magic %x or size %d: rc = %d\n",
-                              filename, lum->lum_magic, lumlen, -EFAULT);
+                              encode_fn_len(filename, namelen),
+                              lum->lum_magic, lumlen, -EFAULT);
                        GOTO(lmv_out_free, rc = -EINVAL);
                }
 
@@ -2738,7 +2743,8 @@ out_hur:
                    lum->lum_magic != LMV_USER_MAGIC_SPECIFIC) {
                        rc = -EINVAL;
                        CERROR("%s: wrong lum magic %x: rc = %d\n",
-                              filename, lum->lum_magic, rc);
+                              encode_fn_len(filename, namelen),
+                              lum->lum_magic, rc);
                        GOTO(migrate_free, rc);
                }
 

diff --git a/lustre/llite/file.c b/lustre/llite/file.c
index 00f1842..91a78e3 100644 (file)
--- a/lustre/llite/file.c
+++ b/lustre/llite/file.c
@@ -417,9 +417,9 @@ int ll_file_release(struct inode *inode, struct file *file)
 
        ENTRY;
        CDEBUG(D_VFSTRACE|D_IOTRACE,
-              "START file %s:"DFID"(%p), flags %o\n",
-              file_dentry(file)->d_name.name,
-              PFID(ll_inode2fid(file_inode(file))), inode, file->f_flags);
+              "START file "DNAME":"DFID"(%p), flags %o\n",
+              encode_fn_file(file), PFID(ll_inode2fid(file_inode(file))),
+              inode, file->f_flags);
 
        lfd = file->private_data;
        LASSERT(lfd != NULL);
@@ -457,10 +457,9 @@ out:
                ll_stats_ops_tally(sbi, LPROC_LL_RELEASE,
                                   ktime_us_delta(ktime_get(), kstart));
        CDEBUG(D_IOTRACE,
-              "COMPLETED file %s:"DFID"(%p), flags %o, rc = %d\n",
-              file_dentry(file)->d_name.name,
-              PFID(ll_inode2fid(file_inode(file))), inode, file->f_flags,
-              rc);
+              "COMPLETED file "DNAME":"DFID"(%p), flags %o, rc = %d\n",
+              encode_fn_file(file), PFID(ll_inode2fid(file_inode(file))),
+              inode, file->f_flags, rc);
 
        RETURN(rc);
 }
@@ -995,9 +994,9 @@ int ll_file_open(struct inode *inode, struct file *file)
 
        ENTRY;
        CDEBUG(D_VFSTRACE|D_IOTRACE,
-              "START file %s:"DFID"(%p), flags %o\n",
-              file_dentry(file)->d_name.name,
-              PFID(ll_inode2fid(file_inode(file))), inode, file->f_flags);
+              "START file "DNAME":"DFID"(%p), flags %o\n",
+              encode_fn_file(file), PFID(ll_inode2fid(file_inode(file))),
+              inode, file->f_flags);
 
        it = file->private_data; /* XXX: compat macro */
        file->private_data = NULL; /* prevent ll_local_open assertion */
@@ -1234,10 +1233,9 @@ out_nofiledata:
        }
 
        CDEBUG(D_IOTRACE,
-              "COMPLETED file %s:"DFID"(%p), flags %o, rc = %d\n",
-              file_dentry(file)->d_name.name,
-              PFID(ll_inode2fid(file_inode(file))), inode, file->f_flags,
-              rc);
+              "COMPLETED file "DNAME":"DFID"(%p), flags %o, rc = %d\n",
+              encode_fn_file(file), PFID(ll_inode2fid(file_inode(file))),
+              inode, file->f_flags, rc);
 
        return rc;
 }
@@ -1755,8 +1753,8 @@ void ll_io_set_mirror(struct cl_io *io, const struct file *file)
                io->ci_layout_version = lfd->fd_layout_version;
        }
 
-       CDEBUG(D_VFSTRACE, "%s: desiginated mirror: %d\n",
-              file->f_path.dentry->d_name.name, io->ci_designated_mirror);
+       CDEBUG(D_VFSTRACE, DNAME": desiginated mirror: %d\n",
+              encode_fn_file(file), io->ci_designated_mirror);
 }
 
 /* This is relatime_need_update() from Linux 5.17, which is not exported */
@@ -1976,9 +1974,9 @@ ll_file_io_generic(const struct lu_env *env, struct vvp_io_args *args,
        int rc = 0;
 
        ENTRY;
-       CDEBUG(D_VFSTRACE, "%s: %s ppos: %llu, bytes: %zu\n",
-               file_dentry(file)->d_name.name,
-               iot == CIT_READ ? "read" : "write", *ppos, bytes);
+       CDEBUG(D_VFSTRACE, DNAME": %s ppos: %llu, bytes: %zu\n",
+              encode_fn_file(file),
+              iot == CIT_READ ? "read" : "write", *ppos, bytes);
 
        max_io_bytes = min_t(size_t, PTLRPC_MAX_BRW_PAGES * OBD_MAX_RIF_DEFAULT,
                             sbi->ll_cache->ccc_lru_max >> 2) << PAGE_SHIFT;
@@ -2114,16 +2112,14 @@ out:
        cl_io_fini(env, io);
 
        CDEBUG(D_VFSTRACE,
-              "%s: %d io complete with rc: %d, result: %zd, restart: %d\n",
-              file->f_path.dentry->d_name.name,
-              iot, rc, result, io->ci_need_restart);
+              DNAME": %d io complete with rc: %d, result: %zd, restart: %d\n",
+              encode_fn_file(file), iot, rc, result, io->ci_need_restart);
 
        if ((!rc || rc == -ENODATA || rc == -ENOLCK || rc == -EIOCBQUEUED) &&
            bytes > 0 && io->ci_need_restart && retries-- > 0) {
                CDEBUG(D_VFSTRACE,
-                      "%s: restart %s from ppos=%lld bytes=%zu retries=%u ret=%zd: rc = %d\n",
-                      file_dentry(file)->d_name.name,
-                      iot == CIT_READ ? "read" : "write",
+                      DNAME": restart %s from ppos=%lld bytes=%zu retries=%u ret=%zd: rc = %d\n",
+                      encode_fn_file(file), iot == CIT_READ ? "read" : "write",
                       *ppos, bytes, retries, result, rc);
                /* preserve the tried count for FLR */
                retried = io->ci_ndelay_tried;
@@ -2340,9 +2336,9 @@ fini_io:
                size = i_size_read(inode);
                if (iocb->ki_pos >= size || read_end > size) {
                        CDEBUG(D_VFSTRACE,
-                              "%s: read [%llu, %llu] over eof, kms %llu, file_size %llu.\n",
-                              file_dentry(file)->d_name.name,
-                              iocb->ki_pos, read_end, kms, size);
+                              DNAME": read [%llu, %llu] over eof, kms %llu, file_size %llu.\n",
+                              encode_fn_file(file), iocb->ki_pos, read_end,
+                              kms, size);
 
                        if (iocb->ki_pos >= size)
                                RETURN(1);
@@ -2447,10 +2443,9 @@ static ssize_t do_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
 
        ENTRY;
        CDEBUG(D_VFSTRACE|D_IOTRACE,
-              "START file %s:"DFID", ppos: %lld, count: %zu\n",
-              file_dentry(file)->d_name.name,
-              PFID(ll_inode2fid(file_inode(file))), iocb->ki_pos,
-              iov_iter_count(to));
+              "START file "DNAME":"DFID", ppos: %lld, count: %zu\n",
+              encode_fn_file(file), PFID(ll_inode2fid(file_inode(file))),
+              iocb->ki_pos, iov_iter_count(to));
 
        if (!iov_iter_count(to))
                RETURN(0);
@@ -2531,10 +2526,9 @@ out:
        }
 
        CDEBUG(D_IOTRACE,
-              "COMPLETED: file %s:"DFID", ppos: %lld, count: %zu, rc = %zu\n",
-              file_dentry(file)->d_name.name,
-              PFID(ll_inode2fid(file_inode(file))), iocb->ki_pos,
-              iov_iter_count(to), result);
+              "COMPLETED: file "DNAME":"DFID", ppos: %lld, count: %zu, rc = %zu\n",
+              encode_fn_file(file), PFID(ll_inode2fid(file_inode(file))),
+              iocb->ki_pos, iov_iter_count(to), result);
 
        RETURN(result);
 }
@@ -2623,10 +2617,9 @@ static ssize_t do_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
 
        ENTRY;
        CDEBUG(D_VFSTRACE|D_IOTRACE,
-              "START file %s:"DFID", ppos: %lld, count: %zu\n",
-              file_dentry(file)->d_name.name,
-              PFID(ll_inode2fid(file_inode(file))), iocb->ki_pos,
-              iov_iter_count(from));
+              "START file "DNAME":"DFID", ppos: %lld, count: %zu\n",
+              encode_fn_file(file), PFID(ll_inode2fid(file_inode(file))),
+              iocb->ki_pos, iov_iter_count(from));
 
        if (!iov_iter_count(from))
                GOTO(out, rc_normal = 0);
@@ -2704,10 +2697,9 @@ out:
        }
 
        CDEBUG(D_IOTRACE,
-              "COMPLETED: file %s:"DFID", ppos: %lld, count: %zu, rc = %zu\n",
-              file_dentry(file)->d_name.name,
-              PFID(ll_inode2fid(file_inode(file))), iocb->ki_pos,
-              iov_iter_count(from), rc_normal);
+              "COMPLETED: file "DNAME":"DFID", ppos: %lld, count: %zu, rc = %zu\n",
+              encode_fn_file(file), PFID(ll_inode2fid(file_inode(file))),
+              iocb->ki_pos, iov_iter_count(from), rc_normal);
 
        RETURN(rc_normal);
 }
@@ -2887,15 +2879,16 @@ int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
        struct ptlrpc_request *req = NULL;
        struct md_op_data *op_data;
        int rc, lmmsize;
+       int namesize;
 
        ENTRY;
        rc = ll_get_default_mdsize(sbi, &lmmsize);
        if (rc)
                RETURN(rc);
 
-       op_data = ll_prep_md_op_data(NULL, inode, NULL, filename,
-                                    strlen(filename), lmmsize,
-                                    LUSTRE_OPC_ANY, NULL);
+       namesize = filename ? strlen(filename) : 0;
+       op_data = ll_prep_md_op_data(NULL, inode, NULL, filename, namesize,
+                                    lmmsize, LUSTRE_OPC_ANY, NULL);
        if (IS_ERR(op_data))
                RETURN(PTR_ERR(op_data));
 
@@ -2904,7 +2897,7 @@ int ll_lov_getstripe_ea_info(struct inode *inode, const char *filename,
        ll_finish_md_op_data(op_data);
        if (rc < 0) {
                CDEBUG(D_INFO, "md_getattr_name failed on %s: rc %d\n",
-                      filename, rc);
+                      encode_fn_len(filename, namesize), rc);
                GOTO(out, rc);
        }
 
@@ -4022,8 +4015,8 @@ int ll_file_lock_ahead(struct file *file, struct llapi_lu_ladvise *ladvise)
 
        ENTRY;
        CDEBUG(D_VFSTRACE,
-              "Lock request: file=%pd, inode=%p, mode=%s start=%llu, end=%llu\n",
-              dentry, dentry->d_inode,
+              "Lock request: file="DNAME", inode=%p, mode=%s start=%llu, end=%llu\n",
+              encode_fn_dentry(dentry), dentry->d_inode,
               user_lockname[ladvise->lla_lockahead_mode], (__u64) start,
               (__u64) end);
 
@@ -5227,10 +5220,9 @@ static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
 
        ENTRY;
        CDEBUG(D_VFSTRACE|D_IOTRACE,
-              "START file %s:"DFID", offset: %lld, type: %s\n",
-              file_dentry(file)->d_name.name,
-              PFID(ll_inode2fid(file_inode(file))), offset,
-              ll_seek_names[origin]);
+              "START file "DNAME":"DFID", offset: %lld, type: %s\n",
+              encode_fn_file(file), PFID(ll_inode2fid(file_inode(file))),
+              offset, ll_seek_names[origin]);
 
        if (origin == SEEK_END) {
                retval = ll_glimpse_size(inode);
@@ -5259,10 +5251,9 @@ static loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
                ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK,
                                   ktime_us_delta(ktime_get(), kstart));
        CDEBUG(D_VFSTRACE|D_IOTRACE,
-              "COMPLETED file %s:"DFID", offset: %lld, type: %s, rc = %lld\n",
-              file_dentry(file)->d_name.name,
-              PFID(ll_inode2fid(file_inode(file))), offset,
-              ll_seek_names[origin], retval);
+              "COMPLETED file "DNAME":"DFID", offset: %lld, type: %s, rc = %lld\n",
+              encode_fn_file(file), PFID(ll_inode2fid(file_inode(file))),
+              offset, ll_seek_names[origin], retval);
 
        RETURN(retval);
 }
@@ -5882,7 +5873,7 @@ int ll_migrate(struct inode *parent, struct file *file, struct lmv_user_md *lum,
 
        ENTRY;
        CDEBUG(D_VFSTRACE, "migrate "DFID"/%s to MDT%04x stripe count %d\n",
-              PFID(ll_inode2fid(parent)), name,
+              PFID(ll_inode2fid(parent)), encode_fn_len(name, namelen),
               lum->lum_stripe_offset, lum->lum_stripe_count);
 
        if (lum->lum_magic != cpu_to_le32(LMV_USER_MAGIC) &&
@@ -6167,8 +6158,8 @@ static int ll_inode_revalidate(struct dentry *dentry, enum ldlm_intent_flags op)
        int rc = 0;
 
        ENTRY;
-       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p),name=%s\n",
-              PFID(ll_inode2fid(inode)), inode, dentry->d_name.name);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p),name="DNAME"\n",
+              PFID(ll_inode2fid(inode)), inode, encode_fn_dentry(dentry));
 
        /* Call getattr by fid */
        if ((exp_connect_flags2(exp) & OBD_CONNECT2_GETATTR_PFID) &&
@@ -6271,8 +6262,8 @@ int ll_getattr_dentry(struct dentry *de, struct kstat *stat, u32 request_mask,
        int rc;
 
        CDEBUG(D_VFSTRACE|D_IOTRACE,
-              "START file %s:"DFID"(%p), request_mask %d, flags %u, foreign %d\n",
-              de->d_name.name, PFID(ll_inode2fid(inode)), inode,
+              "START file "DNAME":"DFID"(%p), request_mask %d, flags %u, foreign %d\n",
+              encode_fn_dentry(de), PFID(ll_inode2fid(inode)), inode,
               request_mask, flags, foreign);
 
        /* The OST object(s) determine the file size, blocks and mtime. */
@@ -6449,8 +6440,8 @@ fill_attr:
                           ktime_us_delta(ktime_get(), kstart));
 
        CDEBUG(D_IOTRACE,
-              "COMPLETED file %s:"DFID"(%p), request_mask %d, flags %u, foreign %d\n",
-              de->d_name.name, PFID(ll_inode2fid(inode)), inode,
+              "COMPLETED file "DNAME":"DFID"(%p), request_mask %d, flags %u, foreign %d\n",
+              encode_fn_dentry(de), PFID(ll_inode2fid(inode)), inode,
               request_mask, flags, foreign);
 
        return 0;

diff --git a/lustre/llite/llite_internal.h b/lustre/llite/llite_internal.h
index b15132f..6c27fab 100644 (file)
--- a/lustre/llite/llite_internal.h
+++ b/lustre/llite/llite_internal.h
@@ -2070,9 +2070,10 @@ static inline int d_lustre_invalid(const struct dentry *dentry)
  */
 static inline void d_lustre_invalidate(struct dentry *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));
+       CDEBUG(D_DENTRY,
+              "invalidate dentry "DNAME" (%p) parent %p inode %p refc %d\n",
+              encode_fn_dentry(dentry), dentry, dentry->d_parent,
+              dentry->d_inode, ll_d_count(dentry));
 
        spin_lock(&dentry->d_lock);
        set_lld_invalid(dentry, 1);

diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c
index 6fd847b..388f934 100644 (file)
--- a/lustre/llite/llite_lib.c
+++ b/lustre/llite/llite_lib.c
@@ -2257,8 +2257,8 @@ int ll_setattr_raw(struct dentry *dentry, struct iattr *attr,
        ll_set_inode_lock_owner(inode);
 
        CDEBUG(D_VFSTRACE|D_IOTRACE,
-              "START file %s:"DFID"(%p) current size %llu, valid attrs %x, mode %x, uid %d, gid %d, new size %llu, atime %lld.%.9ld, mtime %lld.%.9ld, ctime %lld.%.9ld\n",
-              dentry->d_name.name, PFID(ll_inode2fid(inode)), inode,
+              "START file "DNAME":"DFID"(%p) current size %llu, valid attrs %x, mode %x, uid %d, gid %d, new size %llu, atime %lld.%.9ld, mtime %lld.%.9ld, ctime %lld.%.9ld\n",
+              encode_fn_dentry(dentry), PFID(ll_inode2fid(inode)), inode,
               i_size_read(inode), attr->ia_valid, attr->ia_mode,
               attr->ia_uid.val, attr->ia_gid.val, attr->ia_size,
               (long long) attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec,
@@ -2507,8 +2507,8 @@ out:
                                   ktime_us_delta(ktime_get(), kstart));
 clear:
        CDEBUG(D_VFSTRACE|D_IOTRACE,
-              "COMPLETED file %s:"DFID"(%p) current size %llu, valid attrs %x, mode %x, uid %d, gid %d, new size %llu, atime %lld.%.9ld, mtime %lld.%.9ld, ctime %lld.%.9ld, rc %d\n",
-              dentry->d_name.name, PFID(ll_inode2fid(inode)), inode,
+              "COMPLETED file "DNAME":"DFID"(%p) current size %llu, valid attrs %x, mode %x, uid %d, gid %d, new size %llu, atime %lld.%.9ld, mtime %lld.%.9ld, ctime %lld.%.9ld, rc %d\n",
+              encode_fn_dentry(dentry), PFID(ll_inode2fid(inode)), inode,
               i_size_read(inode), attr->ia_valid, attr->ia_mode,
               attr->ia_uid.val, attr->ia_gid.val, attr->ia_size,
               (long long) attr->ia_atime.tv_sec, attr->ia_atime.tv_nsec,

diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c
index 3e4b1af..8e3c7d5 100644 (file)
--- a/lustre/llite/namei.c
+++ b/lustre/llite/namei.c
@@ -185,8 +185,8 @@ restart:
                                spin_unlock(&dentry->d_lock);
                                spin_unlock(&dir->i_lock);
 
-                               CDEBUG(D_DENTRY, "prune negative dentry %pd\n",
-                                      child);
+                               CDEBUG(D_DENTRY, "prune negative dentry "DNAME"\n",
+                                      encode_fn_dentry(child));
 
                                dput(child);
                                goto restart;
@@ -1001,8 +1001,9 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
        if (dentry->d_name.len > sbi->ll_namelen)
                RETURN(ERR_PTR(-ENAMETOOLONG));
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p), intent=%s\n",
-              dentry, PFID(ll_inode2fid(parent)), parent, LL_IT2STR(it));
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", dir="DFID"(%p), intent=%s\n",
+              encode_fn_dentry(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));
@@ -1256,8 +1257,9 @@ static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
        /* VFS has locked the inode before calling this */
        ll_set_inode_lock_owner(parent);
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p), flags=%u\n",
-              dentry, PFID(ll_inode2fid(parent)), parent, flags);
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", dir="DFID"(%p), flags=%u\n",
+              encode_fn_dentry(dentry), PFID(ll_inode2fid(parent)),
+              parent, flags);
 
        /*
         * Optimize away (CREATE && !OPEN). Let .create handle the race.
@@ -1334,9 +1336,9 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry,
        ll_set_inode_lock_owner(dir);
 
        CDEBUG(D_VFSTRACE,
-              "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));
+              "VFS Op:name="DNAME", dir="DFID"(%p), file %p, open_flags %x, mode %x opened %d\n",
+              encode_fn_dentry(dentry), PFID(ll_inode2fid(dir)), dir, file,
+              open_flags, mode, ll_is_opened(opened, file));
 
        /* Only negative dentries enter here */
        LASSERT(dentry->d_inode == NULL);
@@ -1551,8 +1553,9 @@ static int ll_create_it(struct inode *dir, struct dentry *dentry,
 
        ENTRY;
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p), intent=%s\n",
-              dentry, PFID(ll_inode2fid(dir)), dir, LL_IT2STR(it));
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", dir="DFID"(%p), intent=%s\n",
+              encode_fn_dentry(dentry), PFID(ll_inode2fid(dir)),
+              dir, LL_IT2STR(it));
 
        rc = it_open_error(DISP_OPEN_CREATE, it);
        if (rc)
@@ -2004,8 +2007,9 @@ static int ll_mknod(struct mnt_idmap *map, struct inode *dir,
        /* VFS has locked the inode before calling this */
        ll_set_inode_lock_owner(dir);
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p) mode %o dev %x\n",
-              dchild, PFID(ll_inode2fid(dir)), dir, mode, rdev);
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", dir="DFID"(%p) mode %o dev %x\n",
+              encode_fn_dentry(dchild), PFID(ll_inode2fid(dir)),
+              dir, mode, rdev);
 
        if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
                mode &= ~current_umask();
@@ -2052,16 +2056,17 @@ static int ll_create_nd(struct mnt_idmap *map, struct inode *dir,
        CFS_FAIL_TIMEOUT(OBD_FAIL_LLITE_CREATE_FILE_PAUSE, cfs_fail_val);
 
        CDEBUG(D_VFSTRACE,
-              "VFS Op:name=%pd, dir="DFID"(%p), flags=%u, excl=%d\n",
-              dentry, PFID(ll_inode2fid(dir)), dir, mode, want_excl);
+              "VFS Op:name="DNAME", dir="DFID"(%p), flags=%u, excl=%d\n",
+              encode_fn_dentry(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(map, dir, dentry, mode, 0);
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, unhashed %d\n",
-              dentry, d_unhashed(dentry));
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", unhashed %d\n",
+              encode_fn_dentry(dentry), d_unhashed(dentry));
 
        if (!rc)
                ll_stats_ops_tally(ll_i2sbi(dir), LPROC_LL_CREATE,
@@ -2085,8 +2090,9 @@ static int ll_symlink(struct mnt_idmap *map, struct inode *dir,
        /* VFS has locked the inode before calling this */
        ll_set_inode_lock_owner(dir);
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p), target=%.*s\n",
-              dchild, PFID(ll_inode2fid(dir)), dir, 3000, oldpath);
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", dir="DFID"(%p), target="DNAME"\n",
+              encode_fn_dentry(dchild), PFID(ll_inode2fid(dir)),
+              dir, encode_fn_dname(3000, oldpath));
 
        err = llcrypt_prepare_symlink(dir, oldpath, len, dir->i_sb->s_blocksize,
                                      &disk_link);
@@ -2126,9 +2132,9 @@ static int ll_link(struct dentry *old_dentry, struct inode *dir,
        ll_set_inode_lock_owner(dir);
 
        CDEBUG(D_VFSTRACE,
-              "VFS Op: inode="DFID"(%p), dir="DFID"(%p), target=%pd\n",
+              "VFS Op: inode="DFID"(%p), dir="DFID"(%p), target="DNAME"\n",
               PFID(ll_inode2fid(src)), src,
-              PFID(ll_inode2fid(dir)), dir, new_dentry);
+              PFID(ll_inode2fid(dir)), dir, encode_fn_dentry(new_dentry));
 
        err = llcrypt_prepare_link(old_dentry, dir, new_dentry);
        if (err)
@@ -2177,8 +2183,8 @@ static int ll_mkdir(struct mnt_idmap *map, struct inode *dir,
        /* VFS has locked the inode before calling this */
        ll_set_inode_lock_owner(dir);
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p)\n",
-              dchild, PFID(ll_inode2fid(dir)), dir);
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", dir="DFID"(%p)\n",
+              encode_fn_dentry(dchild), PFID(ll_inode2fid(dir)), dir);
 
        if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
                mode &= ~current_umask();
@@ -2252,8 +2258,8 @@ static int ll_rmdir(struct inode *dir, struct dentry *dchild)
        ll_set_inode_lock_owner(dir);
        ll_set_inode_lock_owner(dchild->d_inode);
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p)\n",
-              dchild, PFID(ll_inode2fid(dir)), dir);
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", dir="DFID"(%p)\n",
+              encode_fn_dentry(dchild), PFID(ll_inode2fid(dir)), dir);
 
        if (unlikely(d_mountpoint(dchild)))
                GOTO(out, rc = -EBUSY);
@@ -2314,8 +2320,8 @@ int ll_rmdir_entry(struct inode *dir, char *name, int namelen)
 
        ENTRY;
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n",
-              namelen, name, PFID(ll_inode2fid(dir)), dir);
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", dir="DFID"(%p)\n",
+              encode_fn_dname(namelen, name), PFID(ll_inode2fid(dir)), dir);
 
        op_data = ll_prep_md_op_data(NULL, dir, NULL, name, strlen(name),
                                     S_IFDIR, LUSTRE_OPC_ANY, NULL);
@@ -2349,8 +2355,8 @@ static int ll_unlink(struct inode *dir, struct dentry *dchild)
        ll_set_inode_lock_owner(dir);
        ll_set_inode_lock_owner(dchild->d_inode);
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, dir="DFID"(%p)\n",
-              dchild, PFID(ll_inode2fid(dir)), dir);
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", dir="DFID"(%p)\n",
+              encode_fn_dentry(dchild), PFID(ll_inode2fid(dir)), dir);
 
        /*
         * XXX: unlink bind mountpoint maybe call to here,
@@ -2435,8 +2441,8 @@ static int ll_rename(struct mnt_idmap *map,
 #endif
 
        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,
+              "VFS Op:oldname="DNAME", src_dir="DFID"(%p), newname=%pd, tgt_dir="DFID"(%p)\n",
+              encode_fn_dentry(src_dchild), PFID(ll_inode2fid(src)), src,
               tgt_dchild, PFID(ll_inode2fid(tgt)), tgt);
 
        if (unlikely(d_mountpoint(src_dchild) || d_mountpoint(tgt_dchild)))

diff --git a/lustre/llite/rw.c b/lustre/llite/rw.c
index 1b57497..d0d04f5 100644 (file)
--- a/lustre/llite/rw.c
+++ b/lustre/llite/rw.c
@@ -624,8 +624,8 @@ static void ll_readahead_handle_work(struct work_struct *wq)
        lli = ll_i2info(inode);
 
        CDEBUG(D_READA|D_IOTRACE,
-              "%s:"DFID": async ra from %lu to %lu triggered by user pid %d\n",
-              file_dentry(file)->d_name.name, PFID(ll_inode2fid(inode)),
+              DNAME":"DFID": async ra from %lu to %lu triggered by user pid %d\n",
+              encode_fn_file(file), PFID(ll_inode2fid(inode)),
               work->lrw_start_idx, work->lrw_end_idx, work->lrw_user_pid);
 
        env = cl_env_alloc(&refcheck, LCT_NOREF);

diff --git a/lustre/llite/statahead.c b/lustre/llite/statahead.c
index e9560cb..4575102 100644 (file)
--- a/lustre/llite/statahead.c
+++ b/lustre/llite/statahead.c
@@ -204,8 +204,8 @@ sa_alloc(struct dentry *parent, struct ll_statahead_info *sai, __u64 index,
        if (unlikely(!entry))
                RETURN(ERR_PTR(-ENOMEM));
 
-       CDEBUG(D_READA, "alloc sa entry %.*s(%p) index %llu\n",
-              len, name, entry, index);
+       CDEBUG(D_READA, "alloc sa entry "DNAME"(%p) index %llu\n",
+              encode_fn_dname(len, name), entry, index);
 
        entry->se_index = index;
        entry->se_sai = sai;
@@ -236,8 +236,8 @@ sa_alloc(struct dentry *parent, struct ll_statahead_info *sai, __u64 index,
 /* free sa_entry, which should have been unhashed and not in any list */
 static void sa_free(struct ll_statahead_context *ctx, struct sa_entry *entry)
 {
-       CDEBUG(D_READA, "free sa entry %.*s(%p) index %llu\n",
-              entry->se_qstr.len, entry->se_qstr.name, entry,
+       CDEBUG(D_READA, "free sa entry "DNAME"(%p) index %llu\n",
+              encode_fn_qstr(entry->se_qstr), entry,
               entry->se_index);
 
        LASSERT(list_empty(&entry->se_list));
@@ -852,9 +852,9 @@ static void ll_statahead_interpret_work(struct work_struct *work)
                }
        }
 
-       CDEBUG(D_READA, "%s: setting %.*s"DFID" l_data to inode %p\n",
-              ll_i2sbi(dir)->ll_fsname, entry->se_qstr.len,
-              entry->se_qstr.name, PFID(ll_inode2fid(child)), child);
+       CDEBUG(D_READA, "%s: setting "DNAME""DFID" l_data to inode %p\n",
+              ll_i2sbi(dir)->ll_fsname, encode_fn_qstr(entry->se_qstr),
+              PFID(ll_inode2fid(child)), child);
        ll_set_lock_data(ll_i2sbi(dir)->ll_md_exp, child, it, NULL);
 
        entry->se_inode = child;
@@ -895,8 +895,8 @@ static int ll_statahead_interpret(struct md_op_item *item, int rc)
        sai = entry->se_sai;
        LASSERT(sai != NULL);
 
-       CDEBUG(D_READA, "sa_entry %.*s rc %d\n",
-              entry->se_qstr.len, entry->se_qstr.name, rc);
+       CDEBUG(D_READA, "sa_entry "DNAME" rc %d\n",
+              encode_fn_qstr(entry->se_qstr), rc);
 
        if (rc != 0)
                GOTO(out, rc);
@@ -1843,9 +1843,9 @@ static int is_first_dirent(struct inode *dir, struct dentry *dentry)
                        }
 
                        if (dot_de && target->name[0] != '.') {
-                               CDEBUG(D_READA, "%.*s skip hidden file %.*s\n",
-                                      target->len, target->name,
-                                      namelen, name);
+                               CDEBUG(D_READA, DNAME" skip hidden file "DNAME"\n",
+                                      encode_fn_dentry(dentry),
+                                      encode_fn_dname(namelen, name));
                                continue;
                        }
 

diff --git a/lustre/llite/symlink.c b/lustre/llite/symlink.c
index e7ae929..4533820 100644 (file)
--- a/lustre/llite/symlink.c
+++ b/lustre/llite/symlink.c
@@ -52,9 +52,11 @@ static int ll_readlink_internal(struct inode *inode,
                 * will print a warning to the console, avoid this by
                 * printing just the last part of the symlink.
                 */
-               CDEBUG(D_INODE, "using cached symlink %s%.*s, len = %d\n",
-                      print_limit < symlen ? "..." : "", print_limit,
-                      (*symname) + symlen - print_limit, symlen);
+               CDEBUG(D_INODE, "using cached symlink %s"DNAME", len = %d\n",
+                      print_limit < symlen ? "..." : "",
+                      encode_fn_dname(print_limit,
+                                      (*symname) + symlen - print_limit),
+                      symlen);
                RETURN(0);
        }
 
@@ -192,8 +194,8 @@ static const char *ll_get_link(struct dentry *dentry,
        int rc;
 
        ENTRY;
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%pd, inode="DFID"(%p)\n",
-              dentry, PFID(ll_inode2fid(inode)), inode);
+       CDEBUG(D_VFSTRACE, "VFS Op:name="DNAME", inode="DFID"(%p)\n",
+              encode_fn_dentry(dentry), PFID(ll_inode2fid(inode)), inode);
        if (!dentry)
                RETURN(ERR_PTR(-ECHILD));
        ll_inode_size_lock(inode);

diff --git a/lustre/llite/vvp_io.c b/lustre/llite/vvp_io.c
index 54c0098..45cd1c6 100644 (file)
--- a/lustre/llite/vvp_io.c
+++ b/lustre/llite/vvp_io.c
@@ -817,9 +817,8 @@ static int vvp_io_read_start(const struct lu_env *env,
 
        CLOBINVRNT(env, obj, vvp_object_invariant(obj));
 
-       CDEBUG(D_VFSTRACE, "%s: read [%llu, %llu)\n",
-               file_dentry(file)->d_name.name,
-               pos, pos + crw_bytes);
+       CDEBUG(D_VFSTRACE, DNAME": read [%llu, %llu)\n",
+              encode_fn_file(file), pos, pos + crw_bytes);
 
        trunc_sem_down_read(&lli->lli_trunc_sem);
 
@@ -1304,8 +1303,8 @@ static int vvp_io_write_start(const struct lu_env *env,
                         pos, pos + crw_bytes);
        }
 
-       CDEBUG(D_VFSTRACE, "%s: write [%llu, %llu)\n",
-              file_dentry(file)->d_name.name, pos, pos + crw_bytes);
+       CDEBUG(D_VFSTRACE, DNAME": write [%llu, %llu)\n",
+              encode_fn_file(file), pos, pos + crw_bytes);
 
        /* The maximum Lustre file size is variable, based on the OST maximum
         * object size and number of stripes.  This needs another check in
@@ -1382,9 +1381,8 @@ static int vvp_io_write_start(const struct lu_env *env,
                }
                if (vio->u.readwrite.vui_written > 0) {
                        result = vio->u.readwrite.vui_written;
-                       CDEBUG(D_VFSTRACE, "%s: write bytes %zd, result: %zd\n",
-                               file_dentry(file)->d_name.name,
-                               io->ci_bytes, result);
+                       CDEBUG(D_VFSTRACE, DNAME": write bytes %zd, result: %zd\n",
+                              encode_fn_file(file), io->ci_bytes, result);
                        io->ci_bytes += result;
                } else {
                        io->ci_continue = 0;
@@ -1392,10 +1390,10 @@ static int vvp_io_write_start(const struct lu_env *env,
        }
        if (vio->vui_iocb->ki_pos != (pos + io->ci_bytes - ci_bytes)) {
                CDEBUG(D_VFSTRACE,
-                      "%s: write position mismatch: ki_pos %lld vs. pos %lld, written %zd, commit %ld: rc = %zd\n",
-                      file_dentry(file)->d_name.name,
-                      vio->vui_iocb->ki_pos, pos + io->ci_bytes - ci_bytes,
-                      written, io->ci_bytes - ci_bytes, result);
+                      DNAME": write position mismatch: ki_pos %lld vs. pos %lld, written %zd, commit %ld: rc = %zd\n",
+                      encode_fn_file(file), vio->vui_iocb->ki_pos,
+                      pos + io->ci_bytes - ci_bytes, written,
+                      io->ci_bytes - ci_bytes, result);
                /*
                 * Rewind ki_pos and vui_iter to where it has
                 * successfully committed.

diff --git a/lustre/mdd/mdd_dir.c b/lustre/mdd/mdd_dir.c
index 1ca9f56..f31619f 100644 (file)
--- a/lustre/mdd/mdd_dir.c
+++ b/lustre/mdd/mdd_dir.c
@@ -4673,8 +4673,8 @@ static int mdd_migrate_object(const struct lu_env *env,
 
        ENTRY;
 
-       CDEBUG(D_INFO, "migrate %s from "DFID"/"DFID" to "DFID"/"DFID"\n",
-              sname->ln_name, PFID(mdd_object_fid(spobj)),
+       CDEBUG(D_INFO, "migrate "DNAME" from "DFID"/"DFID" to "DFID"/"DFID"\n",
+              encode_fn_luname(sname), PFID(mdd_object_fid(spobj)),
               PFID(mdd_object_fid(sobj)), PFID(mdd_object_fid(tpobj)),
               PFID(mdd_object_fid(tobj)));