return -EPROTO;
case GMNAL_MSG_IMMEDIATE:
- if (rx->rx_recv_nob < offsetof(gmnal_msg_t, gmm_u.immediate.gmim_payload[0])) {
- CERROR("Short IMMEDIATE from %u: %d("LPSZ")\n",
+ if (rx->rx_recv_nob <
+ offsetof(gmnal_msg_t, gmm_u.immediate.gmim_payload[0])) {
+ CERROR("Short IMMEDIATE from %u: %d(%lu)\n",
rx->rx_recv_gmid, rx->rx_recv_nob,
- offsetof(gmnal_msg_t, gmm_u.immediate.gmim_payload[0]));
+ (long)offsetof(gmnal_msg_t,
+ gmm_u.immediate.gmim_payload[0]));
return -EPROTO;
}
break;
struct cl_io *io = ios->cis_io;
struct cl_object *obj = io->ci_obj;
struct inode *inode = ccc_object_inode(obj);
- int err, ret;
- loff_t pos;
- size_t cnt;
+ int err, ret;
+ loff_t pos;
+ long cnt;
struct llu_io_group *iogroup;
struct lustre_rw_params p = {0};
int iovidx;
GOTO(out, err);
CDEBUG(D_INODE,
- "%s ino %lu, "LPSZ" bytes, offset %lld, i_size %llu\n",
- write?"Write":"Read", (unsigned long)st->st_ino,
+ "%s ino %lu, %lu bytes, offset %lld, i_size %llu\n",
+ write ? "Write" : "Read", (unsigned long)st->st_ino,
cnt, (__u64)pos, (__u64)st->st_size);
if (write && io->u.ci_wr.wr_append)
for (iovidx = 0; iovidx < cio->cui_nrsegs; iovidx++) {
char *buf = (char *) cio->cui_iov[iovidx].iov_base;
- size_t count = cio->cui_iov[iovidx].iov_len;
+ long count = cio->cui_iov[iovidx].iov_len;
if (!count)
continue;
spin_unlock(&sbi->ll_process_lock);
}
-char lpszt[] = LPSZ;
-
static int ll_rw_offset_stats_seq_show(struct seq_file *seq, void *v)
{
struct timeval now;
struct ll_sb_info *sbi = seq->private;
struct ll_rw_process_info *offset = sbi->ll_rw_offset_info;
struct ll_rw_process_info *process = sbi->ll_rw_process_info;
- char format[50];
int i;
do_gettimeofday(&now);
seq_printf(seq, "%3s %10s %14s %14s %17s %17s %14s\n",
"R/W", "PID", "RANGE START", "RANGE END",
"SMALLEST EXTENT", "LARGEST EXTENT", "OFFSET");
- sprintf(format, "%s%s%s%s%s\n",
- "%3c %10d %14Lu %14Lu %17", lpszt+1, " %17", lpszt+1, " %14Ld");
/* We stored the discontiguous offsets here; print them first */
for(i = 0; i < LL_OFFSET_HIST_MAX; i++) {
if (offset[i].rw_pid != 0)
- /* Is there a way to snip the '%' off of LPSZ? */
- seq_printf(seq, format,
+ seq_printf(seq,"%3c %10d %14Lu %14Lu %17lu %17lu %14Lu",
offset[i].rw_op ? 'W' : 'R',
offset[i].rw_pid,
offset[i].rw_range_start,
/* Then print the current offsets for each process */
for(i = 0; i < LL_PROCESS_HIST_MAX; i++) {
if (process[i].rw_pid != 0)
- seq_printf(seq, format,
+ seq_printf(seq,"%3c %10d %14Lu %14Lu %17lu %17lu %14Lu",
process[i].rw_op ? 'W' : 'R',
process[i].rw_pid,
process[i].rw_range_start,
int i;
ssize_t rc = 0;
loff_t file_offset = pv->ldp_start_offset;
- size_t size = pv->ldp_size;
+ long size = pv->ldp_size;
int page_count = pv->ldp_nr;
struct page **pages = pv->ldp_pages;
- size_t page_size = cl_page_size(obj);
+ long page_size = cl_page_size(obj);
ENTRY;
queue = &io->ci_queue;
src = kmap_atomic(src_page, KM_USER0);
dst = kmap_atomic(dst_page, KM_USER1);
- memcpy(dst, (const void *)src, min(page_size, size));
+ memcpy(dst, src, min(page_size, size));
kunmap_atomic(dst, KM_USER1);
kunmap_atomic(src, KM_USER0);
struct file *file = iocb->ki_filp;
struct inode *inode = file->f_mapping->host;
struct ccc_object *obj = cl_inode2ccc(inode);
- ssize_t count = iov_length(iov, nr_segs);
- ssize_t tot_bytes = 0, result = 0;
+ long count = iov_length(iov, nr_segs);
+ long tot_bytes = 0, result = 0;
struct ll_inode_info *lli = ll_i2info(inode);
struct lov_stripe_md *lsm = lli->lli_smd;
unsigned long seg = 0;
- size_t size = MAX_DIO_SIZE;
+ long size = MAX_DIO_SIZE;
int refcheck;
ENTRY;
if ((file_offset & ~CFS_PAGE_MASK) || (count & ~CFS_PAGE_MASK))
RETURN(-EINVAL);
- CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), size="LPSZ" (max %lu), "
- "offset=%lld=%llx, pages "LPSZ" (max %lu)\n",
+ CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p), size=%lu (max %lu), "
+ "offset=%lld=%llx, pages %lu (max %lu)\n",
inode->i_ino, inode->i_generation, inode, count, MAX_DIO_SIZE,
file_offset, file_offset, count >> CFS_PAGE_SHIFT,
MAX_DIO_SIZE >> CFS_PAGE_SHIFT);
LASSERT(obj->cob_transient_pages == 0);
for (seg = 0; seg < nr_segs; seg++) {
- size_t iov_left = iov[seg].iov_len;
+ long iov_left = iov[seg].iov_len;
unsigned long user_addr = (unsigned long)iov[seg].iov_base;
if (rw == READ) {
while (iov_left > 0) {
struct page **pages;
int page_count, max_pages = 0;
- size_t bytes;
+ long bytes;
bytes = min(size,iov_left);
- page_count = ll_get_user_pages(rw, user_addr,
- bytes,
+ page_count = ll_get_user_pages(rw, user_addr, bytes,
&pages, &max_pages);
if (likely(page_count > 0)) {
if (unlikely(page_count < max_pages))
size = ((((size / 2) - 1) |
~CFS_PAGE_MASK) + 1) &
CFS_PAGE_MASK;
- CDEBUG(D_VFSTRACE, "DIO size now %u\n",
- (int)size);
+ CDEBUG(D_VFSTRACE,"DIO size now %lu\n",
+ size);
continue;
}
int result;
loff_t pos = io->u.ci_rd.rd.crw_pos;
- size_t cnt = io->u.ci_rd.rd.crw_count;
- size_t tot = cio->cui_tot_count;
+ long cnt = io->u.ci_rd.rd.crw_count;
+ long tot = cio->cui_tot_count;
int exceed = 0;
CLOBINVRNT(env, obj, ccc_object_invariant(obj));
LASSERT(vio->cui_oneshot == 0);
- CDEBUG(D_VFSTRACE, "read: -> [%lli, %lli)\n", pos, pos + (long long)cnt);
+ CDEBUG(D_VFSTRACE, "read: -> [%lli, %lli)\n", pos, pos + cnt);
result = ccc_prep_size(env, obj, io, pos, tot, 1, &exceed);
if (result != 0)
goto out;
LU_OBJECT_HEADER(D_INODE, env, &obj->co_lu,
- "Read ino %lu, "LPSZ" bytes, offset %lld, size %llu\n",
+ "Read ino %lu, %lu bytes, offset %lld, size %llu\n",
inode->i_ino, cnt, pos, i_size_read(inode));
/* turn off the kernel's read-ahead */
const int blkbits = inode->i_sb->s_blocksize_bits;
const int blksize = inode->i_sb->s_blocksize;
- CDEBUG(D_EXT2, "reading "LPSZ" at dir %lu+%llu\n",
- count, inode->i_ino, *off);
+ CDEBUG(D_EXT2, "reading %lu at dir %lu+%llu\n",
+ (unsigned long)count, inode->i_ino, *off);
while (count > 0) {
struct buffer_head *bh;
int create;
};
-static int ext3_ext_find_goal(struct inode *inode, struct ext3_ext_path *path,
- unsigned long block, int *aflags)
+static long ext3_ext_find_goal(struct inode *inode, struct ext3_ext_path *path,
+ unsigned long block, int *aflags)
{
struct ext3_inode_info *ei = EXT3_I(inode);
unsigned long bg_start;
if (PTR_ERR(exp) == -EALREADY) {
/* export already exists, zero out this one */
lcd->lcd_uuid[0] = '\0';
- } else
+ } else {
GOTO(err_client, rc = PTR_ERR(exp));
+ }
} else {
struct mdt_thread_info *mti;
mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key);
spin_unlock(&mti->mti_exp->exp_lock);
rc = mdt_last_rcvd_write(env, mdt, lcd, &off, th);
- CDEBUG(D_INFO, "wrote client lcd at idx %u off %llu (len "LPSZ")\n",
- cl_idx, med->med_lr_off, sizeof(*lcd));
+ CDEBUG(D_INFO, "wrote client lcd at idx %u off %llu (len %u)\n",
+ cl_idx, med->med_lr_off, (int)sizeof(*lcd));
mdt_trans_stop(env, mdt, th);
RETURN(rc);
ENTRY;
LU_OBJECT_HEADER(D_VFSTRACE, env, &io->ci_obj->co_lu,
- "io range: %i [%llu, %llu) %i %i\n",
- iot, (__u64)pos, (__u64)(pos + count),
+ "io range: %u ["LPU64", "LPU64") %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;
io->u.ci_rw.crw_count = count;
char buf[64];
int len, ret = 0;
- CDEBUG(D_INFO, "LPU64=%s, LPD64=%s, LPX64=%s, LPSZ=%s, LPSSZ=%s\n",
- LPU64, LPD64, LPX64, LPSZ, LPSSZ);
+ CDEBUG(D_INFO, "LPU64=%s, LPD64=%s, LPX64=%s\n", LPU64, LPD64, LPX64);
CDEBUG(D_INFO, "OBD_OBJECT_EOF = "LPX64"\n", (__u64)OBD_OBJECT_EOF);
len = i_size_read(file->f_dentry->d_inode);
CDEBUG(D_MOUNT, "Have %s, size %lu\n", MOUNT_DATA_FILE, len);
if (len != sizeof(*ldd)) {
- CERROR("disk data size does not match: see %lu expect "LPSZ"\n",
- len, sizeof(*ldd));
+ CERROR("disk data size does not match: see %lu expect %u\n",
+ len, (int)sizeof(*ldd));
GOTO(out_close, rc = -EINVAL);
}
ENTRY;
if (data != NULL || datalen != 0) {
- CERROR("invalid: data %p, len "LPSZ"\n", data, datalen);
+ CERROR("invalid: data %p, len %lu\n", data, (long)datalen);
RETURN(-EINVAL);
}
ENTRY;
if (data == NULL || datalen == 0) {
- CWARN("invalid: data %p, len "LPSZ"\n", data, datalen);
+ CWARN("invalid: data %p, len %lu\n", data, (long)datalen);
RETURN(-EINVAL);
}