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

2369

struct nvme_zone_info zi = {};

drivers/nvme/host/core.c

2396

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

drivers/nvme/host/core.c

2421

nvme_update_zone_info(ns, &lim, &zi);

drivers/nvme/host/nvme.h

1181

struct nvme_zone_info *zi);

drivers/nvme/host/nvme.h

1183

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

1041

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

106

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

108

xfs_zone_remove_from_bucket(zi, rgno, from_bucket);

fs/xfs/xfs_zone_alloc.c

1085

atomic_inc(&zi->zi_nr_free_zones);

fs/xfs/xfs_zone_alloc.c

109

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

1095

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

fs/xfs/xfs_zone_alloc.c

1096

zi->zi_nr_open_zones++;

fs/xfs/xfs_zone_alloc.c

111

spin_lock(&zi->zi_reset_list_lock);

fs/xfs/xfs_zone_alloc.c

112

xg->xg_next_reset = zi->zi_reset_list;

fs/xfs/xfs_zone_alloc.c

113

zi->zi_reset_list = xg;

fs/xfs/xfs_zone_alloc.c

114

spin_unlock(&zi->zi_reset_list_lock);

fs/xfs/xfs_zone_alloc.c

116

if (zi->zi_gc_thread)

fs/xfs/xfs_zone_alloc.c

117

wake_up_process(zi->zi_gc_thread);

fs/xfs/xfs_zone_alloc.c

1199

struct xfs_zone_info *zi;

fs/xfs/xfs_zone_alloc.c

1202

zi = kzalloc_obj(*zi);

fs/xfs/xfs_zone_alloc.c

1203

if (!zi)

fs/xfs/xfs_zone_alloc.c

1205

INIT_LIST_HEAD(&zi->zi_open_zones);

fs/xfs/xfs_zone_alloc.c

1206

INIT_LIST_HEAD(&zi->zi_reclaim_reservations);

fs/xfs/xfs_zone_alloc.c

1207

spin_lock_init(&zi->zi_reset_list_lock);

fs/xfs/xfs_zone_alloc.c

1208

spin_lock_init(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

1209

spin_lock_init(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_alloc.c

1210

init_waitqueue_head(&zi->zi_zone_wait);

fs/xfs/xfs_zone_alloc.c

1211

spin_lock_init(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

1213

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

fs/xfs/xfs_zone_alloc.c

1214

if (!zi->zi_used_bucket_bitmap[i])

fs/xfs/xfs_zone_alloc.c

1217

return zi;

fs/xfs/xfs_zone_alloc.c

1221

kvfree(zi->zi_used_bucket_bitmap[i]);

fs/xfs/xfs_zone_alloc.c

1222

kfree(zi);

fs/xfs/xfs_zone_alloc.c

1228

struct xfs_zone_info *zi)

fs/xfs/xfs_zone_alloc.c

123

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

1232

xfs_free_open_zones(zi);

fs/xfs/xfs_zone_alloc.c

1234

kvfree(zi->zi_used_bucket_bitmap[i]);

fs/xfs/xfs_zone_alloc.c

1235

kfree(zi);

fs/xfs/xfs_zone_alloc.c

124

xfs_zone_add_to_bucket(zi, rgno, to_bucket);

fs/xfs/xfs_zone_alloc.c

125

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

127

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

fs/xfs/xfs_zone_alloc.c

1273

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

1276

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

1277

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

fs/xfs/xfs_zone_alloc.c

128

wake_up_process(zi->zi_gc_thread);

fs/xfs/xfs_zone_alloc.c

1283

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

1305

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

1307

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

fs/xfs/xfs_zone_alloc.c

1315

zi->zi_nr_open_zones, mp->m_max_open_zones);

fs/xfs/xfs_zone_alloc.c

134

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

135

xfs_zone_add_to_bucket(zi, rgno, to_bucket);

fs/xfs/xfs_zone_alloc.c

136

xfs_zone_remove_from_bucket(zi, rgno, from_bucket);

fs/xfs/xfs_zone_alloc.c

137

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

147

struct xfs_zone_info *zi)

fs/xfs/xfs_zone_alloc.c

151

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

153

if (zi->zi_used_bucket_entries[i]) {

fs/xfs/xfs_zone_alloc.c

154

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

158

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

169

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

176

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

178

zi->zi_nr_open_gc_zones--;

fs/xfs/xfs_zone_alloc.c

180

zi->zi_nr_open_zones--;

fs/xfs/xfs_zone_alloc.c

182

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

185

wake_up_process(zi->zi_gc_thread);

fs/xfs/xfs_zone_alloc.c

187

wake_up_all(&zi->zi_zone_wait);

fs/xfs/xfs_zone_alloc.c

448

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

466

atomic_dec(&zi->zi_nr_free_zones);

fs/xfs/xfs_zone_alloc.c

478

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

481

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

fs/xfs/xfs_zone_alloc.c

483

if (atomic_read(&zi->zi_nr_free_zones) <

fs/xfs/xfs_zone_alloc.c

491

zi->zi_nr_open_zones++;

fs/xfs/xfs_zone_alloc.c

492

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

494

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

496

zi->zi_nr_open_zones--;

fs/xfs/xfs_zone_alloc.c

501

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

fs/xfs/xfs_zone_alloc.c

507

wake_up_all(&zi->zi_zone_wait);

fs/xfs/xfs_zone_alloc.c

510

wake_up_process(zi->zi_gc_thread);

fs/xfs/xfs_zone_alloc.c

557

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

58

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

592

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

fs/xfs/xfs_zone_alloc.c

593

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

fs/xfs/xfs_zone_alloc.c

599

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

605

lockdep_assert_held(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

607

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

fs/xfs/xfs_zone_alloc.c

608

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

fs/xfs/xfs_zone_alloc.c

611

cond_resched_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

617

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

62

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

fs/xfs/xfs_zone_alloc.c

622

lockdep_assert_held(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

624

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

fs/xfs/xfs_zone_alloc.c

625

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

fs/xfs/xfs_zone_alloc.c

628

cond_resched_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

63

zi->zi_used_bucket_entries[to_bucket]++;

fs/xfs/xfs_zone_alloc.c

669

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

68

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

681

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

682

oz = xfs_select_open_zone_lru(zi, write_hint, XFS_ZONE_ALLOC_GOOD);

fs/xfs/xfs_zone_alloc.c

687

oz = xfs_select_open_zone_mru(zi, write_hint);

fs/xfs/xfs_zone_alloc.c

703

oz = xfs_select_open_zone_lru(zi, write_hint, XFS_ZONE_ALLOC_OK);

fs/xfs/xfs_zone_alloc.c

710

oz = xfs_select_open_zone_lru(zi, write_hint, XFS_ZONE_ALLOC_ANY);

fs/xfs/xfs_zone_alloc.c

712

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

72

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

fs/xfs/xfs_zone_alloc.c

722

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

73

zi->zi_used_bucket_entries[from_bucket]--;

fs/xfs/xfs_zone_alloc.c

731

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

fs/xfs/xfs_zone_alloc.c

737

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

fs/xfs/xfs_zone_alloc.c

83

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

949

struct xfs_zone_info *zi)

fs/xfs/xfs_zone_alloc.c

953

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

954

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

fs/xfs/xfs_zone_alloc.c

959

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

96

if (!zi)

fs/xfs/xfs_zone_gc.c

1036

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

fs/xfs/xfs_zone_gc.c

1041

spin_lock(&zi->zi_reset_list_lock);

fs/xfs/xfs_zone_gc.c

1042

reset_list = zi->zi_reset_list;

fs/xfs/xfs_zone_gc.c

1043

zi->zi_reset_list = NULL;

fs/xfs/xfs_zone_gc.c

1044

spin_unlock(&zi->zi_reset_list_lock);

fs/xfs/xfs_zone_gc.c

1092

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

1117

!zi->zi_reset_list) {

fs/xfs/xfs_zone_gc.c

1184

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

1200

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

fs/xfs/xfs_zone_gc.c

1208

zi->zi_gc_thread = kthread_create(xfs_zoned_gcd, data,

fs/xfs/xfs_zone_gc.c

1210

if (IS_ERR(zi->zi_gc_thread)) {

fs/xfs/xfs_zone_gc.c

1212

error = PTR_ERR(zi->zi_gc_thread);

fs/xfs/xfs_zone_gc.c

1217

kthread_park(zi->zi_gc_thread);

fs/xfs/xfs_zone_gc.c

1232

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

1234

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

928

atomic_inc(&zi->zi_nr_free_zones);

fs/xfs/xfs_zone_gc.c

932

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