Clean up compiler warnings for 64-bit systems where __u64 is a long and

not a long long like on 32-bit systems.  From Evan Felix, PNL.

diff --git a/lustre/include/linux/lustre_dlm.h b/lustre/include/linux/lustre_dlm.h
index 0482b9c..910618f 100644 (file)
--- a/lustre/include/linux/lustre_dlm.h
+++ b/lustre/include/linux/lustre_dlm.h
@@ -217,7 +217,7 @@ do {                                                                    \
         if (lock->l_resource == NULL)                                   \
                 CDEBUG(D_DLMTRACE, "### " format                        \
                        " (UNKNOWN: lock %p(rc=%d/%d,%d) mode %s/%s on " \
-                       "res \?\? (rc=\?\?) type \?\?\? remote %Lx)\n" , \
+                       "res \?\? (rc=\?\?) type \?\?\? remote "LPX64")\n" , \
                        ## a, lock, lock->l_refc, lock->l_readers,       \
                        lock->l_writers,                                 \
                        ldlm_lockname[lock->l_granted_mode],             \
@@ -226,7 +226,7 @@ do {                                                                    \
         else                                                            \
                 CDEBUG(D_DLMTRACE, "### " format                        \
                        " (%s: lock %p(rc=%d/%d,%d) mode %s/%s on res "  \
-                       "%Lu (rc=%d) type %s remote %Lx)\n" , ## a,      \
+                       LPU64" (rc=%d) type %s remote "LPX64")\n" , ## a,      \
                        lock->l_resource->lr_namespace->ns_name, lock,   \
                        lock->l_refc, lock->l_readers, lock->l_writers,  \
                        ldlm_lockname[lock->l_granted_mode],             \

diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c
index 70a6c62..c1a05d1 100644 (file)
--- a/lustre/ldlm/ldlm_lock.c
+++ b/lustre/ldlm/ldlm_lock.c
@@ -854,13 +854,13 @@ void ldlm_lock_dump(struct ldlm_lock *lock)
 
         CDEBUG(D_OTHER, "  -- Lock dump: %p (%s)\n", lock, ver);
         if (lock->l_export && lock->l_export->exp_connection)
-                CDEBUG(D_OTHER, "  Node: NID %x (rhandle: %Lx)\n",
+                CDEBUG(D_OTHER, "  Node: NID %x (rhandle: "LPX64")\n",
                        lock->l_export->exp_connection->c_peer.peer_nid,
                        lock->l_remote_handle.addr);
         else
                 CDEBUG(D_OTHER, "  Node: local\n");
         CDEBUG(D_OTHER, "  Parent: %p\n", lock->l_parent);
-        CDEBUG(D_OTHER, "  Resource: %p (%Ld)\n", lock->l_resource,
+        CDEBUG(D_OTHER, "  Resource: %p ("LPD64")\n", lock->l_resource,
                lock->l_resource->lr_name[0]);
         CDEBUG(D_OTHER, "  Requested mode: %d, granted mode: %d\n",
                (int)lock->l_req_mode, (int)lock->l_granted_mode);

diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c
index 04437a5..67f73c7 100644 (file)
--- a/lustre/ldlm/ldlm_lockd.c
+++ b/lustre/ldlm/ldlm_lockd.c
@@ -372,7 +372,7 @@ static int ldlm_handle_bl_callback(struct ptlrpc_request *req)
 
         lock = ldlm_handle2lock(&dlm_req->lock_handle1);
         if (!lock) {
-                CERROR("blocking callback on lock %Lx - lock disappeared\n",
+                CERROR("blocking callback on lock "LPX64" - lock disappeared\n",
                        dlm_req->lock_handle1.addr);
                 RETURN(0);
         }
@@ -419,7 +419,7 @@ static int ldlm_handle_cp_callback(struct ptlrpc_request *req)
 
         lock = ldlm_handle2lock(&dlm_req->lock_handle1);
         if (!lock) {
-                CERROR("completion callback on lock %Lx - lock disappeared\n",
+                CERROR("completion callback on lock "LPX64" - lock disappeared\n",
                        dlm_req->lock_handle1.addr);
                 RETURN(0);
         }

diff --git a/lustre/lib/simple.c b/lustre/lib/simple.c
index cda15b3..232f164 100644 (file)
--- a/lustre/lib/simple.c
+++ b/lustre/lib/simple.c
@@ -85,7 +85,7 @@ struct dentry *simple_mkdir(struct dentry *dir, char *name, int mode)
         ENTRY;
 
         ASSERT_KERNEL_CTXT("kernel doing mkdir outside kernel context\n");
-        CDEBUG(D_INODE, "creating directory %*s\n", strlen(name), name);
+        CDEBUG(D_INODE, "creating directory %*s\n", (int)strlen(name), name);
         down(&dir->d_inode->i_sem);
         dchild = lookup_one_len(name, dir, strlen(name));
         if (IS_ERR(dchild))

diff --git a/lustre/llite/file.c b/lustre/llite/file.c
index 359b592..5be84a6 100644 (file)
--- a/lustre/llite/file.c
+++ b/lustre/llite/file.c
@@ -361,7 +361,7 @@ static ssize_t ll_file_read(struct file *filp, char *buf, size_t count,
 
                 extent.start = *ppos;
                 extent.end = *ppos + count;
-                CDEBUG(D_INFO, "Locking inode %ld, start %Lu end %Lu\n",
+                CDEBUG(D_INFO, "Locking inode %ld, start "LPU64" end "LPU64"\n",
                        inode->i_ino, extent.start, extent.end);
 
                 err = obd_enqueue(&sbi->ll_osc_conn, md, NULL, LDLM_EXTENT,
@@ -436,7 +436,7 @@ ll_file_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
                         GOTO(out_eof, retval = -ENOMEM);
                 extent.start = *ppos;
                 extent.end = *ppos + count;
-                CDEBUG(D_INFO, "Locking inode %ld, start %Lu end %Lu\n",
+                CDEBUG(D_INFO, "Locking inode %ld, start "LPU64" end "LPU64"\n",
                        inode->i_ino, extent.start, extent.end);
 
                 err = obd_enqueue(&sbi->ll_osc_conn, md, NULL, LDLM_EXTENT,

diff --git a/lustre/llite/super.c b/lustre/llite/super.c
index 811b77d..3d61b44 100644 (file)
--- a/lustre/llite/super.c
+++ b/lustre/llite/super.c
@@ -283,7 +283,7 @@ static void ll_delete_inode(struct inode *inode)
 
                 err = obd_destroy(ll_i2obdconn(inode), oa, md);
                 obdo_free(oa);
-                CDEBUG(D_SUPER, "obd destroy of %Ld error %d\n",
+                CDEBUG(D_SUPER, "obd destroy of "LPD64" error %d\n",
                        md->lmd_object_id, err);
         }
 out:

diff --git a/lustre/lov/lov_obd.c b/lustre/lov/lov_obd.c
index f6e9949..77fecc1 100644 (file)
--- a/lustre/lov/lov_obd.c
+++ b/lustre/lov/lov_obd.c
@@ -302,7 +302,7 @@ static int lov_destroy(struct lustre_handle *conn, struct obdo *oa,
                 tmp.o_id = md->lmd_oinfo[i].loi_id;
                 rc = obd_destroy(&lov->tgts[i].conn, &tmp, NULL);
                 if (rc)
-                        CERROR("Error destroying object %Ld on %d\n",
+                        CERROR("Error destroying object "LPD64"on %d\n",
                                md->lmd_oinfo[i].loi_id, i);
         }
         RETURN(rc);
@@ -341,7 +341,7 @@ static int lov_getattr(struct lustre_handle *conn, struct obdo *oa,
 
                 err = obd_getattr(&lov->tgts[i].conn, &tmp, NULL);
                 if (err) {
-                        CERROR("Error getattr object %Ld on %d: err = %d\n",
+                        CERROR("Error getattr object "LPD64" on %d: err = %d\n",
                                md->lmd_oinfo[i].loi_id, i, err);
                         if (!rc)
                                 rc = err;
@@ -391,7 +391,7 @@ static int lov_setattr(struct lustre_handle *conn, struct obdo *oa,
 
                 rc = obd_setattr(&lov->tgts[i].conn, &tmp, NULL);
                 if (rc)
-                        CERROR("Error setattr object %Ld on %d\n",
+                        CERROR("Error setattr object "LPD64" on %d\n",
                                tmp.o_id, i);
         }
         RETURN(rc);
@@ -423,7 +423,7 @@ static int lov_open(struct lustre_handle *conn, struct obdo *oa,
                 rc = obd_open(&lov->tgts[i].conn, &tmp, NULL);
                 if (rc) {
                         rc2 = rc;
-                        CERROR("Error open object %Ld on %d\n",
+                        CERROR("Error open object "LPD64" on %d\n",
                                md->lmd_oinfo[i].loi_id, i);
                 }
         }
@@ -455,7 +455,7 @@ static int lov_close(struct lustre_handle *conn, struct obdo *oa,
 
                 rc = obd_close(&lov->tgts[i].conn, &tmp, NULL);
                 if (rc)
-                        CERROR("Error close object %Ld on %d\n",
+                        CERROR("Error close object "LPD64" on %d\n",
                                md->lmd_oinfo[i].loi_id, i);
         }
         RETURN(rc);
@@ -545,7 +545,7 @@ static int lov_punch(struct lustre_handle *conn, struct obdo *oa,
                 rc = obd_punch(&lov->tgts[i].conn, &tmp, NULL,
                                starti, endi);
                 if (rc)
-                        CERROR("Error punch object %Ld on %d\n",
+                        CERROR("Error punch object "LPD64" on %d\n",
                                md->lmd_oinfo[i].loi_id, i);
         }
         RETURN(rc);
@@ -699,7 +699,8 @@ static int lov_enqueue(struct lustre_handle *conn, struct lov_stripe_md *md,
                                  flags, cb, data, datalen, &(lockhs[i]));
                 // XXX add a lock debug statement here
                 if (rc)
-                        CERROR("Error obd_enqueue object %Ld subobj %Ld\n",
+                        CERROR("Error obd_enqueue object "LPD64
+                               " subobj "LPD64"\n",
                                md->lmd_object_id, md->lmd_oinfo[i].loi_id);
         }
         RETURN(rc);
@@ -732,7 +733,7 @@ static int lov_cancel(struct lustre_handle *conn, struct lov_stripe_md *md,
                 submd.lmd_easize = sizeof(struct lov_mds_md);
                 rc = obd_cancel(&lov->tgts[i].conn, &submd, mode, &lockhs[i]);
                 if (rc)
-                        CERROR("Error cancel object %Ld subobj %Ld\n",
+                        CERROR("Error cancel object "LPD64" subobj "LPD64"\n",
                                md->lmd_object_id, md->lmd_oinfo[i].loi_id);
         }
         RETURN(rc);

diff --git a/lustre/mds/handler.c b/lustre/mds/handler.c
index f54b3c6..49e4344 100644 (file)
--- a/lustre/mds/handler.c
+++ b/lustre/mds/handler.c
@@ -526,7 +526,7 @@ static int mds_getattr_name(int offset, struct ptlrpc_request *req)
         rc = ldlm_lock_match(obd->obd_namespace, res_id, LDLM_PLAIN,
                              NULL, 0, lock_mode, &lockh);
         if (rc == 0) {
-                LDLM_DEBUG_NOLOCK("enqueue res %Lu", res_id[0]);
+                LDLM_DEBUG_NOLOCK("enqueue res "LPU64, res_id[0]);
                 rc = ldlm_cli_enqueue(NULL, NULL, obd->obd_namespace, NULL,
                                       res_id, LDLM_PLAIN, NULL, 0, lock_mode,
                                       &flags, ldlm_completion_ast,
@@ -667,7 +667,7 @@ static int mds_open(struct ptlrpc_request *req)
                 fd = list_entry(tmp, struct mds_file_data, mfd_list);
                 if (body->extra == fd->mfd_clientfd &&
                     body->fid1.id == fd->mfd_file->f_dentry->d_inode->i_ino) {
-                        CERROR("Re opening %Ld\n", body->fid1.id);
+                        CERROR("Re opening "LPD64"\n", body->fid1.id);
                         RETURN(0);
                 }
         }

diff --git a/lustre/mds/mds_extN.c b/lustre/mds/mds_extN.c
index 42b838e..39cc9b4 100644 (file)
--- a/lustre/mds/mds_extN.c
+++ b/lustre/mds/mds_extN.c
@@ -224,7 +224,7 @@ static void mds_extN_callback_status(void *jcb, int error)
 {
         struct mds_cb_data *mcb = (struct mds_cb_data *)jcb;
 
-        CDEBUG(D_EXT2, "got callback for last_rcvd %Ld: rc = %d\n",
+        CDEBUG(D_EXT2, "got callback for last_rcvd "LPD64": rc = %d\n",
                mcb->cb_last_rcvd, error);
         if (!error && mcb->cb_last_rcvd > mcb->cb_mds->mds_last_committed)
                 mcb->cb_mds->mds_last_committed = mcb->cb_last_rcvd;

diff --git a/lustre/mds/mds_reint.c b/lustre/mds/mds_reint.c
index 1808b67..5272f91 100644 (file)
--- a/lustre/mds/mds_reint.c
+++ b/lustre/mds/mds_reint.c
@@ -61,7 +61,7 @@ int mds_update_last_rcvd(struct mds_obd *mds, void *handle,
 
         mds_fs_set_last_rcvd(mds, handle);
         rc = lustre_fwrite(mds->mds_rcvd_filp, (char *)mcd, sizeof(*mcd), &off);
-        CDEBUG(D_INODE, "wrote trans #%Ld for client '%s' at #%d: rc = %d\n",
+        CDEBUG(D_INODE, "wrote trans #"LPD64" for client '%s' at #%d: rc = %d\n",
                last_rcvd, mcd->mcd_uuid, med->med_off, rc);
 
         if (rc == sizeof(*mcd))
@@ -610,7 +610,7 @@ static int mds_reint_rename(struct mds_update_record *rec, int offset,
         rc = ldlm_lock_match(obd->obd_namespace, res_id, LDLM_PLAIN,
                              NULL, 0, lock_mode, &srclockh);
         if (rc == 0) {
-                LDLM_DEBUG_NOLOCK("enqueue res %Lu", res_id[0]);
+                LDLM_DEBUG_NOLOCK("enqueue res "LPU64, res_id[0]);
                 rc = ldlm_cli_enqueue(NULL, NULL, obd->obd_namespace, NULL,
                                       res_id, LDLM_PLAIN, NULL, 0, lock_mode,
                                       &flags, ldlm_completion_ast,
@@ -632,7 +632,7 @@ static int mds_reint_rename(struct mds_update_record *rec, int offset,
         rc = ldlm_lock_match(obd->obd_namespace, res_id, LDLM_PLAIN,
                              NULL, 0, lock_mode, &tgtlockh);
         if (rc == 0) {
-                LDLM_DEBUG_NOLOCK("enqueue res %Lu", res_id[0]);
+                LDLM_DEBUG_NOLOCK("enqueue res "LPU64, res_id[0]);
                 rc = ldlm_cli_enqueue(NULL, NULL, obd->obd_namespace, NULL,
                                       res_id, LDLM_PLAIN, NULL, 0, lock_mode,
                                       &flags, ldlm_completion_ast,
@@ -714,13 +714,13 @@ static int mds_reint_rename(struct mds_update_record *rec, int offset,
                 /* Take an exclusive lock on the resource that we're
                  * about to free, to force everyone to drop their
                  * locks. */
-                LDLM_DEBUG_NOLOCK("getting EX lock res %Lu", res_id[0]);
+                LDLM_DEBUG_NOLOCK("getting EX lock res "LPU64, res_id[0]);
                 rc = ldlm_cli_enqueue(NULL, NULL, obd->obd_namespace, NULL,
                                       res_id, LDLM_PLAIN, NULL, 0, LCK_EX,
                                       &flags, ldlm_completion_ast,
                                       mds_blocking_ast, NULL, 0, &oldhandle);
                 if (rc)
-                        CERROR("failed to get child inode lock (child ino %Ld, "
+                        CERROR("failed to get child inode lock (child ino "LPD64", "
                                "dir ino %ld)\n",
                                res_id[0], de_old->d_inode->i_ino);
         }
@@ -732,7 +732,7 @@ static int mds_reint_rename(struct mds_update_record *rec, int offset,
                 rc = ldlm_cli_cancel(&oldhandle);
                 if (rc < 0)
                         CERROR("failed to cancel child inode lock ino "
-                               "%Ld: %d\n", res_id[0], rc);
+                               LPD64": %d\n", res_id[0], rc);
         }
 out_rename_tgtdir:
         double_up(&de_srcdir->d_inode->i_sem, &de_tgtdir->d_inode->i_sem);

diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c
index d5492fc..c68e44d 100644 (file)
--- a/lustre/obdclass/class_obd.c
+++ b/lustre/obdclass/class_obd.c
@@ -734,7 +734,7 @@ static int obd_class_ioctl (struct inode * inode, struct file * filp,
 
                 err = obd_connect(&conn, obd, cluuid);
 
-                CDEBUG(D_IOCTL, "assigned export %Lx\n", conn.addr);
+                CDEBUG(D_IOCTL, "assigned export "LPX64"\n", conn.addr);
                 obd_conn2data(data, &conn);
                 if (err)
                         GOTO(out, err);

diff --git a/lustre/obdclass/debug.c b/lustre/obdclass/debug.c
index 18ade8b..636ee20 100644 (file)
--- a/lustre/obdclass/debug.c
+++ b/lustre/obdclass/debug.c
@@ -19,14 +19,14 @@
 
 int dump_ioo(struct obd_ioobj *ioo)
 {
-        CERROR("obd_ioobj: ioo_id=%Ld, ioo_gr=%Ld, ioo_type=%d, ioo_bufct=%d\n",
+        CERROR("obd_ioobj: ioo_id="LPD64", ioo_gr="LPD64", ioo_type=%d, ioo_bufct=%d\n",
                ioo->ioo_id, ioo->ioo_gr, ioo->ioo_type, ioo->ioo_bufcnt);
         return -EINVAL;
 }
 
 int dump_lniobuf(struct niobuf_local *nb)
 {
-        CERROR("niobuf_local: addr=%p, offset=%Ld, len=%d, xid=%d, page=%p\n",
+        CERROR("niobuf_local: addr=%p, offset="LPD64", len=%d, xid=%d, page=%p\n",
                nb->addr, nb->offset, nb->len, nb->xid, nb->page);
         CERROR("nb->page: index = %ld\n", nb->page ? nb->page->index : -1);
 
@@ -35,7 +35,7 @@ int dump_lniobuf(struct niobuf_local *nb)
 
 int dump_rniobuf(struct niobuf_remote *nb)
 {
-        CERROR("niobuf_remote: offset=%Ld, len=%d, flags=%x, xid=%d\n",
+        CERROR("niobuf_remote: offset="LPD64", len=%d, flags=%x, xid=%d\n",
                nb->offset, nb->len, nb->flags, nb->xid);
 
         return -EINVAL;
@@ -45,17 +45,17 @@ int dump_obdo(struct obdo *oa)
 {
         CERROR("obdo: o_valid = %08x\n", oa->o_valid);
         if (oa->o_valid & OBD_MD_FLID)
-                CERROR("obdo: o_id = %Ld\n", oa->o_id);
+                CERROR("obdo: o_id = "LPD64"\n", oa->o_id);
         if (oa->o_valid & OBD_MD_FLATIME)
-                CERROR("obdo: o_atime = %Ld\n", oa->o_atime);
+                CERROR("obdo: o_atime = "LPD64"\n", oa->o_atime);
         if (oa->o_valid & OBD_MD_FLMTIME)
-                CERROR("obdo: o_mtime = %Ld\n", oa->o_mtime);
+                CERROR("obdo: o_mtime = "LPD64"\n", oa->o_mtime);
         if (oa->o_valid & OBD_MD_FLCTIME)
-                CERROR("obdo: o_ctime = %Ld\n", oa->o_ctime);
+                CERROR("obdo: o_ctime = "LPD64"\n", oa->o_ctime);
         if (oa->o_valid & OBD_MD_FLSIZE)
-                CERROR("obdo: o_size = %Ld\n", oa->o_size);
+                CERROR("obdo: o_size = "LPD64"\n", oa->o_size);
         if (oa->o_valid & OBD_MD_FLBLOCKS)   /* allocation of space */
-                CERROR("obdo: o_blocks = %Ld\n", oa->o_blocks);
+                CERROR("obdo: o_blocks = "LPD64"\n", oa->o_blocks);
         if (oa->o_valid & OBD_MD_FLBLKSZ)
                 CERROR("obdo: o_blksize = %d\n", oa->o_blksize);
         if (oa->o_valid & OBD_MD_FLMODE)

diff --git a/lustre/obdclass/genops.c b/lustre/obdclass/genops.c
index adb16f2..a2741f2 100644 (file)
--- a/lustre/obdclass/genops.c
+++ b/lustre/obdclass/genops.c
@@ -322,7 +322,7 @@ struct obd_export *class_conn2export(struct lustre_handle *conn)
                 RETURN(NULL);
         }
 
-        CDEBUG(D_IOCTL, "looking for export addr %Lx cookie %Lx\n",
+        CDEBUG(D_IOCTL, "looking for export addr "LPX64" cookie "LPX64"\n",
                conn->addr, conn->cookie);
         export = (struct obd_export *) (unsigned long)conn->addr;
         if (!kmem_cache_validate(export_cachep, (void *)export))
@@ -445,7 +445,7 @@ int class_disconnect(struct lustre_handle *conn)
         if (!(export = class_conn2export(conn))) {
                 fixme();
                 CDEBUG(D_IOCTL, "disconnect: attempting to free "
-                       "nonexistent client %Lx\n", conn->addr);
+                       "nonexistent client "LPX64"\n", conn->addr);
                 RETURN(-EINVAL);
         }
 

diff --git a/lustre/obdfilter/filter.c b/lustre/obdfilter/filter.c
index 7347368..cd7b328 100644 (file)
--- a/lustre/obdfilter/filter.c
+++ b/lustre/obdfilter/filter.c
@@ -487,7 +487,7 @@ static int filter_getattr(struct lustre_handle *conn, struct obdo *oa,
         ENTRY;
 
         if (!class_conn2export(conn)) {
-                CDEBUG(D_IOCTL, "fatal: invalid client %Lx\n", conn->addr);
+                CDEBUG(D_IOCTL, "fatal: invalid client "LPX64"\n", conn->addr);
                 RETURN(-EINVAL);
         }
 
@@ -558,7 +558,7 @@ static int filter_open(struct lustre_handle *conn, struct obdo *oa,
 
         export = class_conn2export(conn);
         if (!export) {
-                CDEBUG(D_IOCTL, "fatal: invalid client %Lx\n", conn->addr);
+                CDEBUG(D_IOCTL, "fatal: invalid client "LPX64"\n", conn->addr);
                 RETURN(-EINVAL);
         }
 
@@ -583,7 +583,7 @@ static int filter_close(struct lustre_handle *conn, struct obdo *oa,
 
         obd = class_conn2obd(conn);
         if (!obd) {
-                CDEBUG(D_IOCTL, "fatal: invalid client %Lx\n", conn->addr);
+                CDEBUG(D_IOCTL, "fatal: invalid client "LPX64"\n", conn->addr);
                 RETURN(-EINVAL);
         }
 
@@ -610,7 +610,7 @@ static int filter_create(struct lustre_handle* conn, struct obdo *oa,
         ENTRY;
 
         if (!obd) {
-                CERROR("invalid client %Lx\n", conn->addr);
+                CERROR("invalid client "LPX64"\n", conn->addr);
                 return -EINVAL;
         }
 
@@ -653,11 +653,11 @@ static int filter_destroy(struct lustre_handle *conn, struct obdo *oa,
 
         obd = class_conn2obd(conn);
         if (!obd) {
-                CERROR("invalid client %Lx\n", conn->addr);
+                CERROR("invalid client "LPX64"\n", conn->addr);
                 RETURN(-EINVAL);
         }
 
-        CDEBUG(D_INODE, "destroying object %Ld\n", oa->o_id);
+        CDEBUG(D_INODE, "destroying object "LPD64"\n", oa->o_id);
 
         dir_dentry = filter_parent(obd, oa->o_mode);
         down(&dir_dentry->d_inode->i_sem);
@@ -669,7 +669,7 @@ static int filter_destroy(struct lustre_handle *conn, struct obdo *oa,
 
         inode = object_dentry->d_inode;
         if (inode == NULL) {
-                CERROR("trying to destroy negative inode %Ld!\n", oa->o_id);
+                CERROR("trying to destroy negative inode "LPD64"!\n", oa->o_id);
                 GOTO(out, rc = -ENOENT);
         }
 
@@ -704,8 +704,8 @@ static int filter_truncate(struct lustre_handle *conn, struct obdo *oa,
         if (end != 0xffffffffffffffff)
                 CERROR("PUNCH not supported, only truncate works\n");
 
-        CDEBUG(D_INODE, "calling truncate for object #%Ld, valid = %x, "
-               "o_size = %Ld\n", oa->o_id, oa->o_valid, start);
+        CDEBUG(D_INODE, "calling truncate for object #"LPD64", valid = %x, "
+               "o_size = "LPD64"\n", oa->o_id, oa->o_valid, start);
         oa->o_size = start;
         error = filter_setattr(conn, oa, NULL);
         RETURN(error);
@@ -727,7 +727,7 @@ static int filter_pgcache_brw(int cmd, struct lustre_handle *conn,
         ENTRY;
 
         if (!obd) {
-                CDEBUG(D_IOCTL, "invalid client %Lx\n", conn->addr);
+                CDEBUG(D_IOCTL, "invalid client "LPX64"\n", conn->addr);
                 RETURN(-EINVAL);
         }
 

diff --git a/lustre/ptlrpc/client.c b/lustre/ptlrpc/client.c
index b348e2a..0286e8b 100644 (file)
--- a/lustre/ptlrpc/client.c
+++ b/lustre/ptlrpc/client.c
@@ -315,7 +315,7 @@ restart:
                 req = list_entry(tmp, struct ptlrpc_request, rq_list);
 
                 if (req->rq_flags & PTL_RPC_FL_REPLAY) {
-                        CDEBUG(D_INFO, "Keeping req %p xid %Ld for replay\n",
+                        CDEBUG(D_INFO, "Keeping req %p xid "LPD64" for replay\n",
                                req, req->rq_xid);
                         continue;
                 }
@@ -393,7 +393,7 @@ restart2:
 void ptlrpc_continue_req(struct ptlrpc_request *req)
 {
         ENTRY;
-        CDEBUG(D_INODE, "continue delayed request %Ld opc %d\n", 
+        CDEBUG(D_INODE, "continue delayed request "LPD64" opc %d\n", 
                req->rq_xid, req->rq_reqmsg->opc); 
         wake_up(&req->rq_wait_for_rep); 
         EXIT;
@@ -402,7 +402,7 @@ void ptlrpc_continue_req(struct ptlrpc_request *req)
 void ptlrpc_resend_req(struct ptlrpc_request *req)
 {
         ENTRY;
-        CDEBUG(D_INODE, "resend request %Ld, opc %d\n", 
+        CDEBUG(D_INODE, "resend request "LPD64", opc %d\n", 
                req->rq_xid, req->rq_reqmsg->opc);
         req->rq_reqmsg->addr = req->rq_import->imp_handle.addr;
         req->rq_reqmsg->cookie = req->rq_import->imp_handle.cookie;
@@ -417,7 +417,7 @@ void ptlrpc_resend_req(struct ptlrpc_request *req)
 void ptlrpc_restart_req(struct ptlrpc_request *req)
 {
         ENTRY;
-        CDEBUG(D_INODE, "restart completed request %Ld, opc %d\n", 
+        CDEBUG(D_INODE, "restart completed request "LPD64", opc %d\n", 
                req->rq_xid, req->rq_reqmsg->opc);
         req->rq_status = -ERESTARTSYS;
         req->rq_flags |= PTL_RPC_FL_RECOVERY;
@@ -464,7 +464,7 @@ int ptlrpc_queue_wait(struct ptlrpc_request *req)
         ENTRY;
 
         init_waitqueue_head(&req->rq_wait_for_rep);
-        CDEBUG(D_NET, "subsys: %s req %Ld opc %d level %d, conn level %d\n",
+        CDEBUG(D_NET, "subsys: %s req "LPD64" opc %d level %d, conn level %d\n",
                cli->cli_name, req->rq_xid, req->rq_reqmsg->opc, req->rq_level,
                req->rq_connection->c_level);
 
@@ -561,7 +561,7 @@ int ptlrpc_queue_wait(struct ptlrpc_request *req)
                 GOTO(out, rc = -EINVAL);
         }
 #endif
-        CDEBUG(D_NET, "got rep %Ld\n", req->rq_xid);
+        CDEBUG(D_NET, "got rep "LPD64"\n", req->rq_xid);
         if (req->rq_repmsg->status == 0)
                 CDEBUG(D_NET, "--> buf %p len %d status %d\n", req->rq_repmsg,
                        req->rq_replen, req->rq_repmsg->status);
@@ -585,7 +585,7 @@ int ptlrpc_replay_req(struct ptlrpc_request *req)
         ENTRY;
 
         init_waitqueue_head(&req->rq_wait_for_rep);
-        CDEBUG(D_NET, "req %Ld opc %d level %d, conn level %d\n",
+        CDEBUG(D_NET, "req "LPD64" opc %d level %d, conn level %d\n",
                req->rq_xid, req->rq_reqmsg->opc, req->rq_level,
                req->rq_connection->c_level);
 
@@ -621,13 +621,13 @@ int ptlrpc_replay_req(struct ptlrpc_request *req)
                 GOTO(out, rc);
         }
 
-        CDEBUG(D_NET, "got rep %Ld\n", req->rq_xid);
+        CDEBUG(D_NET, "got rep "LPD64"\n", req->rq_xid);
         if (req->rq_repmsg->status == 0)
                 CDEBUG(D_NET, "--> buf %p len %d status %d\n", req->rq_repmsg,
                        req->rq_replen, req->rq_repmsg->status);
         else {
                 CERROR("recovery failed: "); 
-                CERROR("req %Ld opc %d level %d, conn level %d\n", 
+                CERROR("req "LPD64" opc %d level %d, conn level %d\n", 
                        req->rq_xid, req->rq_reqmsg->opc, req->rq_level,
                        req->rq_connection->c_level);
                 LBUG();

diff --git a/lustre/ptlrpc/niobuf.c b/lustre/ptlrpc/niobuf.c
index 8606f01..b6e6ce5 100644 (file)
--- a/lustre/ptlrpc/niobuf.c
+++ b/lustre/ptlrpc/niobuf.c
@@ -25,6 +25,7 @@
 #include <linux/obd_support.h>
 #include <linux/lustre_net.h>
 #include <linux/lustre_lib.h>
+#include <linux/obd.h>
 
 extern ptl_handle_eq_t request_out_eq, reply_in_eq, reply_out_eq,
         bulk_source_eq, bulk_sink_eq;
@@ -69,7 +70,7 @@ static int ptl_send_buf(struct ptlrpc_request *request,
         remote_id.nid = conn->c_peer.peer_nid;
         remote_id.pid = 0;
 
-        CDEBUG(D_NET, "Sending %d bytes to portal %d, xid %Ld\n",
+        CDEBUG(D_NET, "Sending %d bytes to portal %d, xid "LPD64"\n",
                request->rq_req_md.length, portal, request->rq_xid);
 
         if (!portal)
@@ -77,7 +78,7 @@ static int ptl_send_buf(struct ptlrpc_request *request,
         rc = PtlPut(md_h, PTL_NOACK_REQ, remote_id, portal, 0, request->rq_xid,
                     0, 0);
         if (rc != PTL_OK) {
-                CERROR("PtlPut(%Lu, %d, %Ld) failed: %d\n", remote_id.nid,
+                CERROR("PtlPut("LPU64", %d, "LPD64") failed: %d\n", remote_id.nid,
                        portal, request->rq_xid, rc);
                 PtlMDUnlink(md_h);
         }
@@ -165,14 +166,14 @@ int ptlrpc_send_bulk(struct ptlrpc_bulk_desc *desc)
         remote_id.nid = desc->bd_connection->c_peer.peer_nid;
         remote_id.pid = 0;
 
-        CDEBUG(D_NET, "Sending %u pages %u bytes to portal %d nid %Lx pid %d xid %d\n",
+        CDEBUG(D_NET, "Sending %u pages %u bytes to portal %d nid "LPX64" pid %d xid %d\n",
                desc->bd_md.niov, desc->bd_md.length,
                desc->bd_portal, remote_id.nid, remote_id.pid, xid);
 
         rc = PtlPut(desc->bd_md_h, PTL_ACK_REQ, remote_id,
                     desc->bd_portal, 0, xid, 0, 0);
         if (rc != PTL_OK) {
-                CERROR("PtlPut(%Lu, %d, %d) failed: %d\n",
+                CERROR("PtlPut("LPU64", %d, %d) failed: %d\n",
                        remote_id.nid, desc->bd_portal, xid, rc);
                 PtlMDUnlink(desc->bd_md_h);
                 LBUG();
@@ -364,7 +365,7 @@ int ptl_send_rpc(struct ptlrpc_request *request)
                 GOTO(cleanup2, rc);
         }
 
-        CDEBUG(D_NET, "Setup reply buffer: %u bytes, xid %Lu, portal %u\n",
+        CDEBUG(D_NET, "Setup reply buffer: %u bytes, xid "LPU64", portal %u\n",
                request->rq_replen, request->rq_xid,
                request->rq_import->imp_client->cli_reply_portal);
 

diff --git a/lustre/ptlrpc/service.c b/lustre/ptlrpc/service.c
index 478b40a..6163a71 100644 (file)
--- a/lustre/ptlrpc/service.c
+++ b/lustre/ptlrpc/service.c
@@ -162,7 +162,7 @@ static int handle_incoming_request(struct obd_device *obddev,
         request.rq_reqlen = event->mem_desc.length;
 
         if (request.rq_reqlen < sizeof(struct lustre_msg)) {
-                CERROR("incomplete request (%d): ptl %d from %Lx xid %Ld\n",
+                CERROR("incomplete request (%d): ptl %d from "LPX64" xid "LPD64"\n",
                        request.rq_reqlen, svc->srv_req_portal,
                        event->initiator.nid, request.rq_xid);
                 spin_unlock(&svc->srv_lock);
@@ -178,7 +178,7 @@ static int handle_incoming_request(struct obd_device *obddev,
         }
 
         if (request.rq_reqmsg->magic != PTLRPC_MSG_MAGIC) {
-                CERROR("wrong lustre_msg magic %d: ptl %d from %Lx xid %Ld\n",
+                CERROR("wrong lustre_msg magic %d: ptl %d from "LPX64" xid "LPD64"\n",
                        request.rq_reqmsg->magic, svc->srv_req_portal,
                        event->initiator.nid, request.rq_xid);
                 spin_unlock(&svc->srv_lock);
@@ -186,14 +186,14 @@ static int handle_incoming_request(struct obd_device *obddev,
         }
 
         if (request.rq_reqmsg->version != PTLRPC_MSG_VERSION) {
-                CERROR("wrong lustre_msg version %d: ptl %d from %Lx xid %Ld\n",
+                CERROR("wrong lustre_msg version %d: ptl %d from "LPX64" xid "LPD64"\n",
                        request.rq_reqmsg->version, svc->srv_req_portal,
                        event->initiator.nid, request.rq_xid);
                 spin_unlock(&svc->srv_lock);
                 RETURN(-EINVAL);
         }
 
-        CDEBUG(D_NET, "got req %Ld\n", request.rq_xid);
+        CDEBUG(D_NET, "got req "LPD64"\n", request.rq_xid);
 
         request.rq_peer.peer_nid = event->initiator.nid;
         /* FIXME: this NI should be the incoming NI.