Lines Matching refs:mdsc
47 static u64 __get_oldest_flush_tid(struct ceph_mds_client *mdsc);
48 static void __kick_flushing_caps(struct ceph_mds_client *mdsc,
129 void ceph_caps_init(struct ceph_mds_client *mdsc)
131 INIT_LIST_HEAD(&mdsc->caps_list);
132 spin_lock_init(&mdsc->caps_list_lock);
135 void ceph_caps_finalize(struct ceph_mds_client *mdsc)
139 spin_lock(&mdsc->caps_list_lock);
140 while (!list_empty(&mdsc->caps_list)) {
141 cap = list_first_entry(&mdsc->caps_list,
146 mdsc->caps_total_count = 0;
147 mdsc->caps_avail_count = 0;
148 mdsc->caps_use_count = 0;
149 mdsc->caps_reserve_count = 0;
150 mdsc->caps_min_count = 0;
151 spin_unlock(&mdsc->caps_list_lock);
154 void ceph_adjust_caps_max_min(struct ceph_mds_client *mdsc,
157 spin_lock(&mdsc->caps_list_lock);
158 mdsc->caps_min_count = fsopt->max_readdir;
159 if (mdsc->caps_min_count < 1024)
160 mdsc->caps_min_count = 1024;
161 mdsc->caps_use_max = fsopt->caps_max;
162 if (mdsc->caps_use_max > 0 &&
163 mdsc->caps_use_max < mdsc->caps_min_count)
164 mdsc->caps_use_max = mdsc->caps_min_count;
165 spin_unlock(&mdsc->caps_list_lock);
168 static void __ceph_unreserve_caps(struct ceph_mds_client *mdsc, int nr_caps)
174 BUG_ON(mdsc->caps_reserve_count < nr_caps);
175 mdsc->caps_reserve_count -= nr_caps;
176 if (mdsc->caps_avail_count >=
177 mdsc->caps_reserve_count + mdsc->caps_min_count) {
178 mdsc->caps_total_count -= nr_caps;
180 cap = list_first_entry(&mdsc->caps_list,
186 mdsc->caps_avail_count += nr_caps;
191 mdsc->caps_total_count, mdsc->caps_use_count,
192 mdsc->caps_reserve_count, mdsc->caps_avail_count);
193 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
194 mdsc->caps_reserve_count +
195 mdsc->caps_avail_count);
200 * Called under mdsc->mutex.
202 int ceph_reserve_caps(struct ceph_mds_client *mdsc,
218 spin_lock(&mdsc->caps_list_lock);
219 if (mdsc->caps_avail_count >= need)
222 have = mdsc->caps_avail_count;
223 mdsc->caps_avail_count -= have;
224 mdsc->caps_reserve_count += have;
225 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
226 mdsc->caps_reserve_count +
227 mdsc->caps_avail_count);
228 spin_unlock(&mdsc->caps_list_lock);
240 for (j = 0; j < mdsc->max_sessions; j++) {
241 s = __ceph_lookup_mds_session(mdsc, j);
244 mutex_unlock(&mdsc->mutex);
248 ceph_trim_caps(mdsc, s, max_caps);
252 mutex_lock(&mdsc->mutex);
256 spin_lock(&mdsc->caps_list_lock);
257 if (mdsc->caps_avail_count) {
259 if (mdsc->caps_avail_count >= need - i)
262 more_have = mdsc->caps_avail_count;
266 mdsc->caps_avail_count -= more_have;
267 mdsc->caps_reserve_count += more_have;
270 spin_unlock(&mdsc->caps_list_lock);
287 spin_lock(&mdsc->caps_list_lock);
288 mdsc->caps_total_count += alloc;
289 mdsc->caps_reserve_count += alloc;
290 list_splice(&newcaps, &mdsc->caps_list);
292 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
293 mdsc->caps_reserve_count +
294 mdsc->caps_avail_count);
297 __ceph_unreserve_caps(mdsc, have + alloc);
299 spin_unlock(&mdsc->caps_list_lock);
302 ctx, mdsc->caps_total_count, mdsc->caps_use_count,
303 mdsc->caps_reserve_count, mdsc->caps_avail_count);
307 void ceph_unreserve_caps(struct ceph_mds_client *mdsc,
315 spin_lock(&mdsc->caps_list_lock);
316 __ceph_unreserve_caps(mdsc, ctx->count);
319 if (mdsc->caps_use_max > 0 &&
320 mdsc->caps_use_count > mdsc->caps_use_max)
322 spin_unlock(&mdsc->caps_list_lock);
325 ceph_reclaim_caps_nr(mdsc, ctx->used);
328 struct ceph_cap *ceph_get_cap(struct ceph_mds_client *mdsc,
337 spin_lock(&mdsc->caps_list_lock);
338 mdsc->caps_use_count++;
339 mdsc->caps_total_count++;
340 spin_unlock(&mdsc->caps_list_lock);
342 spin_lock(&mdsc->caps_list_lock);
343 if (mdsc->caps_avail_count) {
344 BUG_ON(list_empty(&mdsc->caps_list));
346 mdsc->caps_avail_count--;
347 mdsc->caps_use_count++;
348 cap = list_first_entry(&mdsc->caps_list,
352 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
353 mdsc->caps_reserve_count + mdsc->caps_avail_count);
355 spin_unlock(&mdsc->caps_list_lock);
361 spin_lock(&mdsc->caps_list_lock);
363 ctx, ctx->count, mdsc->caps_total_count, mdsc->caps_use_count,
364 mdsc->caps_reserve_count, mdsc->caps_avail_count);
366 BUG_ON(ctx->count > mdsc->caps_reserve_count);
367 BUG_ON(list_empty(&mdsc->caps_list));
371 mdsc->caps_reserve_count--;
372 mdsc->caps_use_count++;
374 cap = list_first_entry(&mdsc->caps_list, struct ceph_cap, caps_item);
377 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
378 mdsc->caps_reserve_count + mdsc->caps_avail_count);
379 spin_unlock(&mdsc->caps_list_lock);
383 void ceph_put_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap)
385 spin_lock(&mdsc->caps_list_lock);
387 cap, mdsc->caps_total_count, mdsc->caps_use_count,
388 mdsc->caps_reserve_count, mdsc->caps_avail_count);
389 mdsc->caps_use_count--;
394 if (mdsc->caps_avail_count >= mdsc->caps_reserve_count +
395 mdsc->caps_min_count) {
396 mdsc->caps_total_count--;
399 mdsc->caps_avail_count++;
400 list_add(&cap->caps_item, &mdsc->caps_list);
403 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
404 mdsc->caps_reserve_count + mdsc->caps_avail_count);
405 spin_unlock(&mdsc->caps_list_lock);
412 struct ceph_mds_client *mdsc = fsc->mdsc;
414 spin_lock(&mdsc->caps_list_lock);
417 *total = mdsc->caps_total_count;
419 *avail = mdsc->caps_avail_count;
421 *used = mdsc->caps_use_count;
423 *reserved = mdsc->caps_reserve_count;
425 *min = mdsc->caps_min_count;
427 spin_unlock(&mdsc->caps_list_lock);
491 static void __cap_set_timeouts(struct ceph_mds_client *mdsc,
494 struct ceph_mount_options *opt = mdsc->fsc->mount_options;
507 * -> we take mdsc->cap_delay_lock
509 static void __cap_delay_requeue(struct ceph_mds_client *mdsc,
514 if (!mdsc->stopping) {
515 spin_lock(&mdsc->cap_delay_lock);
521 __cap_set_timeouts(mdsc, ci);
522 list_add_tail(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
524 spin_unlock(&mdsc->cap_delay_lock);
533 static void __cap_delay_requeue_front(struct ceph_mds_client *mdsc,
537 spin_lock(&mdsc->cap_delay_lock);
541 list_add(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
542 spin_unlock(&mdsc->cap_delay_lock);
550 static void __cap_delay_cancel(struct ceph_mds_client *mdsc,
556 spin_lock(&mdsc->cap_delay_lock);
558 spin_unlock(&mdsc->cap_delay_lock);
638 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
671 atomic64_inc(&mdsc->metric.total_caps);
706 struct ceph_snap_realm *realm = ceph_lookup_snap_realm(mdsc,
729 __cap_delay_requeue(mdsc, ci);
930 ceph_update_cap_hit(&fsc->mdsc->metric);
932 ceph_update_cap_mis(&fsc->mdsc->metric);
1111 struct ceph_mds_client *mdsc;
1124 mdsc = ceph_inode_to_client(&ci->netfs.inode)->mdsc;
1140 atomic64_dec(&mdsc->metric.total_caps);
1167 ceph_put_cap(mdsc, cap);
1177 __cap_delay_cancel(mdsc, ci);
1595 struct ceph_mds_client *mdsc = session->s_mdsc;
1619 spin_lock(&mdsc->cap_dirty_lock);
1620 capsnap->cap_flush.tid = ++mdsc->last_cap_flush_tid;
1622 &mdsc->cap_flush_list);
1624 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
1629 spin_unlock(&mdsc->cap_dirty_lock);
1689 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
1716 mutex_lock(&mdsc->mutex);
1717 session = __ceph_lookup_mds_session(mdsc, mds);
1718 mutex_unlock(&mdsc->mutex);
1724 __kick_flushing_caps(mdsc, session, ci, 0);
1735 spin_lock(&mdsc->snap_flush_lock);
1739 spin_unlock(&mdsc->snap_flush_lock);
1753 struct ceph_mds_client *mdsc =
1754 ceph_sb_to_client(ci->netfs.inode.i_sb)->mdsc;
1779 WARN_ON_ONCE(!rwsem_is_locked(&mdsc->snap_rwsem));
1786 spin_lock(&mdsc->cap_dirty_lock);
1788 spin_unlock(&mdsc->cap_dirty_lock);
1800 __cap_delay_requeue(mdsc, ci);
1822 static u64 __get_oldest_flush_tid(struct ceph_mds_client *mdsc)
1824 if (!list_empty(&mdsc->cap_flush_list)) {
1826 list_first_entry(&mdsc->cap_flush_list,
1834 * Remove cap_flush from the mdsc's or inode's flushing cap list.
1837 static bool __detach_cap_flush_from_mdsc(struct ceph_mds_client *mdsc,
1843 if (wake && cf->g_list.prev != &mdsc->cap_flush_list) {
1877 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
1900 spin_lock(&mdsc->cap_dirty_lock);
1903 cf->tid = ++mdsc->last_cap_flush_tid;
1904 list_add_tail(&cf->g_list, &mdsc->cap_flush_list);
1905 *oldest_flush_tid = __get_oldest_flush_tid(mdsc);
1909 mdsc->num_cap_flushing++;
1911 spin_unlock(&mdsc->cap_dirty_lock);
1972 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
2016 if (!mdsc->stopping && inode->i_nlink > 0) {
2063 if ((!(flags & CHECK_CAPS_NOINVAL) || mdsc->stopping) &&
2180 __kick_flushing_caps(mdsc, session, ci, 0);
2197 spin_lock(&mdsc->cap_dirty_lock);
2198 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2199 spin_unlock(&mdsc->cap_dirty_lock);
2219 __cap_delay_requeue(mdsc, ci);
2236 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
2256 __kick_flushing_caps(mdsc, session, ci, 0);
2314 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
2346 mutex_lock(&mdsc->mutex);
2347 max_sessions = mdsc->max_sessions;
2351 mutex_unlock(&mdsc->mutex);
2391 mutex_unlock(&mdsc->mutex);
2496 struct ceph_mds_client *mdsc =
2497 ceph_sb_to_client(inode->i_sb)->mdsc;
2501 __cap_delay_requeue_front(mdsc, ci);
2507 static void __kick_flushing_caps(struct ceph_mds_client *mdsc,
2589 void ceph_early_kick_flushing_caps(struct ceph_mds_client *mdsc,
2598 spin_lock(&mdsc->cap_dirty_lock);
2599 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2600 spin_unlock(&mdsc->cap_dirty_lock);
2627 __kick_flushing_caps(mdsc, session, ci,
2637 void ceph_kick_flushing_caps(struct ceph_mds_client *mdsc,
2648 spin_lock(&mdsc->cap_dirty_lock);
2649 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2650 spin_unlock(&mdsc->cap_dirty_lock);
2662 __kick_flushing_caps(mdsc, session, ci,
2672 struct ceph_mds_client *mdsc = session->s_mdsc;
2682 spin_lock(&mdsc->cap_dirty_lock);
2685 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2686 spin_unlock(&mdsc->cap_dirty_lock);
2688 __kick_flushing_caps(mdsc, session, ci, oldest_flush_tid);
2750 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
2772 up_read(&mdsc->snap_rwsem);
2819 if (!down_read_trylock(&mdsc->snap_rwsem)) {
2830 down_read(&mdsc->snap_rwsem);
2879 __ceph_touch_fmode(ci, mdsc, flags);
2883 up_read(&mdsc->snap_rwsem);
2886 ceph_update_cap_mis(&mdsc->metric);
2888 ceph_update_cap_hit(&mdsc->metric);
2990 struct ceph_mds_client *mdsc = fsc->mdsc;
2999 spin_lock(&mdsc->caps_list_lock);
3000 list_add(&cw.list, &mdsc->cap_wait_list);
3001 spin_unlock(&mdsc->caps_list_lock);
3020 spin_lock(&mdsc->caps_list_lock);
3022 spin_unlock(&mdsc->caps_list_lock);
3731 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3779 spin_lock(&mdsc->cap_dirty_lock);
3782 wake_mdsc |= __detach_cap_flush_from_mdsc(mdsc, cf);
3795 mdsc->num_cap_flushing--;
3812 spin_unlock(&mdsc->cap_dirty_lock);
3828 wake_up_all(&mdsc->cap_flushing_wq);
3837 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3849 spin_lock(&mdsc->cap_dirty_lock);
3853 ret = __detach_cap_flush_from_mdsc(mdsc, &capsnap->cap_flush);
3856 spin_unlock(&mdsc->cap_dirty_lock);
3881 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3916 wake_up_all(&mdsc->cap_flushing_wq);
3973 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
3996 down_read(&mdsc->snap_rwsem);
4049 spin_lock(&mdsc->cap_dirty_lock);
4052 spin_unlock(&mdsc->cap_dirty_lock);
4060 up_read(&mdsc->snap_rwsem);
4064 tsession = ceph_mdsc_open_export_target_session(mdsc, target);
4075 new_cap = ceph_get_cap(mdsc, NULL);
4086 up_read(&mdsc->snap_rwsem);
4093 ceph_put_cap(mdsc, new_cap);
4101 static void handle_cap_import(struct ceph_mds_client *mdsc,
4135 new_cap = ceph_get_cap(mdsc, NULL);
4142 ceph_put_cap(mdsc, new_cap);
4230 struct ceph_mds_client *mdsc = session->s_mdsc;
4251 if (!ceph_inc_mds_stopping_blocker(mdsc, session))
4299 struct ceph_osd_client *osdc = &mdsc->fsc->client->osdc;
4350 inode = ceph_find_inode(mdsc->fsc->sb, vino);
4388 down_write(&mdsc->snap_rwsem);
4389 if (ceph_update_snap_trace(mdsc, snaptrace,
4392 up_write(&mdsc->snap_rwsem);
4396 downgrade_write(&mdsc->snap_rwsem);
4398 down_read(&mdsc->snap_rwsem);
4401 handle_cap_import(mdsc, inode, h, peer, session,
4406 ceph_put_snap_realm(mdsc, realm);
4463 ceph_dec_mds_stopping_blocker(mdsc);
4469 ceph_mdsc_close_sessions(mdsc);
4481 cap = ceph_get_cap(mdsc, NULL);
4492 ceph_flush_cap_releases(mdsc, session);
4508 unsigned long ceph_check_delayed_caps(struct ceph_mds_client *mdsc)
4512 struct ceph_mount_options *opt = mdsc->fsc->mount_options;
4518 spin_lock(&mdsc->cap_delay_lock);
4519 while (!list_empty(&mdsc->cap_delay_list)) {
4520 ci = list_first_entry(&mdsc->cap_delay_list,
4535 spin_unlock(&mdsc->cap_delay_lock);
4539 spin_lock(&mdsc->cap_delay_lock);
4542 spin_unlock(&mdsc->cap_delay_lock);
4552 struct ceph_mds_client *mdsc = s->s_mdsc;
4557 spin_lock(&mdsc->cap_dirty_lock);
4564 spin_unlock(&mdsc->cap_dirty_lock);
4568 spin_lock(&mdsc->cap_dirty_lock);
4570 spin_unlock(&mdsc->cap_dirty_lock);
4574 void ceph_flush_dirty_caps(struct ceph_mds_client *mdsc)
4576 ceph_mdsc_iterate_sessions(mdsc, flush_dirty_session_caps, true);
4580 struct ceph_mds_client *mdsc, int fmode)
4591 __cap_delay_requeue(mdsc, ci);
4596 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->netfs.inode.i_sb);
4602 atomic64_inc(&mdsc->metric.opened_files);
4619 percpu_counter_inc(&mdsc->metric.opened_inodes);
4630 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->netfs.inode.i_sb);
4636 atomic64_dec(&mdsc->metric.opened_files);
4655 percpu_counter_dec(&mdsc->metric.opened_inodes);
4675 struct ceph_mds_client *mdsc =
4676 ceph_inode_to_client(inode)->mdsc;
4677 __cap_delay_requeue_front(mdsc, ci);
4831 static int remove_capsnaps(struct ceph_mds_client *mdsc, struct inode *inode)
4850 wake_up_all(&mdsc->cap_flushing_wq);
4857 struct ceph_mds_client *mdsc = fsc->mdsc;
4880 spin_lock(&mdsc->cap_dirty_lock);
4908 mdsc->num_cap_flushing--;
4911 spin_unlock(&mdsc->cap_dirty_lock);
4940 iputs = remove_capsnaps(mdsc, inode);