Lines Matching refs:mdsc
45 static u64 __get_oldest_flush_tid(struct ceph_mds_client *mdsc);
46 static void __kick_flushing_caps(struct ceph_mds_client *mdsc,
127 void ceph_caps_init(struct ceph_mds_client *mdsc)
129 INIT_LIST_HEAD(&mdsc->caps_list);
130 spin_lock_init(&mdsc->caps_list_lock);
133 void ceph_caps_finalize(struct ceph_mds_client *mdsc)
137 spin_lock(&mdsc->caps_list_lock);
138 while (!list_empty(&mdsc->caps_list)) {
139 cap = list_first_entry(&mdsc->caps_list,
144 mdsc->caps_total_count = 0;
145 mdsc->caps_avail_count = 0;
146 mdsc->caps_use_count = 0;
147 mdsc->caps_reserve_count = 0;
148 mdsc->caps_min_count = 0;
149 spin_unlock(&mdsc->caps_list_lock);
152 void ceph_adjust_caps_max_min(struct ceph_mds_client *mdsc,
155 spin_lock(&mdsc->caps_list_lock);
156 mdsc->caps_min_count = fsopt->max_readdir;
157 if (mdsc->caps_min_count < 1024)
158 mdsc->caps_min_count = 1024;
159 mdsc->caps_use_max = fsopt->caps_max;
160 if (mdsc->caps_use_max > 0 &&
161 mdsc->caps_use_max < mdsc->caps_min_count)
162 mdsc->caps_use_max = mdsc->caps_min_count;
163 spin_unlock(&mdsc->caps_list_lock);
166 static void __ceph_unreserve_caps(struct ceph_mds_client *mdsc, int nr_caps)
172 BUG_ON(mdsc->caps_reserve_count < nr_caps);
173 mdsc->caps_reserve_count -= nr_caps;
174 if (mdsc->caps_avail_count >=
175 mdsc->caps_reserve_count + mdsc->caps_min_count) {
176 mdsc->caps_total_count -= nr_caps;
178 cap = list_first_entry(&mdsc->caps_list,
184 mdsc->caps_avail_count += nr_caps;
189 mdsc->caps_total_count, mdsc->caps_use_count,
190 mdsc->caps_reserve_count, mdsc->caps_avail_count);
191 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
192 mdsc->caps_reserve_count +
193 mdsc->caps_avail_count);
198 * Called under mdsc->mutex.
200 int ceph_reserve_caps(struct ceph_mds_client *mdsc,
216 spin_lock(&mdsc->caps_list_lock);
217 if (mdsc->caps_avail_count >= need)
220 have = mdsc->caps_avail_count;
221 mdsc->caps_avail_count -= have;
222 mdsc->caps_reserve_count += have;
223 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
224 mdsc->caps_reserve_count +
225 mdsc->caps_avail_count);
226 spin_unlock(&mdsc->caps_list_lock);
238 for (j = 0; j < mdsc->max_sessions; j++) {
239 s = __ceph_lookup_mds_session(mdsc, j);
242 mutex_unlock(&mdsc->mutex);
246 ceph_trim_caps(mdsc, s, max_caps);
250 mutex_lock(&mdsc->mutex);
254 spin_lock(&mdsc->caps_list_lock);
255 if (mdsc->caps_avail_count) {
257 if (mdsc->caps_avail_count >= need - i)
260 more_have = mdsc->caps_avail_count;
264 mdsc->caps_avail_count -= more_have;
265 mdsc->caps_reserve_count += more_have;
268 spin_unlock(&mdsc->caps_list_lock);
285 spin_lock(&mdsc->caps_list_lock);
286 mdsc->caps_total_count += alloc;
287 mdsc->caps_reserve_count += alloc;
288 list_splice(&newcaps, &mdsc->caps_list);
290 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
291 mdsc->caps_reserve_count +
292 mdsc->caps_avail_count);
295 __ceph_unreserve_caps(mdsc, have + alloc);
297 spin_unlock(&mdsc->caps_list_lock);
300 ctx, mdsc->caps_total_count, mdsc->caps_use_count,
301 mdsc->caps_reserve_count, mdsc->caps_avail_count);
305 void ceph_unreserve_caps(struct ceph_mds_client *mdsc,
313 spin_lock(&mdsc->caps_list_lock);
314 __ceph_unreserve_caps(mdsc, ctx->count);
317 if (mdsc->caps_use_max > 0 &&
318 mdsc->caps_use_count > mdsc->caps_use_max)
320 spin_unlock(&mdsc->caps_list_lock);
323 ceph_reclaim_caps_nr(mdsc, ctx->used);
326 struct ceph_cap *ceph_get_cap(struct ceph_mds_client *mdsc,
335 spin_lock(&mdsc->caps_list_lock);
336 mdsc->caps_use_count++;
337 mdsc->caps_total_count++;
338 spin_unlock(&mdsc->caps_list_lock);
340 spin_lock(&mdsc->caps_list_lock);
341 if (mdsc->caps_avail_count) {
342 BUG_ON(list_empty(&mdsc->caps_list));
344 mdsc->caps_avail_count--;
345 mdsc->caps_use_count++;
346 cap = list_first_entry(&mdsc->caps_list,
350 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
351 mdsc->caps_reserve_count + mdsc->caps_avail_count);
353 spin_unlock(&mdsc->caps_list_lock);
359 spin_lock(&mdsc->caps_list_lock);
361 ctx, ctx->count, mdsc->caps_total_count, mdsc->caps_use_count,
362 mdsc->caps_reserve_count, mdsc->caps_avail_count);
364 BUG_ON(ctx->count > mdsc->caps_reserve_count);
365 BUG_ON(list_empty(&mdsc->caps_list));
369 mdsc->caps_reserve_count--;
370 mdsc->caps_use_count++;
372 cap = list_first_entry(&mdsc->caps_list, struct ceph_cap, caps_item);
375 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
376 mdsc->caps_reserve_count + mdsc->caps_avail_count);
377 spin_unlock(&mdsc->caps_list_lock);
381 void ceph_put_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap)
383 spin_lock(&mdsc->caps_list_lock);
385 cap, mdsc->caps_total_count, mdsc->caps_use_count,
386 mdsc->caps_reserve_count, mdsc->caps_avail_count);
387 mdsc->caps_use_count--;
392 if (mdsc->caps_avail_count >= mdsc->caps_reserve_count +
393 mdsc->caps_min_count) {
394 mdsc->caps_total_count--;
397 mdsc->caps_avail_count++;
398 list_add(&cap->caps_item, &mdsc->caps_list);
401 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
402 mdsc->caps_reserve_count + mdsc->caps_avail_count);
403 spin_unlock(&mdsc->caps_list_lock);
410 struct ceph_mds_client *mdsc = fsc->mdsc;
412 spin_lock(&mdsc->caps_list_lock);
415 *total = mdsc->caps_total_count;
417 *avail = mdsc->caps_avail_count;
419 *used = mdsc->caps_use_count;
421 *reserved = mdsc->caps_reserve_count;
423 *min = mdsc->caps_min_count;
425 spin_unlock(&mdsc->caps_list_lock);
489 static void __cap_set_timeouts(struct ceph_mds_client *mdsc,
492 struct ceph_mount_options *opt = mdsc->fsc->mount_options;
505 * -> we take mdsc->cap_delay_lock
507 static void __cap_delay_requeue(struct ceph_mds_client *mdsc,
512 if (!mdsc->stopping) {
513 spin_lock(&mdsc->cap_delay_lock);
519 __cap_set_timeouts(mdsc, ci);
520 list_add_tail(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
522 spin_unlock(&mdsc->cap_delay_lock);
531 static void __cap_delay_requeue_front(struct ceph_mds_client *mdsc,
535 spin_lock(&mdsc->cap_delay_lock);
539 list_add(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
540 spin_unlock(&mdsc->cap_delay_lock);
548 static void __cap_delay_cancel(struct ceph_mds_client *mdsc,
554 spin_lock(&mdsc->cap_delay_lock);
556 spin_unlock(&mdsc->cap_delay_lock);
636 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,
725 ceph_put_snap_realm(mdsc, oldrealm);
746 __cap_delay_requeue(mdsc, ci);
948 ceph_update_cap_hit(&fsc->mdsc->metric);
950 ceph_update_cap_mis(&fsc->mdsc->metric);
1129 ceph_put_snap_realm(ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc,
1143 struct ceph_mds_client *mdsc;
1154 mdsc = ceph_inode_to_client(&ci->vfs_inode)->mdsc;
1172 atomic64_dec(&mdsc->metric.total_caps);
1198 ceph_put_cap(mdsc, cap);
1208 __cap_delay_cancel(mdsc, ci);
1545 struct ceph_mds_client *mdsc = session->s_mdsc;
1569 spin_lock(&mdsc->cap_dirty_lock);
1570 capsnap->cap_flush.tid = ++mdsc->last_cap_flush_tid;
1572 &mdsc->cap_flush_list);
1574 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
1579 spin_unlock(&mdsc->cap_dirty_lock);
1638 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
1666 mutex_lock(&mdsc->mutex);
1667 session = __ceph_lookup_mds_session(mdsc, mds);
1668 mutex_unlock(&mdsc->mutex);
1678 __kick_flushing_caps(mdsc, session, ci, 0);
1691 spin_lock(&mdsc->snap_flush_lock);
1695 spin_unlock(&mdsc->snap_flush_lock);
1709 struct ceph_mds_client *mdsc =
1710 ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc;
1735 WARN_ON_ONCE(!rwsem_is_locked(&mdsc->snap_rwsem));
1742 spin_lock(&mdsc->cap_dirty_lock);
1744 spin_unlock(&mdsc->cap_dirty_lock);
1756 __cap_delay_requeue(mdsc, ci);
1778 static u64 __get_oldest_flush_tid(struct ceph_mds_client *mdsc)
1780 if (!list_empty(&mdsc->cap_flush_list)) {
1782 list_first_entry(&mdsc->cap_flush_list,
1790 * Remove cap_flush from the mdsc's or inode's flushing cap list.
1793 static bool __detach_cap_flush_from_mdsc(struct ceph_mds_client *mdsc,
1799 if (wake && cf->g_list.prev != &mdsc->cap_flush_list) {
1833 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
1856 spin_lock(&mdsc->cap_dirty_lock);
1859 cf->tid = ++mdsc->last_cap_flush_tid;
1860 list_add_tail(&cf->g_list, &mdsc->cap_flush_list);
1861 *oldest_flush_tid = __get_oldest_flush_tid(mdsc);
1865 mdsc->num_cap_flushing++;
1867 spin_unlock(&mdsc->cap_dirty_lock);
1929 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
1933 int took_snap_rwsem = 0; /* true if mdsc->snap_rwsem held */
1968 if (!mdsc->stopping && inode->i_nlink > 0) {
2014 if ((!(flags & CHECK_CAPS_NOINVAL) || mdsc->stopping) &&
2119 up_read(&mdsc->snap_rwsem);
2144 __kick_flushing_caps(mdsc, session, ci, 0);
2153 if (down_read_trylock(&mdsc->snap_rwsem) == 0) {
2157 down_read(&mdsc->snap_rwsem);
2174 spin_lock(&mdsc->cap_dirty_lock);
2175 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2176 spin_unlock(&mdsc->cap_dirty_lock);
2195 __cap_delay_requeue(mdsc, ci);
2206 up_read(&mdsc->snap_rwsem);
2214 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
2243 __kick_flushing_caps(mdsc, session, ci, 0);
2304 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
2336 mutex_lock(&mdsc->mutex);
2337 max_sessions = mdsc->max_sessions;
2341 mutex_unlock(&mdsc->mutex);
2381 mutex_unlock(&mdsc->mutex);
2482 struct ceph_mds_client *mdsc =
2483 ceph_sb_to_client(inode->i_sb)->mdsc;
2487 __cap_delay_requeue_front(mdsc, ci);
2493 static void __kick_flushing_caps(struct ceph_mds_client *mdsc,
2571 void ceph_early_kick_flushing_caps(struct ceph_mds_client *mdsc,
2580 spin_lock(&mdsc->cap_dirty_lock);
2581 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2582 spin_unlock(&mdsc->cap_dirty_lock);
2609 __kick_flushing_caps(mdsc, session, ci,
2619 void ceph_kick_flushing_caps(struct ceph_mds_client *mdsc,
2630 spin_lock(&mdsc->cap_dirty_lock);
2631 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2632 spin_unlock(&mdsc->cap_dirty_lock);
2644 __kick_flushing_caps(mdsc, session, ci,
2654 struct ceph_mds_client *mdsc = session->s_mdsc;
2664 spin_lock(&mdsc->cap_dirty_lock);
2667 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2668 spin_unlock(&mdsc->cap_dirty_lock);
2670 __kick_flushing_caps(mdsc, session, ci, oldest_flush_tid);
2732 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
2754 up_read(&mdsc->snap_rwsem);
2797 if (!down_read_trylock(&mdsc->snap_rwsem)) {
2808 down_read(&mdsc->snap_rwsem);
2842 if (READ_ONCE(mdsc->fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) {
2861 __ceph_touch_fmode(ci, mdsc, flags);
2865 up_read(&mdsc->snap_rwsem);
2868 ceph_update_cap_mis(&mdsc->metric);
2870 ceph_update_cap_hit(&mdsc->metric);
2974 struct ceph_mds_client *mdsc = fsc->mdsc;
2983 spin_lock(&mdsc->caps_list_lock);
2984 list_add(&cw.list, &mdsc->cap_wait_list);
2985 spin_unlock(&mdsc->caps_list_lock);
3004 spin_lock(&mdsc->caps_list_lock);
3006 spin_unlock(&mdsc->caps_list_lock);
3654 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3702 spin_lock(&mdsc->cap_dirty_lock);
3705 wake_mdsc |= __detach_cap_flush_from_mdsc(mdsc, cf);
3718 mdsc->num_cap_flushing--;
3735 spin_unlock(&mdsc->cap_dirty_lock);
3751 wake_up_all(&mdsc->cap_flushing_wq);
3760 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3772 spin_lock(&mdsc->cap_dirty_lock);
3776 ret = __detach_cap_flush_from_mdsc(mdsc, &capsnap->cap_flush);
3779 spin_unlock(&mdsc->cap_dirty_lock);
3804 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3840 wake_up_all(&mdsc->cap_flushing_wq);
3888 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
3963 spin_lock(&mdsc->cap_dirty_lock);
3966 spin_unlock(&mdsc->cap_dirty_lock);
3977 tsession = ceph_mdsc_open_export_target_session(mdsc, target);
3988 new_cap = ceph_get_cap(mdsc, NULL);
4005 ceph_put_cap(mdsc, new_cap);
4013 static void handle_cap_import(struct ceph_mds_client *mdsc,
4047 new_cap = ceph_get_cap(mdsc, NULL);
4054 ceph_put_cap(mdsc, new_cap);
4096 struct ceph_mds_client *mdsc = session->s_mdsc;
4160 struct ceph_osd_client *osdc = &mdsc->fsc->client->osdc;
4209 inode = ceph_find_inode(mdsc->fsc->sb, vino);
4223 cap = ceph_get_cap(mdsc, NULL);
4251 down_write(&mdsc->snap_rwsem);
4252 ceph_update_snap_trace(mdsc, snaptrace,
4255 downgrade_write(&mdsc->snap_rwsem);
4257 down_read(&mdsc->snap_rwsem);
4260 handle_cap_import(mdsc, inode, h, peer, session,
4265 ceph_put_snap_realm(mdsc, realm);
4322 ceph_flush_cap_releases(mdsc, session);
4338 unsigned long ceph_check_delayed_caps(struct ceph_mds_client *mdsc)
4342 struct ceph_mount_options *opt = mdsc->fsc->mount_options;
4348 spin_lock(&mdsc->cap_delay_lock);
4349 while (!list_empty(&mdsc->cap_delay_list)) {
4350 ci = list_first_entry(&mdsc->cap_delay_list,
4365 spin_unlock(&mdsc->cap_delay_lock);
4370 spin_lock(&mdsc->cap_delay_lock);
4373 spin_unlock(&mdsc->cap_delay_lock);
4383 struct ceph_mds_client *mdsc = s->s_mdsc;
4388 spin_lock(&mdsc->cap_dirty_lock);
4395 spin_unlock(&mdsc->cap_dirty_lock);
4398 spin_lock(&mdsc->cap_dirty_lock);
4400 spin_unlock(&mdsc->cap_dirty_lock);
4404 void ceph_flush_dirty_caps(struct ceph_mds_client *mdsc)
4406 ceph_mdsc_iterate_sessions(mdsc, flush_dirty_session_caps, true);
4410 struct ceph_mds_client *mdsc, int fmode)
4421 __cap_delay_requeue(mdsc, ci);
4426 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->vfs_inode.i_sb);
4432 atomic64_inc(&mdsc->metric.opened_files);
4449 percpu_counter_inc(&mdsc->metric.opened_inodes);
4460 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->vfs_inode.i_sb);
4466 atomic64_dec(&mdsc->metric.opened_files);
4485 percpu_counter_dec(&mdsc->metric.opened_inodes);
4505 struct ceph_mds_client *mdsc =
4506 ceph_inode_to_client(inode)->mdsc;
4507 __cap_delay_requeue_front(mdsc, ci);