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

2337

struct nvme_zone_info zi = {};

drivers/nvme/host/core.c

2364

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

drivers/nvme/host/core.c

2390

nvme_update_zone_info(ns, &lim, &zi);

drivers/nvme/host/nvme.h

1175

struct nvme_zone_info *zi);

drivers/nvme/host/nvme.h

1177

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

1038

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

1082

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

1092

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

fs/xfs/xfs_zone_alloc.c

1093

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

1196

struct xfs_zone_info *zi;

fs/xfs/xfs_zone_alloc.c

1199

zi = kzalloc_obj(*zi);

fs/xfs/xfs_zone_alloc.c

1200

if (!zi)

fs/xfs/xfs_zone_alloc.c

1202

INIT_LIST_HEAD(&zi->zi_open_zones);

fs/xfs/xfs_zone_alloc.c

1203

INIT_LIST_HEAD(&zi->zi_reclaim_reservations);

fs/xfs/xfs_zone_alloc.c

1204

spin_lock_init(&zi->zi_reset_list_lock);

fs/xfs/xfs_zone_alloc.c

1205

spin_lock_init(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

1206

spin_lock_init(&zi->zi_reservation_lock);

fs/xfs/xfs_zone_alloc.c

1207

init_waitqueue_head(&zi->zi_zone_wait);

fs/xfs/xfs_zone_alloc.c

1208

spin_lock_init(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

1210

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

fs/xfs/xfs_zone_alloc.c

1211

if (!zi->zi_used_bucket_bitmap[i])

fs/xfs/xfs_zone_alloc.c

1214

return zi;

fs/xfs/xfs_zone_alloc.c

1218

kvfree(zi->zi_used_bucket_bitmap[i]);

fs/xfs/xfs_zone_alloc.c

1219

kfree(zi);

fs/xfs/xfs_zone_alloc.c

1225

struct xfs_zone_info *zi)

fs/xfs/xfs_zone_alloc.c

1229

xfs_free_open_zones(zi);

fs/xfs/xfs_zone_alloc.c

123

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_alloc.c

1231

kvfree(zi->zi_used_bucket_bitmap[i]);

fs/xfs/xfs_zone_alloc.c

1232

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

128

wake_up_process(zi->zi_gc_thread);

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

ASSERT(current == zi->zi_gc_thread);

fs/xfs/xfs_zone_alloc.c

179

zi->zi_open_gc_zone = NULL;

fs/xfs/xfs_zone_alloc.c

181

zi->zi_nr_open_zones--;

fs/xfs/xfs_zone_alloc.c

184

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

187

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

58

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

590

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

fs/xfs/xfs_zone_alloc.c

591

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

fs/xfs/xfs_zone_alloc.c

597

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

603

lockdep_assert_held(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

605

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

fs/xfs/xfs_zone_alloc.c

606

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

fs/xfs/xfs_zone_alloc.c

609

cond_resched_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

615

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

620

lockdep_assert_held(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

622

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

fs/xfs/xfs_zone_alloc.c

623

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

fs/xfs/xfs_zone_alloc.c

626

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

667

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

679

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

68

struct xfs_zone_info *zi,

fs/xfs/xfs_zone_alloc.c

680

oz = xfs_select_open_zone_lru(zi, write_hint, XFS_ZONE_ALLOC_GOOD);

fs/xfs/xfs_zone_alloc.c

685

oz = xfs_select_open_zone_mru(zi, write_hint);

fs/xfs/xfs_zone_alloc.c

700

oz = xfs_select_open_zone_lru(zi, write_hint, XFS_ZONE_ALLOC_OK);

fs/xfs/xfs_zone_alloc.c

707

oz = xfs_select_open_zone_lru(zi, write_hint, XFS_ZONE_ALLOC_ANY);

fs/xfs/xfs_zone_alloc.c

709

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

719

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_alloc.c

72

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

fs/xfs/xfs_zone_alloc.c

728

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

fs/xfs/xfs_zone_alloc.c

73

zi->zi_used_bucket_entries[from_bucket]--;

fs/xfs/xfs_zone_alloc.c

734

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

946

struct xfs_zone_info *zi)

fs/xfs/xfs_zone_alloc.c

950

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

951

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

fs/xfs/xfs_zone_alloc.c

956

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_alloc.c

96

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

1093

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

1118

!zi->zi_reset_list) {

fs/xfs/xfs_zone_gc.c

1166

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

1180

zi->zi_nr_open_zones == mp->m_max_open_zones)

fs/xfs/xfs_zone_gc.c

1181

oz = xfs_zone_gc_steal_open(zi);

fs/xfs/xfs_zone_gc.c

1191

zi->zi_open_gc_zone = oz;

fs/xfs/xfs_zone_gc.c

1199

zi->zi_gc_thread = kthread_create(xfs_zoned_gcd, data,

fs/xfs/xfs_zone_gc.c

1201

if (IS_ERR(zi->zi_gc_thread)) {

fs/xfs/xfs_zone_gc.c

1203

error = PTR_ERR(zi->zi_gc_thread);

fs/xfs/xfs_zone_gc.c

1208

kthread_park(zi->zi_gc_thread);

fs/xfs/xfs_zone_gc.c

1214

xfs_open_zone_put(zi->zi_open_gc_zone);

fs/xfs/xfs_zone_gc.c

1223

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

1225

kthread_stop(zi->zi_gc_thread);

fs/xfs/xfs_zone_gc.c

1226

if (zi->zi_open_gc_zone)

fs/xfs/xfs_zone_gc.c

1227

xfs_open_zone_put(zi->zi_open_gc_zone);

fs/xfs/xfs_zone_gc.c

433

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

438

if (!zi->zi_used_bucket_entries[bucket])

fs/xfs/xfs_zone_gc.c

441

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

fs/xfs/xfs_zone_gc.c

498

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

502

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_gc.c

508

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_gc.c

520

struct xfs_zone_info *zi)

fs/xfs/xfs_zone_gc.c

524

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_gc.c

525

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

fs/xfs/xfs_zone_gc.c

533

zi->zi_nr_open_zones--;

fs/xfs/xfs_zone_gc.c

536

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_gc.c

544

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

545

struct xfs_open_zone *oz = zi->zi_open_gc_zone;

fs/xfs/xfs_zone_gc.c

553

ASSERT(zi->zi_nr_open_zones <=

fs/xfs/xfs_zone_gc.c

558

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_gc.c

559

zi->zi_open_gc_zone = oz;

fs/xfs/xfs_zone_gc.c

560

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_gc.c

882

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_gc.c

890

atomic_inc(&zi->zi_nr_free_zones);

fs/xfs/xfs_zone_gc.c

894

wake_up_all(&zi->zi_zone_wait);

fs/xfs/xfs_zone_info.c

100

xfs_show_open_zone(m, zi->zi_open_gc_zone);

fs/xfs/xfs_zone_info.c

102

spin_unlock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_info.c

45

struct xfs_zone_info *zi = mp->m_zone_info;

fs/xfs/xfs_zone_info.c

48

spin_lock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_info.c

50

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

fs/xfs/xfs_zone_info.c

58

spin_unlock(&zi->zi_used_buckets_lock);

fs/xfs/xfs_zone_info.c

61

if (zi->zi_open_gc_zone)

fs/xfs/xfs_zone_info.c

63

full -= zi->zi_nr_open_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

93

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

fs/xfs/xfs_zone_info.c

95

spin_lock(&zi->zi_open_zones_lock);

fs/xfs/xfs_zone_info.c

96

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

fs/xfs/xfs_zone_info.c

98

if (zi->zi_open_gc_zone) {

fs/xfs/xfs_zone_priv.h

115

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

362

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

382

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

387

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

40

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

430

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

446

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

448

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

473

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

507

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

509

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

521

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

53

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

635

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

656

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

659

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

664

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

68

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

693

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

708

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

714

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

743

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

747

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

749

if (!zi->i_wr_refcnt) {

fs/zonefs/file.c

775

zi->i_wr_refcnt++;

fs/zonefs/file.c

778

mutex_unlock(&zi->i_truncate_mutex);

fs/zonefs/file.c

800

struct zonefs_inode_info *zi = ZONEFS_I(inode);

fs/zonefs/file.c

806

mutex_lock(&zi->i_truncate_mutex);

fs/zonefs/file.c

808

zi->i_wr_refcnt--;

fs/zonefs/file.c

809

if (zi->i_wr_refcnt)

fs/zonefs/file.c

846

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