arch/um/drivers/ubd_kern.c

1134

__u64 sector = io_offset >> SECTOR_SHIFT;

arch/um/drivers/ubd_kern.c

1137

for (i = 0; i < length >> SECTOR_SHIFT; i++) {

arch/um/drivers/ubd_kern.c

1172

__u64 sector = offset >> SECTOR_SHIFT;

arch/um/drivers/ubd_kern.c

1175

if (segment->length > (sizeof(segment->sector_mask) * 8) << SECTOR_SHIFT)

arch/um/drivers/ubd_kern.c

1179

for (i = 0; i < segment->length >> SECTOR_SHIFT; i++) {

arch/um/drivers/ubd_kern.c

1244

io_req->offset = (u64) blk_rq_pos(req) << SECTOR_SHIFT;

arch/xtensa/platforms/iss/simdisk.c

113

unsigned len = bvec.bv_len >> SECTOR_SHIFT;

arch/xtensa/platforms/iss/simdisk.c

173

set_capacity(dev->gd, dev->size >> SECTOR_SHIFT);

arch/xtensa/platforms/iss/simdisk.c

74

unsigned long offset = sector << SECTOR_SHIFT;

arch/xtensa/platforms/iss/simdisk.c

75

unsigned long nbytes = nsect << SECTOR_SHIFT;

block/bdev.c

493

i_size_write(BD_INODE(bdev), (loff_t)sectors << SECTOR_SHIFT);

block/bio-integrity-fs.c

71

bip->bip_iter.bi_size = bio_integrity_bytes(bi, size >> SECTOR_SHIFT);

block/bio-integrity.c

380

if (bytes >> SECTOR_SHIFT > queue_max_hw_sectors(q))

block/blk-iocost.c

311

IOC_SECT_TO_PAGE_SHIFT = IOC_PAGE_SHIFT - SECTOR_SHIFT,

block/blk-lib.c

137

bio->bi_iter.bi_size = len << SECTOR_SHIFT;

block/blk-lib.c

208

nr_sects << SECTOR_SHIFT);

block/blk-lib.c

211

nr_sects -= len >> SECTOR_SHIFT;

block/blk-lib.c

212

sector += len >> SECTOR_SHIFT;

block/blk-lib.c

22

round_up(sector, discard_granularity >> SECTOR_SHIFT);

block/blk-lib.c

343

bio->bi_iter.bi_size = len << SECTOR_SHIFT;

block/blk-lib.c

35

return round_down(BIO_MAX_SIZE, discard_granularity) >> SECTOR_SHIFT;

block/blk-lib.c

51

bio->bi_iter.bi_size = bio_sects << SECTOR_SHIFT;

block/blk-map.c

429

unsigned int max_bytes = lim->max_hw_sectors << SECTOR_SHIFT;

block/blk-map.c

465

unsigned int max_bytes = rq->q->limits.max_hw_sectors << SECTOR_SHIFT;

block/blk-map.c

660

if (len > (queue_max_hw_sectors(rq->q) << SECTOR_SHIFT))

block/blk-merge.c

104

SECTOR_SHIFT;

block/blk-merge.c

232

unsigned pbs = lim->physical_block_size >> SECTOR_SHIFT;

block/blk-merge.c

233

unsigned lbs = lim->logical_block_size >> SECTOR_SHIFT;

block/blk-merge.c

417

return bytes >> SECTOR_SHIFT;

block/blk-merge.c

426

get_max_io_size(bio, lim) << SECTOR_SHIFT));

block/blk-merge.c

442

lim->max_zone_append_sectors << SECTOR_SHIFT);

block/blk-mq.c

3075

((bio->bi_iter.bi_sector << SECTOR_SHIFT) & bs_mask))

block/blk-settings.c

185

} else if (bi->interval_exp < SECTOR_SHIFT ||

block/blk-settings.c

207

max_integrity_io_size(lim) >> SECTOR_SHIFT);

block/blk-settings.c

233

unsigned int unit_limit = min(lim->max_hw_sectors << SECTOR_SHIFT,

block/blk-settings.c

239

min(lim->atomic_write_hw_max >> SECTOR_SHIFT,

block/blk-settings.c

246

lim->atomic_write_hw_boundary >> SECTOR_SHIFT;

block/blk-settings.c

274

lim->atomic_write_hw_max >> SECTOR_SHIFT;

block/blk-settings.c

304

boundary_sectors = lim->atomic_write_hw_boundary >> SECTOR_SHIFT;

block/blk-settings.c

391

logical_block_sectors = lim->logical_block_size >> SECTOR_SHIFT;

block/blk-settings.c

409

} else if (lim->io_opt > (BLK_DEF_MAX_SECTORS_CAP << SECTOR_SHIFT)) {

block/blk-settings.c

411

min(max_hw_sectors, lim->io_opt >> SECTOR_SHIFT);

block/blk-settings.c

412

} else if (lim->io_min > (BLK_DEF_MAX_SECTORS_CAP << SECTOR_SHIFT)) {

block/blk-settings.c

414

min(max_hw_sectors, lim->io_min >> SECTOR_SHIFT);

block/blk-settings.c

620

unsigned int alignment = sector_div(sector, granularity >> SECTOR_SHIFT)

block/blk-settings.c

621

<< SECTOR_SHIFT;

block/blk-settings.c

635

alignment = lim->discard_alignment >> SECTOR_SHIFT;

block/blk-settings.c

636

granularity = lim->discard_granularity >> SECTOR_SHIFT;

block/blk-settings.c

645

return offset << SECTOR_SHIFT;

block/blk-settings.c

650

sectors = round_down(sectors, lbs >> SECTOR_SHIFT);

block/blk-settings.c

651

if (sectors < PAGE_SIZE >> SECTOR_SHIFT)

block/blk-settings.c

652

sectors = PAGE_SIZE >> SECTOR_SHIFT;

block/blk-settings.c

693

if (check_shl_overflow(t->chunk_sectors, SECTOR_SHIFT, &chunk_bytes))

block/blk-settings.c

719

b->atomic_write_hw_boundary >> SECTOR_SHIFT))

block/blk-settings.c

80

io_opt = (u64)lim->max_sectors << SECTOR_SHIFT;

block/blk-settings.c

888

if (t->chunk_sectors % (t->physical_block_size >> SECTOR_SHIFT)) {

block/blk-sysfs.c

244

SECTOR_SHIFT); \

block/blk-sysfs.c

289

if ((max_discard_bytes >> SECTOR_SHIFT) > UINT_MAX)

block/blk-sysfs.c

292

lim->max_user_discard_sectors = max_discard_bytes >> SECTOR_SHIFT;

block/blk-sysfs.c

306

max_hw_zeroes_bytes = lim->max_hw_wzeroes_unmap_sectors << SECTOR_SHIFT;

block/blk-sysfs.c

310

lim->max_user_wzeroes_unmap_sectors = max_zeroes_bytes >> SECTOR_SHIFT;

block/blk-zoned.c

433

start = zrange->sector << SECTOR_SHIFT;

block/blk-zoned.c

434

end = ((zrange->sector + zrange->nr_sectors) << SECTOR_SHIFT) - 1;

block/blk.h

235

UINT_MAX >> SECTOR_SHIFT);

block/blk.h

239

UINT_MAX >> SECTOR_SHIFT);

block/blk.h

24

#define BLK_DEF_MAX_SECTORS_CAP (SZ_4M >> SECTOR_SHIFT)

block/fops.c

212

bio->bi_iter.bi_sector = pos >> SECTOR_SHIFT;

block/fops.c

337

bio->bi_iter.bi_sector = pos >> SECTOR_SHIFT;

block/fops.c

80

bio.bi_iter.bi_sector = pos >> SECTOR_SHIFT;

block/fops.c

909

error = blkdev_issue_zeroout(bdev, start >> SECTOR_SHIFT,

block/fops.c

910

len >> SECTOR_SHIFT, GFP_KERNEL, flags);

block/ioctl.c

152

sector = start >> SECTOR_SHIFT;

block/ioctl.c

153

nr_sects = len >> SECTOR_SHIFT;

block/ioctl.c

47

start = p.start >> SECTOR_SHIFT;

block/ioctl.c

48

length = p.length >> SECTOR_SHIFT;

block/ioctl.c

896

sector_t sector = start >> SECTOR_SHIFT;

block/ioctl.c

897

sector_t nr_sects = len >> SECTOR_SHIFT;

block/t10-pi.c

545

u64 ref = blk_rq_pos(rq) >> (bi->interval_exp - SECTOR_SHIFT);

drivers/ata/libata-scsi.c

2246

max_blocks = 128 << (20 - SECTOR_SHIFT);

drivers/block/brd.c

142

u32 offset = (sector & (PAGE_SECTORS - 1)) << SECTOR_SHIFT;

drivers/block/brd.c

184

sector + (size >> SECTOR_SHIFT), PAGE_SECTORS);

drivers/block/drbd/drbd_bitmap.c

1003

on_disk_sector = first_bm_sect + (((sector_t)page_nr) << (PAGE_SHIFT-SECTOR_SHIFT));

drivers/block/drbd/drbd_nl.c

1316

queue_max_hw_sectors(b) << SECTOR_SHIFT;

drivers/block/drbd/drbd_nl.c

1345

lim.max_hw_sectors = new >> SECTOR_SHIFT;

drivers/block/drbd/drbd_nl.c

1395

if ((lim.discard_granularity >> SECTOR_SHIFT) >

drivers/block/n64cart.c

151

set_capacity(disk, size >> SECTOR_SHIFT);

drivers/block/n64cart.c

93

u32 pos = bio->bi_iter.bi_sector << SECTOR_SHIFT;

drivers/block/nbd.c

1948

.io_opt = 256 << SECTOR_SHIFT,

drivers/block/nbd.c

356

lim.max_hw_discard_sectors = UINT_MAX >> SECTOR_SHIFT;

drivers/block/nbd.c

370

lim.max_write_zeroes_sectors = UINT_MAX >> SECTOR_SHIFT;

drivers/block/null_blk/main.c

1070

i += (nullb->dev->blocksize >> SECTOR_SHIFT)) {

drivers/block/null_blk/main.c

1072

offset = (i << SECTOR_SHIFT);

drivers/block/null_blk/main.c

1152

sector = pos >> SECTOR_SHIFT;

drivers/block/null_blk/main.c

1186

sector = pos >> SECTOR_SHIFT;

drivers/block/null_blk/main.c

1205

size_t n = nr_sectors << SECTOR_SHIFT;

drivers/block/null_blk/main.c

1214

sector += temp >> SECTOR_SHIFT;

drivers/block/null_blk/main.c

1255

pos >> SECTOR_SHIFT, len);

drivers/block/null_blk/main.c

1289

loff_t pos = blk_rq_pos(rq) << SECTOR_SHIFT;

drivers/block/null_blk/main.c

1290

unsigned int max_bytes = nr_sectors << SECTOR_SHIFT;

drivers/block/null_blk/main.c

1351

unsigned int block_sectors = dev->blocksize >> SECTOR_SHIFT;

drivers/block/null_blk/main.c

2038

((sector_t)nullb->dev->size * SZ_1M) >> SECTOR_SHIFT);

drivers/block/null_blk/main.c

48

#define MAP_SZ ((PAGE_SIZE >> SECTOR_SHIFT) + 2)

drivers/block/null_blk/zoned.c

109

dev->blocksize >> SECTOR_SHIFT),

drivers/block/null_blk/zoned.c

16

return ((sector_t)mb * SZ_1M) >> SECTOR_SHIFT;

drivers/block/null_blk/zoned.c

255

return (zone->wp - sector) << SECTOR_SHIFT;

drivers/block/rbd.c

3500

u64 off = (u64)blk_rq_pos(rq) << SECTOR_SHIFT;

drivers/block/rbd.c

4730

u64 offset = (u64)blk_rq_pos(rq) << SECTOR_SHIFT;

drivers/block/rbd.c

4950

.max_hw_sectors = objset_bytes >> SECTOR_SHIFT,

drivers/block/rbd.c

4971

lim.max_hw_discard_sectors = objset_bytes >> SECTOR_SHIFT;

drivers/block/rbd.c

4972

lim.max_write_zeroes_sectors = objset_bytes >> SECTOR_SHIFT;

drivers/block/rbd.c

7166

(unsigned long long)get_capacity(rbd_dev->disk) << SECTOR_SHIFT,

drivers/block/rbd.c

938

if (ondisk->options.order < SECTOR_SHIFT)

drivers/block/ublk_drv.c

1038

if (p->interval_exp < SECTOR_SHIFT ||

drivers/block/ublk_drv.c

610

min_t(size_t, bufsize, queue_max_hw_sectors(q) << SECTOR_SHIFT);

drivers/block/virtio_blk.c

1410

discard_granularity << SECTOR_SHIFT;

drivers/block/virtio_blk.c

189

u32 num_sectors = bio->bi_iter.bi_size >> SECTOR_SHIFT;

drivers/block/virtio_blk.c

541

queue_max_hw_sectors(q) << SECTOR_SHIFT);

drivers/block/virtio_blk.c

778

if ((v << SECTOR_SHIFT) < wg) {

drivers/block/zloop.c

1055

if (zlo->zone_capacity & ((zlo->block_size >> SECTOR_SHIFT) - 1)) {

drivers/block/zloop.c

1110

file_sectors = stat.size >> SECTOR_SHIFT;

drivers/block/zloop.c

1119

zlo->zone_size << SECTOR_SHIFT);

drivers/block/zloop.c

1176

.max_hw_sectors = SZ_1M >> SECTOR_SHIFT,

drivers/block/zloop.c

1327

((sector_t)zlo->zone_size << SECTOR_SHIFT) >> 20,

drivers/block/zloop.c

1400

(old_wp - zone->start) << SECTOR_SHIFT);

drivers/block/zloop.c

1507

((sector_t)token * SZ_1M) >> SECTOR_SHIFT;

drivers/block/zloop.c

1521

((sector_t)token * SZ_1M) >> SECTOR_SHIFT;

drivers/block/zloop.c

1534

((sector_t)token * SZ_1M) >> SECTOR_SHIFT;

drivers/block/zloop.c

326

file_sectors = stat.size >> SECTOR_SHIFT;

drivers/block/zloop.c

481

if (vfs_truncate(&zone->file->f_path, zlo->zone_size << SECTOR_SHIFT)) {

drivers/block/zloop.c

559

cmd->iocb.ki_pos = (cmd->sector - zone->start) << SECTOR_SHIFT;

drivers/block/zloop.c

61

#define ZLOOP_DEF_ZONE_SIZE ((256ULL * SZ_1M) >> SECTOR_SHIFT)

drivers/block/zram/zram_drv.c

2678

SECTOR_SHIFT;

drivers/block/zram/zram_drv.c

2719

SECTOR_SHIFT;

drivers/block/zram/zram_drv.c

2750

SECTOR_SHIFT;

drivers/block/zram/zram_drv.c

2899

set_capacity_and_notify(zram->disk, zram->disksize >> SECTOR_SHIFT);

drivers/block/zram/zram_drv.h

23

#define SECTORS_PER_PAGE_SHIFT (PAGE_SHIFT - SECTOR_SHIFT)

drivers/block/zram/zram_drv.h

28

(1 << (ZRAM_LOGICAL_BLOCK_SHIFT - SECTOR_SHIFT))

drivers/md/bcache/bcache.h

269

#define BCH_MIN_STRIPE_SZ ((4 << 20) >> SECTOR_SHIFT)

drivers/md/bcache/bcache_ondisk.h

154

#define SB_OFFSET (SB_SECTOR << SECTOR_SHIFT)

drivers/md/bcache/super.c

918

d->stripe_size = bdev_io_opt(cached_bdev) >> SECTOR_SHIFT;

drivers/md/dm-bufio.c

1190

c->sectors_per_block_bits - (PAGE_SHIFT - SECTOR_SHIFT));

drivers/md/dm-bufio.c

1215

c->sectors_per_block_bits - (PAGE_SHIFT - SECTOR_SHIFT));

drivers/md/dm-bufio.c

1357

len = n_sectors << SECTOR_SHIFT;

drivers/md/dm-bufio.c

1371

sector = block * (c->block_size >> SECTOR_SHIFT);

drivers/md/dm-bufio.c

1389

n_sectors = b->c->block_size >> SECTOR_SHIFT;

drivers/md/dm-bufio.c

1404

sector += offset >> SECTOR_SHIFT;

drivers/md/dm-bufio.c

1405

n_sectors = (end - offset) >> SECTOR_SHIFT;

drivers/md/dm-bufio.c

2243

count * (c->block_size >> SECTOR_SHIFT),

drivers/md/dm-bufio.c

2321

sector_div(s, c->block_size >> SECTOR_SHIFT);

drivers/md/dm-bufio.c

2412

retain_bytes >>= c->sectors_per_block_bits + SECTOR_SHIFT;

drivers/md/dm-bufio.c

2509

if (!block_size || block_size & ((1 << SECTOR_SHIFT) - 1)) {

drivers/md/dm-bufio.c

2526

c->sectors_per_block_bits = __ffs(block_size) - SECTOR_SHIFT;

drivers/md/dm-cache-metadata.c

1786

new_bm = dm_block_manager_create(cmd->bdev, DM_CACHE_METADATA_BLOCK_SIZE << SECTOR_SHIFT,

drivers/md/dm-cache-metadata.c

539

cmd->bm = dm_block_manager_create(cmd->bdev, DM_CACHE_METADATA_BLOCK_SIZE << SECTOR_SHIFT,

drivers/md/dm-cache-metadata.h

28

#define DM_CACHE_METADATA_MAX_SECTORS_WARNING (16 * (1024 * 1024 * 1024 >> SECTOR_SHIFT))

drivers/md/dm-cache-target.c

1067

(bio->bi_iter.bi_size == (cache->sectors_per_block << SECTOR_SHIFT));

drivers/md/dm-cache-target.c

244

#define DATA_DEV_BLOCK_SIZE_MIN_SECTORS (32 * 1024 >> SECTOR_SHIFT)

drivers/md/dm-cache-target.c

245

#define DATA_DEV_BLOCK_SIZE_MAX_SECTORS (1024 * 1024 * 1024 >> SECTOR_SHIFT)

drivers/md/dm-cache-target.c

3519

limits->discard_granularity = cache->discard_block_size << SECTOR_SHIFT;

drivers/md/dm-cache-target.c

3535

uint64_t io_opt_sectors = limits->io_opt >> SECTOR_SHIFT;

drivers/md/dm-cache-target.c

3543

limits->io_min = cache->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-cache-target.c

3544

limits->io_opt = cache->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-clone-metadata.c

445

DM_CLONE_METADATA_BLOCK_SIZE << SECTOR_SHIFT,

drivers/md/dm-clone-metadata.h

22

#define DM_CLONE_METADATA_MAX_SECTORS_WARNING (16 * (1024 * 1024 * 1024 >> SECTOR_SHIFT))

drivers/md/dm-clone-target.c

2033

limits->discard_granularity = clone->region_size << SECTOR_SHIFT;

drivers/md/dm-clone-target.c

2034

limits->max_hw_discard_sectors = round_down(UINT_MAX >> SECTOR_SHIFT,

drivers/md/dm-clone-target.c

2053

u64 io_opt_sectors = limits->io_opt >> SECTOR_SHIFT;

drivers/md/dm-clone-target.c

2061

limits->io_min = clone->region_size << SECTOR_SHIFT;

drivers/md/dm-clone-target.c

2062

limits->io_opt = clone->region_size << SECTOR_SHIFT;

drivers/md/dm-crypt.c

1518

unsigned int sector_step = cc->sector_size >> SECTOR_SHIFT;

drivers/md/dm-crypt.c

283

return val >> SECTOR_SHIFT;

drivers/md/dm-crypt.c

3139

if (cc->sector_size < (1 << SECTOR_SHIFT) ||

drivers/md/dm-crypt.c

3145

if (ti->len & ((cc->sector_size >> SECTOR_SHIFT) - 1)) {

drivers/md/dm-crypt.c

3149

cc->sector_shift = __ffs(cc->sector_size) - SECTOR_SHIFT;

drivers/md/dm-crypt.c

3208

cc->sector_size = (1 << SECTOR_SHIFT);

drivers/md/dm-crypt.c

3290

(tmpll & ((cc->sector_size >> SECTOR_SHIFT) - 1))) {

drivers/md/dm-crypt.c

3459

if (unlikely((bio->bi_iter.bi_sector & ((cc->sector_size >> SECTOR_SHIFT) - 1)) != 0))

drivers/md/dm-crypt.c

3540

num_feature_args += cc->sector_size != (1 << SECTOR_SHIFT);

drivers/md/dm-crypt.c

3559

if (cc->sector_size != (1 << SECTOR_SHIFT))

drivers/md/dm-crypt.c

3585

if (cc->sector_size != (1 << SECTOR_SHIFT))

drivers/md/dm-crypt.c

472

if (cc->sector_size != (1 << SECTOR_SHIFT)) {

drivers/md/dm-crypt.c

596

if (cc->sector_size != (1 << SECTOR_SHIFT)) {

drivers/md/dm-crypt.c

656

for (i = 0; i < ((1 << SECTOR_SHIFT) / 8); i++)

drivers/md/dm-dust.c

356

sect_per_block = (blksz >> SECTOR_SHIFT);

drivers/md/dm-era-target.c

1664

(unsigned int) (DM_ERA_METADATA_BLOCK_SIZE >> SECTOR_SHIFT),

drivers/md/dm-era-target.c

1732

uint64_t io_opt_sectors = limits->io_opt >> SECTOR_SHIFT;

drivers/md/dm-era-target.c

1741

limits->io_opt = era->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-era-target.c

517

disk->metadata_block_size = cpu_to_le32(DM_ERA_METADATA_BLOCK_SIZE >> SECTOR_SHIFT);

drivers/md/dm-exception-store.c

180

if (chunk_size > INT_MAX >> SECTOR_SHIFT) {

drivers/md/dm-flakey.c

435

dm_accept_partial_bio(bio, UIO_MAXIOV << PAGE_SHIFT >> SECTOR_SHIFT);

drivers/md/dm-inlinecrypt.c

394

if (ti->len & ((ctx->sector_size >> SECTOR_SHIFT) - 1)) {

drivers/md/dm-inlinecrypt.c

399

if (ctx->iv_offset & ((ctx->sector_size >> SECTOR_SHIFT) - 1)) {

drivers/md/dm-inlinecrypt.c

406

(ctx->sector_bits - SECTOR_SHIFT);

drivers/md/dm-inlinecrypt.c

470

if (dun[0] & ((ctx->sector_size >> SECTOR_SHIFT) - 1))

drivers/md/dm-inlinecrypt.c

472

dun[0] >>= ctx->sector_bits - SECTOR_SHIFT; /* crypto sectors */

drivers/md/dm-integrity.c

1062

pl_index = sector >> (PAGE_SHIFT - SECTOR_SHIFT);

drivers/md/dm-integrity.c

1063

pl_offset = (sector << SECTOR_SHIFT) & (PAGE_SIZE - 1);

drivers/md/dm-integrity.c

1186

pl_index = sector >> (PAGE_SHIFT - SECTOR_SHIFT);

drivers/md/dm-integrity.c

1187

pl_offset = (sector << SECTOR_SHIFT) & (PAGE_SIZE - 1);

drivers/md/dm-integrity.c

126

#define JOURNAL_SECTOR_DATA ((1 << SECTOR_SHIFT) - sizeof(commit_id_t))

drivers/md/dm-integrity.c

1433

to_copy = min((1U << SECTOR_SHIFT << ic->log2_buffer_sectors) - *metadata_offset, total_size);

drivers/md/dm-integrity.c

1478

if (unlikely(*metadata_offset == 1U << SECTOR_SHIFT << ic->log2_buffer_sectors)) {

drivers/md/dm-integrity.c

1621

bio_advance(bio, dio->range.n_sectors << SECTOR_SHIFT);

drivers/md/dm-integrity.c

1674

r = crypto_shash_update(req, data + offset, ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

1738

sg_set_page(s, page, ic->sectors_per_block << SECTOR_SHIFT, offset);

drivers/md/dm-integrity.c

1739

nbytes += ic->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-integrity.c

1833

alignment = dio->range.logical_sector | bio_sectors(bio) | (PAGE_SIZE >> SECTOR_SHIFT);

drivers/md/dm-integrity.c

1837

buffer_offset = (sector - io_loc.sector) << SECTOR_SHIFT;

drivers/md/dm-integrity.c

1863

memcpy(mem + pos, buffer + buffer_offset, ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

1866

pos += ic->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-integrity.c

1897

checksums = kmalloc((PAGE_SIZE >> SECTOR_SHIFT >> ic->sb->log2_sectors_per_block) * ic->tag_size + extra_space,

drivers/md/dm-integrity.c

1918

unsigned int this_step_blocks = bi_size >> (SECTOR_SHIFT + ic->sb->log2_sectors_per_block);

drivers/md/dm-integrity.c

1929

bi_size -= this_step_blocks << (SECTOR_SHIFT + ic->sb->log2_sectors_per_block);

drivers/md/dm-integrity.c

1953

pos += ic->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-integrity.c

2037

if (unlikely(bv.bv_len & ((ic->sectors_per_block << SECTOR_SHIFT) - 1))) {

drivers/md/dm-integrity.c

2146

if (unlikely(bv.bv_len >> SECTOR_SHIFT > n_sectors))

drivers/md/dm-integrity.c

2147

bv.bv_len = n_sectors << SECTOR_SHIFT;

drivers/md/dm-integrity.c

2148

n_sectors -= bv.bv_len >> SECTOR_SHIFT;

drivers/md/dm-integrity.c

2179

mem_ptr += 1 << SECTOR_SHIFT;

drivers/md/dm-integrity.c

2213

memcpy(js, mem + bv.bv_offset, ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

2245

bv.bv_offset += ic->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-integrity.c

2246

} while (bv.bv_len -= ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

2459

bio->bi_iter.bi_size = dio->range.n_sectors << SECTOR_SHIFT;

drivers/md/dm-integrity.c

2609

bio_advance_iter_single(bio, &dio->bio_details.bi_iter, ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

2657

ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

2701

memcpy(mem, outgoing_data, ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

2704

bio_advance_iter_single(bio, &dio->bio_details.bi_iter, ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

2730

bio_advance_iter_single(bio, &dio->bio_details.bi_iter, ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

3130

recalc_buffer = kmalloc(recalc_sectors << SECTOR_SHIFT, GFP_NOIO | __GFP_NOWARN);

drivers/md/dm-integrity.c

3226

void *ptr = recalc_buffer + (i << SECTOR_SHIFT);

drivers/md/dm-integrity.c

3294

recalc_buffer = kmalloc(recalc_sectors << SECTOR_SHIFT, GFP_NOIO | __GFP_NOWARN);

drivers/md/dm-integrity.c

3341

range.n_sectors << SECTOR_SHIFT);

drivers/md/dm-integrity.c

3351

void *ptr = recalc_buffer + (i << SECTOR_SHIFT);

drivers/md/dm-integrity.c

3362

range.n_sectors << SECTOR_SHIFT);

drivers/md/dm-integrity.c

3446

bbs->idx * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT),

drivers/md/dm-integrity.c

3447

BITMAP_BLOCK_SIZE >> SECTOR_SHIFT, NULL);

drivers/md/dm-integrity.c

3492

ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);

drivers/md/dm-integrity.c

3811

ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);

drivers/md/dm-integrity.c

3815

ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);

drivers/md/dm-integrity.c

3827

ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);

drivers/md/dm-integrity.c

3846

ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);

drivers/md/dm-integrity.c

3890

ic->n_bitmap_blocks * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT), NULL);

drivers/md/dm-integrity.c

3960

DMEMIT(" block_size:%u", ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

4011

DMEMIT(",block_size=%u", ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

4045

dm_stack_bs_limits(limits, ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

4047

limits->discard_granularity = ic->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-integrity.c

4056

ic->sb->log2_sectors_per_block + SECTOR_SHIFT;

drivers/md/dm-integrity.c

4097

(__u64)(METADATA_PADDING_SECTORS << SECTOR_SHIFT) :

drivers/md/dm-integrity.c

4098

(__u64)(1 << SECTOR_SHIFT << METADATA_PADDING_SECTORS);

drivers/md/dm-integrity.c

4101

metadata_run_padding) >> SECTOR_SHIFT;

drivers/md/dm-integrity.c

4114

meta_size = (meta_size + ((1U << (ic->log2_buffer_sectors + SECTOR_SHIFT)) - 1))

drivers/md/dm-integrity.c

4115

>> (ic->log2_buffer_sectors + SECTOR_SHIFT);

drivers/md/dm-integrity.c

4152

memset(ic->sb, 0, SB_SECTORS << SECTOR_SHIFT);

drivers/md/dm-integrity.c

4305

end = end_offset + (1 << SECTOR_SHIFT);

drivers/md/dm-integrity.c

4422

PAGE_SIZE >> SECTOR_SHIFT) >> (PAGE_SHIFT - SECTOR_SHIFT);

drivers/md/dm-integrity.c

449

ms += offset >> (SECTOR_SHIFT + ic->log2_buffer_sectors - ic->log2_tag_size);

drivers/md/dm-integrity.c

450

mo = (offset << ic->log2_tag_size) & ((1U << SECTOR_SHIFT << ic->log2_buffer_sectors) - 1);

drivers/md/dm-integrity.c

452

ms += (__u64)offset * ic->tag_size >> (SECTOR_SHIFT + ic->log2_buffer_sectors);

drivers/md/dm-integrity.c

453

mo = (offset * ic->tag_size) & ((1U << SECTOR_SHIFT << ic->log2_buffer_sectors) - 1);

drivers/md/dm-integrity.c

4607

section_req->cryptlen = (size_t)ic->journal_section_sectors << SECTOR_SHIFT;

drivers/md/dm-integrity.c

4791

if (val < 1 << SECTOR_SHIFT ||

drivers/md/dm-integrity.c

4792

val > MAX_SECTORS_PER_BLOCK << SECTOR_SHIFT ||

drivers/md/dm-integrity.c

4798

ic->sectors_per_block = val >> SECTOR_SHIFT;

drivers/md/dm-integrity.c

4856

ic->log2_buffer_sectors = min((int)__fls(buffer_sectors), 31 - SECTOR_SHIFT);

drivers/md/dm-integrity.c

4940

if (1 << bi->interval_exp != ic->sectors_per_block << SECTOR_SHIFT) {

drivers/md/dm-integrity.c

5045

ic->sb = alloc_pages_exact(SB_SECTORS << SECTOR_SHIFT, GFP_KERNEL);

drivers/md/dm-integrity.c

506

__u8 *mac = sb + (1 << SECTOR_SHIFT) - mac_size;

drivers/md/dm-integrity.c

5060

if (memchr_inv(ic->sb, 0, SB_SECTORS << SECTOR_SHIFT)) {

drivers/md/dm-integrity.c

508

if (sizeof(struct superblock) + mac_size > 1 << SECTOR_SHIFT ||

drivers/md/dm-integrity.c

5169

bits_in_journal = ((__u64)ic->journal_section_sectors * ic->journal_sections) << (SECTOR_SHIFT + 3);

drivers/md/dm-integrity.c

5247

1U << (SECTOR_SHIFT + ic->log2_buffer_sectors), 1, 0, NULL, NULL, 0);

drivers/md/dm-integrity.c

5297

sector = i * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT);

drivers/md/dm-integrity.c

5298

pl_index = sector >> (PAGE_SHIFT - SECTOR_SHIFT);

drivers/md/dm-integrity.c

5299

pl_offset = (sector << SECTOR_SHIFT) & (PAGE_SIZE - 1);

drivers/md/dm-integrity.c

5417

free_pages_exact(ic->sb, SB_SECTORS << SECTOR_SHIFT);

drivers/md/dm-integrity.c

737

*pl_index = sector >> (PAGE_SHIFT - SECTOR_SHIFT);

drivers/md/dm-integrity.c

738

*pl_offset = (sector << SECTOR_SHIFT) & (PAGE_SIZE - 1);

drivers/md/dm-integrity.c

750

*n_sectors = (PAGE_SIZE - pl_offset) >> SECTOR_SHIFT;

drivers/md/dm-integrity.c

894

size_t n_bytes = (size_t)(n_sections * ic->journal_section_sectors) << SECTOR_SHIFT;

drivers/md/dm-io.c

350

(PAGE_SIZE >> SECTOR_SHIFT)) + 1);

drivers/md/dm-io.c

362

bio->bi_iter.bi_size = num_sectors << SECTOR_SHIFT;

drivers/md/dm-io.c

513

r = dp_init(io_req, &dp, (unsigned long)where->count << SECTOR_SHIFT);

drivers/md/dm-kcopyd.c

945

reserve_pages = DIV_ROUND_UP(kc->sub_job_size << SECTOR_SHIFT, PAGE_SIZE);

drivers/md/dm-log-writes.c

141

return sectors >> (lc->sectorshift - SECTOR_SHIFT);

drivers/md/dm-log-writes.c

147

return sectors << (lc->sectorshift - SECTOR_SHIFT);

drivers/md/dm-log-writes.c

387

sector += block->vecs[i].bv_len >> SECTOR_SHIFT;

drivers/md/dm-log-writes.c

567

lc->next_sector = lc->sectorsize >> SECTOR_SHIFT;

drivers/md/dm-log-writes.c

877

limits->max_hw_discard_sectors = (UINT_MAX >> SECTOR_SHIFT);

drivers/md/dm-log.c

456

dm_round_up((LOG_OFFSET << SECTOR_SHIFT) + bitset_size,

drivers/md/dm-log.c

466

lc->header_location.count = buf_size >> SECTOR_SHIFT;

drivers/md/dm-log.c

488

(LOG_OFFSET << SECTOR_SHIFT);

drivers/md/dm-pcache/backing_dev.c

278

bio_trim(clone, off >> SECTOR_SHIFT, len >> SECTOR_SHIFT);

drivers/md/dm-pcache/backing_dev.c

280

clone->bi_iter.bi_sector = (pcache_req->off + off) >> SECTOR_SHIFT;

drivers/md/dm-pcache/backing_dev.c

304

backing_bio->bi_iter.bi_sector = (opts->kmem.backing_off) >> SECTOR_SHIFT;

drivers/md/dm-pcache/cache.c

289

n_subtrees = DIV_ROUND_UP(cache->dev_size << SECTOR_SHIFT, PCACHE_CACHE_SUBTREE_SIZE);

drivers/md/dm-pcache/dm_pcache.c

386

pcache_req->off = (u64)bio->bi_iter.bi_sector << SECTOR_SHIFT;

drivers/md/dm-snap-persistent.c

175

len = ps->store->chunk_size << SECTOR_SHIFT;

drivers/md/dm-snap-persistent.c

297

memset(ps->area, 0, ps->store->chunk_size << SECTOR_SHIFT);

drivers/md/dm-snap-persistent.c

387

memset(ps->header_area, 0, ps->store->chunk_size << SECTOR_SHIFT);

drivers/md/dm-snap-persistent.c

498

ps->store->chunk_size << SECTOR_SHIFT,

drivers/md/dm-snap-persistent.c

546

memcpy(ps->area, area, ps->store->chunk_size << SECTOR_SHIFT);

drivers/md/dm-snap-persistent.c

627

ps->exceptions_per_area = (ps->store->chunk_size << SECTOR_SHIFT) /

drivers/md/dm-snap.c

1936

(s->store->chunk_size << SECTOR_SHIFT);

drivers/md/dm-stripe.c

463

if (!check_shl_overflow(sc->chunk_size, SECTOR_SHIFT, &io_min) &&

drivers/md/dm-stripe.c

474

limits->max_hw_discard_sectors = UINT_MAX >> SECTOR_SHIFT;

drivers/md/dm-table.c

237

limits->logical_block_size >> SECTOR_SHIFT;

drivers/md/dm-table.c

439

(unsigned long long) start << SECTOR_SHIFT);

drivers/md/dm-table.c

611

limits->logical_block_size >> SECTOR_SHIFT;

drivers/md/dm-table.c

647

SECTOR_SHIFT) - 1))

drivers/md/dm-table.c

692

if (start + len < start || start + len > LLONG_MAX >> SECTOR_SHIFT) {

drivers/md/dm-thin-metadata.c

791

pmd->bm = dm_block_manager_create(pmd->bdev, THIN_METADATA_BLOCK_SIZE << SECTOR_SHIFT,

drivers/md/dm-thin-metadata.h

25

#define THIN_METADATA_MAX_SECTORS_WARNING (16 * (1024 * 1024 * 1024 >> SECTOR_SHIFT))

drivers/md/dm-thin.c

1237

(pool->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-thin.c

1986

bio->bi_iter.bi_size = (tc->origin_size - bio->bi_iter.bi_sector) << SECTOR_SHIFT;

drivers/md/dm-thin.c

4054

sector_t io_opt_sectors = limits->io_opt >> SECTOR_SHIFT;

drivers/md/dm-thin.c

4080

limits->io_min = limits->max_sectors << SECTOR_SHIFT;

drivers/md/dm-thin.c

4082

limits->io_min = pool->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-thin.c

4083

limits->io_opt = pool->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-thin.c

4488

limits->discard_granularity = pool->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-thin.c

45

#define DATA_DEV_BLOCK_SIZE_MIN_SECTORS (64 * 1024 >> SECTOR_SHIFT)

drivers/md/dm-thin.c

46

#define DATA_DEV_BLOCK_SIZE_MAX_SECTORS (1024 * 1024 * 1024 >> SECTOR_SHIFT)

drivers/md/dm-thin.c

693

sector_t e = b + (bio->bi_iter.bi_size >> SECTOR_SHIFT);

drivers/md/dm-vdo/constants.h

93

VDO_SECTORS_PER_BLOCK = (VDO_BLOCK_SIZE >> SECTOR_SHIFT),

drivers/md/dm-vdo/indexer/io-factory.h

24

SECTORS_PER_BLOCK = UDS_BLOCK_SIZE >> SECTOR_SHIFT,

drivers/md/dm-verity-fec.c

537

((sector_t)(num_ll << (v->data_dev_block_bits - SECTOR_SHIFT))

drivers/md/dm-verity-fec.c

538

>> (v->data_dev_block_bits - SECTOR_SHIFT) != num_ll)) {

drivers/md/dm-verity-fec.c

546

((sector_t)(num_ll << (v->data_dev_block_bits - SECTOR_SHIFT)) >>

drivers/md/dm-verity-fec.c

547

(v->data_dev_block_bits - SECTOR_SHIFT) != num_ll)) {

drivers/md/dm-verity-fec.c

673

dm_bufio_set_sector_offset(f->bufio, f->start << (v->data_dev_block_bits - SECTOR_SHIFT));

drivers/md/dm-verity-target.c

1505

(sector_t)(num_ll << (v->data_dev_block_bits - SECTOR_SHIFT))

drivers/md/dm-verity-target.c

1506

>> (v->data_dev_block_bits - SECTOR_SHIFT) != num_ll) {

drivers/md/dm-verity-target.c

1513

if (ti->len > (v->data_blocks << (v->data_dev_block_bits - SECTOR_SHIFT))) {

drivers/md/dm-verity-target.c

1520

(sector_t)(num_ll << (v->hash_dev_block_bits - SECTOR_SHIFT))

drivers/md/dm-verity-target.c

1521

>> (v->hash_dev_block_bits - SECTOR_SHIFT) != num_ll) {

drivers/md/dm-verity-target.c

396

io_loc.sector = cur_block << (v->data_dev_block_bits - SECTOR_SHIFT);

drivers/md/dm-verity-target.c

397

io_loc.count = 1 << (v->data_dev_block_bits - SECTOR_SHIFT);

drivers/md/dm-verity-target.c

796

((1 << (v->data_dev_block_bits - SECTOR_SHIFT)) - 1)) {

drivers/md/dm-verity-target.c

802

(v->data_dev_block_bits - SECTOR_SHIFT) > v->data_blocks) {

drivers/md/dm-verity-target.c

813

io->block = bio->bi_iter.bi_sector >> (v->data_dev_block_bits - SECTOR_SHIFT);

drivers/md/dm-writecache.c

1017

(wc->metadata_sectors << SECTOR_SHIFT) - sb_entries_offset);

drivers/md/dm-writecache.c

1344

if (next_boundary < bio->bi_iter.bi_size >> SECTOR_SHIFT)

drivers/md/dm-writecache.c

1365

dm_accept_partial_bio(bio, wc->block_size >> SECTOR_SHIFT);

drivers/md/dm-writecache.c

1386

sector_t current_cache_sec = start_cache_sec + (bio_size >> SECTOR_SHIFT);

drivers/md/dm-writecache.c

1395

(bio_size >> SECTOR_SHIFT), wc->seq_count);

drivers/md/dm-writecache.c

1408

read_original_sector(wc, e) + (wc->block_size >> SECTOR_SHIFT))

drivers/md/dm-writecache.c

1417

current_cache_sec += wc->block_size >> SECTOR_SHIFT;

drivers/md/dm-writecache.c

1422

dm_accept_partial_bio(bio, bio_size >> SECTOR_SHIFT);

drivers/md/dm-writecache.c

1859

read_original_sector(wc, e) + (wc->block_size >> SECTOR_SHIFT))

drivers/md/dm-writecache.c

1897

n_sectors = e->wc_list_contiguous << (wc->block_size_bits - SECTOR_SHIFT);

drivers/md/dm-writecache.c

1911

while ((n_sectors -= wc->block_size >> SECTOR_SHIFT)) {

drivers/md/dm-writecache.c

2040

read_original_sector(wc, f) + (wc->block_size >> SECTOR_SHIFT))

drivers/md/dm-writecache.c

2404

wc->start_sector >= wc->memory_map_size >> SECTOR_SHIFT)

drivers/md/dm-writecache.c

2514

wc->memory_map_size -= (uint64_t)wc->start_sector << SECTOR_SHIFT;

drivers/md/dm-writecache.c

2556

wc->metadata_sectors = n_metadata_blocks << (wc->block_size_bits - SECTOR_SHIFT);

drivers/md/dm-writecache.c

2566

r = writecache_read_metadata(wc, wc->block_size >> SECTOR_SHIFT);

drivers/md/dm-writecache.c

2633

wc->metadata_sectors = offset >> SECTOR_SHIFT;

drivers/md/dm-writecache.c

338

wc->memory_map += (size_t)wc->start_sector << SECTOR_SHIFT;

drivers/md/dm-writecache.c

339

wc->memory_map_size -= (size_t)wc->start_sector << SECTOR_SHIFT;

drivers/md/dm-writecache.c

359

vunmap(wc->memory_map - ((size_t)wc->start_sector << SECTOR_SHIFT));

drivers/md/dm-writecache.c

405

((sector_t)e->index << (wc->block_size_bits - SECTOR_SHIFT));

drivers/md/dm-writecache.c

515

region.sector = (sector_t)i * (BITMAP_GRANULARITY >> SECTOR_SHIFT);

drivers/md/dm-writecache.c

516

region.count = (sector_t)(j - i) * (BITMAP_GRANULARITY >> SECTOR_SHIFT);

drivers/md/dm-writecache.c

556

region.count = max(4096U, wc->block_size) >> SECTOR_SHIFT;

drivers/md/dm-zoned-target.c

135

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

drivers/md/dm-zoned.h

35

#define DMZ_BLOCK_SECTORS_SHIFT (DMZ_BLOCK_SHIFT - SECTOR_SHIFT)

drivers/md/dm-zoned.h

36

#define DMZ_BLOCK_SECTORS (DMZ_BLOCK_SIZE >> SECTOR_SHIFT)

drivers/md/dm.c

1346

bio->bi_iter.bi_size = n_sectors << SECTOR_SHIFT;

drivers/md/md-llbitmap.c

1148

while (chunks > mddev->bitmap_info.space << SECTOR_SHIFT) {

drivers/md/md-llbitmap.c

564

sector_t bit_sector = llbitmap->io_size >> SECTOR_SHIFT;

drivers/md/md-llbitmap.c

909

unsigned long space = mddev->bitmap_info.space << SECTOR_SHIFT;

drivers/md/md-llbitmap.c

998

mddev->bitmap_info.space << SECTOR_SHIFT)) {

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

13

#define DM_SM_METADATA_BLOCK_SIZE (4096 >> SECTOR_SHIFT)

drivers/mmc/core/block.c

1461

brq->data.blocks = queue_physical_block_size(mq->queue) >> SECTOR_SHIFT;

drivers/mmc/core/block.c

2961

card->part[idx].size >> SECTOR_SHIFT,

drivers/mmc/core/block.c

2968

card->part[idx].size >> SECTOR_SHIFT,

drivers/mmc/core/core.c

100

data->bytes_xfered = get_random_u32_below(data->bytes_xfered >> SECTOR_SHIFT)

drivers/mmc/core/core.c

101

<< SECTOR_SHIFT;

drivers/mmc/core/mmc_test.c

1386

t->blocks = sz >> SECTOR_SHIFT;

drivers/mmc/core/mmc_test.c

1469

dev_addr += sz >> SECTOR_SHIFT;

drivers/mmc/core/mmc_test.c

1512

return mmc_erase(test->card, t->dev_addr, t->max_sz >> SECTOR_SHIFT,

drivers/mmc/core/mmc_test.c

1548

sz = (unsigned long)test->card->pref_erase << SECTOR_SHIFT;

drivers/mmc/core/mmc_test.c

1560

if (t->max_tfr >> SECTOR_SHIFT > test->card->host->max_blk_count)

drivers/mmc/core/mmc_test.c

1561

t->max_tfr = test->card->host->max_blk_count << SECTOR_SHIFT;

drivers/mmc/core/mmc_test.c

1591

t->dev_addr -= t->dev_addr % (t->max_sz >> SECTOR_SHIFT);

drivers/mmc/core/mmc_test.c

1696

dev_addr = t->dev_addr + (sz >> SECTOR_SHIFT);

drivers/mmc/core/mmc_test.c

1720

dev_addr = t->dev_addr + (sz >> SECTOR_SHIFT);

drivers/mmc/core/mmc_test.c

1751

dev_addr = t->dev_addr + (sz >> SECTOR_SHIFT);

drivers/mmc/core/mmc_test.c

1753

ret = mmc_erase(test->card, dev_addr, sz >> SECTOR_SHIFT, MMC_TRIM_ARG);

drivers/mmc/core/mmc_test.c

1761

ret = mmc_erase(test->card, dev_addr, sz >> SECTOR_SHIFT, MMC_TRIM_ARG);

drivers/mmc/core/mmc_test.c

1783

dev_addr += (sz >> SECTOR_SHIFT);

drivers/mmc/core/mmc_test.c

1825

dev_addr += (sz >> SECTOR_SHIFT);

drivers/mmc/core/mmc_test.c

1878

ret = mmc_erase(test->card, dev_addr, sz >> SECTOR_SHIFT,

drivers/mmc/core/mmc_test.c

1882

dev_addr += (sz >> SECTOR_SHIFT);

drivers/mmc/core/mmc_test.c

1909

ssz = sz >> SECTOR_SHIFT;

drivers/mmc/core/mmc_test.c

2025

ssz = sz >> SECTOR_SHIFT;

drivers/mmc/core/mmc_test.c

2027

if (tot_sz > dev_addr << SECTOR_SHIFT)

drivers/mmc/core/mmc_test.c

2028

tot_sz = dev_addr << SECTOR_SHIFT;

drivers/mmc/core/mmc_test.c

2448

if (repeat_cmd && (t->blocks + 1) << SECTOR_SHIFT > t->max_tfr)

drivers/mmc/core/mmc_test.c

560

unsigned int rate, iops, sectors = bytes >> SECTOR_SHIFT;

drivers/mmc/core/mmc_test.c

585

unsigned int rate, iops, sectors = bytes >> SECTOR_SHIFT;

drivers/mtd/ssfdc.c

132

cis_sector = (int)(offset >> SECTOR_SHIFT);

drivers/mtd/ssfdc.c

153

loff_t offset = (loff_t)sect_no << SECTOR_SHIFT;

drivers/mtd/ssfdc.c

307

ssfdc->cis_block = cis_sector / (mtd->erasesize >> SECTOR_SHIFT);

drivers/mtd/ssfdc.c

319

ssfdc->cylinders = (unsigned short)(((u32)mtd->size >> SECTOR_SHIFT) /

drivers/mtd/ssfdc.c

373

sectors_per_block = ssfdc->erase_size >> SECTOR_SHIFT;

drivers/nvdimm/btt.c

1069

__u64 lba = div_u64(sector << SECTOR_SHIFT, btt->sector_size);

drivers/nvdimm/btt.c

1278

sector += btt->sector_size >> SECTOR_SHIFT;

drivers/nvdimm/btt.c

1408

sector += btt->sector_size >> SECTOR_SHIFT;

drivers/nvdimm/pmem.c

118

pmem_clear_bb(pmem, to_sect(pmem, offset), cleared >> SECTOR_SHIFT);

drivers/nvdimm/pmem.c

247

sector_t sector = PFN_PHYS(pgoff) >> SECTOR_SHIFT;

drivers/nvdimm/pmem.c

248

unsigned int num = PFN_PHYS(nr_pages) >> SECTOR_SHIFT;

drivers/nvdimm/pmem.c

271

PAGE_ALIGN((first_bad - sector) << SECTOR_SHIFT));

drivers/nvdimm/pmem.c

299

PFN_PHYS(pgoff) >> SECTOR_SHIFT,

drivers/nvdimm/pmem.c

336

if (!is_bad_pmem(&pmem->bb, PFN_PHYS(pgoff) >> SECTOR_SHIFT, len))

drivers/nvdimm/pmem.c

362

pmem_clear_bb(pmem, to_sect(pmem, pmem_off), cleared >> SECTOR_SHIFT);

drivers/nvdimm/pmem.c

55

return (offset - pmem->data_offset) >> SECTOR_SHIFT;

drivers/nvdimm/pmem.c

60

return (sector << SECTOR_SHIFT) + pmem->data_offset;

drivers/nvme/host/core.c

2062

return ctrl->max_hw_sectors / (NVME_CTRL_PAGE_SIZE >> SECTOR_SHIFT) + 1;

drivers/nvme/host/core.c

2431

id->lbaf[lbaf].ds - SECTOR_SHIFT, &capacity)) {

drivers/nvme/host/core.c

992

u64 start = blk_rq_pos(req) << SECTOR_SHIFT;

drivers/nvme/host/multipath.c

1441

size_t max_transfer_size = ctrl->max_hw_sectors << SECTOR_SHIFT;

drivers/nvme/host/multipath.c

212

blk_rq_bytes(rq) >> SECTOR_SHIFT,

drivers/nvme/host/nvme.h

759

return sector >> (head->lba_shift - SECTOR_SHIFT);

drivers/nvme/host/nvme.h

767

return lba << (head->lba_shift - SECTOR_SHIFT);

drivers/nvme/host/pci.c

3733

NVME_MAX_BYTES >> SECTOR_SHIFT,

drivers/nvme/host/zns.c

135

queue_max_hw_sectors(q) << SECTOR_SHIFT);

drivers/nvme/target/io-cmd-bdev.c

224

(bi->interval_exp - SECTOR_SHIFT));

drivers/nvme/target/nvmet.h

868

return cpu_to_le64(sect >> (ns->blksize_shift - SECTOR_SHIFT));

drivers/nvme/target/nvmet.h

873

return le64_to_cpu(lba) << (ns->blksize_shift - SECTOR_SHIFT);

drivers/nvme/target/zns.c

545

bdev_max_zone_append_sectors(req->ns->bdev) << SECTOR_SHIFT) {

drivers/scsi/hosts.c

257

dma_max_mapping_size(dma_dev) >> SECTOR_SHIFT);

drivers/scsi/mpt3sas/mpt3sas_scsih.c

2751

lim->max_hw_sectors = SZ_2M >> SECTOR_SHIFT;

drivers/scsi/mpt3sas/mpt3sas_scsih.c

2754

pcie_device->nvme_mdts >> SECTOR_SHIFT);

drivers/scsi/scsi_transport_sas.c

244

opt_sectors = min_t(unsigned int, opt >> SECTOR_SHIFT,

drivers/scsi/sd.c

1219

sdkp->max_ws_blocks * (logical_block_size >> SECTOR_SHIFT);

drivers/scsi/sd.c

202

(logical_block_size >> SECTOR_SHIFT);

drivers/scsi/sd.c

3857

lim->io_opt = sdp->host->opt_sectors << SECTOR_SHIFT;

drivers/scsi/sd_zbc.c

184

queue_max_hw_sectors(q) << SECTOR_SHIFT);

drivers/target/target_core_iblock.c

552

block_lba += sg->length >> SECTOR_SHIFT;

drivers/target/target_core_iblock.c

553

sectors -= sg->length >> SECTOR_SHIFT;

drivers/target/target_core_iblock.c

712

(bi->interval_exp - SECTOR_SHIFT));

drivers/target/target_core_iblock.c

839

block_lba += sg->length >> SECTOR_SHIFT;

drivers/usb/storage/scsiglue.c

127

lim->max_hw_sectors, dma_max_mapping_size(dev) >> SECTOR_SHIFT);

drivers/vdpa/vdpa_sim/vdpa_sim_blk.c

157

offset = sector << SECTOR_SHIFT;

drivers/vdpa/vdpa_sim/vdpa_sim_blk.c

172

to_push >> SECTOR_SHIFT,

drivers/vdpa/vdpa_sim/vdpa_sim_blk.c

195

to_pull >> SECTOR_SHIFT,

drivers/vdpa/vdpa_sim/vdpa_sim_blk.c

256

offset = sector << SECTOR_SHIFT;

drivers/vdpa/vdpa_sim/vdpa_sim_blk.c

286

num_sectors << SECTOR_SHIFT);

drivers/vdpa/vdpa_sim/vdpa_sim_blk.c

433

blk->buffer = kvzalloc(VDPASIM_BLK_CAPACITY << SECTOR_SHIFT,

drivers/vdpa/vdpa_sim/vdpa_sim_blk.c

489

shared_buffer = kvzalloc(VDPASIM_BLK_CAPACITY << SECTOR_SHIFT,

fs/btrfs/bio.c

1000

smap.physical >> SECTOR_SHIFT);

fs/btrfs/bio.c

1016

u64 logical = bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/bio.c

189

const u64 logical = repair_bbio->saved_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/bio.c

254

const u64 logical = round_down(failed_bbio->saved_iter.bi_sector << SECTOR_SHIFT,

fs/btrfs/bio.c

282

repair_bio->bi_iter.bi_sector = logical >> SECTOR_SHIFT;

fs/btrfs/bio.c

455

stripe->physical = bio->bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/bio.c

479

stripe->physical = bio->bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/bio.c

497

u64 physical = bio->bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/bio.c

517

bio->bi_iter.bi_sector = zone_start >> SECTOR_SHIFT;

fs/btrfs/bio.c

562

bio->bi_iter.bi_sector = bioc->stripes[dev_nr].physical >> SECTOR_SHIFT;

fs/btrfs/bio.c

574

bio->bi_iter.bi_sector = smap->physical >> SECTOR_SHIFT;

fs/btrfs/bio.c

749

return ALIGN_DOWN(sector_offset << SECTOR_SHIFT, fs_info->sectorsize);

fs/btrfs/bio.c

759

u64 logical = bio->bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/bio.c

87

bio = bio_split(&orig_bbio->bio, map_length >> SECTOR_SHIFT, GFP_NOFS,

fs/btrfs/bio.c

888

const u64 logical = bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/bio.c

983

bio->bi_iter.bi_sector = smap.physical >> SECTOR_SHIFT;

fs/btrfs/compression.c

333

cb->bbio.bio.bi_iter.bi_sector = ordered->disk_bytenr >> SECTOR_SHIFT;

fs/btrfs/compression.c

476

(btrfs_extent_map_block_start(em) >> SECTOR_SHIFT) !=

fs/btrfs/direct-io.c

726

u64 start = (u64)bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/disk-io.c

3906

bio->bi_iter.bi_sector = bytenr >> SECTOR_SHIFT;

fs/btrfs/extent-tree.c

1341

ret = blkdev_issue_discard(bdev, start >> SECTOR_SHIFT,

fs/btrfs/extent-tree.c

1342

size >> SECTOR_SHIFT,

fs/btrfs/extent-tree.c

1361

ret = blkdev_issue_discard(bdev, start >> SECTOR_SHIFT,

fs/btrfs/extent-tree.c

1362

bytes_to_discard >> SECTOR_SHIFT,

fs/btrfs/extent_io.c

2294

bbio->bio.bi_iter.bi_sector = eb->start >> SECTOR_SHIFT;

fs/btrfs/extent_io.c

3950

bbio->bio.bi_iter.bi_sector = eb->start >> SECTOR_SHIFT;

fs/btrfs/extent_io.c

708

const sector_t sector = disk_bytenr >> SECTOR_SHIFT;

fs/btrfs/extent_io.c

735

bbio->bio.bi_iter.bi_sector = disk_bytenr >> SECTOR_SHIFT;

fs/btrfs/file-item.c

357

u64 orig_disk_bytenr = bio->bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/file-item.c

885

bbio->sums->logical = bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/inode.c

1091

async_extent->cb->bbio.bio.bi_iter.bi_sector = ins.objectid >> SECTOR_SHIFT;

fs/btrfs/inode.c

8076

ALIGN(delalloc_bytes, blocksize)) >> SECTOR_SHIFT;

fs/btrfs/inode.c

9436

bbio->bio.bi_iter.bi_sector = disk_bytenr >> SECTOR_SHIFT;

fs/btrfs/inode.c

9447

bbio->bio.bi_iter.bi_sector = disk_bytenr >> SECTOR_SHIFT;

fs/btrfs/raid56.c

1260

u64 last_end = last->bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/raid56.c

1279

bio->bi_iter.bi_sector = disk_start >> SECTOR_SHIFT;

fs/btrfs/raid56.c

1295

u32 offset = (bio->bi_iter.bi_sector << SECTOR_SHIFT) -

fs/btrfs/raid56.c

1342

trace_info->offset = (bio->bi_iter.bi_sector << SECTOR_SHIFT) -

fs/btrfs/raid56.c

1548

u32 offset = (bio->bi_iter.bi_sector << SECTOR_SHIFT) -

fs/btrfs/raid56.c

1815

const u64 orig_logical = orig_bio->bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/relocation.c

4080

bbio->bio.bi_iter.bi_sector = (addr >> SECTOR_SHIFT);

fs/btrfs/relocation.c

4094

bbio->bio.bi_iter.bi_sector = (addr >> SECTOR_SHIFT);

fs/btrfs/scrub.c

1299

u32 bio_off = (bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT) -

fs/btrfs/scrub.c

2119

bio.bi_iter.bi_sector = full_stripe_start >> SECTOR_SHIFT;

fs/btrfs/scrub.c

2946

ret = bdev_rw_virt(dev->bdev, physical >> SECTOR_SHIFT, sb,

fs/btrfs/scrub.c

950

bbio->bio.bi_iter.bi_sector = logical >> SECTOR_SHIFT;

fs/btrfs/volumes.c

8280

queue_max_sectors(queue) << SECTOR_SHIFT;

fs/btrfs/zoned.c

1045

sb_zone = sb_zone_number(zone_sectors_shift + SECTOR_SHIFT, mirror);

fs/btrfs/zoned.c

1173

physical >> SECTOR_SHIFT, length >> SECTOR_SHIFT);

fs/btrfs/zoned.c

121

*wp_ret = zones[0].start << SECTOR_SHIFT;

fs/btrfs/zoned.c

130

u64 zone_end = (zones[i].start + zones[i].capacity) << SECTOR_SHIFT;

fs/btrfs/zoned.c

1375

capacity = bdev_zone_capacity(device->bdev, info->physical >> SECTOR_SHIFT);

fs/btrfs/zoned.c

1378

info->capacity = capacity << SECTOR_SHIFT;

fs/btrfs/zoned.c

1397

zone.start << SECTOR_SHIFT, rcu_dereference(device->name),

fs/btrfs/zoned.c

1403

info->capacity = (zone.capacity << SECTOR_SHIFT);

fs/btrfs/zoned.c

1422

info->alloc_offset = ((zone.wp - zone.start) << SECTOR_SHIFT);

fs/btrfs/zoned.c

161

*wp_ret = sector << SECTOR_SHIFT;

fs/btrfs/zoned.c

204

const sector_t zone_sectors = device->fs_info->zone_size >> SECTOR_SHIFT;

fs/btrfs/zoned.c

2043

u64 start = (bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT);

fs/btrfs/zoned.c

208

pos >>= SECTOR_SHIFT;

fs/btrfs/zoned.c

2082

const u64 physical = bbio->bio.bi_iter.bi_sector << SECTOR_SHIFT;

fs/btrfs/zoned.c

2317

return blkdev_issue_zeroout(device->bdev, physical >> SECTOR_SHIFT,

fs/btrfs/zoned.c

2318

length >> SECTOR_SHIFT, GFP_NOFS, 0);

fs/btrfs/zoned.c

2385

wp = physical_start + ((zone.wp - zone.start) << SECTOR_SHIFT);

fs/btrfs/zoned.c

2530

physical >> SECTOR_SHIFT,

fs/btrfs/zoned.c

2531

zinfo->zone_size >> SECTOR_SHIFT);

fs/btrfs/zoned.c

271

ret = blkdev_report_zones_cached(device->bdev, pos >> SECTOR_SHIFT,

fs/btrfs/zoned.c

3115

const sector_t zone_size_sectors = fs_info->zone_size >> SECTOR_SHIFT;

fs/btrfs/zoned.c

3179

stripe->physical >> SECTOR_SHIFT,

fs/btrfs/zoned.c

419

zone_sectors = fs_info->zone_size >> SECTOR_SHIFT;

fs/btrfs/zoned.c

425

zone_info->zone_size = zone_sectors << SECTOR_SHIFT;

fs/btrfs/zoned.c

499

ret = btrfs_get_dev_zones(device, sector << SECTOR_SHIFT, zones,

fs/btrfs/zoned.c

68

#define SUPER_INFO_SECTORS ((u64)BTRFS_SUPER_INFO_SIZE >> SECTOR_SHIFT)

fs/btrfs/zoned.c

780

min3((u64)lim->max_zone_append_sectors << SECTOR_SHIFT,

fs/btrfs/zoned.c

781

(u64)lim->max_sectors << SECTOR_SHIFT,

fs/btrfs/zoned.c

837

*bytenr_ret = zones[0].start << SECTOR_SHIFT;

fs/btrfs/zoned.c

848

if (wp == zones[0].start << SECTOR_SHIFT)

fs/btrfs/zoned.c

850

else if (wp == zones[1].start << SECTOR_SHIFT)

fs/btrfs/zoned.c

875

if (wp == zones[0].start << SECTOR_SHIFT)

fs/btrfs/zoned.c

877

else if (wp == zones[1].start << SECTOR_SHIFT)

fs/btrfs/zoned.c

880

wp = ALIGN_DOWN(zone_end << SECTOR_SHIFT,

fs/btrfs/zoned.c

916

sb_zone = sb_zone_number(zone_sectors_shift + SECTOR_SHIFT, mirror);

fs/btrfs/zoned.h

355

(bdev_zone_sectors(bdev) << SECTOR_SHIFT);

fs/crypto/bio.c

191

sector += 1U << (du_bits - SECTOR_SHIFT);

fs/crypto/bio.c

98

sector += (bytes_this_page >> SECTOR_SHIFT);

fs/crypto/policy.c

256

policy->log2_data_unit_size < SECTOR_SHIFT /* 9 */) {

fs/erofs/fileio.c

51

rq->iocb.ki_pos = rq->bio.bi_iter.bi_sector << SECTOR_SHIFT;

fs/ext4/inode.c

422

pblk << (inode->i_blkbits - SECTOR_SHIFT),

fs/f2fs/segment.c

5293

unsigned int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;

fs/f2fs/segment.c

5397

unsigned int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;

fs/gfs2/inode.h

47

inode->i_blocks = blocks << (inode->i_blkbits - SECTOR_SHIFT);

fs/gfs2/inode.h

52

return inode->i_blocks >> (inode->i_blkbits - SECTOR_SHIFT);

fs/gfs2/inode.h

57

change <<= inode->i_blkbits - SECTOR_SHIFT;

fs/gfs2/meta_io.c

234

bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> SECTOR_SHIFT);

fs/gfs2/ops_fstype.c

1156

sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift - SECTOR_SHIFT;

fs/gfs2/ops_fstype.c

228

sector << (sdp->sd_vfs->s_blocksize_bits - SECTOR_SHIFT),

fs/gfs2/ops_fstype.c

261

sdp->sd_fsb2bb_shift = sdp->sd_sb.sb_bsize_shift - SECTOR_SHIFT;

fs/iomap/fiemap.c

103

const unsigned int blkshift = mapping->host->i_blkbits - SECTOR_SHIFT;

fs/iomap/ioend.c

407

if (ioend->io_sector + (ioend->io_size >> SECTOR_SHIFT) !=

fs/iomap/ioend.c

474

lim->max_zone_append_sectors << SECTOR_SHIFT);

fs/iomap/ioend.c

484

sector_offset = max_len >> SECTOR_SHIFT;

fs/iomap/ioend.c

488

sector_offset = ALIGN_DOWN(sector_offset << SECTOR_SHIFT,

fs/iomap/ioend.c

489

i_blocksize(ioend->io_inode)) >> SECTOR_SHIFT;

fs/iomap/ioend.c

507

ioend->io_sector += (split_ioend->io_size >> SECTOR_SHIFT);

fs/jbd2/journal.c

2006

byte_start >> SECTOR_SHIFT,

fs/jbd2/journal.c

2007

byte_count >> SECTOR_SHIFT,

fs/jbd2/journal.c

2011

byte_start >> SECTOR_SHIFT,

fs/jbd2/journal.c

2012

byte_count >> SECTOR_SHIFT,

fs/nfs/blocklayout/blocklayout.c

140

disk_addr = (u64)isect << SECTOR_SHIFT;

fs/nfs/blocklayout/blocklayout.c

157

bio->bi_iter.bi_sector = disk_addr >> SECTOR_SHIFT;

fs/nfs/blocklayout/blocklayout.c

175

isect = header->args.offset >> SECTOR_SHIFT;

fs/nfs/blocklayout/blocklayout.c

176

bytes_left += header->args.offset - (isect << SECTOR_SHIFT);

fs/nfs/blocklayout/blocklayout.c

184

if (bytes_left > extent_length << SECTOR_SHIFT)

fs/nfs/blocklayout/blocklayout.c

185

bytes_left -= extent_length << SECTOR_SHIFT;

fs/nfs/blocklayout/blocklayout.c

257

isect = (sector_t) (f_offset >> SECTOR_SHIFT);

fs/nfs/blocklayout/blocklayout.c

303

isect += (pg_len >> SECTOR_SHIFT);

fs/nfs/blocklayout/blocklayout.c

304

extent_length -= (pg_len >> SECTOR_SHIFT);

fs/nfs/blocklayout/blocklayout.c

309

if ((isect << SECTOR_SHIFT) >= header->inode->i_size) {

fs/nfs/blocklayout/blocklayout.c

313

header->res.count = (isect << SECTOR_SHIFT) - header->args.offset;

fs/nfs/blocklayout/blocklayout.c

355

ext_tree_mark_written(bl, start >> SECTOR_SHIFT,

fs/nfs/blocklayout/blocklayout.c

356

(end - start) >> SECTOR_SHIFT, lwb);

fs/nfs/blocklayout/blocklayout.c

404

isect = offset >> SECTOR_SHIFT;

fs/nfs/blocklayout/blocklayout.c

430

isect += (pg_len >> SECTOR_SHIFT);

fs/nfs/blocklayout/blocklayout.c

431

extent_length -= (pg_len >> SECTOR_SHIFT);

fs/nfs/blocklayout/blocklayout.c

554

*sp = s >> SECTOR_SHIFT;

fs/nfs/blocklayout/blocklayout.c

668

.start = lgr->range.offset >> SECTOR_SHIFT,

fs/nfs/blocklayout/blocklayout.c

669

.inval = lgr->range.offset >> SECTOR_SHIFT,

fs/nfs/blocklayout/blocklayout.c

670

.cowread = lgr->range.offset >> SECTOR_SHIFT,

fs/nfs/blocklayout/blocklayout.c

716

lv.start << SECTOR_SHIFT) {

fs/nfs/blocklayout/blocklayout.c

765

sector_t offset = range->offset >> SECTOR_SHIFT, end;

fs/nfs/blocklayout/blocklayout.c

780

end = offset + (range->length >> SECTOR_SHIFT);

fs/nfs/blocklayout/blocklayout.h

43

#define PAGE_CACHE_SECTORS (PAGE_SIZE >> SECTOR_SHIFT)

fs/nfs/blocklayout/blocklayout.h

44

#define PAGE_CACHE_SECTOR_SHIFT (PAGE_SHIFT - SECTOR_SHIFT)

fs/nfs/blocklayout/blocklayout.h

45

#define SECTOR_SIZE (1 << SECTOR_SHIFT)

fs/nfs/blocklayout/extent_tree.c

511

p = xdr_encode_hyper(p, be->be_f_offset << SECTOR_SHIFT);

fs/nfs/blocklayout/extent_tree.c

512

p = xdr_encode_hyper(p, be->be_length << SECTOR_SHIFT);

fs/nfs/blocklayout/extent_tree.c

520

p = xdr_encode_hyper(p, be->be_f_offset << SECTOR_SHIFT);

fs/nfs/blocklayout/extent_tree.c

521

return xdr_encode_hyper(p, be->be_length << SECTOR_SHIFT);

fs/nfs/blocklayout/extent_tree.c

616

*lastbyte <<= SECTOR_SHIFT;

fs/ntfs/bdev-io.c

37

sector_t sector = start >> SECTOR_SHIFT;

fs/ntfs/iomap.c

347

offset >> SECTOR_SHIFT,

fs/ntfs/iomap.c

348

length >> SECTOR_SHIFT,

fs/ntfs/lcnalloc.c

1001

gran) >> SECTOR_SHIFT;

fs/ntfs/lcnalloc.c

1004

gran) >> SECTOR_SHIFT;

fs/ntfs3/attrib.c

216

u8 shift = sbi->cluster_bits - SECTOR_SHIFT;

fs/ntfs3/fslog.c

1369

sizeof(short) * ((log->page_size >> SECTOR_SHIFT) + 1),

fs/ntfs3/fslog.c

1381

((log->sys_page_size >> SECTOR_SHIFT) + 1),

fs/ntfs3/fslog.c

2675

fo = (SECTOR_SIZE - ((bytes >> SECTOR_SHIFT) + 1) * sizeof(short));

fs/ntfs3/fslog.c

2695

SECTOR_SHIFT;

fs/ntfs3/fslog.c

2823

fo > (SECTOR_SIZE - ((rs >> SECTOR_SHIFT) + 1) * sizeof(short)) ||

fs/ntfs3/fslog.c

3117

u64 cbo = (u64)le16_to_cpu(lrh->cluster_off) << SECTOR_SHIFT;

fs/ntfs3/fslog.c

455

end_usa = ((sys_page >> SECTOR_SHIFT) + 1) * sizeof(short);

fs/ntfs3/fslog.c

5096

voff += le16_to_cpu(lrh->cluster_off) << SECTOR_SHIFT;

fs/ntfs3/fslog.c

5284

t16 = (log->page_size >> SECTOR_SHIFT) + 1;

fs/ntfs3/fsntfs.c

176

fn = simple ? ((bytes >> SECTOR_SHIFT) + 1) :

fs/ntfs3/index.c

680

fn != ((bytes >> SECTOR_SHIFT) + 1)) {

fs/ntfs3/index.c

939

if ((sbi->cluster_size >> SECTOR_SHIFT) &

fs/ntfs3/index.c

944

indx->vbn2vbo_bits = SECTOR_SHIFT;

fs/ntfs3/index.c

997

fn = (bytes >> SECTOR_SHIFT) + 1; // 9

fs/ntfs3/ntfs.h

71

static_assert(SECTOR_SHIFT == 9);

fs/ntfs3/ntfs_fs.h

128

struct buffer_head *bh[PAGE_SIZE >> SECTOR_SHIFT];

fs/ntfs3/super.c

1127

ALIGN(((record_size >> SECTOR_SHIFT) * sizeof(short)), 8) -

fs/ntfs3/super.c

1169

fn = (sbi->record_size >> SECTOR_SHIFT) + 1;

fs/squashfs/block.c

235

bio->bi_iter.bi_sector = block * (msblk->devblksize >> SECTOR_SHIFT);

fs/xfs/scrub/trace.h

1018

__entry->bytes_used = inode->i_blocks << SECTOR_SHIFT;

fs/xfs/scrub/trace.h

995

__entry->bytes = inode->i_blocks << SECTOR_SHIFT;

fs/xfs/scrub/xfile.h

32

return file_inode(xf->file)->i_blocks << SECTOR_SHIFT;

fs/xfs/xfs_trace.h

5148

__entry->bytes = (inode->i_blocks << SECTOR_SHIFT) + inode->i_bytes;

fs/xfs/xfs_verify_media.c

185

BUILD_BUG_ON(BBSHIFT != SECTOR_SHIFT);

fs/xfs/xfs_verify_media.c

348

min(bbcount << SECTOR_SHIFT, folio_size(folio)),

fs/xfs/xfs_verify_media.c

356

bio_bbcount = bio->bi_iter.bi_size >> SECTOR_SHIFT;

fs/xfs/xfs_zone_gc.c

804

lim->max_zone_append_sectors << SECTOR_SHIFT);

fs/xfs/xfs_zone_gc.c

809

split_sectors = ALIGN_DOWN(split_sectors << SECTOR_SHIFT,

fs/xfs/xfs_zone_gc.c

810

data->mp->m_sb.sb_blocksize) >> SECTOR_SHIFT;

fs/xfs/xfs_zone_gc.c

811

split_len = split_sectors << SECTOR_SHIFT;

fs/zonefs/file.c

50

iomap->addr = (z->z_sector << SECTOR_SHIFT) + iomap->offset;

fs/zonefs/file.c

93

iomap->addr = (z->z_sector << SECTOR_SHIFT) + iomap->offset;

fs/zonefs/super.c

1000

z->z_size = zone->len << SECTOR_SHIFT;

fs/zonefs/super.c

1001

if (z->z_size > bdev_zone_sectors(sb->s_bdev) << SECTOR_SHIFT &&

fs/zonefs/super.c

1006

bdev_zone_sectors(sb->s_bdev) << SECTOR_SHIFT);

fs/zonefs/super.c

1011

zone->capacity << SECTOR_SHIFT);

fs/zonefs/super.c

117

z->z_size >> SECTOR_SHIFT);

fs/zonefs/super.c

221

return (zone->wp - zone->start) << SECTOR_SHIFT;

fs/zonefs/super.c

383

zone.len = z->z_size >> SECTOR_SHIFT;

fs/zonefs/super.c

663

inode->i_blocks = z->z_capacity >> SECTOR_SHIFT;

fs/zonefs/trace.h

39

__entry->nr_sectors = z->z_size >> SECTOR_SHIFT;

include/linux/blk-mq.h

1142

return blk_rq_bytes(rq) >> SECTOR_SHIFT;

include/linux/blk-mq.h

1147

return blk_rq_cur_bytes(rq) >> SECTOR_SHIFT;

include/linux/blk_types.h

291

#define BIO_MAX_SECTORS (BIO_MAX_SIZE >> SECTOR_SHIFT)

include/linux/blk_types.h

30

#ifndef SECTOR_SHIFT

include/linux/blk_types.h

34

#define SECTOR_SIZE (1 << SECTOR_SHIFT)

include/linux/blk_types.h

37

#define PAGE_SECTORS_SHIFT (PAGE_SHIFT - SECTOR_SHIFT)

include/linux/blkdev.h

1295

SECTOR_SHIFT),

include/linux/blkdev.h

1297

SECTOR_SHIFT),

include/linux/blkdev.h

1305

SECTOR_SHIFT),

include/linux/blkdev.h

1307

SECTOR_SHIFT),

include/linux/blkdev.h

1596

return q->limits.atomic_write_boundary_sectors << SECTOR_SHIFT;

include/linux/blkdev.h

1602

return q->limits.atomic_write_max_sectors << SECTOR_SHIFT;

include/linux/blkdev.h

1627

return order_base_2(size >> SECTOR_SHIFT) + SECTOR_SHIFT;

include/linux/blkdev.h

1855

return IS_ALIGNED(sector, alignment >> SECTOR_SHIFT);

include/linux/blkdev.h

857

return (loff_t)bdev_nr_sectors(bdev) << SECTOR_SHIFT;

include/linux/blkdev.h

868

(sb->s_blocksize_bits - SECTOR_SHIFT);

include/linux/device-mapper.h

750

return (n >> SECTOR_SHIFT);

include/linux/device-mapper.h

755

return (n << SECTOR_SHIFT);

include/linux/iomap.h

146

return (iomap->addr + pos - iomap->offset) >> SECTOR_SHIFT;

include/linux/t10-pi.h

36

return blk_rq_pos(rq) >> (shift - SECTOR_SHIFT);

include/scsi/scsi_cmnd.h

230

unsigned int shift = ilog2(scmd->device->sector_size) - SECTOR_SHIFT;

include/trace/events/btrfs.h

3282

__entry->physical = bio->bi_iter.bi_sector << SECTOR_SHIFT;

kernel/trace/blktrace.c

1189

__blk_add_trace(bt, sector, sectors << SECTOR_SHIFT, 0,

kernel/trace/blktrace.c

1205

__blk_add_trace(bt, sector, sectors << SECTOR_SHIFT, 0,