arch/arm/crypto/ghash-ce-glue.c

331

int nblocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

333

pmull_gcm_encrypt(nblocks, dg, src, ctx, dst, iv,

arch/arm/crypto/ghash-ce-glue.c

335

counter += nblocks;

arch/arm/crypto/ghash-ce-glue.c

338

src += nblocks * AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

339

dst += nblocks * AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

424

int nblocks = walk.nbytes / AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

426

pmull_gcm_decrypt(nblocks, dg, src, ctx, dst, iv,

arch/arm/crypto/ghash-ce-glue.c

428

counter += nblocks;

arch/arm/crypto/ghash-ce-glue.c

431

src += nblocks * AES_BLOCK_SIZE;

arch/arm/crypto/ghash-ce-glue.c

432

dst += nblocks * AES_BLOCK_SIZE;

arch/arm64/crypto/sm4-ce-ccm-glue.c

122

unsigned int l, nblocks;

arch/arm64/crypto/sm4-ce-ccm-glue.c

131

nblocks = n / SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-ce-ccm-glue.c

133

mac, p, nblocks);

arch/arm64/crypto/sm4-ce-ccm-glue.c

135

p += nblocks * SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-ce-ccm-glue.c

22

const u8 *src, unsigned int nblocks);

arch/arm64/crypto/sm4-ce-gcm-glue.c

107

nblocks = n / GHASH_BLOCK_SIZE;

arch/arm64/crypto/sm4-ce-gcm-glue.c

108

if (nblocks) {

arch/arm64/crypto/sm4-ce-gcm-glue.c

110

p, nblocks);

arch/arm64/crypto/sm4-ce-gcm-glue.c

111

p += nblocks * GHASH_BLOCK_SIZE;

arch/arm64/crypto/sm4-ce-gcm-glue.c

24

const u8 *src, unsigned int nblocks);

arch/arm64/crypto/sm4-ce-gcm-glue.c

94

unsigned int nblocks;

arch/arm64/crypto/sm4-ce-glue.c

163

unsigned int nblocks;

arch/arm64/crypto/sm4-ce-glue.c

165

nblocks = nbytes / SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-ce-glue.c

166

if (nblocks) {

arch/arm64/crypto/sm4-ce-glue.c

170

walk.iv, nblocks);

arch/arm64/crypto/sm4-ce-glue.c

173

walk.iv, nblocks);

arch/arm64/crypto/sm4-ce-glue.c

32

u8 *iv, unsigned int nblocks);

arch/arm64/crypto/sm4-ce-glue.c

331

int nblocks = DIV_ROUND_UP(req->cryptlen, SM4_BLOCK_SIZE) - 2;

arch/arm64/crypto/sm4-ce-glue.c

34

u8 *iv, unsigned int nblocks);

arch/arm64/crypto/sm4-ce-glue.c

340

nblocks * SM4_BLOCK_SIZE, req->iv);

arch/arm64/crypto/sm4-ce-glue.c

48

const u8 *src, unsigned int nblocks,

arch/arm64/crypto/sm4-ce-glue.c

579

unsigned int nblocks = len / SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-ce-glue.c

584

nblocks, false, true);

arch/arm64/crypto/sm4-ce.h

13

u8 *iv, unsigned int nblocks);

arch/arm64/crypto/sm4-neon-glue.c

122

unsigned int nblocks;

arch/arm64/crypto/sm4-neon-glue.c

124

nblocks = nbytes / SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-neon-glue.c

125

if (nblocks) {

arch/arm64/crypto/sm4-neon-glue.c

128

walk.iv, nblocks);

arch/arm64/crypto/sm4-neon-glue.c

150

unsigned int nblocks;

arch/arm64/crypto/sm4-neon-glue.c

152

nblocks = nbytes / SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-neon-glue.c

153

if (nblocks) {

arch/arm64/crypto/sm4-neon-glue.c

156

walk.iv, nblocks);

arch/arm64/crypto/sm4-neon-glue.c

158

dst += nblocks * SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-neon-glue.c

159

src += nblocks * SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-neon-glue.c

160

nbytes -= nblocks * SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-neon-glue.c

22

unsigned int nblocks);

arch/arm64/crypto/sm4-neon-glue.c

24

u8 *iv, unsigned int nblocks);

arch/arm64/crypto/sm4-neon-glue.c

26

u8 *iv, unsigned int nblocks);

arch/arm64/crypto/sm4-neon-glue.c

47

unsigned int nblocks;

arch/arm64/crypto/sm4-neon-glue.c

49

nblocks = nbytes / SM4_BLOCK_SIZE;

arch/arm64/crypto/sm4-neon-glue.c

50

if (nblocks) {

arch/arm64/crypto/sm4-neon-glue.c

52

sm4_neon_crypt(rkey, dst, src, nblocks);

arch/riscv/crypto/aes-riscv64-glue.c

238

u32 ctr32, nblocks;

arch/riscv/crypto/aes-riscv64-glue.c

249

nblocks = nbytes / AES_BLOCK_SIZE;

arch/riscv/crypto/aes-riscv64-glue.c

252

nblocks = DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

arch/riscv/crypto/aes-riscv64-glue.c

254

ctr32 += nblocks;

arch/riscv/crypto/aes-riscv64-glue.c

257

if (ctr32 >= nblocks) {

arch/riscv/crypto/aes-riscv64-glue.c

270

(nblocks - ctr32) * AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

609

unsigned int nbytes, p1_nbytes, nblocks;

arch/x86/crypto/aesni-intel_glue.c

624

nblocks = nbytes / AES_BLOCK_SIZE;

arch/x86/crypto/aesni-intel_glue.c

627

nblocks = DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

629

ctr64 += nblocks;

arch/x86/crypto/aesni-intel_glue.c

632

if (likely(ctr64 >= nblocks)) {

arch/x86/crypto/aesni-intel_glue.c

643

p1_nbytes = min(nbytes, (nblocks - ctr64) * AES_BLOCK_SIZE);

arch/x86/crypto/sm3_avx_glue.c

20

const u8 *data, int nblocks);

arch/x86/crypto/sm4_aesni_avx_glue.c

151

unsigned int nblocks = min(nbytes >> 4, 8u);

arch/x86/crypto/sm4_aesni_avx_glue.c

155

src, nblocks);

arch/x86/crypto/sm4_aesni_avx_glue.c

157

src += ((int)nblocks - 2) * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

158

dst += (nblocks - 1) * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

161

for (i = nblocks - 1; i > 0; i--) {

arch/x86/crypto/sm4_aesni_avx_glue.c

170

dst += nblocks * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

171

src += (nblocks + 1) * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

172

nbytes -= nblocks * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

215

unsigned int nblocks = min(nbytes >> 4, 8u);

arch/x86/crypto/sm4_aesni_avx_glue.c

218

for (i = 0; i < nblocks; i++) {

arch/x86/crypto/sm4_aesni_avx_glue.c

224

keystream, nblocks);

arch/x86/crypto/sm4_aesni_avx_glue.c

227

nblocks * SM4_BLOCK_SIZE);

arch/x86/crypto/sm4_aesni_avx_glue.c

228

dst += nblocks * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

229

src += nblocks * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

23

const u8 *src, int nblocks);

arch/x86/crypto/sm4_aesni_avx_glue.c

230

nbytes -= nblocks * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

25

const u8 *src, int nblocks);

arch/x86/crypto/sm4_aesni_avx_glue.c

59

unsigned int nblocks = min(nbytes >> 4, 4u);

arch/x86/crypto/sm4_aesni_avx_glue.c

60

sm4_aesni_avx_crypt4(rkey, dst, src, nblocks);

arch/x86/crypto/sm4_aesni_avx_glue.c

61

dst += nblocks * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

62

src += nblocks * SM4_BLOCK_SIZE;

arch/x86/crypto/sm4_aesni_avx_glue.c

63

nbytes -= nblocks * SM4_BLOCK_SIZE;

block/partitions/sysv68.c

44

__be32 nblocks; /* slice size (in blocks) */

block/partitions/sysv68.c

83

if (be32_to_cpu(slice->nblocks)) {

block/partitions/sysv68.c

86

be32_to_cpu(slice->nblocks));

drivers/block/virtio_blk.c

918

unsigned long long nblocks;

drivers/block/virtio_blk.c

924

nblocks = DIV_ROUND_UP_ULL(capacity, queue_logical_block_size(q) >> 9);

drivers/block/virtio_blk.c

926

string_get_size(nblocks, queue_logical_block_size(q),

drivers/block/virtio_blk.c

928

string_get_size(nblocks, queue_logical_block_size(q),

drivers/block/virtio_blk.c

935

nblocks,

drivers/cdrom/cdrom.c

2046

int blocksize, int nblocks)

drivers/cdrom/cdrom.c

2056

cgc->cmd[6] = (nblocks >> 16) & 0xff;

drivers/cdrom/cdrom.c

2057

cgc->cmd[7] = (nblocks >> 8) & 0xff;

drivers/cdrom/cdrom.c

2058

cgc->cmd[8] = nblocks & 0xff;

drivers/cdrom/cdrom.c

2059

cgc->buflen = blocksize * nblocks;

drivers/cdrom/cdrom.c

2066

int lba, int nblocks, int format, int blksize)

drivers/cdrom/cdrom.c

2080

cgc->cmd[6] = (nblocks >> 16) & 0xff;

drivers/cdrom/cdrom.c

2081

cgc->cmd[7] = (nblocks >> 8) & 0xff;

drivers/cdrom/cdrom.c

2082

cgc->cmd[8] = nblocks & 0xff;

drivers/cdrom/cdrom.c

2083

cgc->buflen = blksize * nblocks;

drivers/dma/apple-admac.c

155

int i, ret = 0, nblocks;

drivers/dma/apple-admac.c

166

nblocks = sram->size / SRAM_BLOCK;

drivers/dma/apple-admac.c

167

for (i = 0; i < nblocks; i++)

drivers/dma/apple-admac.c

171

if (i < nblocks) {

drivers/infiniband/hw/mlx5/umr.c

1000

size_t *nblocks,

drivers/infiniband/hw/mlx5/umr.c

1022

*nblocks = ib_umem_num_dma_blocks(mr->umem, 1UL << max_page_shift);

drivers/infiniband/hw/mlx5/umr.c

1024

*nblocks = ALIGN(*nblocks, MLX5_UMR_KSM_NUM_ENTRIES_ALIGNMENT);

drivers/infiniband/hw/mlx5/umr.c

1026

*nblocks = ALIGN(*nblocks, MLX5_UMR_MTT_NUM_ENTRIES_ALIGNMENT);

drivers/infiniband/hw/mlx5/umr.c

1033

if (*nblocks >= page_shift_nblocks)

drivers/infiniband/hw/mlx5/umr.c

1034

*nblocks = 0;

drivers/infiniband/hw/mlx5/umr.c

1039

if (*nblocks)

drivers/infiniband/hw/mlx5/umr.c

1041

err = _mlx5r_dmabuf_umr_update_pas(mr, flags, 0, *nblocks, dd);

drivers/infiniband/hw/mlx5/umr.c

1050

if (*nblocks) {

drivers/infiniband/hw/mlx5/umr.c

688

size_t start_block, size_t nblocks)

drivers/infiniband/hw/mlx5/umr.c

713

if (nblocks)

drivers/infiniband/hw/mlx5/umr.c

714

total_blocks = nblocks;

drivers/infiniband/hw/mlx5/umr.c

741

if (nblocks && processed_blocks >= nblocks)

drivers/infiniband/hw/mlx5/umr.c

806

size_t nblocks)

drivers/infiniband/hw/mlx5/umr.c

813

return _mlx5r_umr_update_mr_pas(mr, flags, true, start_block, nblocks);

drivers/infiniband/hw/mlx5/umr.c

823

size_t start_block, size_t nblocks)

drivers/infiniband/hw/mlx5/umr.c

828

return _mlx5r_umr_update_mr_pas(mr, flags, false, start_block, nblocks);

drivers/infiniband/hw/mlx5/umr.c

975

size_t start_block, size_t nblocks, bool dd)

drivers/infiniband/hw/mlx5/umr.c

980

nblocks);

drivers/infiniband/hw/mlx5/umr.c

983

nblocks);

drivers/infiniband/hw/mlx5/umr.h

100

size_t nblocks);

drivers/infiniband/hw/mlx5/umr.h

103

size_t start_block, size_t nblocks);

drivers/md/dm-vdo/murmurhash3.c

36

const int nblocks = len / 16;

drivers/md/dm-vdo/murmurhash3.c

49

for (i = 0; i < nblocks; i++) {

drivers/md/dm-vdo/murmurhash3.c

75

const u8 *tail = (const u8 *)(data + nblocks * 16);

drivers/media/usb/pwc/pwc-dec23.c

594

int compression_index, nblocks;

drivers/media/usb/pwc/pwc-dec23.c

605

nblocks = compressed_image_width / 4;

drivers/media/usb/pwc/pwc-dec23.c

611

while (nblocks) {

drivers/media/usb/pwc/pwc-dec23.c

615

nblocks--;

drivers/media/usb/pwc/pwc-dec23.c

619

nblocks = compressed_image_width / 8;

drivers/media/usb/pwc/pwc-dec23.c

625

while (nblocks) {

drivers/media/usb/pwc/pwc-dec23.c

634

nblocks -= 2;

drivers/misc/sram.c

181

unsigned int nblocks, exports = 0;

drivers/misc/sram.c

193

nblocks = (np) ? of_get_available_child_count(np) + 1 : 1;

drivers/misc/sram.c

194

rblocks = kzalloc_objs(*rblocks, nblocks);

drivers/misc/sram.c

263

rblocks[nblocks - 1].start = size;

drivers/misc/sram.c

264

rblocks[nblocks - 1].size = 0;

drivers/misc/sram.c

265

list_add_tail(&rblocks[nblocks - 1].list, &reserve_list);

drivers/mtd/ftl.c

746

u_long sector, u_long nblocks)

drivers/mtd/ftl.c

754

part, sector, nblocks);

drivers/mtd/ftl.c

761

for (i = 0; i < nblocks; i++) {

drivers/mtd/ftl.c

860

u_long sector, u_long nblocks)

drivers/mtd/ftl.c

868

part, sector, nblocks);

drivers/mtd/ftl.c

874

while (part->FreeTotal < nblocks) {

drivers/mtd/ftl.c

883

for (i = 0; i < nblocks; i++) {

drivers/mtd/nand/bbt.c

26

unsigned int nblocks = nanddev_neraseblocks(nand);

drivers/mtd/nand/bbt.c

28

nand->bbt.cache = bitmap_zalloc(nblocks * bits_per_block, GFP_KERNEL);

drivers/net/wireless/quantenna/qtnfmac/pcie/topaz_pcie.c

909

u32 nblocks;

drivers/net/wireless/quantenna/qtnfmac/pcie/topaz_pcie.c

939

nblocks = NBLOCKS(fw_size, blksize);

drivers/net/wireless/quantenna/qtnfmac/pcie/topaz_pcie.c

950

for (count = 0 ; count < nblocks; count++) {

drivers/nvme/host/ioctl.c

227

length = (io.nblocks + 1) << ns->head->lba_shift;

drivers/nvme/host/ioctl.c

240

meta_len = (io.nblocks + 1) * ns->head->ms;

drivers/nvme/host/ioctl.c

257

c.rw.length = cpu_to_le16(io.nblocks);

drivers/nvme/host/ioctl.c

568

__u16 nblocks;

drivers/s390/char/tape_char.c

175

int nblocks;

drivers/s390/char/tape_char.c

188

nblocks = count / block_size;

drivers/s390/char/tape_char.c

191

nblocks = 1;

drivers/s390/char/tape_char.c

199

DBF_EVENT(6, "TCHAR:nblocks: %x\n", nblocks);

drivers/s390/char/tape_char.c

205

for (i = 0; i < nblocks; i++) {

drivers/staging/greybus/sdio.c

255

size_t len, u16 nblocks, off_t skip)

drivers/staging/greybus/sdio.c

277

request->data_blocks = cpu_to_le16(nblocks);

drivers/staging/greybus/sdio.c

309

size_t len, u16 nblocks, off_t skip)

drivers/staging/greybus/sdio.c

331

request->data_blocks = cpu_to_le16(nblocks);

drivers/staging/greybus/sdio.c

365

u16 nblocks;

drivers/staging/greybus/sdio.c

385

nblocks = len / data->blksz;

drivers/staging/greybus/sdio.c

386

len = nblocks * data->blksz;

drivers/staging/greybus/sdio.c

389

ret = _gb_sdio_recv(host, data, len, nblocks, skip);

drivers/staging/greybus/sdio.c

393

ret = _gb_sdio_send(host, data, len, nblocks, skip);

fs/afs/dir_search.c

43

unsigned int nblocks;

fs/afs/dir_search.c

46

nblocks = umin(i_size / AFS_DIR_BLOCK_SIZE, AFS_DIR_MAX_BLOCKS);

fs/afs/dir_search.c

47

if (!nblocks)

fs/afs/dir_search.c

49

iter->loop_check = nblocks * (AFS_DIR_SLOTS_PER_BLOCK - AFS_DIR_RESV_BLOCKS);

fs/btrfs/file-item.c

356

const unsigned int nblocks = orig_len >> fs_info->sectorsize_bits;

fs/btrfs/file-item.c

381

if (nblocks * csum_size > BTRFS_BIO_INLINE_CSUM_SIZE) {

fs/btrfs/file-item.c

382

bbio->csum = kvcalloc(nblocks, csum_size, GFP_NOFS);

fs/btrfs/file-item.c

393

if (nblocks > fs_info->csums_per_leaf)

fs/ext4/ext4.h

2947

int nblocks);

fs/ext4/ext4.h

2953

type, nblocks) \

fs/ext4/ext4.h

2955

0, (type), __LINE__, (nblocks))

fs/ext4/ext4_jbd2.h

221

#define ext4_journal_start_sb(sb, type, nblocks) \

fs/ext4/ext4_jbd2.h

222

__ext4_journal_start_sb(NULL, (sb), __LINE__, (type), (nblocks), 0,\

fs/ext4/ext4_jbd2.h

225

#define ext4_journal_start(inode, type, nblocks) \

fs/ext4/ext4_jbd2.h

226

__ext4_journal_start((inode), __LINE__, (type), (nblocks), 0, \

fs/ext4/ext4_jbd2.h

260

static inline int ext4_journal_extend(handle_t *handle, int nblocks, int revoke)

fs/ext4/ext4_jbd2.h

263

return jbd2_journal_extend(handle, nblocks, revoke);

fs/ext4/ext4_jbd2.h

267

static inline int ext4_journal_restart(handle_t *handle, int nblocks,

fs/ext4/ext4_jbd2.h

271

return jbd2__journal_restart(handle, nblocks, revoke, GFP_NOFS);

fs/ext4/ialloc.c

1010

nblocks += ret2;

fs/ext4/ialloc.c

1086

BUG_ON(nblocks <= 0);

fs/ext4/ialloc.c

1088

line_no, handle_type, nblocks, 0,

fs/ext4/ialloc.c

878

int nblocks = 0;

fs/ext4/ialloc.c

887

nblocks += (S_ISDIR(mode) ? 2 : 1) *

fs/ext4/ialloc.c

906

nblocks += num_security_xattrs *

fs/ext4/ialloc.c

913

nblocks += __ext4_xattr_set_credits(sb,

fs/ext4/ialloc.c

918

return nblocks;

fs/ext4/ialloc.c

936

int nblocks)

fs/ext4/namei.c

1531

ext4_lblk_t nblocks;

fs/ext4/namei.c

1557

nblocks = 1;

fs/ext4/namei.c

1578

nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);

fs/ext4/namei.c

1579

if (!nblocks) {

fs/ext4/namei.c

1584

if (start >= nblocks)

fs/ext4/namei.c

1599

ra_max = nblocks - block;

fs/ext4/namei.c

1646

if (++block >= nblocks)

fs/ext4/namei.c

1654

block = nblocks;

fs/ext4/namei.c

1655

nblocks = dir->i_size >> EXT4_BLOCK_SIZE_BITS(sb);

fs/ext4/namei.c

1656

if (block < nblocks) {

fs/gfs2/rgrp.c

2416

int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,

fs/gfs2/rgrp.c

2426

BUG_ON(ip->i_res.rs_reserved < *nblocks);

fs/gfs2/rgrp.c

2441

(unsigned long long)ip->i_no_addr, error, *nblocks,

fs/gfs2/rgrp.c

2447

gfs2_alloc_extent(&rbm, dinode, nblocks);

fs/gfs2/rgrp.c

2451

ip->i_goal = block + *nblocks - 1;

fs/gfs2/rgrp.c

2463

gfs2_adjust_reservation(ip, &rbm, *nblocks);

fs/gfs2/rgrp.c

2464

if (rbm.rgd->rd_free < *nblocks || rbm.rgd->rd_reserved < *nblocks) {

fs/gfs2/rgrp.c

2465

fs_warn(sdp, "nblocks=%u\n", *nblocks);

fs/gfs2/rgrp.c

2469

GLOCK_BUG_ON(rbm.rgd->rd_gl, rbm.rgd->rd_reserved < *nblocks);

fs/gfs2/rgrp.c

2470

GLOCK_BUG_ON(rbm.rgd->rd_gl, rbm.rgd->rd_free_clone < *nblocks);

fs/gfs2/rgrp.c

2471

GLOCK_BUG_ON(rbm.rgd->rd_gl, rbm.rgd->rd_free < *nblocks);

fs/gfs2/rgrp.c

2472

rbm.rgd->rd_reserved -= *nblocks;

fs/gfs2/rgrp.c

2473

rbm.rgd->rd_free_clone -= *nblocks;

fs/gfs2/rgrp.c

2474

rbm.rgd->rd_free -= *nblocks;

fs/gfs2/rgrp.c

2490

gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);

fs/gfs2/rgrp.c

2492

gfs2_trans_remove_revoke(sdp, block, *nblocks);

fs/gfs2/rgrp.c

2494

gfs2_quota_change(ip, *nblocks, ip->i_inode.i_uid, ip->i_inode.i_gid);

fs/gfs2/rgrp.c

2496

trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,

fs/isofs/inode.c

1022

struct buffer_head **bh, unsigned long nblocks)

fs/isofs/inode.c

1046

while (nblocks) {

fs/isofs/inode.c

1100

nblocks--;

fs/jbd2/checkpoint.c

111

__func__, nblocks, space_left);

fs/jbd2/checkpoint.c

53

int nblocks, space_left;

fs/jbd2/checkpoint.c

56

nblocks = journal->j_max_transaction_buffers;

fs/jbd2/checkpoint.c

57

while (jbd2_log_space_left(journal) < nblocks) {

fs/jbd2/checkpoint.c

79

if (space_left < nblocks) {

fs/jbd2/transaction.c

455

static handle_t *new_handle(int nblocks)

fs/jbd2/transaction.c

460

handle->h_total_credits = nblocks;

fs/jbd2/transaction.c

466

handle_t *jbd2__journal_start(journal_t *journal, int nblocks, int rsv_blocks,

fs/jbd2/transaction.c

482

nblocks += DIV_ROUND_UP(revoke_records,

fs/jbd2/transaction.c

484

handle = new_handle(nblocks);

fs/jbd2/transaction.c

512

line_no, nblocks);

fs/jbd2/transaction.c

538

handle_t *jbd2_journal_start(journal_t *journal, int nblocks)

fs/jbd2/transaction.c

540

return jbd2__journal_start(journal, nblocks, 0, 0, GFP_NOFS, 0, 0);

fs/jbd2/transaction.c

641

int jbd2_journal_extend(handle_t *handle, int nblocks, int revoke_records)

fs/jbd2/transaction.c

659

"transaction not running\n", handle, nblocks);

fs/jbd2/transaction.c

663

nblocks += DIV_ROUND_UP(

fs/jbd2/transaction.c

669

wanted = atomic_add_return(nblocks,

fs/jbd2/transaction.c

674

"transaction too large\n", handle, nblocks);

fs/jbd2/transaction.c

675

atomic_sub(nblocks, &transaction->t_outstanding_credits);

fs/jbd2/transaction.c

683

nblocks);

fs/jbd2/transaction.c

685

handle->h_total_credits += nblocks;

fs/jbd2/transaction.c

686

handle->h_requested_credits += nblocks;

fs/jbd2/transaction.c

691

jbd2_debug(3, "extended handle %p by %d\n", handle, nblocks);

fs/jbd2/transaction.c

759

int jbd2__journal_restart(handle_t *handle, int nblocks, int revoke_records,

fs/jbd2/transaction.c

792

handle->h_total_credits = nblocks +

fs/jbd2/transaction.c

806

int jbd2_journal_restart(handle_t *handle, int nblocks)

fs/jbd2/transaction.c

808

return jbd2__journal_restart(handle, nblocks, 0, GFP_NOFS);

fs/jfs/jfs_discard.c

32

void jfs_issue_discard(struct inode *ip, u64 blkno, u64 nblocks)

fs/jfs/jfs_discard.c

37

r = sb_issue_discard(sb, blkno, nblocks, GFP_NOFS, 0);

fs/jfs/jfs_discard.c

41

(unsigned long long)nblocks, r);

fs/jfs/jfs_discard.c

46

(unsigned long long)nblocks, r);

fs/jfs/jfs_discard.h

10

extern void jfs_issue_discard(struct inode *ip, u64 blkno, u64 nblocks);

fs/jfs/jfs_dmap.c

102

int nblocks);

fs/jfs/jfs_dmap.c

103

static int dbInitDmap(struct dmap * dp, s64 blkno, int nblocks);

fs/jfs/jfs_dmap.c

107

static int dbGetL2AGSize(s64 nblocks);

fs/jfs/jfs_dmap.c

1072

int nblocks)

fs/jfs/jfs_dmap.c

1097

if (dbitno + nblocks > BPERDMAP)

fs/jfs/jfs_dmap.c

1119

for (rembits = nblocks; rembits > 0; rembits -= nb, dbitno += nb) {

fs/jfs/jfs_dmap.c

1171

return (dbAllocDmap(bmp, dp, blkno, nblocks));

fs/jfs/jfs_dmap.c

1204

struct dmap * dp, s64 blkno, int nblocks, int l2nb, s64 * results)

fs/jfs/jfs_dmap.c

1247

if ((rc = dbAllocDmap(bmp, dp, blkno, nblocks)) == 0)

fs/jfs/jfs_dmap.c

1312

dbAllocAG(struct bmap * bmp, int agno, s64 nblocks, int l2nb, s64 * results)

fs/jfs/jfs_dmap.c

1353

rc = dbAllocCtl(bmp, nblocks, l2nb, blkno, results);

fs/jfs/jfs_dmap.c

1358

(unsigned long long) nblocks);

fs/jfs/jfs_dmap.c

1472

rc = dbAllocCtl(bmp, nblocks, l2nb, blkno, results);

fs/jfs/jfs_dmap.c

1516

static int dbAllocAny(struct bmap * bmp, s64 nblocks, int l2nb, s64 * results)

fs/jfs/jfs_dmap.c

1532

rc = dbAllocCtl(bmp, nblocks, l2nb, blkno, results);

fs/jfs/jfs_dmap.c

1575

s64 nblocks, blkno;

fs/jfs/jfs_dmap.c

1582

u64 nblocks;

fs/jfs/jfs_dmap.c

1592

nblocks = bmp->db_agfree[agno];

fs/jfs/jfs_dmap.c

1593

max_ranges = nblocks;

fs/jfs/jfs_dmap.c

1604

while (nblocks >= minlen) {

fs/jfs/jfs_dmap.c

1605

l2nb = BLKSTOL2(nblocks);

fs/jfs/jfs_dmap.c

1608

rc = dbAllocAG(bmp, agno, nblocks, l2nb, &blkno);

fs/jfs/jfs_dmap.c

1611

tt->nblocks = nblocks;

fs/jfs/jfs_dmap.c

1619

nblocks = bmp->db_agfree[agno];

fs/jfs/jfs_dmap.c

1623

l2nb = BLKSTOL2(nblocks) - 1;

fs/jfs/jfs_dmap.c

1626

nblocks = 1LL << l2nb;

fs/jfs/jfs_dmap.c

1639

tt->nblocks = 0; /* mark the current end */

fs/jfs/jfs_dmap.c

1640

for (tt = totrim; tt->nblocks != 0; tt++) {

fs/jfs/jfs_dmap.c

1644

jfs_issue_discard(ip, tt->blkno, tt->nblocks);

fs/jfs/jfs_dmap.c

1645

dbFree(ip, tt->blkno, tt->nblocks);

fs/jfs/jfs_dmap.c

1646

trimmed += tt->nblocks;

fs/jfs/jfs_dmap.c

1800

dbAllocCtl(struct bmap * bmp, s64 nblocks, int l2nb, s64 blkno, s64 * results)

fs/jfs/jfs_dmap.c

1825

rc = dbAllocDmapLev(bmp, dp, (int) nblocks, l2nb, results);

fs/jfs/jfs_dmap.c

1841

for (n = nblocks, b = blkno; n > 0; n -= nb, b += nb) {

fs/jfs/jfs_dmap.c

1893

for (n = nblocks - n, b = blkno; n > 0;

fs/jfs/jfs_dmap.c

1957

struct dmap * dp, int nblocks, int l2nb, s64 * results)

fs/jfs/jfs_dmap.c

1988

if ((rc = dbAllocDmap(bmp, dp, blkno, nblocks)) == 0)

fs/jfs/jfs_dmap.c

2023

int nblocks)

fs/jfs/jfs_dmap.c

2034

dbAllocBits(bmp, dp, blkno, nblocks);

fs/jfs/jfs_dmap.c

2045

dbFreeBits(bmp, dp, blkno, nblocks);

fs/jfs/jfs_dmap.c

2078

int nblocks)

fs/jfs/jfs_dmap.c

2089

rc = dbFreeBits(bmp, dp, blkno, nblocks);

fs/jfs/jfs_dmap.c

2110

dbAllocBits(bmp, dp, blkno, nblocks);

fs/jfs/jfs_dmap.c

2140

int nblocks)

fs/jfs/jfs_dmap.c

2157

assert(dbitno + nblocks <= BPERDMAP);

fs/jfs/jfs_dmap.c

2172

for (rembits = nblocks; rembits > 0; rembits -= nb, dbitno += nb) {

fs/jfs/jfs_dmap.c

2244

le32_add_cpu(&dp->nfree, -nblocks);

fs/jfs/jfs_dmap.c

2257

bmp->db_agfree[agno] -= nblocks;

fs/jfs/jfs_dmap.c

2258

bmp->db_nfree -= nblocks;

fs/jfs/jfs_dmap.c

2287

int nblocks)

fs/jfs/jfs_dmap.c

2302

assert(dbitno + nblocks <= BPERDMAP);

fs/jfs/jfs_dmap.c

2321

for (rembits = nblocks; rembits > 0; rembits -= nb, dbitno += nb) {

fs/jfs/jfs_dmap.c

2388

le32_add_cpu(&dp->nfree, nblocks);

fs/jfs/jfs_dmap.c

2396

bmp->db_nfree += nblocks;

fs/jfs/jfs_dmap.c

2397

bmp->db_agfree[agno] += nblocks;

fs/jfs/jfs_dmap.c

3191

int dbAllocBottomUp(struct inode *ip, s64 blkno, s64 nblocks)

fs/jfs/jfs_dmap.c

3203

ASSERT(nblocks <= bmp->db_mapsize - blkno);

fs/jfs/jfs_dmap.c

3209

for (rem = nblocks; rem > 0; rem -= nb, blkno += nb) {

fs/jfs/jfs_dmap.c

3247

int nblocks)

fs/jfs/jfs_dmap.c

3266

assert(dbitno + nblocks <= BPERDMAP);

fs/jfs/jfs_dmap.c

3281

for (rembits = nblocks; rembits > 0; rembits -= nb, dbitno += nb) {

fs/jfs/jfs_dmap.c

3314

le32_add_cpu(&dp->nfree, -nblocks);

fs/jfs/jfs_dmap.c

3330

bmp->db_agfree[agno] -= nblocks;

fs/jfs/jfs_dmap.c

3331

bmp->db_nfree -= nblocks;

fs/jfs/jfs_dmap.c

3344

dbFreeBits(bmp, dp, blkno, nblocks);

fs/jfs/jfs_dmap.c

3367

int dbExtendFS(struct inode *ipbmap, s64 blkno, s64 nblocks)

fs/jfs/jfs_dmap.c

3382

newsize = blkno + nblocks;

fs/jfs/jfs_dmap.c

3385

(long long) blkno, (long long) nblocks, (long long) newsize);

fs/jfs/jfs_dmap.c

344

int dbFree(struct inode *ip, s64 blkno, s64 nblocks)

fs/jfs/jfs_dmap.c

3542

n = min(nblocks, (s64)BPERDMAP - n);

fs/jfs/jfs_dmap.c

3550

n = min_t(s64, nblocks, BPERDMAP);

fs/jfs/jfs_dmap.c

3566

nblocks -= n;

fs/jfs/jfs_dmap.c

3567

if (nblocks == 0)

fs/jfs/jfs_dmap.c

357

if (unlikely((blkno == 0) || (blkno + nblocks > bmp->db_mapsize))) {

fs/jfs/jfs_dmap.c

3579

if (nblocks)

fs/jfs/jfs_dmap.c

3603

if (nblocks)

fs/jfs/jfs_dmap.c

361

(unsigned long long) nblocks);

fs/jfs/jfs_dmap.c

370

if (JFS_SBI(sb)->minblks_trim <= nblocks)

fs/jfs/jfs_dmap.c

371

jfs_issue_discard(ipbmap, blkno, nblocks);

fs/jfs/jfs_dmap.c

3730

static int dbInitDmap(struct dmap * dp, s64 Blkno, int nblocks)

fs/jfs/jfs_dmap.c

3738

dp->nblocks = dp->nfree = cpu_to_le32(nblocks);

fs/jfs/jfs_dmap.c

3741

if (nblocks == BPERDMAP) {

fs/jfs/jfs_dmap.c

3747

le32_add_cpu(&dp->nblocks, nblocks);

fs/jfs/jfs_dmap.c

3748

le32_add_cpu(&dp->nfree, nblocks);

fs/jfs/jfs_dmap.c

3759

for (r = nblocks; r > 0; r -= nb, blkno += nb) {

fs/jfs/jfs_dmap.c

377

for (rem = nblocks; rem > 0; rem -= nb, blkno += nb) {

fs/jfs/jfs_dmap.c

3987

static int dbGetL2AGSize(s64 nblocks)

fs/jfs/jfs_dmap.c

3993

if (nblocks < BPERDMAP * MAXAG)

fs/jfs/jfs_dmap.c

3999

if (m & nblocks)

fs/jfs/jfs_dmap.c

4004

if (sz < nblocks)

fs/jfs/jfs_dmap.c

4037

s64 nblocks;

fs/jfs/jfs_dmap.c

4042

nblocks = ipbmap->i_size >> JFS_SBI(sb)->l2bsize;

fs/jfs/jfs_dmap.c

4043

npages = nblocks >> JFS_SBI(sb)->l2nbperpage;

fs/jfs/jfs_dmap.c

4071

nblocks = ndmaps << L2BPERDMAP;

fs/jfs/jfs_dmap.c

4073

return (nblocks);

fs/jfs/jfs_dmap.c

439

int free, s64 blkno, s64 nblocks, struct tblock * tblk)

fs/jfs/jfs_dmap.c

453

if (blkno + nblocks > bmp->db_mapsize) {

fs/jfs/jfs_dmap.c

456

(unsigned long long) nblocks);

fs/jfs/jfs_dmap.c

471

for (rem = nblocks; rem > 0; rem -= nblks, blkno += nblks) {

fs/jfs/jfs_dmap.c

65

int nblocks);

fs/jfs/jfs_dmap.c

714

int dbAlloc(struct inode *ip, s64 hint, s64 nblocks, s64 * results)

fs/jfs/jfs_dmap.c

72

static int dbAllocAny(struct bmap * bmp, s64 nblocks, int l2nb, s64 * results);

fs/jfs/jfs_dmap.c

727

assert(nblocks > 0);

fs/jfs/jfs_dmap.c

733

l2nb = BLKSTOL2(nblocks);

fs/jfs/jfs_dmap.c

74

int nblocks);

fs/jfs/jfs_dmap.c

751

rc = dbAllocAny(bmp, nblocks, l2nb, results);

fs/jfs/jfs_dmap.c

76

int nblocks,

fs/jfs/jfs_dmap.c

789

if (nblocks <= BPERDMAP) {

fs/jfs/jfs_dmap.c

79

int nblocks);

fs/jfs/jfs_dmap.c

80

static int dbAllocDmapLev(struct bmap * bmp, struct dmap * dp, int nblocks,

fs/jfs/jfs_dmap.c

805

if ((rc = dbAllocNext(bmp, dp, blkno, (int) nblocks))

fs/jfs/jfs_dmap.c

83

static int dbAllocAG(struct bmap * bmp, int agno, s64 nblocks, int l2nb,

fs/jfs/jfs_dmap.c

832

dbAllocNear(bmp, dp, blkno, (int) nblocks, l2nb, results))

fs/jfs/jfs_dmap.c

844

if ((rc = dbAllocDmapLev(bmp, dp, (int) nblocks, l2nb, results))

fs/jfs/jfs_dmap.c

85

static int dbAllocCtl(struct bmap * bmp, s64 nblocks, int l2nb, s64 blkno,

fs/jfs/jfs_dmap.c

861

if ((rc = dbAllocAG(bmp, agno, nblocks, l2nb, results)) != -ENOSPC)

fs/jfs/jfs_dmap.c

87

static int dbExtend(struct inode *ip, s64 blkno, s64 nblocks, s64 addnblocks);

fs/jfs/jfs_dmap.c

877

if ((rc = dbAllocAG(bmp, agno, nblocks, l2nb, results)) == -ENOSPC)

fs/jfs/jfs_dmap.c

878

rc = dbAllocAny(bmp, nblocks, l2nb, results);

fs/jfs/jfs_dmap.c

92

int nblocks);

fs/jfs/jfs_dmap.c

925

s64 blkno, s64 nblocks, s64 addnblocks, s64 * results)

fs/jfs/jfs_dmap.c

931

if ((rc = dbExtend(ip, blkno, nblocks, addnblocks)) == 0) {

fs/jfs/jfs_dmap.c

94

int nblocks);

fs/jfs/jfs_dmap.c

945

(ip, blkno + nblocks - 1, addnblocks + nblocks, results));

fs/jfs/jfs_dmap.c

972

static int dbExtend(struct inode *ip, s64 blkno, s64 nblocks, s64 addnblocks)

fs/jfs/jfs_dmap.c

987

(rel_block + nblocks + addnblocks > sbi->nbperpage))

fs/jfs/jfs_dmap.c

991

lastblkno = blkno + nblocks - 1;

fs/jfs/jfs_dmap.h

148

__le32 nblocks; /* 4: num blks covered by this dmap */

fs/jfs/jfs_dmap.h

284

extern int dbFree(struct inode *ipbmap, s64 blkno, s64 nblocks);

fs/jfs/jfs_dmap.h

287

int free, s64 blkno, s64 nblocks, struct tblock * tblk);

fs/jfs/jfs_dmap.h

291

extern int dbAlloc(struct inode *ipbmap, s64 hint, s64 nblocks, s64 * results);

fs/jfs/jfs_dmap.h

294

s64 blkno, s64 nblocks, s64 addnblocks, s64 * results);

fs/jfs/jfs_dmap.h

297

extern int dbAllocBottomUp(struct inode *ip, s64 blkno, s64 nblocks);

fs/jfs/jfs_dmap.h

298

extern int dbExtendFS(struct inode *ipbmap, s64 blkno, s64 nblocks);

fs/jfs/jfs_extent.c

309

extBalloc(struct inode *ip, s64 hint, s64 * nblocks, s64 * blkno)

fs/jfs/jfs_extent.c

330

if (*nblocks >= max && *nblocks > nbperpage)

fs/jfs/jfs_extent.c

333

nb = nblks = *nblocks;

fs/jfs/jfs_extent.c

351

*nblocks = nb;

fs/jfs/jfs_xtree.c

1973

int nsplit, nblocks, xlen;

fs/jfs/jfs_xtree.c

2027

nblocks = JFS_SBI(ip->i_sb)->nbperpage;

fs/jfs/jfs_xtree.c

2028

for (; nsplit > 0; nsplit--, pxd++, xaddr += nblocks, maxblocks -= nblocks) {

fs/jfs/jfs_xtree.c

2029

if ((rc = dbAllocBottomUp(ip, xaddr, (s64) nblocks)) == 0) {

fs/jfs/jfs_xtree.c

2031

PXDlength(pxd, nblocks);

fs/jfs/resize.c

313

nblocks = min(t64 - mapSize, XSize);

fs/jfs/resize.c

322

if ((rc = dbExtendFS(ipbmap, XAddress, nblocks)))

fs/jfs/resize.c

332

XSize -= nblocks;

fs/jfs/resize.c

382

xlen = min(xlen, (int) nblocks) & ~(sbi->nbperpage - 1);

fs/jfs/resize.c

387

if ((rc = xtAppend(tid, ipbmap, 0, xoff, nblocks, &xlen, &xaddr, 0))) {

fs/jfs/resize.c

62

s64 XAddress, XSize, nblocks, xoff, xaddr, t64;

fs/jfs/xattr.c

207

int nblocks;

fs/jfs/xattr.c

225

nblocks = (size + (sb->s_blocksize - 1)) >> sb->s_blocksize_bits;

fs/jfs/xattr.c

228

rc = dquot_alloc_block(ip, nblocks);

fs/jfs/xattr.c

232

rc = dbAlloc(ip, INOHINT(ip), nblocks, &blkno);

fs/jfs/xattr.c

235

dquot_free_block(ip, nblocks);

fs/jfs/xattr.c

246

for (i = 0; i < nblocks; i += sbi->nbperpage) {

fs/jfs/xattr.c

289

DXDlength(ea, nblocks);

fs/jfs/xattr.c

300

dquot_free_block(ip, nblocks);

fs/jfs/xattr.c

302

dbFree(ip, blkno, nblocks);

fs/jfs/xattr.c

356

int nblocks;

fs/jfs/xattr.c

378

nblocks = lengthDXD(&ji->ea) << sbi->l2nbperpage;

fs/jfs/xattr.c

386

for (i = 0; i < nblocks; i += sbi->nbperpage) {

fs/minix/itree_v1.c

66

return nblocks(size, sb);

fs/minix/itree_v2.c

74

return nblocks(size, sb);

fs/mpage.c

169

unsigned nblocks;

fs/mpage.c

191

nblocks = map_bh->b_size >> blkbits;

fs/mpage.c

194

block_in_file < (args->first_logical_block + nblocks)) {

fs/mpage.c

196

unsigned last = nblocks - map_offset;

fs/mpage.c

255

nblocks = map_bh->b_size >> blkbits;

fs/mpage.c

257

if (relative_block == nblocks) {

fs/mpage.c

301

nblocks = map_bh->b_size >> blkbits;

fs/mpage.c

302

if ((buffer_boundary(map_bh) && relative_block == nblocks) ||

fs/nfs/nfs4xdr.c

5207

uint32_t limit_type, nblocks, blocksize;

fs/nfs/nfs4xdr.c

5219

nblocks = be32_to_cpup(p++);

fs/nfs/nfs4xdr.c

5221

maxsize = (uint64_t)nblocks * (uint64_t)blocksize;

fs/nilfs2/recovery.c

351

unsigned long nblocks, ndatablk, nnodeblk;

fs/nilfs2/recovery.c

360

nblocks = le32_to_cpu(finfo->fi_nblocks);

fs/nilfs2/recovery.c

362

nnodeblk = nblocks - ndatablk;

fs/nilfs2/recovery.c

871

unsigned long nblocks;

fs/nilfs2/recovery.c

907

nblocks = le32_to_cpu(sum->ss_nblocks);

fs/nilfs2/recovery.c

908

pseg_end = pseg_start + nblocks - 1;

fs/nilfs2/recovery.c

957

nilfs->ns_pseg_offset = pseg_start + nblocks - seg_start;

fs/nilfs2/recovery.c

974

pseg_start += nblocks;

fs/nilfs2/segbuf.c

120

segbuf->sb_pseg_start + segbuf->sb_sum.nblocks);

fs/nilfs2/segbuf.c

134

segbuf->sb_sum.nblocks = segbuf->sb_sum.nsumblk = 0;

fs/nilfs2/segbuf.c

165

raw_sum->ss_nblocks = cpu_to_le32(segbuf->sb_sum.nblocks);

fs/nilfs2/segbuf.c

369

wi->rest_blocks = segbuf->sb_sum.nblocks;

fs/nilfs2/segbuf.c

467

segbuf->sb_sum.nblocks,

fs/nilfs2/segbuf.c

83

segbuf->sb_pseg_start = prev->sb_pseg_start + prev->sb_sum.nblocks;

fs/nilfs2/segbuf.h

131

return segbuf->sb_sum.nblocks == segbuf->sb_sum.nsumblk;

fs/nilfs2/segbuf.h

139

segbuf->sb_sum.nblocks++;

fs/nilfs2/segbuf.h

148

segbuf->sb_sum.nblocks++;

fs/nilfs2/segbuf.h

34

unsigned long nblocks;

fs/nilfs2/segment.c

1032

(sci->sc_nblk_this_inc + sci->sc_curseg->sb_sum.nblocks);

fs/nilfs2/segment.c

1489

live_blocks = segbuf->sb_sum.nblocks +

fs/nilfs2/segment.c

1548

sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks;

fs/nilfs2/segment.c

1603

unsigned long nblocks = 0, ndatablk = 0;

fs/nilfs2/segment.c

1626

nblocks = le32_to_cpu(finfo->fi_nblocks);

fs/nilfs2/segment.c

1654

if (--nblocks == 0) {

fs/nilfs2/segment.c

1893

+ segbuf->sb_sum.nblocks;

fs/nilfs2/segment.c

454

sci->sc_nblk_this_inc += sci->sc_curseg->sb_sum.nblocks;

fs/nilfs2/segment.c

470

if (segbuf->sb_sum.nblocks >= segbuf->sb_rest_blocks) {

fs/nilfs2/segment.c

557

if (segbuf->sb_sum.nblocks + required + 1 > segbuf->sb_rest_blocks) {

fs/nilfs2/sufile.c

1069

sector_t start = 0, nblocks = 0;

fs/nilfs2/sufile.c

1128

if (!nblocks) {

fs/nilfs2/sufile.c

1131

nblocks = seg_end - seg_start + 1;

fs/nilfs2/sufile.c

1135

if (start + nblocks == seg_start) {

fs/nilfs2/sufile.c

1137

nblocks += seg_end - seg_start + 1;

fs/nilfs2/sufile.c

1143

nblocks -= start_block - start;

fs/nilfs2/sufile.c

1147

if (nblocks >= minlen) {

fs/nilfs2/sufile.c

1152

nblocks * sects_per_block,

fs/nilfs2/sufile.c

1159

ndiscarded += nblocks;

fs/nilfs2/sufile.c

1168

nblocks = seg_end - seg_start + 1;

fs/nilfs2/sufile.c

1175

if (nblocks) {

fs/nilfs2/sufile.c

1178

nblocks -= start_block - start;

fs/nilfs2/sufile.c

1181

if (start + nblocks > end_block + 1)

fs/nilfs2/sufile.c

1182

nblocks = end_block - start + 1;

fs/nilfs2/sufile.c

1184

if (nblocks >= minlen) {

fs/nilfs2/sufile.c

1187

nblocks * sects_per_block,

fs/nilfs2/sufile.c

1190

ndiscarded += nblocks;

fs/nilfs2/sufile.c

570

unsigned long nblocks, time64_t modtime)

fs/nilfs2/sufile.c

592

su->su_nblocks = cpu_to_le32(nblocks);

fs/nilfs2/sufile.h

29

unsigned long nblocks, time64_t modtime);

fs/nilfs2/the_nilfs.c

440

u64 nsegments, nblocks;

fs/nilfs2/the_nilfs.c

500

nblocks = sb_bdev_nr_blocks(nilfs->ns_sb);

fs/nilfs2/the_nilfs.c

501

if (nblocks) {

fs/nilfs2/the_nilfs.c

509

if (nblocks < min_block_count) {

fs/nilfs2/the_nilfs.c

513

(unsigned long long)nblocks);

fs/nilfs2/the_nilfs.c

791

sector_t start = 0, nblocks = 0;

fs/nilfs2/the_nilfs.c

801

if (!nblocks) {

fs/nilfs2/the_nilfs.c

803

nblocks = seg_end - seg_start + 1;

fs/nilfs2/the_nilfs.c

804

} else if (start + nblocks == seg_start) {

fs/nilfs2/the_nilfs.c

805

nblocks += seg_end - seg_start + 1;

fs/nilfs2/the_nilfs.c

809

nblocks * sects_per_block,

fs/nilfs2/the_nilfs.c

813

nblocks = 0;

fs/nilfs2/the_nilfs.c

816

if (nblocks)

fs/nilfs2/the_nilfs.c

819

nblocks * sects_per_block,

fs/nilfs2/the_nilfs.c

824

int nilfs_count_free_blocks(struct the_nilfs *nilfs, sector_t *nblocks)

fs/nilfs2/the_nilfs.c

829

*nblocks = (sector_t)ncleansegs * nilfs->ns_blocks_per_segment;

fs/ocfs2/dir.c

696

int nblocks, i;

fs/ocfs2/dir.c

700

nblocks = i_size_read(dir) >> sb->s_blocksize_bits;

fs/ocfs2/dir.c

702

if (start >= nblocks)

fs/ocfs2/dir.c

721

if (b >= nblocks || (num && block == start)) {

fs/ocfs2/dir.c

758

if (++block >= nblocks)

fs/ocfs2/dir.c

766

block = nblocks;

fs/ocfs2/dir.c

767

nblocks = i_size_read(dir) >> sb->s_blocksize_bits;

fs/ocfs2/dir.c

768

if (block < nblocks) {

fs/ocfs2/journal.c

428

int ocfs2_extend_trans(handle_t *handle, int nblocks)

fs/ocfs2/journal.c

433

BUG_ON(nblocks < 0);

fs/ocfs2/journal.c

435

if (!nblocks)

fs/ocfs2/journal.c

440

trace_ocfs2_extend_trans(old_nblocks, nblocks);

fs/ocfs2/journal.c

445

status = jbd2_journal_extend(handle, nblocks, 0);

fs/ocfs2/journal.c

453

trace_ocfs2_extend_trans_restart(old_nblocks + nblocks);

fs/ocfs2/journal.c

455

old_nblocks + nblocks);

fs/ocfs2/journal.c

474

int ocfs2_assure_trans_credits(handle_t *handle, int nblocks)

fs/ocfs2/journal.c

479

if (old_nblks >= nblocks)

fs/ocfs2/journal.c

481

return ocfs2_extend_trans(handle, nblocks - old_nblks);

fs/ocfs2/journal.h

246

int ocfs2_extend_trans(handle_t *handle, int nblocks);

fs/ocfs2/journal.h

248

int nblocks);

fs/xfs/libxfs/xfs_inode_buf.c

605

xfs_filblks_t nblocks;

fs/xfs/libxfs/xfs_inode_buf.c

670

nblocks = be64_to_cpu(dip->di_nblocks);

fs/xfs/libxfs/xfs_inode_buf.c

673

if (mode && nextents + naextents > nblocks)

fs/xfs/libxfs/xfs_inode_buf.c

789

if (nextents + naextents == 0 && nblocks != 0)

fs/xfs/scrub/bmap_repair.c

266

rb->nblocks += rec->rm_blockcount;

fs/xfs/scrub/bmap_repair.c

430

rb->nblocks += rec->rm_blockcount;

fs/xfs/scrub/bmap_repair.c

633

sc->ip->i_nblocks = rb->nblocks + delta;

fs/xfs/scrub/bmap_repair.c

75

xfs_rfsblock_t nblocks;

fs/xfs/scrub/inode_repair.c

1501

xfs_filblks_t nblocks;

fs/xfs/scrub/inode_repair.c

1512

nblocks = be64_to_cpu(dip->di_nblocks);

fs/xfs/scrub/inode_repair.c

1515

if (data_extents > nblocks)

fs/xfs/scrub/inode_repair.c

1517

if (attr_extents > nblocks)

fs/xfs/scrub/inode_repair.c

1519

if (data_extents + attr_extents > nblocks)

fs/xfs/scrub/trace.h

2440

__field(uint64_t, nblocks)

fs/xfs/scrub/trace.h

2460

__entry->nblocks = be64_to_cpu(dip->di_nblocks);

fs/xfs/scrub/trace.h

2480

__entry->nblocks,

fs/xfs/scrub/trace.h

2516

__field(xfs_rfsblock_t, nblocks)

fs/xfs/scrub/trace.h

2528

__entry->nblocks = sc->ip->i_nblocks;

fs/xfs/scrub/trace.h

2540

__entry->nblocks,

fs/xfs/xfs_mount.c

139

uint64_t nblocks)

fs/xfs/xfs_mount.c

145

if (check_shl_overflow(nblocks, sbp->sb_blocklog, &max_bytes))

include/crypto/internal/poly1305.h

29

unsigned int nblocks, u32 hibit);

include/linux/jbd2.h

1503

extern handle_t *jbd2_journal_start(journal_t *, int nblocks);

include/linux/jbd2.h

1507

extern int jbd2_journal_restart(handle_t *, int nblocks);

include/linux/jbd2.h

1508

extern int jbd2__journal_restart(handle_t *, int nblocks,

include/linux/jbd2.h

1513

extern int jbd2_journal_extend(handle_t *handle, int nblocks,

include/sound/tas2781-dsp.h

193

unsigned int nblocks;

include/sound/util_mem.h

29

int nblocks; /* # of allocated blocks */

include/uapi/linux/nilfs2_api.h

134

NILFS_SUINFO_UPDATE_FNS(NBLOCKS, nblocks)

include/uapi/linux/nvme_ioctl.h

16

__u16 nblocks;

include/vdso/getrandom.h

57

extern void __arch_chacha20_blocks_nostack(u8 *dst_bytes, const u32 *key, u32 *counter, size_t nblocks);

init/do_mounts_rd.c

100

nblocks = (ntohl(romfsb->size)+BLOCK_SIZE-1)>>BLOCK_SIZE_BITS;

init/do_mounts_rd.c

108

nblocks = (cramfsb->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;

init/do_mounts_rd.c

117

nblocks = (le64_to_cpu(squashfsb->bytes_used) + BLOCK_SIZE - 1)

init/do_mounts_rd.c

132

nblocks = (cramfsb->size + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;

init/do_mounts_rd.c

148

nblocks = minixsb->s_nzones << minixsb->s_log_zone_size;

init/do_mounts_rd.c

158

nblocks = n;

init/do_mounts_rd.c

168

return nblocks;

init/do_mounts_rd.c

184

int nblocks, i;

init/do_mounts_rd.c

199

nblocks = identify_ramdisk_image(in_file, in_pos, &decompressor);

init/do_mounts_rd.c

200

if (nblocks < 0)

init/do_mounts_rd.c

203

if (nblocks == 0) {

init/do_mounts_rd.c

214

if (nblocks > rd_blocks) {

init/do_mounts_rd.c

216

nblocks, rd_blocks);

init/do_mounts_rd.c

223

devblocks = nblocks;

init/do_mounts_rd.c

236

nr_disks = (nblocks - 1) / devblocks + 1;

init/do_mounts_rd.c

238

nblocks, nr_disks, str_plural(nr_disks));

init/do_mounts_rd.c

239

for (i = 0; i < nblocks; i++) {

init/do_mounts_rd.c

60

int nblocks = -1;

init/do_mounts_rd.c

90

nblocks = 0;

lib/crypto/arm/blake2b.h

14

const u8 *data, size_t nblocks, u32 inc);

lib/crypto/arm/blake2b.h

17

const u8 *data, size_t nblocks, u32 inc)

lib/crypto/arm/blake2b.h

20

blake2b_compress_generic(ctx, data, nblocks, inc);

lib/crypto/arm/blake2b.h

24

const size_t blocks = min_t(size_t, nblocks,

lib/crypto/arm/blake2b.h

31

nblocks -= blocks;

lib/crypto/arm/blake2b.h

32

} while (nblocks);

lib/crypto/arm/blake2s.h

5

const u8 *data, size_t nblocks, u32 inc);

lib/crypto/arm/sha1.h

13

const u8 *data, size_t nblocks);

lib/crypto/arm/sha1.h

15

const u8 *data, size_t nblocks);

lib/crypto/arm/sha1.h

17

const u8 *data, size_t nblocks);

lib/crypto/arm/sha1.h

20

const u8 *data, size_t nblocks)

lib/crypto/arm/sha1.h

26

sha1_ce_transform(state, data, nblocks);

lib/crypto/arm/sha1.h

28

sha1_transform_neon(state, data, nblocks);

lib/crypto/arm/sha1.h

31

sha1_block_data_order(state, data, nblocks);

lib/crypto/arm/sha256.h

14

const u8 *data, size_t nblocks);

lib/crypto/arm/sha256.h

16

const u8 *data, size_t nblocks);

lib/crypto/arm/sha256.h

18

const u8 *data, size_t nblocks);

lib/crypto/arm/sha256.h

21

const u8 *data, size_t nblocks)

lib/crypto/arm/sha256.h

27

sha256_ce_transform(state, data, nblocks);

lib/crypto/arm/sha256.h

29

sha256_block_data_order_neon(state, data, nblocks);

lib/crypto/arm/sha256.h

32

sha256_block_data_order(state, data, nblocks);

lib/crypto/arm/sha512.h

13

const u8 *data, size_t nblocks);

lib/crypto/arm/sha512.h

15

const u8 *data, size_t nblocks);

lib/crypto/arm/sha512.h

18

const u8 *data, size_t nblocks)

lib/crypto/arm/sha512.h

23

sha512_block_data_order_neon(state, data, nblocks);

lib/crypto/arm/sha512.h

25

sha512_block_data_order(state, data, nblocks);

lib/crypto/arm64/polyval.h

18

const u8 *data, size_t nblocks);

lib/crypto/arm64/polyval.h

56

const u8 *data, size_t nblocks)

lib/crypto/arm64/polyval.h

61

size_t n = min_t(size_t, nblocks,

lib/crypto/arm64/polyval.h

67

nblocks -= n;

lib/crypto/arm64/polyval.h

68

} while (nblocks);

lib/crypto/arm64/polyval.h

71

data, nblocks);

lib/crypto/arm64/sha1.h

13

const u8 *data, size_t nblocks);

lib/crypto/arm64/sha1.h

16

const u8 *data, size_t nblocks)

lib/crypto/arm64/sha1.h

23

rem = __sha1_ce_transform(state, data, nblocks);

lib/crypto/arm64/sha1.h

25

data += (nblocks - rem) * SHA1_BLOCK_SIZE;

lib/crypto/arm64/sha1.h

26

nblocks = rem;

lib/crypto/arm64/sha1.h

27

} while (nblocks);

lib/crypto/arm64/sha1.h

29

sha1_blocks_generic(state, data, nblocks);

lib/crypto/arm64/sha256.h

14

const u8 *data, size_t nblocks);

lib/crypto/arm64/sha256.h

16

const u8 *data, size_t nblocks);

lib/crypto/arm64/sha256.h

18

const u8 *data, size_t nblocks);

lib/crypto/arm64/sha256.h

21

const u8 *data, size_t nblocks)

lib/crypto/arm64/sha256.h

31

nblocks);

lib/crypto/arm64/sha256.h

33

data += (nblocks - rem) * SHA256_BLOCK_SIZE;

lib/crypto/arm64/sha256.h

34

nblocks = rem;

lib/crypto/arm64/sha256.h

35

} while (nblocks);

lib/crypto/arm64/sha256.h

38

sha256_block_neon(state, data, nblocks);

lib/crypto/arm64/sha256.h

41

sha256_block_data_order(state, data, nblocks);

lib/crypto/arm64/sha3.h

16

size_t nblocks, size_t block_size);

lib/crypto/arm64/sha3.h

19

size_t nblocks, size_t block_size)

lib/crypto/arm64/sha3.h

26

rem = sha3_ce_transform(state, data, nblocks,

lib/crypto/arm64/sha3.h

28

data += (nblocks - rem) * block_size;

lib/crypto/arm64/sha3.h

29

nblocks = rem;

lib/crypto/arm64/sha3.h

30

} while (nblocks);

lib/crypto/arm64/sha3.h

32

sha3_absorb_blocks_generic(state, data, nblocks, block_size);

lib/crypto/arm64/sha512.h

14

const u8 *data, size_t nblocks);

lib/crypto/arm64/sha512.h

16

const u8 *data, size_t nblocks);

lib/crypto/arm64/sha512.h

19

const u8 *data, size_t nblocks)

lib/crypto/arm64/sha512.h

28

rem = __sha512_ce_transform(state, data, nblocks);

lib/crypto/arm64/sha512.h

30

data += (nblocks - rem) * SHA512_BLOCK_SIZE;

lib/crypto/arm64/sha512.h

31

nblocks = rem;

lib/crypto/arm64/sha512.h

32

} while (nblocks);

lib/crypto/arm64/sha512.h

34

sha512_block_data_order(state, data, nblocks);

lib/crypto/blake2b.c

102

--nblocks;

lib/crypto/blake2b.c

131

const size_t nblocks = DIV_ROUND_UP(inlen, BLAKE2B_BLOCK_SIZE);

lib/crypto/blake2b.c

133

blake2b_compress(ctx, in, nblocks - 1, BLAKE2B_BLOCK_SIZE);

lib/crypto/blake2b.c

134

in += BLAKE2B_BLOCK_SIZE * (nblocks - 1);

lib/crypto/blake2b.c

135

inlen -= BLAKE2B_BLOCK_SIZE * (nblocks - 1);

lib/crypto/blake2b.c

43

const u8 *data, size_t nblocks, u32 inc)

lib/crypto/blake2b.c

50

(nblocks > 1 && inc != BLAKE2B_BLOCK_SIZE));

lib/crypto/blake2b.c

52

while (nblocks > 0) {

lib/crypto/blake2s.c

125

const size_t nblocks = DIV_ROUND_UP(inlen, BLAKE2S_BLOCK_SIZE);

lib/crypto/blake2s.c

127

blake2s_compress(ctx, in, nblocks - 1, BLAKE2S_BLOCK_SIZE);

lib/crypto/blake2s.c

128

in += BLAKE2S_BLOCK_SIZE * (nblocks - 1);

lib/crypto/blake2s.c

129

inlen -= BLAKE2S_BLOCK_SIZE * (nblocks - 1);

lib/crypto/blake2s.c

41

const u8 *data, size_t nblocks, u32 inc)

lib/crypto/blake2s.c

48

(nblocks > 1 && inc != BLAKE2S_BLOCK_SIZE));

lib/crypto/blake2s.c

50

while (nblocks > 0) {

lib/crypto/blake2s.c

96

--nblocks;

lib/crypto/md5.c

123

const u8 *data, size_t nblocks)

lib/crypto/md5.c

128

} while (--nblocks);

lib/crypto/md5.c

151

size_t nblocks;

lib/crypto/md5.c

163

nblocks = len / MD5_BLOCK_SIZE;

lib/crypto/md5.c

166

if (nblocks) {

lib/crypto/md5.c

167

md5_blocks(&ctx->state, data, nblocks);

lib/crypto/md5.c

168

data += nblocks * MD5_BLOCK_SIZE;

lib/crypto/mips/md5.h

30

const u8 *data, size_t nblocks)

lib/crypto/mips/md5.h

37

return md5_blocks_generic(state, data, nblocks);

lib/crypto/mips/md5.h

58

} while (--nblocks);

lib/crypto/mips/sha1.h

53

const u8 *data, size_t nblocks)

lib/crypto/mips/sha1.h

59

return sha1_blocks_generic(state, data, nblocks);

lib/crypto/mips/sha1.h

77

} while (--nblocks);

lib/crypto/mips/sha256.h

23

const u8 *data, size_t nblocks)

lib/crypto/mips/sha256.h

30

return sha256_blocks_generic(state, data, nblocks);

lib/crypto/mips/sha256.h

51

} while (--nblocks);

lib/crypto/mips/sha512.h

24

const u8 *data, size_t nblocks)

lib/crypto/mips/sha512.h

30

return sha512_blocks_generic(state, data, nblocks);

lib/crypto/mips/sha512.h

63

} while (--nblocks);

lib/crypto/poly1305-donna32.c

111

} while (--nblocks);

lib/crypto/poly1305-donna32.c

34

unsigned int nblocks, u32 hibit)

lib/crypto/poly1305-donna32.c

43

if (!nblocks)

lib/crypto/poly1305-donna64.c

104

} while (--nblocks);

lib/crypto/poly1305-donna64.c

35

unsigned int nblocks, u32 hibit)

lib/crypto/poly1305-donna64.c

45

if (!nblocks)

lib/crypto/polyval.c

210

const u8 *data, size_t nblocks)

lib/crypto/polyval.c

217

} while (--nblocks);

lib/crypto/polyval.c

249

const u8 *data, size_t nblocks)

lib/crypto/polyval.c

252

polyval_blocks_arch(&ctx->acc, ctx->key, data, nblocks);

lib/crypto/polyval.c

254

polyval_blocks_generic(&ctx->acc, &ctx->key->h, data, nblocks);

lib/crypto/polyval.c

271

size_t nblocks = len / POLYVAL_BLOCK_SIZE;

lib/crypto/polyval.c

273

polyval_blocks(ctx, data, nblocks);

lib/crypto/powerpc/md5.h

11

ppc_md5_transform(state->h, data, nblocks);

lib/crypto/powerpc/md5.h

6

void ppc_md5_transform(u32 *state, const u8 *data, size_t nblocks);

lib/crypto/powerpc/md5.h

9

const u8 *data, size_t nblocks)

lib/crypto/powerpc/sha1.h

25

const u8 *data, u32 nblocks);

lib/crypto/powerpc/sha1.h

42

const u8 *data, size_t nblocks)

lib/crypto/powerpc/sha1.h

45

u32 unit = min_t(size_t, nblocks, MAX_BYTES / SHA1_BLOCK_SIZE);

lib/crypto/powerpc/sha1.h

52

nblocks -= unit;

lib/crypto/powerpc/sha1.h

53

} while (nblocks);

lib/crypto/powerpc/sha1.h

60

const u8 *data, size_t nblocks)

lib/crypto/powerpc/sha1.h

65

} while (--nblocks);

lib/crypto/powerpc/sha256.h

44

const u8 *data, size_t nblocks)

lib/crypto/powerpc/sha256.h

48

u32 unit = min_t(size_t, nblocks,

lib/crypto/powerpc/sha256.h

56

nblocks -= unit;

lib/crypto/powerpc/sha256.h

57

} while (nblocks);

lib/crypto/riscv/chacha.h

17

size_t nblocks, int nrounds);

lib/crypto/riscv/sha256.h

19

const u8 *data, size_t nblocks);

lib/crypto/riscv/sha256.h

22

const u8 *data, size_t nblocks)

lib/crypto/riscv/sha256.h

26

sha256_transform_zvknha_or_zvknhb_zvkb(state, data, nblocks);

lib/crypto/riscv/sha256.h

29

sha256_blocks_generic(state, data, nblocks);

lib/crypto/riscv/sha512.h

18

const u8 *data, size_t nblocks);

lib/crypto/riscv/sha512.h

21

const u8 *data, size_t nblocks)

lib/crypto/riscv/sha512.h

25

sha512_transform_zvknhb_zvkb(state, data, nblocks);

lib/crypto/riscv/sha512.h

28

sha512_blocks_generic(state, data, nblocks);

lib/crypto/s390/sha1.h

13

const u8 *data, size_t nblocks)

lib/crypto/s390/sha1.h

17

nblocks * SHA1_BLOCK_SIZE);

lib/crypto/s390/sha1.h

19

sha1_blocks_generic(state, data, nblocks);

lib/crypto/s390/sha256.h

13

const u8 *data, size_t nblocks)

lib/crypto/s390/sha256.h

17

nblocks * SHA256_BLOCK_SIZE);

lib/crypto/s390/sha256.h

19

sha256_blocks_generic(state, data, nblocks);

lib/crypto/s390/sha3.h

14

size_t nblocks, size_t block_size)

lib/crypto/s390/sha3.h

25

data, nblocks * block_size);

lib/crypto/s390/sha3.h

33

data, nblocks * block_size);

lib/crypto/s390/sha3.h

37

data, nblocks * block_size);

lib/crypto/s390/sha3.h

41

data, nblocks * block_size);

lib/crypto/s390/sha3.h

45

sha3_absorb_blocks_generic(state, data, nblocks, block_size);

lib/crypto/s390/sha512.h

13

const u8 *data, size_t nblocks)

lib/crypto/s390/sha512.h

17

nblocks * SHA512_BLOCK_SIZE);

lib/crypto/s390/sha512.h

19

sha512_blocks_generic(state, data, nblocks);

lib/crypto/sha1.c

116

const u8 *data, size_t nblocks)

lib/crypto/sha1.c

123

} while (--nblocks);

lib/crypto/sha1.c

148

size_t nblocks;

lib/crypto/sha1.c

160

nblocks = len / SHA1_BLOCK_SIZE;

lib/crypto/sha1.c

163

if (nblocks) {

lib/crypto/sha1.c

164

sha1_blocks(&ctx->state, data, nblocks);

lib/crypto/sha1.c

165

data += nblocks * SHA1_BLOCK_SIZE;

lib/crypto/sha256.c

147

const u8 *data, size_t nblocks)

lib/crypto/sha256.c

154

} while (--nblocks);

lib/crypto/sha256.c

192

size_t nblocks;

lib/crypto/sha256.c

204

nblocks = len / SHA256_BLOCK_SIZE;

lib/crypto/sha256.c

207

if (nblocks) {

lib/crypto/sha256.c

208

sha256_blocks(&ctx->state, data, nblocks);

lib/crypto/sha256.c

209

data += nblocks * SHA256_BLOCK_SIZE;

lib/crypto/sha3.c

183

size_t nblocks, size_t block_size)

lib/crypto/sha3.c

190

} while (--nblocks);

lib/crypto/sha3.c

218

size_t nblocks = in_len / block_size;

lib/crypto/sha3.c

220

sha3_absorb_blocks(&ctx->state, in, nblocks, block_size);

lib/crypto/sha3.c

221

in += nblocks * block_size;

lib/crypto/sha3.c

222

in_len -= nblocks * block_size;

lib/crypto/sha512.c

128

const u8 *data, size_t nblocks)

lib/crypto/sha512.c

133

} while (--nblocks);

lib/crypto/sha512.c

171

size_t nblocks;

lib/crypto/sha512.c

183

nblocks = len / SHA512_BLOCK_SIZE;

lib/crypto/sha512.c

186

if (nblocks) {

lib/crypto/sha512.c

187

sha512_blocks(&ctx->state, data, nblocks);

lib/crypto/sha512.c

188

data += nblocks * SHA512_BLOCK_SIZE;

lib/crypto/sparc/md5.h

20

const u8 *data, size_t nblocks);

lib/crypto/sparc/md5.h

23

const u8 *data, size_t nblocks)

lib/crypto/sparc/md5.h

27

md5_sparc64_transform(state, data, nblocks);

lib/crypto/sparc/md5.h

30

md5_blocks_generic(state, data, nblocks);

lib/crypto/sparc/sha1.h

18

const u8 *data, size_t nblocks);

lib/crypto/sparc/sha1.h

21

const u8 *data, size_t nblocks)

lib/crypto/sparc/sha1.h

24

sha1_sparc64_transform(state, data, nblocks);

lib/crypto/sparc/sha1.h

26

sha1_blocks_generic(state, data, nblocks);

lib/crypto/sparc/sha256.h

18

const u8 *data, size_t nblocks);

lib/crypto/sparc/sha256.h

21

const u8 *data, size_t nblocks)

lib/crypto/sparc/sha256.h

24

sha256_sparc64_transform(state, data, nblocks);

lib/crypto/sparc/sha256.h

26

sha256_blocks_generic(state, data, nblocks);

lib/crypto/sparc/sha512.h

17

const u8 *data, size_t nblocks);

lib/crypto/sparc/sha512.h

20

const u8 *data, size_t nblocks)

lib/crypto/sparc/sha512.h

23

sha512_sparc64_transform(state, data, nblocks);

lib/crypto/sparc/sha512.h

25

sha512_blocks_generic(state, data, nblocks);

lib/crypto/x86/blake2s.h

15

const u8 *data, size_t nblocks, u32 inc);

lib/crypto/x86/blake2s.h

17

const u8 *data, size_t nblocks, u32 inc);

lib/crypto/x86/blake2s.h

23

const u8 *data, size_t nblocks, u32 inc)

lib/crypto/x86/blake2s.h

29

blake2s_compress_generic(ctx, data, nblocks, inc);

lib/crypto/x86/blake2s.h

34

const size_t blocks = min_t(size_t, nblocks,

lib/crypto/x86/blake2s.h

45

nblocks -= blocks;

lib/crypto/x86/blake2s.h

46

} while (nblocks);

lib/crypto/x86/polyval.h

18

const u8 *data, size_t nblocks);

lib/crypto/x86/polyval.h

57

const u8 *data, size_t nblocks)

lib/crypto/x86/polyval.h

62

size_t n = min_t(size_t, nblocks,

lib/crypto/x86/polyval.h

69

nblocks -= n;

lib/crypto/x86/polyval.h

70

} while (nblocks);

lib/crypto/x86/polyval.h

73

data, nblocks);

lib/crypto/x86/sha1.h

14

const u8 *data, size_t nblocks); \

lib/crypto/x86/sha1.h

16

const u8 *data, size_t nblocks) \

lib/crypto/x86/sha1.h

20

asm_fn(state, data, nblocks); \

lib/crypto/x86/sha1.h

23

sha1_blocks_generic(state, data, nblocks); \

lib/crypto/x86/sha1.h

34

const u8 *data, size_t nblocks);

lib/crypto/x86/sha1.h

36

const u8 *data, size_t nblocks)

lib/crypto/x86/sha1.h

41

if (nblocks >= SHA1_AVX2_BLOCK_OPTSIZE)

lib/crypto/x86/sha1.h

42

sha1_transform_avx2(state, data, nblocks);

lib/crypto/x86/sha1.h

44

sha1_transform_avx(state, data, nblocks);

lib/crypto/x86/sha1.h

47

sha1_blocks_generic(state, data, nblocks);

lib/crypto/x86/sha1.h

52

const u8 *data, size_t nblocks)

lib/crypto/x86/sha1.h

54

static_call(sha1_blocks_x86)(state, data, nblocks);

lib/crypto/x86/sha256.h

16

const u8 *data, size_t nblocks); \

lib/crypto/x86/sha256.h

18

size_t nblocks) \

lib/crypto/x86/sha256.h

22

asm_fn(state, data, nblocks); \

lib/crypto/x86/sha256.h

25

sha256_blocks_generic(state, data, nblocks); \

lib/crypto/x86/sha256.h

35

const u8 *data, size_t nblocks)

lib/crypto/x86/sha256.h

37

static_call(sha256_blocks_x86)(state, data, nblocks);

lib/crypto/x86/sha512.h

14

const u8 *data, size_t nblocks); \

lib/crypto/x86/sha512.h

16

size_t nblocks) \

lib/crypto/x86/sha512.h

20

asm_fn(state, data, nblocks); \

lib/crypto/x86/sha512.h

23

sha512_blocks_generic(state, data, nblocks); \

lib/crypto/x86/sha512.h

32

const u8 *data, size_t nblocks)

lib/crypto/x86/sha512.h

34

static_call(sha512_blocks_x86)(state, data, nblocks);

lib/vdso/getrandom.c

238

nblocks = len / CHACHA_BLOCK_SIZE;

lib/vdso/getrandom.c

239

if (nblocks) {

lib/vdso/getrandom.c

240

__arch_chacha20_blocks_nostack(buffer, state->key, counter, nblocks);

lib/vdso/getrandom.c

241

buffer += nblocks * CHACHA_BLOCK_SIZE;

lib/vdso/getrandom.c

242

len -= nblocks * CHACHA_BLOCK_SIZE;

lib/vdso/getrandom.c

76

size_t batch_len, nblocks, orig_len = len;

net/ipv4/inet_hashtables.c

1302

unsigned int i, nblocks = 1;

net/ipv4/inet_hashtables.c

1309

nblocks = max(2U * L1_CACHE_BYTES / locksz, 1U) * num_possible_cpus();

net/ipv4/inet_hashtables.c

1312

nblocks = max(nblocks, num_online_nodes() * PAGE_SIZE / locksz);

net/ipv4/inet_hashtables.c

1314

nblocks = roundup_pow_of_two(nblocks);

net/ipv4/inet_hashtables.c

1317

nblocks = min(nblocks, hashinfo->ehash_mask + 1);

net/ipv4/inet_hashtables.c

1323

ptr = vmalloc_array(nblocks, locksz);

net/ipv4/inet_hashtables.c

1326

ptr = kvmalloc_array(nblocks, locksz, GFP_KERNEL);

net/ipv4/inet_hashtables.c

1330

for (i = 0; i < nblocks; i++)

net/ipv4/inet_hashtables.c

1334

hashinfo->ehash_locks_mask = nblocks - 1;

net/sunrpc/auth_gss/gss_krb5_crypto.c

481

u32 blocksize, nbytes, nblocks, cbcbytes;

net/sunrpc/auth_gss/gss_krb5_crypto.c

487

nblocks = (nbytes + blocksize - 1) / blocksize;

net/sunrpc/auth_gss/gss_krb5_crypto.c

489

if (nblocks > 2)

net/sunrpc/auth_gss/gss_krb5_crypto.c

490

cbcbytes = (nblocks - 2) * blocksize;

net/sunrpc/auth_gss/gss_krb5_crypto.c

545

u32 blocksize, nblocks, cbcbytes;

net/sunrpc/auth_gss/gss_krb5_crypto.c

550

nblocks = (buf->len + blocksize - 1) / blocksize;

net/sunrpc/auth_gss/gss_krb5_crypto.c

552

if (nblocks > 2)

net/sunrpc/auth_gss/gss_krb5_crypto.c

553

cbcbytes = (nblocks - 2) * blocksize;

sound/soc/codecs/pcm6240.c

1260

cfg_info->nblocks =

sound/soc/codecs/pcm6240.c

1265

cfg_info->nblocks);

sound/soc/codecs/pcm6240.c

1271

for (i = 0; i < cfg_info->nblocks; i++) {

sound/soc/codecs/pcm6240.c

1276

__func__, i, cfg_info->nblocks);

sound/soc/codecs/pcm6240.c

1315

__func__, i, cfg_info->nblocks);

sound/soc/codecs/pcm6240.h

199

unsigned int nblocks;

sound/soc/codecs/tas2781-fmwlib.c

223

cfg_info->nblocks = get_unaligned_be32(&config_data[config_offset]);

sound/soc/codecs/tas2781-fmwlib.c

231

cfg_info->nblocks);

sound/soc/codecs/tas2781-fmwlib.c

237

for (i = 0; i < cfg_info->nblocks; i++) {

sound/soc/codecs/tas2781-fmwlib.c

242

__func__, i, cfg_info->nblocks);

sound/soc/codecs/tas2781-fmwlib.c

282

__func__, i, cfg_info->nblocks);

sound/synth/emux/emux_proc.c

36

snd_iprintf(buf, "Allocated Blocks: %d\n", emu->memhdr->nblocks);

sound/synth/util_mem.c

115

hdr->nblocks++;

sound/synth/util_mem.c

140

hdr->nblocks--;

tools/lib/bpf/libbpf_utils.c

195

static void sha256_blocks(__u32 state[8], const __u8 *data, size_t nblocks)

tools/lib/bpf/libbpf_utils.c

197

while (nblocks--) {

tools/perf/util/blake2s.c

109

--nblocks;

tools/perf/util/blake2s.c

132

const size_t nblocks = DIV_ROUND_UP(inlen, BLAKE2S_BLOCK_SIZE);

tools/perf/util/blake2s.c

134

blake2s_compress(ctx, in, nblocks - 1, BLAKE2S_BLOCK_SIZE);

tools/perf/util/blake2s.c

135

in += BLAKE2S_BLOCK_SIZE * (nblocks - 1);

tools/perf/util/blake2s.c

136

inlen -= BLAKE2S_BLOCK_SIZE * (nblocks - 1);

tools/perf/util/blake2s.c

50

const u8 *data, size_t nblocks, u32 inc)

tools/perf/util/blake2s.c

56

while (nblocks > 0) {

tools/testing/selftests/vDSO/vdso_test_chacha.c

37

static void reference_chacha20_blocks(uint8_t *dst_bytes, const uint32_t *key, uint32_t *counter, size_t nblocks)

tools/testing/selftests/vDSO/vdso_test_chacha.c

45

while (nblocks--) {

tools/testing/selftests/vDSO/vdso_test_chacha.c

77

void __weak __arch_chacha20_blocks_nostack(uint8_t *dst_bytes, const uint32_t *key, uint32_t *counter, size_t nblocks)