drivers/edac/edac_device.c

109

inst->nr_blocks = nr_blocks;

drivers/edac/edac_device.c

110

blk_p = &dev_blk[instance * nr_blocks];

drivers/edac/edac_device.c

117

for (block = 0; block < nr_blocks; block++) {

drivers/edac/edac_device.c

498

if ((block_nr >= instance->nr_blocks) || (block_nr < 0)) {

drivers/edac/edac_device.c

503

instance->nr_blocks);

drivers/edac/edac_device.c

507

if (instance->nr_blocks > 0) {

drivers/edac/edac_device.c

544

if ((block_nr >= instance->nr_blocks) || (block_nr < 0)) {

drivers/edac/edac_device.c

549

instance->nr_blocks);

drivers/edac/edac_device.c

553

if (instance->nr_blocks > 0) {

drivers/edac/edac_device.c

58

char *blk_name, unsigned nr_blocks, unsigned off_val,

drivers/edac/edac_device.c

68

edac_dbg(4, "instances=%d blocks=%d\n", nr_instances, nr_blocks);

drivers/edac/edac_device.c

81

nr_instances * nr_blocks);

drivers/edac/edac_device.h

129

u32 nr_blocks; /* how many blocks */

drivers/edac/edac_device.h

233

char *edac_block_name, unsigned nr_blocks,

drivers/edac/edac_device_sysfs.c

630

instance->nr_blocks, idx);

drivers/edac/edac_device_sysfs.c

633

for (i = 0; i < instance->nr_blocks; i++) {

drivers/edac/edac_device_sysfs.c

672

for (i = 0; i < instance->nr_blocks; i++)

drivers/hwtracing/intel_th/msu.c

1100

static int msc_buffer_win_alloc(struct msc *msc, unsigned int nr_blocks)

drivers/hwtracing/intel_th/msu.c

1105

if (!nr_blocks)

drivers/hwtracing/intel_th/msu.c

1122

win->pgoff = prev->pgoff + prev->nr_blocks;

drivers/hwtracing/intel_th/msu.c

1127

nr_blocks << PAGE_SHIFT);

drivers/hwtracing/intel_th/msu.c

1129

ret = __msc_buffer_win_alloc(win, nr_blocks);

drivers/hwtracing/intel_th/msu.c

1135

win->nr_blocks = nr_blocks;

drivers/hwtracing/intel_th/msu.c

1144

msc->nr_pages += nr_blocks;

drivers/hwtracing/intel_th/msu.c

1176

msc->nr_pages -= win->nr_blocks;

drivers/hwtracing/intel_th/msu.c

1416

if (pgoff >= win->pgoff && pgoff < win->pgoff + win->nr_blocks)

drivers/hwtracing/intel_th/msu.c

1972

"%d%c", win->nr_blocks,

drivers/hwtracing/intel_th/msu.c

343

return (size_t)win->nr_blocks << PAGE_SHIFT;

drivers/hwtracing/intel_th/msu.c

73

unsigned int nr_blocks;

drivers/md/dm-cache-target.c

2367

dm_block_t nr_blocks = from_cblock(size);

drivers/md/dm-cache-target.c

2369

if (nr_blocks > (1 << 20) && cache->cache_size != size)

drivers/md/dm-cache-target.c

2373

(unsigned long long) nr_blocks);

drivers/md/dm-cache-target.c

2995

uint32_t nr_blocks = from_cblock(cache->cache_size);

drivers/md/dm-cache-target.c

2999

for_each_set_bit(i, cache->invalid_bitset, nr_blocks) {

drivers/md/dm-era-target.c

1178

dm_block_t nr_blocks;

drivers/md/dm-era-target.c

1611

if (era->nr_blocks != new_size) {

drivers/md/dm-era-target.c

1624

era->nr_blocks = new_size;

drivers/md/dm-era-target.c

180

__le32 nr_blocks;

drivers/md/dm-era-target.c

278

uint32_t nr_blocks;

drivers/md/dm-era-target.c

518

disk->nr_blocks = cpu_to_le32(md->nr_blocks);

drivers/md/dm-era-target.c

603

md->nr_blocks = le32_to_cpu(disk->nr_blocks);

drivers/md/dm-era-target.c

75

static int writeset_alloc(struct writeset *ws, dm_block_t nr_blocks)

drivers/md/dm-era-target.c

77

ws->bits = vzalloc(bitset_size(nr_blocks));

drivers/md/dm-era-target.c

782

d->nr_bits = min(d->writeset.nr_bits, md->nr_blocks);

drivers/md/dm-era-target.c

880

md->nr_blocks, *new_size,

drivers/md/dm-era-target.c

889

md->nr_blocks = *new_size;

drivers/md/dm-era-target.c

90

dm_block_t nr_blocks)

drivers/md/dm-era-target.c

935

r = writeset_init(&md->bitset_info, new_writeset, md->nr_blocks);

drivers/md/dm-era-target.c

94

memset(ws->bits, 0, bitset_size(nr_blocks));

drivers/md/dm-era-target.c

96

ws->md.nr_bits = nr_blocks;

drivers/md/dm-zoned-metadata.c

2449

unsigned int nr_blocks;

drivers/md/dm-zoned-metadata.c

2459

nr_blocks = ret;

drivers/md/dm-zoned-metadata.c

2460

ret = dmz_validate_blocks(zmd, to_zone, chunk_block, nr_blocks);

drivers/md/dm-zoned-metadata.c

2464

chunk_block += nr_blocks;

drivers/md/dm-zoned-metadata.c

2474

sector_t chunk_block, unsigned int nr_blocks)

drivers/md/dm-zoned-metadata.c

2483

nr_blocks);

drivers/md/dm-zoned-metadata.c

2485

WARN_ON(chunk_block + nr_blocks > zone_nr_blocks);

drivers/md/dm-zoned-metadata.c

2487

while (nr_blocks) {

drivers/md/dm-zoned-metadata.c

2495

nr_bits = min(nr_blocks, zmd->zone_bits_per_mblk - bit);

drivers/md/dm-zoned-metadata.c

2504

nr_blocks -= nr_bits;

drivers/md/dm-zoned-metadata.c

2555

sector_t chunk_block, unsigned int nr_blocks)

drivers/md/dm-zoned-metadata.c

2562

zone->id, (u64)chunk_block, nr_blocks);

drivers/md/dm-zoned-metadata.c

2564

WARN_ON(chunk_block + nr_blocks > zmd->zone_nr_blocks);

drivers/md/dm-zoned-metadata.c

2566

while (nr_blocks) {

drivers/md/dm-zoned-metadata.c

2574

nr_bits = min(nr_blocks, zmd->zone_bits_per_mblk - bit);

drivers/md/dm-zoned-metadata.c

2584

nr_blocks -= nr_bits;

drivers/md/dm-zoned-metadata.c

2629

sector_t chunk_block, unsigned int nr_blocks,

drivers/md/dm-zoned-metadata.c

2638

WARN_ON(chunk_block + nr_blocks > zmd->zone_nr_blocks);

drivers/md/dm-zoned-metadata.c

2640

while (nr_blocks) {

drivers/md/dm-zoned-metadata.c

2649

nr_bits = min(nr_blocks, zone_bits - bit);

drivers/md/dm-zoned-metadata.c

2660

nr_blocks -= nr_bits;

drivers/md/dm-zoned-metadata.c

2745

unsigned int nr_blocks = zmd->zone_nr_blocks;

drivers/md/dm-zoned-metadata.c

2749

while (nr_blocks) {

drivers/md/dm-zoned-metadata.c

2760

nr_bits = min(nr_blocks, zmd->zone_bits_per_mblk - bit);

drivers/md/dm-zoned-metadata.c

2765

nr_blocks -= nr_bits;

drivers/md/dm-zoned-reclaim.c

123

sector_t nr_blocks;

drivers/md/dm-zoned-reclaim.c

152

nr_blocks = ret;

drivers/md/dm-zoned-reclaim.c

167

src.count = dmz_blk2sect(nr_blocks);

drivers/md/dm-zoned-reclaim.c

184

block += nr_blocks;

drivers/md/dm-zoned-reclaim.c

65

unsigned int nr_blocks;

drivers/md/dm-zoned-reclaim.c

78

nr_blocks = block - wp_block;

drivers/md/dm-zoned-reclaim.c

81

dmz_blk2sect(nr_blocks), GFP_NOIO);

drivers/md/dm-zoned-reclaim.c

86

(unsigned long long)block, nr_blocks, ret);

drivers/md/dm-zoned-target.c

118

unsigned int nr_blocks)

drivers/md/dm-zoned-target.c

135

clone->bi_iter.bi_size = dmz_blk2sect(nr_blocks) << SECTOR_SHIFT;

drivers/md/dm-zoned-target.c

145

zone->wp_block += nr_blocks;

drivers/md/dm-zoned-target.c

154

sector_t chunk_block, unsigned int nr_blocks)

drivers/md/dm-zoned-target.c

156

unsigned int size = nr_blocks << DMZ_BLOCK_SHIFT;

drivers/md/dm-zoned-target.c

174

unsigned int nr_blocks = dmz_bio_blocks(bio);

drivers/md/dm-zoned-target.c

175

sector_t end_block = chunk_block + nr_blocks;

drivers/md/dm-zoned-target.c

191

(unsigned long long)chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

196

nr_blocks = 0;

drivers/md/dm-zoned-target.c

205

nr_blocks = ret;

drivers/md/dm-zoned-target.c

214

if (!nr_blocks && bzone) {

drivers/md/dm-zoned-target.c

220

nr_blocks = ret;

drivers/md/dm-zoned-target.c

225

if (nr_blocks) {

drivers/md/dm-zoned-target.c

227

nr_blocks = min_t(unsigned int, nr_blocks,

drivers/md/dm-zoned-target.c

230

chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

233

chunk_block += nr_blocks;

drivers/md/dm-zoned-target.c

252

unsigned int nr_blocks)

drivers/md/dm-zoned-target.c

262

ret = dmz_submit_bio(dmz, zone, bio, chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

270

ret = dmz_validate_blocks(zmd, zone, chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

272

ret = dmz_invalidate_blocks(zmd, bzone, chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

285

unsigned int nr_blocks)

drivers/md/dm-zoned-target.c

300

ret = dmz_submit_bio(dmz, bzone, bio, chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

308

ret = dmz_validate_blocks(zmd, bzone, chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

310

ret = dmz_invalidate_blocks(zmd, zone, chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

323

unsigned int nr_blocks = dmz_bio_blocks(bio);

drivers/md/dm-zoned-target.c

334

(unsigned long long)chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

344

chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

351

return dmz_handle_buffered_write(dmz, zone, bio, chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

362

unsigned int nr_blocks = dmz_bio_blocks(bio);

drivers/md/dm-zoned-target.c

377

(unsigned long long)chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

385

ret = dmz_invalidate_blocks(zmd, zone, chunk_block, nr_blocks);

drivers/md/dm-zoned-target.c

388

chunk_block, nr_blocks);

drivers/md/dm-zoned.h

255

sector_t chunk_block, unsigned int nr_blocks);

drivers/md/dm-zoned.h

257

sector_t chunk_block, unsigned int nr_blocks);

drivers/md/md-llbitmap.c

1347

int nr_blocks = DIV_ROUND_UP(BITMAP_DATA_OFFSET, llbitmap->io_size);

drivers/md/md-llbitmap.c

1349

bitmap_fill(llbitmap->pctl[0]->dirty, nr_blocks);

drivers/md/persistent-data/dm-space-map-common.c

1043

ll->nr_blocks = 0;

drivers/md/persistent-data/dm-space-map-common.c

1085

ll->nr_blocks = le64_to_cpu(smr.nr_blocks);

drivers/md/persistent-data/dm-space-map-common.c

1221

ll->nr_blocks = 0;

drivers/md/persistent-data/dm-space-map-common.c

1257

ll->nr_blocks = le64_to_cpu(smr->nr_blocks);

drivers/md/persistent-data/dm-space-map-common.c

229

ll->nr_blocks = 0;

drivers/md/persistent-data/dm-space-map-common.c

240

dm_block_t i, nr_blocks, nr_indexes;

drivers/md/persistent-data/dm-space-map-common.c

243

nr_blocks = ll->nr_blocks + extra_blocks;

drivers/md/persistent-data/dm-space-map-common.c

244

old_blocks = dm_sector_div_up(ll->nr_blocks, ll->entries_per_block);

drivers/md/persistent-data/dm-space-map-common.c

245

blocks = dm_sector_div_up(nr_blocks, ll->entries_per_block);

drivers/md/persistent-data/dm-space-map-common.c

247

nr_indexes = dm_sector_div_up(nr_blocks, ll->entries_per_block);

drivers/md/persistent-data/dm-space-map-common.c

256

ll->nr_blocks = nr_blocks;

drivers/md/persistent-data/dm-space-map-common.c

287

if (b >= ll->nr_blocks) {

drivers/md/persistent-data/dm-space-map-common.c

400

r = sm_ll_find_free_block(new_ll, begin, new_ll->nr_blocks, b);

drivers/md/persistent-data/dm-space-map-common.c

405

if (*b >= old_ll->nr_blocks)

drivers/md/persistent-data/dm-space-map-common.h

102

__le64 nr_blocks;

drivers/md/persistent-data/dm-space-map-common.h

79

dm_block_t nr_blocks;

drivers/md/persistent-data/dm-space-map-disk.c

139

r = sm_ll_find_common_free_block(&smd->old_ll, &smd->ll, smd->begin, smd->ll.nr_blocks, b);

drivers/md/persistent-data/dm-space-map-disk.c

185

root_le.nr_blocks = cpu_to_le64(smd->ll.nr_blocks);

drivers/md/persistent-data/dm-space-map-disk.c

218

dm_block_t nr_blocks)

drivers/md/persistent-data/dm-space-map-disk.c

235

r = sm_ll_extend(&smd->ll, nr_blocks);

drivers/md/persistent-data/dm-space-map-disk.c

53

*count = smd->old_ll.nr_blocks;

drivers/md/persistent-data/dm-space-map-disk.c

62

*count = (smd->old_ll.nr_blocks - smd->old_ll.nr_allocated) - smd->nr_allocated_this_transaction;

drivers/md/persistent-data/dm-space-map-disk.h

21

dm_block_t nr_blocks);

drivers/md/persistent-data/dm-space-map-metadata.c

287

*count = smm->ll.nr_blocks;

drivers/md/persistent-data/dm-space-map-metadata.c

296

*count = smm->old_ll.nr_blocks - smm->old_ll.nr_allocated -

drivers/md/persistent-data/dm-space-map-metadata.c

458

r = sm_ll_find_common_free_block(&smm->old_ll, &smm->ll, smm->begin, smm->ll.nr_blocks, b);

drivers/md/persistent-data/dm-space-map-metadata.c

548

root_le.nr_blocks = cpu_to_le64(smm->ll.nr_blocks);

drivers/md/persistent-data/dm-space-map-metadata.c

601

*count = smm->ll.nr_blocks;

drivers/md/persistent-data/dm-space-map-metadata.c

610

*count = smm->ll.nr_blocks - smm->begin;

drivers/md/persistent-data/dm-space-map-metadata.c

648

if (smm->begin == smm->ll.nr_blocks)

drivers/md/persistent-data/dm-space-map-metadata.c

723

dm_block_t old_len = smm->ll.nr_blocks;

drivers/md/persistent-data/dm-space-map-metadata.c

786

dm_block_t nr_blocks,

drivers/md/persistent-data/dm-space-map-metadata.c

802

if (nr_blocks > DM_SM_METADATA_MAX_BLOCKS)

drivers/md/persistent-data/dm-space-map-metadata.c

803

nr_blocks = DM_SM_METADATA_MAX_BLOCKS;

drivers/md/persistent-data/dm-space-map-metadata.c

804

r = sm_ll_extend(&smm->ll, nr_blocks);

drivers/md/persistent-data/dm-space-map-metadata.h

35

dm_block_t nr_blocks,

drivers/net/ethernet/marvell/octeontx2/af/rvu.c

1337

int numlfs, total_lfs = 0, nr_blocks = 0;

drivers/net/ethernet/marvell/octeontx2/af/rvu.c

1359

num_blkaddr[nr_blocks] = blkaddr;

drivers/net/ethernet/marvell/octeontx2/af/rvu.c

1360

nr_blocks++;

drivers/net/ethernet/marvell/octeontx2/af/rvu.c

1373

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

drivers/scsi/scsi_trace.c

333

unsigned int nr_blocks;

drivers/scsi/scsi_trace.c

338

nr_blocks = get_unaligned_be16(&cdb[12]);

drivers/scsi/scsi_trace.c

341

lba, nr_blocks, boundary_size);

drivers/scsi/sd.c

1040

u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));

drivers/scsi/sd.c

1051

put_unaligned_be32(nr_blocks, &cmd->cmnd[10]);

drivers/scsi/sd.c

1067

u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));

drivers/scsi/sd.c

1078

put_unaligned_be16(nr_blocks, &cmd->cmnd[7]);

drivers/scsi/sd.c

1093

u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));

drivers/scsi/sd.c

1109

if (sdkp->ws16 || lba > 0xffffffff || nr_blocks > 0xffff)

drivers/scsi/sd.c

1235

sector_t lba, unsigned int nr_blocks,

drivers/scsi/sd.c

1247

put_unaligned_be32(nr_blocks, &cmd->cmnd[28]);

drivers/scsi/sd.c

1253

sector_t lba, unsigned int nr_blocks,

drivers/scsi/sd.c

1262

put_unaligned_be32(nr_blocks, &cmd->cmnd[10]);

drivers/scsi/sd.c

1268

sector_t lba, unsigned int nr_blocks,

drivers/scsi/sd.c

1277

put_unaligned_be16(nr_blocks, &cmd->cmnd[7]);

drivers/scsi/sd.c

1283

sector_t lba, unsigned int nr_blocks,

drivers/scsi/sd.c

1287

if (WARN_ON_ONCE(nr_blocks == 0))

drivers/scsi/sd.c

1305

cmd->cmnd[4] = nr_blocks;

drivers/scsi/sd.c

1337

sector_t lba, unsigned int nr_blocks,

drivers/scsi/sd.c

1344

put_unaligned_be16(nr_blocks, &cmd->cmnd[12]);

drivers/scsi/sd.c

1346

put_unaligned_be16(nr_blocks, &cmd->cmnd[10]);

drivers/scsi/sd.c

1349

put_unaligned_be16(nr_blocks, &cmd->cmnd[12]);

drivers/scsi/sd.c

1363

unsigned int nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));

drivers/scsi/sd.c

1398

if (unlikely(sdp->last_sector_bug && lba + nr_blocks > threshold)) {

drivers/scsi/sd.c

1401

nr_blocks = threshold - lba;

drivers/scsi/sd.c

1404

nr_blocks = 1;

drivers/scsi/sd.c

1419

ret = sd_setup_rw32_cmnd(cmd, write, lba, nr_blocks,

drivers/scsi/sd.c

1422

ret = sd_setup_atomic_cmnd(cmd, lba, nr_blocks,

drivers/scsi/sd.c

1425

} else if (sdp->use_16_for_rw || (nr_blocks > 0xffff)) {

drivers/scsi/sd.c

1426

ret = sd_setup_rw16_cmnd(cmd, write, lba, nr_blocks,

drivers/scsi/sd.c

1428

} else if ((nr_blocks > 0xff) || (lba > 0x1fffff) ||

drivers/scsi/sd.c

1430

ret = sd_setup_rw10_cmnd(cmd, write, lba, nr_blocks,

drivers/scsi/sd.c

1433

ret = sd_setup_rw6_cmnd(cmd, write, lba, nr_blocks,

drivers/scsi/sd.c

1446

cmd->underflow = nr_blocks << 9;

drivers/scsi/sd.c

1448

cmd->sdb.length = nr_blocks * sdp->sector_size;

drivers/scsi/sd.c

1458

write ? "writing" : "reading", nr_blocks,

drivers/scsi/sd.c

950

u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));

drivers/scsi/sd.c

965

put_unaligned_be32(nr_blocks, &buf[16]);

fs/afs/dir_edit.c

248

unsigned int nr_blocks, b, entry;

fs/afs/dir_edit.c

270

nr_blocks = i_size / AFS_DIR_BLOCK_SIZE;

fs/afs/dir_edit.c

275

for (b = 0; b < nr_blocks + 1; b++) {

fs/afs/dir_edit.c

279

if (nr_blocks >= AFS_DIR_MAX_BLOCKS)

fs/afs/dir_edit.c

302

if (b == nr_blocks) {

fs/afs/dir_edit.c

333

nr_blocks = 1;

fs/afs/dir_edit.c

534

unsigned int nr_blocks, b;

fs/afs/dir_edit.c

546

nr_blocks = i_size / AFS_DIR_BLOCK_SIZE;

fs/afs/dir_edit.c

551

for (b = 0; b < nr_blocks; b++) {

fs/btrfs/scrub.c

243

unsigned int nr_blocks) \

fs/btrfs/scrub.c

248

bitmap_set(stripe->bitmaps, start_bit, nr_blocks); \

fs/btrfs/scrub.c

252

unsigned int nr_blocks) \

fs/btrfs/scrub.c

257

bitmap_clear(stripe->bitmaps, start_bit, nr_blocks); \

fs/btrfs/scrub.c

285

const unsigned int nr_blocks = stripe->nr_sectors; \

fs/btrfs/scrub.c

287

ASSERT(nr_blocks > 0 && nr_blocks <= BITS_PER_LONG, \

fs/btrfs/scrub.c

289

nr_blocks, BITS_PER_LONG); \

fs/btrfs/scrub.c

291

return bitmap_read(stripe->bitmaps, nr_blocks * scrub_bitmap_nr_##name, \

fs/crypto/inline_crypt.c

495

u64 fscrypt_limit_io_blocks(const struct inode *inode, u64 lblk, u64 nr_blocks)

fs/crypto/inline_crypt.c

501

return nr_blocks;

fs/crypto/inline_crypt.c

503

if (nr_blocks <= 1)

fs/crypto/inline_crypt.c

504

return nr_blocks;

fs/crypto/inline_crypt.c

509

return nr_blocks;

fs/crypto/inline_crypt.c

515

return min_t(u64, nr_blocks, (u64)U32_MAX + 1 - dun);

fs/gfs2/dir.c

2166

da->nr_blocks = 0;

fs/gfs2/dir.c

2172

da->nr_blocks = sdp->sd_max_dirres;

fs/gfs2/dir.c

2175

da->nr_blocks = 1;

fs/gfs2/dir.h

20

unsigned nr_blocks;

fs/gfs2/inode.c

1105

if (da.nr_blocks) {

fs/gfs2/inode.c

1106

struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };

fs/gfs2/inode.c

1144

if (da.nr_blocks)

fs/gfs2/inode.c

1147

if (da.nr_blocks)

fs/gfs2/inode.c

1497

struct gfs2_diradd da = { .nr_blocks = 0, .save_loc = 0, };

fs/gfs2/inode.c

1661

if (da.nr_blocks) {

fs/gfs2/inode.c

1662

struct gfs2_alloc_parms ap = { .target = da.nr_blocks, };

fs/gfs2/inode.c

1702

if (da.nr_blocks)

fs/gfs2/inode.c

1705

if (da.nr_blocks)

fs/gfs2/inode.c

625

return da->nr_blocks + gfs2_rg_blocks(dip, da->nr_blocks) +

fs/gfs2/inode.c

633

struct gfs2_alloc_parms ap = { .target = da->nr_blocks, };

fs/gfs2/inode.c

636

if (da->nr_blocks) {

fs/iomap/buffered-io.c

224

unsigned int nr_blocks = i_blocks_per_folio(inode, folio);

fs/iomap/buffered-io.c

227

if (ifs || nr_blocks <= 1)

fs/iomap/buffered-io.c

241

ifs = kzalloc_flex(*ifs, state, BITS_TO_LONGS(2 * nr_blocks), gfp);

fs/iomap/buffered-io.c

247

bitmap_set(ifs->state, 0, nr_blocks);

fs/iomap/buffered-io.c

249

bitmap_set(ifs->state, nr_blocks, nr_blocks);

fs/iomap/buffered-io.c

798

unsigned int nr_blocks = i_blocks_per_folio(iter->inode, folio);

fs/iomap/buffered-io.c

814

if ((iter->flags & IOMAP_NOWAIT) && !ifs && nr_blocks > 1)

fs/jffs2/build.c

326

size += c->nr_blocks * 100; /* And 100 bytes per eraseblock */

fs/jffs2/build.c

356

c->flash_size / 1024, c->sector_size / 1024, c->nr_blocks);

fs/jffs2/build.c

380

c->nr_blocks = c->flash_size / c->sector_size;

fs/jffs2/build.c

381

size = sizeof(struct jffs2_eraseblock) * c->nr_blocks;

fs/jffs2/build.c

391

for (i=0; i<c->nr_blocks; i++) {

fs/jffs2/debug.c

285

if (nr_counted != c->nr_blocks) {

fs/jffs2/debug.c

287

__func__, nr_counted, c->nr_blocks);

fs/jffs2/jffs2_fs_sb.h

91

uint32_t nr_blocks;

fs/jffs2/nodelist.c

509

for (i=0; i<c->nr_blocks; i++) {

fs/jffs2/nodemgmt.c

605

if (blocknr >= c->nr_blocks) {

fs/jffs2/scan.c

143

for (i=0; i<c->nr_blocks; i++) {

fs/jffs2/scan.c

267

((c->nr_free_blocks+empty_blocks+bad_blocks) != c->nr_blocks || bad_blocks == c->nr_blocks)) {

fs/jffs2/scan.c

270

empty_blocks, bad_blocks, c->nr_blocks);

fs/ocfs2/file.c

1554

u64 start_block, end_block, nr_blocks;

fs/ocfs2/file.c

1565

nr_blocks = end_block - start_block;

fs/ocfs2/file.c

1566

if (!nr_blocks)

fs/ocfs2/file.c

1579

return sb_issue_zeroout(sb, p_block, nr_blocks, GFP_NOFS);

fs/xfs/libxfs/xfs_btree_staging.c

578

uint64_t nr_blocks = 0;

fs/xfs/libxfs/xfs_btree_staging.c

615

nr_blocks++;

fs/xfs/libxfs/xfs_btree_staging.c

648

nr_blocks++;

fs/xfs/libxfs/xfs_btree_staging.c

657

nr_blocks += level_blocks;

fs/xfs/libxfs/xfs_btree_staging.c

666

bbl->nr_blocks = nr_blocks - 1;

fs/xfs/libxfs/xfs_btree_staging.c

668

bbl->nr_blocks = nr_blocks;

fs/xfs/libxfs/xfs_btree_staging.h

106

uint64_t nr_blocks;

fs/xfs/scrub/alloc_repair.c

124

xfs_agblock_t nr_blocks;

fs/xfs/scrub/alloc_repair.c

218

ra->nr_blocks += arec.ar_blockcount;

fs/xfs/scrub/alloc_repair.c

462

required = ra->new_bnobt.bload.nr_blocks +

fs/xfs/scrub/alloc_repair.c

463

ra->new_cntbt.bload.nr_blocks;

fs/xfs/scrub/alloc_repair.c

494

ra->nr_blocks -= len;

fs/xfs/scrub/alloc_repair.c

661

freesp_btreeblks += ra->new_bnobt.bload.nr_blocks - 1;

fs/xfs/scrub/alloc_repair.c

662

freesp_btreeblks += ra->new_cntbt.bload.nr_blocks - 1;

fs/xfs/scrub/alloc_repair.c

673

agf->agf_freeblks = cpu_to_be32(ra->nr_blocks);

fs/xfs/scrub/bmap_repair.c

712

rb->new_bmapbt.bload.nr_blocks, 0, true);

fs/xfs/scrub/bmap_repair.c

718

rb->new_bmapbt.bload.nr_blocks);

fs/xfs/scrub/ialloc_repair.c

694

ri->new_inobt.bload.nr_blocks);

fs/xfs/scrub/ialloc_repair.c

700

ri->new_finobt.bload.nr_blocks);

fs/xfs/scrub/newbt.c

268

uint64_t nr_blocks)

fs/xfs/scrub/newbt.c

277

while (nr_blocks > 0) {

fs/xfs/scrub/newbt.c

283

.maxlen = nr_blocks,

fs/xfs/scrub/newbt.c

315

nr_blocks -= args.len;

fs/xfs/scrub/newbt.c

343

uint64_t nr_blocks)

fs/xfs/scrub/newbt.c

351

while (nr_blocks > 0) {

fs/xfs/scrub/newbt.c

357

.maxlen = nr_blocks,

fs/xfs/scrub/newbt.c

393

nr_blocks -= args.len;

fs/xfs/scrub/newbt.c

408

uint64_t nr_blocks)

fs/xfs/scrub/newbt.c

411

return xrep_newbt_alloc_file_blocks(xnr, nr_blocks);

fs/xfs/scrub/newbt.c

412

return xrep_newbt_alloc_ag_blocks(xnr, nr_blocks);

fs/xfs/scrub/newbt.h

67

int xrep_newbt_alloc_blocks(struct xrep_newbt *xnr, uint64_t nr_blocks);

fs/xfs/scrub/refcount_repair.c

620

rr->new_btree.bload.nr_blocks);

fs/xfs/scrub/repair.c

267

xfs_extlen_t nr_blocks,

fs/xfs/scrub/repair.c

272

pag->pagf_freeblks > xfs_ag_resv_needed(pag, type) + nr_blocks;

fs/xfs/scrub/repair.h

29

bool xrep_ag_has_space(struct xfs_perag *pag, xfs_extlen_t nr_blocks,

fs/xfs/scrub/rmap_repair.c

1049

uint64_t nr_blocks; /* RMB */

fs/xfs/scrub/rmap_repair.c

1060

nr_blocks = rr->new_btree.bload.nr_blocks;

fs/xfs/scrub/rmap_repair.c

1069

nr_blocks - *blocks_reserved);

fs/xfs/scrub/rmap_repair.c

1073

*blocks_reserved = rr->new_btree.bload.nr_blocks;

fs/xfs/scrub/rmap_repair.c

1125

*done = nr_blocks >= rr->new_btree.bload.nr_blocks;

fs/xfs/scrub/rtrefcount_repair.c

656

rr->new_btree.bload.nr_blocks, 0, true);

fs/xfs/scrub/rtrefcount_repair.c

662

rr->new_btree.bload.nr_blocks);

fs/xfs/scrub/rtrmap_repair.c

749

rr->new_btree.bload.nr_blocks, 0, true);

fs/xfs/scrub/rtrmap_repair.c

755

rr->new_btree.bload.nr_blocks);

fs/xfs/xfs_buf.c

1721

xfs_rfsblock_t nr_blocks)

fs/xfs/xfs_buf.c

1743

btp->bt_nr_sectors = nr_blocks << (mp->m_sb.sb_blocklog - BBSHIFT);

fs/xfs/xfs_buf.h

378

xfs_fsblock_t nr_blocks);

fs/xfs/xfs_trace.h

4831

uint64_t block_idx, uint64_t nr_blocks,

fs/xfs/xfs_trace.h

4833

TP_ARGS(cur, level, block_idx, nr_blocks, ptr, nr_records),

fs/xfs/xfs_trace.h

4839

__field(unsigned long long, nr_blocks)

fs/xfs/xfs_trace.h

4849

__entry->nr_blocks = nr_blocks;

fs/xfs/xfs_trace.h

4866

__entry->nr_blocks,

fs/zonefs/super.c

159

loff_t nr_blocks;

fs/zonefs/super.c

171

nr_blocks = (old_isize - new_isize) >> sb->s_blocksize_bits;

fs/zonefs/super.c

172

if (sbi->s_used_blocks > nr_blocks)

fs/zonefs/super.c

173

sbi->s_used_blocks -= nr_blocks;

include/linux/blkdev.h

1278

sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)

include/linux/blkdev.h

1283

nr_blocks << (sb->s_blocksize_bits -

include/linux/blkdev.h

1288

sector_t nr_blocks, gfp_t gfp_mask)

include/linux/blkdev.h

1293

nr_blocks << (sb->s_blocksize_bits -

include/linux/fscrypt.h

884

u64 fscrypt_limit_io_blocks(const struct inode *inode, u64 lblk, u64 nr_blocks);

include/linux/fscrypt.h

921

u64 nr_blocks)

include/linux/fscrypt.h

923

return nr_blocks;

include/linux/mtd/blktrans.h

53

unsigned long block, unsigned nr_blocks);

include/linux/platform_data/sh_mmcif.h

147

unsigned long nr_blocks,

include/linux/platform_data/sh_mmcif.h

167

for (k = 0; !ret && k < nr_blocks; k++)

init/do_mounts_rd.c

213

rd_blocks = nr_blocks(out_file);

kernel/power/snapshot.c

545

unsigned int i, nr_blocks;

kernel/power/snapshot.c

557

nr_blocks = DIV_ROUND_UP(pages, BM_BITS_PER_BLOCK);

kernel/power/snapshot.c

559

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

mm/dmapool.c

327

pool->nr_blocks++;

mm/dmapool.c

52

size_t nr_blocks;

mm/dmapool.c

85

pool->nr_blocks, pool->size,

mm/dmapool_test.c

65

int blocks = nr_blocks(parms->size);

mm/swapfile.c

286

sector_t nr_blocks;

mm/swapfile.c

292

nr_blocks = ((sector_t)se->nr_pages - 1) << (PAGE_SHIFT - 9);

mm/swapfile.c

293

if (nr_blocks) {

mm/swapfile.c

295

nr_blocks, GFP_KERNEL);

mm/swapfile.c

303

nr_blocks = (sector_t)se->nr_pages << (PAGE_SHIFT - 9);

mm/swapfile.c

306

nr_blocks, GFP_KERNEL);

mm/swapfile.c

360

sector_t nr_blocks = se->nr_pages - offset;

mm/swapfile.c

362

if (nr_blocks > nr_pages)

mm/swapfile.c

363

nr_blocks = nr_pages;

mm/swapfile.c

364

start_page += nr_blocks;

mm/swapfile.c

365

nr_pages -= nr_blocks;

mm/swapfile.c

368

nr_blocks <<= PAGE_SHIFT - 9;

mm/swapfile.c

370

nr_blocks, GFP_NOIO))