arch/arm64/kvm/config.c

64

#define __NEEDS_FEAT_3(m, f, w, id, fld, lim) \

arch/arm64/kvm/config.c

72

.lo_lim = id ##_## fld ##_## lim \

arch/m68k/emu/nfblock.c

124

dev->disk = blk_alloc_disk(&lim, NUMA_NO_NODE);

arch/m68k/emu/nfblock.c

99

struct queue_limits lim = {

arch/powerpc/kernel/cacheinfo.c

238

int i, lim;

arch/powerpc/kernel/cacheinfo.c

240

lim = ARRAY_SIZE(cache_type_info[cache->type].line_size_props);

arch/powerpc/kernel/cacheinfo.c

242

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

arch/um/drivers/ubd_kern.c

832

struct queue_limits lim = {

arch/um/drivers/ubd_kern.c

844

lim.max_hw_sectors = 8 * sizeof(long);

arch/um/drivers/ubd_kern.c

846

lim.max_hw_discard_sectors = UBD_MAX_REQUEST;

arch/um/drivers/ubd_kern.c

847

lim.max_write_zeroes_sectors = UBD_MAX_REQUEST;

arch/um/drivers/ubd_kern.c

875

disk = blk_mq_alloc_disk(&ubd_dev->tag_set, &lim, ubd_dev);

arch/um/os-Linux/main.c

26

struct rlimit lim;

arch/um/os-Linux/main.c

28

if (getrlimit(RLIMIT_STACK, &lim) < 0) {

arch/um/os-Linux/main.c

32

if ((lim.rlim_cur == RLIM_INFINITY) || (lim.rlim_cur > STACKSIZE)) {

arch/um/os-Linux/main.c

33

lim.rlim_cur = STACKSIZE;

arch/um/os-Linux/main.c

34

if (setrlimit(RLIMIT_STACK, &lim) < 0) {

arch/um/os-Linux/start_up.c

372

struct rlimit lim;

arch/um/os-Linux/start_up.c

373

int err = getrlimit(RLIMIT_CORE, &lim);

arch/um/os-Linux/start_up.c

381

if (lim.rlim_cur == RLIM_INFINITY)

arch/um/os-Linux/start_up.c

384

os_info("%llu\n", (unsigned long long)lim.rlim_cur);

arch/um/os-Linux/start_up.c

387

if (lim.rlim_max == RLIM_INFINITY)

arch/um/os-Linux/start_up.c

390

os_info("%llu\n", (unsigned long long)lim.rlim_max);

arch/x86/kvm/emulate.c

646

u32 lim;

arch/x86/kvm/emulate.c

676

lim = desc_limit_scaled(&desc);

arch/x86/kvm/emulate.c

679

if (addr.ea <= lim)

arch/x86/kvm/emulate.c

681

lim = desc.d ? 0xffffffff : 0xffff;

arch/x86/kvm/emulate.c

683

if (addr.ea > lim)

arch/x86/kvm/emulate.c

685

if (lim == 0xffffffff)

arch/x86/kvm/emulate.c

688

*max_size = (u64)lim + 1 - addr.ea;

arch/xtensa/platforms/iss/simdisk.c

271

struct queue_limits lim = {

arch/xtensa/platforms/iss/simdisk.c

282

dev->gd = blk_alloc_disk(&lim, NUMA_NO_NODE);

block/blk-core.c

393

struct request_queue *blk_alloc_queue(struct queue_limits *lim, int node_id)

block/blk-core.c

417

error = blk_set_default_limits(lim);

block/blk-core.c

420

q->limits = *lim;

block/blk-integrity.c

230

struct queue_limits lim;

block/blk-integrity.c

239

lim = queue_limits_start_update(q);

block/blk-integrity.c

241

lim.integrity.flags &= ~flag;

block/blk-integrity.c

243

lim.integrity.flags |= flag;

block/blk-integrity.c

245

err = queue_limits_commit_update_frozen(q, &lim);

block/blk-map.c

428

const struct queue_limits *lim = &rq->q->limits;

block/blk-map.c

429

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

block/blk-map.c

434

ret = bio_split_io_at(bio, lim, &nr_segs, max_bytes, 0);

block/blk-merge.c

101

static unsigned int bio_allowed_max_sectors(const struct queue_limits *lim)

block/blk-merge.c

103

return round_down(BIO_MAX_SIZE, lim->logical_block_size) >>

block/blk-merge.c

162

const struct queue_limits *lim, unsigned *nsegs,

block/blk-merge.c

171

granularity = max(lim->discard_granularity >> 9, 1U);

block/blk-merge.c

173

max_discard_sectors = min(max_sectors, bio_allowed_max_sectors(lim));

block/blk-merge.c

188

((lim->discard_alignment >> 9) % granularity);

block/blk-merge.c

197

struct bio *bio_split_discard(struct bio *bio, const struct queue_limits *lim,

block/blk-merge.c

203

max_sectors = lim->max_secure_erase_sectors;

block/blk-merge.c

205

max_sectors = lim->max_discard_sectors;

block/blk-merge.c

207

return __bio_split_discard(bio, lim, nsegs, max_sectors);

block/blk-merge.c

210

static inline unsigned int blk_boundary_sectors(const struct queue_limits *lim,

block/blk-merge.c

217

if (is_atomic && lim->atomic_write_boundary_sectors)

block/blk-merge.c

218

return lim->atomic_write_boundary_sectors;

block/blk-merge.c

220

return lim->chunk_sectors;

block/blk-merge.c

232

const struct queue_limits *lim)

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

237

unsigned boundary_sectors = blk_boundary_sectors(lim, is_atomic);

block/blk-merge.c

245

max_sectors = lim->max_write_zeroes_sectors;

block/blk-merge.c

247

max_sectors = lim->atomic_write_max_sectors;

block/blk-merge.c

249

max_sectors = lim->max_sectors;

block/blk-merge.c

284

static bool bvec_split_segs(const struct queue_limits *lim,

block/blk-merge.c

294

seg_size = get_max_segment_size(lim, bvec_phys(bv) + total_len, len);

block/blk-merge.c

300

if ((bv->bv_offset + total_len) & lim->virt_boundary_mask)

block/blk-merge.c

311

const struct queue_limits *lim)

block/blk-merge.c

313

if (op_is_write(bio_op(bio)) && lim->zone_write_granularity)

block/blk-merge.c

314

return lim->zone_write_granularity;

block/blk-merge.c

315

return lim->logical_block_size;

block/blk-merge.c

337

int bio_split_io_at(struct bio *bio, const struct queue_limits *lim,

block/blk-merge.c

344

unsigned start_align_mask = lim->dma_alignment;

block/blk-merge.c

361

if (bvec_gap_to_prev(lim, bvprvp, bv.bv_offset))

block/blk-merge.c

366

if (nsegs < lim->max_segments &&

block/blk-merge.c

368

bv.bv_offset + bv.bv_len <= lim->max_fast_segment_size) {

block/blk-merge.c

372

if (bvec_split_segs(lim, &bv, &nsegs, &bytes,

block/blk-merge.c

373

lim->max_segments, max_bytes))

block/blk-merge.c

408

bytes = ALIGN_DOWN(bytes, bio_split_alignment(bio, lim));

block/blk-merge.c

423

struct bio *bio_split_rw(struct bio *bio, const struct queue_limits *lim,

block/blk-merge.c

427

bio_split_rw_at(bio, lim, nr_segs,

block/blk-merge.c

428

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

block/blk-merge.c

439

const struct queue_limits *lim, unsigned *nr_segs)

block/blk-merge.c

443

split_sectors = bio_split_rw_at(bio, lim, nr_segs,

block/blk-merge.c

444

lim->max_zone_append_sectors << SECTOR_SHIFT);

block/blk-merge.c

451

const struct queue_limits *lim, unsigned *nsegs)

block/blk-merge.c

453

unsigned int max_sectors = get_max_io_size(bio, lim);

block/blk-merge.c

526

struct queue_limits *lim = &q->limits;

block/blk-merge.c

533

boundary_sectors = blk_boundary_sectors(lim, is_atomic);

block/blk-mq.c

4417

struct queue_limits *lim, void *queuedata)

block/blk-mq.c

4423

if (!lim)

block/blk-mq.c

4424

lim = &default_lim;

block/blk-mq.c

4425

lim->features |= BLK_FEAT_IO_STAT | BLK_FEAT_NOWAIT;

block/blk-mq.c

4427

lim->features |= BLK_FEAT_POLL;

block/blk-mq.c

4429

q = blk_alloc_queue(lim, set->numa_node);

block/blk-mq.c

4470

struct queue_limits *lim, void *queuedata,

block/blk-mq.c

4476

q = blk_mq_alloc_queue(set, lim, queuedata);

block/blk-settings.c

106

if (lim->max_active_zones &&

block/blk-settings.c

107

lim->max_open_zones > lim->max_active_zones)

block/blk-settings.c

110

if (lim->zone_write_granularity < lim->logical_block_size)

block/blk-settings.c

111

lim->zone_write_granularity = lim->logical_block_size;

block/blk-settings.c

120

lim->max_zone_append_sectors =

block/blk-settings.c

121

min_not_zero(lim->max_hw_zone_append_sectors,

block/blk-settings.c

122

min(lim->chunk_sectors, lim->max_hw_sectors));

block/blk-settings.c

132

static inline unsigned int max_integrity_io_size(struct queue_limits *lim)

block/blk-settings.c

134

return min_t(unsigned int, lim->max_segment_size,

block/blk-settings.c

135

(BLK_INTEGRITY_MAX_SIZE / lim->integrity.metadata_size) <<

block/blk-settings.c

136

lim->integrity.interval_exp);

block/blk-settings.c

139

static int blk_validate_integrity_limits(struct queue_limits *lim)

block/blk-settings.c

141

struct blk_integrity *bi = &lim->integrity;

block/blk-settings.c

197

bi->interval_exp = ilog2(lim->logical_block_size);

block/blk-settings.c

199

bi->interval_exp > ilog2(lim->logical_block_size)) {

block/blk-settings.c

210

lim->dma_alignment = max(lim->dma_alignment,

block/blk-settings.c

219

lim->max_sectors = min(lim->max_sectors,

block/blk-settings.c

220

max_integrity_io_size(lim) >> SECTOR_SHIFT);

block/blk-settings.c

232

static unsigned int blk_queue_max_guaranteed_bio(struct queue_limits *lim)

block/blk-settings.c

234

unsigned int max_segments = min(BIO_MAX_VECS, lim->max_segments);

block/blk-settings.c

237

length = min(max_segments, 2) * lim->logical_block_size;

block/blk-settings.c

244

static void blk_atomic_writes_update_limits(struct queue_limits *lim)

block/blk-settings.c

246

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

block/blk-settings.c

247

blk_queue_max_guaranteed_bio(lim));

block/blk-settings.c

251

lim->atomic_write_max_sectors =

block/blk-settings.c

252

min(lim->atomic_write_hw_max >> SECTOR_SHIFT,

block/blk-settings.c

253

lim->max_hw_sectors);

block/blk-settings.c

254

lim->atomic_write_unit_min =

block/blk-settings.c

255

min(lim->atomic_write_hw_unit_min, unit_limit);

block/blk-settings.c

256

lim->atomic_write_unit_max =

block/blk-settings.c

257

min(lim->atomic_write_hw_unit_max, unit_limit);

block/blk-settings.c

258

lim->atomic_write_boundary_sectors =

block/blk-settings.c

259

lim->atomic_write_hw_boundary >> SECTOR_SHIFT;

block/blk-settings.c

283

static void blk_validate_atomic_write_limits(struct queue_limits *lim)

block/blk-settings.c

287

lim->atomic_write_hw_max >> SECTOR_SHIFT;

block/blk-settings.c

289

if (!(lim->features & BLK_FEAT_ATOMIC_WRITES))

block/blk-settings.c

293

if (lim->atomic_write_hw_max == UINT_MAX)

block/blk-settings.c

296

if (!lim->atomic_write_hw_max)

block/blk-settings.c

299

if (WARN_ON_ONCE(!is_power_of_2(lim->atomic_write_hw_unit_min)))

block/blk-settings.c

302

if (WARN_ON_ONCE(!is_power_of_2(lim->atomic_write_hw_unit_max)))

block/blk-settings.c

305

if (WARN_ON_ONCE(lim->atomic_write_hw_unit_min >

block/blk-settings.c

306

lim->atomic_write_hw_unit_max))

block/blk-settings.c

309

if (WARN_ON_ONCE(lim->atomic_write_hw_unit_max >

block/blk-settings.c

310

lim->atomic_write_hw_max))

block/blk-settings.c

313

if (WARN_ON_ONCE(lim->chunk_sectors &&

block/blk-settings.c

314

atomic_write_hw_max_sectors > lim->chunk_sectors))

block/blk-settings.c

317

boundary_sectors = lim->atomic_write_hw_boundary >> SECTOR_SHIFT;

block/blk-settings.c

320

if (WARN_ON_ONCE(lim->atomic_write_hw_max >

block/blk-settings.c

321

lim->atomic_write_hw_boundary))

block/blk-settings.c

325

lim->chunk_sectors, boundary_sectors)))

block/blk-settings.c

339

blk_atomic_writes_update_limits(lim);

block/blk-settings.c

343

lim->atomic_write_max_sectors = 0;

block/blk-settings.c

344

lim->atomic_write_boundary_sectors = 0;

block/blk-settings.c

345

lim->atomic_write_unit_min = 0;

block/blk-settings.c

346

lim->atomic_write_unit_max = 0;

block/blk-settings.c

353

int blk_validate_limits(struct queue_limits *lim)

block/blk-settings.c

364

if (!lim->logical_block_size)

block/blk-settings.c

365

lim->logical_block_size = SECTOR_SIZE;

block/blk-settings.c

366

else if (blk_validate_block_size(lim->logical_block_size)) {

block/blk-settings.c

367

pr_warn("Invalid logical block size (%d)\n", lim->logical_block_size);

block/blk-settings.c

37

void blk_set_stacking_limits(struct queue_limits *lim)

block/blk-settings.c

370

if (lim->physical_block_size < lim->logical_block_size) {

block/blk-settings.c

371

lim->physical_block_size = lim->logical_block_size;

block/blk-settings.c

372

} else if (!is_power_of_2(lim->physical_block_size)) {

block/blk-settings.c

373

pr_warn("Invalid physical block size (%d)\n", lim->physical_block_size);

block/blk-settings.c

381

if (lim->io_min < lim->physical_block_size)

block/blk-settings.c

382

lim->io_min = lim->physical_block_size;

block/blk-settings.c

389

lim->io_opt = round_down(lim->io_opt, lim->physical_block_size);

block/blk-settings.c

39

memset(lim, 0, sizeof(*lim));

block/blk-settings.c

40

lim->logical_block_size = SECTOR_SIZE;

block/blk-settings.c

400

if (!lim->max_hw_sectors)

block/blk-settings.c

401

lim->max_hw_sectors = BLK_SAFE_MAX_SECTORS;

block/blk-settings.c

402

if (WARN_ON_ONCE(lim->max_hw_sectors < PAGE_SECTORS))

block/blk-settings.c

404

logical_block_sectors = lim->logical_block_size >> SECTOR_SHIFT;

block/blk-settings.c

405

if (WARN_ON_ONCE(logical_block_sectors > lim->max_hw_sectors))

block/blk-settings.c

407

lim->max_hw_sectors = round_down(lim->max_hw_sectors,

block/blk-settings.c

41

lim->physical_block_size = SECTOR_SIZE;

block/blk-settings.c

416

max_hw_sectors = min_not_zero(lim->max_hw_sectors,

block/blk-settings.c

417

lim->max_dev_sectors);

block/blk-settings.c

418

if (lim->max_user_sectors) {

block/blk-settings.c

419

if (lim->max_user_sectors < BLK_MIN_SEGMENT_SIZE / SECTOR_SIZE)

block/blk-settings.c

42

lim->io_min = SECTOR_SIZE;

block/blk-settings.c

421

lim->max_sectors = min(max_hw_sectors, lim->max_user_sectors);

block/blk-settings.c

422

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

block/blk-settings.c

423

lim->max_sectors =

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

426

lim->max_sectors =

block/blk-settings.c

427

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

block/blk-settings.c

429

lim->max_sectors = min(max_hw_sectors, BLK_DEF_MAX_SECTORS_CAP);

block/blk-settings.c

43

lim->discard_granularity = SECTOR_SIZE;

block/blk-settings.c

431

lim->max_sectors = round_down(lim->max_sectors,

block/blk-settings.c

438

if (!lim->max_segments)

block/blk-settings.c

439

lim->max_segments = BLK_MAX_SEGMENTS;

block/blk-settings.c

44

lim->dma_alignment = SECTOR_SIZE - 1;

block/blk-settings.c

441

if (lim->max_hw_wzeroes_unmap_sectors &&

block/blk-settings.c

442

lim->max_hw_wzeroes_unmap_sectors != lim->max_write_zeroes_sectors)

block/blk-settings.c

444

lim->max_wzeroes_unmap_sectors = min(lim->max_hw_wzeroes_unmap_sectors,

block/blk-settings.c

445

lim->max_user_wzeroes_unmap_sectors);

block/blk-settings.c

447

lim->max_discard_sectors =

block/blk-settings.c

448

min(lim->max_hw_discard_sectors, lim->max_user_discard_sectors);

block/blk-settings.c

45

lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;

block/blk-settings.c

454

if (lim->max_discard_sectors)

block/blk-settings.c

455

lim->discard_granularity =

block/blk-settings.c

456

max(lim->discard_granularity, lim->physical_block_size);

block/blk-settings.c

458

lim->discard_granularity = 0;

block/blk-settings.c

460

if (!lim->max_discard_segments)

block/blk-settings.c

461

lim->max_discard_segments = 1;

block/blk-settings.c

468

if (!lim->seg_boundary_mask)

block/blk-settings.c

469

lim->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;

block/blk-settings.c

470

if (WARN_ON_ONCE(lim->seg_boundary_mask < BLK_MIN_SEGMENT_SIZE - 1))

block/blk-settings.c

48

lim->max_segments = USHRT_MAX;

block/blk-settings.c

480

if (lim->virt_boundary_mask) {

block/blk-settings.c

481

if (!lim->max_segment_size)

block/blk-settings.c

482

lim->max_segment_size = UINT_MAX;

block/blk-settings.c

489

if (!lim->max_segment_size)

block/blk-settings.c

49

lim->max_discard_segments = USHRT_MAX;

block/blk-settings.c

490

lim->max_segment_size = BLK_MAX_SEGMENT_SIZE;

block/blk-settings.c

491

if (WARN_ON_ONCE(lim->max_segment_size < BLK_MIN_SEGMENT_SIZE))

block/blk-settings.c

496

if (lim->seg_boundary_mask > lim->max_segment_size - 1)

block/blk-settings.c

497

seg_size = lim->max_segment_size;

block/blk-settings.c

499

seg_size = lim->seg_boundary_mask + 1;

block/blk-settings.c

50

lim->max_hw_sectors = UINT_MAX;

block/blk-settings.c

500

lim->max_fast_segment_size = min_t(unsigned int, seg_size, PAGE_SIZE);

block/blk-settings.c

508

if (!lim->dma_alignment)

block/blk-settings.c

509

lim->dma_alignment = SECTOR_SIZE - 1;

block/blk-settings.c

51

lim->max_segment_size = UINT_MAX;

block/blk-settings.c

510

if (WARN_ON_ONCE(lim->dma_alignment > PAGE_SIZE))

block/blk-settings.c

513

if (lim->alignment_offset) {

block/blk-settings.c

514

lim->alignment_offset &= (lim->physical_block_size - 1);

block/blk-settings.c

515

lim->flags &= ~BLK_FLAG_MISALIGNED;

block/blk-settings.c

518

if (!(lim->features & BLK_FEAT_WRITE_CACHE))

block/blk-settings.c

519

lim->features &= ~BLK_FEAT_FUA;

block/blk-settings.c

52

lim->max_sectors = UINT_MAX;

block/blk-settings.c

521

blk_validate_atomic_write_limits(lim);

block/blk-settings.c

523

err = blk_validate_integrity_limits(lim);

block/blk-settings.c

526

return blk_validate_zoned_limits(lim);

block/blk-settings.c

53

lim->max_dev_sectors = UINT_MAX;

block/blk-settings.c

535

int blk_set_default_limits(struct queue_limits *lim)

block/blk-settings.c

54

lim->max_write_zeroes_sectors = UINT_MAX;

block/blk-settings.c

542

lim->max_user_discard_sectors = UINT_MAX;

block/blk-settings.c

543

lim->max_user_wzeroes_unmap_sectors = UINT_MAX;

block/blk-settings.c

544

return blk_validate_limits(lim);

block/blk-settings.c

55

lim->max_hw_wzeroes_unmap_sectors = UINT_MAX;

block/blk-settings.c

559

struct queue_limits *lim)

block/blk-settings.c

56

lim->max_user_wzeroes_unmap_sectors = UINT_MAX;

block/blk-settings.c

565

error = blk_validate_limits(lim);

block/blk-settings.c

57

lim->max_hw_zone_append_sectors = UINT_MAX;

block/blk-settings.c

570

if (q->crypto_profile && lim->integrity.tag_size) {

block/blk-settings.c

577

q->limits = *lim;

block/blk-settings.c

579

blk_apply_bdi_limits(q->disk->bdi, lim);

block/blk-settings.c

58

lim->max_user_discard_sectors = UINT_MAX;

block/blk-settings.c

59

lim->atomic_write_hw_max = UINT_MAX;

block/blk-settings.c

598

struct queue_limits *lim)

block/blk-settings.c

604

ret = queue_limits_commit_update(q, lim);

block/blk-settings.c

622

int queue_limits_set(struct request_queue *q, struct queue_limits *lim)

block/blk-settings.c

625

return queue_limits_commit_update(q, lim);

block/blk-settings.c

629

static int queue_limit_alignment_offset(const struct queue_limits *lim,

block/blk-settings.c

632

unsigned int granularity = max(lim->physical_block_size, lim->io_min);

block/blk-settings.c

636

return (granularity + lim->alignment_offset - alignment) % granularity;

block/blk-settings.c

64

struct queue_limits *lim)

block/blk-settings.c

640

const struct queue_limits *lim, sector_t sector)

block/blk-settings.c

644

if (!lim->max_discard_sectors)

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

66

u64 io_opt = lim->io_opt;

block/blk-settings.c

79

if (!io_opt && (lim->features & BLK_FEAT_ROTATIONAL))

block/blk-settings.c

80

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

block/blk-settings.c

85

bdi->io_pages = lim->max_sectors >> PAGE_SECTORS_SHIFT;

block/blk-settings.c

88

static int blk_validate_zoned_limits(struct queue_limits *lim)

block/blk-settings.c

90

if (!(lim->features & BLK_FEAT_ZONED)) {

block/blk-settings.c

91

if (WARN_ON_ONCE(lim->max_open_zones) ||

block/blk-settings.c

92

WARN_ON_ONCE(lim->max_active_zones) ||

block/blk-settings.c

93

WARN_ON_ONCE(lim->zone_write_granularity) ||

block/blk-settings.c

94

WARN_ON_ONCE(lim->max_zone_append_sectors))

block/blk-sysfs.c

276

const char *page, size_t count, struct queue_limits *lim)

block/blk-sysfs.c

291

lim->max_user_discard_sectors = max_discard_bytes >> SECTOR_SHIFT;

block/blk-sysfs.c

296

const char *page, size_t count, struct queue_limits *lim)

block/blk-sysfs.c

30

size_t count, struct queue_limits *lim);

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-sysfs.c

315

struct queue_limits *lim)

block/blk-sysfs.c

324

lim->max_user_sectors = max_sectors_kb << 1;

block/blk-sysfs.c

329

size_t count, struct queue_limits *lim, blk_features_t feature)

block/blk-sysfs.c

339

lim->features |= feature;

block/blk-sysfs.c

341

lim->features &= ~feature;

block/blk-sysfs.c

352

const char *page, size_t count, struct queue_limits *lim) \

block/blk-sysfs.c

354

return queue_feature_store(disk, page, count, lim, _feature); \

block/blk-sysfs.c

399

const char *page, size_t count, struct queue_limits *lim)

block/blk-sysfs.c

409

lim->flags |= BLK_FLAG_IOSTATS_PASSTHROUGH;

block/blk-sysfs.c

411

lim->flags &= ~BLK_FLAG_IOSTATS_PASSTHROUGH;

block/blk-sysfs.c

534

size_t count, struct queue_limits *lim)

block/blk-sysfs.c

548

lim->flags |= BLK_FLAG_WRITE_CACHE_DISABLED;

block/blk-sysfs.c

550

lim->flags &= ~BLK_FLAG_WRITE_CACHE_DISABLED;

block/blk-sysfs.c

858

struct queue_limits lim = queue_limits_start_update(q);

block/blk-sysfs.c

860

res = entry->store_limit(disk, page, length, &lim);

block/blk-sysfs.c

866

res = queue_limits_commit_update_frozen(q, &lim);

block/blk-zoned.c

1911

struct queue_limits *lim = &disk->queue->limits;

block/blk-zoned.c

1916

DIV_ROUND_UP_ULL(get_capacity(disk), lim->chunk_sectors);

block/blk-zoned.c

1930

pool_size = max(lim->max_open_zones, lim->max_active_zones);

block/blk-zoned.c

1951

struct queue_limits lim;

block/blk-zoned.c

1954

lim = queue_limits_start_update(q);

block/blk-zoned.c

1978

if (lim.max_open_zones >= nr_seq_zones)

block/blk-zoned.c

1979

lim.max_open_zones = 0;

block/blk-zoned.c

1980

if (lim.max_active_zones >= nr_seq_zones)

block/blk-zoned.c

1981

lim.max_active_zones = 0;

block/blk-zoned.c

1993

pool_size = max(lim.max_open_zones, lim.max_active_zones);

block/blk-zoned.c

1999

if (!lim.max_open_zones && !lim.max_active_zones) {

block/blk-zoned.c

2001

lim.max_open_zones = pool_size;

block/blk-zoned.c

2003

lim.max_open_zones = 0;

block/blk-zoned.c

2007

ret = queue_limits_commit_update(q, &lim);

block/blk.h

142

static inline bool __bvec_gap_to_prev(const struct queue_limits *lim,

block/blk.h

145

return (offset & lim->virt_boundary_mask) ||

block/blk.h

146

((bprv->bv_offset + bprv->bv_len) & lim->virt_boundary_mask);

block/blk.h

153

static inline bool bvec_gap_to_prev(const struct queue_limits *lim,

block/blk.h

156

if (!lim->virt_boundary_mask)

block/blk.h

158

return __bvec_gap_to_prev(lim, bprv, offset);

block/blk.h

358

struct bio *bio_split_discard(struct bio *bio, const struct queue_limits *lim,

block/blk.h

361

const struct queue_limits *lim, unsigned *nsegs);

block/blk.h

362

struct bio *bio_split_rw(struct bio *bio, const struct queue_limits *lim,

block/blk.h

365

const struct queue_limits *lim, unsigned *nr_segs);

block/blk.h

376

const struct queue_limits *lim)

block/blk.h

380

if (lim->chunk_sectors)

block/blk.h

389

return bv->bv_len + bv->bv_offset > lim->max_fast_segment_size;

block/blk.h

406

const struct queue_limits *lim, unsigned int *nr_segs)

block/blk.h

411

if (bio_may_need_split(bio, lim))

block/blk.h

412

return bio_split_rw(bio, lim, nr_segs);

block/blk.h

416

return bio_split_zone_append(bio, lim, nr_segs);

block/blk.h

419

return bio_split_discard(bio, lim, nr_segs);

block/blk.h

421

return bio_split_write_zeroes(bio, lim, nr_segs);

block/blk.h

438

static inline unsigned get_max_segment_size(const struct queue_limits *lim,

block/blk.h

446

min(lim->seg_boundary_mask - (lim->seg_boundary_mask & paddr),

block/blk.h

447

(unsigned long)lim->max_segment_size - 1) + 1);

block/blk.h

458

int blk_set_default_limits(struct queue_limits *lim);

block/blk.h

460

struct queue_limits *lim);

block/blk.h

602

struct request_queue *blk_alloc_queue(struct queue_limits *lim, int node_id);

block/bsg-lib.c

363

struct queue_limits *lim, bsg_job_fn *job_fn,

block/bsg-lib.c

388

q = blk_mq_alloc_queue(set, lim, dev);

block/genhd.c

1508

struct gendisk *__blk_alloc_disk(struct queue_limits *lim, int node,

block/genhd.c

1515

q = blk_alloc_queue(lim ? lim : &default_lim, node);

drivers/ata/libata-sata.c

1360

int ata_sas_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim,

drivers/ata/libata-sata.c

1365

return ata_scsi_dev_config(sdev, lim, ap->link.device);

drivers/ata/libata-scsi.c

1064

int ata_scsi_dev_config(struct scsi_device *sdev, struct queue_limits *lim,

drivers/ata/libata-scsi.c

1074

lim->max_hw_sectors = dev->max_sectors;

drivers/ata/libata-scsi.c

1080

lim->dma_pad_mask = ATA_DMA_PAD_SZ - 1;

drivers/ata/libata-scsi.c

1083

lim->max_segments--;

drivers/ata/libata-scsi.c

1121

lim->dma_alignment = sdev->sector_size - 1;

drivers/ata/libata-scsi.c

1187

int ata_scsi_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/ata/libata-scsi.c

1193

return ata_scsi_dev_config(sdev, lim, dev);

drivers/ata/libata.h

166

int ata_scsi_dev_config(struct scsi_device *sdev, struct queue_limits *lim,

drivers/ata/pata_macio.c

816

struct queue_limits *lim)

drivers/ata/pata_macio.c

825

rc = ata_scsi_sdev_configure(sdev, lim);

drivers/ata/pata_macio.c

834

lim->dma_alignment = 31;

drivers/ata/pata_macio.c

835

lim->dma_pad_mask = 31;

drivers/ata/pata_macio.c

849

lim->dma_alignment = 15;

drivers/ata/pata_macio.c

850

lim->dma_pad_mask = 15;

drivers/ata/sata_nv.c

1875

struct queue_limits *lim)

drivers/ata/sata_nv.c

1885

rc = ata_scsi_sdev_configure(sdev, lim);

drivers/ata/sata_nv.c

300

struct queue_limits *lim);

drivers/ata/sata_nv.c

323

struct queue_limits *lim);

drivers/ata/sata_nv.c

667

struct queue_limits *lim)

drivers/ata/sata_nv.c

679

rc = ata_scsi_sdev_configure(sdev, lim);

drivers/ata/sata_nv.c

746

lim->seg_boundary_mask = segment_boundary;

drivers/ata/sata_nv.c

747

lim->max_segments = sg_tablesize;

drivers/base/cacheinfo.c

137

int i, lim, ct_idx;

drivers/base/cacheinfo.c

140

lim = ARRAY_SIZE(cache_type_info[ct_idx].line_size_props);

drivers/base/cacheinfo.c

142

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

drivers/block/amiflop.c

1780

struct queue_limits lim = {

drivers/block/amiflop.c

1786

disk = blk_mq_alloc_disk(&unit[drive].tag_set, &lim, NULL);

drivers/block/aoe/aoeblk.c

337

struct queue_limits lim = {

drivers/block/aoe/aoeblk.c

378

gd = blk_mq_alloc_disk(set, &lim, d);

drivers/block/aoe/aoedev.c

258

size_t lim;

drivers/block/aoe/aoedev.c

263

lim = sizeof(d->gd->disk_name);

drivers/block/aoe/aoedev.c

264

lim -= p - d->gd->disk_name;

drivers/block/aoe/aoedev.c

265

if (slen < lim)

drivers/block/aoe/aoedev.c

266

lim = slen;

drivers/block/aoe/aoedev.c

268

return !strncmp(s, p, lim);

drivers/block/ataflop.c

1996

struct queue_limits lim = {

drivers/block/ataflop.c

2001

disk = blk_mq_alloc_disk(&unit[drive].tag_set, &lim, NULL);

drivers/block/brd.c

300

struct queue_limits lim = {

drivers/block/brd.c

327

disk = brd->brd_disk = blk_alloc_disk(&lim, NUMA_NO_NODE);

drivers/block/drbd/drbd_main.c

2659

struct queue_limits lim = {

drivers/block/drbd/drbd_main.c

2685

disk = blk_alloc_disk(&lim, NUMA_NO_NODE);

drivers/block/drbd/drbd_nl.c

1266

struct queue_limits lim;

drivers/block/drbd/drbd_nl.c

1293

lim = queue_limits_start_update(q);

drivers/block/drbd/drbd_nl.c

1295

blk_set_stacking_limits(&lim);

drivers/block/drbd/drbd_nl.c

1296

lim.max_segments = drbd_backing_dev_max_segments(device);

drivers/block/drbd/drbd_nl.c

1298

lim.max_segments = BLK_MAX_SEGMENTS;

drivers/block/drbd/drbd_nl.c

1299

lim.features = BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA |

drivers/block/drbd/drbd_nl.c

1303

lim.max_hw_sectors = new >> SECTOR_SHIFT;

drivers/block/drbd/drbd_nl.c

1304

lim.seg_boundary_mask = PAGE_SIZE - 1;

drivers/block/drbd/drbd_nl.c

1315

lim.discard_granularity = 512;

drivers/block/drbd/drbd_nl.c

1316

lim.max_hw_discard_sectors =

drivers/block/drbd/drbd_nl.c

1319

lim.discard_granularity = 0;

drivers/block/drbd/drbd_nl.c

1320

lim.max_hw_discard_sectors = 0;

drivers/block/drbd/drbd_nl.c

1324

blk_stack_limits(&lim, &b->limits, 0);

drivers/block/drbd/drbd_nl.c

1339

lim.features |= BLK_FEAT_STABLE_WRITES;

drivers/block/drbd/drbd_nl.c

1348

lim.max_write_zeroes_sectors = DRBD_MAX_BBIO_SECTORS;

drivers/block/drbd/drbd_nl.c

1350

lim.max_write_zeroes_sectors = 0;

drivers/block/drbd/drbd_nl.c

1351

lim.max_hw_wzeroes_unmap_sectors = 0;

drivers/block/drbd/drbd_nl.c

1353

if ((lim.discard_granularity >> SECTOR_SHIFT) >

drivers/block/drbd/drbd_nl.c

1354

lim.max_hw_discard_sectors) {

drivers/block/drbd/drbd_nl.c

1355

lim.discard_granularity = 0;

drivers/block/drbd/drbd_nl.c

1356

lim.max_hw_discard_sectors = 0;

drivers/block/drbd/drbd_nl.c

1359

if (queue_limits_commit_update(q, &lim))

drivers/block/floppy.c

4513

struct queue_limits lim = {

drivers/block/floppy.c

4519

disk = blk_mq_alloc_disk(&tag_sets[drive], &lim, NULL);

drivers/block/loop.c

1061

lim = queue_limits_start_update(lo->lo_queue);

drivers/block/loop.c

1062

loop_update_limits(lo, &lim, config->block_size);

drivers/block/loop.c

1064

error = queue_limits_commit_update(lo->lo_queue, &lim);

drivers/block/loop.c

1117

struct queue_limits lim;

drivers/block/loop.c

1137

lim = queue_limits_start_update(lo->lo_queue);

drivers/block/loop.c

1138

lim.logical_block_size = SECTOR_SIZE;

drivers/block/loop.c

1139

lim.physical_block_size = SECTOR_SIZE;

drivers/block/loop.c

1140

lim.io_min = SECTOR_SIZE;

drivers/block/loop.c

1141

queue_limits_commit_update(lo->lo_queue, &lim);

drivers/block/loop.c

1448

struct queue_limits lim;

drivers/block/loop.c

1477

lim = queue_limits_start_update(lo->lo_queue);

drivers/block/loop.c

1478

loop_update_limits(lo, &lim, arg);

drivers/block/loop.c

1481

err = queue_limits_commit_update(lo->lo_queue, &lim);

drivers/block/loop.c

2001

struct queue_limits lim = {

drivers/block/loop.c

2049

disk = lo->lo_disk = blk_mq_alloc_disk(&lo->tag_set, &lim, lo);

drivers/block/loop.c

226

struct queue_limits lim = queue_limits_start_update(lo->lo_queue);

drivers/block/loop.c

229

lim.max_write_zeroes_sectors = 0;

drivers/block/loop.c

232

lim.max_hw_discard_sectors = 0;

drivers/block/loop.c

233

lim.discard_granularity = 0;

drivers/block/loop.c

243

queue_limits_commit_update(lo->lo_queue, &lim);

drivers/block/loop.c

947

static void loop_update_limits(struct loop_device *lo, struct queue_limits *lim,

drivers/block/loop.c

965

lim->logical_block_size = bsize;

drivers/block/loop.c

966

lim->physical_block_size = bsize;

drivers/block/loop.c

967

lim->io_min = bsize;

drivers/block/loop.c

968

lim->features &= ~(BLK_FEAT_WRITE_CACHE | BLK_FEAT_ROTATIONAL);

drivers/block/loop.c

970

lim->features |= BLK_FEAT_WRITE_CACHE;

drivers/block/loop.c

972

lim->features |= BLK_FEAT_ROTATIONAL;

drivers/block/loop.c

973

lim->max_hw_discard_sectors = max_discard_sectors;

drivers/block/loop.c

974

lim->max_write_zeroes_sectors = max_discard_sectors;

drivers/block/loop.c

976

lim->discard_granularity = granularity;

drivers/block/loop.c

978

lim->discard_granularity = 0;

drivers/block/loop.c

986

struct queue_limits lim;

drivers/block/mtip32xx/mtip32xx.c

3401

struct queue_limits lim = {

drivers/block/mtip32xx/mtip32xx.c

3436

dd->disk = blk_mq_alloc_disk(&dd->tags, &lim, dd);

drivers/block/n64cart.c

117

struct queue_limits lim = {

drivers/block/n64cart.c

138

disk = blk_alloc_disk(&lim, NUMA_NO_NODE);

drivers/block/nbd.c

1909

struct queue_limits lim = {

drivers/block/nbd.c

1954

disk = blk_mq_alloc_disk(&nbd->tag_set, &lim, NULL);

drivers/block/nbd.c

336

struct queue_limits lim;

drivers/block/nbd.c

354

lim = queue_limits_start_update(nbd->disk->queue);

drivers/block/nbd.c

356

lim.max_hw_discard_sectors = UINT_MAX >> SECTOR_SHIFT;

drivers/block/nbd.c

358

lim.max_hw_discard_sectors = 0;

drivers/block/nbd.c

360

lim.features &= ~(BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA);

drivers/block/nbd.c

362

lim.features |= BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA;

drivers/block/nbd.c

364

lim.features |= BLK_FEAT_WRITE_CACHE;

drivers/block/nbd.c

365

lim.features &= ~BLK_FEAT_FUA;

drivers/block/nbd.c

368

lim.features |= BLK_FEAT_ROTATIONAL;

drivers/block/nbd.c

370

lim.max_write_zeroes_sectors = UINT_MAX >> SECTOR_SHIFT;

drivers/block/nbd.c

372

lim.logical_block_size = blksize;

drivers/block/nbd.c

373

lim.physical_block_size = blksize;

drivers/block/nbd.c

374

error = queue_limits_commit_update_frozen(nbd->disk->queue, &lim);

drivers/block/null_blk/main.c

1789

static void null_config_discard(struct nullb *nullb, struct queue_limits *lim)

drivers/block/null_blk/main.c

1806

lim->max_hw_discard_sectors = UINT_MAX >> 9;

drivers/block/null_blk/main.c

1957

struct queue_limits lim = {

drivers/block/null_blk/main.c

1990

lim.virt_boundary_mask = PAGE_SIZE - 1;

drivers/block/null_blk/main.c

1991

null_config_discard(nullb, &lim);

drivers/block/null_blk/main.c

1993

rv = null_init_zoned_dev(dev, &lim);

drivers/block/null_blk/main.c

2000

lim.features |= BLK_FEAT_WRITE_CACHE;

drivers/block/null_blk/main.c

2002

lim.features |= BLK_FEAT_FUA;

drivers/block/null_blk/main.c

2006

lim.features |= BLK_FEAT_ROTATIONAL;

drivers/block/null_blk/main.c

2008

nullb->disk = blk_mq_alloc_disk(nullb->tag_set, &lim, nullb);

drivers/block/null_blk/null_blk.h

142

int null_init_zoned_dev(struct nullb_device *dev, struct queue_limits *lim);

drivers/block/null_blk/null_blk.h

156

struct queue_limits *lim)

drivers/block/null_blk/zoned.c

167

lim->features |= BLK_FEAT_ZONED;

drivers/block/null_blk/zoned.c

168

lim->chunk_sectors = dev->zone_size_sects;

drivers/block/null_blk/zoned.c

169

lim->max_hw_zone_append_sectors = dev->zone_append_max_sectors;

drivers/block/null_blk/zoned.c

170

lim->max_open_zones = dev->zone_max_open;

drivers/block/null_blk/zoned.c

171

lim->max_active_zones = dev->zone_max_active;

drivers/block/null_blk/zoned.c

52

struct queue_limits *lim)

drivers/block/ps3disk.c

389

struct queue_limits lim = {

drivers/block/ps3disk.c

445

gendisk = blk_mq_alloc_disk(&priv->tag_set, &lim, dev);

drivers/block/rbd.c

4963

struct queue_limits lim = {

drivers/block/rbd.c

4984

lim.discard_granularity = rbd_dev->opts->alloc_size;

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

4990

lim.features |= BLK_FEAT_STABLE_WRITES;

drivers/block/rbd.c

4992

disk = blk_mq_alloc_disk(&rbd_dev->tag_set, &lim, rbd_dev);

drivers/block/rnbd/rnbd-clt.c

1366

struct queue_limits lim = {

drivers/block/rnbd/rnbd-clt.c

1385

lim.max_secure_erase_sectors =

drivers/block/rnbd/rnbd-clt.c

1390

lim.features |= BLK_FEAT_WRITE_CACHE;

drivers/block/rnbd/rnbd-clt.c

1392

lim.features |= BLK_FEAT_FUA;

drivers/block/rnbd/rnbd-clt.c

1395

dev->gd = blk_mq_alloc_disk(&dev->sess->tag_set, &lim, dev);

drivers/block/sunvdc.c

786

struct queue_limits lim = {

drivers/block/sunvdc.c

835

g = blk_mq_alloc_disk(&port->tag_set, &lim, port);

drivers/block/swim.c

790

struct queue_limits lim = {

drivers/block/swim.c

826

blk_mq_alloc_disk(&swd->unit[drive].tag_set, &lim,

drivers/block/swim3.c

1193

struct queue_limits lim = {

drivers/block/swim3.c

1216

disk = blk_mq_alloc_disk(&fs->tag_set, &lim, fs);

drivers/block/ublk_drv.c

4308

struct queue_limits lim = {

drivers/block/ublk_drv.c

4331

lim.discard_alignment = pd->discard_alignment;

drivers/block/ublk_drv.c

4332

lim.discard_granularity = pd->discard_granularity;

drivers/block/ublk_drv.c

4333

lim.max_hw_discard_sectors = pd->max_discard_sectors;

drivers/block/ublk_drv.c

4334

lim.max_write_zeroes_sectors = pd->max_write_zeroes_sectors;

drivers/block/ublk_drv.c

4335

lim.max_discard_segments = pd->max_discard_segments;

drivers/block/ublk_drv.c

4344

lim.features |= BLK_FEAT_ZONED;

drivers/block/ublk_drv.c

4345

lim.max_active_zones = p->max_active_zones;

drivers/block/ublk_drv.c

4346

lim.max_open_zones = p->max_open_zones;

drivers/block/ublk_drv.c

4347

lim.max_hw_zone_append_sectors = p->max_zone_append_sectors;

drivers/block/ublk_drv.c

4351

lim.features |= BLK_FEAT_WRITE_CACHE;

drivers/block/ublk_drv.c

4353

lim.features |= BLK_FEAT_FUA;

drivers/block/ublk_drv.c

4357

lim.features |= BLK_FEAT_ROTATIONAL;

drivers/block/ublk_drv.c

4360

lim.dma_alignment = ub->params.dma.alignment;

drivers/block/ublk_drv.c

4363

lim.seg_boundary_mask = ub->params.seg.seg_boundary_mask;

drivers/block/ublk_drv.c

4364

lim.max_segment_size = ub->params.seg.max_segment_size;

drivers/block/ublk_drv.c

4365

lim.max_segments = ub->params.seg.max_segments;

drivers/block/ublk_drv.c

4372

lim.max_integrity_segments =

drivers/block/ublk_drv.c

4374

lim.integrity = (struct blk_integrity) {

drivers/block/ublk_drv.c

4403

disk = blk_mq_alloc_disk(&ub->tag_set, &lim, NULL);

drivers/block/virtio_blk.c

1098

struct queue_limits lim;

drivers/block/virtio_blk.c

1108

lim = queue_limits_start_update(disk->queue);

drivers/block/virtio_blk.c

1110

lim.features |= BLK_FEAT_WRITE_CACHE;

drivers/block/virtio_blk.c

1112

lim.features &= ~BLK_FEAT_WRITE_CACHE;

drivers/block/virtio_blk.c

1113

i = queue_limits_commit_update_frozen(disk->queue, &lim);

drivers/block/virtio_blk.c

1245

struct queue_limits *lim)

drivers/block/virtio_blk.c

1269

lim->max_segments = sg_elems;

drivers/block/virtio_blk.c

1272

lim->max_hw_sectors = UINT_MAX;

drivers/block/virtio_blk.c

1284

lim->max_segment_size = max_size;

drivers/block/virtio_blk.c

1289

&lim->logical_block_size);

drivers/block/virtio_blk.c

1296

lim->physical_block_size =

drivers/block/virtio_blk.c

1297

lim->logical_block_size * (1 << physical_block_exp);

drivers/block/virtio_blk.c

1303

lim->alignment_offset =

drivers/block/virtio_blk.c

1304

lim->logical_block_size * alignment_offset;

drivers/block/virtio_blk.c

1310

lim->io_min = lim->logical_block_size * min_io_size;

drivers/block/virtio_blk.c

1316

lim->io_opt = lim->logical_block_size * opt_io_size;

drivers/block/virtio_blk.c

1324

lim->max_hw_discard_sectors = v ? v : UINT_MAX;

drivers/block/virtio_blk.c

1333

lim->max_write_zeroes_sectors = v ? v : UINT_MAX;

drivers/block/virtio_blk.c

1376

lim->max_secure_erase_sectors = v;

drivers/block/virtio_blk.c

1403

lim->max_discard_segments =

drivers/block/virtio_blk.c

1407

lim->discard_granularity =

drivers/block/virtio_blk.c

1410

lim->discard_granularity = lim->logical_block_size;

drivers/block/virtio_blk.c

1423

err = virtblk_read_zoned_limits(vblk, lim);

drivers/block/virtio_blk.c

1439

struct queue_limits lim = {

drivers/block/virtio_blk.c

1501

err = virtblk_read_limits(vblk, &lim);

drivers/block/virtio_blk.c

1506

lim.features |= BLK_FEAT_WRITE_CACHE;

drivers/block/virtio_blk.c

1508

vblk->disk = blk_mq_alloc_disk(&vblk->tag_set, &lim, vblk);

drivers/block/virtio_blk.c

1535

(lim.features & BLK_FEAT_ZONED)) {

drivers/block/virtio_blk.c

719

struct queue_limits *lim)

drivers/block/virtio_blk.c

726

lim->features |= BLK_FEAT_ZONED;

drivers/block/virtio_blk.c

730

lim->max_open_zones = v;

drivers/block/virtio_blk.c

735

lim->max_active_zones = v;

drivers/block/virtio_blk.c

744

lim->physical_block_size = wg;

drivers/block/virtio_blk.c

745

lim->io_min = wg;

drivers/block/virtio_blk.c

761

lim->chunk_sectors = vblk->zone_sectors;

drivers/block/virtio_blk.c

767

lim->max_hw_discard_sectors = 0;

drivers/block/virtio_blk.c

782

lim->max_hw_zone_append_sectors = v;

drivers/block/virtio_blk.c

794

struct queue_limits *lim)

drivers/block/xen-blkfront.c

1075

struct queue_limits lim = {};

drivers/block/xen-blkfront.c

1141

blkif_set_queue_limits(info, &lim);

drivers/block/xen-blkfront.c

1142

gd = blk_mq_alloc_disk(&info->tag_set, &lim, info);

drivers/block/xen-blkfront.c

2008

struct queue_limits lim;

drivers/block/xen-blkfront.c

2015

lim = queue_limits_start_update(info->rq);

drivers/block/xen-blkfront.c

2017

blkif_set_queue_limits(info, &lim);

drivers/block/xen-blkfront.c

2018

rc = queue_limits_commit_update(info->rq, &lim);

drivers/block/xen-blkfront.c

948

struct queue_limits *lim)

drivers/block/xen-blkfront.c

954

lim->max_hw_discard_sectors = UINT_MAX;

drivers/block/xen-blkfront.c

956

lim->discard_granularity = info->discard_granularity;

drivers/block/xen-blkfront.c

957

lim->discard_alignment = info->discard_alignment;

drivers/block/xen-blkfront.c

959

lim->max_secure_erase_sectors = UINT_MAX;

drivers/block/xen-blkfront.c

963

lim->features |= BLK_FEAT_WRITE_CACHE;

drivers/block/xen-blkfront.c

965

lim->features |= BLK_FEAT_FUA;

drivers/block/xen-blkfront.c

969

lim->logical_block_size = info->sector_size;

drivers/block/xen-blkfront.c

970

lim->physical_block_size = info->physical_sector_size;

drivers/block/xen-blkfront.c

971

lim->max_hw_sectors = (segments * XEN_PAGE_SIZE) / 512;

drivers/block/xen-blkfront.c

974

lim->seg_boundary_mask = PAGE_SIZE - 1;

drivers/block/xen-blkfront.c

975

lim->max_segment_size = PAGE_SIZE;

drivers/block/xen-blkfront.c

978

lim->max_segments = segments / GRANTS_PER_PSEG;

drivers/block/xen-blkfront.c

981

lim->dma_alignment = 511;

drivers/block/zloop.c

1087

lim.physical_block_size = zlo->block_size;

drivers/block/zloop.c

1088

lim.logical_block_size = zlo->block_size;

drivers/block/zloop.c

1090

lim.max_hw_zone_append_sectors = lim.max_hw_sectors;

drivers/block/zloop.c

1105

zlo->disk = blk_mq_alloc_disk(&zlo->tag_set, &lim, zlo);

drivers/block/zloop.c

1115

set_capacity(zlo->disk, (u64)lim.chunk_sectors * zlo->nr_zones);

drivers/block/zloop.c

992

struct queue_limits lim = {

drivers/block/zram/zram_drv.c

3044

struct queue_limits lim = {

drivers/block/zram/zram_drv.c

3087

zram->disk = blk_alloc_disk(&lim, NUMA_NO_NODE);

drivers/cdrom/gdrom.c

741

struct queue_limits lim = {

drivers/cdrom/gdrom.c

784

gd.disk = blk_mq_alloc_disk(&gd.tag_set, &lim, NULL);

drivers/edac/amd64_edac.c

1742

amd64_read_pci_cfg(pvt->F1, DRAM_LIMIT_LO + off, &pvt->ranges[range].lim.lo);

drivers/edac/amd64_edac.c

1751

amd64_read_pci_cfg(pvt->F1, DRAM_LIMIT_HI + off, &pvt->ranges[range].lim.hi);

drivers/edac/amd64_edac.c

1774

pvt->ranges[range].lim.lo &= GENMASK_ULL(15, 0);

drivers/edac/amd64_edac.c

1777

pvt->ranges[range].lim.lo |= ((llim & 0x1fff) << 3 | 0x7) << 16;

drivers/edac/amd64_edac.c

1779

pvt->ranges[range].lim.hi &= GENMASK_ULL(7, 0);

drivers/edac/amd64_edac.c

1782

pvt->ranges[range].lim.hi |= llim >> 13;

drivers/edac/amd64_edac.h

137

#define dram_intlv_sel(pvt, i) ((u8)((pvt->ranges[i].lim.lo >> 8) & 0x7))

drivers/edac/amd64_edac.h

138

#define dram_dst_node(pvt, i) ((u8)(pvt->ranges[i].lim.lo & 0x7))

drivers/edac/amd64_edac.h

290

struct reg_pair lim;

drivers/edac/amd64_edac.h

423

u64 lim = (((u64)pvt->ranges[i].lim.lo & 0xffff0000) << 8) | 0x00ffffff;

drivers/edac/amd64_edac.h

426

return lim;

drivers/edac/amd64_edac.h

428

return (((u64)pvt->ranges[i].lim.hi & 0x000000ff) << 40) | lim;

drivers/firewire/sbp2.c

1511

struct queue_limits *lim)

drivers/firewire/sbp2.c

1537

lim->max_hw_sectors = 128 * 1024 / 512;

drivers/firmware/broadcom/bcm47xx_nvram.c

138

int bcm47xx_nvram_init_from_mem(u32 base, u32 lim)

drivers/firmware/broadcom/bcm47xx_nvram.c

143

iobase = ioremap(base, lim);

drivers/firmware/broadcom/bcm47xx_nvram.c

147

err = bcm47xx_nvram_find_and_copy(iobase, lim);

drivers/firmware/efi/libstub/printk.c

78

size_t pos = 0, lim = ARRAY_SIZE(buf);

drivers/firmware/efi/libstub/printk.c

97

if (*s8 == '\0' || pos >= lim - 2) {

drivers/gpu/drm/i915/display/intel_vdsc_regs.h

175

#define DSC_PPS10_RC_QUANT_INC_LIMIT1(lim) REG_FIELD_PREP(DSC_PPS10_RC_QUANT_INC_LIMIT1_MASK, lim)

drivers/gpu/drm/i915/display/intel_vdsc_regs.h

176

#define DSC_PPS10_RC_QUANT_INC_LIMIT0(lim) REG_FIELD_PREP(DSC_PPS10_RC_QUANT_INC_LIMIT0_MASK, lim)

drivers/infiniband/ulp/srp/ib_srp.c

2848

struct queue_limits *lim)

drivers/input/serio/hil_mlc.c

289

static int hilse_inc_lcv(hil_mlc *mlc, int lim)

drivers/input/serio/hil_mlc.c

291

return mlc->lcv++ >= lim ? -1 : 0;

drivers/md/bcache/super.c

903

struct queue_limits lim = {

drivers/md/bcache/super.c

919

lim.io_opt = umax(block_size, bdev_io_opt(cached_bdev));

drivers/md/bcache/super.c

958

if (lim.logical_block_size > PAGE_SIZE && cached_bdev) {

drivers/md/bcache/super.c

964

idx, lim.logical_block_size,

drivers/md/bcache/super.c

968

lim.logical_block_size = bdev_logical_block_size(cached_bdev);

drivers/md/bcache/super.c

971

d->disk = blk_alloc_disk(&lim, NUMA_NO_NODE);

drivers/md/dm-zone.c

277

struct queue_limits *lim;

drivers/md/dm-zone.c

330

zlim->lim->max_active_zones =

drivers/md/dm-zone.c

331

min_not_zero(max_active_zones, zlim->lim->max_active_zones);

drivers/md/dm-zone.c

336

zlim->lim->max_open_zones =

drivers/md/dm-zone.c

337

min_not_zero(max_open_zones, zlim->lim->max_open_zones);

drivers/md/dm-zone.c

350

struct queue_limits *lim)

drivers/md/dm-zone.c

356

.lim = lim,

drivers/md/dm-zone.c

367

lim->max_hw_zone_append_sectors = 0;

drivers/md/dm-zone.c

368

else if (lim->max_hw_zone_append_sectors == 0)

drivers/md/dm-zone.c

369

lim->max_hw_zone_append_sectors = lim->max_zone_append_sectors;

drivers/md/dm-zone.c

401

lim->max_open_zones = 0;

drivers/md/dm-zone.c

402

lim->max_active_zones = 0;

drivers/md/dm-zone.c

403

lim->max_hw_zone_append_sectors = 0;

drivers/md/dm-zone.c

404

lim->max_zone_append_sectors = 0;

drivers/md/dm-zone.c

405

lim->zone_write_granularity = 0;

drivers/md/dm-zone.c

406

lim->chunk_sectors = 0;

drivers/md/dm-zone.c

407

lim->features &= ~BLK_FEAT_ZONED;

drivers/md/dm-zone.c

412

if (q->limits.chunk_sectors != lim->chunk_sectors) {

drivers/md/dm-zone.c

418

if (lim->max_hw_zone_append_sectors != 0 &&

drivers/md/dm-zone.c

439

if (lim->features & BLK_FEAT_ZONED &&

drivers/md/dm-zone.c

445

void dm_finalize_zone_settings(struct dm_table *t, struct queue_limits *lim)

drivers/md/dm-zone.c

449

if (lim->features & BLK_FEAT_ZONED) {

drivers/md/dm.h

106

struct queue_limits *lim);

drivers/md/dm.h

108

void dm_finalize_zone_settings(struct dm_table *t, struct queue_limits *lim);

drivers/md/md-linear.c

70

struct queue_limits lim;

drivers/md/md-linear.c

73

md_init_stacking_limits(&lim);

drivers/md/md-linear.c

74

lim.max_hw_sectors = mddev->chunk_sectors;

drivers/md/md-linear.c

75

lim.logical_block_size = mddev->logical_block_size;

drivers/md/md-linear.c

76

lim.max_write_zeroes_sectors = mddev->chunk_sectors;

drivers/md/md-linear.c

77

lim.max_hw_wzeroes_unmap_sectors = mddev->chunk_sectors;

drivers/md/md-linear.c

78

lim.io_min = mddev->chunk_sectors << 9;

drivers/md/md-linear.c

79

lim.features |= BLK_FEAT_ATOMIC_WRITES;

drivers/md/md-linear.c

80

err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY);

drivers/md/md-linear.c

84

return queue_limits_set(mddev->gendisk->queue, &lim);

drivers/md/md.c

5948

struct queue_limits lim;

drivers/md/md.c

5956

lim = queue_limits_start_update(mddev->gendisk->queue);

drivers/md/md.c

5957

lim.logical_block_size = lbs;

drivers/md/md.c

5960

err = queue_limits_commit_update(mddev->gendisk->queue, &lim);

drivers/md/md.c

6166

int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,

drivers/md/md.c

6172

queue_limits_stack_bdev(lim, rdev->bdev, rdev->data_offset,

drivers/md/md.c

6175

!queue_limits_stack_integrity_bdev(lim, rdev->bdev))

drivers/md/md.c

6183

if (lim->logical_block_size > PAGE_SIZE) {

drivers/md/md.c

6202

mddev->logical_block_size = lim->logical_block_size;

drivers/md/md.c

6217

struct queue_limits lim;

drivers/md/md.c

6229

lim = queue_limits_start_update(mddev->gendisk->queue);

drivers/md/md.c

6230

queue_limits_stack_bdev(&lim, rdev->bdev, rdev->data_offset,

drivers/md/md.c

6233

if (!queue_limits_stack_integrity_bdev(&lim, rdev->bdev)) {

drivers/md/md.c

6240

return queue_limits_commit_update(mddev->gendisk->queue, &lim);

drivers/md/md.c

6247

struct queue_limits lim;

drivers/md/md.c

6255

lim = queue_limits_start_update(mddev->gendisk->queue);

drivers/md/md.c

6256

lim.io_opt = lim.io_min * nr_stripes;

drivers/md/md.c

6257

queue_limits_commit_update(mddev->gendisk->queue, &lim);

drivers/md/md.c

6269

void md_init_stacking_limits(struct queue_limits *lim)

drivers/md/md.c

6271

blk_set_stacking_limits(lim);

drivers/md/md.c

6272

lim->features = BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA |

drivers/md/md.h

1033

int mddev_stack_rdev_limits(struct mddev *mddev, struct queue_limits *lim,

drivers/md/md.h

940

void md_init_stacking_limits(struct queue_limits *lim);

drivers/md/raid0.c

383

struct queue_limits lim;

drivers/md/raid0.c

386

md_init_stacking_limits(&lim);

drivers/md/raid0.c

387

lim.max_hw_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

388

lim.max_write_zeroes_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

389

lim.max_hw_wzeroes_unmap_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

390

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid0.c

391

lim.io_min = mddev->chunk_sectors << 9;

drivers/md/raid0.c

392

lim.io_opt = lim.io_min * mddev->raid_disks;

drivers/md/raid0.c

393

lim.chunk_sectors = mddev->chunk_sectors;

drivers/md/raid0.c

394

lim.features |= BLK_FEAT_ATOMIC_WRITES;

drivers/md/raid0.c

395

err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY);

drivers/md/raid0.c

398

return queue_limits_set(mddev->gendisk->queue, &lim);

drivers/md/raid1.c

3187

struct queue_limits lim;

drivers/md/raid1.c

3190

md_init_stacking_limits(&lim);

drivers/md/raid1.c

3191

lim.max_write_zeroes_sectors = 0;

drivers/md/raid1.c

3192

lim.max_hw_wzeroes_unmap_sectors = 0;

drivers/md/raid1.c

3193

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid1.c

3194

lim.features |= BLK_FEAT_ATOMIC_WRITES;

drivers/md/raid1.c

3195

err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY);

drivers/md/raid1.c

3198

return queue_limits_set(mddev->gendisk->queue, &lim);

drivers/md/raid10.c

3931

struct queue_limits lim;

drivers/md/raid10.c

3934

md_init_stacking_limits(&lim);

drivers/md/raid10.c

3935

lim.max_write_zeroes_sectors = 0;

drivers/md/raid10.c

3936

lim.max_hw_wzeroes_unmap_sectors = 0;

drivers/md/raid10.c

3937

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid10.c

3938

lim.io_min = mddev->chunk_sectors << 9;

drivers/md/raid10.c

3939

lim.chunk_sectors = mddev->chunk_sectors;

drivers/md/raid10.c

3940

lim.io_opt = lim.io_min * raid10_nr_stripes(conf);

drivers/md/raid10.c

3941

lim.features |= BLK_FEAT_ATOMIC_WRITES;

drivers/md/raid10.c

3942

err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY);

drivers/md/raid10.c

3945

return queue_limits_set(mddev->gendisk->queue, &lim);

drivers/md/raid5.c

7134

struct queue_limits lim = queue_limits_start_update(q);

drivers/md/raid5.c

7138

lim.features |= BLK_FEAT_STABLE_WRITES;

drivers/md/raid5.c

7140

lim.features &= ~BLK_FEAT_STABLE_WRITES;

drivers/md/raid5.c

7141

err = queue_limits_commit_update(q, &lim);

drivers/md/raid5.c

7763

struct queue_limits lim;

drivers/md/raid5.c

7779

md_init_stacking_limits(&lim);

drivers/md/raid5.c

7780

lim.logical_block_size = mddev->logical_block_size;

drivers/md/raid5.c

7781

lim.io_min = mddev->chunk_sectors << 9;

drivers/md/raid5.c

7782

lim.io_opt = lim.io_min * (conf->raid_disks - conf->max_degraded);

drivers/md/raid5.c

7783

lim.features |= BLK_FEAT_RAID_PARTIAL_STRIPES_EXPENSIVE;

drivers/md/raid5.c

7784

lim.discard_granularity = stripe;

drivers/md/raid5.c

7785

lim.max_write_zeroes_sectors = 0;

drivers/md/raid5.c

7786

lim.max_hw_wzeroes_unmap_sectors = 0;

drivers/md/raid5.c

7787

mddev_stack_rdev_limits(mddev, &lim, 0);

drivers/md/raid5.c

7789

queue_limits_stack_bdev(&lim, rdev->bdev, rdev->new_data_offset,

drivers/md/raid5.c

7807

lim.max_discard_sectors < (stripe >> 9) ||

drivers/md/raid5.c

7808

lim.discard_granularity < stripe)

drivers/md/raid5.c

7809

lim.max_hw_discard_sectors = 0;

drivers/md/raid5.c

7815

lim.max_hw_sectors = RAID5_MAX_REQ_STRIPES << RAID5_STRIPE_SHIFT(conf);

drivers/md/raid5.c

7816

if ((lim.max_hw_sectors << 9) < lim.io_opt)

drivers/md/raid5.c

7817

lim.max_hw_sectors = lim.io_opt >> 9;

drivers/md/raid5.c

7820

lim.max_segments = USHRT_MAX;

drivers/md/raid5.c

7822

return queue_limits_set(mddev->gendisk->queue, &lim);

drivers/media/i2c/ccs-pll.c

157

const struct ccs_pll_limits *lim,

drivers/media/i2c/ccs-pll.c

166

lim_fr = &lim->op_fr;

drivers/media/i2c/ccs-pll.c

169

lim_fr = &lim->vt_fr;

drivers/media/i2c/ccs-pll.c

197

const struct ccs_pll_limits *lim,

drivers/media/i2c/ccs-pll.c

209

lim_bk = &lim->op_bk;

drivers/media/i2c/ccs-pll.c

212

lim_bk = &lim->vt_bk;

drivers/media/i2c/ccs-pll.c

256

ccs_pll_find_vt_sys_div(struct device *dev, const struct ccs_pll_limits *lim,

drivers/media/i2c/ccs-pll.c

265

*min_sys_div = lim->vt_bk.min_sys_clk_div;

drivers/media/i2c/ccs-pll.c

269

lim->vt_bk.max_pix_clk_div));

drivers/media/i2c/ccs-pll.c

273

/ lim->vt_bk.max_sys_clk_freq_hz);

drivers/media/i2c/ccs-pll.c

278

*max_sys_div = lim->vt_bk.max_sys_clk_div;

drivers/media/i2c/ccs-pll.c

282

lim->vt_bk.min_pix_clk_div));

drivers/media/i2c/ccs-pll.c

286

lim->vt_bk.min_pix_clk_freq_hz));

drivers/media/i2c/ccs-pll.c

296

const struct ccs_pll_limits *lim,

drivers/media/i2c/ccs-pll.c

299

const struct ccs_pll_branch_limits_fr *lim_fr = &lim->vt_fr;

drivers/media/i2c/ccs-pll.c

300

const struct ccs_pll_branch_limits_bk *lim_bk = &lim->vt_bk;

drivers/media/i2c/ccs-pll.c

340

ccs_pll_find_vt_sys_div(dev, lim, pll, pll_fr, vt_div, vt_div,

drivers/media/i2c/ccs-pll.c

392

const struct ccs_pll_limits *lim,

drivers/media/i2c/ccs-pll.c

395

const struct ccs_pll_branch_limits_fr *lim_fr = &lim->vt_fr;

drivers/media/i2c/ccs-pll.c

436

rval = __ccs_pll_calculate_vt_tree(dev, lim, pll,

drivers/media/i2c/ccs-pll.c

441

rval = check_fr_bounds(dev, lim, pll, PLL_VT);

drivers/media/i2c/ccs-pll.c

445

rval = check_bk_bounds(dev, lim, pll, PLL_VT);

drivers/media/i2c/ccs-pll.c

457

ccs_pll_calculate_vt(struct device *dev, const struct ccs_pll_limits *lim,

drivers/media/i2c/ccs-pll.c

489

if (lim->min_line_length_pck_bin > lim->min_line_length_pck

drivers/media/i2c/ccs-pll.c

523

lim->vt_bk.max_pix_clk_freq_hz));

drivers/media/i2c/ccs-pll.c

526

min_vt_div = max_t(u16, min_vt_div, lim->vt_bk.min_pix_clk_div

drivers/media/i2c/ccs-pll.c

527

* lim->vt_bk.min_sys_clk_div);

drivers/media/i2c/ccs-pll.c

530

max_vt_div = lim->vt_bk.max_sys_clk_div * lim->vt_bk.max_pix_clk_div;

drivers/media/i2c/ccs-pll.c

534

lim->vt_bk.min_pix_clk_freq_hz));

drivers/media/i2c/ccs-pll.c

538

ccs_pll_find_vt_sys_div(dev, lim, pll, pll_fr, min_vt_div,

drivers/media/i2c/ccs-pll.c

556

if (pix_div < lim->vt_bk.min_pix_clk_div

drivers/media/i2c/ccs-pll.c

557

|| pix_div > lim->vt_bk.max_pix_clk_div) {

drivers/media/i2c/ccs-pll.c

561

lim->vt_bk.min_pix_clk_div,

drivers/media/i2c/ccs-pll.c

562

lim->vt_bk.max_pix_clk_div);

drivers/media/i2c/ccs-pll.c

609

ccs_pll_calculate_op(struct device *dev, const struct ccs_pll_limits *lim,

drivers/media/i2c/ccs-pll.c

727

int ccs_pll_calculate(struct device *dev, const struct ccs_pll_limits *lim,

drivers/media/i2c/ccs-pll.c

753

op_lim_fr = &lim->op_fr;

drivers/media/i2c/ccs-pll.c

754

op_lim_bk = &lim->op_bk;

drivers/media/i2c/ccs-pll.c

763

op_lim_fr = &lim->vt_fr;

drivers/media/i2c/ccs-pll.c

764

op_lim_bk = &lim->vt_bk;

drivers/media/i2c/ccs-pll.c

768

op_lim_fr = &lim->vt_fr;

drivers/media/i2c/ccs-pll.c

769

op_lim_bk = &lim->op_bk;

drivers/media/i2c/ccs-pll.c

856

rval = ccs_pll_calculate_op(dev, lim, op_lim_fr, op_lim_bk, pll,

drivers/media/i2c/ccs-pll.c

863

rval = check_fr_bounds(dev, lim, pll,

drivers/media/i2c/ccs-pll.c

869

rval = check_bk_bounds(dev, lim, pll, PLL_OP);

drivers/media/i2c/ccs-pll.c

876

rval = ccs_pll_calculate_vt(dev, lim, op_lim_bk, pll, op_pll_fr,

drivers/media/i2c/ccs-pll.c

881

rval = check_bk_bounds(dev, lim, pll, PLL_VT);

drivers/media/i2c/ccs-pll.c

897

rval = ccs_pll_calculate_vt_tree(dev, lim, pll);

drivers/media/i2c/ccs/ccs-core.c

105

ccs_limit_offsets[limit + 1].lim))

drivers/media/i2c/ccs/ccs-core.c

108

*__ptr = sensor->ccs_limits + ccs_limit_offsets[limit].lim + offset;

drivers/media/i2c/ccs/ccs-core.c

172

alloc = kzalloc(ccs_limit_offsets[CCS_L_LAST].lim, GFP_KERNEL);

drivers/media/i2c/ccs/ccs-core.c

176

end = alloc + ccs_limit_offsets[CCS_L_LAST].lim;

drivers/media/i2c/ccs/ccs-core.c

228

ptr = alloc + ccs_limit_offsets[l].lim;

drivers/media/i2c/ccs/ccs-core.c

3699

ccs_limit_offsets[l + 1].lim =

drivers/media/i2c/ccs/ccs-core.c

3700

ALIGN(ccs_limit_offsets[l].lim +

drivers/media/i2c/ccs/ccs-core.c

3708

ccs_limit_offsets[l].lim += ccs_limits[i].size;

drivers/media/i2c/ccs/ccs-core.c

43

u16 lim;

drivers/media/i2c/ccs/ccs-core.c

467

struct ccs_pll_limits lim = {

drivers/media/i2c/ccs/ccs-core.c

512

return ccs_pll_calculate(&client->dev, &lim, pll);

drivers/media/platform/samsung/exynos4-is/fimc-core.c

870

struct fimc_pix_limit *lim;

drivers/media/platform/samsung/exynos4-is/fimc-core.c

877

v = devm_kzalloc(dev, sizeof(*v) + sizeof(*lim), GFP_KERNEL);

drivers/media/platform/samsung/exynos4-is/fimc-core.c

890

lim = (struct fimc_pix_limit *)&v[1];

drivers/media/platform/samsung/exynos4-is/fimc-core.c

892

lim->scaler_en_w = args[0];

drivers/media/platform/samsung/exynos4-is/fimc-core.c

893

lim->scaler_dis_w = args[1];

drivers/media/platform/samsung/exynos4-is/fimc-core.c

894

lim->out_rot_en_w = args[2];

drivers/media/platform/samsung/exynos4-is/fimc-core.c

895

lim->out_rot_dis_w = args[3];

drivers/media/platform/samsung/exynos4-is/fimc-core.c

896

v->pix_limit = lim;

drivers/media/usb/pvrusb2/pvrusb2-ctrl.c

22

int lim;

drivers/media/usb/pvrusb2/pvrusb2-ctrl.c

23

lim = cptr->info->def.type_int.min_value;

drivers/media/usb/pvrusb2/pvrusb2-ctrl.c

25

cptr->info->get_min_value(cptr,&lim);

drivers/media/usb/pvrusb2/pvrusb2-ctrl.c

27

if (val < lim) return -ERANGE;

drivers/media/usb/pvrusb2/pvrusb2-ctrl.c

28

lim = cptr->info->def.type_int.max_value;

drivers/media/usb/pvrusb2/pvrusb2-ctrl.c

30

cptr->info->get_max_value(cptr,&lim);

drivers/media/usb/pvrusb2/pvrusb2-ctrl.c

32

if (val > lim) return -ERANGE;

drivers/memstick/core/ms_block.c

2080

struct queue_limits lim = {

drivers/memstick/core/ms_block.c

2100

msb->disk = blk_mq_alloc_disk(&msb->tag_set, &lim, card);

drivers/memstick/core/mspro_block.c

1102

struct queue_limits lim = {

drivers/memstick/core/mspro_block.c

1142

msb->disk = blk_mq_alloc_disk(&msb->tag_set, &lim, card);

drivers/message/fusion/mptsas.c

1712

mptsas_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/message/fusion/mptsas.c

1738

return mptscsih_sdev_configure(sdev, lim);

drivers/message/fusion/mptscsih.c

2342

mptscsih_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/message/fusion/mptscsih.h

121

struct queue_limits *lim);

drivers/message/fusion/mptspi.c

750

struct queue_limits *lim)

drivers/message/fusion/mptspi.c

758

ret = mptscsih_sdev_configure(sdev, lim);

drivers/mmc/core/queue.c

178

struct queue_limits *lim)

drivers/mmc/core/queue.c

186

lim->max_hw_discard_sectors = max_discard;

drivers/mmc/core/queue.c

188

lim->max_secure_erase_sectors = max_discard;

drivers/mmc/core/queue.c

190

lim->max_write_zeroes_sectors = max_discard;

drivers/mmc/core/queue.c

194

lim->discard_granularity = SECTOR_SIZE;

drivers/mmc/core/queue.c

196

lim->discard_granularity = card->pref_erase << 9;

drivers/mmc/core/queue.c

350

struct queue_limits lim = {

drivers/mmc/core/queue.c

356

mmc_queue_setup_discard(card, &lim);

drivers/mmc/core/queue.c

358

lim.max_hw_sectors = min(host->max_blk_count, host->max_req_size / 512);

drivers/mmc/core/queue.c

361

lim.logical_block_size = card->ext_csd.data_sector_size;

drivers/mmc/core/queue.c

363

lim.logical_block_size = 512;

drivers/mmc/core/queue.c

365

WARN_ON_ONCE(lim.logical_block_size != 512 &&

drivers/mmc/core/queue.c

366

lim.logical_block_size != 4096);

drivers/mmc/core/queue.c

373

lim.virt_boundary_mask = dma_get_merge_boundary(mmc_dev(host));

drivers/mmc/core/queue.c

374

lim.max_segments = MMC_DMA_MAP_MERGE_SEGMENTS;

drivers/mmc/core/queue.c

376

lim.max_segment_size =

drivers/mmc/core/queue.c

377

round_down(host->max_seg_size, lim.logical_block_size);

drivers/mmc/core/queue.c

378

lim.max_segments = host->max_segs;

drivers/mmc/core/queue.c

382

lim.features |= BLK_FEAT_STABLE_WRITES;

drivers/mmc/core/queue.c

384

disk = blk_mq_alloc_disk(&mq->tag_set, &lim, mq);

drivers/mtd/mtd_blkdevs.c

280

struct queue_limits lim = { };

drivers/mtd/mtd_blkdevs.c

336

lim.logical_block_size = tr->blksize;

drivers/mtd/mtd_blkdevs.c

338

lim.max_hw_discard_sectors = UINT_MAX;

drivers/mtd/mtd_blkdevs.c

340

lim.features |= BLK_FEAT_WRITE_CACHE;

drivers/mtd/mtd_blkdevs.c

343

gd = blk_mq_alloc_disk(new->tag_set, &lim, new);

drivers/mtd/ubi/block.c

351

struct queue_limits lim = {

drivers/mtd/ubi/block.c

400

gd = blk_mq_alloc_disk(&dev->tag_set, &lim, dev);

drivers/net/wireless/quantenna/qtnfmac/commands.c

1016

const struct qlink_iface_limit *lim;

drivers/net/wireless/quantenna/qtnfmac/commands.c

1078

rec_len = sizeof(*rec) + rec->n_limits * sizeof(*lim);

drivers/net/wireless/quantenna/qtnfmac/commands.c

1098

lim = &rec->limits[i];

drivers/net/wireless/quantenna/qtnfmac/commands.c

1099

limits[i].max = le16_to_cpu(lim->max_num);

drivers/net/wireless/quantenna/qtnfmac/commands.c

1101

qlink_iface_type_to_nl_mask(le16_to_cpu(lim->type));

drivers/nvdimm/btt.c

1498

struct queue_limits lim = {

drivers/nvdimm/btt.c

1507

lim.integrity.metadata_size = btt_meta_size(btt);

drivers/nvdimm/btt.c

1508

lim.integrity.tag_size = btt_meta_size(btt);

drivers/nvdimm/btt.c

1511

btt->btt_disk = blk_alloc_disk(&lim, NUMA_NO_NODE);

drivers/nvdimm/pmem.c

453

struct queue_limits lim = {

drivers/nvdimm/pmem.c

499

lim.features |= BLK_FEAT_FUA;

drivers/nvdimm/pmem.c

501

lim.features |= BLK_FEAT_DAX;

drivers/nvdimm/pmem.c

509

disk = blk_alloc_disk(&lim, nid);

drivers/nvme/host/core.c

1821

struct queue_limits *lim, struct nvme_ns_info *info)

drivers/nvme/host/core.c

1823

struct blk_integrity *bi = &lim->integrity;

drivers/nvme/host/core.c

1886

static void nvme_config_discard(struct nvme_ns *ns, struct queue_limits *lim)

drivers/nvme/host/core.c

1891

lim->max_hw_discard_sectors =

drivers/nvme/host/core.c

1894

lim->max_hw_discard_sectors = UINT_MAX;

drivers/nvme/host/core.c

1896

lim->max_hw_discard_sectors = 0;

drivers/nvme/host/core.c

1898

lim->discard_granularity = lim->logical_block_size;

drivers/nvme/host/core.c

1901

lim->max_discard_segments = ctrl->dmrl;

drivers/nvme/host/core.c

1903

lim->max_discard_segments = NVME_DSM_MAX_RANGES;

drivers/nvme/host/core.c

2031

struct nvme_id_ns *id, struct queue_limits *lim, u32 bs)

drivers/nvme/host/core.c

2055

lim->atomic_write_hw_max = atomic_bs;

drivers/nvme/host/core.c

2056

lim->atomic_write_hw_boundary = boundary;

drivers/nvme/host/core.c

2057

lim->atomic_write_hw_unit_min = bs;

drivers/nvme/host/core.c

2058

lim->atomic_write_hw_unit_max = rounddown_pow_of_two(atomic_bs);

drivers/nvme/host/core.c

2059

lim->features |= BLK_FEAT_ATOMIC_WRITES;

drivers/nvme/host/core.c

2069

struct queue_limits *lim, bool is_admin)

drivers/nvme/host/core.c

2071

lim->max_hw_sectors = ctrl->max_hw_sectors;

drivers/nvme/host/core.c

2072

lim->max_segments = min_t(u32, USHRT_MAX,

drivers/nvme/host/core.c

2074

lim->max_integrity_segments = ctrl->max_integrity_segments;

drivers/nvme/host/core.c

2075

lim->virt_boundary_mask = ctrl->ops->get_virt_boundary(ctrl, is_admin);

drivers/nvme/host/core.c

2076

lim->max_segment_size = UINT_MAX;

drivers/nvme/host/core.c

2077

lim->dma_alignment = 3;

drivers/nvme/host/core.c

2081

struct queue_limits *lim)

drivers/nvme/host/core.c

2099

atomic_bs = nvme_configure_atomic_write(ns, id, lim, bs);

drivers/nvme/host/core.c

2114

lim->logical_block_size = bs;

drivers/nvme/host/core.c

2115

lim->physical_block_size = min(phys_bs, atomic_bs);

drivers/nvme/host/core.c

2116

lim->io_min = phys_bs;

drivers/nvme/host/core.c

2117

lim->io_opt = io_opt;

drivers/nvme/host/core.c

2120

lim->max_write_zeroes_sectors = UINT_MAX;

drivers/nvme/host/core.c

2122

lim->max_write_zeroes_sectors = ns->ctrl->max_zeroes_sectors;

drivers/nvme/host/core.c

2138

struct queue_limits *lim)

drivers/nvme/host/core.c

2166

lim->chunk_sectors = iob;

drivers/nvme/host/core.c

2172

struct queue_limits lim;

drivers/nvme/host/core.c

2176

lim = queue_limits_start_update(ns->disk->queue);

drivers/nvme/host/core.c

2177

nvme_set_ctrl_limits(ns->ctrl, &lim, false);

drivers/nvme/host/core.c

2180

ret = queue_limits_commit_update(ns->disk->queue, &lim);

drivers/nvme/host/core.c

2335

struct queue_limits lim;

drivers/nvme/host/core.c

2375

lim = queue_limits_start_update(ns->disk->queue);

drivers/nvme/host/core.c

2381

nvme_set_ctrl_limits(ns->ctrl, &lim, false);

drivers/nvme/host/core.c

2383

nvme_set_chunk_sectors(ns, id, &lim);

drivers/nvme/host/core.c

2384

if (!nvme_update_disk_info(ns, id, &lim))

drivers/nvme/host/core.c

2387

nvme_config_discard(ns, &lim);

drivers/nvme/host/core.c

2390

nvme_update_zone_info(ns, &lim, &zi);

drivers/nvme/host/core.c

2393

lim.features |= BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA;

drivers/nvme/host/core.c

2395

lim.features &= ~(BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA);

drivers/nvme/host/core.c

2398

lim.features |= BLK_FEAT_ROTATIONAL;

drivers/nvme/host/core.c

2406

if (!nvme_init_integrity(ns->head, &lim, info))

drivers/nvme/host/core.c

2409

lim.max_write_streams = ns->head->nr_plids;

drivers/nvme/host/core.c

2410

if (lim.max_write_streams)

drivers/nvme/host/core.c

2411

lim.write_stream_granularity = min(info->runs, U32_MAX);

drivers/nvme/host/core.c

2413

lim.write_stream_granularity = 0;

drivers/nvme/host/core.c

2423

lim.max_hw_wzeroes_unmap_sectors = lim.max_write_zeroes_sectors;

drivers/nvme/host/core.c

2426

ret = queue_limits_commit_update(ns->disk->queue, &lim);

drivers/nvme/host/core.c

2490

struct queue_limits lim;

drivers/nvme/host/core.c

2493

lim = queue_limits_start_update(ns->head->disk->queue);

drivers/nvme/host/core.c

2510

lim.logical_block_size = ns_lim->logical_block_size;

drivers/nvme/host/core.c

2511

lim.physical_block_size = ns_lim->physical_block_size;

drivers/nvme/host/core.c

2512

lim.io_min = ns_lim->io_min;

drivers/nvme/host/core.c

2513

lim.io_opt = ns_lim->io_opt;

drivers/nvme/host/core.c

2514

queue_limits_stack_bdev(&lim, ns->disk->part0, 0,

drivers/nvme/host/core.c

2519

nvme_init_integrity(ns->head, &lim, info);

drivers/nvme/host/core.c

2520

lim.max_write_streams = ns_lim->max_write_streams;

drivers/nvme/host/core.c

2521

lim.write_stream_granularity = ns_lim->write_stream_granularity;

drivers/nvme/host/core.c

2522

ret = queue_limits_commit_update(ns->head->disk->queue, &lim);

drivers/nvme/host/core.c

3519

struct queue_limits lim;

drivers/nvme/host/core.c

3586

lim = queue_limits_start_update(ctrl->admin_q);

drivers/nvme/host/core.c

3587

nvme_set_ctrl_limits(ctrl, &lim, true);

drivers/nvme/host/core.c

3588

ret = queue_limits_commit_update(ctrl->admin_q, &lim);

drivers/nvme/host/core.c

4106

struct queue_limits lim = { };

drivers/nvme/host/core.c

4117

lim.features |= BLK_FEAT_STABLE_WRITES;

drivers/nvme/host/core.c

4120

lim.features |= BLK_FEAT_PCI_P2PDMA;

drivers/nvme/host/core.c

4122

disk = blk_mq_alloc_disk(ctrl->tagset, &lim, ns);

drivers/nvme/host/core.c

4938

struct queue_limits lim = {

drivers/nvme/host/core.c

4942

ctrl->connect_q = blk_mq_alloc_queue(set, &lim, NULL);

drivers/nvme/host/multipath.c

719

struct queue_limits lim;

drivers/nvme/host/multipath.c

747

blk_set_stacking_limits(&lim);

drivers/nvme/host/multipath.c

748

lim.dma_alignment = 3;

drivers/nvme/host/multipath.c

749

lim.features |= BLK_FEAT_IO_STAT | BLK_FEAT_NOWAIT |

drivers/nvme/host/multipath.c

752

lim.features |= BLK_FEAT_ZONED;

drivers/nvme/host/multipath.c

754

head->disk = blk_alloc_disk(&lim, ctrl->numa_node);

drivers/nvme/host/nvme.h

1176

void nvme_update_zone_info(struct nvme_ns *ns, struct queue_limits *lim,

drivers/nvme/host/zns.c

108

void nvme_update_zone_info(struct nvme_ns *ns, struct queue_limits *lim,

drivers/nvme/host/zns.c

111

lim->features |= BLK_FEAT_ZONED;

drivers/nvme/host/zns.c

112

lim->max_open_zones = zi->max_open_zones;

drivers/nvme/host/zns.c

113

lim->max_active_zones = zi->max_active_zones;

drivers/nvme/host/zns.c

114

lim->max_hw_zone_append_sectors = ns->ctrl->max_zone_append;

drivers/nvme/host/zns.c

115

lim->chunk_sectors = ns->head->zsze =

drivers/regulator/bd9576-regulator.c

217

struct regmap *regmap, int reg, int mask, int lim)

drivers/regulator/bd9576-regulator.c

223

if (lim) {

drivers/regulator/bd9576-regulator.c

226

lim, &sel, &found);

drivers/regulator/bd9576-regulator.c

233

lim);

drivers/regulator/bd9576-regulator.c

465

static int bd9576_set_tw(struct regulator_dev *rdev, int lim, int severity,

drivers/regulator/bd9576-regulator.c

476

if (lim)

drivers/regulator/core.c

1565

int lim = rdev->constraints->over_curr_limits.prot;

drivers/regulator/core.c

1567

ret = ops->set_over_current_protection(rdev, lim,

drivers/regulator/mt6363-regulator.c

634

static int mt6363_set_ocp(struct regulator_dev *rdev, int lim, int severity, bool enable)

drivers/regulator/mt6363-regulator.c

639

if (lim || severity != REGULATOR_SEVERITY_PROT || !enable)

drivers/regulator/qcom-labibb-regulator.c

310

static int qcom_labibb_set_ocp(struct regulator_dev *rdev, int lim,

drivers/regulator/qcom-labibb-regulator.c

322

if (lim || severity != REGULATOR_SEVERITY_PROT || !enable)

drivers/regulator/qcom-labibb-regulator.c

565

struct labibb_current_limits *lim = &vreg->uA_limits;

drivers/regulator/qcom-labibb-regulator.c

569

if (min_uA < lim->uA_min || max_uA < lim->uA_min)

drivers/regulator/qcom-labibb-regulator.c

573

int uA_limit = (lim->uA_step * i) + lim->uA_min;

drivers/regulator/qcom-labibb-regulator.c

587

mask = desc->csel_mask | lim->ovr_val;

drivers/regulator/qcom-labibb-regulator.c

589

val = (u32)sel | lim->ovr_val;

drivers/regulator/qcom-labibb-regulator.c

599

struct labibb_current_limits *lim = &vreg->uA_limits;

drivers/regulator/qcom-labibb-regulator.c

608

return (cur_step * lim->uA_step) + lim->uA_min;

drivers/regulator/rt5759-regulator.c

147

static int rt5759_set_otp(struct regulator_dev *rdev, int lim, int severity,

drivers/regulator/rt5759-regulator.c

161

if (lim == 0)

drivers/regulator/rt5759-regulator.c

162

lim = 150;

drivers/regulator/rt5759-regulator.c

165

if (lim <= otp_lvl[i])

drivers/regulator/stpmic1_regulator.c

35

static int stpmic1_set_icc(struct regulator_dev *rdev, int lim, int severity,

drivers/regulator/stpmic1_regulator.c

495

static int stpmic1_set_icc(struct regulator_dev *rdev, int lim, int severity,

drivers/regulator/stpmic1_regulator.c

512

if (lim || severity != REGULATOR_SEVERITY_PROT || !enable)

drivers/s390/block/dasd.c

300

struct queue_limits lim;

drivers/s390/block/dasd.c

320

lim = queue_limits_start_update(block->gdp->queue);

drivers/s390/block/dasd.c

321

lim.max_dev_sectors = device->discipline->max_sectors(block);

drivers/s390/block/dasd.c

322

lim.max_hw_sectors = lim.max_dev_sectors;

drivers/s390/block/dasd.c

323

lim.logical_block_size = block->bp_block;

drivers/s390/block/dasd.c

328

lim.dma_alignment = lim.logical_block_size - 1;

drivers/s390/block/dasd.c

333

lim.discard_granularity = block->bp_block;

drivers/s390/block/dasd.c

339

lim.max_hw_discard_sectors = max_bytes / block->bp_block;

drivers/s390/block/dasd.c

340

lim.max_write_zeroes_sectors = lim.max_hw_discard_sectors;

drivers/s390/block/dasd.c

342

rc = queue_limits_commit_update(block->gdp->queue, &lim);

drivers/s390/block/dasd_genhd.c

69

struct queue_limits lim = {

drivers/s390/block/dasd_genhd.c

98

gdp = blk_mq_alloc_disk(&block->tag_set, &lim, block);

drivers/s390/block/dcssblk.c

555

struct queue_limits lim = {

drivers/s390/block/dcssblk.c

642

dev_info->gd = blk_alloc_disk(&lim, NUMA_NO_NODE);

drivers/s390/block/scm_blk.c

436

struct queue_limits lim = {

drivers/s390/block/scm_blk.c

442

lim.max_segments = min(scmdev->nr_max_block,

drivers/s390/block/scm_blk.c

444

lim.max_hw_sectors = lim.max_segments << 3; /* 8 * 512 = blk_size */

drivers/s390/block/scm_blk.c

468

bdev->gendisk = blk_mq_alloc_disk(&bdev->tag_set, &lim, scmdev);

drivers/s390/scsi/zfcp_scsi.c

52

struct queue_limits *lim)

drivers/scsi/3w-9xxx.c

1972

struct queue_limits *lim)

drivers/scsi/3w-sas.c

1529

struct queue_limits *lim)

drivers/scsi/3w-xxxx.c

2224

static int tw_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/53c700.c

163

struct queue_limits *lim);

drivers/scsi/53c700.c

2032

NCR_700_sdev_configure(struct scsi_device *SDp, struct queue_limits *lim)

drivers/scsi/BusLogic.c

2166

struct queue_limits *lim)

drivers/scsi/BusLogic.h

1279

struct queue_limits *lim);

drivers/scsi/aacraid/linit.c

390

struct queue_limits *lim)

drivers/scsi/advansys.c

7394

struct queue_limits *lim)

drivers/scsi/aic7xxx/aic79xx_osm.c

704

ahd_linux_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/aic7xxx/aic7xxx_osm.c

667

ahc_linux_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/am53c974.c

142

int lim = 1000;

drivers/scsi/am53c974.c

150

while (--lim > 0) {

drivers/scsi/am53c974.c

164

lim = 1000;

drivers/scsi/am53c974.c

167

if (--lim == 0)

drivers/scsi/am53c974.c

172

esp_dma_log("DMA blast done (%d tries, %d bytes left)\n", lim, resid);

drivers/scsi/arcmsr/arcmsr_hba.c

148

struct queue_limits *lim);

drivers/scsi/arcmsr/arcmsr_hba.c

3350

struct queue_limits *lim)

drivers/scsi/bfa/bfad_im.c

788

bfad_im_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/bnx2fc/bnx2fc_fcoe.c

2652

struct queue_limits *lim)

drivers/scsi/csiostor/csio_scsi.c

2241

csio_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/esp_scsi.c

205

int lim = 1000;

drivers/scsi/esp_scsi.c

208

if (--lim == 0) {

drivers/scsi/esp_scsi.c

2466

static int esp_sdev_configure(struct scsi_device *dev, struct queue_limits *lim)

drivers/scsi/hisi_sas/hisi_sas.h

666

int hisi_sas_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim);

drivers/scsi/hisi_sas/hisi_sas_main.c

903

int hisi_sas_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/hisi_sas/hisi_sas_main.c

906

int ret = sas_sdev_configure(sdev, lim);

drivers/scsi/hisi_sas/hisi_sas_v3_hw.c

2966

struct queue_limits *lim)

drivers/scsi/hisi_sas/hisi_sas_v3_hw.c

2970

int ret = hisi_sas_sdev_configure(sdev, lim);

drivers/scsi/hpsa.c

2140

struct queue_limits *lim)

drivers/scsi/hpsa.c

289

struct queue_limits *lim);

drivers/scsi/hptiop.c

1155

struct queue_limits *lim)

drivers/scsi/hptiop.c

1158

lim->max_hw_sectors = 8192;

drivers/scsi/ibmvscsi/ibmvfc.c

3456

struct queue_limits *lim)

drivers/scsi/ibmvscsi/ibmvscsi.c

1874

struct queue_limits *lim)

drivers/scsi/ipr.c

4782

struct queue_limits *lim)

drivers/scsi/ipr.c

4803

lim->max_hw_sectors = IPR_VSET_MAX_SECTORS;

drivers/scsi/ips.c

1178

ips_sdev_configure(struct scsi_device *SDptr, struct queue_limits *lim)

drivers/scsi/ips.h

404

struct queue_limits *lim);

drivers/scsi/iscsi_tcp.c

1017

struct queue_limits *lim)

drivers/scsi/iscsi_tcp.c

1024

lim->features |= BLK_FEAT_STABLE_WRITES;

drivers/scsi/libsas/sas_scsi_host.c

809

int sas_sdev_configure(struct scsi_device *scsi_dev, struct queue_limits *lim)

drivers/scsi/libsas/sas_scsi_host.c

816

ata_sas_sdev_configure(scsi_dev, lim, dev->sata_dev.ap);

drivers/scsi/lpfc/lpfc_scsi.c

6369

lpfc_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/lpfc/lpfc_scsi.c

6759

lpfc_config_no_sdev(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/megaraid/megaraid_sas.h

2704

struct queue_limits *lim, bool is_target_prop);

drivers/scsi/megaraid/megaraid_sas_base.c

1890

struct queue_limits *lim, bool is_target_prop)

drivers/scsi/megaraid/megaraid_sas_base.c

1918

if (lim)

drivers/scsi/megaraid/megaraid_sas_base.c

1919

lim->dma_alignment = 0x7;

drivers/scsi/megaraid/megaraid_sas_base.c

1972

struct queue_limits *lim, u32 max_io_size)

drivers/scsi/megaraid/megaraid_sas_base.c

1981

lim->max_hw_sectors = max_io_size / 512;

drivers/scsi/megaraid/megaraid_sas_base.c

1982

lim->virt_boundary_mask = mr_nvme_pg_size - 1;

drivers/scsi/megaraid/megaraid_sas_base.c

2044

struct queue_limits *lim, bool is_target_prop)

drivers/scsi/megaraid/megaraid_sas_base.c

2063

megasas_set_nvme_device_properties(sdev, lim,

drivers/scsi/megaraid/megaraid_sas_base.c

2071

struct queue_limits *lim)

drivers/scsi/megaraid/megaraid_sas_base.c

2101

megasas_set_static_target_properties(sdev, lim, is_target_prop);

drivers/scsi/megaraid/megaraid_sas_base.c

2104

megasas_set_dynamic_target_properties(sdev, lim, is_target_prop);

drivers/scsi/mpi3mr/mpi3mr_app.c

3035

struct queue_limits lim = {

drivers/scsi/mpi3mr/mpi3mr_app.c

3055

q = bsg_setup_queue(bsg_dev, dev_name(bsg_dev), &lim,

drivers/scsi/mpi3mr/mpi3mr_os.c

1037

struct queue_limits *lim)

drivers/scsi/mpi3mr/mpi3mr_os.c

1041

lim->max_hw_sectors = tgt_dev->dev_spec.pcie_inf.mdts / 512;

drivers/scsi/mpi3mr/mpi3mr_os.c

1042

lim->virt_boundary_mask = (1 << pgsz) - 1;

drivers/scsi/mpi3mr/mpi3mr_os.c

1046

struct queue_limits *lim)

drivers/scsi/mpi3mr/mpi3mr_os.c

1052

mpi3mr_configure_nvme_dev(tgt_dev, lim);

drivers/scsi/mpi3mr/mpi3mr_os.c

1070

struct queue_limits lim;

drivers/scsi/mpi3mr/mpi3mr_os.c

1078

lim = queue_limits_start_update(sdev->request_queue);

drivers/scsi/mpi3mr/mpi3mr_os.c

1079

mpi3mr_configure_tgt_dev(tgtdev, &lim);

drivers/scsi/mpi3mr/mpi3mr_os.c

1080

WARN_ON_ONCE(queue_limits_commit_update(sdev->request_queue, &lim));

drivers/scsi/mpi3mr/mpi3mr_os.c

4817

struct queue_limits *lim)

drivers/scsi/mpi3mr/mpi3mr_os.c

4848

mpi3mr_configure_tgt_dev(tgt_dev, lim);

drivers/scsi/mpt3sas/mpt3sas_scsih.c

2570

scsih_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/mpt3sas/mpt3sas_scsih.c

2677

lim->max_hw_sectors = MPT3SAS_RAID_MAX_SECTORS;

drivers/scsi/mpt3sas/mpt3sas_scsih.c

2742

lim->max_hw_sectors = pcie_device->nvme_mdts / 512;

drivers/scsi/mpt3sas/mpt3sas_scsih.c

2748

lim->virt_boundary_mask = ioc->page_size - 1;

drivers/scsi/mvumi.c

2003

struct queue_limits *lim)

drivers/scsi/myrb.c

1717

struct queue_limits *lim)

drivers/scsi/myrs.c

1886

struct queue_limits *lim)

drivers/scsi/ncr53c8xx.c

7800

struct queue_limits *lim)

drivers/scsi/pmcraid.c

214

struct queue_limits *lim)

drivers/scsi/pmcraid.c

238

lim->max_hw_sectors = PMCRAID_VSET_MAX_SECTORS;

drivers/scsi/ps3rom.c

65

struct queue_limits *lim)

drivers/scsi/qedf/qedf_main.c

986

struct queue_limits *lim)

drivers/scsi/qla1280.c

1175

qla1280_sdev_configure(struct scsi_device *device, struct queue_limits *lim)

drivers/scsi/qla2xxx/qla_os.c

1948

qla2xxx_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/qlogicpti.c

979

struct queue_limits *lim)

drivers/scsi/scsi_debug.c

6632

struct queue_limits *lim)

drivers/scsi/scsi_lib.c

2019

void scsi_init_limits(struct Scsi_Host *shost, struct queue_limits *lim)

drivers/scsi/scsi_lib.c

2023

memset(lim, 0, sizeof(*lim));

drivers/scsi/scsi_lib.c

2024

lim->max_segments =

drivers/scsi/scsi_lib.c

2032

lim->max_integrity_segments = shost->sg_prot_tablesize;

drivers/scsi/scsi_lib.c

2035

lim->max_hw_sectors = shost->max_sectors;

drivers/scsi/scsi_lib.c

2036

lim->seg_boundary_mask = shost->dma_boundary;

drivers/scsi/scsi_lib.c

2037

lim->max_segment_size = shost->max_segment_size;

drivers/scsi/scsi_lib.c

2038

lim->virt_boundary_mask = shost->virt_boundary_mask;

drivers/scsi/scsi_lib.c

2039

lim->dma_alignment = max_t(unsigned int,

drivers/scsi/scsi_scan.c

1079

lim = queue_limits_start_update(sdev->request_queue);

drivers/scsi/scsi_scan.c

1081

lim.max_hw_sectors = 512;

drivers/scsi/scsi_scan.c

1083

lim.max_hw_sectors = 1024;

drivers/scsi/scsi_scan.c

1086

ret = hostt->sdev_configure(sdev, &lim);

drivers/scsi/scsi_scan.c

1099

ret = queue_limits_commit_update(sdev->request_queue, &lim);

drivers/scsi/scsi_scan.c

288

struct queue_limits lim;

drivers/scsi/scsi_scan.c

338

scsi_init_limits(shost, &lim);

drivers/scsi/scsi_scan.c

339

q = blk_mq_alloc_queue(&sdev->host->tag_set, &lim, sdev);

drivers/scsi/scsi_scan.c

879

struct queue_limits lim;

drivers/scsi/scsi_transport_fc.c

4329

struct queue_limits lim;

drivers/scsi/scsi_transport_fc.c

4340

scsi_init_limits(shost, &lim);

drivers/scsi/scsi_transport_fc.c

4341

lim.max_segments = min_not_zero(lim.max_segments, i->f->max_bsg_segments);

drivers/scsi/scsi_transport_fc.c

4342

q = bsg_setup_queue(dev, bsg_name, &lim, fc_bsg_dispatch,

drivers/scsi/scsi_transport_fc.c

4365

struct queue_limits lim;

drivers/scsi/scsi_transport_fc.c

4373

scsi_init_limits(shost, &lim);

drivers/scsi/scsi_transport_fc.c

4374

lim.max_segments = min_not_zero(lim.max_segments, i->f->max_bsg_segments);

drivers/scsi/scsi_transport_fc.c

4375

q = bsg_setup_queue(dev, dev_name(dev), &lim, fc_bsg_dispatch_prep,

drivers/scsi/scsi_transport_iscsi.c

1538

struct queue_limits lim;

drivers/scsi/scsi_transport_iscsi.c

1546

scsi_init_limits(shost, &lim);

drivers/scsi/scsi_transport_iscsi.c

1547

q = bsg_setup_queue(dev, bsg_name, &lim, iscsi_bsg_host_dispatch, NULL,

drivers/scsi/sd.c

1026

lim->atomic_write_hw_max = max_atomic * logical_block_size;

drivers/scsi/sd.c

1027

lim->atomic_write_hw_boundary = 0;

drivers/scsi/sd.c

1028

lim->atomic_write_hw_unit_min = unit_min * logical_block_size;

drivers/scsi/sd.c

1029

lim->atomic_write_hw_unit_max = unit_max * logical_block_size;

drivers/scsi/sd.c

1030

lim->features |= BLK_FEAT_ATOMIC_WRITES;

drivers/scsi/sd.c

106

struct queue_limits *lim);

drivers/scsi/sd.c

1123

struct queue_limits *lim)

drivers/scsi/sd.c

1178

lim->max_write_zeroes_sectors =

drivers/scsi/sd.c

1183

lim->max_hw_wzeroes_unmap_sectors =

drivers/scsi/sd.c

1184

lim->max_write_zeroes_sectors;

drivers/scsi/sd.c

125

static void sd_config_discard(struct scsi_disk *sdkp, struct queue_limits *lim,

drivers/scsi/sd.c

131

lim->discard_alignment = sdkp->unmap_alignment * logical_block_size;

drivers/scsi/sd.c

132

lim->discard_granularity = max(sdkp->physical_block_size,

drivers/scsi/sd.c

171

lim->max_hw_discard_sectors = max_blocks *

drivers/scsi/sd.c

176

struct queue_limits *lim)

drivers/scsi/sd.c

179

lim->features |= BLK_FEAT_WRITE_CACHE;

drivers/scsi/sd.c

181

lim->features |= BLK_FEAT_FUA;

drivers/scsi/sd.c

183

lim->features &= ~BLK_FEAT_FUA;

drivers/scsi/sd.c

185

lim->features &= ~(BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA);

drivers/scsi/sd.c

224

struct queue_limits lim;

drivers/scsi/sd.c

229

lim = queue_limits_start_update(sdkp->disk->queue);

drivers/scsi/sd.c

230

sd_set_flush_flag(sdkp, &lim);

drivers/scsi/sd.c

232

&lim);

drivers/scsi/sd.c

2610

struct queue_limits *lim)

drivers/scsi/sd.c

2615

sd_dif_config_host(sdkp, lim);

drivers/scsi/sd.c

2664

struct queue_limits *lim, unsigned char *buffer)

drivers/scsi/sd.c

2738

lim->alignment_offset = alignment;

drivers/scsi/sd.c

2850

sd_read_capacity(struct scsi_disk *sdkp, struct queue_limits *lim,

drivers/scsi/sd.c

2857

sector_size = read_capacity_16(sdkp, sdp, lim, buffer);

drivers/scsi/sd.c

2877

sector_size = read_capacity_16(sdkp, sdp, lim, buffer);

drivers/scsi/sd.c

2936

lim->logical_block_size = sector_size;

drivers/scsi/sd.c

2937

lim->physical_block_size = sdkp->physical_block_size;

drivers/scsi/sd.c

3368

struct queue_limits *lim)

drivers/scsi/sd.c

3409

sd_config_atomic(sdkp, lim);

drivers/scsi/sd.c

3430

struct queue_limits *lim)

drivers/scsi/sd.c

3448

lim->features &= ~(BLK_FEAT_ROTATIONAL | BLK_FEAT_ADD_RANDOM);

drivers/scsi/sd.c

3723

struct queue_limits *lim = NULL;

drivers/scsi/sd.c

3738

lim = kmalloc_obj(*lim);

drivers/scsi/sd.c

3739

if (!lim)

drivers/scsi/sd.c

3748

*lim = queue_limits_start_update(sdkp->disk->queue);

drivers/scsi/sd.c

3755

sd_read_capacity(sdkp, lim, buffer);

drivers/scsi/sd.c

3769

lim->features |= (BLK_FEAT_ROTATIONAL | BLK_FEAT_ADD_RANDOM);

drivers/scsi/sd.c

3773

sd_read_block_limits(sdkp, lim);

drivers/scsi/sd.c

3775

sd_read_block_characteristics(sdkp, lim);

drivers/scsi/sd.c

3776

sd_zbc_read_zones(sdkp, lim, buffer);

drivers/scsi/sd.c

3779

sd_config_discard(sdkp, lim, sd_discard_mode(sdkp));

drivers/scsi/sd.c

3789

sd_config_protection(sdkp, lim);

drivers/scsi/sd.c

3796

sd_set_flush_flag(sdkp, lim);

drivers/scsi/sd.c

3803

lim->max_dev_sectors = logical_to_sectors(sdp, dev_max);

drivers/scsi/sd.c

3806

lim->io_min = logical_to_bytes(sdp, sdkp->min_xfer_blocks);

drivers/scsi/sd.c

3808

lim->io_min = 0;

drivers/scsi/sd.c

3815

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

drivers/scsi/sd.c

3817

lim->io_opt = min_not_zero(lim->io_opt,

drivers/scsi/sd.c

3824

sd_config_write_same(sdkp, lim);

drivers/scsi/sd.c

3826

err = queue_limits_commit_update_frozen(sdkp->disk->queue, lim);

drivers/scsi/sd.c

3848

kfree(lim);

drivers/scsi/sd.c

550

struct queue_limits lim;

drivers/scsi/sd.c

563

lim = queue_limits_start_update(sdkp->disk->queue);

drivers/scsi/sd.c

564

sd_config_discard(sdkp, &lim, mode);

drivers/scsi/sd.c

565

err = queue_limits_commit_update_frozen(sdkp->disk->queue, &lim);

drivers/scsi/sd.c

650

struct queue_limits lim;

drivers/scsi/sd.c

672

lim = queue_limits_start_update(sdkp->disk->queue);

drivers/scsi/sd.c

673

sd_config_write_same(sdkp, &lim);

drivers/scsi/sd.c

674

err = queue_limits_commit_update_frozen(sdkp->disk->queue, &lim);

drivers/scsi/sd.c

974

static void sd_config_atomic(struct scsi_disk *sdkp, struct queue_limits *lim)

drivers/scsi/sd.h

231

void sd_dif_config_host(struct scsi_disk *sdkp, struct queue_limits *lim);

drivers/scsi/sd.h

235

int sd_zbc_read_zones(struct scsi_disk *sdkp, struct queue_limits *lim,

drivers/scsi/sd.h

248

struct queue_limits *lim, u8 buf[SD_BUF_SIZE])

drivers/scsi/sd_dif.c

27

void sd_dif_config_host(struct scsi_disk *sdkp, struct queue_limits *lim)

drivers/scsi/sd_dif.c

31

struct blk_integrity *bi = &lim->integrity;

drivers/scsi/sd_zbc.c

589

int sd_zbc_read_zones(struct scsi_disk *sdkp, struct queue_limits *lim,

drivers/scsi/sd_zbc.c

599

lim->features |= BLK_FEAT_ZONED;

drivers/scsi/sd_zbc.c

606

lim->zone_write_granularity = sdkp->physical_block_size;

drivers/scsi/sd_zbc.c

629

lim->max_open_zones = 0;

drivers/scsi/sd_zbc.c

631

lim->max_open_zones = sdkp->zones_max_open;

drivers/scsi/sd_zbc.c

632

lim->max_active_zones = 0;

drivers/scsi/sd_zbc.c

633

lim->chunk_sectors = logical_to_sectors(sdkp->device, zone_blocks);

drivers/scsi/smartpqi/smartpqi_init.c

6612

struct queue_limits *lim)

drivers/scsi/snic/snic_main.c

64

snic_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/sr.c

480

struct queue_limits lim;

drivers/scsi/sr.c

489

lim = queue_limits_start_update(q);

drivers/scsi/sr.c

490

lim.logical_block_size = sector_size;

drivers/scsi/sr.c

491

lim.features |= BLK_FEAT_ROTATIONAL;

drivers/scsi/sr.c

492

return queue_limits_commit_update_frozen(q, &lim);

drivers/scsi/stex.c

587

stex_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/scsi/storvsc_drv.c

1585

struct queue_limits *lim)

drivers/scsi/sun3x_esp.c

109

int lim;

drivers/scsi/sun3x_esp.c

111

lim = 1000;

drivers/scsi/sun3x_esp.c

113

if (--lim == 0) {

drivers/scsi/sun3x_esp.c

87

int lim;

drivers/scsi/sun3x_esp.c

95

lim = 1000;

drivers/scsi/sun3x_esp.c

97

if (--lim == 0) {

drivers/scsi/sun_esp.c

225

int can_do_sbus64, lim;

drivers/scsi/sun_esp.c

265

lim = 1000;

drivers/scsi/sun_esp.c

267

if (--lim == 0) {

drivers/scsi/sun_esp.c

324

int lim;

drivers/scsi/sun_esp.c

336

lim = 1000;

drivers/scsi/sun_esp.c

338

if (--lim == 0) {

drivers/scsi/sun_esp.c

366

int lim;

drivers/scsi/sun_esp.c

368

lim = 1000;

drivers/scsi/sun_esp.c

370

if (--lim == 0) {

drivers/scsi/sym53c8xx_2/sym_glue.c

829

struct queue_limits *lim)

drivers/scsi/xen-scsifront.c

739

struct queue_limits *lim)

drivers/staging/media/meson/vdec/codec_vp9.c

398

u8 lim;

drivers/staging/media/meson/vdec/codec_vp9.c

527

lfi->lfthr[lvl].lim = (u8)block_inside_limit;

drivers/staging/media/meson/vdec/codec_vp9.c

552

thr = ((lfi->lfthr[i * 2 + 1].lim & 0x3f) << 8) |

drivers/staging/media/meson/vdec/codec_vp9.c

554

thr = (thr << 16) | ((lfi->lfthr[i * 2].lim & 0x3f) << 8) |

drivers/staging/media/meson/vdec/codec_vp9.c

598

thr = ((lfi->lfthr[i * 2 + 1].lim & 0x3f) << 8) |

drivers/staging/media/meson/vdec/codec_vp9.c

601

((lfi->lfthr[i * 2].lim & 0x3f) << 8) |

drivers/ufs/core/ufshcd.c

5333

struct queue_limits *lim)

drivers/ufs/core/ufshcd.c

5338

lim->dma_pad_mask = PRDT_DATA_BYTE_COUNT_PAD - 1;

drivers/usb/core/devio.c

148

u64 lim, total_mem;

drivers/usb/core/devio.c

152

lim = READ_ONCE(usbfs_memory_mb);

drivers/usb/core/devio.c

153

lim <<= 20;

drivers/usb/core/devio.c

158

if (lim > 0 && total_mem > lim)

drivers/usb/storage/scsiglue.c

106

lim->max_hw_sectors = min(lim->max_hw_sectors, max_sectors);

drivers/usb/storage/scsiglue.c

113

lim->max_hw_sectors = 0x7FFFFF;

drivers/usb/storage/scsiglue.c

119

lim->max_hw_sectors = 2048;

drivers/usb/storage/scsiglue.c

126

lim->max_hw_sectors = min_t(size_t,

drivers/usb/storage/scsiglue.c

127

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

drivers/usb/storage/scsiglue.c

588

struct queue_limits lim;

drivers/usb/storage/scsiglue.c

595

lim = queue_limits_start_update(sdev->request_queue);

drivers/usb/storage/scsiglue.c

596

lim.max_hw_sectors = ms;

drivers/usb/storage/scsiglue.c

597

ret = queue_limits_commit_update_frozen(sdev->request_queue, &lim);

drivers/usb/storage/scsiglue.c

91

static int sdev_configure(struct scsi_device *sdev, struct queue_limits *lim)

drivers/usb/storage/uas.c

846

struct queue_limits *lim)

drivers/usb/storage/uas.c

851

lim->max_hw_sectors = 64;

drivers/usb/storage/uas.c

853

lim->max_hw_sectors = 240;

fs/btrfs/ioctl.c

3759

ret = btrfs_limit_qgroup(trans, qgroupid, &sa->lim);

fs/btrfs/qgroup.c

3453

dstgroup->lim_flags = inherit->lim.flags;

fs/btrfs/qgroup.c

3454

dstgroup->max_rfer = inherit->lim.max_rfer;

fs/btrfs/qgroup.c

3455

dstgroup->max_excl = inherit->lim.max_excl;

fs/btrfs/qgroup.c

3456

dstgroup->rsv_rfer = inherit->lim.rsv_rfer;

fs/btrfs/qgroup.c

3457

dstgroup->rsv_excl = inherit->lim.rsv_excl;

fs/btrfs/zoned.c

694

struct queue_limits *lim = &fs_info->limits;

fs/btrfs/zoned.c

706

blk_set_stacking_limits(lim);

fs/btrfs/zoned.c

729

blk_stack_limits(lim, bdev_limits(device->bdev), 0);

fs/btrfs/zoned.c

732

ret = blk_validate_limits(lim);

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

766

(u64)lim->max_segments << PAGE_SHIFT),

fs/iomap/ioend.c

446

struct queue_limits *lim = bdev_limits(bio->bi_bdev);

fs/iomap/ioend.c

449

lim->max_zone_append_sectors << SECTOR_SHIFT);

fs/iomap/ioend.c

451

sector_offset = bio_split_rw_at(bio, lim, &nr_segs, max_len);

fs/jfs/jfs_dtree.c

577

int base, index, lim;

fs/jfs/jfs_dtree.c

634

for (base = 0, lim = p->header.nextindex; lim; lim >>= 1) {

fs/jfs/jfs_dtree.c

635

index = base + (lim >> 1);

fs/jfs/jfs_dtree.c

715

--lim;

fs/jfs/jfs_xtree.c

240

int base, index, lim, btindex;

fs/jfs/jfs_xtree.c

367

lim = le16_to_cpu(p->header.nextindex) - XTENTRYSTART;

fs/jfs/jfs_xtree.c

372

for (base = XTENTRYSTART; lim; lim >>= 1) {

fs/jfs/jfs_xtree.c

373

index = base + (lim >> 1);

fs/jfs/jfs_xtree.c

423

--lim;

fs/ntfs3/bitmap.c

1552

unsigned int k, lim = bits / BITS_PER_LONG;

fs/ntfs3/bitmap.c

1555

for (k = 0; k < lim; k++)

fs/xfs/xfs_zone_gc.c

754

struct queue_limits *lim =

fs/xfs/xfs_zone_gc.c

765

split_sectors = bio_split_rw_at(&chunk->bio, lim, &nsegs,

fs/xfs/xfs_zone_gc.c

766

lim->max_zone_append_sectors << SECTOR_SHIFT);

include/linux/bcm47xx_nvram.h

14

int bcm47xx_nvram_init_from_mem(u32 base, u32 lim);

include/linux/bcm47xx_nvram.h

28

static inline int bcm47xx_nvram_init_from_mem(u32 base, u32 lim)

include/linux/bio.h

319

int bio_split_io_at(struct bio *bio, const struct queue_limits *lim,

include/linux/blk-mq.h

728

struct queue_limits *lim, void *queuedata,

include/linux/blk-mq.h

730

#define blk_mq_alloc_disk(set, lim, queuedata) \

include/linux/blk-mq.h

734

__blk_mq_alloc_disk(set, lim, queuedata, &__key); \

include/linux/blk-mq.h

739

struct queue_limits *lim, void *queuedata);

include/linux/blkdev.h

1092

struct queue_limits *lim);

include/linux/blkdev.h

1094

struct queue_limits *lim);

include/linux/blkdev.h

1095

int queue_limits_set(struct request_queue *q, struct queue_limits *lim);

include/linux/blkdev.h

1096

int blk_validate_limits(struct queue_limits *lim);

include/linux/blkdev.h

1138

extern void blk_set_stacking_limits(struct queue_limits *lim);

include/linux/blkdev.h

1599

blk_lim_dma_alignment_and_pad(struct queue_limits *lim)

include/linux/blkdev.h

1601

return lim->dma_alignment | lim->dma_pad_mask;

include/linux/blkdev.h

1874

const struct queue_limits *lim,

include/linux/blkdev.h

1877

return bio_split_io_at(bio, lim, segs, max_bytes, lim->dma_alignment);

include/linux/blkdev.h

967

struct gendisk *__blk_alloc_disk(struct queue_limits *lim, int node,

include/linux/blkdev.h

982

#define blk_alloc_disk(lim, node_id) \

include/linux/blkdev.h

986

__blk_alloc_disk(lim, node_id, &__key); \

include/linux/libata.h

1214

int ata_scsi_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim);

include/linux/libata.h

1314

int ata_sas_sdev_configure(struct scsi_device *sdev, struct queue_limits *lim,

include/linux/regulator/driver.h

184

int (*set_thermal_protection)(struct regulator_dev *, int lim,

include/scsi/libsas.h

695

int sas_sdev_configure(struct scsi_device *dev, struct queue_limits *lim);

include/scsi/scsi_host.h

223

int (* sdev_configure)(struct scsi_device *, struct queue_limits *lim);

include/scsi/scsi_transport.h

86

void scsi_init_limits(struct Scsi_Host *shost, struct queue_limits *lim);

include/uapi/linux/btrfs.h

102

struct btrfs_qgroup_limit lim;

include/uapi/linux/btrfs.h

108

struct btrfs_qgroup_limit lim;

kernel/rcu/tasks.h

249

int lim;

kernel/rcu/tasks.h

260

lim = rcu_task_enqueue_lim;

kernel/rcu/tasks.h

289

if (lim > rcu_task_cpu_ids)

kernel/rcu/tasks.h

290

lim = rcu_task_cpu_ids;

kernel/rcu/tasks.h

291

shift = ilog2(rcu_task_cpu_ids / lim);

kernel/rcu/tasks.h

292

if (((rcu_task_cpu_ids - 1) >> shift) >= lim)

kernel/rcu/tasks.h

295

WRITE_ONCE(rtp->percpu_dequeue_lim, lim);

kernel/rcu/tasks.h

296

smp_store_release(&rtp->percpu_enqueue_lim, lim);

lib/bitmap.c

105

if (!rem || off + k + 1 >= lim)

lib/bitmap.c

109

if (off + k + 1 == lim - 1)

lib/bitmap.c

114

if (off + k == lim - 1)

lib/bitmap.c

120

memset(&dst[lim - off], 0, off*sizeof(unsigned long));

lib/bitmap.c

141

unsigned int lim = BITS_TO_LONGS(nbits);

lib/bitmap.c

143

for (k = lim - off - 1; k >= 0; --k) {

lib/bitmap.c

233

unsigned int lim = bits/BITS_PER_LONG;

lib/bitmap.c

236

for (k = 0; k < lim; k++)

lib/bitmap.c

271

unsigned int lim = bits/BITS_PER_LONG;

lib/bitmap.c

274

for (k = 0; k < lim; k++)

lib/bitmap.c

298

unsigned int k, lim = bits/BITS_PER_LONG;

lib/bitmap.c

299

for (k = 0; k < lim; ++k)

lib/bitmap.c

313

unsigned int k, lim = bits/BITS_PER_LONG;

lib/bitmap.c

314

for (k = 0; k < lim; ++k)

lib/bitmap.c

40

unsigned int k, lim = bits/BITS_PER_LONG;

lib/bitmap.c

41

for (k = 0; k < lim; ++k)

lib/bitmap.c

58

unsigned int k, lim = bits / BITS_PER_LONG;

lib/bitmap.c

61

for (k = 0; k < lim; ++k) {

lib/bitmap.c

75

unsigned int k, lim = BITS_TO_LONGS(bits);

lib/bitmap.c

76

for (k = 0; k < lim; ++k)

lib/bitmap.c

95

unsigned k, lim = BITS_TO_LONGS(nbits);

lib/bitmap.c

98

for (k = 0; off + k < lim; ++k) {

lib/vsprintf.c

652

int lim = spec.precision;

lib/vsprintf.c

654

while (lim--) {

lib/zstd/compress/zstd_lazy.c

846

U32 const lim = idx + MIN(ZSTD_ROW_HASH_CACHE_SIZE, maxElemsToPrefetch);

lib/zstd/compress/zstd_lazy.c

848

for (; idx < lim; ++idx) {

net/tipc/crypto.c

255

static void tipc_aead_users_inc(struct tipc_aead __rcu *aead, int lim);

net/tipc/crypto.c

256

static void tipc_aead_users_dec(struct tipc_aead __rcu *aead, int lim);

net/tipc/crypto.c

445

static void tipc_aead_users_inc(struct tipc_aead __rcu *aead, int lim)

net/tipc/crypto.c

452

atomic_add_unless(&tmp->users, 1, lim);

net/tipc/crypto.c

456

static void tipc_aead_users_dec(struct tipc_aead __rcu *aead, int lim)

net/tipc/crypto.c

463

atomic_add_unless(&tmp->users, -1, lim);

net/tipc/socket.c

2431

unsigned int lim;

net/tipc/socket.c

2453

lim = rcvbuf_limit(sk, skb) + atomic_read(dcnt);

net/tipc/socket.c

2454

if (likely(!sk_add_backlog(sk, skb, lim))) {

net/tipc/socket.c

3902

unsigned int lim = rcvbuf_limit(sk, skb) + atomic_read(dcnt);

net/tipc/socket.c

3905

return (qsize > lim * 90 / 100);

net/tipc/socket.c

3919

unsigned int lim = rcvbuf_limit(sk, skb);

net/tipc/socket.c

3922

return (qsize > lim * 90 / 100);

tools/include/nolibc/stdlib.h

242

unsigned long lim;

tools/include/nolibc/stdlib.h

248

for (dig = 0, lim = 1; dig < pos; dig++)

tools/include/nolibc/stdlib.h

249

lim *= 10;

tools/include/nolibc/stdlib.h

251

if (digits || in >= lim || !pos) {

tools/include/nolibc/stdlib.h

252

for (dig = 0; in >= lim; dig++)

tools/include/nolibc/stdlib.h

253

in -= lim;

tools/include/nolibc/stdlib.h

378

unsigned long long lim;

tools/include/nolibc/stdlib.h

384

for (dig = 0, lim = 1; dig < pos; dig++)

tools/include/nolibc/stdlib.h

385

lim *= 10;

tools/include/nolibc/stdlib.h

387

if (digits || in >= lim || !pos) {

tools/include/nolibc/stdlib.h

388

for (dig = 0; in >= lim; dig++)

tools/include/nolibc/stdlib.h

389

in -= lim;

tools/lib/bitmap.c

10

unsigned int k, w = 0, lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

12

for (k = 0; k < lim; k++)

tools/lib/bitmap.c

148

unsigned int lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

151

for (k = 0; k < lim; k++)

tools/lib/bitmap.c

162

unsigned int k, lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

163

for (k = 0; k < lim; ++k)

tools/lib/bitmap.c

64

unsigned int lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

67

for (k = 0; k < lim; k++)

tools/lib/bitmap.c

78

unsigned int k, lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

79

for (k = 0; k < lim; ++k)

tools/lib/bitmap.c

93

unsigned int k, lim = bits/BITS_PER_LONG;

tools/lib/bitmap.c

94

for (k = 0; k < lim; ++k)

tools/perf/tests/dso-data.c

322

long nr_end, nr = open_files_cnt(), lim = new_limit(3);

tools/perf/tests/dso-data.c

345

!set_fd_limit((lim)));

tools/testing/selftests/mm/compaction_test.c

208

struct rlimit lim;

tools/testing/selftests/mm/compaction_test.c

228

lim.rlim_cur = RLIM_INFINITY;

tools/testing/selftests/mm/compaction_test.c

229

lim.rlim_max = RLIM_INFINITY;

tools/testing/selftests/mm/compaction_test.c

230

if (setrlimit(RLIMIT_MEMLOCK, &lim))

tools/testing/selftests/seccomp/seccomp_bpf.c

4303

const struct rlimit lim = {

tools/testing/selftests/seccomp/seccomp_bpf.c

4330

ASSERT_EQ(prlimit(pid, RLIMIT_NOFILE, &lim, NULL), 0);