redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

staging: lustre: remove LPU64 define 

Just use the proper modifier type...

Cc: Andreas Dilger <andreas.dilger@intel.com>
Cc: Oleg Drokin <oleg.drokin@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
hifive-unleashed-5.1
Greg Kroah-Hartman 2014-07-12 20:06:04 -07:00
parent f537dd2c3c
commit b0f5aad587
75 changed files with 288 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
drivers/staging/lustre/include/linux/libcfs/linux/kp30.h
View File

@ -70,7 +70,6 @@
/* this is a bit chunky */
# define LPU64 "%llu"
# define LPX64 "%#llx"
#endif

2
drivers/staging/lustre/include/linux/lnet/ptllnd.h
View File

@ -49,7 +49,7 @@
#ifdef _USING_LUSTRE_PORTALS_
/* NIDs are 64-bits on Lustre Portals */
#define FMT_NID LPU64
#define FMT_NID "%llu"
#define FMT_PID "%d"
/* When using Lustre Portals Lustre completion semantics are imlicit*/

2
drivers/staging/lustre/lnet/klnds/socklnd/socklnd.c
View File

@ -2517,7 +2517,7 @@ ksocknal_debug_peerhash (lnet_ni_t *ni)
ksock_conn_t *conn;
CWARN ("Active peer on shutdown: %s, ref %d, scnt %d, "
"closing %d, accepting %d, err %d, zcookie "LPU64", "
"closing %d, accepting %d, err %d, zcookie %llu, "
"txq %d, zc_req %d\n", libcfs_id2str(peer->ksnp_id),
atomic_read(&peer->ksnp_refcount),
peer->ksnp_sharecount, peer->ksnp_closing,

2
drivers/staging/lustre/lnet/klnds/socklnd/socklnd_cb.c
View File

@ -1199,7 +1199,7 @@ ksocknal_process_receive (ksock_conn_t *conn)
conn->ksnc_msg.ksm_zc_cookies[1]);
if (rc != 0) {
CERROR("%s: Unknown ZC-ACK cookie: "LPU64", "LPU64"\n",
CERROR("%s: Unknown ZC-ACK cookie: %llu, %llu\n",
libcfs_id2str(conn->ksnc_peer->ksnp_id),
cookie, conn->ksnc_msg.ksm_zc_cookies[1]);
ksocknal_new_packet(conn, 0);

4
drivers/staging/lustre/lnet/klnds/socklnd/socklnd_proto.c
View File

@ -192,7 +192,7 @@ ksocknal_queue_tx_zcack_v3(ksock_conn_t *conn,
if (cookie == tx->tx_msg.ksm_zc_cookies[0] ||
cookie == tx->tx_msg.ksm_zc_cookies[1]) {
CWARN("%s: duplicated ZC cookie: "LPU64"\n",
CWARN("%s: duplicated ZC cookie: %llu\n",
libcfs_id2str(conn->ksnc_peer->ksnp_id), cookie);
return 1; /* XXX return error in the future */
}
@ -244,7 +244,7 @@ ksocknal_queue_tx_zcack_v3(ksock_conn_t *conn,
/* ksm_zc_cookies[0] < ksm_zc_cookies[1], it is range of cookies */
if (cookie >= tx->tx_msg.ksm_zc_cookies[0] &&
cookie <= tx->tx_msg.ksm_zc_cookies[1]) {
CWARN("%s: duplicated ZC cookie: "LPU64"\n",
CWARN("%s: duplicated ZC cookie: %llu\n",
libcfs_id2str(conn->ksnc_peer->ksnp_id), cookie);
return 1; /* XXX: return error in the future */
}

19
drivers/staging/lustre/lnet/lnet/lib-move.c
View File

@ -1426,8 +1426,7 @@ lnet_parse_put(lnet_ni_t *ni, lnet_msg_t *msg)
/* fall through */
case LNET_MATCHMD_DROP:
CNETERR("Dropping PUT from %s portal %d match "LPU64
" offset %d length %d: %d\n",
CNETERR("Dropping PUT from %s portal %d match %llu offset %d length %d: %d\n",
libcfs_id2str(info.mi_id), info.mi_portal,
info.mi_mbits, info.mi_roffset, info.mi_rlength, rc);
@ -1459,8 +1458,7 @@ lnet_parse_get(lnet_ni_t *ni, lnet_msg_t *msg, int rdma_get)
rc = lnet_ptl_match_md(&info, msg);
if (rc == LNET_MATCHMD_DROP) {
CNETERR("Dropping GET from %s portal %d match "LPU64
" offset %d length %d\n",
CNETERR("Dropping GET from %s portal %d match %llu offset %d length %d\n",
libcfs_id2str(info.mi_id), info.mi_portal,
info.mi_mbits, info.mi_roffset, info.mi_rlength);
return ENOENT; /* +ve: OK but no match */
@ -1681,7 +1679,7 @@ lnet_print_hdr(lnet_hdr_t *hdr)
case LNET_MSG_PUT:
CWARN(" Ptl index %d, ack md "LPX64"."LPX64", "
"match bits "LPU64"\n",
"match bits %llu\n",
hdr->msg.put.ptl_index,
hdr->msg.put.ack_wmd.wh_interface_cookie,
hdr->msg.put.ack_wmd.wh_object_cookie,
@ -1693,7 +1691,7 @@ lnet_print_hdr(lnet_hdr_t *hdr)
case LNET_MSG_GET:
CWARN(" Ptl index %d, return md "LPX64"."LPX64", "
"match bits "LPU64"\n", hdr->msg.get.ptl_index,
"match bits %llu\n", hdr->msg.get.ptl_index,
hdr->msg.get.return_wmd.wh_interface_cookie,
hdr->msg.get.return_wmd.wh_object_cookie,
hdr->msg.get.match_bits);
@ -1963,8 +1961,7 @@ lnet_drop_delayed_msg_list(struct list_head *head, char *reason)
LASSERT(msg->msg_rxpeer != NULL);
LASSERT(msg->msg_hdr.type == LNET_MSG_PUT);
CWARN("Dropping delayed PUT from %s portal %d match "LPU64
" offset %d length %d: %s\n",
CWARN("Dropping delayed PUT from %s portal %d match %llu offset %d length %d: %s\n",
libcfs_id2str(id),
msg->msg_hdr.msg.put.ptl_index,
msg->msg_hdr.msg.put.match_bits,
@ -2009,7 +2006,7 @@ lnet_recv_delayed_msg_list(struct list_head *head)
LASSERT(msg->msg_hdr.type == LNET_MSG_PUT);
CDEBUG(D_NET, "Resuming delayed PUT from %s portal %d "
"match "LPU64" offset %d length %d.\n",
"match %llu offset %d length %d.\n",
libcfs_id2str(id), msg->msg_hdr.msg.put.ptl_index,
msg->msg_hdr.msg.put.match_bits,
msg->msg_hdr.msg.put.offset,
@ -2097,7 +2094,7 @@ LNetPut(lnet_nid_t self, lnet_handle_md_t mdh, lnet_ack_req_t ack,
md = lnet_handle2md(&mdh);
if (md == NULL || md->md_threshold == 0 || md->md_me != NULL) {
CERROR("Dropping PUT ("LPU64":%d:%s): MD (%d) invalid\n",
CERROR("Dropping PUT (%llu:%d:%s): MD (%d) invalid\n",
match_bits, portal, libcfs_id2str(target),
md == NULL ? -1 : md->md_threshold);
if (md != NULL && md->md_me != NULL)
@ -2296,7 +2293,7 @@ LNetGet(lnet_nid_t self, lnet_handle_md_t mdh,
md = lnet_handle2md(&mdh);
if (md == NULL || md->md_threshold == 0 || md->md_me != NULL) {
CERROR("Dropping GET ("LPU64":%d:%s): MD (%d) invalid\n",
CERROR("Dropping GET (%llu:%d:%s): MD (%d) invalid\n",
match_bits, portal, libcfs_id2str(target),
md == NULL ? -1 : md->md_threshold);
if (md != NULL && md->md_me != NULL)

6
drivers/staging/lustre/lnet/lnet/lib-ptl.c
View File

@ -184,8 +184,7 @@ lnet_try_match_md(lnet_libmd_t *md,
mlength = info->mi_rlength;
} else if ((md->md_options & LNET_MD_TRUNCATE) == 0) {
/* this packet _really_ is too big */
CERROR("Matching packet from %s, match "LPU64
" length %d too big: %d left, %d allowed\n",
CERROR("Matching packet from %s, match %llu length %d too big: %d left, %d allowed\n",
libcfs_id2str(info->mi_id), info->mi_mbits,
info->mi_rlength, md->md_length - offset, mlength);
@ -687,8 +686,7 @@ lnet_ptl_attach_md(lnet_me_t *me, lnet_libmd_t *md,
if ((rc & LNET_MATCHMD_OK) != 0) {
list_add_tail(&msg->msg_list, matches);
CDEBUG(D_NET, "Resuming delayed PUT from %s portal %d "
"match "LPU64" offset %d length %d.\n",
CDEBUG(D_NET, "Resuming delayed PUT from %s portal %d match %llu offset %d length %d.\n",
libcfs_id2str(info.mi_id),
info.mi_portal, info.mi_mbits,
info.mi_roffset, info.mi_rlength);

5
drivers/staging/lustre/lnet/lnet/router_proc.c
View File

@ -115,7 +115,7 @@ static int __proc_lnet_stats(void *data, int write,
lnet_counters_t *ctrs;
int len;
char *tmpstr;
const int tmpsiz = 256; /* 7 %u and 4 LPU64 */
const int tmpsiz = 256; /* 7 %u and 4 %llu */
if (write) {
lnet_counters_reset();
@ -137,8 +137,7 @@ static int __proc_lnet_stats(void *data, int write,
lnet_counters_get(ctrs);
len = snprintf(tmpstr, tmpsiz,
"%u %u %u %u %u %u %u "LPU64" "LPU64" "
LPU64" "LPU64,
"%u %u %u %u %u %u %u %llu %llu %llu %llu",
ctrs->msgs_alloc, ctrs->msgs_max,
ctrs->errors,
ctrs->send_count, ctrs->recv_count,

8
drivers/staging/lustre/lnet/selftest/framework.c
View File

@ -248,7 +248,7 @@ sfw_session_expired (void *data)
LASSERT (sn->sn_timer_active);
LASSERT (sn == sfw_data.fw_session);
CWARN ("Session expired! sid: %s-"LPU64", name: %s\n",
CWARN ("Session expired! sid: %s-%llu, name: %s\n",
libcfs_nid2str(sn->sn_id.ses_nid),
sn->sn_id.ses_stamp, &sn->sn_name[0]);
@ -741,7 +741,7 @@ sfw_add_test_instance (sfw_batch_t *tsb, srpc_server_rpc_t *rpc)
LIBCFS_ALLOC(tsi, sizeof(*tsi));
if (tsi == NULL) {
CERROR ("Can't allocate test instance for batch: "LPU64"\n",
CERROR ("Can't allocate test instance for batch: %llu\n",
tsb->bat_id.bat_id);
return -ENOMEM;
}
@ -1002,7 +1002,7 @@ sfw_run_batch (sfw_batch_t *tsb)
sfw_test_instance_t *tsi;
if (sfw_batch_active(tsb)) {
CDEBUG(D_NET, "Batch already active: "LPU64" (%d)\n",
CDEBUG(D_NET, "Batch already active: %llu (%d)\n",
tsb->bat_id.bat_id, atomic_read(&tsb->bat_nactive));
return 0;
}
@ -1037,7 +1037,7 @@ sfw_stop_batch (sfw_batch_t *tsb, int force)
srpc_client_rpc_t *rpc;
if (!sfw_batch_active(tsb)) {
CDEBUG(D_NET, "Batch "LPU64" inactive\n", tsb->bat_id.bat_id);
CDEBUG(D_NET, "Batch %llu inactive\n", tsb->bat_id.bat_id);
return 0;
}

4
drivers/staging/lustre/lustre/fid/lproc_fid.c
View File

@ -157,7 +157,7 @@ static ssize_t lprocfs_fid_width_seq_write(struct file *file,
seq->lcs_width = val;
if (rc == 0) {
CDEBUG(D_INFO, "%s: Sequence size: "LPU64"\n",
CDEBUG(D_INFO, "%s: Sequence size: %llu\n",
seq->lcs_name, seq->lcs_width);
}
}
@ -176,7 +176,7 @@ lprocfs_fid_width_seq_show(struct seq_file *m, void *unused)
LASSERT(seq != NULL);
mutex_lock(&seq->lcs_mutex);
rc = seq_printf(m, LPU64"\n", seq->lcs_width);
rc = seq_printf(m, "%llu\n", seq->lcs_width);
mutex_unlock(&seq->lcs_mutex);
return rc;

6
drivers/staging/lustre/lustre/fld/fld_cache.c
View File

@ -113,9 +113,9 @@ void fld_cache_fini(struct fld_cache *cache)
}
CDEBUG(D_INFO, "FLD cache statistics (%s):\n", cache->fci_name);
CDEBUG(D_INFO, " Total reqs: "LPU64"\n", cache->fci_stat.fst_count);
CDEBUG(D_INFO, " Cache reqs: "LPU64"\n", cache->fci_stat.fst_cache);
CDEBUG(D_INFO, " Cache hits: "LPU64"%%\n", pct);
CDEBUG(D_INFO, " Total reqs: %llu\n", cache->fci_stat.fst_count);
CDEBUG(D_INFO, " Cache reqs: %llu\n", cache->fci_stat.fst_cache);
CDEBUG(D_INFO, " Cache hits: %llu%%\n", pct);
OBD_FREE_PTR(cache);
}

17
drivers/staging/lustre/lustre/fld/fld_request.c
View File

@ -148,7 +148,7 @@ fld_rrb_scan(struct lu_client_fld *fld, seqno_t seq)
(char *)target->ft_exp->exp_obd->obd_uuid.uuid :
"<null>";
CERROR(" exp: 0x%p (%s), srv: 0x%p (%s), idx: "LPU64"\n",
CERROR(" exp: 0x%p (%s), srv: 0x%p (%s), idx: %llu\n",
target->ft_exp, exp_name, target->ft_srv,
srv_name, target->ft_idx);
}
@ -184,9 +184,8 @@ fld_client_get_target(struct lu_client_fld *fld, seqno_t seq)
spin_unlock(&fld->lcf_lock);
if (target != NULL) {
CDEBUG(D_INFO, "%s: Found target (idx "LPU64
") by seq "LPX64"\n", fld->lcf_name,
target->ft_idx, seq);
CDEBUG(D_INFO, "%s: Found target (idx %llu) by seq "LPX64"\n",
fld->lcf_name, target->ft_idx, seq);
}
return target;
@ -208,12 +207,12 @@ int fld_client_add_target(struct lu_client_fld *fld,
LASSERT(tar->ft_srv != NULL || tar->ft_exp != NULL);
if (fld->lcf_flags != LUSTRE_FLD_INIT) {
CERROR("%s: Attempt to add target %s (idx "LPU64") on fly - skip it\n",
CERROR("%s: Attempt to add target %s (idx %llu) on fly - skip it\n",
fld->lcf_name, name, tar->ft_idx);
return 0;
} else {
CDEBUG(D_INFO, "%s: Adding target %s (idx "
LPU64")\n", fld->lcf_name, name, tar->ft_idx);
CDEBUG(D_INFO, "%s: Adding target %s (idx %llu)\n",
fld->lcf_name, name, tar->ft_idx);
}
OBD_ALLOC_PTR(target);
@ -225,7 +224,7 @@ int fld_client_add_target(struct lu_client_fld *fld,
if (tmp->ft_idx == tar->ft_idx) {
spin_unlock(&fld->lcf_lock);
OBD_FREE_PTR(target);
CERROR("Target %s exists in FLD and known as %s:#"LPU64"\n",
CERROR("Target %s exists in FLD and known as %s:#%llu\n",
name, fld_target_name(tmp), tmp->ft_idx);
return -EEXIST;
}
@ -473,7 +472,7 @@ int fld_client_lookup(struct lu_client_fld *fld, seqno_t seq, mdsno_t *mds,
target = fld_client_get_target(fld, seq);
LASSERT(target != NULL);
CDEBUG(D_INFO, "%s: Lookup fld entry (seq: "LPX64") on target %s (idx "LPU64")\n",
CDEBUG(D_INFO, "%s: Lookup fld entry (seq: "LPX64") on target %s (idx %llu)\n",
fld->lcf_name, seq, fld_target_name(target), target->ft_idx);
res.lsr_start = seq;

6
drivers/staging/lustre/lustre/include/lustre/lustre_idl.h
View File

@ -91,7 +91,7 @@
#ifndef _LUSTRE_IDL_H_
#define _LUSTRE_IDL_H_
#if !defined(LPU64)
#if !defined(LPX64)
#include "../../../include/linux/libcfs/libcfs.h" /* for LPUX64, etc */
#endif
@ -681,14 +681,14 @@ static inline void ostid_set_id(struct ost_id *oi, __u64 oid)
{
if (fid_seq_is_mdt0(ostid_seq(oi))) {
if (oid >= IDIF_MAX_OID) {
CERROR("Bad "LPU64" to set "DOSTID"\n",
CERROR("Bad %llu to set "DOSTID"\n",
oid, POSTID(oi));
return;
}
oi->oi.oi_id = oid;
} else {
if (oid > OBIF_MAX_OID) {
CERROR("Bad "LPU64" to set "DOSTID"\n",
CERROR("Bad %llu to set "DOSTID"\n",
oid, POSTID(oi));
return;
}

2
drivers/staging/lustre/lustre/include/lustre/lustre_user.h
View File

@ -179,7 +179,7 @@ struct ost_id {
};
};
#define DOSTID LPX64":"LPU64
#define DOSTID LPX64":%llu"
#define POSTID(oi) ostid_seq(oi), ostid_id(oi)
/*

2
drivers/staging/lustre/lustre/include/lustre_capa.h
View File

@ -167,7 +167,7 @@ do { \
#define DEBUG_CAPA_KEY(level, k, fmt, args...) \
do { \
CDEBUG(level, fmt " capability key@%p seq "LPU64" keyid %u\n", \
CDEBUG(level, fmt " capability key@%p seq %llu keyid %u\n", \
##args, k, capa_key_seq(k), capa_key_keyid(k)); \
} while (0)

10
drivers/staging/lustre/lustre/include/obd_class.h
View File

@ -1160,13 +1160,12 @@ static inline int obd_statfs_async(struct obd_export *exp,
OBD_CHECK_DT_OP(obd, statfs, -EOPNOTSUPP);
OBD_COUNTER_INCREMENT(obd, statfs);
CDEBUG(D_SUPER, "%s: osfs %p age "LPU64", max_age "LPU64"\n",
CDEBUG(D_SUPER, "%s: osfs %p age %llu, max_age %llu\n",
obd->obd_name, &obd->obd_osfs, obd->obd_osfs_age, max_age);
if (cfs_time_before_64(obd->obd_osfs_age, max_age)) {
rc = OBP(obd, statfs_async)(exp, oinfo, max_age, rqset);
} else {
CDEBUG(D_SUPER,"%s: use %p cache blocks "LPU64"/"LPU64
" objects "LPU64"/"LPU64"\n",
CDEBUG(D_SUPER,"%s: use %p cache blocks %llu/%llu objects %llu/%llu\n",
obd->obd_name, &obd->obd_osfs,
obd->obd_osfs.os_bavail, obd->obd_osfs.os_blocks,
obd->obd_osfs.os_ffree, obd->obd_osfs.os_files);
@ -1217,7 +1216,7 @@ static inline int obd_statfs(const struct lu_env *env, struct obd_export *exp,
OBD_CHECK_DT_OP(obd, statfs, -EOPNOTSUPP);
OBD_COUNTER_INCREMENT(obd, statfs);
CDEBUG(D_SUPER, "osfs "LPU64", max_age "LPU64"\n",
CDEBUG(D_SUPER, "osfs %llu, max_age %llu\n",
obd->obd_osfs_age, max_age);
if (cfs_time_before_64(obd->obd_osfs_age, max_age)) {
rc = OBP(obd, statfs)(env, exp, osfs, max_age, flags);
@ -1228,8 +1227,7 @@ static inline int obd_statfs(const struct lu_env *env, struct obd_export *exp,
spin_unlock(&obd->obd_osfs_lock);
}
} else {
CDEBUG(D_SUPER, "%s: use %p cache blocks "LPU64"/"LPU64
" objects "LPU64"/"LPU64"\n",
CDEBUG(D_SUPER, "%s: use %p cache blocks %llu/%llu objects %llu/%llu\n",
obd->obd_name, &obd->obd_osfs,
obd->obd_osfs.os_bavail, obd->obd_osfs.os_blocks,
obd->obd_osfs.os_ffree, obd->obd_osfs.os_files);

12
drivers/staging/lustre/lustre/include/obd_support.h
View File

@ -662,7 +662,7 @@ do { \
if (unlikely((ptr) == NULL)) { \
CERROR("vmalloc of '" #ptr "' (%d bytes) failed\n", \
(int)(size)); \
CERROR(LPU64" total bytes allocated by Lustre, %d by LNET\n", \
CERROR("%llu total bytes allocated by Lustre, %d by LNET\n", \
obd_memory_sum(), atomic_read(&libcfs_kmemory)); \
} else { \
OBD_ALLOC_POST(ptr, size, "vmalloced"); \
@ -822,11 +822,11 @@ do { \
alloc_page(gfp_mask) : \
alloc_pages_node(cfs_cpt_spread_node(cptab, cpt), gfp_mask, 0);\
if (unlikely((ptr) == NULL)) { \
CERROR("alloc_pages of '" #ptr "' %d page(s) / "LPU64" bytes "\
CERROR("alloc_pages of '" #ptr "' %d page(s) / %llu bytes "\
"failed\n", (int)1, \
(__u64)(1 << PAGE_CACHE_SHIFT)); \
CERROR(LPU64" total bytes and "LPU64" total pages " \
"("LPU64" bytes) allocated by Lustre, " \
CERROR("%llu total bytes and %llu total pages " \
"(%llu bytes) allocated by Lustre, " \
"%d total bytes by LNET\n", \
obd_memory_sum(), \
obd_pages_sum() << PAGE_CACHE_SHIFT, \
@ -835,7 +835,7 @@ do { \
} else { \
obd_pages_add(0); \
CDEBUG(D_MALLOC, "alloc_pages '" #ptr "': %d page(s) / " \
LPU64" bytes at %p.\n", \
"%llu bytes at %p.\n", \
(int)1, \
(__u64)(1 << PAGE_CACHE_SHIFT), ptr); \
} \
@ -850,7 +850,7 @@ do { \
do { \
LASSERT(ptr); \
obd_pages_sub(0); \
CDEBUG(D_MALLOC, "free_pages '" #ptr "': %d page(s) / "LPU64" bytes " \
CDEBUG(D_MALLOC, "free_pages '" #ptr "': %d page(s) / %llu bytes " \
"at %p.\n", \
(int)1, (__u64)(1 << PAGE_CACHE_SHIFT), \
ptr); \

2
drivers/staging/lustre/lustre/lclient/lcommon_cl.c
View File

@ -843,7 +843,7 @@ int ccc_prep_size(const struct lu_env *env, struct cl_object *obj,
if (cl_isize_read(inode) < kms) {
cl_isize_write_nolock(inode, kms);
CDEBUG(D_VFSTRACE,
DFID" updating i_size "LPU64"\n",
DFID" updating i_size %llu\n",
PFID(lu_object_fid(&obj->co_lu)),
(__u64)cl_isize_read(inode));

2
drivers/staging/lustre/lustre/ldlm/ldlm_extent.c
View File

@ -90,7 +90,7 @@ __u64 ldlm_extent_shift_kms(struct ldlm_lock *lock, __u64 old_kms)
if (lck->l_policy_data.l_extent.end + 1 > kms)
kms = lck->l_policy_data.l_extent.end + 1;
}
LASSERTF(kms <= old_kms, "kms "LPU64" old_kms "LPU64"\n", kms, old_kms);
LASSERTF(kms <= old_kms, "kms %llu old_kms %llu\n", kms, old_kms);
return kms;
}

5
drivers/staging/lustre/lustre/ldlm/ldlm_flock.c
View File

@ -260,9 +260,8 @@ ldlm_process_flock_lock(struct ldlm_lock *req, __u64 *flags, int first_enq,
int splitted = 0;
const struct ldlm_callback_suite null_cbs = { NULL };
CDEBUG(D_DLMTRACE, "flags %#llx owner "LPU64" pid %u mode %u start "
LPU64" end "LPU64"\n", *flags,
new->l_policy_data.l_flock.owner,
CDEBUG(D_DLMTRACE, "flags %#llx owner %llu pid %u mode %u start %llu end %llu\n",
*flags, new->l_policy_data.l_flock.owner,
new->l_policy_data.l_flock.pid, mode,
req->l_policy_data.l_flock.start,
req->l_policy_data.l_flock.end);

2
drivers/staging/lustre/lustre/ldlm/ldlm_lib.c
View File

@ -697,7 +697,7 @@ void target_send_reply(struct ptlrpc_request *req, int rc, int fail_id)
rs->rs_opc = lustre_msg_get_opc(req->rq_reqmsg);
spin_lock(&exp->exp_uncommitted_replies_lock);
CDEBUG(D_NET, "rs transno = "LPU64", last committed = "LPU64"\n",
CDEBUG(D_NET, "rs transno = %llu, last committed = %llu\n",
rs->rs_transno, exp->exp_last_committed);
if (rs->rs_transno > exp->exp_last_committed) {
/* not committed already */

16
drivers/staging/lustre/lustre/ldlm/ldlm_lock.c
View File

@ -624,8 +624,7 @@ void ldlm_lock2desc(struct ldlm_lock *lock, struct ldlm_lock_desc *desc)
LASSERTF(lock->l_policy_data.l_inodebits.bits ==
(MDS_INODELOCK_LOOKUP | MDS_INODELOCK_UPDATE |
MDS_INODELOCK_LAYOUT),
"Inappropriate inode lock bits during "
"conversion " LPU64 "\n",
"Inappropriate inode lock bits during conversion %llu\n",
lock->l_policy_data.l_inodebits.bits);
ldlm_res2desc(lock->l_resource, &desc->l_resource);
@ -1350,7 +1349,7 @@ ldlm_mode_t ldlm_lock_match(struct ldlm_namespace *ns, __u64 flags,
}
out2:
if (rc) {
LDLM_DEBUG(lock, "matched ("LPU64" "LPU64")",
LDLM_DEBUG(lock, "matched (%llu %llu)",
(type == LDLM_PLAIN || type == LDLM_IBITS) ?
res_id->name[2] : policy->l_extent.start,
(type == LDLM_PLAIN || type == LDLM_IBITS) ?
@ -1369,9 +1368,8 @@ ldlm_mode_t ldlm_lock_match(struct ldlm_namespace *ns, __u64 flags,
LDLM_LOCK_RELEASE(lock);
} else if (!(flags & LDLM_FL_TEST_LOCK)) {/*less verbose for test-only*/
LDLM_DEBUG_NOLOCK("not matched ns %p type %u mode %u res "
LPU64"/"LPU64" ("LPU64" "LPU64")", ns,
type, mode, res_id->name[0], res_id->name[1],
LDLM_DEBUG_NOLOCK("not matched ns %p type %u mode %u res %llu/%llu (%llu %llu)",
ns, type, mode, res_id->name[0], res_id->name[1],
(type == LDLM_PLAIN || type == LDLM_IBITS) ?
res_id->name[2] :policy->l_extent.start,
(type == LDLM_PLAIN || type == LDLM_IBITS) ?
@ -2277,8 +2275,8 @@ void _ldlm_lock_debug(struct ldlm_lock *lock,
case LDLM_EXTENT:
libcfs_debug_vmsg2(msgdata, fmt, args,
" ns: %s lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s "
"res: "DLDLMRES" rrc: %d type: %s ["LPU64"->"LPU64"] "
"(req "LPU64"->"LPU64") flags: "LPX64" nid: %s remote: "
"res: "DLDLMRES" rrc: %d type: %s [%llu->%llu] "
"(req %llu->%llu) flags: "LPX64" nid: %s remote: "
LPX64" expref: %d pid: %u timeout: %lu lvb_type: %d\n",
ldlm_lock_to_ns_name(lock), lock,
lock->l_handle.h_cookie, atomic_read(&lock->l_refc),
@ -2301,7 +2299,7 @@ void _ldlm_lock_debug(struct ldlm_lock *lock,
libcfs_debug_vmsg2(msgdata, fmt, args,
" ns: %s lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s "
"res: "DLDLMRES" rrc: %d type: %s pid: %d "
"["LPU64"->"LPU64"] flags: "LPX64" nid: %s "
"[%llu->%llu] flags: "LPX64" nid: %s "
"remote: "LPX64" expref: %d pid: %u timeout: %lu\n",
ldlm_lock_to_ns_name(lock), lock,
lock->l_handle.h_cookie, atomic_read(&lock->l_refc),

4
drivers/staging/lustre/lustre/ldlm/ldlm_pool.c
View File

@ -659,8 +659,8 @@ static int lprocfs_pool_state_seq_show(struct seq_file *m, void *unused)
spin_unlock(&pl->pl_lock);
seq_printf(m, "LDLM pool state (%s):\n"
" SLV: "LPU64"\n"
" CLV: "LPU64"\n"
" SLV: %llu\n"
" CLV: %llu\n"
" LVF: %d\n",
pl->pl_name, slv, clv, lvf);

5
drivers/staging/lustre/lustre/ldlm/ldlm_request.c
View File

@ -1276,8 +1276,7 @@ int ldlm_cli_update_pool(struct ptlrpc_request *req)
* server-side namespace is not possible. */
if (lustre_msg_get_slv(req->rq_repmsg) == 0 ||
lustre_msg_get_limit(req->rq_repmsg) == 0) {
DEBUG_REQ(D_HA, req, "Zero SLV or Limit found "
"(SLV: "LPU64", Limit: %u)",
DEBUG_REQ(D_HA, req, "Zero SLV or Limit found (SLV: %llu, Limit: %u)",
lustre_msg_get_slv(req->rq_repmsg),
lustre_msg_get_limit(req->rq_repmsg));
return 0;
@ -1893,7 +1892,7 @@ int ldlm_cli_cancel_unused_resource(struct ldlm_namespace *ns,
res = ldlm_resource_get(ns, NULL, res_id, 0, 0);
if (res == NULL) {
/* This is not a problem. */
CDEBUG(D_INFO, "No resource "LPU64"\n", res_id->name[0]);
CDEBUG(D_INFO, "No resource %llu\n", res_id->name[0]);
return 0;
}

17
drivers/staging/lustre/lustre/libcfs/upcall_cache.c
View File

@ -68,7 +68,7 @@ static void free_entry(struct upcall_cache *cache,
cache->uc_ops->free_entry(cache, entry);
list_del(&entry->ue_hash);
CDEBUG(D_OTHER, "destroy cache entry %p for key "LPU64"\n",
CDEBUG(D_OTHER, "destroy cache entry %p for key %llu\n",
entry, entry->ue_key);
LIBCFS_FREE(entry, sizeof(*entry));
}
@ -229,7 +229,7 @@ find_again:
if (UC_CACHE_IS_ACQUIRING(entry)) {
/* we're interrupted or upcall failed in the middle */
rc = left > 0 ? -EINTR : -ETIMEDOUT;
CERROR("acquire for key "LPU64": error %d\n",
CERROR("acquire for key %llu: error %d\n",
entry->ue_key, rc);
put_entry(cache, entry);
GOTO(out, entry = ERR_PTR(rc));
@ -302,7 +302,7 @@ int upcall_cache_downcall(struct upcall_cache *cache, __u32 err, __u64 key,
}
if (!found) {
CDEBUG(D_OTHER, "%s: upcall for key "LPU64" not expected\n",
CDEBUG(D_OTHER, "%s: upcall for key %llu not expected\n",
cache->uc_name, key);
/* haven't found, it's possible */
spin_unlock(&cache->uc_lock);
@ -310,19 +310,19 @@ int upcall_cache_downcall(struct upcall_cache *cache, __u32 err, __u64 key,
}
if (err) {
CDEBUG(D_OTHER, "%s: upcall for key "LPU64" returned %d\n",
CDEBUG(D_OTHER, "%s: upcall for key %llu returned %d\n",
cache->uc_name, entry->ue_key, err);
GOTO(out, rc = -EINVAL);
}
if (!UC_CACHE_IS_ACQUIRING(entry)) {
CDEBUG(D_RPCTRACE,"%s: found uptodate entry %p (key "LPU64")\n",
CDEBUG(D_RPCTRACE,"%s: found uptodate entry %p (key %llu)\n",
cache->uc_name, entry, entry->ue_key);
GOTO(out, rc = 0);
}
if (UC_CACHE_IS_INVALID(entry) || UC_CACHE_IS_EXPIRED(entry)) {
CERROR("%s: found a stale entry %p (key "LPU64") in ioctl\n",
CERROR("%s: found a stale entry %p (key %llu) in ioctl\n",
cache->uc_name, entry, entry->ue_key);
GOTO(out, rc = -EINVAL);
}
@ -336,7 +336,7 @@ int upcall_cache_downcall(struct upcall_cache *cache, __u32 err, __u64 key,
entry->ue_expire = cfs_time_shift(cache->uc_entry_expire);
UC_CACHE_SET_VALID(entry);
CDEBUG(D_OTHER, "%s: created upcall cache entry %p for key "LPU64"\n",
CDEBUG(D_OTHER, "%s: created upcall cache entry %p for key %llu\n",
cache->uc_name, entry, entry->ue_key);
out:
if (rc) {
@ -401,8 +401,7 @@ void upcall_cache_flush_one(struct upcall_cache *cache, __u64 key, void *args)
}
if (found) {
CWARN("%s: flush entry %p: key "LPU64", ref %d, fl %x, "
"cur %lu, ex %ld/%ld\n",
CWARN("%s: flush entry %p: key %llu, ref %d, fl %x, cur %lu, ex %ld/%ld\n",
cache->uc_name, entry, entry->ue_key,
atomic_read(&entry->ue_refcount), entry->ue_flags,
get_seconds(), entry->ue_acquire_expire,

19
drivers/staging/lustre/lustre/llite/dir.c
View File

@ -158,7 +158,7 @@ static int ll_dir_filler(void *_hash, struct page *page0)
int i;
int rc;
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) hash "LPU64"\n",
CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p) hash %llu\n",
inode->i_ino, inode->i_generation, inode, hash);
LASSERT(max_pages > 0 && max_pages <= MD_MAX_BRW_PAGES);
@ -304,7 +304,7 @@ static struct page *ll_dir_page_locate(struct inode *dir, __u64 *hash,
}
LASSERTF(*start <= *hash, "start = "LPX64",end = "
LPX64",hash = "LPX64"\n", *start, *end, *hash);
CDEBUG(D_VFSTRACE, "page %lu [%llu %llu], hash "LPU64"\n",
CDEBUG(D_VFSTRACE, "page %lu [%llu %llu], hash %llu\n",
offset, *start, *end, *hash);
if (*hash > *end) {
ll_release_page(page, 0);
@ -376,7 +376,7 @@ struct page *ll_get_dir_page(struct inode *dir, __u64 hash,
if (request)
ptlrpc_req_finished(request);
if (rc < 0) {
CERROR("lock enqueue: "DFID" at "LPU64": rc %d\n",
CERROR("lock enqueue: "DFID" at %llu: rc %d\n",
PFID(ll_inode2fid(dir)), hash, rc);
return ERR_PTR(rc);
}
@ -396,7 +396,7 @@ struct page *ll_get_dir_page(struct inode *dir, __u64 hash,
mutex_lock(&lli->lli_readdir_mutex);
page = ll_dir_page_locate(dir, &lhash, &start, &end);
if (IS_ERR(page)) {
CERROR("dir page locate: "DFID" at "LPU64": rc %ld\n",
CERROR("dir page locate: "DFID" at %llu: rc %ld\n",
PFID(ll_inode2fid(dir)), lhash, PTR_ERR(page));
GOTO(out_unlock, page);
} else if (page != NULL) {
@ -420,7 +420,7 @@ struct page *ll_get_dir_page(struct inode *dir, __u64 hash,
page = read_cache_page(mapping, hash_x_index(hash, hash64),
ll_dir_filler, &lhash);
if (IS_ERR(page)) {
CERROR("read cache page: "DFID" at "LPU64": rc %ld\n",
CERROR("read cache page: "DFID" at %llu: rc %ld\n",
PFID(ll_inode2fid(dir)), hash, PTR_ERR(page));
GOTO(out_unlock, page);
}
@ -428,14 +428,14 @@ struct page *ll_get_dir_page(struct inode *dir, __u64 hash,
wait_on_page_locked(page);
(void)kmap(page);
if (!PageUptodate(page)) {
CERROR("page not updated: "DFID" at "LPU64": rc %d\n",
CERROR("page not updated: "DFID" at %llu: rc %d\n",
PFID(ll_inode2fid(dir)), hash, -5);
goto fail;
}
if (!PageChecked(page))
ll_check_page(dir, page);
if (PageError(page)) {
CERROR("page error: "DFID" at "LPU64": rc %d\n",
CERROR("page error: "DFID" at %llu: rc %d\n",
PFID(ll_inode2fid(dir)), hash, -5);
goto fail;
}
@ -452,10 +452,9 @@ hash_collision:
}
if (end == start) {
LASSERT(start == lhash);
CWARN("Page-wide hash collision: "LPU64"\n", end);
CWARN("Page-wide hash collision: %llu\n", end);
if (BITS_PER_LONG == 32 && hash64)
CWARN("Real page-wide hash collision at ["LPU64" "LPU64
"] with hash "LPU64"\n",
CWARN("Real page-wide hash collision at [%llu %llu] with hash %llu\n",
le64_to_cpu(dp->ldp_hash_start),
le64_to_cpu(dp->ldp_hash_end), hash);
/*

10
drivers/staging/lustre/lustre/llite/file.c
View File

@ -471,7 +471,7 @@ void ll_ioepoch_open(struct ll_inode_info *lli, __u64 ioepoch)
{
if (ioepoch && lli->lli_ioepoch != ioepoch) {
lli->lli_ioepoch = ioepoch;
CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n",
CDEBUG(D_INODE, "Epoch %llu opened on "DFID"\n",
ioepoch, PFID(&lli->lli_fid));
}
}
@ -1008,7 +1008,7 @@ int ll_merge_lvb(const struct lu_env *env, struct inode *inode)
if (lvb.lvb_mtime < attr->cat_mtime)
lvb.lvb_mtime = attr->cat_mtime;
CDEBUG(D_VFSTRACE, DFID" updating i_size "LPU64"\n",
CDEBUG(D_VFSTRACE, DFID" updating i_size %llu\n",
PFID(&lli->lli_fid), attr->cat_size);
cl_isize_write_nolock(inode, attr->cat_size);
@ -2708,9 +2708,9 @@ 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=%#llx, 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=%lu, pid=%u, flags=%#llx, mode=%u, start=%llu, end=%llu\n",
inode->i_ino, 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);

2
drivers/staging/lustre/lustre/llite/llite_close.c
View File

@ -170,7 +170,7 @@ void ll_ioepoch_close(struct inode *inode, struct md_op_data *op_data,
GOTO(out, 0);
}
}
CDEBUG(D_INODE, "Epoch "LPU64" closed on "DFID"\n",
CDEBUG(D_INODE, "Epoch %llu closed on "DFID"\n",
ll_i2info(inode)->lli_ioepoch, PFID(&lli->lli_fid));
op_data->op_flags |= MF_EPOCH_CLOSE;

16
drivers/staging/lustre/lustre/llite/llite_lib.c
View File

@ -1296,7 +1296,7 @@ static int ll_setattr_done_writing(struct inode *inode,
if (!S_ISREG(inode->i_mode))
return 0;
CDEBUG(D_INODE, "Epoch "LPU64" closed on "DFID" for truncate\n",
CDEBUG(D_INODE, "Epoch %llu closed on "DFID" for truncate\n",
op_data->op_ioepoch, PFID(&lli->lli_fid));
op_data->op_flags = MF_EPOCH_CLOSE;
@ -1377,7 +1377,7 @@ int ll_setattr_raw(struct dentry *dentry, struct iattr *attr, bool hsm_import)
* OST maximum object size and number of stripes. This
* needs another check in addition to the VFS check above. */
if (attr->ia_size > ll_file_maxbytes(inode)) {
CDEBUG(D_INODE,"file "DFID" too large %llu > "LPU64"\n",
CDEBUG(D_INODE,"file "DFID" too large %llu > %llu\n",
PFID(&lli->lli_fid), attr->ia_size,
ll_file_maxbytes(inode));
return -EFBIG;
@ -1567,7 +1567,7 @@ int ll_statfs_internal(struct super_block *sb, struct obd_statfs *osfs,
osfs->os_type = sb->s_magic;
CDEBUG(D_SUPER, "MDC blocks "LPU64"/"LPU64" objects "LPU64"/"LPU64"\n",
CDEBUG(D_SUPER, "MDC blocks %llu/%llu objects %llu/%llu\n",
osfs->os_bavail, osfs->os_blocks, osfs->os_ffree,osfs->os_files);
if (sbi->ll_flags & LL_SBI_LAZYSTATFS)
@ -1579,7 +1579,7 @@ int ll_statfs_internal(struct super_block *sb, struct obd_statfs *osfs,
return rc;
}
CDEBUG(D_SUPER, "OSC blocks "LPU64"/"LPU64" objects "LPU64"/"LPU64"\n",
CDEBUG(D_SUPER, "OSC blocks %llu/%llu objects %llu/%llu\n",
obd_osfs.os_bavail, obd_osfs.os_blocks, obd_osfs.os_ffree,
obd_osfs.os_files);
@ -1606,7 +1606,7 @@ int ll_statfs(struct dentry *de, struct kstatfs *sfs)
struct obd_statfs osfs;
int rc;
CDEBUG(D_VFSTRACE, "VFS Op: at "LPU64" jiffies\n", get_jiffies_64());
CDEBUG(D_VFSTRACE, "VFS Op: at %llu jiffies\n", get_jiffies_64());
ll_stats_ops_tally(ll_s2sbi(sb), LPROC_LL_STAFS, 1);
/* Some amount of caching on the client is allowed */
@ -1699,9 +1699,9 @@ void ll_update_inode(struct inode *inode, struct lustre_md *md)
}
if (body->valid & OBD_MD_FLMTIME) {
if (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 ino %lu mtime from %lu to %llu\n",
inode->i_ino, LTIME_S(inode->i_mtime),
body->mtime);
LTIME_S(inode->i_mtime) = body->mtime;
}
lli->lli_lvb.lvb_mtime = body->mtime;

2
drivers/staging/lustre/lustre/llite/llite_mmap.c
View File

@ -449,7 +449,7 @@ int ll_teardown_mmaps(struct address_space *mapping, __u64 first, __u64 last)
{
int rc = -ENOENT;
LASSERTF(last > first, "last "LPU64" first "LPU64"\n", last, first);
LASSERTF(last > first, "last %llu first %llu\n", last, first);
if (mapping_mapped(mapping)) {
rc = 0;
unmap_mapping_range(mapping, first + PAGE_CACHE_SIZE - 1,

10
drivers/staging/lustre/lustre/llite/lproc_llite.c
View File

@ -82,7 +82,7 @@ static int ll_kbytestotal_seq_show(struct seq_file *m, void *v)
while (blk_size >>= 1)
result <<= 1;
rc = seq_printf(m, LPU64"\n", result);
rc = seq_printf(m, "%llu\n", result);
}
return rc;
}
@ -105,7 +105,7 @@ static int ll_kbytesfree_seq_show(struct seq_file *m, void *v)
while (blk_size >>= 1)
result <<= 1;
rc = seq_printf(m, LPU64"\n", result);
rc = seq_printf(m, "%llu\n", result);
}
return rc;
}
@ -128,7 +128,7 @@ static int ll_kbytesavail_seq_show(struct seq_file *m, void *v)
while (blk_size >>= 1)
result <<= 1;
rc = seq_printf(m, LPU64"\n", result);
rc = seq_printf(m, "%llu\n", result);
}
return rc;
}
@ -145,7 +145,7 @@ static int ll_filestotal_seq_show(struct seq_file *m, void *v)
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
rc = seq_printf(m, LPU64"\n", osfs.os_files);
rc = seq_printf(m, "%llu\n", osfs.os_files);
return rc;
}
LPROC_SEQ_FOPS_RO(ll_filestotal);
@ -161,7 +161,7 @@ static int ll_filesfree_seq_show(struct seq_file *m, void *v)
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
rc = seq_printf(m, LPU64"\n", osfs.os_ffree);
rc = seq_printf(m, "%llu\n", osfs.os_ffree);
return rc;
}
LPROC_SEQ_FOPS_RO(ll_filesfree);

2
drivers/staging/lustre/lustre/llite/namei.c
View File

@ -758,7 +758,7 @@ 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",
CDEBUG(D_INODE, "setting ino %lu mtime from %lu to %llu\n",
inode->i_ino, LTIME_S(inode->i_mtime), body->mtime);
LTIME_S(inode->i_mtime) = body->mtime;
}

4
drivers/staging/lustre/lustre/llite/rw.c
View File

@ -601,7 +601,7 @@ stride_pg_count(pgoff_t st_off, unsigned long st_len, unsigned long st_pgs,
if (end_left > st_pgs)
end_left = st_pgs;
CDEBUG(D_READA, "start "LPU64", end "LPU64" start_left %lu end_left %lu \n",
CDEBUG(D_READA, "start %llu, end %llu start_left %lu end_left %lu \n",
start, end, start_left, end_left);
if (start == end)
@ -1013,7 +1013,7 @@ void ras_update(struct ll_sb_info *sbi, struct inode *inode,
kms_pages = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
PAGE_CACHE_SHIFT;
CDEBUG(D_READA, "kmsp "LPU64" mwp %lu mp %lu\n", kms_pages,
CDEBUG(D_READA, "kmsp %llu mwp %lu mp %lu\n", kms_pages,
ra->ra_max_read_ahead_whole_pages, ra->ra_max_pages_per_file);
if (kms_pages &&

22
drivers/staging/lustre/lustre/llite/statahead.c
View File

@ -206,7 +206,7 @@ ll_sa_entry_alloc(struct ll_statahead_info *sai, __u64 index,
if (unlikely(entry == NULL))
return ERR_PTR(-ENOMEM);
CDEBUG(D_READA, "alloc sa entry %.*s(%p) index "LPU64"\n",
CDEBUG(D_READA, "alloc sa entry %.*s(%p) index %llu\n",
len, name, entry, index);
entry->se_index = index;
@ -325,7 +325,7 @@ static void ll_sa_entry_put(struct ll_statahead_info *sai,
struct ll_sa_entry *entry)
{
if (atomic_dec_and_test(&entry->se_refcount)) {
CDEBUG(D_READA, "free sa entry %.*s(%p) index "LPU64"\n",
CDEBUG(D_READA, "free sa entry %.*s(%p) index %llu\n",
entry->se_qstr.len, entry->se_qstr.name, entry,
entry->se_index);
@ -528,8 +528,8 @@ static void ll_sai_put(struct ll_statahead_info *sai)
spin_unlock(&lli->lli_sa_lock);
if (sai->sai_sent > sai->sai_replied)
CDEBUG(D_READA,"statahead for dir "DFID" does not "
"finish: [sent:"LPU64"] [replied:"LPU64"]\n",
CDEBUG(D_READA,"statahead for dir "DFID
" does not finish: [sent:%llu] [replied:%llu]\n",
PFID(&lli->lli_fid),
sai->sai_sent, sai->sai_replied);
@ -595,7 +595,7 @@ static void ll_agl_trigger(struct inode *inode, struct ll_statahead_info *sai)
}
CDEBUG(D_READA, "Handling (init) async glimpse: inode = "
DFID", idx = "LPU64"\n", PFID(&lli->lli_fid), index);
DFID", idx = %llu\n", PFID(&lli->lli_fid), index);
cl_agl(inode);
lli->lli_agl_index = 0;
@ -603,7 +603,7 @@ static void ll_agl_trigger(struct inode *inode, struct ll_statahead_info *sai)
up_write(&lli->lli_glimpse_sem);
CDEBUG(D_READA, "Handled (init) async glimpse: inode= "
DFID", idx = "LPU64", rc = %d\n",
DFID", idx = %llu, rc = %d\n",
PFID(&lli->lli_fid), index, rc);
iput(inode);
@ -1081,8 +1081,7 @@ static int ll_statahead_thread(void *arg)
if (IS_ERR(page)) {
rc = PTR_ERR(page);
CDEBUG(D_READA, "error reading dir "DFID" at "LPU64
"/"LPU64": [rc %d] [parent %u]\n",
CDEBUG(D_READA, "error reading dir "DFID" at %llu/%llu: [rc %d] [parent %u]\n",
PFID(ll_inode2fid(dir)), pos, sai->sai_index,
rc, plli->lli_opendir_pid);
GOTO(out, rc);
@ -1362,8 +1361,7 @@ static int is_first_dirent(struct inode *dir, struct dentry *dentry)
struct ll_inode_info *lli = ll_i2info(dir);
rc = PTR_ERR(page);
CERROR("error reading dir "DFID" at "LPU64": "
"[rc %d] [parent %u]\n",
CERROR("error reading dir "DFID" at %llu: [rc %d] [parent %u]\n",
PFID(ll_inode2fid(dir)), pos,
rc, lli->lli_opendir_pid);
break;
@ -1479,8 +1477,8 @@ ll_sai_unplug(struct ll_statahead_info *sai, struct ll_sa_entry *entry)
if (sa_low_hit(sai) && thread_is_running(thread)) {
atomic_inc(&sbi->ll_sa_wrong);
CDEBUG(D_READA, "Statahead for dir "DFID" hit "
"ratio too low: hit/miss "LPU64"/"LPU64
", sent/replied "LPU64"/"LPU64", stopping "
"ratio too low: hit/miss %llu/%llu"
", sent/replied %llu/%llu, stopping "
"statahead thread\n",
PFID(&lli->lli_fid), sai->sai_hit,
sai->sai_miss, sai->sai_sent,

2
drivers/staging/lustre/lustre/lmv/lmv_obd.c
View File

@ -735,7 +735,7 @@ repeat_fid2path:
*ptr = '/';
}
CDEBUG(D_INFO, "%s: get path %s "DFID" rec: "LPU64" ln: %u\n",
CDEBUG(D_INFO, "%s: get path %s "DFID" rec: %llu ln: %u\n",
tgt->ltd_exp->exp_obd->obd_name,
gf->gf_path, PFID(&gf->gf_fid), gf->gf_recno,
gf->gf_linkno);

6
drivers/staging/lustre/lustre/lov/lov_io.c
View File

@ -398,7 +398,7 @@ static int lov_io_iter_init(const struct lu_env *env,
start, end);
rc = cl_io_iter_init(sub->sub_env, sub->sub_io);
lov_sub_put(sub);
CDEBUG(D_VFSTRACE, "shrink: %d ["LPU64", "LPU64")\n",
CDEBUG(D_VFSTRACE, "shrink: %d [%llu, %llu)\n",
stripe, start, end);
} else
rc = PTR_ERR(sub);
@ -436,8 +436,8 @@ static int lov_io_rw_iter_init(const struct lu_env *env,
next) - io->u.ci_rw.crw_pos;
lio->lis_pos = io->u.ci_rw.crw_pos;
lio->lis_endpos = io->u.ci_rw.crw_pos + io->u.ci_rw.crw_count;
CDEBUG(D_VFSTRACE, "stripe: "LPU64" chunk: ["LPU64", "LPU64") "
LPU64"\n", (__u64)start, lio->lis_pos, lio->lis_endpos,
CDEBUG(D_VFSTRACE, "stripe: %llu chunk: [%llu, %llu) %llu\n",
(__u64)start, lio->lis_pos, lio->lis_endpos,
(__u64)lio->lis_io_endpos);
}
/*

27
drivers/staging/lustre/lustre/lov/lov_merge.c
View File

@ -61,10 +61,9 @@ int lov_merge_lvb_kms(struct lov_stripe_md *lsm,
assert_spin_locked(&lsm->lsm_lock);
LASSERT(lsm->lsm_lock_owner == current_pid());
CDEBUG(D_INODE, "MDT ID "DOSTID" initial value: s="LPU64" m="LPU64
" a="LPU64" c="LPU64" b="LPU64"\n", POSTID(&lsm->lsm_oi),
lvb->lvb_size, lvb->lvb_mtime, lvb->lvb_atime, lvb->lvb_ctime,
lvb->lvb_blocks);
CDEBUG(D_INODE, "MDT ID "DOSTID" initial value: s=%llu m=%llu a=%llu c=%llu b=%llu\n",
POSTID(&lsm->lsm_oi), lvb->lvb_size, lvb->lvb_mtime,
lvb->lvb_atime, lvb->lvb_ctime, lvb->lvb_blocks);
for (i = 0; i < lsm->lsm_stripe_count; i++) {
struct lov_oinfo *loi = lsm->lsm_oinfo[i];
obd_size lov_size, tmpsize;
@ -94,11 +93,11 @@ int lov_merge_lvb_kms(struct lov_stripe_md *lsm,
if (loi->loi_lvb.lvb_ctime > current_ctime)
current_ctime = loi->loi_lvb.lvb_ctime;
CDEBUG(D_INODE, "MDT ID "DOSTID" on OST[%u]: s="LPU64" m="LPU64
" a="LPU64" c="LPU64" b="LPU64"\n", POSTID(&lsm->lsm_oi),
loi->loi_ost_idx, loi->loi_lvb.lvb_size,
loi->loi_lvb.lvb_mtime, loi->loi_lvb.lvb_atime,
loi->loi_lvb.lvb_ctime, loi->loi_lvb.lvb_blocks);
CDEBUG(D_INODE, "MDT ID "DOSTID" on OST[%u]: s=%llu m=%llu a=%llu c=%llu b=%llu\n",
POSTID(&lsm->lsm_oi), loi->loi_ost_idx,
loi->loi_lvb.lvb_size, loi->loi_lvb.lvb_mtime,
loi->loi_lvb.lvb_atime, loi->loi_lvb.lvb_ctime,
loi->loi_lvb.lvb_blocks);
}
*kms_place = kms;
@ -131,9 +130,9 @@ int lov_merge_lvb(struct obd_export *exp,
if (kms_only)
lvb->lvb_size = kms;
CDEBUG(D_INODE, "merged for ID "DOSTID" s="LPU64" m="LPU64" a="LPU64
" c="LPU64" b="LPU64"\n", POSTID(&lsm->lsm_oi), lvb->lvb_size,
lvb->lvb_mtime, lvb->lvb_atime, lvb->lvb_ctime, lvb->lvb_blocks);
CDEBUG(D_INODE, "merged for ID "DOSTID" s=%llu m=%llu a=%llu c=%llu b=%llu\n",
POSTID(&lsm->lsm_oi), lvb->lvb_size, lvb->lvb_mtime,
lvb->lvb_atime, lvb->lvb_ctime, lvb->lvb_blocks);
return rc;
}
@ -153,7 +152,7 @@ int lov_adjust_kms(struct obd_export *exp, struct lov_stripe_md *lsm,
struct lov_oinfo *loi = lsm->lsm_oinfo[stripe];
kms = lov_size_to_stripe(lsm, size, stripe);
CDEBUG(D_INODE,
"stripe %d KMS %sing "LPU64"->"LPU64"\n",
"stripe %d KMS %sing %llu->%llu\n",
stripe, kms > loi->loi_kms ? "increase":"shrink",
loi->loi_kms, kms);
loi_kms_set(loi, loi->loi_lvb.lvb_size = kms);
@ -166,7 +165,7 @@ int lov_adjust_kms(struct obd_export *exp, struct lov_stripe_md *lsm,
kms = lov_size_to_stripe(lsm, size, stripe);
loi = lsm->lsm_oinfo[stripe];
CDEBUG(D_INODE, "stripe %d KMS %sincreasing "LPU64"->"LPU64"\n",
CDEBUG(D_INODE, "stripe %d KMS %sincreasing %llu->%llu\n",
stripe, kms > loi->loi_kms ? "" : "not ", loi->loi_kms, kms);
if (kms > loi->loi_kms)
loi_kms_set(loi, kms);

8
drivers/staging/lustre/lustre/lov/lov_obd.c
View File

@ -727,8 +727,7 @@ void lov_fix_desc_stripe_size(__u64 *val)
*val = LOV_DESC_STRIPE_SIZE_DEFAULT;
} else if (*val & (LOV_MIN_STRIPE_SIZE - 1)) {
*val &= ~(LOV_MIN_STRIPE_SIZE - 1);
LCONSOLE_WARN("Changing default stripe size to "LPU64" (a "
"multiple of %u)\n",
LCONSOLE_WARN("Changing default stripe size to %llu (a multiple of %u)\n",
*val, LOV_MIN_STRIPE_SIZE);
}
}
@ -2636,9 +2635,8 @@ static int lov_extent_calc(struct obd_export *exp, struct lov_stripe_md *lsm,
lov_do_div64(start, ssize);
start = start * ssize;
CDEBUG(D_DLMTRACE, "offset "LPU64", stripe %u, start "LPU64
", end "LPU64"\n", *offset, ssize, start,
start + ssize - 1);
CDEBUG(D_DLMTRACE, "offset %llu, stripe %u, start %llu, end %llu\n",
*offset, ssize, start, start + ssize - 1);
if (cmd == OBD_CALC_STRIPE_END) {
*offset = start + ssize - 1;
} else if (cmd == OBD_CALC_STRIPE_START) {

2
drivers/staging/lustre/lustre/lov/lov_offset.c
View File

@ -223,7 +223,7 @@ int lov_stripe_intersects(struct lov_stripe_md *lsm, int stripeno,
start_side = lov_stripe_offset(lsm, start, stripeno, obd_start);
end_side = lov_stripe_offset(lsm, end, stripeno, obd_end);
CDEBUG(D_INODE, "["LPU64"->"LPU64"] -> [(%d) "LPU64"->"LPU64" (%d)]\n",
CDEBUG(D_INODE, "[%llu->%llu] -> [(%d) %llu->%llu (%d)]\n",
start, end, start_side, *obd_start, *obd_end, end_side);
/* this stripe doesn't intersect the file extent when neither

2
drivers/staging/lustre/lustre/lov/lov_request.c
View File

@ -1076,7 +1076,7 @@ int lov_prep_setattr_set(struct obd_export *exp, struct obd_info *oinfo,
if (off < 0 && req->rq_oi.oi_oa->o_size)
req->rq_oi.oi_oa->o_size--;
CDEBUG(D_INODE, "stripe %d has size "LPU64"/"LPU64"\n",
CDEBUG(D_INODE, "stripe %d has size %llu/%llu\n",
i, req->rq_oi.oi_oa->o_size,
oinfo->oi_oa->o_size);
}

4
drivers/staging/lustre/lustre/lov/lproc_lov.c
View File

@ -48,7 +48,7 @@ static int lov_stripesize_seq_show(struct seq_file *m, void *v)
LASSERT(dev != NULL);
desc = &dev->u.lov.desc;
return seq_printf(m, LPU64"\n", desc->ld_default_stripe_size);
return seq_printf(m, "%llu\n", desc->ld_default_stripe_size);
}
static ssize_t lov_stripesize_seq_write(struct file *file, const char *buffer,
@ -78,7 +78,7 @@ static int lov_stripeoffset_seq_show(struct seq_file *m, void *v)
LASSERT(dev != NULL);
desc = &dev->u.lov.desc;
return seq_printf(m, LPU64"\n", desc->ld_default_stripe_offset);
return seq_printf(m, "%llu\n", desc->ld_default_stripe_offset);
}
static ssize_t lov_stripeoffset_seq_write(struct file *file, const char *buffer,

12
drivers/staging/lustre/lustre/mdc/mdc_request.c
View File

@ -136,7 +136,7 @@ static int send_getstatus(struct obd_import *imp, struct lu_fid *rootfid,
*rootfid = body->fid1;
CDEBUG(D_NET,
"root fid="DFID", last_committed="LPU64"\n",
"root fid="DFID", last_committed=%llu\n",
PFID(rootfid),
lustre_msg_get_last_committed(req->rq_repmsg));
out:
@ -1182,7 +1182,7 @@ static int mdc_ioc_fid2path(struct obd_export *exp, struct getinfo_fid2path *gf)
memcpy(key, KEY_FID2PATH, sizeof(KEY_FID2PATH));
memcpy(key + cfs_size_round(sizeof(KEY_FID2PATH)), gf, sizeof(*gf));
CDEBUG(D_IOCTL, "path get "DFID" from "LPU64" #%d\n",
CDEBUG(D_IOCTL, "path get "DFID" from %llu #%d\n",
PFID(&gf->gf_fid), gf->gf_recno, gf->gf_linkno);
if (!fid_is_sane(&gf->gf_fid))
@ -1200,7 +1200,7 @@ static int mdc_ioc_fid2path(struct obd_export *exp, struct getinfo_fid2path *gf)
else if (vallen > sizeof(*gf) + gf->gf_pathlen)
GOTO(out, rc = -EOVERFLOW);
CDEBUG(D_IOCTL, "path get "DFID" from "LPU64" #%d\n%s\n",
CDEBUG(D_IOCTL, "path get "DFID" from %llu #%d\n%s\n",
PFID(&gf->gf_fid), gf->gf_recno, gf->gf_linkno, gf->gf_path);
out:
@ -1515,12 +1515,12 @@ static int changelog_kkuc_cb(const struct lu_env *env, struct llog_handle *llh,
if (rec->cr.cr_index < cs->cs_startrec) {
/* Skip entries earlier than what we are interested in */
CDEBUG(D_CHANGELOG, "rec="LPU64" start="LPU64"\n",
CDEBUG(D_CHANGELOG, "rec=%llu start=%llu\n",
rec->cr.cr_index, cs->cs_startrec);
return 0;
}
CDEBUG(D_CHANGELOG, LPU64" %02d%-5s "LPU64" 0x%x t="DFID" p="DFID
CDEBUG(D_CHANGELOG, "%llu %02d%-5s %llu 0x%x t="DFID" p="DFID
" %.*s\n", rec->cr.cr_index, rec->cr.cr_type,
changelog_type2str(rec->cr.cr_type), rec->cr.cr_time,
rec->cr.cr_flags & CLF_FLAGMASK,
@ -1547,7 +1547,7 @@ static int mdc_changelog_send_thread(void *csdata)
struct kuc_hdr *kuch;
int rc;
CDEBUG(D_CHANGELOG, "changelog to fp=%p start "LPU64"\n",
CDEBUG(D_CHANGELOG, "changelog to fp=%p start %llu\n",
cs->cs_fp, cs->cs_startrec);
OBD_ALLOC(cs->cs_buf, KUC_CHANGELOG_MSG_MAXSIZE);

4
drivers/staging/lustre/lustre/obdclass/capa.c
View File

@ -411,8 +411,8 @@ void _debug_capa(struct lustre_capa *c,
va_list args;
va_start(args, fmt);
libcfs_debug_vmsg2(msgdata, fmt, args,
" capability@%p fid "DFID" opc "LPX64" uid "LPU64
" gid "LPU64" flags %u alg %d keyid %u timeout %u "
" capability@%p fid "DFID" opc "LPX64" uid %llu"
" gid %llu flags %u alg %d keyid %u timeout %u "
"expiry %u\n", c, PFID(capa_fid(c)), capa_opc(c),
capa_uid(c), capa_gid(c), capa_flags(c),
capa_alg(c), capa_keyid(c), capa_timeout(c),

2
drivers/staging/lustre/lustre/obdclass/cl_io.c
View File

@ -227,7 +227,7 @@ int cl_io_rw_init(const struct lu_env *env, struct cl_io *io,
LINVRNT(io->ci_obj != NULL);
LU_OBJECT_HEADER(D_VFSTRACE, env, &io->ci_obj->co_lu,
"io range: %u ["LPU64", "LPU64") %u %u\n",
"io range: %u [%llu, %llu) %u %u\n",
iot, (__u64)pos, (__u64)pos + count,
io->u.ci_rw.crw_nonblock, io->u.ci_wr.wr_append);
io->u.ci_rw.crw_pos = pos;

3
drivers/staging/lustre/lustre/obdclass/cl_object.c
View File

@ -295,8 +295,7 @@ int cl_object_glimpse(const struct lu_env *env, struct cl_object *obj,
}
}
LU_OBJECT_HEADER(D_DLMTRACE, env, lu_object_top(top),
"size: "LPU64" mtime: "LPU64" atime: "LPU64" "
"ctime: "LPU64" blocks: "LPU64"\n",
"size: %llu mtime: %llu atime: %llu ctime: %llu blocks: %llu\n",
lvb->lvb_size, lvb->lvb_mtime, lvb->lvb_atime,
lvb->lvb_ctime, lvb->lvb_blocks);
return result;

20
drivers/staging/lustre/lustre/obdclass/class_obd.c
View File

@ -141,11 +141,11 @@ int obd_alloc_fail(const void *ptr, const char *name, const char *type,
{
if (ptr == NULL ||
(cfs_rand() & OBD_ALLOC_FAIL_MASK) < obd_alloc_fail_rate) {
CERROR("%s%salloc of %s ("LPU64" bytes) failed at %s:%d\n",
CERROR("%s%salloc of %s (%llu bytes) failed at %s:%d\n",
ptr ? "force " :"", type, name, (__u64)size, file,
line);
CERROR(LPU64" total bytes and "LPU64" total pages "
"("LPU64" bytes) allocated by Lustre, "
CERROR("%llu total bytes and %llu total pages "
"(%llu bytes) allocated by Lustre, "
"%d total bytes by LNET\n",
obd_memory_sum(),
obd_pages_sum() << PAGE_CACHE_SHIFT,
@ -420,7 +420,7 @@ int obd_init_checks(void)
char buf[64];
int len, ret = 0;
CDEBUG(D_INFO, "LPU64=%s, LPD64=%s, LPX64=%s\n", LPU64, "%lld", LPX64);
CDEBUG(D_INFO, "LPU64=%s, LPD64=%s, LPX64=%s\n", "%llu", "%lld", LPX64);
CDEBUG(D_INFO, "OBD_OBJECT_EOF = "LPX64"\n", (__u64)OBD_OBJECT_EOF);
@ -450,11 +450,11 @@ int obd_init_checks(void)
return -EOVERFLOW;
}
if (do_div(div64val, 256) != (u64val & 255)) {
CERROR("do_div("LPX64",256) != "LPU64"\n", u64val, u64val &255);
CERROR("do_div("LPX64",256) != %llu\n", u64val, u64val &255);
return -EOVERFLOW;
}
if (u64val >> 8 != div64val) {
CERROR("do_div("LPX64",256) "LPU64" != "LPU64"\n",
CERROR("do_div("LPX64",256) %llu != %llu\n",
u64val, div64val, u64val >> 8);
return -EOVERFLOW;
}
@ -463,7 +463,7 @@ int obd_init_checks(void)
CWARN("LPX64 wrong length! strlen(%s)=%d != 18\n", buf, len);
ret = -EINVAL;
}
len = snprintf(buf, sizeof(buf), LPU64, u64val);
len = snprintf(buf, sizeof(buf), "%llu", u64val);
if (len != 20) {
CWARN("LPU64 wrong length! strlen(%s)=%d != 20\n", buf, len);
ret = -EINVAL;
@ -474,7 +474,7 @@ int obd_init_checks(void)
ret = -EINVAL;
}
if ((u64val & ~CFS_PAGE_MASK) >= PAGE_CACHE_SIZE) {
CWARN("mask failed: u64val "LPU64" >= "LPU64"\n", u64val,
CWARN("mask failed: u64val %llu >= %llu\n", u64val,
(__u64)PAGE_CACHE_SIZE);
ret = -EINVAL;
}
@ -662,10 +662,10 @@ static void cleanup_obdclass(void)
lprocfs_free_stats(&obd_memory);
CDEBUG((memory_leaked) ? D_ERROR : D_INFO,
"obd_memory max: "LPU64", leaked: "LPU64"\n",
"obd_memory max: %llu, leaked: %llu\n",
memory_max, memory_leaked);
CDEBUG((pages_leaked) ? D_ERROR : D_INFO,
"obd_memory_pages max: "LPU64", leaked: "LPU64"\n",
"obd_memory_pages max: %llu, leaked: %llu\n",
pages_max, pages_leaked);
}

8
drivers/staging/lustre/lustre/obdclass/debug.c
View File

@ -84,24 +84,24 @@ int block_debug_check(char *who, void *addr, int end, __u64 off, __u64 id)
ne_off = le64_to_cpu (off);
id = le64_to_cpu (id);
if (memcmp(addr, (char *)&ne_off, LPDS)) {
CDEBUG(D_ERROR, "%s: id "LPX64" offset "LPU64" off: "LPX64" != "
CDEBUG(D_ERROR, "%s: id "LPX64" offset %llu off: "LPX64" != "
LPX64"\n", who, id, off, *(__u64 *)addr, ne_off);
err = -EINVAL;
}
if (memcmp(addr + LPDS, (char *)&id, LPDS)) {
CDEBUG(D_ERROR, "%s: id "LPX64" offset "LPU64" id: "LPX64" != "LPX64"\n",
CDEBUG(D_ERROR, "%s: id "LPX64" offset %llu id: "LPX64" != "LPX64"\n",
who, id, off, *(__u64 *)(addr + LPDS), id);
err = -EINVAL;
}
addr += end - LPDS - LPDS;
if (memcmp(addr, (char *)&ne_off, LPDS)) {
CDEBUG(D_ERROR, "%s: id "LPX64" offset "LPU64" end off: "LPX64" != "
CDEBUG(D_ERROR, "%s: id "LPX64" offset %llu end off: "LPX64" != "
LPX64"\n", who, id, off, *(__u64 *)addr, ne_off);
err = -EINVAL;
}
if (memcmp(addr + LPDS, (char *)&id, LPDS)) {
CDEBUG(D_ERROR, "%s: id "LPX64" offset "LPU64" end id: "LPX64" != "
CDEBUG(D_ERROR, "%s: id "LPX64" offset %llu end id: "LPX64" != "
LPX64"\n", who, id, off, *(__u64 *)(addr + LPDS), id);
err = -EINVAL;
}

10
drivers/staging/lustre/lustre/obdclass/dt_object.c
View File

@ -963,7 +963,7 @@ int lprocfs_dt_rd_kbytestotal(char *page, char **start, off_t off,
result <<= 1;
*eof = 1;
rc = snprintf(page, count, LPU64"\n", result);
rc = snprintf(page, count, "%llu\n", result);
}
return rc;
@ -985,7 +985,7 @@ int lprocfs_dt_rd_kbytesfree(char *page, char **start, off_t off,
result <<= 1;
*eof = 1;
rc = snprintf(page, count, LPU64"\n", result);
rc = snprintf(page, count, "%llu\n", result);
}
return rc;
@ -1007,7 +1007,7 @@ int lprocfs_dt_rd_kbytesavail(char *page, char **start, off_t off,
result <<= 1;
*eof = 1;
rc = snprintf(page, count, LPU64"\n", result);
rc = snprintf(page, count, "%llu\n", result);
}
return rc;
@ -1023,7 +1023,7 @@ int lprocfs_dt_rd_filestotal(char *page, char **start, off_t off,
int rc = dt_statfs(NULL, dt, &osfs);
if (rc == 0) {
*eof = 1;
rc = snprintf(page, count, LPU64"\n", osfs.os_files);
rc = snprintf(page, count, "%llu\n", osfs.os_files);
}
return rc;
@ -1039,7 +1039,7 @@ int lprocfs_dt_rd_filesfree(char *page, char **start, off_t off,
int rc = dt_statfs(NULL, dt, &osfs);
if (rc == 0) {
*eof = 1;
rc = snprintf(page, count, LPU64"\n", osfs.os_ffree);
rc = snprintf(page, count, "%llu\n", osfs.os_ffree);
}
return rc;

2
drivers/staging/lustre/lustre/obdclass/genops.c
View File

@ -1493,7 +1493,7 @@ static void print_export_data(struct obd_export *exp, const char *status,
}
spin_unlock(&exp->exp_lock);
CDEBUG(D_HA, "%s: %s %p %s %s %d (%d %d %d) %d %d %d %d: %p %s "LPU64"\n",
CDEBUG(D_HA, "%s: %s %p %s %s %d (%d %d %d) %d %d %d %d: %p %s %llu\n",
exp->exp_obd->obd_name, status, exp, exp->exp_client_uuid.uuid,
obd_export_nid2str(exp), atomic_read(&exp->exp_refcount),
atomic_read(&exp->exp_rpc_count),

4
drivers/staging/lustre/lustre/obdclass/linux/linux-obdo.c
View File

@ -151,7 +151,7 @@ void obdo_refresh_inode(struct inode *dst, struct obdo *src, obd_flag valid)
if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
CDEBUG(D_INODE,
"valid "LPX64", cur time %lu/%lu, new "LPU64"/"LPU64"\n",
"valid "LPX64", cur time %lu/%lu, new %llu/%llu\n",
src->o_valid, LTIME_S(dst->i_mtime),
LTIME_S(dst->i_ctime), src->o_mtime, src->o_ctime);
@ -190,7 +190,7 @@ void obdo_to_inode(struct inode *dst, struct obdo *src, obd_flag valid)
if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
CDEBUG(D_INODE,
"valid "LPX64", cur time %lu/%lu, new "LPU64"/"LPU64"\n",
"valid "LPX64", cur time %lu/%lu, new %llu/%llu\n",
src->o_valid, LTIME_S(dst->i_mtime),
LTIME_S(dst->i_ctime), src->o_mtime, src->o_ctime);

8
drivers/staging/lustre/lustre/obdclass/linux/linux-sysctl.c
View File

@ -103,7 +103,7 @@ int proc_memory_alloc(struct ctl_table *table, int write, void __user *buffer,
if (write)
return -EINVAL;
len = snprintf(buf, sizeof(buf), LPU64"\n", obd_memory_sum());
len = snprintf(buf, sizeof(buf), "%llu\n", obd_memory_sum());
if (len > *lenp)
len = *lenp;
buf[len] = '\0';
@ -127,7 +127,7 @@ int proc_pages_alloc(struct ctl_table *table, int write, void __user *buffer,
if (write)
return -EINVAL;
len = snprintf(buf, sizeof(buf), LPU64"\n", obd_pages_sum());
len = snprintf(buf, sizeof(buf), "%llu\n", obd_pages_sum());
if (len > *lenp)
len = *lenp;
buf[len] = '\0';
@ -151,7 +151,7 @@ int proc_mem_max(struct ctl_table *table, int write, void __user *buffer,
if (write)
return -EINVAL;
len = snprintf(buf, sizeof(buf), LPU64"\n", obd_memory_max());
len = snprintf(buf, sizeof(buf), "%llu\n", obd_memory_max());
if (len > *lenp)
len = *lenp;
buf[len] = '\0';
@ -175,7 +175,7 @@ int proc_pages_max(struct ctl_table *table, int write, void __user *buffer,
if (write)
return -EINVAL;
len = snprintf(buf, sizeof(buf), LPU64"\n", obd_pages_max());
len = snprintf(buf, sizeof(buf), "%llu\n", obd_pages_max());
if (len > *lenp)
len = *lenp;
buf[len] = '\0';

22
drivers/staging/lustre/lustre/obdclass/llog_lvfs.c
View File

@ -389,7 +389,7 @@ static int llog_lvfs_next_block(const struct lu_env *env,
if (len == 0 || len & (LLOG_CHUNK_SIZE - 1))
return -EINVAL;
CDEBUG(D_OTHER, "looking for log index %u (cur idx %u off "LPU64")\n",
CDEBUG(D_OTHER, "looking for log index %u (cur idx %u off %llu)\n",
next_idx, *cur_idx, *cur_offset);
while (*cur_offset < i_size_read(loghandle->lgh_file->f_dentry->d_inode)) {
@ -408,7 +408,7 @@ static int llog_lvfs_next_block(const struct lu_env *env,
cur_offset);
if (rc < 0) {
CERROR("Cant read llog block at log id "DOSTID
"/%u offset "LPU64"\n",
"/%u offset %llu\n",
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen,
*cur_offset);
@ -426,8 +426,8 @@ static int llog_lvfs_next_block(const struct lu_env *env,
return 0;
if (rc < sizeof(*tail)) {
CERROR("Invalid llog block at log id "DOSTID"/%u offset"
LPU64"\n", POSTID(&loghandle->lgh_id.lgl_oi),
CERROR("Invalid llog block at log id "DOSTID"/%u offset%llu\n",
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, *cur_offset);
return -EINVAL;
}
@ -451,8 +451,8 @@ static int llog_lvfs_next_block(const struct lu_env *env,
/* this shouldn't happen */
if (tail->lrt_index == 0) {
CERROR("Invalid llog tail at log id "DOSTID"/%u offset "
LPU64"\n", POSTID(&loghandle->lgh_id.lgl_oi),
CERROR("Invalid llog tail at log id "DOSTID"/%u offset %llu\n",
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, *cur_offset);
return -EINVAL;
}
@ -496,7 +496,7 @@ static int llog_lvfs_prev_block(const struct lu_env *env,
&cur_offset);
if (rc < 0) {
CERROR("Cant read llog block at log id "DOSTID
"/%u offset "LPU64"\n",
"/%u offset %llu\n",
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen,
cur_offset);
@ -510,8 +510,8 @@ static int llog_lvfs_prev_block(const struct lu_env *env,
return 0;
if (rc < sizeof(*tail)) {
CERROR("Invalid llog block at log id "DOSTID"/%u offset"
LPU64"\n", POSTID(&loghandle->lgh_id.lgl_oi),
CERROR("Invalid llog block at log id "DOSTID"/%u offset%llu\n",
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, cur_offset);
return -EINVAL;
}
@ -533,8 +533,8 @@ static int llog_lvfs_prev_block(const struct lu_env *env,
/* this shouldn't happen */
if (tail->lrt_index == 0) {
CERROR("Invalid llog tail at log id "DOSTID"/%u offset"
LPU64"\n", POSTID(&loghandle->lgh_id.lgl_oi),
CERROR("Invalid llog tail at log id "DOSTID"/%u offset%llu\n",
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, cur_offset);
return -EINVAL;
}

14
drivers/staging/lustre/lustre/obdclass/llog_osd.c
View File

@ -533,7 +533,7 @@ static int llog_osd_next_block(const struct lu_env *env,
if (len == 0 || len & (LLOG_CHUNK_SIZE - 1))
return -EINVAL;
CDEBUG(D_OTHER, "looking for log index %u (cur idx %u off "LPU64")\n",
CDEBUG(D_OTHER, "looking for log index %u (cur idx %u off %llu)\n",
next_idx, *cur_idx, *cur_offset);
LASSERT(loghandle);
@ -574,7 +574,7 @@ static int llog_osd_next_block(const struct lu_env *env,
dt_read_unlock(env, o);
if (rc < 0) {
CERROR("%s: can't read llog block from log "DFID
" offset "LPU64": rc = %d\n",
" offset %llu: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name,
PFID(lu_object_fid(&o->do_lu)), *cur_offset,
rc);
@ -592,7 +592,7 @@ static int llog_osd_next_block(const struct lu_env *env,
if (rc < sizeof(*tail)) {
CERROR("%s: invalid llog block at log id "DOSTID"/%u "
"offset "LPU64"\n",
"offset %llu\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, *cur_offset);
@ -618,7 +618,7 @@ static int llog_osd_next_block(const struct lu_env *env,
/* this shouldn't happen */
if (tail->lrt_index == 0) {
CERROR("%s: invalid llog tail at log id "DOSTID"/%u "
"offset "LPU64"\n",
"offset %llu\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, *cur_offset);
@ -687,7 +687,7 @@ static int llog_osd_prev_block(const struct lu_env *env,
dt_read_unlock(env, o);
if (rc < 0) {
CERROR("%s: can't read llog block from log "DFID
" offset "LPU64": rc = %d\n",
" offset %llu: rc = %d\n",
o->do_lu.lo_dev->ld_obd->obd_name,
PFID(lu_object_fid(&o->do_lu)), cur_offset, rc);
GOTO(out, rc);
@ -698,7 +698,7 @@ static int llog_osd_prev_block(const struct lu_env *env,
if (rc < sizeof(*tail)) {
CERROR("%s: invalid llog block at log id "DOSTID"/%u "
"offset "LPU64"\n",
"offset %llu\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, cur_offset);
@ -722,7 +722,7 @@ static int llog_osd_prev_block(const struct lu_env *env,
/* this shouldn't happen */
if (tail->lrt_index == 0) {
CERROR("%s: invalid llog tail at log id "DOSTID"/%u "
"offset "LPU64"\n",
"offset %llu\n",
o->do_lu.lo_dev->ld_obd->obd_name,
POSTID(&loghandle->lgh_id.lgl_oi),
loghandle->lgh_id.lgl_ogen, cur_offset);

2
drivers/staging/lustre/lustre/obdclass/local_storage.c
View File

@ -837,7 +837,7 @@ out_trans:
rc = dt_record_read(env, o, &dti->dti_lb, &dti->dti_off);
dt_read_unlock(env, o);
if (rc == 0 && le64_to_cpu(lastid) > OBIF_MAX_OID) {
CERROR("%s: bad oid "LPU64" is read from LAST_ID\n",
CERROR("%s: bad oid %llu is read from LAST_ID\n",
o->do_lu.lo_dev->ld_obd->obd_name,
le64_to_cpu(lastid));
rc = -EINVAL;

24
drivers/staging/lustre/lustre/obdclass/lprocfs_status.c
View File

@ -400,7 +400,7 @@ EXPORT_SYMBOL(lprocfs_wr_uint);
int lprocfs_rd_u64(struct seq_file *m, void *data)
{
return seq_printf(m, LPU64"\n", *(__u64 *)data);
return seq_printf(m, "%llu\n", *(__u64 *)data);
}
EXPORT_SYMBOL(lprocfs_rd_u64);
@ -476,7 +476,7 @@ int lprocfs_rd_kbytestotal(struct seq_file *m, void *data)
while (blk_size >>= 1)
result <<= 1;
rc = seq_printf(m, LPU64"\n", result);
rc = seq_printf(m, "%llu\n", result);
}
return rc;
}
@ -496,7 +496,7 @@ int lprocfs_rd_kbytesfree(struct seq_file *m, void *data)
while (blk_size >>= 1)
result <<= 1;
rc = seq_printf(m, LPU64"\n", result);
rc = seq_printf(m, "%llu\n", result);
}
return rc;
}
@ -516,7 +516,7 @@ int lprocfs_rd_kbytesavail(struct seq_file *m, void *data)
while (blk_size >>= 1)
result <<= 1;
rc = seq_printf(m, LPU64"\n", result);
rc = seq_printf(m, "%llu\n", result);
}
return rc;
}
@ -530,7 +530,7 @@ int lprocfs_rd_filestotal(struct seq_file *m, void *data)
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
rc = seq_printf(m, LPU64"\n", osfs.os_files);
rc = seq_printf(m, "%llu\n", osfs.os_files);
return rc;
}
@ -544,7 +544,7 @@ int lprocfs_rd_filesfree(struct seq_file *m, void *data)
cfs_time_shift_64(-OBD_STATFS_CACHE_SECONDS),
OBD_STATFS_NODELAY);
if (!rc)
rc = seq_printf(m, LPU64"\n", osfs.os_ffree);
rc = seq_printf(m, "%llu\n", osfs.os_ffree);
return rc;
}
EXPORT_SYMBOL(lprocfs_rd_filesfree);
@ -744,7 +744,7 @@ int lprocfs_rd_import(struct seq_file *m, void *data)
" inflight: %u\n"
" unregistering: %u\n"
" timeouts: %u\n"
" avg_waittime: "LPU64" %s\n",
" avg_waittime: %llu %s\n",
atomic_read(&imp->imp_inflight),
atomic_read(&imp->imp_unregistering),
atomic_read(&imp->imp_timeouts),
@ -766,9 +766,9 @@ int lprocfs_rd_import(struct seq_file *m, void *data)
seq_printf(m,
" transactions:\n"
" last_replay: "LPU64"\n"
" peer_committed: "LPU64"\n"
" last_checked: "LPU64"\n",
" last_replay: %llu\n"
" peer_committed: %llu\n"
" last_checked: %llu\n",
imp->imp_last_replay_transno,
imp->imp_peer_committed_transno,
imp->imp_last_transno_checked);
@ -785,7 +785,7 @@ int lprocfs_rd_import(struct seq_file *m, void *data)
ret.lc_sum = sum;
seq_printf(m,
" %s_data_averages:\n"
" bytes_per_rpc: "LPU64"\n",
" bytes_per_rpc: %llu\n",
rw ? "write" : "read",
ret.lc_sum);
}
@ -799,7 +799,7 @@ int lprocfs_rd_import(struct seq_file *m, void *data)
do_div(sum, ret.lc_count);
ret.lc_sum = sum;
seq_printf(m,
" %s_per_rpc: "LPU64"\n",
" %s_per_rpc: %llu\n",
header->lc_units, ret.lc_sum);
j = (int)ret.lc_sum;
if (j > 0)

2
drivers/staging/lustre/lustre/obdclass/obdo.c
View File

@ -252,7 +252,7 @@ void iattr_from_obdo(struct iattr *attr, struct obdo *oa, obd_flag valid)
valid &= oa->o_valid;
if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
CDEBUG(D_INODE, "valid "LPX64", new time "LPU64"/"LPU64"\n",
CDEBUG(D_INODE, "valid "LPX64", new time %llu/%llu\n",
oa->o_valid, oa->o_mtime, oa->o_ctime);
attr->ia_valid = 0;

6
drivers/staging/lustre/lustre/obdecho/echo.c
View File

@ -327,7 +327,7 @@ static int echo_map_nb_to_lb(struct obdo *oa, struct obd_ioobj *obj,
}
}
CDEBUG(D_PAGE, "$$$$ get page %p @ "LPU64" for %d\n",
CDEBUG(D_PAGE, "$$$$ get page %p @ %llu for %d\n",
res->page, res->lnb_file_offset, res->len);
if (cmd & OBD_BRW_READ)
@ -365,7 +365,7 @@ static int echo_finalize_lb(struct obdo *oa, struct obd_ioobj *obj,
void *addr;
if (page == NULL) {
CERROR("null page objid "LPU64":%p, buf %d/%d\n",
CERROR("null page objid %llu:%p, buf %d/%d\n",
ostid_id(&obj->ioo_oid), page, i,
obj->ioo_bufcnt);
return -EFAULT;
@ -373,7 +373,7 @@ static int echo_finalize_lb(struct obdo *oa, struct obd_ioobj *obj,
addr = kmap(page);
CDEBUG(D_PAGE, "$$$$ use page %p, addr %p@"LPU64"\n",
CDEBUG(D_PAGE, "$$$$ use page %p, addr %p@%llu\n",
res->page, addr, res->lnb_file_offset);
if (verify) {

2
drivers/staging/lustre/lustre/obdecho/echo_client.c
View File

@ -1430,7 +1430,7 @@ echo_copyin_lsm (struct echo_device *ed, struct lov_stripe_md *lsm,
static inline void echo_md_build_name(struct lu_name *lname, char *name,
__u64 id)
{
sprintf(name, LPU64, id);
sprintf(name, "%llu", id);
lname->ln_name = name;
lname->ln_namelen = strlen(name);
}

6
drivers/staging/lustre/lustre/osc/lproc_osc.c
View File

@ -693,11 +693,11 @@ static int osc_stats_seq_show(struct seq_file *seq, void *v)
seq_printf(seq, "snapshot_time: %lu.%lu (secs.usecs)\n",
now.tv_sec, (unsigned long)now.tv_usec);
seq_printf(seq, "lockless_write_bytes\t\t"LPU64"\n",
seq_printf(seq, "lockless_write_bytes\t\t%llu\n",
stats->os_lockless_writes);
seq_printf(seq, "lockless_read_bytes\t\t"LPU64"\n",
seq_printf(seq, "lockless_read_bytes\t\t%llu\n",
stats->os_lockless_reads);
seq_printf(seq, "lockless_truncate\t\t"LPU64"\n",
seq_printf(seq, "lockless_truncate\t\t%llu\n",
stats->os_lockless_truncates);
return 0;
}

6
drivers/staging/lustre/lustre/osc/osc_cache.c
View File

@ -2154,7 +2154,7 @@ int osc_prep_async_page(struct osc_object *osc, struct osc_page *ops,
INIT_LIST_HEAD(&oap->oap_rpc_item);
spin_lock_init(&oap->oap_lock);
CDEBUG(D_INFO, "oap %p page %p obj off "LPU64"\n",
CDEBUG(D_INFO, "oap %p page %p obj off %llu\n",
oap, page, oap->oap_obj_off);
return 0;
}
@ -2595,7 +2595,7 @@ again:
break;
}
OSC_EXTENT_DUMP(D_CACHE, ext, "try to trunc:"LPU64".\n", size);
OSC_EXTENT_DUMP(D_CACHE, ext, "try to trunc:%llu.\n", size);
osc_extent_get(ext);
if (ext->oe_state == OES_ACTIVE) {
@ -2656,7 +2656,7 @@ again:
LASSERT(oio->oi_trunc == NULL);
oio->oi_trunc = osc_extent_get(ext);
OSC_EXTENT_DUMP(D_CACHE, ext,
"trunc at "LPU64"\n", size);
"trunc at %llu\n", size);
}
osc_extent_put(env, ext);
}

4
drivers/staging/lustre/lustre/osc/osc_io.c
View File

@ -204,7 +204,7 @@ static void osc_page_touch_at(const struct lu_env *env,
*
* here
*/
CDEBUG(D_INODE, "stripe KMS %sincreasing "LPU64"->"LPU64" "LPU64"\n",
CDEBUG(D_INODE, "stripe KMS %sincreasing %llu->%llu %llu\n",
kms > loi->loi_kms ? "" : "not ", loi->loi_kms, kms,
loi->loi_lvb.lvb_size);
@ -355,7 +355,7 @@ static int trunc_check_cb(const struct lu_env *env, struct cl_io *io,
if (oap->oap_cmd & OBD_BRW_WRITE &&
!list_empty(&oap->oap_pending_item))
CL_PAGE_DEBUG(D_ERROR, env, page, "exists " LPU64 "/%s.\n",
CL_PAGE_DEBUG(D_ERROR, env, page, "exists %llu/%s.\n",
start, current->comm);
{

11
drivers/staging/lustre/lustre/osc/osc_lock.c
View File

@ -369,20 +369,19 @@ static void osc_lock_lvb_update(const struct lu_env *env, struct osc_lock *olck,
if (size > dlmlock->l_policy_data.l_extent.end)
size = dlmlock->l_policy_data.l_extent.end + 1;
if (size >= oinfo->loi_kms) {
LDLM_DEBUG(dlmlock, "lock acquired, setting rss="LPU64
", kms="LPU64, lvb->lvb_size, size);
LDLM_DEBUG(dlmlock, "lock acquired, setting rss=%llu, kms=%llu",
lvb->lvb_size, size);
valid |= CAT_KMS;
attr->cat_kms = size;
} else {
LDLM_DEBUG(dlmlock, "lock acquired, setting rss="
LPU64"; leaving kms="LPU64", end="LPU64,
LDLM_DEBUG(dlmlock, "lock acquired, setting rss=%llu; leaving kms=%llu, end=%llu",
lvb->lvb_size, oinfo->loi_kms,
dlmlock->l_policy_data.l_extent.end);
}
ldlm_lock_allow_match_locked(dlmlock);
} else if (rc == -ENAVAIL && olck->ols_glimpse) {
CDEBUG(D_INODE, "glimpsed, setting rss="LPU64"; leaving"
" kms="LPU64"\n", lvb->lvb_size, oinfo->loi_kms);
CDEBUG(D_INODE, "glimpsed, setting rss=%llu; leaving kms=%llu\n",
lvb->lvb_size, oinfo->loi_kms);
} else
valid = 0;

8
drivers/staging/lustre/lustre/osc/osc_object.c
View File

@ -128,8 +128,7 @@ static void osc_object_free(const struct lu_env *env, struct lu_object *obj)
int osc_lvb_print(const struct lu_env *env, void *cookie,
lu_printer_t p, const struct ost_lvb *lvb)
{
return (*p)(env, cookie, "size: "LPU64" mtime: "LPU64" atime: "LPU64" "
"ctime: "LPU64" blocks: "LPU64,
return (*p)(env, cookie, "size: %llu mtime: %llu atime: %llu ctime: %llu blocks: %llu",
lvb->lvb_size, lvb->lvb_mtime, lvb->lvb_atime,
lvb->lvb_ctime, lvb->lvb_blocks);
}
@ -142,8 +141,7 @@ static int osc_object_print(const struct lu_env *env, void *cookie,
struct osc_async_rc *ar = &oinfo->loi_ar;
(*p)(env, cookie, "id: "DOSTID" "
"idx: %d gen: %d kms_valid: %u kms "LPU64" "
"rc: %d force_sync: %d min_xid: "LPU64" ",
"idx: %d gen: %d kms_valid: %u kms %llu rc: %d force_sync: %d min_xid: %llu ",
POSTID(&oinfo->loi_oi), oinfo->loi_ost_idx,
oinfo->loi_ost_gen, oinfo->loi_kms_valid, oinfo->loi_kms,
ar->ar_rc, ar->ar_force_sync, ar->ar_min_xid);
@ -179,7 +177,7 @@ int osc_attr_set(const struct lu_env *env, struct cl_object *obj,
if (valid & CAT_BLOCKS)
lvb->lvb_blocks = attr->cat_blocks;
if (valid & CAT_KMS) {
CDEBUG(D_CACHE, "set kms from "LPU64"to "LPU64"\n",
CDEBUG(D_CACHE, "set kms from %llu to %llu\n",
oinfo->loi_kms, (__u64)attr->cat_kms);
loi_kms_set(oinfo, attr->cat_kms);
}

2
drivers/staging/lustre/lustre/osc/osc_page.c
View File

@ -371,7 +371,7 @@ static int osc_page_print(const struct lu_env *env,
return (*printer)(env, cookie, LUSTRE_OSC_NAME"-page@%p: "
"1< %#x %d %u %s %s > "
"2< "LPU64" %u %u %#x %#x | %p %p %p > "
"2< %llu %u %u %#x %#x | %p %p %p > "
"3< %s %p %d %lu %d > "
"4< %d %d %d %lu %s | %s %s %s %s > "
"5< %s %s %s %s | %d %s | %d %s %s>\n",

30
drivers/staging/lustre/lustre/osc/osc_request.c
View File

@ -836,7 +836,7 @@ static void osc_announce_cached(struct client_obd *cli, struct obdo *oa,
oa->o_dropped = cli->cl_lost_grant;
cli->cl_lost_grant = 0;
client_obd_list_unlock(&cli->cl_loi_list_lock);
CDEBUG(D_CACHE,"dirty: "LPU64" undirty: %u dropped %u grant: "LPU64"\n",
CDEBUG(D_CACHE,"dirty: %llu undirty: %u dropped %u grant: %llu\n",
oa->o_dirty, oa->o_undirty, oa->o_dropped, oa->o_grant);
}
@ -859,7 +859,7 @@ static void __osc_update_grant(struct client_obd *cli, obd_size grant)
static void osc_update_grant(struct client_obd *cli, struct ost_body *body)
{
if (body->oa.o_valid & OBD_MD_FLGRANT) {
CDEBUG(D_CACHE, "got "LPU64" extra grant\n", body->oa.o_grant);
CDEBUG(D_CACHE, "got %llu extra grant\n", body->oa.o_grant);
__osc_update_grant(cli, body->oa.o_grant);
}
}
@ -1313,11 +1313,11 @@ static int osc_brw_prep_request(int cmd, struct client_obd *cli,struct obdo *oa,
ergo(i > 0 && i < page_count - 1,
poff == 0 && pg->count == PAGE_CACHE_SIZE) &&
ergo(i == page_count - 1, poff == 0)),
"i: %d/%d pg: %p off: "LPU64", count: %u\n",
"i: %d/%d pg: %p off: %llu, count: %u\n",
i, page_count, pg, pg->off, pg->count);
LASSERTF(i == 0 || pg->off > pg_prev->off,
"i %d p_c %u pg %p [pri %lu ind %lu] off "LPU64
" prev_pg %p [pri %lu ind %lu] off "LPU64"\n",
"i %d p_c %u pg %p [pri %lu ind %lu] off %llu"
" prev_pg %p [pri %lu ind %lu] off %llu\n",
i, page_count,
pg->pg, page_private(pg->pg), pg->pg->index, pg->off,
pg_prev->pg, page_private(pg_prev->pg),
@ -1452,7 +1452,7 @@ static int check_write_checksum(struct obdo *oa, const lnet_process_id_t *peer,
"likely false positive due to mmap IO (bug 11742)";
LCONSOLE_ERROR_MSG(0x132, "BAD WRITE CHECKSUM: %s: from %s inode "DFID
" object "DOSTID" extent ["LPU64"-"LPU64"]\n",
" object "DOSTID" extent [%llu-%llu]\n",
msg, libcfs_nid2str(peer->nid),
oa->o_valid & OBD_MD_FLFID ? oa->o_parent_seq : (__u64)0,
oa->o_valid & OBD_MD_FLFID ? oa->o_parent_oid : 0,
@ -1573,7 +1573,7 @@ static int osc_brw_fini_request(struct ptlrpc_request *req, int rc)
if (server_cksum != client_cksum) {
LCONSOLE_ERROR_MSG(0x133, "%s: BAD READ CHECKSUM: from "
"%s%s%s inode "DFID" object "DOSTID
" extent ["LPU64"-"LPU64"]\n",
" extent [%llu-%llu]\n",
req->rq_import->imp_obd->obd_name,
libcfs_nid2str(peer->nid),
via, router,
@ -1930,8 +1930,7 @@ static int brw_interpret(const struct lu_env *env,
client_should_resend(aa->aa_resends, aa->aa_cli)) {
rc = osc_brw_redo_request(req, aa, rc);
} else {
CERROR("%s: too many resent retries for object: "
""LPU64":"LPU64", rc = %d.\n",
CERROR("%s: too many resent retries for object: %llu:%llu, rc = %d.\n",
req->rq_import->imp_obd->obd_name,
POSTID(&aa->aa_oa->o_oi), rc);
}
@ -2321,7 +2320,7 @@ static int osc_enqueue_fini(struct ptlrpc_request *req, struct ost_lvb *lvb,
if ((intent != 0 && rc == ELDLM_LOCK_ABORTED && agl == 0) ||
(rc == 0)) {
*flags |= LDLM_FL_LVB_READY;
CDEBUG(D_INODE,"got kms "LPU64" blocks "LPU64" mtime "LPU64"\n",
CDEBUG(D_INODE,"got kms %llu blocks %llu mtime %llu\n",
lvb->lvb_size, lvb->lvb_blocks, lvb->lvb_mtime);
}
@ -2409,12 +2408,11 @@ void osc_update_enqueue(struct lustre_handle *lov_lockhp,
if (tmp > lock->l_policy_data.l_extent.end)
tmp = lock->l_policy_data.l_extent.end + 1;
if (tmp >= loi->loi_kms) {
LDLM_DEBUG(lock, "lock acquired, setting rss="LPU64
", kms="LPU64, loi->loi_lvb.lvb_size, tmp);
LDLM_DEBUG(lock, "lock acquired, setting rss=%llu, kms=%llu",
loi->loi_lvb.lvb_size, tmp);
loi_kms_set(loi, tmp);
} else {
LDLM_DEBUG(lock, "lock acquired, setting rss="
LPU64"; leaving kms="LPU64", end="LPU64,
LDLM_DEBUG(lock, "lock acquired, setting rss=%llu; leaving kms=%llu, end=%llu",
loi->loi_lvb.lvb_size, loi->loi_kms,
lock->l_policy_data.l_extent.end);
}
@ -2423,8 +2421,8 @@ void osc_update_enqueue(struct lustre_handle *lov_lockhp,
LASSERT(lock != NULL);
loi->loi_lvb = *lvb;
ldlm_lock_allow_match(lock);
CDEBUG(D_INODE, "glimpsed, setting rss="LPU64"; leaving"
" kms="LPU64"\n", loi->loi_lvb.lvb_size, loi->loi_kms);
CDEBUG(D_INODE, "glimpsed, setting rss=%llu; leaving kms=%llu\n",
loi->loi_lvb.lvb_size, loi->loi_kms);
rc = ELDLM_OK;
}

20
drivers/staging/lustre/lustre/ptlrpc/client.c
View File

@ -1451,7 +1451,7 @@ static int ptlrpc_send_new_req(struct ptlrpc_request *req)
}
CDEBUG(D_RPCTRACE, "Sending RPC pname:cluuid:pid:xid:nid:opc"
" %s:%s:%d:"LPU64":%s:%d\n", current_comm(),
" %s:%s:%d:%llu:%s:%d\n", current_comm(),
imp->imp_obd->obd_uuid.uuid,
lustre_msg_get_status(req->rq_reqmsg), req->rq_xid,
libcfs_nid2str(imp->imp_connection->c_peer.nid),
@ -1698,9 +1698,7 @@ int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set)
/* ensure previous bulk fails */
old_xid = req->rq_xid;
req->rq_xid = ptlrpc_next_xid();
CDEBUG(D_HA, "resend bulk "
"old x"LPU64
" new x"LPU64"\n",
CDEBUG(D_HA, "resend bulk old x%llu new x%llu\n",
old_xid, req->rq_xid);
}
}
@ -1831,7 +1829,7 @@ interpret:
CDEBUG(req->rq_reqmsg != NULL ? D_RPCTRACE : 0,
"Completed RPC pname:cluuid:pid:xid:nid:"
"opc %s:%s:%d:"LPU64":%s:%d\n",
"opc %s:%s:%d:%llu:%s:%d\n",
current_comm(), imp->imp_obd->obd_uuid.uuid,
lustre_msg_get_status(req->rq_reqmsg), req->rq_xid,
libcfs_nid2str(imp->imp_connection->c_peer.nid),
@ -2467,11 +2465,11 @@ void ptlrpc_free_committed(struct obd_import *imp)
if (imp->imp_peer_committed_transno == imp->imp_last_transno_checked &&
imp->imp_generation == imp->imp_last_generation_checked) {
CDEBUG(D_INFO, "%s: skip recheck: last_committed "LPU64"\n",
CDEBUG(D_INFO, "%s: skip recheck: last_committed %llu\n",
imp->imp_obd->obd_name, imp->imp_peer_committed_transno);
return;
}
CDEBUG(D_RPCTRACE, "%s: committing for last_committed "LPU64" gen %d\n",
CDEBUG(D_RPCTRACE, "%s: committing for last_committed %llu gen %d\n",
imp->imp_obd->obd_name, imp->imp_peer_committed_transno,
imp->imp_generation);
@ -2509,7 +2507,7 @@ void ptlrpc_free_committed(struct obd_import *imp)
continue;
}
DEBUG_REQ(D_INFO, req, "commit (last_committed "LPU64")",
DEBUG_REQ(D_INFO, req, "commit (last_committed %llu)",
imp->imp_peer_committed_transno);
free_req:
ptlrpc_free_request(req);
@ -2562,7 +2560,7 @@ void ptlrpc_resend_req(struct ptlrpc_request *req)
/* ensure previous bulk fails */
req->rq_xid = ptlrpc_next_xid();
CDEBUG(D_HA, "resend bulk old x"LPU64" new x"LPU64"\n",
CDEBUG(D_HA, "resend bulk old x%llu new x%llu\n",
old_xid, req->rq_xid);
}
ptlrpc_client_wake_req(req);
@ -2741,8 +2739,8 @@ static int ptlrpc_replay_interpret(const struct lu_env *env,
/* transaction number shouldn't be bigger than the latest replayed */
if (req->rq_transno > lustre_msg_get_transno(req->rq_reqmsg)) {
DEBUG_REQ(D_ERROR, req,
"Reported transno "LPU64" is bigger than the "
"replayed one: "LPU64, req->rq_transno,
"Reported transno %llu is bigger than the replayed one: %llu",
req->rq_transno,
lustre_msg_get_transno(req->rq_reqmsg));
GOTO(out, rc = -EINVAL);
}

2
drivers/staging/lustre/lustre/ptlrpc/events.c
View File

@ -337,7 +337,7 @@ void request_in_callback(lnet_event_t *ev)
INIT_LIST_HEAD(&req->rq_exp_list);
atomic_set(&req->rq_refcount, 1);
if (ev->type == LNET_EVENT_PUT)
CDEBUG(D_INFO, "incoming req@%p x"LPU64" msgsize %u\n",
CDEBUG(D_INFO, "incoming req@%p x%llu msgsize %u\n",
req, req->rq_xid, ev->mlength);
CDEBUG(D_RPCTRACE, "peer: %s\n", libcfs_id2str(req->rq_peer));

2
drivers/staging/lustre/lustre/ptlrpc/import.c
View File

@ -494,7 +494,7 @@ static int import_select_connection(struct obd_import *imp)
}
list_for_each_entry(conn, &imp->imp_conn_list, oic_item) {
CDEBUG(D_HA, "%s: connect to NID %s last attempt "LPU64"\n",
CDEBUG(D_HA, "%s: connect to NID %s last attempt %llu\n",
imp->imp_obd->obd_name,
libcfs_nid2str(conn->oic_conn->c_peer.nid),
conn->oic_last_attempt);

8
drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c
View File

@ -726,12 +726,12 @@ ptlrpc_lprocfs_svc_req_history_seek(struct ptlrpc_service_part *svcpt,
* be near the head), we shouldn't have to do long
* re-scans */
LASSERTF(srhi->srhi_seq == srhi->srhi_req->rq_history_seq,
"%s:%d: seek seq "LPU64", request seq "LPU64"\n",
"%s:%d: seek seq %llu, request seq %llu\n",
svcpt->scp_service->srv_name, svcpt->scp_cpt,
srhi->srhi_seq, srhi->srhi_req->rq_history_seq);
LASSERTF(!list_empty(&svcpt->scp_hist_reqs),
"%s:%d: seek offset "LPU64", request seq "LPU64", "
"last culled "LPU64"\n",
"%s:%d: seek offset %llu, request seq %llu, "
"last culled %llu\n",
svcpt->scp_service->srv_name, svcpt->scp_cpt,
seq, srhi->srhi_seq, svcpt->scp_hist_seq_culled);
e = &srhi->srhi_req->rq_history_list;
@ -932,7 +932,7 @@ static int ptlrpc_lprocfs_svc_req_history_show(struct seq_file *s, void *iter)
* must be just as careful as the service's request
* parser. Currently I only print stuff here I know is OK
* to look at coz it was set up in request_in_callback()!!! */
seq_printf(s, "%lld:%s:%s:x"LPU64":%d:%s:%ld:%lds(%+lds) ",
seq_printf(s, "%lld:%s:%s:x%llu:%d:%s:%ld:%lds(%+lds) ",
req->rq_history_seq, libcfs_nid2str(req->rq_self),
libcfs_id2str(req->rq_peer), req->rq_xid,
req->rq_reqlen, ptlrpc_rqphase2str(req),

11
drivers/staging/lustre/lustre/ptlrpc/niobuf.c
View File

@ -159,7 +159,7 @@ int ptlrpc_register_bulk(struct ptlrpc_request *req)
LASSERTF(!(desc->bd_registered &&
req->rq_send_state != LUSTRE_IMP_REPLAY) ||
xid != desc->bd_last_xid,
"registered: %d rq_xid: "LPU64" bd_last_xid: "LPU64"\n",
"registered: %d rq_xid: %llu bd_last_xid: %llu\n",
desc->bd_registered, xid, desc->bd_last_xid);
total_md = (desc->bd_iov_count + LNET_MAX_IOV - 1) / LNET_MAX_IOV;
@ -179,7 +179,7 @@ int ptlrpc_register_bulk(struct ptlrpc_request *req)
rc = LNetMEAttach(desc->bd_portal, peer, xid, 0,
LNET_UNLINK, LNET_INS_AFTER, &me_h);
if (rc != 0) {
CERROR("%s: LNetMEAttach failed x"LPU64"/%d: rc = %d\n",
CERROR("%s: LNetMEAttach failed x%llu/%d: rc = %d\n",
desc->bd_import->imp_obd->obd_name, xid,
posted_md, rc);
break;
@ -189,7 +189,7 @@ int ptlrpc_register_bulk(struct ptlrpc_request *req)
rc = LNetMDAttach(me_h, md, LNET_UNLINK,
&desc->bd_mds[posted_md]);
if (rc != 0) {
CERROR("%s: LNetMDAttach failed x"LPU64"/%d: rc = %d\n",
CERROR("%s: LNetMDAttach failed x%llu/%d: rc = %d\n",
desc->bd_import->imp_obd->obd_name, xid,
posted_md, rc);
rc2 = LNetMEUnlink(me_h);
@ -213,7 +213,7 @@ int ptlrpc_register_bulk(struct ptlrpc_request *req)
* infer the number of bulks that were prepared */
req->rq_xid = --xid;
LASSERTF(desc->bd_last_xid == (req->rq_xid & PTLRPC_BULK_OPS_MASK),
"bd_last_xid = x"LPU64", rq_xid = x"LPU64"\n",
"bd_last_xid = x%llu, rq_xid = x%llu\n",
desc->bd_last_xid, req->rq_xid);
spin_lock(&desc->bd_lock);
@ -619,8 +619,7 @@ int ptl_send_rpc(struct ptlrpc_request *request, int noreply)
GOTO(cleanup_me, rc = -ENOMEM);
}
CDEBUG(D_NET, "Setup reply buffer: %u bytes, xid "LPU64
", portal %u\n",
CDEBUG(D_NET, "Setup reply buffer: %u bytes, xid %llu, portal %u\n",
request->rq_repbuf_len, request->rq_xid,
request->rq_reply_portal);
}

8
drivers/staging/lustre/lustre/ptlrpc/nrs_fifo.c
View File

@ -174,9 +174,9 @@ struct ptlrpc_nrs_request * nrs_fifo_req_get(struct ptlrpc_nrs_policy *policy,
list_del_init(&nrq->nr_u.fifo.fr_list);
CDEBUG(D_RPCTRACE, "NRS start %s request from %s, seq: "LPU64
"\n", policy->pol_desc->pd_name,
libcfs_id2str(req->rq_peer), nrq->nr_u.fifo.fr_sequence);
CDEBUG(D_RPCTRACE, "NRS start %s request from %s, seq: %llu\n",
policy->pol_desc->pd_name, libcfs_id2str(req->rq_peer),
nrq->nr_u.fifo.fr_sequence);
}
return nrq;
@ -236,7 +236,7 @@ static void nrs_fifo_req_stop(struct ptlrpc_nrs_policy *policy,
struct ptlrpc_request *req = container_of(nrq, struct ptlrpc_request,
rq_nrq);
CDEBUG(D_RPCTRACE, "NRS stop %s request from %s, seq: "LPU64"\n",
CDEBUG(D_RPCTRACE, "NRS stop %s request from %s, seq: %llu\n",
policy->pol_desc->pd_name, libcfs_id2str(req->rq_peer),
nrq->nr_u.fifo.fr_sequence);
}

8
drivers/staging/lustre/lustre/ptlrpc/pack_generic.c
View File

@ -2140,8 +2140,8 @@ static void print_lum(struct lov_user_md *lum)
CDEBUG(D_OTHER, "lov_user_md %p:\n", lum);
CDEBUG(D_OTHER, "\tlmm_magic: %#x\n", lum->lmm_magic);
CDEBUG(D_OTHER, "\tlmm_pattern: %#x\n", lum->lmm_pattern);
CDEBUG(D_OTHER, "\tlmm_object_id: "LPU64"\n", lmm_oi_id(&lum->lmm_oi));
CDEBUG(D_OTHER, "\tlmm_object_gr: "LPU64"\n", lmm_oi_seq(&lum->lmm_oi));
CDEBUG(D_OTHER, "\tlmm_object_id: %llu\n", lmm_oi_id(&lum->lmm_oi));
CDEBUG(D_OTHER, "\tlmm_object_gr: %llu\n", lmm_oi_seq(&lum->lmm_oi));
CDEBUG(D_OTHER, "\tlmm_stripe_size: %#x\n", lum->lmm_stripe_size);
CDEBUG(D_OTHER, "\tlmm_stripe_count: %#x\n", lum->lmm_stripe_count);
CDEBUG(D_OTHER, "\tlmm_stripe_offset/lmm_layout_gen: %#x\n",
@ -2292,7 +2292,7 @@ EXPORT_SYMBOL(dump_ioo);
void dump_rniobuf(struct niobuf_remote *nb)
{
CDEBUG(D_RPCTRACE, "niobuf_remote: offset="LPU64", len=%d, flags=%x\n",
CDEBUG(D_RPCTRACE, "niobuf_remote: offset=%llu, len=%d, flags=%x\n",
nb->offset, nb->len, nb->flags);
}
EXPORT_SYMBOL(dump_rniobuf);
@ -2421,7 +2421,7 @@ void _debug_req(struct ptlrpc_request *req,
va_start(args, fmt);
libcfs_debug_vmsg2(msgdata, fmt, args,
" req@%p x"LPU64"/t%lld(%lld) o%d->%s@%s:%d/%d"
" req@%p x%llu/t%lld(%lld) o%d->%s@%s:%d/%d"
" lens %d/%d e %d to %d dl "CFS_TIME_T" ref %d "
"fl "REQ_FLAGS_FMT"/%x/%x rc %d/%d\n",
req, req->rq_xid, req->rq_transno,

6
drivers/staging/lustre/lustre/ptlrpc/recover.c
View File

@ -85,7 +85,7 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
last_transno = imp->imp_last_replay_transno;
spin_unlock(&imp->imp_lock);
CDEBUG(D_HA, "import %p from %s committed "LPU64" last "LPU64"\n",
CDEBUG(D_HA, "import %p from %s committed %llu last %llu\n",
imp, obd2cli_tgt(imp->imp_obd),
imp->imp_peer_committed_transno, last_transno);
@ -164,8 +164,8 @@ int ptlrpc_replay_next(struct obd_import *imp, int *inflight)
if (req != NULL) {
rc = ptlrpc_replay_req(req);
if (rc) {
CERROR("recovery replay error %d for req "
LPU64"\n", rc, req->rq_xid);
CERROR("recovery replay error %d for req %llu\n",
rc, req->rq_xid);
return rc;
}
*inflight = 1;

4
drivers/staging/lustre/lustre/ptlrpc/sec.c
View File

@ -992,7 +992,7 @@ static int do_cli_unwrap_reply(struct ptlrpc_request *req)
case 0:
break;
default:
CERROR("failed unpack reply: x"LPU64"\n", req->rq_xid);
CERROR("failed unpack reply: x%llu\n", req->rq_xid);
return -EPROTO;
}
@ -2033,7 +2033,7 @@ int sptlrpc_svc_unwrap_request(struct ptlrpc_request *req)
case 0:
break;
default:
CERROR("error unpacking request from %s x"LPU64"\n",
CERROR("error unpacking request from %s x%llu\n",
libcfs_id2str(req->rq_peer), req->rq_xid);
return SECSVC_DROP;
}

27
drivers/staging/lustre/lustre/ptlrpc/service.c
View File

@ -1128,8 +1128,7 @@ static int ptlrpc_check_req(struct ptlrpc_request *req)
rc = -ENODEV;
} else if (lustre_msg_get_transno(req->rq_reqmsg) != 0 &&
!obd->obd_recovering) {
DEBUG_REQ(D_ERROR, req, "Invalid req with transno "
LPU64" without recovery",
DEBUG_REQ(D_ERROR, req, "Invalid req with transno %llu without recovery",
lustre_msg_get_transno(req->rq_reqmsg));
class_fail_export(req->rq_export);
rc = -ENODEV;
@ -1766,24 +1765,24 @@ ptlrpc_server_handle_req_in(struct ptlrpc_service_part *svcpt,
if (SPTLRPC_FLVR_POLICY(req->rq_flvr.sf_rpc) != SPTLRPC_POLICY_NULL) {
rc = ptlrpc_unpack_req_msg(req, req->rq_reqlen);
if (rc != 0) {
CERROR("error unpacking request: ptl %d from %s "
"x"LPU64"\n", svc->srv_req_portal,
libcfs_id2str(req->rq_peer), req->rq_xid);
CERROR("error unpacking request: ptl %d from %s x%llu\n",
svc->srv_req_portal, libcfs_id2str(req->rq_peer),
req->rq_xid);
goto err_req;
}
}
rc = lustre_unpack_req_ptlrpc_body(req, MSG_PTLRPC_BODY_OFF);
if (rc) {
CERROR("error unpacking ptlrpc body: ptl %d from %s x"
LPU64"\n", svc->srv_req_portal,
libcfs_id2str(req->rq_peer), req->rq_xid);
CERROR("error unpacking ptlrpc body: ptl %d from %s x%llu\n",
svc->srv_req_portal, libcfs_id2str(req->rq_peer),
req->rq_xid);
goto err_req;
}
if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_DROP_REQ_OPC) &&
lustre_msg_get_opc(req->rq_reqmsg) == cfs_fail_val) {
CERROR("drop incoming rpc opc %u, x"LPU64"\n",
CERROR("drop incoming rpc opc %u, x%llu\n",
cfs_fail_val, req->rq_xid);
goto err_req;
}
@ -1808,7 +1807,7 @@ ptlrpc_server_handle_req_in(struct ptlrpc_service_part *svcpt,
break;
}
CDEBUG(D_RPCTRACE, "got req x"LPU64"\n", req->rq_xid);
CDEBUG(D_RPCTRACE, "got req x%llu\n", req->rq_xid);
req->rq_export = class_conn2export(
lustre_msg_get_handle(req->rq_reqmsg));
@ -1918,7 +1917,7 @@ ptlrpc_server_handle_request(struct ptlrpc_service_part *svcpt,
request->rq_session.lc_cookie = 0x5;
lu_context_enter(&request->rq_session);
CDEBUG(D_NET, "got req "LPU64"\n", request->rq_xid);
CDEBUG(D_NET, "got req %llu\n", request->rq_xid);
request->rq_svc_thread = thread;
if (thread)
@ -1944,7 +1943,7 @@ ptlrpc_server_handle_request(struct ptlrpc_service_part *svcpt,
}
CDEBUG(D_RPCTRACE, "Handling RPC pname:cluuid+ref:pid:xid:nid:opc "
"%s:%s+%d:%d:x"LPU64":%s:%d\n", current_comm(),
"%s:%s+%d:%d:x%llu:%s:%d\n", current_comm(),
(request->rq_export ?
(char *)request->rq_export->exp_client_uuid.uuid : "0"),
(request->rq_export ?
@ -1978,8 +1977,8 @@ put_conn:
do_gettimeofday(&work_end);
timediff = cfs_timeval_sub(&work_end, &work_start, NULL);
CDEBUG(D_RPCTRACE, "Handled RPC pname:cluuid+ref:pid:xid:nid:opc "
"%s:%s+%d:%d:x"LPU64":%s:%d Request processed in "
"%ldus (%ldus total) trans "LPU64" rc %d/%d\n",
"%s:%s+%d:%d:x%llu:%s:%d Request processed in "
"%ldus (%ldus total) trans %llu rc %d/%d\n",
current_comm(),
(request->rq_export ?
(char *)request->rq_export->exp_client_uuid.uuid : "0"),