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

201

int nblocks = walk.nbytes / AES_BLOCK_SIZE;

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

203

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

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

205

counter += nblocks;

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

208

src += nblocks * AES_BLOCK_SIZE;

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

209

dst += nblocks * AES_BLOCK_SIZE;

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

294

int nblocks = walk.nbytes / AES_BLOCK_SIZE;

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

296

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

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

298

counter += nblocks;

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

301

src += nblocks * AES_BLOCK_SIZE;

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

302

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

239

u32 ctr32, nblocks;

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

250

nblocks = nbytes / AES_BLOCK_SIZE;

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

253

nblocks = DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

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

255

ctr32 += nblocks;

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

258

if (ctr32 >= nblocks) {

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

270

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

arch/x86/crypto/aesni-intel_glue.c

610

unsigned int nbytes, p1_nbytes, nblocks;

arch/x86/crypto/aesni-intel_glue.c

625

nblocks = nbytes / AES_BLOCK_SIZE;

arch/x86/crypto/aesni-intel_glue.c

628

nblocks = DIV_ROUND_UP(nbytes, AES_BLOCK_SIZE);

arch/x86/crypto/aesni-intel_glue.c

630

ctr64 += nblocks;

arch/x86/crypto/aesni-intel_glue.c

633

if (likely(ctr64 >= nblocks)) {

arch/x86/crypto/aesni-intel_glue.c

644

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

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

81

if (be32_to_cpu(slice->nblocks)) {

block/partitions/sysv68.c

84

be32_to_cpu(slice->nblocks));

drivers/block/virtio_blk.c

920

unsigned long long nblocks;

drivers/block/virtio_blk.c

926

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

drivers/block/virtio_blk.c

928

string_get_size(nblocks, queue_logical_block_size(q),

drivers/block/virtio_blk.c

930

string_get_size(nblocks, queue_logical_block_size(q),

drivers/block/virtio_blk.c

937

nblocks,

drivers/cdrom/cdrom.c

2069

int blocksize, int nblocks)

drivers/cdrom/cdrom.c

2079

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

drivers/cdrom/cdrom.c

2080

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

drivers/cdrom/cdrom.c

2081

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

drivers/cdrom/cdrom.c

2082

cgc->buflen = blocksize * nblocks;

drivers/cdrom/cdrom.c

2089

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

drivers/cdrom/cdrom.c

2103

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

drivers/cdrom/cdrom.c

2104

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

drivers/cdrom/cdrom.c

2105

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

drivers/cdrom/cdrom.c

2106

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

1015

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

drivers/infiniband/hw/mlx5/umr.c

1017

*nblocks = ALIGN(*nblocks, MLX5_UMR_KSM_NUM_ENTRIES_ALIGNMENT);

drivers/infiniband/hw/mlx5/umr.c

1019

*nblocks = ALIGN(*nblocks, MLX5_UMR_MTT_NUM_ENTRIES_ALIGNMENT);

drivers/infiniband/hw/mlx5/umr.c

1026

if (*nblocks >= page_shift_nblocks)

drivers/infiniband/hw/mlx5/umr.c

1027

*nblocks = 0;

drivers/infiniband/hw/mlx5/umr.c

1032

if (*nblocks)

drivers/infiniband/hw/mlx5/umr.c

1034

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

drivers/infiniband/hw/mlx5/umr.c

1043

if (*nblocks) {

drivers/infiniband/hw/mlx5/umr.c

688

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

814

true, start_block, nblocks);

drivers/infiniband/hw/mlx5/umr.c

824

u32 pdn, size_t start_block, size_t nblocks)

drivers/infiniband/hw/mlx5/umr.c

830

nblocks);

drivers/infiniband/hw/mlx5/umr.c

970

size_t nblocks, bool dd)

drivers/infiniband/hw/mlx5/umr.c

975

nblocks);

drivers/infiniband/hw/mlx5/umr.c

978

start_block, nblocks);

drivers/infiniband/hw/mlx5/umr.c

993

unsigned int page_shift, size_t *nblocks,

drivers/infiniband/hw/mlx5/umr.h

101

size_t nblocks);

drivers/infiniband/hw/mlx5/umr.h

104

u32 pdn, 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

226

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

drivers/nvme/host/ioctl.c

239

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

drivers/nvme/host/ioctl.c

256

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

drivers/nvme/host/ioctl.c

567

__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

358

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

fs/btrfs/file-item.c

384

if (nblocks * csum_size > BTRFS_BIO_INLINE_CSUM_SIZE) {

fs/btrfs/file-item.c

385

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

fs/btrfs/file-item.c

396

if (nblocks > fs_info->csums_per_leaf)

fs/ext4/ext4.h

3030

int nblocks);

fs/ext4/ext4.h

3036

type, nblocks) \

fs/ext4/ext4.h

3038

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

1012

nblocks += ret2;

fs/ext4/ialloc.c

1088

BUG_ON(nblocks <= 0);

fs/ext4/ialloc.c

1090

line_no, handle_type, nblocks, 0,

fs/ext4/ialloc.c

880

int nblocks = 0;

fs/ext4/ialloc.c

889

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

fs/ext4/ialloc.c

908

nblocks += num_security_xattrs *

fs/ext4/ialloc.c

915

nblocks += __ext4_xattr_set_credits(sb,

fs/ext4/ialloc.c

920

return nblocks;

fs/ext4/ialloc.c

938

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

1023

struct buffer_head **bh, unsigned long nblocks)

fs/isofs/inode.c

1047

while (nblocks) {

fs/isofs/inode.c

1101

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

483

nblocks += DIV_ROUND_UP(revoke_records,

fs/jbd2/transaction.c

485

handle = new_handle(nblocks);

fs/jbd2/transaction.c

513

line_no, nblocks);

fs/jbd2/transaction.c

539

handle_t *jbd2_journal_start(journal_t *journal, int nblocks)

fs/jbd2/transaction.c

541

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

fs/jbd2/transaction.c

642

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

fs/jbd2/transaction.c

660

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

fs/jbd2/transaction.c

664

nblocks += DIV_ROUND_UP(

fs/jbd2/transaction.c

670

wanted = atomic_add_return(nblocks,

fs/jbd2/transaction.c

675

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

fs/jbd2/transaction.c

676

atomic_sub(nblocks, &transaction->t_outstanding_credits);

fs/jbd2/transaction.c

684

nblocks);

fs/jbd2/transaction.c

686

handle->h_total_credits += nblocks;

fs/jbd2/transaction.c

687

handle->h_requested_credits += nblocks;

fs/jbd2/transaction.c

692

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

fs/jbd2/transaction.c

760

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

fs/jbd2/transaction.c

793

handle->h_total_credits = nblocks +

fs/jbd2/transaction.c

807

int jbd2_journal_restart(handle_t *handle, int nblocks)

fs/jbd2/transaction.c

809

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

1012

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

fs/jfs/jfs_dmap.c

1018

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

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

1032

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

fs/jfs/jfs_dmap.c

1059

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

fs/jfs/jfs_dmap.c

107

static int dbGetL2AGSize(s64 nblocks);

fs/jfs/jfs_dmap.c

1074

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

fs/jfs/jfs_dmap.c

1078

lastblkno = blkno + nblocks - 1;

fs/jfs/jfs_dmap.c

1159

int nblocks)

fs/jfs/jfs_dmap.c

1184

if (dbitno + nblocks > BPERDMAP)

fs/jfs/jfs_dmap.c

1206

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

fs/jfs/jfs_dmap.c

1258

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

fs/jfs/jfs_dmap.c

1291

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

fs/jfs/jfs_dmap.c

1334

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

fs/jfs/jfs_dmap.c

1399

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

fs/jfs/jfs_dmap.c

1440

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

fs/jfs/jfs_dmap.c

1445

(unsigned long long) nblocks);

fs/jfs/jfs_dmap.c

1559

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

fs/jfs/jfs_dmap.c

1603

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

fs/jfs/jfs_dmap.c

1619

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

fs/jfs/jfs_dmap.c

1662

s64 nblocks, blkno;

fs/jfs/jfs_dmap.c

1669

u64 nblocks;

fs/jfs/jfs_dmap.c

1679

nblocks = bmp->db_agfree[agno];

fs/jfs/jfs_dmap.c

1680

max_ranges = nblocks;

fs/jfs/jfs_dmap.c

1691

while (nblocks >= minlen) {

fs/jfs/jfs_dmap.c

1692

l2nb = BLKSTOL2(nblocks);

fs/jfs/jfs_dmap.c

1695

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

fs/jfs/jfs_dmap.c

1698

tt->nblocks = nblocks;

fs/jfs/jfs_dmap.c

1706

nblocks = bmp->db_agfree[agno];

fs/jfs/jfs_dmap.c

1710

l2nb = BLKSTOL2(nblocks) - 1;

fs/jfs/jfs_dmap.c

1713

nblocks = 1LL << l2nb;

fs/jfs/jfs_dmap.c

1726

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

fs/jfs/jfs_dmap.c

1727

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

fs/jfs/jfs_dmap.c

1731

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

fs/jfs/jfs_dmap.c

1732

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

fs/jfs/jfs_dmap.c

1733

trimmed += tt->nblocks;

fs/jfs/jfs_dmap.c

1887

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

fs/jfs/jfs_dmap.c

1912

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

fs/jfs/jfs_dmap.c

1928

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

fs/jfs/jfs_dmap.c

1980

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

fs/jfs/jfs_dmap.c

2044

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

fs/jfs/jfs_dmap.c

2075

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

fs/jfs/jfs_dmap.c

2110

int nblocks)

fs/jfs/jfs_dmap.c

2121

dbAllocBits(bmp, dp, blkno, nblocks);

fs/jfs/jfs_dmap.c

2132

dbFreeBits(bmp, dp, blkno, nblocks);

fs/jfs/jfs_dmap.c

2165

int nblocks)

fs/jfs/jfs_dmap.c

2176

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

fs/jfs/jfs_dmap.c

2197

dbAllocBits(bmp, dp, blkno, nblocks);

fs/jfs/jfs_dmap.c

2227

int nblocks)

fs/jfs/jfs_dmap.c

2244

assert(dbitno + nblocks <= BPERDMAP);

fs/jfs/jfs_dmap.c

2259

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

fs/jfs/jfs_dmap.c

2331

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

fs/jfs/jfs_dmap.c

2344

bmp->db_agfree[agno] -= nblocks;

fs/jfs/jfs_dmap.c

2345

bmp->db_nfree -= nblocks;

fs/jfs/jfs_dmap.c

2374

int nblocks)

fs/jfs/jfs_dmap.c

2389

assert(dbitno + nblocks <= BPERDMAP);

fs/jfs/jfs_dmap.c

2408

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

fs/jfs/jfs_dmap.c

2475

le32_add_cpu(&dp->nfree, nblocks);

fs/jfs/jfs_dmap.c

2483

bmp->db_nfree += nblocks;

fs/jfs/jfs_dmap.c

2484

bmp->db_agfree[agno] += nblocks;

fs/jfs/jfs_dmap.c

3278

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

fs/jfs/jfs_dmap.c

3290

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

fs/jfs/jfs_dmap.c

3296

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

fs/jfs/jfs_dmap.c

3334

int nblocks)

fs/jfs/jfs_dmap.c

3353

assert(dbitno + nblocks <= BPERDMAP);

fs/jfs/jfs_dmap.c

3368

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

fs/jfs/jfs_dmap.c

3401

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

fs/jfs/jfs_dmap.c

3417

bmp->db_agfree[agno] -= nblocks;

fs/jfs/jfs_dmap.c

3418

bmp->db_nfree -= nblocks;

fs/jfs/jfs_dmap.c

3431

dbFreeBits(bmp, dp, blkno, nblocks);

fs/jfs/jfs_dmap.c

3454

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

fs/jfs/jfs_dmap.c

3469

newsize = blkno + nblocks;

fs/jfs/jfs_dmap.c

3472

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

fs/jfs/jfs_dmap.c

3650

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

fs/jfs/jfs_dmap.c

3658

n = min_t(s64, nblocks, BPERDMAP);

fs/jfs/jfs_dmap.c

3674

nblocks -= n;

fs/jfs/jfs_dmap.c

3675

if (nblocks == 0)

fs/jfs/jfs_dmap.c

3687

if (nblocks)

fs/jfs/jfs_dmap.c

3711

if (nblocks)

fs/jfs/jfs_dmap.c

3838

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

fs/jfs/jfs_dmap.c

3846

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

fs/jfs/jfs_dmap.c

3849

if (nblocks == BPERDMAP) {

fs/jfs/jfs_dmap.c

3855

le32_add_cpu(&dp->nblocks, nblocks);

fs/jfs/jfs_dmap.c

3856

le32_add_cpu(&dp->nfree, nblocks);

fs/jfs/jfs_dmap.c

3867

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

fs/jfs/jfs_dmap.c

4095

static int dbGetL2AGSize(s64 nblocks)

fs/jfs/jfs_dmap.c

4101

if (nblocks < BPERDMAP * MAXAG)

fs/jfs/jfs_dmap.c

4107

if (m & nblocks)

fs/jfs/jfs_dmap.c

4112

if (sz < nblocks)

fs/jfs/jfs_dmap.c

4145

s64 nblocks;

fs/jfs/jfs_dmap.c

4150

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

fs/jfs/jfs_dmap.c

4151

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

fs/jfs/jfs_dmap.c

4179

nblocks = ndmaps << L2BPERDMAP;

fs/jfs/jfs_dmap.c

4181

return (nblocks);

fs/jfs/jfs_dmap.c

431

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

fs/jfs/jfs_dmap.c

444

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

fs/jfs/jfs_dmap.c

448

(unsigned long long) nblocks);

fs/jfs/jfs_dmap.c

457

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

fs/jfs/jfs_dmap.c

458

jfs_issue_discard(ipbmap, blkno, nblocks);

fs/jfs/jfs_dmap.c

464

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

fs/jfs/jfs_dmap.c

526

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

fs/jfs/jfs_dmap.c

540

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

fs/jfs/jfs_dmap.c

543

(unsigned long long) nblocks);

fs/jfs/jfs_dmap.c

558

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

fs/jfs/jfs_dmap.c

65

int nblocks);

fs/jfs/jfs_dmap.c

72

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

fs/jfs/jfs_dmap.c

74

int nblocks);

fs/jfs/jfs_dmap.c

76

int nblocks,

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

801

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

fs/jfs/jfs_dmap.c

814

assert(nblocks > 0);

fs/jfs/jfs_dmap.c

820

l2nb = BLKSTOL2(nblocks);

fs/jfs/jfs_dmap.c

83

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

fs/jfs/jfs_dmap.c

838

rc = dbAllocAny(bmp, 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

87

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

fs/jfs/jfs_dmap.c

876

if (nblocks <= BPERDMAP) {

fs/jfs/jfs_dmap.c

892

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

fs/jfs/jfs_dmap.c

919

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

fs/jfs/jfs_dmap.c

92

int nblocks);

fs/jfs/jfs_dmap.c

931

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

fs/jfs/jfs_dmap.c

94

int nblocks);

fs/jfs/jfs_dmap.c

948

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

fs/jfs/jfs_dmap.c

964

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

fs/jfs/jfs_dmap.c

965

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

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

168

unsigned nblocks;

fs/mpage.c

190

nblocks = map_bh->b_size >> blkbits;

fs/mpage.c

193

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

fs/mpage.c

195

unsigned last = nblocks - map_offset;

fs/mpage.c

254

nblocks = map_bh->b_size >> blkbits;

fs/mpage.c

256

if (relative_block == nblocks) {

fs/mpage.c

300

nblocks = map_bh->b_size >> blkbits;

fs/mpage.c

301

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

721

int nblocks, i;

fs/ocfs2/dir.c

725

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

fs/ocfs2/dir.c

727

if (start >= nblocks)

fs/ocfs2/dir.c

746

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

fs/ocfs2/dir.c

783

if (++block >= nblocks)

fs/ocfs2/dir.c

791

block = nblocks;

fs/ocfs2/dir.c

792

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

fs/ocfs2/dir.c

793

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

483

if (old_nblks >= nblocks)

fs/ocfs2/journal.c

485

return ocfs2_extend_trans(handle, nblocks - old_nblks);

fs/ocfs2/journal.h

249

int ocfs2_extend_trans(handle_t *handle, int nblocks);

fs/ocfs2/journal.h

251

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

136

uint64_t nblocks)

fs/xfs/xfs_mount.c

142

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

1524

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

include/linux/jbd2.h

1528

extern int jbd2_journal_restart(handle_t *, int nblocks);

include/linux/jbd2.h

1529

extern int jbd2__journal_restart(handle_t *, int nblocks,

include/linux/jbd2.h

1534

extern int jbd2_journal_extend(handle_t *handle, int nblocks,

include/linux/kho_block.h

38

long 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;

kernel/liveupdate/kho_block.c

131

bs->nblocks--;

kernel/liveupdate/kho_block.c

156

long orig_nblocks = bs->nblocks;

kernel/liveupdate/kho_block.c

162

while (count > bs->nblocks * bs->count_per_block) {

kernel/liveupdate/kho_block.c

171

while (bs->nblocks > orig_nblocks)

kernel/liveupdate/kho_block.c

194

while (bs->nblocks > 0 && count <= (bs->nblocks - 1) * bs->count_per_block)

kernel/liveupdate/kho_block.c

308

bs->nblocks = 0;

kernel/liveupdate/kho_block.c

84

if (bs->nblocks >= KHO_MAX_BLOCKS)

kernel/liveupdate/kho_block.c

94

bs->nblocks++;

lib/crypto/aes.c

523

size_t nblocks, bool enc_before,

lib/crypto/aes.c

533

size_t nblocks, bool enc_before, bool enc_after)

lib/crypto/aes.c

535

if (aes_cbcmac_blocks_arch(h, key, data, nblocks, enc_before,

lib/crypto/aes.c

541

for (; nblocks > 1; nblocks--) {

lib/crypto/aes.c

605

size_t nblocks;

lib/crypto/aes.c

627

nblocks = data_len / AES_BLOCK_SIZE;

lib/crypto/aes.c

629

if (nblocks == 0) {

lib/crypto/aes.c

637

aes_cbcmac_blocks(ctx->h, &ctx->key->aes, data, nblocks,

lib/crypto/aes.c

639

data += nblocks * AES_BLOCK_SIZE;

lib/crypto/aes.c

648

aes_cbcmac_blocks(ctx->h, &ctx->key->aes, data, nblocks,

lib/crypto/aes.c

674

size_t nblocks;

lib/crypto/aes.c

688

nblocks = data_len / AES_BLOCK_SIZE;

lib/crypto/aes.c

690

if (nblocks == 0) {

lib/crypto/aes.c

694

aes_cbcmac_blocks(ctx->h, ctx->key, data, nblocks, enc_before,

lib/crypto/aes.c

696

data += nblocks * AES_BLOCK_SIZE;

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/gf128hash.h

20

const u8 *data, size_t nblocks)

lib/crypto/arm/gf128hash.h

26

min_t(size_t, nblocks, 4096 / GHASH_BLOCK_SIZE);

lib/crypto/arm/gf128hash.h

31

nblocks -= n;

lib/crypto/arm/gf128hash.h

32

} while (nblocks);

lib/crypto/arm/gf128hash.h

34

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

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/aes.h

191

size_t nblocks, bool enc_before,

lib/crypto/arm64/aes.h

198

key->nrounds, nblocks, h,

lib/crypto/arm64/aes.h

202

key->nrounds, nblocks, h,

lib/crypto/arm64/gf128hash.h

102

const u8 *data, size_t nblocks)

lib/crypto/arm64/gf128hash.h

106

polyval_blocks_pmull(acc, key, data, nblocks);

lib/crypto/arm64/gf128hash.h

109

data, nblocks);

lib/crypto/arm64/gf128hash.h

22

const u8 *data, size_t nblocks);

lib/crypto/arm64/gf128hash.h

89

const u8 *data, size_t nblocks)

lib/crypto/arm64/gf128hash.h

93

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

lib/crypto/arm64/gf128hash.h

95

ghash_blocks_generic(acc, &key->h, 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

20

sha1_ce_transform(state, data, nblocks);

lib/crypto/arm64/sha1.h

22

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

26

sha256_ce_transform(state, data, nblocks);

lib/crypto/arm64/sha256.h

28

sha256_block_neon(state, data, nblocks);

lib/crypto/arm64/sha256.h

31

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

23

sha3_ce_transform(state, data, nblocks, block_size);

lib/crypto/arm64/sha3.h

25

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

24

sha512_ce_transform(state, data, nblocks);

lib/crypto/arm64/sha512.h

26

sha512_block_data_order(state, data, nblocks);

lib/crypto/arm64/sm3.h

14

const u8 *data, size_t nblocks);

lib/crypto/arm64/sm3.h

16

const u8 *data, size_t nblocks);

lib/crypto/arm64/sm3.h

19

const u8 *data, size_t nblocks)

lib/crypto/arm64/sm3.h

24

sm3_ce_transform(state, data, nblocks);

lib/crypto/arm64/sm3.h

26

sm3_neon_transform(state, data, nblocks);

lib/crypto/arm64/sm3.h

29

sm3_blocks_generic(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/gf128hash.c

217

const u8 *data, size_t nblocks)

lib/crypto/gf128hash.c

225

} while (--nblocks);

lib/crypto/gf128hash.c

230

const u8 *data, size_t nblocks)

lib/crypto/gf128hash.c

237

} while (--nblocks);

lib/crypto/gf128hash.c

298

static void ghash_blocks(struct ghash_ctx *ctx, const u8 *data, size_t nblocks)

lib/crypto/gf128hash.c

301

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

lib/crypto/gf128hash.c

303

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

lib/crypto/gf128hash.c

321

size_t nblocks = len / GHASH_BLOCK_SIZE;

lib/crypto/gf128hash.c

323

ghash_blocks(ctx, data, nblocks);

lib/crypto/gf128hash.c

376

const u8 *data, size_t nblocks)

lib/crypto/gf128hash.c

379

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

lib/crypto/gf128hash.c

381

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

lib/crypto/gf128hash.c

398

size_t nblocks = len / POLYVAL_BLOCK_SIZE;

lib/crypto/gf128hash.c

400

polyval_blocks(ctx, data, nblocks);

lib/crypto/md5.c

123

const u8 *data, size_t nblocks)

lib/crypto/md5.c

128

} while (--nblocks);

lib/crypto/md5.c

145

size_t nblocks;

lib/crypto/md5.c

157

nblocks = len / MD5_BLOCK_SIZE;

lib/crypto/md5.c

160

if (nblocks) {

lib/crypto/md5.c

161

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

lib/crypto/md5.c

162

data += nblocks * MD5_BLOCK_SIZE;

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/powerpc/gf128hash.h

80

const u8 *data, size_t nblocks)

lib/crypto/powerpc/gf128hash.h

91

nblocks * GHASH_BLOCK_SIZE);

lib/crypto/powerpc/gf128hash.h

99

ghash_blocks_generic(acc, &key->h, data, 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/gf128hash.h

17

const u8 *data, size_t nblocks);

lib/crypto/riscv/gf128hash.h

33

const u8 *data, size_t nblocks)

lib/crypto/riscv/gf128hash.h

41

ghash_zvkg(ghash_acc, key->h_raw, data, nblocks);

lib/crypto/riscv/gf128hash.h

47

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

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/riscv/sm3.h

18

const u8 *data, size_t nblocks);

lib/crypto/riscv/sm3.h

21

const u8 *data, size_t nblocks)

lib/crypto/riscv/sm3.h

25

sm3_transform_zvksh_zvkb(state, data, nblocks);

lib/crypto/riscv/sm3.h

28

sm3_blocks_generic(state, data, nblocks);

lib/crypto/s390/gf128hash.h

26

const u8 *data, size_t nblocks)

lib/crypto/s390/gf128hash.h

39

nblocks * GHASH_BLOCK_SIZE);

lib/crypto/s390/gf128hash.h

44

ghash_blocks_generic(acc, &key->h, 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/sm3.c

181

const u8 *data, size_t nblocks)

lib/crypto/sm3.c

188

} while (--nblocks);

lib/crypto/sm3.c

213

size_t nblocks;

lib/crypto/sm3.c

225

nblocks = len / SM3_BLOCK_SIZE;

lib/crypto/sm3.c

228

if (nblocks) {

lib/crypto/sm3.c

229

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

lib/crypto/sm3.c

230

data += nblocks * SM3_BLOCK_SIZE;

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/gf128hash.h

105

const u8 *data, size_t nblocks)

lib/crypto/x86/gf128hash.h

110

size_t n = min_t(size_t, nblocks,

lib/crypto/x86/gf128hash.h

117

nblocks -= n;

lib/crypto/x86/gf128hash.h

118

} while (nblocks);

lib/crypto/x86/gf128hash.h

121

data, nblocks);

lib/crypto/x86/gf128hash.h

22

const u8 *data, size_t nblocks);

lib/crypto/x86/gf128hash.h

25

const u8 *data, size_t nblocks);

lib/crypto/x86/gf128hash.h

83

const u8 *data, size_t nblocks)

lib/crypto/x86/gf128hash.h

88

size_t n = min_t(size_t, nblocks,

lib/crypto/x86/gf128hash.h

95

nblocks -= n;

lib/crypto/x86/gf128hash.h

96

} while (nblocks);

lib/crypto/x86/gf128hash.h

98

ghash_blocks_generic(acc, &key->h, 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

36

const u8 *data, size_t nblocks)

lib/crypto/x86/sha256.h

49

: "+a"(padding), "+c"(nblocks), "+S"(data)

lib/crypto/x86/sha256.h

56

const u8 *data, size_t nblocks)

lib/crypto/x86/sha256.h

58

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/crypto/x86/sm3.h

11

const u8 *data, size_t nblocks);

lib/crypto/x86/sm3.h

14

const u8 *data, size_t nblocks)

lib/crypto/x86/sm3.h

18

sm3_transform_avx(state, data, nblocks);

lib/crypto/x86/sm3.h

21

sm3_blocks_generic(state, data, nblocks);

lib/crypto/x86/sm3.h

28

const u8 *data, size_t nblocks)

lib/crypto/x86/sm3.h

30

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

lib/vdso/getrandom.c

241

nblocks = len / CHACHA_BLOCK_SIZE;

lib/vdso/getrandom.c

242

if (nblocks) {

lib/vdso/getrandom.c

243

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

lib/vdso/getrandom.c

244

buffer += nblocks * CHACHA_BLOCK_SIZE;

lib/vdso/getrandom.c

245

len -= nblocks * CHACHA_BLOCK_SIZE;

lib/vdso/getrandom.c

79

size_t batch_len, nblocks, orig_len = len;

net/ipv4/inet_hashtables.c

1312

unsigned int i, nblocks = 1;

net/ipv4/inet_hashtables.c

1319

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

net/ipv4/inet_hashtables.c

1322

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

net/ipv4/inet_hashtables.c

1324

nblocks = roundup_pow_of_two(nblocks);

net/ipv4/inet_hashtables.c

1327

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

net/ipv4/inet_hashtables.c

1333

ptr = vmalloc_array(nblocks, locksz);

net/ipv4/inet_hashtables.c

1336

ptr = kvmalloc_array(nblocks, locksz, GFP_KERNEL);

net/ipv4/inet_hashtables.c

1340

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

net/ipv4/inet_hashtables.c

1344

hashinfo->ehash_locks_mask = nblocks - 1;

net/rxrpc/ar-internal.h

35

size_t nblocks);

net/rxrpc/ar-internal.h

38

size_t nblocks);

net/rxrpc/fcrypt.c

310

size_t nblocks)

net/rxrpc/fcrypt.c

316

while (nblocks--) {

net/rxrpc/fcrypt.c

337

size_t nblocks)

net/rxrpc/fcrypt.c

343

while (nblocks--) {

net/rxrpc/tests/rxrpc_kunit.c

16

size_t nblocks; /* length of ptext and ctext in blocks */

net/rxrpc/tests/rxrpc_kunit.c

27

.nblocks = 1,

net/rxrpc/tests/rxrpc_kunit.c

34

.nblocks = 1,

net/rxrpc/tests/rxrpc_kunit.c

47

.nblocks = 6,

net/rxrpc/tests/rxrpc_kunit.c

59

.nblocks = 6,

net/rxrpc/tests/rxrpc_kunit.c

69

const size_t nblocks = tv->nblocks;

net/rxrpc/tests/rxrpc_kunit.c

70

const size_t len = nblocks * FCRYPT_BSIZE;

net/rxrpc/tests/rxrpc_kunit.c

78

fcrypt_pcbc_encrypt(&key, tv->iv, tv->ptext, data, nblocks);

net/rxrpc/tests/rxrpc_kunit.c

83

fcrypt_pcbc_encrypt(&key, tv->iv, data, data, nblocks);

net/rxrpc/tests/rxrpc_kunit.c

87

fcrypt_pcbc_decrypt(&key, tv->iv, tv->ctext, data, nblocks);

net/rxrpc/tests/rxrpc_kunit.c

92

fcrypt_pcbc_decrypt(&key, tv->iv, data, data, nblocks);

sound/soc/codecs/pcm6240.c

1237

unsigned int nblocks;

sound/soc/codecs/pcm6240.c

1256

nblocks = get_unaligned_be32(&config_data[config_offset]);

sound/soc/codecs/pcm6240.c

1259

cfg_info = kzalloc_flex(*cfg_info, blk_data, nblocks);

sound/soc/codecs/pcm6240.c

1264

cfg_info->nblocks = nblocks;

sound/soc/codecs/pcm6240.c

1268

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

sound/soc/codecs/pcm6240.c

1273

__func__, i, cfg_info->nblocks);

sound/soc/codecs/pcm6240.c

1312

__func__, i, cfg_info->nblocks);

sound/soc/codecs/pcm6240.h

199

unsigned int nblocks;

sound/soc/codecs/pcm6240.h

202

struct pcmdevice_block_data *blk_data[] __counted_by(nblocks);

sound/soc/codecs/tas2781-fmwlib.c

224

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

sound/soc/codecs/tas2781-fmwlib.c

232

cfg_info->nblocks);

sound/soc/codecs/tas2781-fmwlib.c

238

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

sound/soc/codecs/tas2781-fmwlib.c

243

__func__, i, cfg_info->nblocks);

sound/soc/codecs/tas2781-fmwlib.c

283

__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)