LU-3491 llite: Replace printing of i_ino with ll_inode2fid()

The printing of i_ino/i_generation in llite messages is not nearly so
useful as printing the full inode FID, since i_ino is a "compressed"
version of the FID and there may be duplicate values for i_ino in some
cases (especially if running on a 32-bit client).

All instances of printing i_ino/i_generation are replaced with
the FID using ll_inode2fid(). All instances, except for one, of
printing just i_ino was replaced by printing the FID. In all
CERROR lines touched by the i_ino replacements, the device name
or fsname was added at the beginning of the message if it did not
already exist.

Signed-off-by: James Nunez <james.a.nunez@intel.com>
Change-Id: Ia32af1357729bf1951e0b713e75986c8177dd946
Reviewed-on: http://review.whamcloud.com/6848
Tested-by: Jenkins
Reviewed-by: Andreas Dilger <andreas.dilger@intel.com>
Tested-by: Maloo <hpdd-maloo@intel.com>
Reviewed-by: John L. Hammond <john.hammond@intel.com>

diff --git a/lustre/llite/dcache.c b/lustre/llite/dcache.c
index 2518b6a..7346bd6 100644 (file)
--- a/lustre/llite/dcache.c
+++ b/lustre/llite/dcache.c
@@ -292,8 +292,8 @@ void ll_invalidate_aliases(struct inode *inode)
 
        LASSERT(inode != NULL);
 
-       CDEBUG(D_INODE, "marking dentries for ino %lu/%u(%p) invalid\n",
-              inode->i_ino, inode->i_generation, inode);
+       CDEBUG(D_INODE, "marking dentries for inode "DFID"(%p) invalid\n",
+              PFID(ll_inode2fid(inode)), inode);
 
        ll_lock_dcache(inode);
        ll_d_hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
@@ -344,8 +344,8 @@ void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry)
                 struct inode *inode = dentry->d_inode;
                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
 
-                CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
-                       inode, inode->i_ino, inode->i_generation);
+               CDEBUG(D_DLMTRACE, "setting l_data to inode "DFID"(%p)\n",
+                      PFID(ll_inode2fid(inode)), inode);
                 ll_set_lock_data(sbi->ll_md_exp, inode, it, NULL);
         }
 

diff --git a/lustre/llite/dir.c b/lustre/llite/dir.c
index 9a4c11c..adbcbfa 100644 (file)
--- a/lustre/llite/dir.c
+++ b/lustre/llite/dir.c
@@ -160,8 +160,8 @@ static int ll_dir_filler(void *_hash, struct page *page0)
         int rc;
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) hash "LPU64"\n",
-               inode->i_ino, inode->i_generation, inode, hash);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p) hash "LPU64"\n",
+              PFID(ll_inode2fid(inode)), inode, hash);
 
        LASSERT(max_pages > 0 && max_pages <= MD_MAX_BRW_PAGES);
 
@@ -379,8 +379,8 @@ struct page *ll_get_dir_page(struct inode *dir, __u64 hash,
                        return ERR_PTR(rc);
                }
 
-               CDEBUG(D_INODE, "setting lr_lvb_inode to inode %p (%lu/%u)\n",
-                      dir, dir->i_ino, dir->i_generation);
+               CDEBUG(D_INODE, "setting lr_lvb_inode to inode "DFID"(%p)\n",
+                      PFID(ll_inode2fid(dir)), dir);
                md_set_lock_data(ll_i2sbi(dir)->ll_md_exp,
                                 &it.d.lustre.it_lock_handle, dir, NULL);
         } else {
@@ -609,8 +609,8 @@ static int ll_readdir(struct file *filp, void *cookie, filldir_t filldir)
        else
                pos = 0;
 
-       CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) pos %lu/%llu "
-              " 32bit_api %d\n", inode->i_ino, inode->i_generation,
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p) pos %lu/%llu "
+              " 32bit_api %d\n", PFID(ll_inode2fid(inode)),
               inode, (unsigned long)pos, i_size_read(inode), api32);
 
        if (pos == MDS_DIR_END_OFF)
@@ -832,9 +832,8 @@ int ll_dir_getstripe(struct inode *inode, struct lov_mds_md **lmmp,
         rc = md_getattr(sbi->ll_md_exp, op_data, &req);
         ll_finish_md_op_data(op_data);
         if (rc < 0) {
-                CDEBUG(D_INFO, "md_getattr failed on inode "
-                       "%lu/%u: rc %d\n", inode->i_ino,
-                       inode->i_generation, rc);
+               CDEBUG(D_INFO, "md_getattr failed on inode "
+                      DFID": rc %d\n", PFID(ll_inode2fid(inode)), rc);
                 GOTO(out, rc);
         }
 
@@ -1266,8 +1265,8 @@ static long ll_dir_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         int rc = 0;
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), cmd=%#x\n",
-               inode->i_ino, inode->i_generation, inode, cmd);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), cmd=%#x\n",
+              PFID(ll_inode2fid(inode)), inode, cmd);
 
         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
         if (_IOC_TYPE(cmd) == 'T' || _IOC_TYPE(cmd) == 't') /* tty ioctls */

diff --git a/lustre/llite/file.c b/lustre/llite/file.c
index c98ead8..58c1d73 100644 (file)
--- a/lustre/llite/file.c
+++ b/lustre/llite/file.c
@@ -162,14 +162,17 @@ static int ll_close_inode_openhandle(struct obd_export *md_exp,
                  * OSTs and send setattr to back to MDS. */
                 rc = ll_som_update(inode, op_data);
                 if (rc) {
-                        CERROR("inode %lu mdc Size-on-MDS update failed: "
-                               "rc = %d\n", inode->i_ino, rc);
-                        rc = 0;
-                }
-        } else if (rc) {
-                CERROR("inode %lu mdc close failed: rc = %d\n",
-                       inode->i_ino, rc);
-        }
+                       CERROR("%s: inode "DFID" mdc Size-on-MDS update"
+                              " failed: rc = %d\n",
+                              ll_i2mdexp(inode)->exp_obd->obd_name,
+                              PFID(ll_inode2fid(inode)), rc);
+                       rc = 0;
+               }
+       } else if (rc) {
+               CERROR("%s: inode "DFID" mdc close failed: rc = %d\n",
+                      ll_i2mdexp(inode)->exp_obd->obd_name,
+                      PFID(ll_inode2fid(inode)), rc);
+       }
 
        /* DATA_MODIFIED flag was successfully sent on close, cancel data
         * modification flag. */
@@ -184,8 +187,10 @@ static int ll_close_inode_openhandle(struct obd_export *md_exp,
         if (rc == 0) {
                 rc = ll_objects_destroy(req, inode);
                 if (rc)
-                        CERROR("inode %lu ll_objects destroy: rc = %d\n",
-                               inode->i_ino, rc);
+                       CERROR("%s: inode "DFID
+                              " ll_objects destroy: rc = %d\n",
+                              ll_i2mdexp(inode)->exp_obd->obd_name,
+                              PFID(ll_inode2fid(inode)), rc);
         }
 
        if (rc == 0 && op_data->op_bias & MDS_HSM_RELEASE) {
@@ -340,8 +345,8 @@ int ll_file_release(struct inode *inode, struct file *file)
         int rc;
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
-               inode->i_generation, inode);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
+              PFID(ll_inode2fid(inode)), inode);
 
 #ifdef CONFIG_FS_POSIX_ACL
        if (sbi->ll_flags & LL_SBI_RMT_CLIENT &&
@@ -547,8 +552,8 @@ int ll_file_open(struct inode *inode, struct file *file)
         int rc = 0, opendir_set = 0;
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), flags %o\n", inode->i_ino,
-               inode->i_generation, inode, file->f_flags);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), flags %o\n",
+              PFID(ll_inode2fid(inode)), inode, file->f_flags);
 
         it = file->private_data; /* XXX: compat macro */
         file->private_data = NULL; /* prevent ll_local_open assertion */
@@ -1484,8 +1489,8 @@ int ll_lov_setstripe_ea_info(struct inode *inode, struct file *file,
        lsm = ccc_inode_lsm_get(inode);
        if (lsm != NULL) {
                ccc_inode_lsm_put(inode, lsm);
-               CDEBUG(D_IOCTL, "stripe already exists for ino %lu\n",
-                      inode->i_ino);
+               CDEBUG(D_IOCTL, "stripe already exists for inode "DFID"\n",
+                      PFID(ll_inode2fid(inode)));
                RETURN(-EEXIST);
        }
 
@@ -2288,8 +2293,8 @@ long ll_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
        int                      flags, rc;
        ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),cmd=%x\n", inode->i_ino,
-               inode->i_generation, inode, cmd);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), cmd=%x\n",
+              PFID(ll_inode2fid(inode)), inode, cmd);
         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_IOCTL, 1);
 
         /* asm-ppc{,64} declares TCGETS, et. al. as type 't' not 'T' */
@@ -2674,8 +2679,8 @@ loff_t ll_file_seek(struct file *file, loff_t offset, int origin)
        ENTRY;
        retval = offset + ((origin == SEEK_END) ? i_size_read(inode) :
                           (origin == SEEK_CUR) ? file->f_pos : 0);
-       CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), to=%llu=%#llx(%d)\n",
-              inode->i_ino, inode->i_generation, inode, retval, retval,
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), to=%llu=%#llx(%d)\n",
+              PFID(ll_inode2fid(inode)), inode, retval, retval,
               origin);
        ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LLSEEK, 1);
 
@@ -2794,8 +2799,8 @@ int ll_fsync(struct file *file, struct dentry *dentry, int datasync)
         int rc, err;
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
-               inode->i_generation, inode);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
+              PFID(ll_inode2fid(inode)), inode);
         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FSYNC, 1);
 
 #ifdef HAVE_FILE_FSYNC_4ARGS
@@ -2864,8 +2869,8 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
        int rc2 = 0;
        ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu file_lock=%p\n",
-               inode->i_ino, file_lock);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID" file_lock=%p\n",
+              PFID(ll_inode2fid(inode)), file_lock);
 
         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_FLOCK, 1);
 
@@ -2950,9 +2955,10 @@ int ll_file_flock(struct file *file, int cmd, struct file_lock *file_lock)
         if (IS_ERR(op_data))
                 RETURN(PTR_ERR(op_data));
 
-       CDEBUG(D_DLMTRACE, "inode=%lu, pid=%u, flags="LPX64", mode=%u, "
-              "start="LPU64", end="LPU64"\n", inode->i_ino, flock.l_flock.pid,
-              flags, einfo.ei_mode, flock.l_flock.start, flock.l_flock.end);
+       CDEBUG(D_DLMTRACE, "inode="DFID", pid=%u, flags="LPX64", mode=%u, "
+              "start="LPU64", end="LPU64"\n", PFID(ll_inode2fid(inode)),
+              flock.l_flock.pid, flags, einfo.ei_mode,
+              flock.l_flock.start, flock.l_flock.end);
 
         rc = md_enqueue(sbi->ll_md_exp, &einfo, NULL,
                         op_data, &lockh, &flock, 0, NULL /* req */, flags);
@@ -3083,8 +3089,8 @@ int __ll_inode_revalidate_it(struct dentry *dentry, struct lookup_intent *it,
 
         LASSERT(inode != NULL);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),name=%s\n",
-               inode->i_ino, inode->i_generation, inode, dentry->d_name.name);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p),name=%s\n",
+              PFID(ll_inode2fid(inode)), inode, dentry->d_name.name);
 
         exp = ll_i2mdexp(inode);
 
@@ -3353,8 +3359,8 @@ int ll_inode_permission(struct inode *inode, int mask, struct nameidata *nd)
                         RETURN(rc);
         }
 
-       CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), inode mode %x mask %o\n",
-              inode->i_ino, inode->i_generation, inode, inode->i_mode, mask);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), inode mode %x mask %o\n",
+              PFID(ll_inode2fid(inode)), inode, inode->i_mode, mask);
 
        if (ll_i2sbi(inode)->ll_flags & LL_SBI_RMT_CLIENT)
                return lustre_check_remote_perm(inode, mask);
@@ -3655,8 +3661,8 @@ static int ll_layout_lock_set(struct lustre_handle *lockh, ldlm_mode_t mode,
        LASSERT(lock != NULL);
        LASSERT(ldlm_has_layout(lock));
 
-       LDLM_DEBUG(lock, "File %p/"DFID" being reconfigured: %d.\n",
-                  inode, PFID(&lli->lli_fid), reconf);
+       LDLM_DEBUG(lock, "file "DFID"(%p) being reconfigured: %d\n",
+                  PFID(&lli->lli_fid), inode, reconf);
 
        /* in case this is a caching lock and reinstate with new inode */
        md_set_lock_data(sbi->ll_md_exp, &lockh->cookie, inode, NULL);
@@ -3725,9 +3731,9 @@ out:
 
        /* wait for IO to complete if it's still being used. */
        if (wait_layout) {
-               CDEBUG(D_INODE, "%s: %p/"DFID" wait for layout reconf.\n",
-                       ll_get_fsname(inode->i_sb, NULL, 0),
-                       inode, PFID(&lli->lli_fid));
+               CDEBUG(D_INODE, "%s: "DFID"(%p) wait for layout reconf\n",
+                      ll_get_fsname(inode->i_sb, NULL, 0),
+                      PFID(&lli->lli_fid), inode);
 
                memset(&conf, 0, sizeof conf);
                conf.coc_opc = OBJECT_CONF_WAIT;
@@ -3736,8 +3742,9 @@ out:
                if (rc == 0)
                        rc = -EAGAIN;
 
-               CDEBUG(D_INODE, "file: "DFID" waiting layout return: %d.\n",
-                       PFID(&lli->lli_fid), rc);
+               CDEBUG(D_INODE, "%s file="DFID" waiting layout return: %d\n",
+                      ll_get_fsname(inode->i_sb, NULL, 0),
+                      PFID(&lli->lli_fid), rc);
        }
        RETURN(rc);
 }
@@ -3821,9 +3828,9 @@ again:
        it.it_op = IT_LAYOUT;
        lockh.cookie = 0ULL;
 
-       LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file %p/"DFID".\n",
-                       ll_get_fsname(inode->i_sb, NULL, 0), inode,
-                       PFID(&lli->lli_fid));
+       LDLM_DEBUG_NOLOCK("%s: requeue layout lock for file "DFID"(%p)\n",
+                         ll_get_fsname(inode->i_sb, NULL, 0),
+                         PFID(&lli->lli_fid), inode);
 
        rc = md_enqueue(sbi->ll_md_exp, &einfo, &it, op_data, &lockh,
                        NULL, 0, NULL, 0);

diff --git a/lustre/llite/llite_close.c b/lustre/llite/llite_close.c
index 6005f6f..c4cb158 100644 (file)
--- a/lustre/llite/llite_close.c
+++ b/lustre/llite/llite_close.c
@@ -95,16 +95,16 @@ void ll_queue_done_writing(struct inode *inode, unsigned long flags)
                 struct ll_close_queue *lcq = ll_i2sbi(inode)->ll_lcq;
 
                 if (lli->lli_flags & LLIF_MDS_SIZE_LOCK)
-                        CWARN("ino %lu/%u(flags %u) som valid it just after "
-                              "recovery\n",
-                              inode->i_ino, inode->i_generation,
-                              lli->lli_flags);
-                /* DONE_WRITING is allowed and inode has no dirty page. */
+                       CWARN("%s: file "DFID"(flags %u) Size-on-MDS valid, "
+                             "done writing allowed and no diry pages\n",
+                             ll_get_fsname(inode->i_sb, NULL, 0),
+                             PFID(ll_inode2fid(inode)), lli->lli_flags);
+               /* DONE_WRITING is allowed and inode has no dirty page. */
                spin_lock(&lcq->lcq_lock);
 
-                LASSERT(cfs_list_empty(&lli->lli_close_list));
-                CDEBUG(D_INODE, "adding inode %lu/%u to close list\n",
-                       inode->i_ino, inode->i_generation);
+               LASSERT(cfs_list_empty(&lli->lli_close_list));
+               CDEBUG(D_INODE, "adding inode "DFID" to close list\n",
+                      PFID(ll_inode2fid(inode)));
                 cfs_list_add_tail(&lli->lli_close_list, &lcq->lcq_head);
 
                /* Avoid a concurrent insertion into the close thread queue:
@@ -131,9 +131,10 @@ void ll_done_writing_attr(struct inode *inode, struct md_op_data *op_data)
         op_data->op_flags |= MF_SOM_CHANGE;
         /* Check if Size-on-MDS attributes are valid. */
         if (lli->lli_flags & LLIF_MDS_SIZE_LOCK)
-                CERROR("ino %lu/%u(flags %u) som valid it just after "
-                       "recovery\n", inode->i_ino, inode->i_generation,
-                       lli->lli_flags);
+               CERROR("%s: inode "DFID"(flags %u) MDS holds lock on "
+                      "Size-on-MDS attributes\n",
+                      ll_get_fsname(inode->i_sb, NULL, 0),
+                      PFID(ll_inode2fid(inode)), lli->lli_flags);
 
         if (!cl_local_size(inode)) {
                 /* Send Size-on-MDS Attributes if valid. */
@@ -229,9 +230,10 @@ int ll_som_update(struct inode *inode, struct md_op_data *op_data)
 
         LASSERT(op_data != NULL);
         if (lli->lli_flags & LLIF_MDS_SIZE_LOCK)
-                CERROR("ino %lu/%u(flags %u) som valid it just after "
-                       "recovery\n", inode->i_ino, inode->i_generation,
-                       lli->lli_flags);
+               CERROR("%s: inode "DFID"(flags %u) MDS holds lock on "
+                      "Size-on-MDS attributes\n",
+                      ll_get_fsname(inode->i_sb, NULL, 0),
+                      PFID(ll_inode2fid(inode)), lli->lli_flags);
 
         OBDO_ALLOC(oa);
         if (!oa) {
@@ -249,10 +251,11 @@ int ll_som_update(struct inode *inode, struct md_op_data *op_data)
                 if (rc) {
                         oa->o_valid = 0;
                        if (rc != -ENOENT)
-                                CERROR("inode_getattr failed (%d): unable to "
-                                       "send a Size-on-MDS attribute update "
-                                       "for inode %lu/%u\n", rc, inode->i_ino,
-                                       inode->i_generation);
+                               CERROR("%s: inode_getattr failed - unable to "
+                                      "send a Size-on-MDS attribute update "
+                                      "for inode "DFID": rc = %d\n",
+                                      ll_get_fsname(inode->i_sb, NULL, 0),
+                                      PFID(ll_inode2fid(inode)), rc);
                 } else {
                         CDEBUG(D_INODE, "Size-on-MDS update on "DFID"\n",
                                PFID(&lli->lli_fid));
@@ -315,8 +318,9 @@ static void ll_done_writing(struct inode *inode)
                  * OSTs and send setattr to back to MDS. */
                 rc = ll_som_update(inode, op_data);
         } else if (rc) {
-                CERROR("inode %lu mdc done_writing failed: rc = %d\n",
-                       inode->i_ino, rc);
+               CERROR("%s: inode "DFID" mdc done_writing failed: rc = %d\n",
+                      ll_get_fsname(inode->i_sb, NULL, 0),
+                      PFID(ll_inode2fid(inode)), rc);
         }
 out:
         ll_finish_md_op_data(op_data);
@@ -363,8 +367,8 @@ static int ll_close_thread(void *arg)
                         break;
 
                 inode = ll_info2i(lli);
-                CDEBUG(D_INFO, "done_writting for inode %lu/%u\n",
-                       inode->i_ino, inode->i_generation);
+               CDEBUG(D_INFO, "done_writting for inode "DFID"\n",
+                      PFID(ll_inode2fid(inode)));
                 ll_done_writing(inode);
                 iput(inode);
         }

diff --git a/lustre/llite/llite_internal.h b/lustre/llite/llite_internal.h
index 82d29f8..a0cfd37 100644 (file)
--- a/lustre/llite/llite_internal.h
+++ b/lustre/llite/llite_internal.h
@@ -1544,18 +1544,18 @@ static inline void ll_set_lock_data(struct obd_export *exp, struct inode *inode,
                 * case the dcache being cleared */
                if (it->d.lustre.it_remote_lock_mode) {
                        handle.cookie = it->d.lustre.it_remote_lock_handle;
-                       CDEBUG(D_DLMTRACE, "setting l_data to inode %p"
-                              "(%lu/%u) for remote lock "LPX64"\n", inode,
-                              inode->i_ino, inode->i_generation,
+                       CDEBUG(D_DLMTRACE, "setting l_data to inode "DFID
+                              "(%p) for remote lock "LPX64"\n",
+                              PFID(ll_inode2fid(inode)), inode,
                               handle.cookie);
                        md_set_lock_data(exp, &handle.cookie, inode, NULL);
                }
-               
+
                handle.cookie = it->d.lustre.it_lock_handle;
 
-               CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)"
-                      " for lock "LPX64"\n", inode, inode->i_ino,
-                      inode->i_generation, handle.cookie);
+               CDEBUG(D_DLMTRACE, "setting l_data to inode "DFID"(%p)"
+                      " for lock "LPX64"\n",
+                      PFID(ll_inode2fid(inode)), inode, handle.cookie);
 
                md_set_lock_data(exp, &handle.cookie, inode,
                                 &it->d.lustre.it_lock_bits);

diff --git a/lustre/llite/llite_lib.c b/lustre/llite/llite_lib.c
index 024c1df..9815b08 100644 (file)
--- a/lustre/llite/llite_lib.c
+++ b/lustre/llite/llite_lib.c
@@ -655,8 +655,10 @@ void ll_dump_inode(struct inode *inode)
        ll_d_hlist_for_each(tmp, &inode->i_dentry)
                dentry_count++;
 
-       CERROR("inode %p dump: dev=%s ino=%lu mode=%o count=%u, %d dentries\n",
-              inode, ll_i2mdexp(inode)->exp_obd->obd_name, inode->i_ino,
+       CERROR("%s: inode %p dump: dev=%s fid="DFID
+              " mode=%o count=%u, %d dentries\n",
+              ll_get_fsname(inode->i_sb, NULL, 0), inode,
+              ll_i2mdexp(inode)->exp_obd->obd_name, PFID(ll_inode2fid(inode)),
               inode->i_mode, atomic_read(&inode->i_count), dentry_count);
 }
 
@@ -1206,8 +1208,8 @@ void ll_clear_inode(struct inode *inode)
         struct ll_sb_info *sbi = ll_i2sbi(inode);
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n", inode->i_ino,
-               inode->i_generation, inode);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
+              PFID(ll_inode2fid(inode)), inode);
 
         if (S_ISDIR(inode->i_mode)) {
                 /* these should have been cleared in ll_file_release */
@@ -1357,8 +1359,9 @@ static int ll_setattr_done_writing(struct inode *inode,
                  * from OSTs and send setattr to back to MDS. */
                 rc = ll_som_update(inode, op_data);
         } else if (rc) {
-                CERROR("inode %lu mdc truncate failed: rc = %d\n",
-                       inode->i_ino, rc);
+               CERROR("%s: inode "DFID" mdc truncate failed: rc = %d\n",
+                      ll_i2sbi(inode)->ll_md_exp->exp_obd->obd_name,
+                      PFID(ll_inode2fid(inode)), rc);
         }
         RETURN(rc);
 }
@@ -1405,14 +1408,14 @@ int ll_setattr_raw(struct dentry *dentry, struct iattr *attr, bool hsm_import)
         struct md_op_data *op_data = NULL;
         struct md_open_data *mod = NULL;
        bool file_is_released = false;
-        int rc = 0, rc1 = 0;
-        ENTRY;
+       int rc = 0, rc1 = 0;
+       ENTRY;
 
-       CDEBUG(D_VFSTRACE, "%s: setattr inode %p/fid:"DFID" from %llu to %llu, "
-               "valid %x, hsm_import %d\n",
-               ll_get_fsname(inode->i_sb, NULL, 0), inode,
-               PFID(&lli->lli_fid), i_size_read(inode), attr->ia_size,
-               attr->ia_valid, hsm_import);
+       CDEBUG(D_VFSTRACE, "%s: setattr inode "DFID"(%p) from %llu to %llu, "
+              "valid %x, hsm_import %d\n",
+              ll_get_fsname(inode->i_sb, NULL, 0), PFID(&lli->lli_fid),
+              inode, i_size_read(inode), attr->ia_size, attr->ia_valid,
+              hsm_import);
 
        if (attr->ia_valid & ATTR_SIZE) {
                 /* Check new size against VFS/VM file size limit and rlimit */
@@ -1786,9 +1789,9 @@ void ll_update_inode(struct inode *inode, struct lustre_md *md)
                 if (fid_is_sane(&lli->lli_fid)) {
                         LASSERTF(lu_fid_eq(&lli->lli_fid, &body->fid1),
                                  "Trying to change FID "DFID
-                                 " to the "DFID", inode %lu/%u(%p)\n",
-                                 PFID(&lli->lli_fid), PFID(&body->fid1),
-                                 inode->i_ino, inode->i_generation, inode);
+                                " to the "DFID", inode "DFID"(%p)\n",
+                                PFID(&lli->lli_fid), PFID(&body->fid1),
+                                PFID(ll_inode2fid(inode)), inode);
                 } else
                         lli->lli_fid = body->fid1;
         }
@@ -1813,10 +1816,12 @@ void ll_update_inode(struct inode *inode, struct lustre_md *md)
                                 if (lli->lli_flags & (LLIF_DONE_WRITING |
                                                       LLIF_EPOCH_PENDING |
                                                       LLIF_SOM_DIRTY)) {
-                                        CERROR("ino %lu flags %u still has "
-                                               "size authority! do not trust "
-                                               "the size got from MDS\n",
-                                               inode->i_ino, lli->lli_flags);
+                                       CERROR("%s: inode "DFID" flags %u still"
+                                              " has size authority! do not "
+                                              "trust the size from MDS\n",
+                                              sbi->ll_md_exp->exp_obd->obd_name,
+                                              PFID(ll_inode2fid(inode)),
+                                              lli->lli_flags);
                                 } else {
                                         /* Use old size assignment to avoid
                                          * deadlock bz14138 & bz14326 */
@@ -1832,8 +1837,10 @@ void ll_update_inode(struct inode *inode, struct lustre_md *md)
                          * deadlock bz14138 & bz14326 */
                         i_size_write(inode, body->size);
 
-                        CDEBUG(D_VFSTRACE, "inode=%lu, updating i_size %llu\n",
-                               inode->i_ino, (unsigned long long)body->size);
+                       CDEBUG(D_VFSTRACE,
+                              "inode="DFID", updating i_size %llu\n",
+                              PFID(ll_inode2fid(inode)),
+                              (unsigned long long)body->size);
                 }
 
                 if (body->valid & OBD_MD_FLBLOCKS)
@@ -1923,9 +1930,9 @@ void ll_delete_inode(struct inode *inode)
                spin_lock_irq(&inode->i_data.tree_lock);
                spin_unlock_irq(&inode->i_data.tree_lock);
                 LASSERTF(inode->i_data.nrpages == 0,
-                         "inode=%lu/%u(%p) nrpages=%lu, see "
-                         "http://jira.whamcloud.com/browse/LU-118\n",
-                         inode->i_ino, inode->i_generation, inode,
+                        "inode="DFID"(%p) nrpages=%lu, see "
+                        "http://jira.whamcloud.com/browse/LU-118\n",
+                        PFID(ll_inode2fid(inode)), inode,
                          inode->i_data.nrpages);
         }
         /* Workaround end */
@@ -1961,7 +1968,9 @@ int ll_iocontrol(struct inode *inode, struct file *file,
                 rc = md_getattr(sbi->ll_md_exp, op_data, &req);
                 ll_finish_md_op_data(op_data);
                 if (rc) {
-                        CERROR("failure %d inode %lu\n", rc, inode->i_ino);
+                       CERROR("%s: failure inode "DFID": rc = %d\n",
+                              sbi->ll_md_exp->exp_obd->obd_name,
+                              PFID(ll_inode2fid(inode)), rc);
                         RETURN(-abs(rc));
                 }
 

diff --git a/lustre/llite/llite_mmap.c b/lustre/llite/llite_mmap.c
index eeeefdb..77ec4d5 100644 (file)
--- a/lustre/llite/llite_mmap.c
+++ b/lustre/llite/llite_mmap.c
@@ -395,10 +395,10 @@ static int ll_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
                 result = ll_page_mkwrite0(vma, vmf->page, &retry);
 
                 if (!printed && ++count > 16) {
-                        CWARN("app(%s): the page %lu of file %lu is under heavy"
-                              " contention.\n",
-                              current->comm, vmf->pgoff,
-                              vma->vm_file->f_dentry->d_inode->i_ino);
+                       CWARN("app(%s): the page %lu of file "DFID" is under"
+                             " heavy contention\n",
+                             current->comm, vmf->pgoff,
+                             PFID(ll_inode2fid(vma->vm_file->f_dentry->d_inode)));
                         printed = true;
                 }
         } while (retry);

diff --git a/lustre/llite/llite_nfs.c b/lustre/llite/llite_nfs.c
index 916c0fc..dbfdde0 100644 (file)
--- a/lustre/llite/llite_nfs.c
+++ b/lustre/llite/llite_nfs.c
@@ -188,9 +188,10 @@ static int ll_encode_fh(struct inode *inode, __u32 *fh, int *plen,
        struct lustre_nfs_fid *nfs_fid = (void *)fh;
        ENTRY;
 
-       CDEBUG(D_INFO, "encoding for (%lu,"DFID") maxlen=%d minlen=%d\n",
-             inode->i_ino, PFID(ll_inode2fid(inode)), *plen,
-             (int)sizeof(struct lustre_nfs_fid));
+       CDEBUG(D_INFO, "%s: encoding for ("DFID") maxlen=%d minlen=%d\n",
+              ll_get_fsname(inode->i_sb, NULL, 0),
+              PFID(ll_inode2fid(inode)), *plen,
+              (int)sizeof(struct lustre_nfs_fid));
 
        if (*plen < sizeof(struct lustre_nfs_fid) / 4)
                RETURN(255);
@@ -288,8 +289,9 @@ static struct dentry *ll_get_parent(struct dentry *dchild)
 
         sbi = ll_s2sbi(dir->i_sb);
 
-        CDEBUG(D_INFO, "getting parent for (%lu,"DFID")\n",
-                        dir->i_ino, PFID(ll_inode2fid(dir)));
+       CDEBUG(D_INFO, "%s: getting parent for ("DFID")\n",
+              ll_get_fsname(dir->i_sb, NULL, 0),
+              PFID(ll_inode2fid(dir)));
 
        rc = ll_get_max_mdsize(sbi, &lmmsize);
        if (rc != 0)
@@ -304,7 +306,9 @@ static struct dentry *ll_get_parent(struct dentry *dchild)
         rc = md_getattr_name(sbi->ll_md_exp, op_data, &req);
         ll_finish_md_op_data(op_data);
         if (rc) {
-                CERROR("failure %d inode %lu get parent\n", rc, dir->i_ino);
+               CERROR("%s: failure inode "DFID" get parent: rc = %d\n",
+                      ll_get_fsname(dir->i_sb, NULL, 0),
+                      PFID(ll_inode2fid(dir)), rc);
                 RETURN(ERR_PTR(rc));
         }
         body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);

diff --git a/lustre/llite/namei.c b/lustre/llite/namei.c
index 883c873..4c5dfe7 100644 (file)
--- a/lustre/llite/namei.c
+++ b/lustre/llite/namei.c
@@ -166,8 +166,8 @@ struct inode *ll_iget(struct super_block *sb, ino_t hash,
                                 unlock_new_inode(inode);
                 } else if (!(inode->i_state & (I_FREEING | I_CLEAR)))
                         ll_update_inode(inode, md);
-                CDEBUG(D_VFSTRACE, "got inode: %p for "DFID"\n",
-                       inode, PFID(&md->body->fid1));
+                       CDEBUG(D_VFSTRACE, "got inode: "DFID"(%p)\n",
+                              PFID(&md->body->fid1), inode);
         }
         RETURN(inode);
 }
@@ -258,9 +258,11 @@ int ll_md_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
                                 flags = FMODE_READ;
                                 break;
                         default:
-                                CERROR("Unexpected lock mode for OPEN lock "
-                                       "%d, inode %ld\n", lock->l_req_mode,
-                                       inode->i_ino);
+                               CERROR("%s: unexpected lock mode for OPEN lock"
+                                      " %d, inode "DFID"\n",
+                                      ll_get_fsname(inode->i_sb, NULL, 0),
+                                      lock->l_req_mode,
+                                      PFID(ll_inode2fid(inode)));
                         }
                         ll_md_real_close(inode, flags);
                 }
@@ -284,8 +286,8 @@ int ll_md_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
 
                 if (S_ISDIR(inode->i_mode) &&
                      (bits & MDS_INODELOCK_UPDATE)) {
-                        CDEBUG(D_INODE, "invalidating inode %lu\n",
-                               inode->i_ino);
+                       CDEBUG(D_INODE, "invalidating inode "DFID"\n",
+                              PFID(ll_inode2fid(inode)));
                         truncate_inode_pages(inode->i_mapping, 0);
                        ll_invalidate_negative_children(inode);
                }
@@ -514,9 +516,9 @@ static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
         if (dentry->d_name.len > ll_i2sbi(parent)->ll_namelen)
                 RETURN(ERR_PTR(-ENAMETOOLONG));
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
-               dentry->d_name.len, dentry->d_name.name, parent->i_ino,
-               parent->i_generation, parent, LL_IT2STR(it));
+       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));
 
         if (d_mountpoint(dentry))
                 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
@@ -588,9 +590,9 @@ static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
        struct lookup_intent *itp, it = { .it_op = IT_GETATTR };
        struct dentry *de;
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),flags=%u\n",
-              dentry->d_name.len, dentry->d_name.name, parent->i_ino,
-              parent->i_generation, parent, flags);
+       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);
 
        /* Optimize away (CREATE && !OPEN). Let .create handle the race. */
        if ((flags & LOOKUP_CREATE) && !(flags & LOOKUP_OPEN))
@@ -622,10 +624,10 @@ static int ll_atomic_open(struct inode *dir, struct dentry *dentry,
        int rc = 0;
        ENTRY;
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),file %p,"
-                          "open_flags %x,mode %x opened %d\n",
-              dentry->d_name.len, dentry->d_name.name, dir->i_ino,
-              dir->i_generation, dir, file, open_flags, mode, *opened);
+       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, *opened);
 
        OBD_ALLOC(it, sizeof(*it));
        if (!it)
@@ -810,8 +812,8 @@ static struct inode *ll_create_node(struct inode *dir, const char *name,
         /* We asked for a lock on the directory, but were granted a
          * lock on the inode.  Since we finally have an inode pointer,
          * stuff it in the lock. */
-        CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
-               inode, inode->i_ino, inode->i_generation);
+       CDEBUG(D_DLMTRACE, "setting l_ast_data to inode "DFID"(%p)\n",
+              PFID(ll_inode2fid(inode)), inode);
         ll_set_lock_data(sbi->ll_md_exp, inode, it, NULL);
         EXIT;
  out:
@@ -840,9 +842,9 @@ static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
        int rc = 0;
        ENTRY;
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
-              dentry->d_name.len, dentry->d_name.name, dir->i_ino,
-              dir->i_generation, dir, LL_IT2STR(it));
+       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));
 
        rc = it_open_error(DISP_OPEN_CREATE, it);
        if (rc)
@@ -869,8 +871,9 @@ static void ll_update_times(struct ptlrpc_request *request,
         LASSERT(body);
         if (body->valid & OBD_MD_FLMTIME &&
             body->mtime > LTIME_S(inode->i_mtime)) {
-                CDEBUG(D_INODE, "setting ino %lu mtime from %lu to "LPU64"\n",
-                       inode->i_ino, LTIME_S(inode->i_mtime), body->mtime);
+               CDEBUG(D_INODE, "setting fid "DFID" mtime from %lu to "LPU64
+                               "\n", PFID(ll_inode2fid(inode)),
+                               LTIME_S(inode->i_mtime), body->mtime);
                 LTIME_S(inode->i_mtime) = body->mtime;
         }
         if (body->valid & OBD_MD_FLCTIME &&
@@ -927,8 +930,8 @@ static int ll_mknod_generic(struct inode *dir, struct qstr *name, int mode,
         int err;
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p) mode %o dev %x\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir,
+       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);
 
        if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
@@ -967,10 +970,10 @@ static int ll_create_nd(struct inode *dir, struct dentry *dentry,
 {
        int rc;
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),"
-                          "flags=%u, excl=%d\n",
-              dentry->d_name.len, dentry->d_name.name, dir->i_ino,
-              dir->i_generation, dir, mode, want_excl);
+       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);
 
        rc = ll_mknod_generic(dir, &dentry->d_name, mode, 0, dentry);
 
@@ -1030,9 +1033,9 @@ static int ll_symlink_generic(struct inode *dir, struct qstr *name,
         int err;
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),target=%.*s\n",
-               name->len, name->name, dir->i_ino, dir->i_generation,
-               dir, 3000, tgt);
+       CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p), target=%.*s\n",
+              name->len, name->name, PFID(ll_inode2fid(dir)),
+              dir, 3000, tgt);
 
         err = ll_new_node(dir, name, (char *)tgt, S_IFLNK | S_IRWXUGO,
                           0, dchild, LUSTRE_OPC_SYMLINK);
@@ -1052,10 +1055,9 @@ static int ll_link_generic(struct inode *src,  struct inode *dir,
         int err;
 
         ENTRY;
-        CDEBUG(D_VFSTRACE,
-               "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n",
-               src->i_ino, src->i_generation, src, dir->i_ino,
-               dir->i_generation, dir, name->len, name->name);
+       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);
 
         op_data = ll_prep_md_op_data(NULL, src, dir, name->name, name->len,
                                      0, LUSTRE_OPC_ANY, NULL);
@@ -1082,8 +1084,8 @@ static int ll_mkdir_generic(struct inode *dir, struct qstr *name,
         int err;
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir);
+       CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n",
+              name->len, name->name, PFID(ll_inode2fid(dir)), dir);
 
        if (!IS_POSIXACL(dir) || !exp_connect_umask(ll_i2mdexp(dir)))
                mode &= ~current_umask();
@@ -1104,8 +1106,8 @@ static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent,
         int rc;
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir);
+       CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n",
+              name->len, name->name, PFID(ll_inode2fid(dir)), dir);
 
         if (unlikely(ll_d_mountpoint(dparent, dchild, name)))
                 RETURN(-EBUSY);
@@ -1139,8 +1141,8 @@ int ll_rmdir_entry(struct inode *dir, char *name, int namelen)
        int rc;
        ENTRY;
 
-       CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
-              namelen, name, dir->i_ino, dir->i_generation, dir);
+       CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n",
+              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);
@@ -1245,8 +1247,8 @@ static int ll_unlink_generic(struct inode *dir, struct dentry *dparent,
         struct md_op_data *op_data;
         int rc;
         ENTRY;
-        CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
-               name->len, name->name, dir->i_ino, dir->i_generation, dir);
+       CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s, dir="DFID"(%p)\n",
+              name->len, name->name, PFID(ll_inode2fid(dir)), dir);
 
         /*
          * XXX: unlink bind mountpoint maybe call to here,
@@ -1288,10 +1290,11 @@ static int ll_rename_generic(struct inode *src, struct dentry *src_dparent,
         struct md_op_data *op_data;
         int err;
         ENTRY;
-        CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s,"
-               "tgt_dir=%lu/%u(%p)\n", src_name->len, src_name->name,
-               src->i_ino, src->i_generation, src, tgt_name->len,
-               tgt_name->name, tgt->i_ino, tgt->i_generation, tgt);
+       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);
 
         if (unlikely(ll_d_mountpoint(src_dparent, src_dchild, src_name) ||
             ll_d_mountpoint(tgt_dparent, tgt_dchild, tgt_name)))

diff --git a/lustre/llite/rw26.c b/lustre/llite/rw26.c
index a90b9dd..b97edd0 100644 (file)
--- a/lustre/llite/rw26.c
+++ b/lustre/llite/rw26.c
@@ -397,9 +397,9 @@ static ssize_t ll_direct_IO_26(int rw, struct kiocb *iocb,
         if ((file_offset & ~CFS_PAGE_MASK) || (count & ~CFS_PAGE_MASK))
                 RETURN(-EINVAL);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), size=%lu (max %lu), "
-               "offset=%lld=%llx, pages %lu (max %lu)\n",
-               inode->i_ino, inode->i_generation, inode, count, MAX_DIO_SIZE,
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), size=%lu (max %lu), "
+              "offset=%lld=%llx, pages %lu (max %lu)\n",
+              PFID(ll_inode2fid(inode)), inode, count, MAX_DIO_SIZE,
               file_offset, file_offset, count >> PAGE_CACHE_SHIFT,
               MAX_DIO_SIZE >> PAGE_CACHE_SHIFT);
 

diff --git a/lustre/llite/statahead.c b/lustre/llite/statahead.c
index 183eda9..ca3faaa 100644 (file)
--- a/lustre/llite/statahead.c
+++ b/lustre/llite/statahead.c
@@ -681,8 +681,9 @@ static void ll_post_statahead(struct ll_statahead_info *sai)
         if (rc)
                 GOTO(out, rc);
 
-        CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
-               child, child->i_ino, child->i_generation);
+       CDEBUG(D_DLMTRACE, "%s: setting l_data to inode "DFID"(%p)\n",
+              ll_get_fsname(child->i_sb, NULL, 0),
+              PFID(ll_inode2fid(child)), child);
         ll_set_lock_data(ll_i2sbi(dir)->ll_md_exp, child, it, NULL);
 
         entry->se_inode = child;
@@ -1627,14 +1628,14 @@ int do_statahead_enter(struct inode *dir, struct dentry **dentryp,
                                 } else if ((*dentryp)->d_inode != inode) {
                                         /* revalidate, but inode is recreated */
                                         CDEBUG(D_READA,
-                                              "stale dentry %.*s inode %lu/%u, "
-                                              "statahead inode %lu/%u\n",
-                                              (*dentryp)->d_name.len,
-                                              (*dentryp)->d_name.name,
-                                              (*dentryp)->d_inode->i_ino,
-                                              (*dentryp)->d_inode->i_generation,
-                                              inode->i_ino,
-                                              inode->i_generation);
+                                              "%s: stale dentry %.*s inode "
+                                              DFID", statahead inode "DFID
+                                              "\n",
+                                              ll_get_fsname((*dentryp)->d_inode->i_sb, NULL, 0),
+                                              (*dentryp)->d_name.len,
+                                              (*dentryp)->d_name.name,
+                                              PFID(ll_inode2fid((*dentryp)->d_inode)),
+                                              PFID(ll_inode2fid(inode)));
                                         ll_sai_unplug(sai, entry);
                                         RETURN(-ESTALE);
                                 } else {

diff --git a/lustre/llite/symlink.c b/lustre/llite/symlink.c
index a2de898..6b43a05 100644 (file)
--- a/lustre/llite/symlink.c
+++ b/lustre/llite/symlink.c
@@ -78,7 +78,9 @@ static int ll_readlink_internal(struct inode *inode,
         ll_finish_md_op_data(op_data);
         if (rc) {
                 if (rc != -ENOENT)
-                        CERROR("inode %lu: rc = %d\n", inode->i_ino, rc);
+                       CERROR("%s: inode "DFID": rc = %d\n",
+                              ll_get_fsname(inode->i_sb, NULL, 0),
+                              PFID(ll_inode2fid(inode)), rc);
                 GOTO (failed, rc);
         }
 
@@ -91,8 +93,10 @@ static int ll_readlink_internal(struct inode *inode,
 
         LASSERT(symlen != 0);
         if (body->eadatasize != symlen) {
-                CERROR("inode %lu: symlink length %d not expected %d\n",
-                        inode->i_ino, body->eadatasize - 1, symlen - 1);
+               CERROR("%s: inode "DFID": symlink length %d not expected %d\n",
+                      ll_get_fsname(inode->i_sb, NULL, 0),
+                      PFID(ll_inode2fid(inode)), body->eadatasize - 1,
+                      symlen - 1);
                 GOTO(failed, rc = -EPROTO);
         }
 
@@ -100,8 +104,9 @@ static int ll_readlink_internal(struct inode *inode,
         if (*symname == NULL ||
             strnlen(*symname, symlen) != symlen - 1) {
                 /* not full/NULL terminated */
-                CERROR("inode %lu: symlink not NULL terminated string"
-                        "of length %d\n", inode->i_ino, symlen - 1);
+               CERROR("%s: inode "DFID": symlink not NULL terminated string"
+                      "of length %d\n", ll_get_fsname(inode->i_sb, NULL, 0),
+                      PFID(ll_inode2fid(inode)), symlen - 1);
                 GOTO(failed, rc = -EPROTO);
         }
 

diff --git a/lustre/llite/vvp_dev.c b/lustre/llite/vvp_dev.c
index 3aadb74..9e5d09d 100644 (file)
--- a/lustre/llite/vvp_dev.c
+++ b/lustre/llite/vvp_dev.c
@@ -407,19 +407,19 @@ static void vvp_pgcache_page_show(const struct lu_env *env,
        struct page      *vmpage;
        int              has_flags;
 
-        cpg = cl2ccc_page(cl_page_at(page, &vvp_device_type));
-        vmpage = cpg->cpg_page;
-        seq_printf(seq," %5i | %p %p %s %s %s %s | %p %lu/%u(%p) %lu %u [",
-                   0 /* gen */,
-                   cpg, page,
-                   "none",
-                   cpg->cpg_write_queued ? "wq" : "- ",
-                   cpg->cpg_defer_uptodate ? "du" : "- ",
-                   PageWriteback(vmpage) ? "wb" : "-",
-                   vmpage, vmpage->mapping->host->i_ino,
-                   vmpage->mapping->host->i_generation,
-                   vmpage->mapping->host, vmpage->index,
-                   page_count(vmpage));
+       cpg = cl2ccc_page(cl_page_at(page, &vvp_device_type));
+       vmpage = cpg->cpg_page;
+       seq_printf(seq, " %5i | %p %p %s %s %s %s | %p "DFID"(%p) %lu %u [",
+                  0 /* gen */,
+                  cpg, page,
+                  "none",
+                  cpg->cpg_write_queued ? "wq" : "- ",
+                  cpg->cpg_defer_uptodate ? "du" : "- ",
+                  PageWriteback(vmpage) ? "wb" : "-",
+                  vmpage,
+                  PFID(ll_inode2fid(vmpage->mapping->host)),
+                  vmpage->mapping->host, vmpage->index,
+                  page_count(vmpage));
         has_flags = 0;
         seq_page_flag(seq, vmpage, locked, has_flags);
         seq_page_flag(seq, vmpage, error, has_flags);

diff --git a/lustre/llite/xattr.c b/lustre/llite/xattr.c
index 56decef..3db8073 100644 (file)
--- a/lustre/llite/xattr.c
+++ b/lustre/llite/xattr.c
@@ -215,8 +215,8 @@ int ll_setxattr(struct dentry *dentry, const char *name,
         LASSERT(inode);
         LASSERT(name);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), xattr %s\n",
-               inode->i_ino, inode->i_generation, inode, name);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), xattr %s\n",
+              PFID(ll_inode2fid(inode)), inode, name);
 
         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_SETXATTR, 1);
 
@@ -267,8 +267,8 @@ int ll_removexattr(struct dentry *dentry, const char *name)
         LASSERT(inode);
         LASSERT(name);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), xattr %s\n",
-               inode->i_ino, inode->i_generation, inode, name);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), xattr %s\n",
+              PFID(ll_inode2fid(inode)), inode, name);
 
         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_REMOVEXATTR, 1);
         return ll_setxattr_common(inode, name, NULL, 0, 0,
@@ -289,8 +289,8 @@ int ll_getxattr_common(struct inode *inode, const char *name,
        struct ll_inode_info *lli = ll_i2info(inode);
         ENTRY;
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n",
-               inode->i_ino, inode->i_generation, inode);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
+              PFID(ll_inode2fid(inode)), inode);
 
         /* listxattr have slightly different behavior from of ext3:
          * without 'user_xattr' ext3 will list all xattr names but
@@ -448,8 +448,8 @@ ssize_t ll_getxattr(struct dentry *dentry, const char *name,
         LASSERT(inode);
         LASSERT(name);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), xattr %s\n",
-               inode->i_ino, inode->i_generation, inode, name);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p), xattr %s\n",
+              PFID(ll_inode2fid(inode)), inode, name);
 
         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_GETXATTR, 1);
 
@@ -537,8 +537,8 @@ ssize_t ll_listxattr(struct dentry *dentry, char *buffer, size_t size)
 
         LASSERT(inode);
 
-        CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p)\n",
-               inode->i_ino, inode->i_generation, inode);
+       CDEBUG(D_VFSTRACE, "VFS Op:inode="DFID"(%p)\n",
+              PFID(ll_inode2fid(inode)), inode);
 
         ll_stats_ops_tally(ll_i2sbi(inode), LPROC_LL_LISTXATTR, 1);