tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

lib/vsprintf.c: remove %Z support

Now that %z is standartised in C99 there is no reason to support %Z.
Unlike %L it doesn't even make format strings smaller.

Use BUILD_BUG_ON in a couple ATM drivers.

In case anyone didn't notice lib/vsprintf.o is about half of SLUB which
is in my opinion is quite an achievement. Hopefully this patch inspires
someone else to trim vsprintf.c more.

Link: http://lkml.kernel.org/r/20170103230126.GA30170@avx2
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Cc: Andy Shevchenko <andy.shevchenko@gmail.com>
Cc: Rasmus Villemoes <linux@rasmusvillemoes.dk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

authored by

Alexey Dobriyan and committed by
Linus Torvalds 5b5e0928 d7f67243

+187 -201
+3 -3
block/bsg.c
··· 573 573 int ret; 574 574 ssize_t bytes_read; 575 575 576 - dprintk("%s: read %Zd bytes\n", bd->name, count); 576 + dprintk("%s: read %zd bytes\n", bd->name, count); 577 577 578 578 bsg_set_block(bd, file); 579 579 ··· 648 648 ssize_t bytes_written; 649 649 int ret; 650 650 651 - dprintk("%s: write %Zd bytes\n", bd->name, count); 651 + dprintk("%s: write %zd bytes\n", bd->name, count); 652 652 653 653 if (unlikely(segment_eq(get_fs(), KERNEL_DS))) 654 654 return -EINVAL; ··· 667 667 if (!bytes_written || err_block_err(ret)) 668 668 bytes_written = ret; 669 669 670 - dprintk("%s: returning %Zd\n", bd->name, bytes_written); 670 + dprintk("%s: returning %zd\n", bd->name, bytes_written); 671 671 return bytes_written; 672 672 } 673 673
+1 -6
drivers/atm/ambassador.c
··· 2394 2394 { 2395 2395 PRINTD (DBG_FLOW|DBG_INIT, "init_module"); 2396 2396 2397 - // sanity check - cast needed as printk does not support %Zu 2398 - if (sizeof(amb_mem) != 4*16 + 4*12) { 2399 - PRINTK (KERN_ERR, "Fix amb_mem (is %lu words).", 2400 - (unsigned long) sizeof(amb_mem)); 2401 - return -ENOMEM; 2402 - } 2397 + BUILD_BUG_ON(sizeof(amb_mem) != 4*16 + 4*12); 2403 2398 2404 2399 show_version(); 2405 2400
+1 -5
drivers/atm/eni.c
··· 2326 2326 { 2327 2327 struct sk_buff *skb; /* dummy for sizeof */ 2328 2328 2329 - if (sizeof(skb->cb) < sizeof(struct eni_skb_prv)) { 2330 - printk(KERN_ERR "eni_detect: skb->cb is too small (%Zd < %Zd)\n", 2331 - sizeof(skb->cb),sizeof(struct eni_skb_prv)); 2332 - return -EIO; 2333 - } 2329 + BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct eni_skb_prv)); 2334 2330 return pci_register_driver(&eni_driver); 2335 2331 } 2336 2332
+6 -6
drivers/atm/firestream.c
··· 895 895 /* XXX handle qos parameters (rate limiting) ? */ 896 896 897 897 vcc = kmalloc(sizeof(struct fs_vcc), GFP_KERNEL); 898 - fs_dprintk (FS_DEBUG_ALLOC, "Alloc VCC: %p(%Zd)\n", vcc, sizeof(struct fs_vcc)); 898 + fs_dprintk (FS_DEBUG_ALLOC, "Alloc VCC: %p(%zd)\n", vcc, sizeof(struct fs_vcc)); 899 899 if (!vcc) { 900 900 clear_bit(ATM_VF_ADDR, &atm_vcc->flags); 901 901 return -ENOMEM; ··· 946 946 947 947 if (DO_DIRECTION (txtp)) { 948 948 tc = kmalloc (sizeof (struct fs_transmit_config), GFP_KERNEL); 949 - fs_dprintk (FS_DEBUG_ALLOC, "Alloc tc: %p(%Zd)\n", 949 + fs_dprintk (FS_DEBUG_ALLOC, "Alloc tc: %p(%zd)\n", 950 950 tc, sizeof (struct fs_transmit_config)); 951 951 if (!tc) { 952 952 fs_dprintk (FS_DEBUG_OPEN, "fs: can't alloc transmit_config.\n"); ··· 1185 1185 vcc->last_skb = skb; 1186 1186 1187 1187 td = kmalloc (sizeof (struct FS_BPENTRY), GFP_ATOMIC); 1188 - fs_dprintk (FS_DEBUG_ALLOC, "Alloc transd: %p(%Zd)\n", td, sizeof (struct FS_BPENTRY)); 1188 + fs_dprintk (FS_DEBUG_ALLOC, "Alloc transd: %p(%zd)\n", td, sizeof (struct FS_BPENTRY)); 1189 1189 if (!td) { 1190 1190 /* Oops out of mem */ 1191 1191 return -ENOMEM; ··· 1492 1492 fs_dprintk (FS_DEBUG_ALLOC, "Alloc rec-skb: %p(%d)\n", skb, fp->bufsize); 1493 1493 if (!skb) break; 1494 1494 ne = kmalloc (sizeof (struct FS_BPENTRY), gfp_flags); 1495 - fs_dprintk (FS_DEBUG_ALLOC, "Alloc rec-d: %p(%Zd)\n", ne, sizeof (struct FS_BPENTRY)); 1495 + fs_dprintk (FS_DEBUG_ALLOC, "Alloc rec-d: %p(%zd)\n", ne, sizeof (struct FS_BPENTRY)); 1496 1496 if (!ne) { 1497 1497 fs_dprintk (FS_DEBUG_ALLOC, "Free rec-skb: %p\n", skb); 1498 1498 dev_kfree_skb_any (skb); ··· 1803 1803 } 1804 1804 dev->atm_vccs = kcalloc (dev->nchannels, sizeof (struct atm_vcc *), 1805 1805 GFP_KERNEL); 1806 - fs_dprintk (FS_DEBUG_ALLOC, "Alloc atmvccs: %p(%Zd)\n", 1806 + fs_dprintk (FS_DEBUG_ALLOC, "Alloc atmvccs: %p(%zd)\n", 1807 1807 dev->atm_vccs, dev->nchannels * sizeof (struct atm_vcc *)); 1808 1808 1809 1809 if (!dev->atm_vccs) { ··· 1911 1911 goto err_out; 1912 1912 1913 1913 fs_dev = kzalloc (sizeof (struct fs_dev), GFP_KERNEL); 1914 - fs_dprintk (FS_DEBUG_ALLOC, "Alloc fs-dev: %p(%Zd)\n", 1914 + fs_dprintk (FS_DEBUG_ALLOC, "Alloc fs-dev: %p(%zd)\n", 1915 1915 fs_dev, sizeof (struct fs_dev)); 1916 1916 if (!fs_dev) 1917 1917 goto err_out;
+1 -6
drivers/atm/horizon.c
··· 2884 2884 /********** module entry **********/ 2885 2885 2886 2886 static int __init hrz_module_init (void) { 2887 - // sanity check - cast is needed since printk does not support %Zu 2888 - if (sizeof(struct MEMMAP) != 128*1024/4) { 2889 - PRINTK (KERN_ERR, "Fix struct MEMMAP (is %lu fakewords).", 2890 - (unsigned long) sizeof(struct MEMMAP)); 2891 - return -ENOMEM; 2892 - } 2887 + BUILD_BUG_ON(sizeof(struct MEMMAP) != 128*1024/4); 2893 2888 2894 2889 show_version(); 2895 2890
+8 -8
drivers/atm/lanai.c
··· 1389 1389 if (n < 0) 1390 1390 n += lanai_buf_size(&lvcc->rx.buf); 1391 1391 APRINTK(n >= 0 && n < lanai_buf_size(&lvcc->rx.buf) && !(n & 15), 1392 - "vcc_rx_aal5: n out of range (%d/%Zu)\n", 1392 + "vcc_rx_aal5: n out of range (%d/%zu)\n", 1393 1393 n, lanai_buf_size(&lvcc->rx.buf)); 1394 1394 /* Recover the second-to-last word to get true pdu length */ 1395 1395 if ((x = &end[-2]) < lvcc->rx.buf.start) ··· 1493 1493 return -ENOMEM; 1494 1494 if (unlikely(lanai_buf_size(buf) < size)) 1495 1495 printk(KERN_WARNING DEV_LABEL "(itf %d): wanted %d bytes " 1496 - "for %s buffer, got only %Zu\n", lanai->number, size, 1496 + "for %s buffer, got only %zu\n", lanai->number, size, 1497 1497 name, lanai_buf_size(buf)); 1498 - DPRINTK("Allocated %Zu byte %s buffer\n", lanai_buf_size(buf), name); 1498 + DPRINTK("Allocated %zu byte %s buffer\n", lanai_buf_size(buf), name); 1499 1499 return 0; 1500 1500 } 1501 1501 ··· 1586 1586 lanai->pci); 1587 1587 if (unlikely(lanai->service.start == NULL)) 1588 1588 return -ENOMEM; 1589 - DPRINTK("allocated service buffer at 0x%08lX, size %Zu(%d)\n", 1589 + DPRINTK("allocated service buffer at 0x%08lX, size %zu(%d)\n", 1590 1590 (unsigned long) lanai->service.start, 1591 1591 lanai_buf_size(&lanai->service), 1592 1592 lanai_buf_size_cardorder(&lanai->service)); ··· 2467 2467 (lanai->status & STATUS_LED) ? 1 : 0, 2468 2468 (lanai->status & STATUS_GPIN) ? 1 : 0); 2469 2469 if (left-- == 0) 2470 - return sprintf(page, "global buffer sizes: service=%Zu, " 2471 - "aal0_rx=%Zu\n", lanai_buf_size(&lanai->service), 2470 + return sprintf(page, "global buffer sizes: service=%zu, " 2471 + "aal0_rx=%zu\n", lanai_buf_size(&lanai->service), 2472 2472 lanai->naal0 ? lanai_buf_size(&lanai->aal0buf) : 0); 2473 2473 if (left-- == 0) { 2474 2474 get_statistics(lanai); ··· 2513 2513 left += sprintf(&page[left], ",\n rx_AAL=%d", 2514 2514 lvcc->rx.atmvcc->qos.aal == ATM_AAL5 ? 5 : 0); 2515 2515 if (lvcc->rx.atmvcc->qos.aal == ATM_AAL5) 2516 - left += sprintf(&page[left], ", rx_buf_size=%Zu, " 2516 + left += sprintf(&page[left], ", rx_buf_size=%zu, " 2517 2517 "rx_bad_len=%u,\n rx_service_trash=%u, " 2518 2518 "rx_service_stream=%u, rx_bad_crc=%u", 2519 2519 lanai_buf_size(&lvcc->rx.buf), ··· 2524 2524 } 2525 2525 if (lvcc->tx.atmvcc != NULL) 2526 2526 left += sprintf(&page[left], ",\n tx_AAL=%d, " 2527 - "tx_buf_size=%Zu, tx_qos=%cBR, tx_backlogged=%c", 2527 + "tx_buf_size=%zu, tx_qos=%cBR, tx_backlogged=%c", 2528 2528 lvcc->tx.atmvcc->qos.aal == ATM_AAL5 ? 5 : 0, 2529 2529 lanai_buf_size(&lvcc->tx.buf), 2530 2530 lvcc->tx.atmvcc == lanai->cbrvcc ? 'C' : 'U',
+1 -1
drivers/char/pcmcia/cm4000_cs.c
··· 1037 1037 clear_bit(LOCK_IO, &dev->flags); 1038 1038 wake_up_interruptible(&dev->ioq); 1039 1039 1040 - DEBUGP(2, dev, "<- cmm_read returns: rc = %Zi\n", 1040 + DEBUGP(2, dev, "<- cmm_read returns: rc = %zi\n", 1041 1041 (rc < 0 ? rc : count)); 1042 1042 return rc < 0 ? rc : count; 1043 1043 }
+1 -1
drivers/char/pcmcia/cm4040_cs.c
··· 331 331 } 332 332 333 333 if ((count < 5) || (count > READ_WRITE_BUFFER_SIZE)) { 334 - DEBUGP(2, dev, "<- cm4040_write buffersize=%Zd < 5\n", count); 334 + DEBUGP(2, dev, "<- cm4040_write buffersize=%zd < 5\n", count); 335 335 return -EIO; 336 336 } 337 337
+2 -2
drivers/gpu/drm/mga/mga_drv.h
··· 266 266 do { \ 267 267 if (MGA_VERBOSE) { \ 268 268 DRM_INFO("BEGIN_DMA(%d)\n", (n)); \ 269 - DRM_INFO(" space=0x%x req=0x%Zx\n", \ 269 + DRM_INFO(" space=0x%x req=0x%zx\n", \ 270 270 dev_priv->prim.space, (n) * DMA_BLOCK_SIZE); \ 271 271 } \ 272 272 prim = dev_priv->prim.start; \ ··· 313 313 #define DMA_WRITE(offset, val) \ 314 314 do { \ 315 315 if (MGA_VERBOSE) \ 316 - DRM_INFO(" DMA_WRITE( 0x%08x ) at 0x%04Zx\n", \ 316 + DRM_INFO(" DMA_WRITE( 0x%08x ) at 0x%04zx\n", \ 317 317 (u32)(val), write + (offset) * sizeof(u32)); \ 318 318 *(volatile u32 *)(prim + write + (offset) * sizeof(u32)) = val; \ 319 319 } while (0)
+1 -1
drivers/ide/ide-acpi.c
··· 447 447 memcpy(&hwif->acpidata->gtm, out_obj->buffer.pointer, 448 448 sizeof(struct GTM_buffer)); 449 449 450 - DEBPRINT("_GTM info: ptr: 0x%p, len: 0x%x, exp.len: 0x%Zx\n", 450 + DEBPRINT("_GTM info: ptr: 0x%p, len: 0x%x, exp.len: 0x%zx\n", 451 451 out_obj->buffer.pointer, out_obj->buffer.length, 452 452 sizeof(struct GTM_buffer)); 453 453
+2 -2
drivers/ide/ide-tape.c
··· 1136 1136 ssize_t ret = 0; 1137 1137 int rc; 1138 1138 1139 - ide_debug_log(IDE_DBG_FUNC, "count %Zd", count); 1139 + ide_debug_log(IDE_DBG_FUNC, "count %zd", count); 1140 1140 1141 1141 if (tape->chrdev_dir != IDETAPE_DIR_READ) { 1142 1142 if (test_bit(ilog2(IDE_AFLAG_DETECT_BS), &drive->atapi_flags)) ··· 1195 1195 if (tape->write_prot) 1196 1196 return -EACCES; 1197 1197 1198 - ide_debug_log(IDE_DBG_FUNC, "count %Zd", count); 1198 + ide_debug_log(IDE_DBG_FUNC, "count %zd", count); 1199 1199 1200 1200 /* Initialize write operation */ 1201 1201 rc = idetape_init_rw(drive, IDETAPE_DIR_WRITE);
+31 -31
drivers/input/touchscreen/cyttsp4_core.c
··· 202 202 int rc; 203 203 204 204 si->si_ofs.cydata_size = si->si_ofs.test_ofs - si->si_ofs.cydata_ofs; 205 - dev_dbg(cd->dev, "%s: cydata size: %Zd\n", __func__, 205 + dev_dbg(cd->dev, "%s: cydata size: %zd\n", __func__, 206 206 si->si_ofs.cydata_size); 207 207 208 208 p = krealloc(si->si_ptrs.cydata, si->si_ofs.cydata_size, GFP_KERNEL); ··· 430 430 for (abs = 0; abs < CY_TCH_NUM_ABS; abs++) { 431 431 dev_dbg(cd->dev, "%s: tch_rec_%s\n", __func__, 432 432 cyttsp4_tch_abs_string[abs]); 433 - dev_dbg(cd->dev, "%s: ofs =%2Zd\n", __func__, 433 + dev_dbg(cd->dev, "%s: ofs =%2zd\n", __func__, 434 434 si->si_ofs.tch_abs[abs].ofs); 435 - dev_dbg(cd->dev, "%s: siz =%2Zd\n", __func__, 435 + dev_dbg(cd->dev, "%s: siz =%2zd\n", __func__, 436 436 si->si_ofs.tch_abs[abs].size); 437 - dev_dbg(cd->dev, "%s: max =%2Zd\n", __func__, 437 + dev_dbg(cd->dev, "%s: max =%2zd\n", __func__, 438 438 si->si_ofs.tch_abs[abs].max); 439 - dev_dbg(cd->dev, "%s: bofs=%2Zd\n", __func__, 439 + dev_dbg(cd->dev, "%s: bofs=%2zd\n", __func__, 440 440 si->si_ofs.tch_abs[abs].bofs); 441 441 } 442 442 ··· 586 586 static void cyttsp4_si_put_log_data(struct cyttsp4 *cd) 587 587 { 588 588 struct cyttsp4_sysinfo *si = &cd->sysinfo; 589 - dev_dbg(cd->dev, "%s: cydata_ofs =%4Zd siz=%4Zd\n", __func__, 589 + dev_dbg(cd->dev, "%s: cydata_ofs =%4zd siz=%4zd\n", __func__, 590 590 si->si_ofs.cydata_ofs, si->si_ofs.cydata_size); 591 - dev_dbg(cd->dev, "%s: test_ofs =%4Zd siz=%4Zd\n", __func__, 591 + dev_dbg(cd->dev, "%s: test_ofs =%4zd siz=%4zd\n", __func__, 592 592 si->si_ofs.test_ofs, si->si_ofs.test_size); 593 - dev_dbg(cd->dev, "%s: pcfg_ofs =%4Zd siz=%4Zd\n", __func__, 593 + dev_dbg(cd->dev, "%s: pcfg_ofs =%4zd siz=%4zd\n", __func__, 594 594 si->si_ofs.pcfg_ofs, si->si_ofs.pcfg_size); 595 - dev_dbg(cd->dev, "%s: opcfg_ofs =%4Zd siz=%4Zd\n", __func__, 595 + dev_dbg(cd->dev, "%s: opcfg_ofs =%4zd siz=%4zd\n", __func__, 596 596 si->si_ofs.opcfg_ofs, si->si_ofs.opcfg_size); 597 - dev_dbg(cd->dev, "%s: ddata_ofs =%4Zd siz=%4Zd\n", __func__, 597 + dev_dbg(cd->dev, "%s: ddata_ofs =%4zd siz=%4zd\n", __func__, 598 598 si->si_ofs.ddata_ofs, si->si_ofs.ddata_size); 599 - dev_dbg(cd->dev, "%s: mdata_ofs =%4Zd siz=%4Zd\n", __func__, 599 + dev_dbg(cd->dev, "%s: mdata_ofs =%4zd siz=%4zd\n", __func__, 600 600 si->si_ofs.mdata_ofs, si->si_ofs.mdata_size); 601 601 602 - dev_dbg(cd->dev, "%s: cmd_ofs =%4Zd\n", __func__, 602 + dev_dbg(cd->dev, "%s: cmd_ofs =%4zd\n", __func__, 603 603 si->si_ofs.cmd_ofs); 604 - dev_dbg(cd->dev, "%s: rep_ofs =%4Zd\n", __func__, 604 + dev_dbg(cd->dev, "%s: rep_ofs =%4zd\n", __func__, 605 605 si->si_ofs.rep_ofs); 606 - dev_dbg(cd->dev, "%s: rep_sz =%4Zd\n", __func__, 606 + dev_dbg(cd->dev, "%s: rep_sz =%4zd\n", __func__, 607 607 si->si_ofs.rep_sz); 608 - dev_dbg(cd->dev, "%s: num_btns =%4Zd\n", __func__, 608 + dev_dbg(cd->dev, "%s: num_btns =%4zd\n", __func__, 609 609 si->si_ofs.num_btns); 610 - dev_dbg(cd->dev, "%s: num_btn_regs =%4Zd\n", __func__, 610 + dev_dbg(cd->dev, "%s: num_btn_regs =%4zd\n", __func__, 611 611 si->si_ofs.num_btn_regs); 612 - dev_dbg(cd->dev, "%s: tt_stat_ofs =%4Zd\n", __func__, 612 + dev_dbg(cd->dev, "%s: tt_stat_ofs =%4zd\n", __func__, 613 613 si->si_ofs.tt_stat_ofs); 614 - dev_dbg(cd->dev, "%s: tch_rec_size =%4Zd\n", __func__, 614 + dev_dbg(cd->dev, "%s: tch_rec_size =%4zd\n", __func__, 615 615 si->si_ofs.tch_rec_size); 616 - dev_dbg(cd->dev, "%s: max_tchs =%4Zd\n", __func__, 616 + dev_dbg(cd->dev, "%s: max_tchs =%4zd\n", __func__, 617 617 si->si_ofs.max_tchs); 618 - dev_dbg(cd->dev, "%s: mode_size =%4Zd\n", __func__, 618 + dev_dbg(cd->dev, "%s: mode_size =%4zd\n", __func__, 619 619 si->si_ofs.mode_size); 620 - dev_dbg(cd->dev, "%s: data_size =%4Zd\n", __func__, 620 + dev_dbg(cd->dev, "%s: data_size =%4zd\n", __func__, 621 621 si->si_ofs.data_size); 622 - dev_dbg(cd->dev, "%s: map_sz =%4Zd\n", __func__, 622 + dev_dbg(cd->dev, "%s: map_sz =%4zd\n", __func__, 623 623 si->si_ofs.map_sz); 624 624 625 - dev_dbg(cd->dev, "%s: btn_rec_size =%2Zd\n", __func__, 625 + dev_dbg(cd->dev, "%s: btn_rec_size =%2zd\n", __func__, 626 626 si->si_ofs.btn_rec_size); 627 - dev_dbg(cd->dev, "%s: btn_diff_ofs =%2Zd\n", __func__, 627 + dev_dbg(cd->dev, "%s: btn_diff_ofs =%2zd\n", __func__, 628 628 si->si_ofs.btn_diff_ofs); 629 - dev_dbg(cd->dev, "%s: btn_diff_size =%2Zd\n", __func__, 629 + dev_dbg(cd->dev, "%s: btn_diff_size =%2zd\n", __func__, 630 630 si->si_ofs.btn_diff_size); 631 631 632 - dev_dbg(cd->dev, "%s: max_x = 0x%04ZX (%Zd)\n", __func__, 632 + dev_dbg(cd->dev, "%s: max_x = 0x%04zX (%zd)\n", __func__, 633 633 si->si_ofs.max_x, si->si_ofs.max_x); 634 - dev_dbg(cd->dev, "%s: x_origin = %Zd (%s)\n", __func__, 634 + dev_dbg(cd->dev, "%s: x_origin = %zd (%s)\n", __func__, 635 635 si->si_ofs.x_origin, 636 636 si->si_ofs.x_origin == CY_NORMAL_ORIGIN ? 637 637 "left corner" : "right corner"); 638 - dev_dbg(cd->dev, "%s: max_y = 0x%04ZX (%Zd)\n", __func__, 638 + dev_dbg(cd->dev, "%s: max_y = 0x%04zX (%zd)\n", __func__, 639 639 si->si_ofs.max_y, si->si_ofs.max_y); 640 - dev_dbg(cd->dev, "%s: y_origin = %Zd (%s)\n", __func__, 640 + dev_dbg(cd->dev, "%s: y_origin = %zd (%s)\n", __func__, 641 641 si->si_ofs.y_origin, 642 642 si->si_ofs.y_origin == CY_NORMAL_ORIGIN ? 643 643 "upper corner" : "lower corner"); 644 - dev_dbg(cd->dev, "%s: max_p = 0x%04ZX (%Zd)\n", __func__, 644 + dev_dbg(cd->dev, "%s: max_p = 0x%04zX (%zd)\n", __func__, 645 645 si->si_ofs.max_p, si->si_ofs.max_p); 646 646 647 647 dev_dbg(cd->dev, "%s: xy_mode=%p xy_data=%p\n", __func__, ··· 1000 1000 dev_dbg(dev, "%s: Large area detected\n", __func__); 1001 1001 1002 1002 if (num_cur_tch > si->si_ofs.max_tchs) { 1003 - dev_err(dev, "%s: too many tch; set to max tch (n=%d c=%Zd)\n", 1003 + dev_err(dev, "%s: too many tch; set to max tch (n=%d c=%zd)\n", 1004 1004 __func__, num_cur_tch, si->si_ofs.max_tchs); 1005 1005 num_cur_tch = si->si_ofs.max_tchs; 1006 1006 }
+1 -1
drivers/media/dvb-frontends/helene.c
··· 309 309 310 310 if (len + 1 > sizeof(buf)) { 311 311 dev_warn(&priv->i2c->dev, 312 - "wr reg=%04x: len=%d vs %Zu is too big!\n", 312 + "wr reg=%04x: len=%d vs %zu is too big!\n", 313 313 reg, len + 1, sizeof(buf)); 314 314 return -E2BIG; 315 315 }
+1 -1
drivers/media/dvb-frontends/or51132.c
··· 133 133 u32 firmwareAsize, firmwareBsize; 134 134 int i,ret; 135 135 136 - dprintk("Firmware is %Zd bytes\n",fw->size); 136 + dprintk("Firmware is %zd bytes\n",fw->size); 137 137 138 138 /* Get size of firmware A and B */ 139 139 firmwareAsize = le32_to_cpu(*((__le32*)fw->data));
+1 -1
drivers/media/dvb-frontends/tda10048.c
··· 499 499 __func__); 500 500 return -EIO; 501 501 } else { 502 - printk(KERN_INFO "%s: firmware read %Zu bytes.\n", 502 + printk(KERN_INFO "%s: firmware read %zu bytes.\n", 503 503 __func__, 504 504 fw->size); 505 505 ret = 0;
+1 -1
drivers/media/pci/saa7164/saa7164-fw.c
··· 422 422 return -ENOMEM; 423 423 } 424 424 425 - printk(KERN_INFO "%s() firmware read %Zu bytes.\n", 425 + printk(KERN_INFO "%s() firmware read %zu bytes.\n", 426 426 __func__, fw->size); 427 427 428 428 if (fw->size != fwlength) {
+1 -1
drivers/media/tuners/xc5000.c
··· 1144 1144 pr_err("xc5000: Upload failed. rc %d\n", ret); 1145 1145 return ret; 1146 1146 } 1147 - dprintk(1, "firmware read %Zu bytes.\n", fw->size); 1147 + dprintk(1, "firmware read %zu bytes.\n", fw->size); 1148 1148 1149 1149 if (fw->size != desired_fw->size) { 1150 1150 pr_err("xc5000: Firmware file with incorrect size\n");
+2 -2
drivers/media/usb/dvb-usb/dib0700_devices.c
··· 2414 2414 deb_info("%s: Upload failed. (file not found?)\n", __func__); 2415 2415 return -ENODEV; 2416 2416 } else { 2417 - deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size); 2417 + deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size); 2418 2418 } 2419 2419 stk9090m_config.microcode_B_fe_size = state->frontend_firmware->size; 2420 2420 stk9090m_config.microcode_B_fe_buffer = state->frontend_firmware->data; ··· 2480 2480 deb_info("%s: Upload failed. (file not found?)\n", __func__); 2481 2481 return -EIO; 2482 2482 } else { 2483 - deb_info("%s: firmware read %Zu bytes.\n", __func__, state->frontend_firmware->size); 2483 + deb_info("%s: firmware read %zu bytes.\n", __func__, state->frontend_firmware->size); 2484 2484 } 2485 2485 nim9090md_config[0].microcode_B_fe_size = state->frontend_firmware->size; 2486 2486 nim9090md_config[0].microcode_B_fe_buffer = state->frontend_firmware->data;
+1 -1
drivers/misc/vmw_vmci/vmci_context.c
··· 303 303 304 304 vmci_dg_size = VMCI_DG_SIZE(dg); 305 305 if (vmci_dg_size > VMCI_MAX_DG_SIZE) { 306 - pr_devel("Datagram too large (bytes=%Zu)\n", vmci_dg_size); 306 + pr_devel("Datagram too large (bytes=%zu)\n", vmci_dg_size); 307 307 return VMCI_ERROR_INVALID_ARGS; 308 308 } 309 309
+1 -1
drivers/net/arcnet/arcnet.c
··· 123 123 arc_proto_map[count] = arc_proto_default; 124 124 125 125 if (BUGLVL(D_DURING)) 126 - pr_info("struct sizes: %Zd %Zd %Zd %Zd %Zd\n", 126 + pr_info("struct sizes: %zd %zd %zd %zd %zd\n", 127 127 sizeof(struct arc_hardware), 128 128 sizeof(struct arc_rfc1201), 129 129 sizeof(struct arc_rfc1051),
+1 -1
drivers/net/ethernet/cadence/macb.c
··· 1622 1622 } 1623 1623 } 1624 1624 1625 - netdev_dbg(bp->dev, "mtu [%u] rx_buffer_size [%Zu]\n", 1625 + netdev_dbg(bp->dev, "mtu [%u] rx_buffer_size [%zu]\n", 1626 1626 bp->dev->mtu, bp->rx_buffer_size); 1627 1627 } 1628 1628
+1 -1
drivers/net/gtp.c
··· 1330 1330 if (err < 0) 1331 1331 goto unreg_genl_family; 1332 1332 1333 - pr_info("GTP module loaded (pdp ctx size %Zd bytes)\n", 1333 + pr_info("GTP module loaded (pdp ctx size %zd bytes)\n", 1334 1334 sizeof(struct pdp_ctx)); 1335 1335 return 0; 1336 1336
+1 -1
drivers/net/usb/rndis_host.c
··· 383 383 384 384 /* REVISIT: peripheral "alignment" request is ignored ... */ 385 385 dev_dbg(&intf->dev, 386 - "hard mtu %u (%u from dev), rx buflen %Zu, align %d\n", 386 + "hard mtu %u (%u from dev), rx buflen %zu, align %d\n", 387 387 dev->hard_mtu, tmp, dev->rx_urb_size, 388 388 1 << le32_to_cpu(u.init_c->packet_alignment)); 389 389
+1 -1
drivers/net/usb/sierra_net.c
··· 379 379 u32 expected_length; 380 380 381 381 if (datalen < sizeof(struct lsi_umts_single)) { 382 - netdev_err(dev->net, "%s: Data length %d, exp >= %Zu\n", 382 + netdev_err(dev->net, "%s: Data length %d, exp >= %zu\n", 383 383 __func__, datalen, sizeof(struct lsi_umts_single)); 384 384 return -1; 385 385 }
+1 -1
drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c
··· 4874 4874 kfree(af_params); 4875 4875 } else { 4876 4876 brcmf_dbg(TRACE, "Unhandled, fc=%04x!!\n", mgmt->frame_control); 4877 - brcmf_dbg_hex_dump(true, buf, len, "payload, len=%Zu\n", len); 4877 + brcmf_dbg_hex_dump(true, buf, len, "payload, len=%zu\n", len); 4878 4878 } 4879 4879 4880 4880 exit:
+15 -15
drivers/net/wireless/intel/iwlegacy/4965-mac.c
··· 4855 4855 */ 4856 4856 4857 4857 D_INFO("f/w package hdr ucode version raw = 0x%x\n", il->ucode_ver); 4858 - D_INFO("f/w package hdr runtime inst size = %Zd\n", pieces.inst_size); 4859 - D_INFO("f/w package hdr runtime data size = %Zd\n", pieces.data_size); 4860 - D_INFO("f/w package hdr init inst size = %Zd\n", pieces.init_size); 4861 - D_INFO("f/w package hdr init data size = %Zd\n", pieces.init_data_size); 4862 - D_INFO("f/w package hdr boot inst size = %Zd\n", pieces.boot_size); 4858 + D_INFO("f/w package hdr runtime inst size = %zd\n", pieces.inst_size); 4859 + D_INFO("f/w package hdr runtime data size = %zd\n", pieces.data_size); 4860 + D_INFO("f/w package hdr init inst size = %zd\n", pieces.init_size); 4861 + D_INFO("f/w package hdr init data size = %zd\n", pieces.init_data_size); 4862 + D_INFO("f/w package hdr boot inst size = %zd\n", pieces.boot_size); 4863 4863 4864 4864 /* Verify that uCode images will fit in card's SRAM */ 4865 4865 if (pieces.inst_size > il->hw_params.max_inst_size) { 4866 - IL_ERR("uCode instr len %Zd too large to fit in\n", 4866 + IL_ERR("uCode instr len %zd too large to fit in\n", 4867 4867 pieces.inst_size); 4868 4868 goto try_again; 4869 4869 } 4870 4870 4871 4871 if (pieces.data_size > il->hw_params.max_data_size) { 4872 - IL_ERR("uCode data len %Zd too large to fit in\n", 4872 + IL_ERR("uCode data len %zd too large to fit in\n", 4873 4873 pieces.data_size); 4874 4874 goto try_again; 4875 4875 } 4876 4876 4877 4877 if (pieces.init_size > il->hw_params.max_inst_size) { 4878 - IL_ERR("uCode init instr len %Zd too large to fit in\n", 4878 + IL_ERR("uCode init instr len %zd too large to fit in\n", 4879 4879 pieces.init_size); 4880 4880 goto try_again; 4881 4881 } 4882 4882 4883 4883 if (pieces.init_data_size > il->hw_params.max_data_size) { 4884 - IL_ERR("uCode init data len %Zd too large to fit in\n", 4884 + IL_ERR("uCode init data len %zd too large to fit in\n", 4885 4885 pieces.init_data_size); 4886 4886 goto try_again; 4887 4887 } 4888 4888 4889 4889 if (pieces.boot_size > il->hw_params.max_bsm_size) { 4890 - IL_ERR("uCode boot instr len %Zd too large to fit in\n", 4890 + IL_ERR("uCode boot instr len %zd too large to fit in\n", 4891 4891 pieces.boot_size); 4892 4892 goto try_again; 4893 4893 } ··· 4938 4938 /* Copy images into buffers for card's bus-master reads ... */ 4939 4939 4940 4940 /* Runtime instructions (first block of data in file) */ 4941 - D_INFO("Copying (but not loading) uCode instr len %Zd\n", 4941 + D_INFO("Copying (but not loading) uCode instr len %zd\n", 4942 4942 pieces.inst_size); 4943 4943 memcpy(il->ucode_code.v_addr, pieces.inst, pieces.inst_size); 4944 4944 ··· 4949 4949 * Runtime data 4950 4950 * NOTE: Copy into backup buffer will be done in il_up() 4951 4951 */ 4952 - D_INFO("Copying (but not loading) uCode data len %Zd\n", 4952 + D_INFO("Copying (but not loading) uCode data len %zd\n", 4953 4953 pieces.data_size); 4954 4954 memcpy(il->ucode_data.v_addr, pieces.data, pieces.data_size); 4955 4955 memcpy(il->ucode_data_backup.v_addr, pieces.data, pieces.data_size); 4956 4956 4957 4957 /* Initialization instructions */ 4958 4958 if (pieces.init_size) { 4959 - D_INFO("Copying (but not loading) init instr len %Zd\n", 4959 + D_INFO("Copying (but not loading) init instr len %zd\n", 4960 4960 pieces.init_size); 4961 4961 memcpy(il->ucode_init.v_addr, pieces.init, pieces.init_size); 4962 4962 } 4963 4963 4964 4964 /* Initialization data */ 4965 4965 if (pieces.init_data_size) { 4966 - D_INFO("Copying (but not loading) init data len %Zd\n", 4966 + D_INFO("Copying (but not loading) init data len %zd\n", 4967 4967 pieces.init_data_size); 4968 4968 memcpy(il->ucode_init_data.v_addr, pieces.init_data, 4969 4969 pieces.init_data_size); 4970 4970 } 4971 4971 4972 4972 /* Bootstrap instructions */ 4973 - D_INFO("Copying (but not loading) boot instr len %Zd\n", 4973 + D_INFO("Copying (but not loading) boot instr len %zd\n", 4974 4974 pieces.boot_size); 4975 4975 memcpy(il->ucode_boot.v_addr, pieces.boot, pieces.boot_size); 4976 4976
+8 -8
drivers/net/wireless/intel/iwlwifi/iwl-drv.c
··· 1141 1141 struct iwl_firmware_pieces *pieces, 1142 1142 const struct iwl_cfg *cfg) 1143 1143 { 1144 - IWL_DEBUG_INFO(drv, "f/w package hdr runtime inst size = %Zd\n", 1144 + IWL_DEBUG_INFO(drv, "f/w package hdr runtime inst size = %zd\n", 1145 1145 get_sec_size(pieces, IWL_UCODE_REGULAR, 1146 1146 IWL_UCODE_SECTION_INST)); 1147 - IWL_DEBUG_INFO(drv, "f/w package hdr runtime data size = %Zd\n", 1147 + IWL_DEBUG_INFO(drv, "f/w package hdr runtime data size = %zd\n", 1148 1148 get_sec_size(pieces, IWL_UCODE_REGULAR, 1149 1149 IWL_UCODE_SECTION_DATA)); 1150 - IWL_DEBUG_INFO(drv, "f/w package hdr init inst size = %Zd\n", 1150 + IWL_DEBUG_INFO(drv, "f/w package hdr init inst size = %zd\n", 1151 1151 get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST)); 1152 - IWL_DEBUG_INFO(drv, "f/w package hdr init data size = %Zd\n", 1152 + IWL_DEBUG_INFO(drv, "f/w package hdr init data size = %zd\n", 1153 1153 get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA)); 1154 1154 1155 1155 /* Verify that uCode images will fit in card's SRAM. */ 1156 1156 if (get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_INST) > 1157 1157 cfg->max_inst_size) { 1158 - IWL_ERR(drv, "uCode instr len %Zd too large to fit in\n", 1158 + IWL_ERR(drv, "uCode instr len %zd too large to fit in\n", 1159 1159 get_sec_size(pieces, IWL_UCODE_REGULAR, 1160 1160 IWL_UCODE_SECTION_INST)); 1161 1161 return -1; ··· 1163 1163 1164 1164 if (get_sec_size(pieces, IWL_UCODE_REGULAR, IWL_UCODE_SECTION_DATA) > 1165 1165 cfg->max_data_size) { 1166 - IWL_ERR(drv, "uCode data len %Zd too large to fit in\n", 1166 + IWL_ERR(drv, "uCode data len %zd too large to fit in\n", 1167 1167 get_sec_size(pieces, IWL_UCODE_REGULAR, 1168 1168 IWL_UCODE_SECTION_DATA)); 1169 1169 return -1; ··· 1171 1171 1172 1172 if (get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_INST) > 1173 1173 cfg->max_inst_size) { 1174 - IWL_ERR(drv, "uCode init instr len %Zd too large to fit in\n", 1174 + IWL_ERR(drv, "uCode init instr len %zd too large to fit in\n", 1175 1175 get_sec_size(pieces, IWL_UCODE_INIT, 1176 1176 IWL_UCODE_SECTION_INST)); 1177 1177 return -1; ··· 1179 1179 1180 1180 if (get_sec_size(pieces, IWL_UCODE_INIT, IWL_UCODE_SECTION_DATA) > 1181 1181 cfg->max_data_size) { 1182 - IWL_ERR(drv, "uCode init data len %Zd too large to fit in\n", 1182 + IWL_ERR(drv, "uCode init data len %zd too large to fit in\n", 1183 1183 get_sec_size(pieces, IWL_UCODE_REGULAR, 1184 1184 IWL_UCODE_SECTION_DATA)); 1185 1185 return -1;
+1 -1
drivers/parport/ieee1284_ops.c
··· 307 307 if (parport_read_status (port) & PARPORT_STATUS_ERROR) { 308 308 end_of_data: 309 309 DPRINTK (KERN_DEBUG 310 - "%s: No more byte data (%Zd bytes)\n", 310 + "%s: No more byte data (%zd bytes)\n", 311 311 port->name, count); 312 312 313 313 /* Go to reverse idle phase. */
+1 -1
drivers/scsi/osd/osd_initiator.c
··· 1290 1290 or->enc_get_attr.total_bytes = total_bytes; 1291 1291 1292 1292 OSD_DEBUG( 1293 - "get_attr.total_bytes=%u(%u) enc_get_attr.total_bytes=%u(%Zu)\n", 1293 + "get_attr.total_bytes=%u(%u) enc_get_attr.total_bytes=%u(%zu)\n", 1294 1294 or->get_attr.total_bytes, 1295 1295 or->get_attr.total_bytes - _osd_req_sizeof_alist_header(or), 1296 1296 or->enc_get_attr.total_bytes,
+3 -3
drivers/scsi/osst.c
··· 3435 3435 3436 3436 /* Write must be integral number of blocks */ 3437 3437 if (STp->block_size != 0 && (count % STp->block_size) != 0) { 3438 - printk(KERN_ERR "%s:E: Write (%Zd bytes) not multiple of tape block size (%d%c).\n", 3438 + printk(KERN_ERR "%s:E: Write (%zd bytes) not multiple of tape block size (%d%c).\n", 3439 3439 name, count, STp->block_size<1024? 3440 3440 STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k'); 3441 3441 retval = (-EINVAL); ··· 3756 3756 3757 3757 if ((count % STp->block_size) != 0) { 3758 3758 printk(KERN_WARNING 3759 - "%s:W: Read (%Zd bytes) not multiple of tape block size (%d%c).\n", name, count, 3759 + "%s:W: Read (%zd bytes) not multiple of tape block size (%d%c).\n", name, count, 3760 3760 STp->block_size<1024?STp->block_size:STp->block_size/1024, STp->block_size<1024?'b':'k'); 3761 3761 } 3762 3762 ··· 3815 3815 3816 3816 if (transfer == 0) { 3817 3817 printk(KERN_WARNING 3818 - "%s:W: Nothing can be transferred, requested %Zd, tape block size (%d%c).\n", 3818 + "%s:W: Nothing can be transferred, requested %zd, tape block size (%d%c).\n", 3819 3819 name, count, STp->block_size < 1024? 3820 3820 STp->block_size:STp->block_size/1024, 3821 3821 STp->block_size<1024?'b':'k');
+5 -5
drivers/scsi/qla2xxx/qla_init.c
··· 5669 5669 /* Validate firmware image by checking version. */ 5670 5670 if (blob->fw->size < 8 * sizeof(uint16_t)) { 5671 5671 ql_log(ql_log_fatal, vha, 0x0085, 5672 - "Unable to verify integrity of firmware image (%Zd).\n", 5672 + "Unable to verify integrity of firmware image (%zd).\n", 5673 5673 blob->fw->size); 5674 5674 goto fail_fw_integrity; 5675 5675 } ··· 5697 5697 if (blob->fw->size < fwclen) { 5698 5698 ql_log(ql_log_fatal, vha, 0x0088, 5699 5699 "Unable to verify integrity of firmware image " 5700 - "(%Zd).\n", blob->fw->size); 5700 + "(%zd).\n", blob->fw->size); 5701 5701 goto fail_fw_integrity; 5702 5702 } 5703 5703 ··· 5778 5778 /* Validate firmware image by checking version. */ 5779 5779 if (blob->fw->size < 8 * sizeof(uint32_t)) { 5780 5780 ql_log(ql_log_fatal, vha, 0x0093, 5781 - "Unable to verify integrity of firmware image (%Zd).\n", 5781 + "Unable to verify integrity of firmware image (%zd).\n", 5782 5782 blob->fw->size); 5783 5783 return QLA_FUNCTION_FAILED; 5784 5784 } ··· 5789 5789 (dcode[0] == 0 && dcode[1] == 0 && dcode[2] == 0 && 5790 5790 dcode[3] == 0)) { 5791 5791 ql_log(ql_log_fatal, vha, 0x0094, 5792 - "Unable to verify integrity of firmware image (%Zd).\n", 5792 + "Unable to verify integrity of firmware image (%zd).\n", 5793 5793 blob->fw->size); 5794 5794 ql_log(ql_log_fatal, vha, 0x0095, 5795 5795 "Firmware data: %08x %08x %08x %08x.\n", ··· 5807 5807 if (blob->fw->size < fwclen) { 5808 5808 ql_log(ql_log_fatal, vha, 0x0096, 5809 5809 "Unable to verify integrity of firmware image " 5810 - "(%Zd).\n", blob->fw->size); 5810 + "(%zd).\n", blob->fw->size); 5811 5811 return QLA_FUNCTION_FAILED; 5812 5812 } 5813 5813
+1 -1
drivers/tty/n_hdlc.c
··· 667 667 struct n_hdlc_buf *tbuf; 668 668 669 669 if (debuglevel >= DEBUG_LEVEL_INFO) 670 - printk("%s(%d)n_hdlc_tty_write() called count=%Zd\n", 670 + printk("%s(%d)n_hdlc_tty_write() called count=%zd\n", 671 671 __FILE__,__LINE__,count); 672 672 673 673 /* Verify pointers */
+1 -1
drivers/usb/gadget/legacy/inode.c
··· 1848 1848 1849 1849 fail: 1850 1850 spin_unlock_irq (&dev->lock); 1851 - pr_debug ("%s: %s fail %Zd, %p\n", shortname, __func__, value, dev); 1851 + pr_debug ("%s: %s fail %zd, %p\n", shortname, __func__, value, dev); 1852 1852 kfree (dev->buf); 1853 1853 dev->buf = NULL; 1854 1854 return value;
+1 -1
drivers/usb/host/ehci-hcd.c
··· 1322 1322 printk(KERN_WARNING "Warning! ehci_hcd should always be loaded" 1323 1323 " before uhci_hcd and ohci_hcd, not after\n"); 1324 1324 1325 - pr_debug("%s: block sizes: qh %Zd qtd %Zd itd %Zd sitd %Zd\n", 1325 + pr_debug("%s: block sizes: qh %zd qtd %zd itd %zd sitd %zd\n", 1326 1326 hcd_name, 1327 1327 sizeof(struct ehci_qh), sizeof(struct ehci_qtd), 1328 1328 sizeof(struct ehci_itd), sizeof(struct ehci_sitd));
+1 -1
drivers/usb/host/fotg210-hcd.c
··· 5697 5697 test_bit(USB_OHCI_LOADED, &usb_hcds_loaded)) 5698 5698 pr_warn("Warning! fotg210_hcd should always be loaded before uhci_hcd and ohci_hcd, not after\n"); 5699 5699 5700 - pr_debug("%s: block sizes: qh %Zd qtd %Zd itd %Zd\n", 5700 + pr_debug("%s: block sizes: qh %zd qtd %zd itd %zd\n", 5701 5701 hcd_name, sizeof(struct fotg210_qh), 5702 5702 sizeof(struct fotg210_qtd), 5703 5703 sizeof(struct fotg210_itd));
+1 -1
drivers/usb/host/ohci-hcd.c
··· 1252 1252 return -ENODEV; 1253 1253 1254 1254 printk(KERN_INFO "%s: " DRIVER_DESC "\n", hcd_name); 1255 - pr_debug ("%s: block sizes: ed %Zd td %Zd\n", hcd_name, 1255 + pr_debug ("%s: block sizes: ed %zd td %zd\n", hcd_name, 1256 1256 sizeof (struct ed), sizeof (struct td)); 1257 1257 set_bit(USB_OHCI_LOADED, &usb_hcds_loaded); 1258 1258
+3 -3
drivers/usb/misc/adutux.c
··· 563 563 } 564 564 565 565 dev_dbg(&dev->udev->dev, 566 - "%s : in progress, count = %Zd\n", 566 + "%s : in progress, count = %zd\n", 567 567 __func__, count); 568 568 } else { 569 569 spin_unlock_irqrestore(&dev->buflock, flags); 570 570 set_current_state(TASK_RUNNING); 571 571 remove_wait_queue(&dev->write_wait, &waita); 572 - dev_dbg(&dev->udev->dev, "%s : sending, count = %Zd\n", 572 + dev_dbg(&dev->udev->dev, "%s : sending, count = %zd\n", 573 573 __func__, count); 574 574 575 575 /* write the data into interrupt_out_buffer from userspace */ 576 576 buffer_size = usb_endpoint_maxp(dev->interrupt_out_endpoint); 577 577 bytes_to_write = count > buffer_size ? buffer_size : count; 578 578 dev_dbg(&dev->udev->dev, 579 - "%s : buffer_size = %Zd, count = %Zd, bytes_to_write = %Zd\n", 579 + "%s : buffer_size = %zd, count = %zd, bytes_to_write = %zd\n", 580 580 __func__, buffer_size, count, bytes_to_write); 581 581 582 582 if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write) != 0) {
+1 -1
drivers/usb/misc/legousbtower.c
··· 673 673 674 674 /* write the data into interrupt_out_buffer from userspace */ 675 675 bytes_to_write = min_t(int, count, write_buffer_size); 676 - dev_dbg(&dev->udev->dev, "%s: count = %Zd, bytes_to_write = %Zd\n", 676 + dev_dbg(&dev->udev->dev, "%s: count = %zd, bytes_to_write = %zd\n", 677 677 __func__, count, bytes_to_write); 678 678 679 679 if (copy_from_user (dev->interrupt_out_buffer, buffer, bytes_to_write)) {
+4 -4
drivers/usb/misc/uss720.c
··· 526 526 return 0; 527 527 i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buf, length, &rlen, 20000); 528 528 if (i) 529 - printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buf, length, rlen); 529 + printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %zu rlen %u\n", buf, length, rlen); 530 530 change_mode(pp, ECR_PS2); 531 531 return rlen; 532 532 #endif ··· 587 587 return 0; 588 588 i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buffer, len, &rlen, 20000); 589 589 if (i) 590 - printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buffer, len, rlen); 590 + printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %zu rlen %u\n", buffer, len, rlen); 591 591 change_mode(pp, ECR_PS2); 592 592 return rlen; 593 593 } ··· 605 605 return 0; 606 606 i = usb_bulk_msg(usbdev, usb_rcvbulkpipe(usbdev, 2), buffer, len, &rlen, 20000); 607 607 if (i) 608 - printk(KERN_ERR "uss720: recvbulk ep 2 buf %p len %Zu rlen %u\n", buffer, len, rlen); 608 + printk(KERN_ERR "uss720: recvbulk ep 2 buf %p len %zu rlen %u\n", buffer, len, rlen); 609 609 change_mode(pp, ECR_PS2); 610 610 return rlen; 611 611 } ··· 638 638 return 0; 639 639 i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buffer, len, &rlen, 20000); 640 640 if (i) 641 - printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buffer, len, rlen); 641 + printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %zu rlen %u\n", buffer, len, rlen); 642 642 change_mode(pp, ECR_PS2); 643 643 return rlen; 644 644 }
+1 -1
drivers/video/fbdev/metronomefb.c
··· 187 187 epd_frame_table[par->dt].wfm_size = user_wfm_size; 188 188 189 189 if (size != epd_frame_table[par->dt].wfm_size) { 190 - dev_err(dev, "Error: unexpected size %Zd != %d\n", size, 190 + dev_err(dev, "Error: unexpected size %zd != %d\n", size, 191 191 epd_frame_table[par->dt].wfm_size); 192 192 return -EINVAL; 193 193 }
+7 -7
fs/afs/dir.c
··· 252 252 /* skip entries marked unused in the bitmap */ 253 253 if (!(block->pagehdr.bitmap[offset / 8] & 254 254 (1 << (offset % 8)))) { 255 - _debug("ENT[%Zu.%u]: unused", 255 + _debug("ENT[%zu.%u]: unused", 256 256 blkoff / sizeof(union afs_dir_block), offset); 257 257 if (offset >= curr) 258 258 ctx->pos = blkoff + ··· 266 266 sizeof(*block) - 267 267 offset * sizeof(union afs_dirent)); 268 268 269 - _debug("ENT[%Zu.%u]: %s %Zu \"%s\"", 269 + _debug("ENT[%zu.%u]: %s %zu \"%s\"", 270 270 blkoff / sizeof(union afs_dir_block), offset, 271 271 (offset < curr ? "skip" : "fill"), 272 272 nlen, dire->u.name); ··· 274 274 /* work out where the next possible entry is */ 275 275 for (tmp = nlen; tmp > 15; tmp -= sizeof(union afs_dirent)) { 276 276 if (next >= AFS_DIRENT_PER_BLOCK) { 277 - _debug("ENT[%Zu.%u]:" 277 + _debug("ENT[%zu.%u]:" 278 278 " %u travelled beyond end dir block" 279 - " (len %u/%Zu)", 279 + " (len %u/%zu)", 280 280 blkoff / sizeof(union afs_dir_block), 281 281 offset, next, tmp, nlen); 282 282 return -EIO; 283 283 } 284 284 if (!(block->pagehdr.bitmap[next / 8] & 285 285 (1 << (next % 8)))) { 286 - _debug("ENT[%Zu.%u]:" 287 - " %u unmarked extension (len %u/%Zu)", 286 + _debug("ENT[%zu.%u]:" 287 + " %u unmarked extension (len %u/%zu)", 288 288 blkoff / sizeof(union afs_dir_block), 289 289 offset, next, tmp, nlen); 290 290 return -EIO; 291 291 } 292 292 293 - _debug("ENT[%Zu.%u]: ext %u/%Zu", 293 + _debug("ENT[%zu.%u]: ext %u/%zu", 294 294 blkoff / sizeof(union afs_dir_block), 295 295 next, tmp, nlen); 296 296 next++;
+2 -2
fs/ncpfs/sock.c
··· 525 525 return result; 526 526 } 527 527 if (result > len) { 528 - pr_err("tcp: bug in recvmsg (%u > %Zu)\n", result, len); 528 + pr_err("tcp: bug in recvmsg (%u > %zu)\n", result, len); 529 529 return -EIO; 530 530 } 531 531 return result; ··· 619 619 goto skipdata2; 620 620 } 621 621 if (datalen > req->datalen + 8) { 622 - pr_err("tcp: Unexpected reply len %d (expected at most %Zd)\n", datalen, req->datalen + 8); 622 + pr_err("tcp: Unexpected reply len %d (expected at most %zd)\n", datalen, req->datalen + 8); 623 623 server->rcv.state = 3; 624 624 goto skipdata; 625 625 }
+1 -1
fs/nfs/blocklayout/blocklayout.c
··· 381 381 struct blk_plug plug; 382 382 int i; 383 383 384 - dprintk("%s enter, %Zu@%lld\n", __func__, count, offset); 384 + dprintk("%s enter, %zu@%lld\n", __func__, count, offset); 385 385 386 386 /* At this point, header->page_aray is a (sequential) list of nfs_pages. 387 387 * We want to write each, and if there is an error set pnfs_error
+2 -2
fs/nfs/filelayout/filelayout.c
··· 482 482 u32 j, idx; 483 483 struct nfs_fh *fh; 484 484 485 - dprintk("--> %s ino %lu pgbase %u req %Zu@%llu\n", 485 + dprintk("--> %s ino %lu pgbase %u req %zu@%llu\n", 486 486 __func__, hdr->inode->i_ino, 487 487 hdr->args.pgbase, (size_t)hdr->args.count, offset); 488 488 ··· 540 540 if (IS_ERR(ds_clnt)) 541 541 return PNFS_NOT_ATTEMPTED; 542 542 543 - dprintk("%s ino %lu sync %d req %Zu@%llu DS: %s cl_count %d\n", 543 + dprintk("%s ino %lu sync %d req %zu@%llu DS: %s cl_count %d\n", 544 544 __func__, hdr->inode->i_ino, sync, (size_t) hdr->args.count, 545 545 offset, ds->ds_remotestr, atomic_read(&ds->ds_clp->cl_count)); 546 546
+2 -2
fs/nfs/flexfilelayout/flexfilelayout.c
··· 1751 1751 int vers; 1752 1752 struct nfs_fh *fh; 1753 1753 1754 - dprintk("--> %s ino %lu pgbase %u req %Zu@%llu\n", 1754 + dprintk("--> %s ino %lu pgbase %u req %zu@%llu\n", 1755 1755 __func__, hdr->inode->i_ino, 1756 1756 hdr->args.pgbase, (size_t)hdr->args.count, offset); 1757 1757 ··· 1828 1828 1829 1829 vers = nfs4_ff_layout_ds_version(lseg, idx); 1830 1830 1831 - dprintk("%s ino %lu sync %d req %Zu@%llu DS: %s cl_count %d vers %d\n", 1831 + dprintk("%s ino %lu sync %d req %zu@%llu DS: %s cl_count %d vers %d\n", 1832 1832 __func__, hdr->inode->i_ino, sync, (size_t) hdr->args.count, 1833 1833 offset, ds->ds_remotestr, atomic_read(&ds->ds_clp->cl_count), 1834 1834 vers);
+1 -1
fs/nfs/objlayout/objlayout.c
··· 291 291 &hdr->args.pgbase, 292 292 hdr->args.offset, hdr->args.count); 293 293 294 - dprintk("%s: inode(%lx) offset 0x%llx count 0x%Zx eof=%d\n", 294 + dprintk("%s: inode(%lx) offset 0x%llx count 0x%zx eof=%d\n", 295 295 __func__, inode->i_ino, offset, count, hdr->res.eof); 296 296 297 297 err = objio_read_pagelist(hdr);
+1 -1
fs/nfsd/nfscache.c
··· 578 578 struct kvec *vec = &rqstp->rq_res.head[0]; 579 579 580 580 if (vec->iov_len + data->iov_len > PAGE_SIZE) { 581 - printk(KERN_WARNING "nfsd: cached reply too large (%Zd).\n", 581 + printk(KERN_WARNING "nfsd: cached reply too large (%zd).\n", 582 582 data->iov_len); 583 583 return 0; 584 584 }
+1 -1
kernel/relay.c
··· 847 847 848 848 if (chan->last_toobig) 849 849 printk(KERN_WARNING "relay: one or more items not logged " 850 - "[item size (%Zd) > sub-buffer size (%Zd)]\n", 850 + "[item size (%zd) > sub-buffer size (%zd)]\n", 851 851 chan->last_toobig, chan->subbuf_size); 852 852 853 853 list_del(&chan->list);
+4 -4
lib/vsprintf.c
··· 1739 1739 * 'h', 'l', or 'L' for integer fields 1740 1740 * 'z' support added 23/7/1999 S.H. 1741 1741 * 'z' changed to 'Z' --davidm 1/25/99 1742 + * 'Z' changed to 'z' --adobriyan 2017-01-25 1742 1743 * 't' added for ptrdiff_t 1743 1744 * 1744 1745 * @fmt: the format string ··· 1839 1838 /* get the conversion qualifier */ 1840 1839 qualifier = 0; 1841 1840 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 1842 - _tolower(*fmt) == 'z' || *fmt == 't') { 1841 + *fmt == 'z' || *fmt == 't') { 1843 1842 qualifier = *fmt++; 1844 1843 if (unlikely(qualifier == *fmt)) { 1845 1844 if (qualifier == 'l') { ··· 1908 1907 else if (qualifier == 'l') { 1909 1908 BUILD_BUG_ON(FORMAT_TYPE_ULONG + SIGN != FORMAT_TYPE_LONG); 1910 1909 spec->type = FORMAT_TYPE_ULONG + (spec->flags & SIGN); 1911 - } else if (_tolower(qualifier) == 'z') { 1910 + } else if (qualifier == 'z') { 1912 1911 spec->type = FORMAT_TYPE_SIZE_T; 1913 1912 } else if (qualifier == 't') { 1914 1913 spec->type = FORMAT_TYPE_PTRDIFF; ··· 2658 2657 /* get conversion qualifier */ 2659 2658 qualifier = -1; 2660 2659 if (*fmt == 'h' || _tolower(*fmt) == 'l' || 2661 - _tolower(*fmt) == 'z') { 2660 + *fmt == 'z') { 2662 2661 qualifier = *fmt++; 2663 2662 if (unlikely(qualifier == *fmt)) { 2664 2663 if (qualifier == 'h') { ··· 2852 2851 else 2853 2852 *va_arg(args, unsigned long long *) = val.u; 2854 2853 break; 2855 - case 'Z': 2856 2854 case 'z': 2857 2855 *va_arg(args, size_t *) = val.u; 2858 2856 break;
+1 -1
mm/dmapool.c
··· 93 93 spin_unlock_irq(&pool->lock); 94 94 95 95 /* per-pool info, no real statistics yet */ 96 - temp = scnprintf(next, size, "%-16s %4u %4Zu %4Zu %2u\n", 96 + temp = scnprintf(next, size, "%-16s %4u %4zu %4zu %2u\n", 97 97 pool->name, blocks, 98 98 pages * (pool->allocation / pool->size), 99 99 pool->size, pages);
+2 -2
net/appletalk/ddp.c
··· 1656 1656 ddp->deh_dport = usat->sat_port; 1657 1657 ddp->deh_sport = at->src_port; 1658 1658 1659 - SOCK_DEBUG(sk, "SK %p: Copy user data (%Zd bytes).\n", sk, len); 1659 + SOCK_DEBUG(sk, "SK %p: Copy user data (%zd bytes).\n", sk, len); 1660 1660 1661 1661 err = memcpy_from_msg(skb_put(skb, len), msg, len); 1662 1662 if (err) { ··· 1720 1720 */ 1721 1721 aarp_send_ddp(dev, skb, &usat->sat_addr, NULL); 1722 1722 } 1723 - SOCK_DEBUG(sk, "SK %p: Done write (%Zd).\n", sk, len); 1723 + SOCK_DEBUG(sk, "SK %p: Done write (%zd).\n", sk, len); 1724 1724 1725 1725 out: 1726 1726 release_sock(sk);
+1 -1
net/atm/mpc.c
··· 451 451 return; 452 452 } 453 453 if (end_of_tlvs - tlvs != 0) 454 - pr_info("(%s) ignoring %Zd bytes of trailing TLV garbage\n", 454 + pr_info("(%s) ignoring %zd bytes of trailing TLV garbage\n", 455 455 dev->name, end_of_tlvs - tlvs); 456 456 } 457 457
+1 -1
net/bridge/netfilter/ebt_among.c
··· 187 187 expected_length += ebt_mac_wormhash_size(wh_src); 188 188 189 189 if (em->match_size != EBT_ALIGN(expected_length)) { 190 - pr_info("wrong size: %d against expected %d, rounded to %Zd\n", 190 + pr_info("wrong size: %d against expected %d, rounded to %zd\n", 191 191 em->match_size, expected_length, 192 192 EBT_ALIGN(expected_length)); 193 193 return -EINVAL;
+2 -2
net/ieee802154/socket.c
··· 279 279 pr_debug("name = %s, mtu = %u\n", dev->name, mtu); 280 280 281 281 if (size > mtu) { 282 - pr_debug("size = %Zu, mtu = %u\n", size, mtu); 282 + pr_debug("size = %zu, mtu = %u\n", size, mtu); 283 283 err = -EMSGSIZE; 284 284 goto out_dev; 285 285 } ··· 645 645 pr_debug("name = %s, mtu = %u\n", dev->name, mtu); 646 646 647 647 if (size > mtu) { 648 - pr_debug("size = %Zu, mtu = %u\n", size, mtu); 648 + pr_debug("size = %zu, mtu = %u\n", size, mtu); 649 649 err = -EMSGSIZE; 650 650 goto out_dev; 651 651 }
+1 -1
net/ipv4/fib_trie.c
··· 2388 2388 2389 2389 seq_printf(seq, 2390 2390 "Basic info: size of leaf:" 2391 - " %Zd bytes, size of tnode: %Zd bytes.\n", 2391 + " %zd bytes, size of tnode: %zd bytes.\n", 2392 2392 LEAF_SIZE, TNODE_SIZE(0)); 2393 2393 2394 2394 for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
+1 -1
net/ipv4/ipmr.c
··· 2596 2596 const char *name = vif->dev ? vif->dev->name : "none"; 2597 2597 2598 2598 seq_printf(seq, 2599 - "%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n", 2599 + "%2zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n", 2600 2600 vif - mrt->vif_table, 2601 2601 name, vif->bytes_in, vif->pkt_in, 2602 2602 vif->bytes_out, vif->pkt_out,
+1 -1
net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
··· 235 235 } 236 236 237 237 if ((unsigned int) *len < sizeof(struct sockaddr_in)) { 238 - pr_debug("SO_ORIGINAL_DST: len %d not %Zu\n", 238 + pr_debug("SO_ORIGINAL_DST: len %d not %zu\n", 239 239 *len, sizeof(struct sockaddr_in)); 240 240 return -EINVAL; 241 241 }
+1 -1
net/ipv4/netfilter/nf_log_arp.c
··· 69 69 70 70 ap = skb_header_pointer(skb, sizeof(_arph), sizeof(_arpp), &_arpp); 71 71 if (ap == NULL) { 72 - nf_log_buf_add(m, " INCOMPLETE [%Zu bytes]", 72 + nf_log_buf_add(m, " INCOMPLETE [%zu bytes]", 73 73 skb->len - sizeof(_arph)); 74 74 return; 75 75 }
+1 -1
net/ipv6/netfilter/nf_log_ipv6.c
··· 64 64 nf_log_buf_add(m, "SRC=%pI6 DST=%pI6 ", &ih->saddr, &ih->daddr); 65 65 66 66 /* Max length: 44 "LEN=65535 TC=255 HOPLIMIT=255 FLOWLBL=FFFFF " */ 67 - nf_log_buf_add(m, "LEN=%Zu TC=%u HOPLIMIT=%u FLOWLBL=%u ", 67 + nf_log_buf_add(m, "LEN=%zu TC=%u HOPLIMIT=%u FLOWLBL=%u ", 68 68 ntohs(ih->payload_len) + sizeof(struct ipv6hdr), 69 69 (ntohl(*(__be32 *)ih) & 0x0ff00000) >> 20, 70 70 ih->hop_limit,
+6 -6
net/irda/irnet/irnet_ppp.c
··· 51 51 char * next; /* Next command to process */ 52 52 int length; /* Length of current command */ 53 53 54 - DENTER(CTRL_TRACE, "(ap=0x%p, count=%Zd)\n", ap, count); 54 + DENTER(CTRL_TRACE, "(ap=0x%p, count=%zd)\n", ap, count); 55 55 56 56 /* Check for overflow... */ 57 57 DABORT(count >= IRNET_MAX_COMMAND, -ENOMEM, ··· 66 66 67 67 /* Safe terminate the string */ 68 68 command[count] = '\0'; 69 - DEBUG(CTRL_INFO, "Command line received is ``%s'' (%Zd).\n", 69 + DEBUG(CTRL_INFO, "Command line received is ``%s'' (%zd).\n", 70 70 command, count); 71 71 72 72 /* Check every commands in the command line */ ··· 285 285 char event[75]; 286 286 ssize_t ret = 0; 287 287 288 - DENTER(CTRL_TRACE, "(ap=0x%p, count=%Zd)\n", ap, count); 288 + DENTER(CTRL_TRACE, "(ap=0x%p, count=%zd)\n", ap, count); 289 289 290 290 #ifdef INITIAL_DISCOVERY 291 291 /* Check if we have read the log */ ··· 328 328 if(ret != 0) 329 329 { 330 330 /* No, return the error code */ 331 - DEXIT(CTRL_TRACE, " - ret %Zd\n", ret); 331 + DEXIT(CTRL_TRACE, " - ret %zd\n", ret); 332 332 return ret; 333 333 } 334 334 ··· 568 568 { 569 569 irnet_socket * ap = file->private_data; 570 570 571 - DPASS(FS_TRACE, "(file=0x%p, ap=0x%p, count=%Zd)\n", 571 + DPASS(FS_TRACE, "(file=0x%p, ap=0x%p, count=%zd)\n", 572 572 file, ap, count); 573 573 DABORT(ap == NULL, -ENXIO, FS_ERROR, "ap is NULL !!!\n"); 574 574 ··· 592 592 { 593 593 irnet_socket * ap = file->private_data; 594 594 595 - DPASS(FS_TRACE, "(file=0x%p, ap=0x%p, count=%Zd)\n", 595 + DPASS(FS_TRACE, "(file=0x%p, ap=0x%p, count=%zd)\n", 596 596 file, ap, count); 597 597 DABORT(ap == NULL, -ENXIO, FS_ERROR, "ap is NULL !!!\n"); 598 598
+2 -2
net/l2tp/l2tp_core.c
··· 1058 1058 1059 1059 /* Debug */ 1060 1060 if (session->send_seq) 1061 - l2tp_dbg(session, L2TP_MSG_DATA, "%s: send %Zd bytes, ns=%u\n", 1061 + l2tp_dbg(session, L2TP_MSG_DATA, "%s: send %zd bytes, ns=%u\n", 1062 1062 session->name, data_len, session->ns - 1); 1063 1063 else 1064 - l2tp_dbg(session, L2TP_MSG_DATA, "%s: send %Zd bytes\n", 1064 + l2tp_dbg(session, L2TP_MSG_DATA, "%s: send %zd bytes\n", 1065 1065 session->name, data_len); 1066 1066 1067 1067 if (session->debug & L2TP_MSG_DATA) {
+1 -1
net/netfilter/ipvs/ip_vs_conn.c
··· 1429 1429 "(size=%d, memory=%ldKbytes)\n", 1430 1430 ip_vs_conn_tab_size, 1431 1431 (long)(ip_vs_conn_tab_size*sizeof(struct list_head))/1024); 1432 - IP_VS_DBG(0, "Each connection entry needs %Zd bytes at least\n", 1432 + IP_VS_DBG(0, "Each connection entry needs %zd bytes at least\n", 1433 1433 sizeof(struct ip_vs_conn)); 1434 1434 1435 1435 for (idx = 0; idx < ip_vs_conn_tab_size; idx++)
+2 -2
net/netfilter/ipvs/ip_vs_dh.c
··· 163 163 return -ENOMEM; 164 164 165 165 svc->sched_data = s; 166 - IP_VS_DBG(6, "DH hash table (memory=%Zdbytes) allocated for " 166 + IP_VS_DBG(6, "DH hash table (memory=%zdbytes) allocated for " 167 167 "current service\n", 168 168 sizeof(struct ip_vs_dh_bucket)*IP_VS_DH_TAB_SIZE); 169 169 ··· 183 183 184 184 /* release the table itself */ 185 185 kfree_rcu(s, rcu_head); 186 - IP_VS_DBG(6, "DH hash table (memory=%Zdbytes) released\n", 186 + IP_VS_DBG(6, "DH hash table (memory=%zdbytes) released\n", 187 187 sizeof(struct ip_vs_dh_bucket)*IP_VS_DH_TAB_SIZE); 188 188 } 189 189
+2 -2
net/netfilter/ipvs/ip_vs_lblc.c
··· 356 356 return -ENOMEM; 357 357 358 358 svc->sched_data = tbl; 359 - IP_VS_DBG(6, "LBLC hash table (memory=%Zdbytes) allocated for " 359 + IP_VS_DBG(6, "LBLC hash table (memory=%zdbytes) allocated for " 360 360 "current service\n", sizeof(*tbl)); 361 361 362 362 /* ··· 393 393 394 394 /* release the table itself */ 395 395 kfree_rcu(tbl, rcu_head); 396 - IP_VS_DBG(6, "LBLC hash table (memory=%Zdbytes) released\n", 396 + IP_VS_DBG(6, "LBLC hash table (memory=%zdbytes) released\n", 397 397 sizeof(*tbl)); 398 398 } 399 399
+2 -2
net/netfilter/ipvs/ip_vs_lblcr.c
··· 519 519 return -ENOMEM; 520 520 521 521 svc->sched_data = tbl; 522 - IP_VS_DBG(6, "LBLCR hash table (memory=%Zdbytes) allocated for " 522 + IP_VS_DBG(6, "LBLCR hash table (memory=%zdbytes) allocated for " 523 523 "current service\n", sizeof(*tbl)); 524 524 525 525 /* ··· 556 556 557 557 /* release the table itself */ 558 558 kfree_rcu(tbl, rcu_head); 559 - IP_VS_DBG(6, "LBLCR hash table (memory=%Zdbytes) released\n", 559 + IP_VS_DBG(6, "LBLCR hash table (memory=%zdbytes) released\n", 560 560 sizeof(*tbl)); 561 561 } 562 562
+2 -2
net/netfilter/ipvs/ip_vs_sh.c
··· 239 239 return -ENOMEM; 240 240 241 241 svc->sched_data = s; 242 - IP_VS_DBG(6, "SH hash table (memory=%Zdbytes) allocated for " 242 + IP_VS_DBG(6, "SH hash table (memory=%zdbytes) allocated for " 243 243 "current service\n", 244 244 sizeof(struct ip_vs_sh_bucket)*IP_VS_SH_TAB_SIZE); 245 245 ··· 259 259 260 260 /* release the table itself */ 261 261 kfree_rcu(s, rcu_head); 262 - IP_VS_DBG(6, "SH hash table (memory=%Zdbytes) released\n", 262 + IP_VS_DBG(6, "SH hash table (memory=%zdbytes) released\n", 263 263 sizeof(struct ip_vs_sh_bucket)*IP_VS_SH_TAB_SIZE); 264 264 } 265 265
+1 -1
net/netfilter/ipvs/ip_vs_sync.c
··· 1791 1791 u16 mtu, min_mtu; 1792 1792 1793 1793 IP_VS_DBG(7, "%s(): pid %d\n", __func__, task_pid_nr(current)); 1794 - IP_VS_DBG(7, "Each ip_vs_sync_conn entry needs %Zd bytes\n", 1794 + IP_VS_DBG(7, "Each ip_vs_sync_conn entry needs %zd bytes\n", 1795 1795 sizeof(struct ip_vs_sync_conn_v0)); 1796 1796 1797 1797 if (!ipvs->sync_state) {
+1 -1
net/netfilter/nf_conntrack_ftp.c
··· 300 300 { 301 301 size_t i = plen; 302 302 303 - pr_debug("find_pattern `%s': dlen = %Zu\n", pattern, dlen); 303 + pr_debug("find_pattern `%s': dlen = %zu\n", pattern, dlen); 304 304 305 305 if (dlen <= plen) { 306 306 /* Short packet: try for partial? */
+1 -1
net/sctp/output.c
··· 177 177 { 178 178 sctp_xmit_t retval; 179 179 180 - pr_debug("%s: packet:%p size:%Zu chunk:%p size:%d\n", __func__, 180 + pr_debug("%s: packet:%p size:%zu chunk:%p size:%d\n", __func__, 181 181 packet, packet->size, chunk, chunk->skb ? chunk->skb->len : -1); 182 182 183 183 switch ((retval = (sctp_packet_append_chunk(packet, chunk)))) {
+1 -1
net/sunrpc/auth_gss/auth_gss.c
··· 763 763 err: 764 764 kfree(buf); 765 765 out: 766 - dprintk("RPC: %s returning %Zd\n", __func__, err); 766 + dprintk("RPC: %s returning %zd\n", __func__, err); 767 767 return err; 768 768 } 769 769
+1 -1
net/sunrpc/svc.c
··· 1260 1260 return 0; 1261 1261 1262 1262 err_short_len: 1263 - svc_printk(rqstp, "short len %Zd, dropping request\n", 1263 + svc_printk(rqstp, "short len %zd, dropping request\n", 1264 1264 argv->iov_len); 1265 1265 goto close; 1266 1266
+2 -2
net/sunrpc/svcsock.c
··· 278 278 rqstp->rq_respages[0], tailoff); 279 279 280 280 out: 281 - dprintk("svc: socket %p sendto([%p %Zu... ], %d) = %d (addr %s)\n", 281 + dprintk("svc: socket %p sendto([%p %zu... ], %d) = %d (addr %s)\n", 282 282 svsk, xdr->head[0].iov_base, xdr->head[0].iov_len, 283 283 xdr->len, len, svc_print_addr(rqstp, buf, sizeof(buf))); 284 284 ··· 346 346 if (len == buflen) 347 347 set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags); 348 348 349 - dprintk("svc: socket %p recvfrom(%p, %Zu) = %d\n", 349 + dprintk("svc: socket %p recvfrom(%p, %zu) = %d\n", 350 350 svsk, iov[0].iov_base, iov[0].iov_len, len); 351 351 return len; 352 352 }
+4 -4
net/sunrpc/xprtsock.c
··· 1188 1188 char *p; 1189 1189 1190 1190 len = sizeof(transport->tcp_xid) - transport->tcp_offset; 1191 - dprintk("RPC: reading XID (%Zu bytes)\n", len); 1191 + dprintk("RPC: reading XID (%zu bytes)\n", len); 1192 1192 p = ((char *) &transport->tcp_xid) + transport->tcp_offset; 1193 1193 used = xdr_skb_read_bits(desc, p, len); 1194 1194 transport->tcp_offset += used; ··· 1219 1219 */ 1220 1220 offset = transport->tcp_offset - sizeof(transport->tcp_xid); 1221 1221 len = sizeof(transport->tcp_calldir) - offset; 1222 - dprintk("RPC: reading CALL/REPLY flag (%Zu bytes)\n", len); 1222 + dprintk("RPC: reading CALL/REPLY flag (%zu bytes)\n", len); 1223 1223 p = ((char *) &transport->tcp_calldir) + offset; 1224 1224 used = xdr_skb_read_bits(desc, p, len); 1225 1225 transport->tcp_offset += used; ··· 1310 1310 return; 1311 1311 } 1312 1312 1313 - dprintk("RPC: XID %08x read %Zd bytes\n", 1313 + dprintk("RPC: XID %08x read %zd bytes\n", 1314 1314 ntohl(transport->tcp_xid), r); 1315 1315 dprintk("RPC: xprt = %p, tcp_copied = %lu, tcp_offset = %u, " 1316 1316 "tcp_reclen = %u\n", xprt, transport->tcp_copied, ··· 1456 1456 desc->count -= len; 1457 1457 desc->offset += len; 1458 1458 transport->tcp_offset += len; 1459 - dprintk("RPC: discarded %Zu bytes\n", len); 1459 + dprintk("RPC: discarded %zu bytes\n", len); 1460 1460 xs_tcp_check_fraghdr(transport); 1461 1461 } 1462 1462
+1 -1
security/selinux/ss/ebitmap.c
··· 360 360 361 361 if (mapunit != BITS_PER_U64) { 362 362 printk(KERN_ERR "SELinux: ebitmap: map size %u does not " 363 - "match my size %Zd (high bit was %d)\n", 363 + "match my size %zd (high bit was %d)\n", 364 364 mapunit, BITS_PER_U64, e->highbit); 365 365 goto bad; 366 366 }
+1 -1
security/selinux/ss/policydb.c
··· 2266 2266 len = le32_to_cpu(buf[1]); 2267 2267 if (len != strlen(POLICYDB_STRING)) { 2268 2268 printk(KERN_ERR "SELinux: policydb string length %d does not " 2269 - "match expected length %Zu\n", 2269 + "match expected length %zu\n", 2270 2270 len, strlen(POLICYDB_STRING)); 2271 2271 goto bad; 2272 2272 }
+2 -2
sound/pci/korg1212/korg1212.c
··· 2051 2051 snd_iprintf(buffer, korg1212->card->longname); 2052 2052 snd_iprintf(buffer, " (index #%d)\n", korg1212->card->number + 1); 2053 2053 snd_iprintf(buffer, "\nGeneral settings\n"); 2054 - snd_iprintf(buffer, " period size: %Zd bytes\n", K1212_PERIOD_BYTES); 2054 + snd_iprintf(buffer, " period size: %zd bytes\n", K1212_PERIOD_BYTES); 2055 2055 snd_iprintf(buffer, " clock mode: %s\n", clockSourceName[korg1212->clkSrcRate] ); 2056 2056 snd_iprintf(buffer, " left ADC Sens: %d\n", korg1212->leftADCInSens ); 2057 2057 snd_iprintf(buffer, " right ADC Sens: %d\n", korg1212->rightADCInSens ); ··· 2276 2276 2277 2277 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), 2278 2278 sizeof(struct KorgSharedBuffer), &korg1212->dma_shared) < 0) { 2279 - snd_printk(KERN_ERR "korg1212: can not allocate shared buffer memory (%Zd bytes)\n", sizeof(struct KorgSharedBuffer)); 2279 + snd_printk(KERN_ERR "korg1212: can not allocate shared buffer memory (%zd bytes)\n", sizeof(struct KorgSharedBuffer)); 2280 2280 snd_korg1212_free(korg1212); 2281 2281 return -ENOMEM; 2282 2282 }
+1 -1
sound/pci/pcxhr/pcxhr_hwdep.c
··· 292 292 int err, card_index; 293 293 294 294 dev_dbg(&mgr->pci->dev, 295 - "loading dsp [%d] size = %Zd\n", index, dsp->size); 295 + "loading dsp [%d] size = %zd\n", index, dsp->size); 296 296 297 297 switch (index) { 298 298 case PCXHR_FIRMWARE_XLX_INT_INDEX:
+1 -1
sound/pcmcia/vx/vxp_ops.c
··· 201 201 c |= (int)vx_inb(chip, RXM) << 8; 202 202 c |= vx_inb(chip, RXL); 203 203 204 - snd_printdd(KERN_DEBUG "xilinx: dsp size received 0x%x, orig 0x%Zx\n", c, fw->size); 204 + snd_printdd(KERN_DEBUG "xilinx: dsp size received 0x%x, orig 0x%zx\n", c, fw->size); 205 205 206 206 vx_outb(chip, ICR, ICR_HF0); 207 207
+1 -1
sound/soc/soc-core.c
··· 3041 3041 unsigned int i; 3042 3042 int ret; 3043 3043 3044 - dev_dbg(dev, "ASoC: dai register %s #%Zu\n", dev_name(dev), count); 3044 + dev_dbg(dev, "ASoC: dai register %s #%zu\n", dev_name(dev), count); 3045 3045 3046 3046 component->dai_drv = dai_drv; 3047 3047