Lines Matching defs: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;
189 doutc(mdsc->fsc->client,
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,
205 struct ceph_client *cl = mdsc->fsc->client;
219 spin_lock(&mdsc->caps_list_lock);
220 if (mdsc->caps_avail_count >= need)
223 have = mdsc->caps_avail_count;
224 mdsc->caps_avail_count -= have;
225 mdsc->caps_reserve_count += have;
226 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
227 mdsc->caps_reserve_count +
228 mdsc->caps_avail_count);
229 spin_unlock(&mdsc->caps_list_lock);
241 for (j = 0; j < mdsc->max_sessions; j++) {
242 s = __ceph_lookup_mds_session(mdsc, j);
245 mutex_unlock(&mdsc->mutex);
249 ceph_trim_caps(mdsc, s, max_caps);
253 mutex_lock(&mdsc->mutex);
257 spin_lock(&mdsc->caps_list_lock);
258 if (mdsc->caps_avail_count) {
260 if (mdsc->caps_avail_count >= need - i)
263 more_have = mdsc->caps_avail_count;
267 mdsc->caps_avail_count -= more_have;
268 mdsc->caps_reserve_count += more_have;
271 spin_unlock(&mdsc->caps_list_lock);
288 spin_lock(&mdsc->caps_list_lock);
289 mdsc->caps_total_count += alloc;
290 mdsc->caps_reserve_count += alloc;
291 list_splice(&newcaps, &mdsc->caps_list);
293 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
294 mdsc->caps_reserve_count +
295 mdsc->caps_avail_count);
298 __ceph_unreserve_caps(mdsc, have + alloc);
300 spin_unlock(&mdsc->caps_list_lock);
303 mdsc->caps_total_count, mdsc->caps_use_count,
304 mdsc->caps_reserve_count, mdsc->caps_avail_count);
308 void ceph_unreserve_caps(struct ceph_mds_client *mdsc,
311 struct ceph_client *cl = mdsc->fsc->client;
317 spin_lock(&mdsc->caps_list_lock);
318 __ceph_unreserve_caps(mdsc, ctx->count);
321 if (mdsc->caps_use_max > 0 &&
322 mdsc->caps_use_count > mdsc->caps_use_max)
324 spin_unlock(&mdsc->caps_list_lock);
327 ceph_reclaim_caps_nr(mdsc, ctx->used);
330 struct ceph_cap *ceph_get_cap(struct ceph_mds_client *mdsc,
333 struct ceph_client *cl = mdsc->fsc->client;
340 spin_lock(&mdsc->caps_list_lock);
341 mdsc->caps_use_count++;
342 mdsc->caps_total_count++;
343 spin_unlock(&mdsc->caps_list_lock);
345 spin_lock(&mdsc->caps_list_lock);
346 if (mdsc->caps_avail_count) {
347 BUG_ON(list_empty(&mdsc->caps_list));
349 mdsc->caps_avail_count--;
350 mdsc->caps_use_count++;
351 cap = list_first_entry(&mdsc->caps_list,
355 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
356 mdsc->caps_reserve_count + mdsc->caps_avail_count);
358 spin_unlock(&mdsc->caps_list_lock);
364 spin_lock(&mdsc->caps_list_lock);
366 ctx->count, mdsc->caps_total_count, mdsc->caps_use_count,
367 mdsc->caps_reserve_count, mdsc->caps_avail_count);
369 BUG_ON(ctx->count > mdsc->caps_reserve_count);
370 BUG_ON(list_empty(&mdsc->caps_list));
374 mdsc->caps_reserve_count--;
375 mdsc->caps_use_count++;
377 cap = list_first_entry(&mdsc->caps_list, struct ceph_cap, caps_item);
380 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
381 mdsc->caps_reserve_count + mdsc->caps_avail_count);
382 spin_unlock(&mdsc->caps_list_lock);
386 void ceph_put_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap)
388 struct ceph_client *cl = mdsc->fsc->client;
390 spin_lock(&mdsc->caps_list_lock);
392 mdsc->caps_total_count, mdsc->caps_use_count,
393 mdsc->caps_reserve_count, mdsc->caps_avail_count);
394 mdsc->caps_use_count--;
399 if (mdsc->caps_avail_count >= mdsc->caps_reserve_count +
400 mdsc->caps_min_count) {
401 mdsc->caps_total_count--;
404 mdsc->caps_avail_count++;
405 list_add(&cap->caps_item, &mdsc->caps_list);
408 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
409 mdsc->caps_reserve_count + mdsc->caps_avail_count);
410 spin_unlock(&mdsc->caps_list_lock);
417 struct ceph_mds_client *mdsc = fsc->mdsc;
419 spin_lock(&mdsc->caps_list_lock);
422 *total = mdsc->caps_total_count;
424 *avail = mdsc->caps_avail_count;
426 *used = mdsc->caps_use_count;
428 *reserved = mdsc->caps_reserve_count;
430 *min = mdsc->caps_min_count;
432 spin_unlock(&mdsc->caps_list_lock);
496 static void __cap_set_timeouts(struct ceph_mds_client *mdsc,
500 struct ceph_mount_options *opt = mdsc->fsc->mount_options;
504 doutc(mdsc->fsc->client, "%p %llx.%llx %lu\n", inode,
514 * -> we take mdsc->cap_delay_lock
516 static void __cap_delay_requeue(struct ceph_mds_client *mdsc,
521 doutc(mdsc->fsc->client, "%p %llx.%llx flags 0x%lx at %lu\n",
524 if (!mdsc->stopping) {
525 spin_lock(&mdsc->cap_delay_lock);
531 __cap_set_timeouts(mdsc, ci);
532 list_add_tail(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
534 spin_unlock(&mdsc->cap_delay_lock);
543 static void __cap_delay_requeue_front(struct ceph_mds_client *mdsc,
548 doutc(mdsc->fsc->client, "%p %llx.%llx\n", inode, ceph_vinop(inode));
549 spin_lock(&mdsc->cap_delay_lock);
553 list_add(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
554 spin_unlock(&mdsc->cap_delay_lock);
562 static void __cap_delay_cancel(struct ceph_mds_client *mdsc,
567 doutc(mdsc->fsc->client, "%p %llx.%llx\n", inode, ceph_vinop(inode));
570 spin_lock(&mdsc->cap_delay_lock);
572 spin_unlock(&mdsc->cap_delay_lock);
655 struct ceph_mds_client *mdsc = ceph_inode_to_fs_client(inode)->mdsc;
690 atomic64_inc(&mdsc->metric.total_caps);
725 struct ceph_snap_realm *realm = ceph_lookup_snap_realm(mdsc,
748 __cap_delay_requeue(mdsc, ci);
956 ceph_update_cap_hit(&fsc->mdsc->metric);
958 ceph_update_cap_mis(&fsc->mdsc->metric);
1140 struct ceph_mds_client *mdsc;
1153 mdsc = ceph_inode_to_fs_client(&ci->netfs.inode)->mdsc;
1169 atomic64_dec(&mdsc->metric.total_caps);
1196 ceph_put_cap(mdsc, cap);
1206 __cap_delay_cancel(mdsc, ci);
1210 void ceph_remove_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap,
1218 doutc(mdsc->fsc->client, "inode is NULL\n");
1260 struct ceph_mds_client *mdsc = arg->session->s_mdsc;
1261 struct ceph_osd_client *osdc = &mdsc->fsc->client->osdc;
1263 doutc(mdsc->fsc->client,
1380 struct ceph_mds_client *mdsc = ceph_inode_to_fs_client(inode)->mdsc;
1390 ceph_remove_cap(mdsc, cap, true);
1635 struct ceph_mds_client *mdsc = session->s_mdsc;
1636 struct ceph_client *cl = mdsc->fsc->client;
1661 spin_lock(&mdsc->cap_dirty_lock);
1662 capsnap->cap_flush.tid = ++mdsc->last_cap_flush_tid;
1664 &mdsc->cap_flush_list);
1666 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
1671 spin_unlock(&mdsc->cap_dirty_lock);
1733 struct ceph_mds_client *mdsc = ceph_inode_to_fs_client(inode)->mdsc;
1761 mutex_lock(&mdsc->mutex);
1762 session = __ceph_lookup_mds_session(mdsc, mds);
1763 mutex_unlock(&mdsc->mutex);
1769 __kick_flushing_caps(mdsc, session, ci, 0);
1780 spin_lock(&mdsc->snap_flush_lock);
1784 spin_unlock(&mdsc->snap_flush_lock);
1798 struct ceph_mds_client *mdsc =
1799 ceph_sb_to_fs_client(ci->netfs.inode.i_sb)->mdsc;
1826 WARN_ON_ONCE(!rwsem_is_locked(&mdsc->snap_rwsem));
1834 spin_lock(&mdsc->cap_dirty_lock);
1836 spin_unlock(&mdsc->cap_dirty_lock);
1848 __cap_delay_requeue(mdsc, ci);
1870 static u64 __get_oldest_flush_tid(struct ceph_mds_client *mdsc)
1872 if (!list_empty(&mdsc->cap_flush_list)) {
1874 list_first_entry(&mdsc->cap_flush_list,
1882 * Remove cap_flush from the mdsc's or inode's flushing cap list.
1885 static bool __detach_cap_flush_from_mdsc(struct ceph_mds_client *mdsc,
1891 if (wake && cf->g_list.prev != &mdsc->cap_flush_list) {
1925 struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(inode->i_sb)->mdsc;
1949 spin_lock(&mdsc->cap_dirty_lock);
1952 cf->tid = ++mdsc->last_cap_flush_tid;
1953 list_add_tail(&cf->g_list, &mdsc->cap_flush_list);
1954 *oldest_flush_tid = __get_oldest_flush_tid(mdsc);
1958 mdsc->num_cap_flushing++;
1960 spin_unlock(&mdsc->cap_dirty_lock);
2023 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
2068 if (!mdsc->stopping && inode->i_nlink > 0) {
2115 if ((!(flags & CHECK_CAPS_NOINVAL) || mdsc->stopping) &&
2232 __kick_flushing_caps(mdsc, session, ci, 0);
2249 spin_lock(&mdsc->cap_dirty_lock);
2250 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2251 spin_unlock(&mdsc->cap_dirty_lock);
2271 __cap_delay_requeue(mdsc, ci);
2288 struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(inode->i_sb)->mdsc;
2308 __kick_flushing_caps(mdsc, session, ci, 0);
2366 struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(inode->i_sb)->mdsc;
2399 mutex_lock(&mdsc->mutex);
2400 max_sessions = mdsc->max_sessions;
2404 mutex_unlock(&mdsc->mutex);
2444 mutex_unlock(&mdsc->mutex);
2554 struct ceph_mds_client *mdsc =
2555 ceph_sb_to_fs_client(inode->i_sb)->mdsc;
2559 __cap_delay_requeue_front(mdsc, ci);
2565 static void __kick_flushing_caps(struct ceph_mds_client *mdsc,
2573 struct ceph_client *cl = mdsc->fsc->client;
2648 void ceph_early_kick_flushing_caps(struct ceph_mds_client *mdsc,
2651 struct ceph_client *cl = mdsc->fsc->client;
2658 spin_lock(&mdsc->cap_dirty_lock);
2659 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2660 spin_unlock(&mdsc->cap_dirty_lock);
2690 __kick_flushing_caps(mdsc, session, ci,
2700 void ceph_kick_flushing_caps(struct ceph_mds_client *mdsc,
2703 struct ceph_client *cl = mdsc->fsc->client;
2712 spin_lock(&mdsc->cap_dirty_lock);
2713 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2714 spin_unlock(&mdsc->cap_dirty_lock);
2729 __kick_flushing_caps(mdsc, session, ci,
2739 struct ceph_mds_client *mdsc = session->s_mdsc;
2745 doutc(mdsc->fsc->client, "%p %llx.%llx flushing %s\n",
2751 spin_lock(&mdsc->cap_dirty_lock);
2754 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2755 spin_unlock(&mdsc->cap_dirty_lock);
2757 __kick_flushing_caps(mdsc, session, ci, oldest_flush_tid);
2822 struct ceph_mds_client *mdsc = ceph_inode_to_fs_client(inode)->mdsc;
2847 up_read(&mdsc->snap_rwsem);
2895 if (!down_read_trylock(&mdsc->snap_rwsem)) {
2906 down_read(&mdsc->snap_rwsem);
2958 __ceph_touch_fmode(ci, mdsc, flags);
2962 up_read(&mdsc->snap_rwsem);
2965 ceph_update_cap_mis(&mdsc->metric);
2967 ceph_update_cap_hit(&mdsc->metric);
3070 struct ceph_mds_client *mdsc = fsc->mdsc;
3079 spin_lock(&mdsc->caps_list_lock);
3080 list_add(&cw.list, &mdsc->cap_wait_list);
3081 spin_unlock(&mdsc->caps_list_lock);
3100 spin_lock(&mdsc->caps_list_lock);
3102 spin_unlock(&mdsc->caps_list_lock);
3811 struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(inode->i_sb)->mdsc;
3812 struct ceph_client *cl = mdsc->fsc->client;
3860 spin_lock(&mdsc->cap_dirty_lock);
3863 wake_mdsc |= __detach_cap_flush_from_mdsc(mdsc, cf);
3877 mdsc->num_cap_flushing--;
3896 spin_unlock(&mdsc->cap_dirty_lock);
3912 wake_up_all(&mdsc->cap_flushing_wq);
3921 struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(inode->i_sb)->mdsc;
3922 struct ceph_client *cl = mdsc->fsc->client;
3935 spin_lock(&mdsc->cap_dirty_lock);
3939 ret = __detach_cap_flush_from_mdsc(mdsc, &capsnap->cap_flush);
3942 spin_unlock(&mdsc->cap_dirty_lock);
3967 struct ceph_mds_client *mdsc = ceph_sb_to_fs_client(inode->i_sb)->mdsc;
3968 struct ceph_client *cl = mdsc->fsc->client;
4004 wake_up_all(&mdsc->cap_flushing_wq);
4062 struct ceph_mds_client *mdsc = ceph_inode_to_fs_client(inode)->mdsc;
4063 struct ceph_client *cl = mdsc->fsc->client;
4086 down_read(&mdsc->snap_rwsem);
4093 ceph_remove_cap(mdsc, cap, false);
4130 ceph_remove_cap(mdsc, cap, false);
4141 spin_lock(&mdsc->cap_dirty_lock);
4144 spin_unlock(&mdsc->cap_dirty_lock);
4147 ceph_remove_cap(mdsc, cap, false);
4152 up_read(&mdsc->snap_rwsem);
4156 tsession = ceph_mdsc_open_export_target_session(mdsc, target);
4167 new_cap = ceph_get_cap(mdsc, NULL);
4178 up_read(&mdsc->snap_rwsem);
4185 ceph_put_cap(mdsc, new_cap);
4193 static void handle_cap_import(struct ceph_mds_client *mdsc,
4200 struct ceph_client *cl = mdsc->fsc->client;
4228 new_cap = ceph_get_cap(mdsc, NULL);
4235 ceph_put_cap(mdsc, new_cap);
4261 ceph_remove_cap(mdsc, ocap, (ph->flags & CEPH_CAP_FLAG_RELEASE));
4323 struct ceph_mds_client *mdsc = session->s_mdsc;
4324 struct ceph_client *cl = mdsc->fsc->client;
4345 if (!ceph_inc_mds_stopping_blocker(mdsc, session))
4393 struct ceph_osd_client *osdc = &mdsc->fsc->client->osdc;
4444 inode = ceph_find_inode(mdsc->fsc->sb, vino);
4482 down_write(&mdsc->snap_rwsem);
4483 if (ceph_update_snap_trace(mdsc, snaptrace,
4486 up_write(&mdsc->snap_rwsem);
4490 downgrade_write(&mdsc->snap_rwsem);
4492 down_read(&mdsc->snap_rwsem);
4495 handle_cap_import(mdsc, inode, h, peer, session,
4500 ceph_put_snap_realm(mdsc, realm);
4557 ceph_dec_mds_stopping_blocker(mdsc);
4563 ceph_mdsc_close_sessions(mdsc);
4575 cap = ceph_get_cap(mdsc, NULL);
4586 ceph_flush_cap_releases(mdsc, session);
4602 unsigned long ceph_check_delayed_caps(struct ceph_mds_client *mdsc)
4604 struct ceph_client *cl = mdsc->fsc->client;
4607 struct ceph_mount_options *opt = mdsc->fsc->mount_options;
4613 spin_lock(&mdsc->cap_delay_lock);
4614 while (!list_empty(&mdsc->cap_delay_list)) {
4615 ci = list_first_entry(&mdsc->cap_delay_list,
4630 spin_unlock(&mdsc->cap_delay_lock);
4635 spin_lock(&mdsc->cap_delay_lock);
4640 * slowness doesn't block mdsc delayed work,
4646 spin_unlock(&mdsc->cap_delay_lock);
4657 struct ceph_mds_client *mdsc = s->s_mdsc;
4658 struct ceph_client *cl = mdsc->fsc->client;
4663 spin_lock(&mdsc->cap_dirty_lock);
4670 spin_unlock(&mdsc->cap_dirty_lock);
4674 spin_lock(&mdsc->cap_dirty_lock);
4676 spin_unlock(&mdsc->cap_dirty_lock);
4680 void ceph_flush_dirty_caps(struct ceph_mds_client *mdsc)
4682 ceph_mdsc_iterate_sessions(mdsc, flush_dirty_session_caps, true);
4686 struct ceph_mds_client *mdsc, int fmode)
4697 __cap_delay_requeue(mdsc, ci);
4702 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->netfs.inode.i_sb);
4708 atomic64_inc(&mdsc->metric.opened_files);
4725 percpu_counter_inc(&mdsc->metric.opened_inodes);
4736 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->netfs.inode.i_sb);
4742 atomic64_dec(&mdsc->metric.opened_files);
4761 percpu_counter_dec(&mdsc->metric.opened_inodes);
4781 struct ceph_mds_client *mdsc =
4782 ceph_inode_to_fs_client(inode)->mdsc;
4784 doutc(mdsc->fsc->client, "%p %llx.%llx\n", inode,
4786 spin_lock(&mdsc->cap_delay_lock);
4791 &mdsc->cap_unlink_delay_list);
4792 spin_unlock(&mdsc->cap_delay_lock);
4798 ceph_queue_cap_unlink_work(mdsc);
4957 static int remove_capsnaps(struct ceph_mds_client *mdsc, struct inode *inode)
4960 struct ceph_client *cl = mdsc->fsc->client;
4978 wake_up_all(&mdsc->cap_flushing_wq);
4985 struct ceph_mds_client *mdsc = fsc->mdsc;
5009 spin_lock(&mdsc->cap_dirty_lock);
5037 mdsc->num_cap_flushing--;
5040 spin_unlock(&mdsc->cap_dirty_lock);
5070 iputs = remove_capsnaps(mdsc, inode);