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

506

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

block/bio-integrity.c

318

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

214

nr_sects << SECTOR_SHIFT);

block/blk-lib.c

217

nr_sects -= len >> SECTOR_SHIFT;

block/blk-lib.c

218

sector += len >> SECTOR_SHIFT;

block/blk-lib.c

22

round_up(sector, discard_granularity >> SECTOR_SHIFT);

block/blk-lib.c

35

return round_down(BIO_MAX_SIZE, discard_granularity) >> SECTOR_SHIFT;

block/blk-lib.c

355

bio->bi_iter.bi_size = len << 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

659

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

block/blk-merge.c

104

SECTOR_SHIFT;

block/blk-merge.c

234

unsigned pbs = lim->physical_block_size >> SECTOR_SHIFT;

block/blk-merge.c

235

unsigned lbs = lim->logical_block_size >> SECTOR_SHIFT;

block/blk-merge.c

419

return bytes >> SECTOR_SHIFT;

block/blk-merge.c

428

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

block/blk-merge.c

444

lim->max_zone_append_sectors << SECTOR_SHIFT);

block/blk-mq.c

3123

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

block/blk-settings.c

198

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

block/blk-settings.c

220

max_integrity_io_size(lim) >> SECTOR_SHIFT);

block/blk-settings.c

246

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

block/blk-settings.c

252

min(lim->atomic_write_hw_max >> SECTOR_SHIFT,

block/blk-settings.c

259

lim->atomic_write_hw_boundary >> SECTOR_SHIFT;

block/blk-settings.c

287

lim->atomic_write_hw_max >> SECTOR_SHIFT;

block/blk-settings.c

317

boundary_sectors = lim->atomic_write_hw_boundary >> SECTOR_SHIFT;

block/blk-settings.c

404

logical_block_sectors = lim->logical_block_size >> SECTOR_SHIFT;

block/blk-settings.c

422

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

block/blk-settings.c

424

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

block/blk-settings.c

425

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

block/blk-settings.c

427

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

block/blk-settings.c

633

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

block/blk-settings.c

634

<< SECTOR_SHIFT;

block/blk-settings.c

648

alignment = lim->discard_alignment >> SECTOR_SHIFT;

block/blk-settings.c

649

granularity = lim->discard_granularity >> SECTOR_SHIFT;

block/blk-settings.c

658

return offset << SECTOR_SHIFT;

block/blk-settings.c

663

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

block/blk-settings.c

664

if (sectors < PAGE_SIZE >> SECTOR_SHIFT)

block/blk-settings.c

665

sectors = PAGE_SIZE >> SECTOR_SHIFT;

block/blk-settings.c

706

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

block/blk-settings.c

732

b->atomic_write_hw_boundary >> SECTOR_SHIFT))

block/blk-settings.c

80

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

block/blk-settings.c

899

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

block/blk-sysfs.c

243

SECTOR_SHIFT); \

block/blk-sysfs.c

288

if ((max_discard_bytes >> SECTOR_SHIFT) > UINT_MAX)

block/blk-sysfs.c

291

lim->max_user_discard_sectors = max_discard_bytes >> SECTOR_SHIFT;

block/blk-sysfs.c

305

max_hw_zeroes_bytes = lim->max_hw_wzeroes_unmap_sectors << SECTOR_SHIFT;

block/blk-sysfs.c

309

lim->max_user_wzeroes_unmap_sectors = max_zeroes_bytes >> SECTOR_SHIFT;

block/blk-zoned.c

425

start = zrange->sector << SECTOR_SHIFT;

block/blk-zoned.c

426

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

block/blk.h

213

UINT_MAX >> SECTOR_SHIFT);

block/blk.h

217

UINT_MAX >> SECTOR_SHIFT);

block/blk.h

23

#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

338

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

block/fops.c

80

bio.bi_iter.bi_sector = pos >> SECTOR_SHIFT;

block/fops.c

934

error = blkdev_issue_zeroout(bdev, start >> SECTOR_SHIFT,

block/fops.c

935

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

901

sector_t sector = start >> SECTOR_SHIFT;

block/ioctl.c

902

sector_t nr_sects = len >> SECTOR_SHIFT;

drivers/ata/libata-scsi.c

2227

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

1274

queue_max_hw_sectors(b) << SECTOR_SHIFT;

drivers/block/drbd/drbd_nl.c

1303

lim.max_hw_sectors = new >> SECTOR_SHIFT;

drivers/block/drbd/drbd_nl.c

1353

if ((lim.discard_granularity >> SECTOR_SHIFT) >

drivers/block/n64cart.c

150

set_capacity(disk, size >> SECTOR_SHIFT);

drivers/block/n64cart.c

92

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

drivers/block/nbd.c

1911

.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

3502

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

drivers/block/rbd.c

4744

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

drivers/block/rbd.c

4964

.max_hw_sectors = objset_bytes >> SECTOR_SHIFT,

drivers/block/rbd.c

4985

lim.max_hw_discard_sectors = objset_bytes >> SECTOR_SHIFT;

drivers/block/rbd.c

4986

lim.max_write_zeroes_sectors = objset_bytes >> SECTOR_SHIFT;

drivers/block/rbd.c

7175

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

drivers/block/rbd.c

945

if (ondisk->options.order < SECTOR_SHIFT)

drivers/block/ublk_drv.c

518

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

drivers/block/ublk_drv.c

936

if (p->interval_exp < SECTOR_SHIFT ||

drivers/block/virtio_blk.c

1408

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

776

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

drivers/block/zloop.c

1133

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

drivers/block/zloop.c

1269

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

drivers/block/zloop.c

1283

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

drivers/block/zloop.c

1296

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

drivers/block/zloop.c

174

file_sectors = stat.size >> SECTOR_SHIFT;

drivers/block/zloop.c

181

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

drivers/block/zloop.c

343

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

drivers/block/zloop.c

525

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

drivers/block/zloop.c

56

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

drivers/block/zloop.c

873

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

drivers/block/zloop.c

927

file_sectors = stat.size >> SECTOR_SHIFT;

drivers/block/zloop.c

936

zlo->zone_size << SECTOR_SHIFT);

drivers/block/zloop.c

993

.max_hw_sectors = SZ_1M >> SECTOR_SHIFT,

drivers/block/zram/zram_drv.c

2686

SECTOR_SHIFT;

drivers/block/zram/zram_drv.c

2726

SECTOR_SHIFT;

drivers/block/zram/zram_drv.c

2757

SECTOR_SHIFT;

drivers/block/zram/zram_drv.c

2912

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

2319

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

drivers/md/dm-bufio.c

2410

retain_bytes >>= c->sectors_per_block_bits + SECTOR_SHIFT;

drivers/md/dm-bufio.c

2507

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

drivers/md/dm-bufio.c

2524

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

drivers/md/dm-cache-metadata.c

1791

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

3477

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

drivers/md/dm-cache-target.c

3493

uint64_t io_opt_sectors = limits->io_opt >> SECTOR_SHIFT;

drivers/md/dm-cache-target.c

3501

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

drivers/md/dm-cache-target.c

3502

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

1553

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

drivers/md/dm-crypt.c

282

return val >> SECTOR_SHIFT;

drivers/md/dm-crypt.c

3177

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

drivers/md/dm-crypt.c

3183

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

drivers/md/dm-crypt.c

3187

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

drivers/md/dm-crypt.c

3246

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

drivers/md/dm-crypt.c

3328

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

drivers/md/dm-crypt.c

3497

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

drivers/md/dm-crypt.c

3578

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

drivers/md/dm-crypt.c

3597

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

drivers/md/dm-crypt.c

3623

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

drivers/md/dm-crypt.c

471

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

drivers/md/dm-crypt.c

598

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

drivers/md/dm-crypt.c

660

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

1660

(unsigned int) (DM_ERA_METADATA_BLOCK_SIZE >> SECTOR_SHIFT),

drivers/md/dm-era-target.c

1728

uint64_t io_opt_sectors = limits->io_opt >> SECTOR_SHIFT;

drivers/md/dm-era-target.c

1737

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

1624

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

drivers/md/dm-integrity.c

1677

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

drivers/md/dm-integrity.c

1741

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

drivers/md/dm-integrity.c

1742

nbytes += ic->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-integrity.c

1836

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

drivers/md/dm-integrity.c

1840

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

drivers/md/dm-integrity.c

1866

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

drivers/md/dm-integrity.c

1869

pos += ic->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-integrity.c

1900

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

drivers/md/dm-integrity.c

1921

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

drivers/md/dm-integrity.c

1932

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

drivers/md/dm-integrity.c

1956

pos += ic->sectors_per_block << SECTOR_SHIFT;

drivers/md/dm-integrity.c

2040

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

drivers/md/dm-integrity.c

2149

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

drivers/md/dm-integrity.c

2150

bv.bv_len = n_sectors << SECTOR_SHIFT;

drivers/md/dm-integrity.c

2151

n_sectors -= bv.bv_len >> SECTOR_SHIFT;

drivers/md/dm-integrity.c

2182

mem_ptr += 1 << SECTOR_SHIFT;

drivers/md/dm-integrity.c

2216

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

drivers/md/dm-integrity.c

2248

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

drivers/md/dm-integrity.c

2249

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

drivers/md/dm-integrity.c

2462

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

drivers/md/dm-integrity.c

2613

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

drivers/md/dm-integrity.c

2661

ic->sectors_per_block << SECTOR_SHIFT);

drivers/md/dm-integrity.c

2705

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

drivers/md/dm-integrity.c

2708

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

drivers/md/dm-integrity.c

2734

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

drivers/md/dm-integrity.c

3134

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

drivers/md/dm-integrity.c

3230

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

drivers/md/dm-integrity.c

3298

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

drivers/md/dm-integrity.c

3345

range.n_sectors << SECTOR_SHIFT);

drivers/md/dm-integrity.c

3355

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

drivers/md/dm-integrity.c

3366

range.n_sectors << SECTOR_SHIFT);

drivers/md/dm-integrity.c

3450

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

drivers/md/dm-integrity.c

3451

BITMAP_BLOCK_SIZE >> SECTOR_SHIFT, NULL);

drivers/md/dm-integrity.c

3496

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

3819

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

drivers/md/dm-integrity.c

3831

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

drivers/md/dm-integrity.c

3850

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

drivers/md/dm-integrity.c

3894

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

drivers/md/dm-integrity.c

3964

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

drivers/md/dm-integrity.c

4015

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

drivers/md/dm-integrity.c

4050

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

drivers/md/dm-integrity.c

4051

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

drivers/md/dm-integrity.c

4052

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

drivers/md/dm-integrity.c

4054

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

drivers/md/dm-integrity.c

4064

ic->sb->log2_sectors_per_block + SECTOR_SHIFT;

drivers/md/dm-integrity.c

4105

(__u64)(METADATA_PADDING_SECTORS << SECTOR_SHIFT) :

drivers/md/dm-integrity.c

4106

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

drivers/md/dm-integrity.c

4109

metadata_run_padding) >> SECTOR_SHIFT;

drivers/md/dm-integrity.c

4122

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

drivers/md/dm-integrity.c

4123

>> (ic->log2_buffer_sectors + SECTOR_SHIFT);

drivers/md/dm-integrity.c

4160

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

drivers/md/dm-integrity.c

4313

end = end_offset + (1 << SECTOR_SHIFT);

drivers/md/dm-integrity.c

4430

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

4615

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

drivers/md/dm-integrity.c

4799

if (val < 1 << SECTOR_SHIFT ||

drivers/md/dm-integrity.c

4800

val > MAX_SECTORS_PER_BLOCK << SECTOR_SHIFT ||

drivers/md/dm-integrity.c

4806

ic->sectors_per_block = val >> SECTOR_SHIFT;

drivers/md/dm-integrity.c

4864

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

drivers/md/dm-integrity.c

4948

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

drivers/md/dm-integrity.c

5053

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

5068

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

5163

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

drivers/md/dm-integrity.c

5241

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

drivers/md/dm-integrity.c

5291

sector = i * (BITMAP_BLOCK_SIZE >> SECTOR_SHIFT);

drivers/md/dm-integrity.c

5292

pl_index = sector >> (PAGE_SHIFT - SECTOR_SHIFT);

drivers/md/dm-integrity.c

5293

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

drivers/md/dm-integrity.c

5411

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

449

dm_round_up((LOG_OFFSET << SECTOR_SHIFT) + bitset_size,

drivers/md/dm-log.c

459

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

drivers/md/dm-log.c

481

(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

378

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

789

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

84

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

570

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

drivers/md/dm-verity-fec.c

571

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

drivers/md/dm-verity-fec.c

579

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

drivers/md/dm-verity-fec.c

580

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

drivers/md/dm-verity-fec.c

707

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

drivers/md/dm-verity-fec.c

709

fec_blocks = div64_u64(f->rounds * f->roots, v->fec->roots << SECTOR_SHIFT);

drivers/md/dm-verity-target.c

1507

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

drivers/md/dm-verity-target.c

1508

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

drivers/md/dm-verity-target.c

1515

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

drivers/md/dm-verity-target.c

1522

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

drivers/md/dm-verity-target.c

1523

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

drivers/md/dm-verity-target.c

394

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

drivers/md/dm-verity-target.c

395

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

drivers/md/dm-verity-target.c

794

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

drivers/md/dm-verity-target.c

800

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

drivers/md/dm-verity-target.c

811

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

1867

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

drivers/md/dm-writecache.c

1905

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

drivers/md/dm-writecache.c

1919

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

drivers/md/dm-writecache.c

2048

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

drivers/md/dm-writecache.c

2412

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

drivers/md/dm-writecache.c

2522

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

drivers/md/dm-writecache.c

2564

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

drivers/md/dm-writecache.c

2574

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

drivers/md/dm-writecache.c

2641

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

1337

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

drivers/md/md-llbitmap.c

1020

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

drivers/md/md-llbitmap.c

494

sector_t bit_sector = llbitmap->io_size >> SECTOR_SHIFT;

drivers/md/md-llbitmap.c

781

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

drivers/md/md-llbitmap.c

870

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/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

1066

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

drivers/nvdimm/btt.c

1275

sector += btt->sector_size >> SECTOR_SHIFT;

drivers/nvdimm/btt.c

1405

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

2065

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

drivers/nvme/host/core.c

976

u64 start = blk_rq_pos(req) << SECTOR_SHIFT;

drivers/nvme/host/multipath.c

1350

size_t max_transfer_size = ctrl->max_hw_sectors << SECTOR_SHIFT;

drivers/nvme/host/multipath.c

211

blk_rq_bytes(rq) >> SECTOR_SHIFT,

drivers/nvme/host/nvme.h

746

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

drivers/nvme/host/nvme.h

754

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

drivers/nvme/host/pci.c

3698

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

213

(bi->interval_exp - SECTOR_SHIFT));

drivers/nvme/target/nvmet.h

853

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

drivers/nvme/target/nvmet.h

858

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

drivers/nvme/target/zns.c

549

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/scsi_transport_sas.c

244

dma_opt_mapping_size(dma_dev) >> SECTOR_SHIFT);

drivers/scsi/sd.c

1179

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

drivers/scsi/sd.c

172

(logical_block_size >> SECTOR_SHIFT);

drivers/scsi/sd.c

3815

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

440

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

drivers/vdpa/vdpa_sim/vdpa_sim_blk.c

498

shared_buffer = kvzalloc(VDPASIM_BLK_CAPACITY << SECTOR_SHIFT,

fs/btrfs/bio.c

1008

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

fs/btrfs/bio.c

188

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

fs/btrfs/bio.c

253

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

fs/btrfs/bio.c

281

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

fs/btrfs/bio.c

447

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

fs/btrfs/bio.c

471

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

fs/btrfs/bio.c

489

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

fs/btrfs/bio.c

509

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

fs/btrfs/bio.c

554

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

fs/btrfs/bio.c

566

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

fs/btrfs/bio.c

741

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

fs/btrfs/bio.c

751

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

fs/btrfs/bio.c

86

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

fs/btrfs/bio.c

880

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

fs/btrfs/bio.c

975

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

fs/btrfs/bio.c

992

smap.physical >> SECTOR_SHIFT);

fs/btrfs/compression.c

334

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

fs/btrfs/compression.c

475

(btrfs_extent_map_block_start(em) >> SECTOR_SHIFT) !=

fs/btrfs/direct-io.c

675

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

fs/btrfs/disk-io.c

3838

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

2255

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

fs/btrfs/extent_io.c

3907

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

fs/btrfs/extent_io.c

720

const sector_t sector = disk_bytenr >> SECTOR_SHIFT;

fs/btrfs/extent_io.c

747

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

fs/btrfs/file-item.c

355

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

fs/btrfs/file-item.c

859

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

fs/btrfs/inode.c

1200

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

fs/btrfs/inode.c

8272

ALIGN(delalloc_bytes, blocksize)) >> SECTOR_SHIFT;

fs/btrfs/inode.c

9604

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

fs/btrfs/inode.c

9615

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

fs/btrfs/raid56.c

1280

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

fs/btrfs/raid56.c

1299

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

fs/btrfs/raid56.c

1315

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

fs/btrfs/raid56.c

1362

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

fs/btrfs/raid56.c

1567

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

fs/btrfs/raid56.c

1837

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

fs/btrfs/relocation.c

4003

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

fs/btrfs/relocation.c

4017

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

fs/btrfs/scrub.c

1312

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

fs/btrfs/scrub.c

2132

bio.bi_iter.bi_sector = full_stripe_start >> SECTOR_SHIFT;

fs/btrfs/scrub.c

2959

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

fs/btrfs/scrub.c

954

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

fs/btrfs/zoned.c

1029

sb_zone = sb_zone_number(zone_sectors_shift + SECTOR_SHIFT, mirror);

fs/btrfs/zoned.c

1157

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

1359

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

fs/btrfs/zoned.c

1362

info->capacity = capacity << SECTOR_SHIFT;

fs/btrfs/zoned.c

1381

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

fs/btrfs/zoned.c

1387

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

fs/btrfs/zoned.c

1406

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

fs/btrfs/zoned.c

159

*wp_ret = sector << SECTOR_SHIFT;

fs/btrfs/zoned.c

202

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

fs/btrfs/zoned.c

2028

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

fs/btrfs/zoned.c

206

pos >>= SECTOR_SHIFT;

fs/btrfs/zoned.c

2067

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

fs/btrfs/zoned.c

2289

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

fs/btrfs/zoned.c

2290

length >> SECTOR_SHIFT, GFP_NOFS, 0);

fs/btrfs/zoned.c

2357

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

fs/btrfs/zoned.c

2499

physical >> SECTOR_SHIFT,

fs/btrfs/zoned.c

2500

zinfo->zone_size >> SECTOR_SHIFT);

fs/btrfs/zoned.c

269

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

fs/btrfs/zoned.c

3093

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

fs/btrfs/zoned.c

3157

stripe->physical >> SECTOR_SHIFT,

fs/btrfs/zoned.c

396

zone_sectors = fs_info->zone_size >> SECTOR_SHIFT;

fs/btrfs/zoned.c

402

zone_info->zone_size = zone_sectors << SECTOR_SHIFT;

fs/btrfs/zoned.c

486

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

764

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

fs/btrfs/zoned.c

765

(u64)lim->max_sectors << SECTOR_SHIFT,

fs/btrfs/zoned.c

821

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

fs/btrfs/zoned.c

832

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

fs/btrfs/zoned.c

834

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

fs/btrfs/zoned.c

859

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

fs/btrfs/zoned.c

861

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

fs/btrfs/zoned.c

864

wp = ALIGN_DOWN(zone_end << SECTOR_SHIFT,

fs/btrfs/zoned.c

900

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

102

sector += (bytes_this_page >> SECTOR_SHIFT);

fs/crypto/bio.c

144

sector_t sector = pblk << (inode->i_blkbits - SECTOR_SHIFT);

fs/crypto/bio.c

195

sector += 1U << (du_bits - 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/f2fs/segment.c

5307

unsigned int log_sectors_per_block = sbi->log_blocksize - SECTOR_SHIFT;

fs/f2fs/segment.c

5411

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

233

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

382

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

fs/iomap/ioend.c

449

lim->max_zone_append_sectors << SECTOR_SHIFT);

fs/iomap/ioend.c

459

sector_offset = max_len >> SECTOR_SHIFT;

fs/iomap/ioend.c

463

sector_offset = ALIGN_DOWN(sector_offset << SECTOR_SHIFT,

fs/iomap/ioend.c

464

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

fs/iomap/ioend.c

482

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

fs/jbd2/journal.c

2010

byte_start >> SECTOR_SHIFT,

fs/jbd2/journal.c

2011

byte_count >> SECTOR_SHIFT,

fs/jbd2/journal.c

2015

byte_start >> SECTOR_SHIFT,

fs/jbd2/journal.c

2016

byte_count >> SECTOR_SHIFT,

fs/nfs/blocklayout/blocklayout.c

141

disk_addr = (u64)isect << SECTOR_SHIFT;

fs/nfs/blocklayout/blocklayout.c

158

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

fs/nfs/blocklayout/blocklayout.c

176

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

fs/nfs/blocklayout/blocklayout.c

177

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

fs/nfs/blocklayout/blocklayout.c

185

if (bytes_left > extent_length << SECTOR_SHIFT)

fs/nfs/blocklayout/blocklayout.c

186

bytes_left -= extent_length << SECTOR_SHIFT;

fs/nfs/blocklayout/blocklayout.c

258

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

fs/nfs/blocklayout/blocklayout.c

304

isect += (pg_len >> SECTOR_SHIFT);

fs/nfs/blocklayout/blocklayout.c

305

extent_length -= (pg_len >> SECTOR_SHIFT);

fs/nfs/blocklayout/blocklayout.c

310

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

fs/nfs/blocklayout/blocklayout.c

314

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

fs/nfs/blocklayout/blocklayout.c

356

ext_tree_mark_written(bl, start >> SECTOR_SHIFT,

fs/nfs/blocklayout/blocklayout.c

357

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

fs/nfs/blocklayout/blocklayout.c

406

isect = offset >> SECTOR_SHIFT;

fs/nfs/blocklayout/blocklayout.c

433

isect += (pg_len >> SECTOR_SHIFT);

fs/nfs/blocklayout/blocklayout.c

434

extent_length -= (pg_len >> SECTOR_SHIFT);

fs/nfs/blocklayout/blocklayout.c

557

*sp = s >> SECTOR_SHIFT;

fs/nfs/blocklayout/blocklayout.c

671

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

fs/nfs/blocklayout/blocklayout.c

672

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

fs/nfs/blocklayout/blocklayout.c

673

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

fs/nfs/blocklayout/blocklayout.c

719

lv.start << SECTOR_SHIFT) {

fs/nfs/blocklayout/blocklayout.c

768

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

fs/nfs/blocklayout/blocklayout.c

783

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/ntfs3/attrib.c

216

u8 shift = sbi->cluster_bits - SECTOR_SHIFT;

fs/ntfs3/fslog.c

1358

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

fs/ntfs3/fslog.c

1370

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

fs/ntfs3/fslog.c

2650

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

fs/ntfs3/fslog.c

2670

SECTOR_SHIFT;

fs/ntfs3/fslog.c

2797

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

fs/ntfs3/fslog.c

3082

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

4965

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

fs/ntfs3/fslog.c

5153

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

fs/ntfs3/fsntfs.c

176

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

fs/ntfs3/index.c

645

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

fs/ntfs3/index.c

902

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

fs/ntfs3/index.c

907

indx->vbn2vbo_bits = SECTOR_SHIFT;

fs/ntfs3/index.c

964

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

1134

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

fs/ntfs3/super.c

1176

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

5149

__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

766

lim->max_zone_append_sectors << SECTOR_SHIFT);

fs/xfs/xfs_zone_gc.c

771

split_sectors = ALIGN_DOWN(split_sectors << SECTOR_SHIFT,

fs/xfs/xfs_zone_gc.c

772

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

fs/xfs/xfs_zone_gc.c

773

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

1002

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

fs/zonefs/super.c

1007

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

659

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

fs/zonefs/super.c

996

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

fs/zonefs/super.c

997

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

fs/zonefs/trace.h

39

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

include/linux/blk-mq.h

1133

return blk_rq_bytes(rq) >> SECTOR_SHIFT;

include/linux/blk-mq.h

1138

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

1282

SECTOR_SHIFT),

include/linux/blkdev.h

1284

SECTOR_SHIFT),

include/linux/blkdev.h

1292

SECTOR_SHIFT),

include/linux/blkdev.h

1294

SECTOR_SHIFT),

include/linux/blkdev.h

1584

return q->limits.atomic_write_boundary_sectors << SECTOR_SHIFT;

include/linux/blkdev.h

1590

return q->limits.atomic_write_max_sectors << SECTOR_SHIFT;

include/linux/blkdev.h

1615

return order_base_2(size >> SECTOR_SHIFT) + SECTOR_SHIFT;

include/linux/blkdev.h

1839

return IS_ALIGNED(sector, alignment >> SECTOR_SHIFT);

include/linux/blkdev.h

842

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

include/linux/blkdev.h

853

(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

127

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

include/linux/t10-pi.h

47

return blk_rq_pos(rq) >> (shift - SECTOR_SHIFT) & 0xffffffff;

include/linux/t10-pi.h

72

return lower_48_bits(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

2413

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