crypto/cast5_generic.c

408

z[1] = x[2] ^ s5[zi(0)] ^ s6[zi(2)] ^ s7[zi(1)] ^ sb8[zi(3)] ^

crypto/cast5_generic.c

410

z[2] = x[3] ^ s5[zi(7)] ^ s6[zi(6)] ^ s7[zi(5)] ^ sb8[zi(4)] ^

crypto/cast5_generic.c

412

z[3] = x[1] ^ s5[zi(10)] ^ s6[zi(9)] ^ s7[zi(11)] ^ sb8[zi(8)] ^

crypto/cast5_generic.c

414

k[0] = s5[zi(8)] ^ s6[zi(9)] ^ s7[zi(7)] ^ sb8[zi(6)] ^ s5[zi(2)];

crypto/cast5_generic.c

415

k[1] = s5[zi(10)] ^ s6[zi(11)] ^ s7[zi(5)] ^ sb8[zi(4)] ^

crypto/cast5_generic.c

416

s6[zi(6)];

crypto/cast5_generic.c

417

k[2] = s5[zi(12)] ^ s6[zi(13)] ^ s7[zi(3)] ^ sb8[zi(2)] ^

crypto/cast5_generic.c

418

s7[zi(9)];

crypto/cast5_generic.c

419

k[3] = s5[zi(14)] ^ s6[zi(15)] ^ s7[zi(1)] ^ sb8[zi(0)] ^

crypto/cast5_generic.c

420

sb8[zi(12)];

crypto/cast5_generic.c

422

x[0] = z[2] ^ s5[zi(5)] ^ s6[zi(7)] ^ s7[zi(4)] ^ sb8[zi(6)] ^

crypto/cast5_generic.c

423

s7[zi(0)];

crypto/cast5_generic.c

425

sb8[zi(2)];

crypto/cast5_generic.c

427

s5[zi(1)];

crypto/cast5_generic.c

429

s6[zi(3)];

crypto/cast5_generic.c

440

z[1] = x[2] ^ s5[zi(0)] ^ s6[zi(2)] ^ s7[zi(1)] ^ sb8[zi(3)] ^

crypto/cast5_generic.c

442

z[2] = x[3] ^ s5[zi(7)] ^ s6[zi(6)] ^ s7[zi(5)] ^ sb8[zi(4)] ^

crypto/cast5_generic.c

444

z[3] = x[1] ^ s5[zi(10)] ^ s6[zi(9)] ^ s7[zi(11)] ^ sb8[zi(8)] ^

crypto/cast5_generic.c

446

k[8] = s5[zi(3)] ^ s6[zi(2)] ^ s7[zi(12)] ^ sb8[zi(13)] ^

crypto/cast5_generic.c

447

s5[zi(9)];

crypto/cast5_generic.c

448

k[9] = s5[zi(1)] ^ s6[zi(0)] ^ s7[zi(14)] ^ sb8[zi(15)] ^

crypto/cast5_generic.c

449

s6[zi(12)];

crypto/cast5_generic.c

450

k[10] = s5[zi(7)] ^ s6[zi(6)] ^ s7[zi(8)] ^ sb8[zi(9)] ^ s7[zi(2)];

crypto/cast5_generic.c

451

k[11] = s5[zi(5)] ^ s6[zi(4)] ^ s7[zi(10)] ^ sb8[zi(11)] ^

crypto/cast5_generic.c

452

sb8[zi(6)];

crypto/cast5_generic.c

454

x[0] = z[2] ^ s5[zi(5)] ^ s6[zi(7)] ^ s7[zi(4)] ^ sb8[zi(6)] ^

crypto/cast5_generic.c

455

s7[zi(0)];

crypto/cast5_generic.c

457

sb8[zi(2)];

crypto/cast5_generic.c

459

s5[zi(1)];

crypto/cast5_generic.c

461

s6[zi(3)];

drivers/nvme/host/core.c

2392

struct nvme_zone_info zi = {};

drivers/nvme/host/core.c

2419

ret = nvme_query_zone_info(ns, lbaf, &zi);

drivers/nvme/host/core.c

2452

nvme_update_zone_info(ns, &lim, &zi);

drivers/nvme/host/nvme.h

1199

struct nvme_zone_info *zi);

drivers/nvme/host/nvme.h

1201

struct nvme_zone_info *zi);

drivers/nvme/host/zns.c

100

zi->max_open_zones = le32_to_cpu(id->mor) + 1;

drivers/nvme/host/zns.c

101

zi->max_active_zones = le32_to_cpu(id->mar) + 1;

drivers/nvme/host/zns.c

109

struct nvme_zone_info *zi)

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

116

nvme_lba_to_sect(ns->head, zi->zone_size);

drivers/nvme/host/zns.c

39

struct nvme_zone_info *zi)

drivers/nvme/host/zns.c

92

zi->zone_size = le64_to_cpu(id->lbafe[lbaf].zsze);

drivers/nvme/host/zns.c

93

if (!is_power_of_2(zi->zone_size)) {

drivers/nvme/host/zns.c

96

zi->zone_size, ns->head->ns_id);

drivers/zorro/zorro.c

131

struct zorro_dev_init *zi;

drivers/zorro/zorro.c

159

zi = &zorro_autocon_init[i];

drivers/zorro/zorro.c

162

z->rom = zi->rom;

drivers/zorro/zorro.c

167

unsigned long magic = zi->boardaddr + 0x8000;

drivers/zorro/zorro.c

171

z->slotaddr = zi->slotaddr;

drivers/zorro/zorro.c

172

z->slotsize = zi->slotsize;

drivers/zorro/zorro.c

175

z->resource = DEFINE_RES_MEM_NAMED(zi->boardaddr, zi->boardsize, z->name);

fs/ubifs/tnc.c

2120

struct ubifs_znode *zn, *zi, *zp;

fs/ubifs/tnc.c

2184

zi = znode;

fs/ubifs/tnc.c

2206

zi = znode;

fs/ubifs/tnc.c

2211

zi = zn;

fs/ubifs/tnc.c

2242

insert_zbranch(c, zi, zbr, n);

fs/ubifs/tnc.c

2246

if (n == 0 && zi == znode && znode->iip == 0)

fs/ubifs/tnc.c

2266

zi = kzalloc(c->max_znode_sz, GFP_NOFS);

fs/ubifs/tnc.c

2267

if (!zi)

fs/ubifs/tnc.c

2270

zi->child_cnt = 2;

fs/ubifs/tnc.c

2271

zi->level = znode->level + 1;

fs/ubifs/tnc.c

2273

__set_bit(DIRTY_ZNODE, &zi->flags);

fs/ubifs/tnc.c

2276

zi->zbranch[0].key = znode->zbranch[0].key;

fs/ubifs/tnc.c

2277

zi->zbranch[0].znode = znode;

fs/ubifs/tnc.c

2278

zi->zbranch[0].lnum = c->zroot.lnum;

fs/ubifs/tnc.c

2279

zi->zbranch[0].offs = c->zroot.offs;

fs/ubifs/tnc.c

2280

zi->zbranch[0].len = c->zroot.len;

fs/ubifs/tnc.c

2281

zi->zbranch[1].key = zn->zbranch[0].key;

fs/ubifs/tnc.c

2282

zi->zbranch[1].znode = zn;

fs/ubifs/tnc.c

2287

c->zroot.znode = zi;

fs/ubifs/tnc.c

2289

zn->parent = zi;

fs/ubifs/tnc.c

2291

znode->parent = zi;

fs/xfs/xfs_sysfs.c

728

struct xfs_zone_info *zi = zoned_to_mp(kobj)->m_zone_info;

fs/xfs/xfs_sysfs.c

730

return sysfs_emit(buf, "%u\n", READ_ONCE(zi->zi_nr_open_zones));

fs/xfs/xfs_zone_alloc.c

1050

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

107

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

109

xfs_zone_remove_from_bucket(zi, rgno, from_bucket);

fs/xfs/xfs_zone_alloc.c

110

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

1103

list_add_tail(&oz->oz_entry, &zi->zi_open_zones);

fs/xfs/xfs_zone_alloc.c

1104

zi->zi_nr_open_zones++;

fs/xfs/xfs_zone_alloc.c

112

spin_lock(&zi->zi_reset_list_lock);

fs/xfs/xfs_zone_alloc.c

113

xg->xg_next_reset = zi->zi_reset_list;

fs/xfs/xfs_zone_alloc.c

114

zi->zi_reset_list = xg;

fs/xfs/xfs_zone_alloc.c

115

spin_unlock(&zi->zi_reset_list_lock);

fs/xfs/xfs_zone_alloc.c

117

if (zi->zi_gc_thread)

fs/xfs/xfs_zone_alloc.c

118

wake_up_process(zi->zi_gc_thread);

fs/xfs/xfs_zone_alloc.c

1207

struct xfs_zone_info *zi;

fs/xfs/xfs_zone_alloc.c

1210

zi = kzalloc_obj(*zi);

fs/xfs/xfs_zone_alloc.c

1211

if (!zi)

fs/xfs/xfs_zone_alloc.c

1213

INIT_LIST_HEAD(&zi->zi_open_zones);

fs/xfs/xfs_zone_alloc.c

1214

INIT_LIST_HEAD(&zi->zi_reclaim_reservations);

fs/xfs/xfs_zone_alloc.c

1215

spin_lock_init(&zi->zi_reset_list_lock);

fs/xfs/xfs_zone_alloc.c

1216

spin_lock_init(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

1217

spin_lock_init(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_alloc.c

1218

init_waitqueue_head(&zi->zi_zone_wait);

fs/xfs/xfs_zone_alloc.c

1219

spin_lock_init(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

1221

zi->zi_used_bucket_bitmap[i] = xfs_alloc_bucket_bitmap(mp);

fs/xfs/xfs_zone_alloc.c

1222

if (!zi->zi_used_bucket_bitmap[i])

fs/xfs/xfs_zone_alloc.c

1225

return zi;

fs/xfs/xfs_zone_alloc.c

1229

kvfree(zi->zi_used_bucket_bitmap[i]);

fs/xfs/xfs_zone_alloc.c

1230

kfree(zi);

fs/xfs/xfs_zone_alloc.c

1236

struct xfs_zone_info *zi)

fs/xfs/xfs_zone_alloc.c

124

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

1240

xfs_free_open_zones(zi);

fs/xfs/xfs_zone_alloc.c

1242

kvfree(zi->zi_used_bucket_bitmap[i]);

fs/xfs/xfs_zone_alloc.c

1243

kfree(zi);

fs/xfs/xfs_zone_alloc.c

125

xfs_zone_add_to_bucket(zi, rgno, to_bucket);

fs/xfs/xfs_zone_alloc.c

126

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

128

if (zi->zi_gc_thread && xfs_zoned_need_gc(mp))

fs/xfs/xfs_zone_alloc.c

1281

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

1284

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

1285

list_for_each_entry(oz, &zi->zi_open_zones, oz_entry) {

fs/xfs/xfs_zone_alloc.c

129

wake_up_process(zi->zi_gc_thread);

fs/xfs/xfs_zone_alloc.c

1291

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

1313

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

1315

while (zi->zi_nr_open_zones > mp->m_max_open_zones) {

fs/xfs/xfs_zone_alloc.c

1323

zi->zi_nr_open_zones, mp->m_max_open_zones);

fs/xfs/xfs_zone_alloc.c

135

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

136

xfs_zone_add_to_bucket(zi, rgno, to_bucket);

fs/xfs/xfs_zone_alloc.c

137

xfs_zone_remove_from_bucket(zi, rgno, from_bucket);

fs/xfs/xfs_zone_alloc.c

138

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

148

struct xfs_zone_info *zi)

fs/xfs/xfs_zone_alloc.c

152

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

154

if (zi->zi_used_bucket_entries[i]) {

fs/xfs/xfs_zone_alloc.c

155

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

159

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

170

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

177

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

179

zi->zi_nr_open_gc_zones--;

fs/xfs/xfs_zone_alloc.c

181

zi->zi_nr_open_zones--;

fs/xfs/xfs_zone_alloc.c

183

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

186

wake_up_process(zi->zi_gc_thread);

fs/xfs/xfs_zone_alloc.c

188

wake_up_all(&zi->zi_zone_wait);

fs/xfs/xfs_zone_alloc.c

449

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

467

atomic_dec(&zi->zi_nr_free_zones);

fs/xfs/xfs_zone_alloc.c

479

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

482

if (zi->zi_nr_open_zones >= mp->m_max_open_zones - XFS_OPEN_GC_ZONES)

fs/xfs/xfs_zone_alloc.c

484

if (atomic_read(&zi->zi_nr_free_zones) <

fs/xfs/xfs_zone_alloc.c

492

zi->zi_nr_open_zones++;

fs/xfs/xfs_zone_alloc.c

493

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

495

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

497

zi->zi_nr_open_zones--;

fs/xfs/xfs_zone_alloc.c

502

list_add_tail(&oz->oz_entry, &zi->zi_open_zones);

fs/xfs/xfs_zone_alloc.c

508

wake_up_all(&zi->zi_zone_wait);

fs/xfs/xfs_zone_alloc.c

511

wake_up_process(zi->zi_gc_thread);

fs/xfs/xfs_zone_alloc.c

558

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

59

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

593

if (!list_is_last(&oz->oz_entry, &zi->zi_open_zones))

fs/xfs/xfs_zone_alloc.c

594

list_move_tail(&oz->oz_entry, &zi->zi_open_zones);

fs/xfs/xfs_zone_alloc.c

600

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

606

lockdep_assert_held(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

608

list_for_each_entry(oz, &zi->zi_open_zones, oz_entry)

fs/xfs/xfs_zone_alloc.c

609

if (xfs_try_use_zone(zi, file_hint, oz, goodness))

fs/xfs/xfs_zone_alloc.c

612

cond_resched_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

618

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

623

lockdep_assert_held(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

625

list_for_each_entry_reverse(oz, &zi->zi_open_zones, oz_entry)

fs/xfs/xfs_zone_alloc.c

626

if (xfs_try_use_zone(zi, file_hint, oz, XFS_ZONE_ALLOC_OK))

fs/xfs/xfs_zone_alloc.c

629

cond_resched_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

63

__set_bit(rgno, zi->zi_used_bucket_bitmap[to_bucket]);

fs/xfs/xfs_zone_alloc.c

64

zi->zi_used_bucket_entries[to_bucket]++;

fs/xfs/xfs_zone_alloc.c

670

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

682

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

683

oz = xfs_select_open_zone_lru(zi, write_hint, XFS_ZONE_ALLOC_GOOD);

fs/xfs/xfs_zone_alloc.c

688

oz = xfs_select_open_zone_mru(zi, write_hint);

fs/xfs/xfs_zone_alloc.c

69

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

704

oz = xfs_select_open_zone_lru(zi, write_hint, XFS_ZONE_ALLOC_OK);

fs/xfs/xfs_zone_alloc.c

711

oz = xfs_select_open_zone_lru(zi, write_hint, XFS_ZONE_ALLOC_ANY);

fs/xfs/xfs_zone_alloc.c

713

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

723

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

73

__clear_bit(rgno, zi->zi_used_bucket_bitmap[from_bucket]);

fs/xfs/xfs_zone_alloc.c

732

prepare_to_wait(&zi->zi_zone_wait, &wait, TASK_UNINTERRUPTIBLE);

fs/xfs/xfs_zone_alloc.c

738

finish_wait(&zi->zi_zone_wait, &wait);

fs/xfs/xfs_zone_alloc.c

74

zi->zi_used_bucket_entries[from_bucket]--;

fs/xfs/xfs_zone_alloc.c

84

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

958

struct xfs_zone_info *zi)

fs/xfs/xfs_zone_alloc.c

962

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

963

while ((oz = list_first_entry_or_null(&zi->zi_open_zones,

fs/xfs/xfs_zone_alloc.c

968

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

97

if (!zi)

fs/xfs/xfs_zone_gc.c

1034

struct xfs_zone_info *zi = data->mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

1039

spin_lock(&zi->zi_reset_list_lock);

fs/xfs/xfs_zone_gc.c

1040

reset_list = zi->zi_reset_list;

fs/xfs/xfs_zone_gc.c

1041

zi->zi_reset_list = NULL;

fs/xfs/xfs_zone_gc.c

1042

spin_unlock(&zi->zi_reset_list_lock);

fs/xfs/xfs_zone_gc.c

1090

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

1115

!zi->zi_reset_list) {

fs/xfs/xfs_zone_gc.c

1182

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

1198

zi->zi_nr_open_zones >= mp->m_max_open_zones) {

fs/xfs/xfs_zone_gc.c

1206

zi->zi_gc_thread = kthread_create(xfs_zoned_gcd, data,

fs/xfs/xfs_zone_gc.c

1208

if (IS_ERR(zi->zi_gc_thread)) {

fs/xfs/xfs_zone_gc.c

1210

error = PTR_ERR(zi->zi_gc_thread);

fs/xfs/xfs_zone_gc.c

1215

kthread_park(zi->zi_gc_thread);

fs/xfs/xfs_zone_gc.c

1230

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

1232

kthread_stop(zi->zi_gc_thread);

fs/xfs/xfs_zone_gc.c

443

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

448

if (!zi->zi_used_bucket_entries[bucket])

fs/xfs/xfs_zone_gc.c

451

for_each_set_bit(bit, zi->zi_used_bucket_bitmap[bucket],

fs/xfs/xfs_zone_gc.c

508

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

512

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_gc.c

518

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_gc.c

532

struct xfs_zone_info *zi = data->mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

535

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_gc.c

536

list_for_each_entry(oz, &zi->zi_open_zones, oz_entry) {

fs/xfs/xfs_zone_gc.c

541

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_gc.c

547

zi->zi_nr_open_zones--;

fs/xfs/xfs_zone_gc.c

548

zi->zi_nr_open_gc_zones++;

fs/xfs/xfs_zone_gc.c

549

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_gc.c

563

struct xfs_zone_info *zi = data->mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

586

ASSERT(zi->zi_nr_open_zones <=

fs/xfs/xfs_zone_gc.c

593

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_gc.c

594

zi->zi_nr_open_gc_zones++;

fs/xfs/xfs_zone_gc.c

595

list_add_tail(&data->oz->oz_entry, &zi->zi_open_zones);

fs/xfs/xfs_zone_gc.c

596

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_gc.c

920

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

930

wake_up_all(&zi->zi_zone_wait);

fs/xfs/xfs_zone_info.c

101

zi->zi_nr_open_zones);

fs/xfs/xfs_zone_info.c

103

zi->zi_nr_open_gc_zones);

fs/xfs/xfs_zone_info.c

105

list_for_each_entry(oz, &zi->zi_open_zones, oz_entry)

fs/xfs/xfs_zone_info.c

107

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_info.c

46

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_info.c

49

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_info.c

51

unsigned int entries = zi->zi_used_bucket_entries[i];

fs/xfs/xfs_zone_info.c

59

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_info.c

62

full -= zi->zi_nr_open_zones;

fs/xfs/xfs_zone_info.c

63

full -= zi->zi_nr_open_gc_zones;

fs/xfs/xfs_zone_info.c

64

full -= atomic_read(&zi->zi_nr_free_zones);

fs/xfs/xfs_zone_info.c

75

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_info.c

89

!list_empty_careful(&zi->zi_reclaim_reservations));

fs/xfs/xfs_zone_info.c

95

seq_printf(m, "\tfree zones: %d\n", atomic_read(&zi->zi_nr_free_zones));

fs/xfs/xfs_zone_info.c

97

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_priv.h

106

bool xfs_zoned_have_reclaimable(struct xfs_zone_info *zi);

fs/xfs/xfs_zone_space_resv.c

103

spin_unlock(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_space_resv.c

123

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_space_resv.c

139

if (likely(list_empty_careful(&zi->zi_reclaim_reservations) ||

fs/xfs/xfs_zone_space_resv.c

150

spin_lock(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_space_resv.c

151

list_add_tail(&reservation.entry, &zi->zi_reclaim_reservations);

fs/xfs/xfs_zone_space_resv.c

168

wake_up_process(zi->zi_gc_thread);

fs/xfs/xfs_zone_space_resv.c

179

spin_unlock(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_space_resv.c

181

spin_lock(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_space_resv.c

184

spin_unlock(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_space_resv.c

203

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_space_resv.c

207

spin_lock(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_space_resv.c

214

spin_unlock(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_space_resv.c

71

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_space_resv.c

74

spin_lock(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_space_resv.c

75

list_for_each_entry(reservation, &zi->zi_reclaim_reservations, entry)

fs/xfs/xfs_zone_space_resv.c

77

spin_unlock(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_space_resv.c

85

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_space_resv.c

88

if (list_empty_careful(&zi->zi_reclaim_reservations)) {

fs/xfs/xfs_zone_space_resv.c

93

spin_lock(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_space_resv.c

96

list_for_each_entry(reservation, &zi->zi_reclaim_reservations, entry) {

fs/zonefs/file.c

102

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

200

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

227

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

262

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

31

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

361

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

381

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

386

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

40

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

429

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

445

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

447

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

472

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

506

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

508

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

520

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

53

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

634

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

655

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

658

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

663

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

68

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

692

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

707

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

713

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

742

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

746

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

748

if (!zi->i_wr_refcnt) {

fs/zonefs/file.c

774

zi->i_wr_refcnt++;

fs/zonefs/file.c

777

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

799

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

805

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

807

zi->i_wr_refcnt--;

fs/zonefs/file.c

808

if (zi->i_wr_refcnt)

fs/zonefs/file.c

845

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

90

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/super.c

420

struct zonefs_inode_info *zi;

fs/zonefs/super.c

422

zi = alloc_inode_sb(sb, zonefs_inode_cachep, GFP_KERNEL);

fs/zonefs/super.c

423

if (!zi)

fs/zonefs/super.c

426

inode_init_once(&zi->i_vnode);

fs/zonefs/super.c

427

mutex_init(&zi->i_truncate_mutex);

fs/zonefs/super.c

428

zi->i_wr_refcnt = 0;

fs/zonefs/super.c

430

return &zi->i_vnode;

fs/zonefs/zonefs.h

267

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/zonefs.h

269

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/zonefs.h

271

mutex_unlock(&zi->i_truncate_mutex);