Lines Matching refs:ci
48 struct ceph_inode_info *ci,
433 static struct ceph_cap *__get_cap_for_mds(struct ceph_inode_info *ci, int mds)
436 struct rb_node *n = ci->i_caps.rb_node;
450 struct ceph_cap *ceph_get_cap_for_mds(struct ceph_inode_info *ci, int mds)
454 spin_lock(&ci->i_ceph_lock);
455 cap = __get_cap_for_mds(ci, mds);
456 spin_unlock(&ci->i_ceph_lock);
463 static void __insert_cap_node(struct ceph_inode_info *ci,
466 struct rb_node **p = &ci->i_caps.rb_node;
482 rb_insert_color(&new->ci_node, &ci->i_caps);
490 struct ceph_inode_info *ci)
493 ci->i_hold_caps_max = round_jiffies(jiffies +
495 dout("__cap_set_timeouts %p %lu\n", &ci->vfs_inode,
496 ci->i_hold_caps_max - jiffies);
508 struct ceph_inode_info *ci)
510 dout("__cap_delay_requeue %p flags 0x%lx at %lu\n", &ci->vfs_inode,
511 ci->i_ceph_flags, ci->i_hold_caps_max);
514 if (!list_empty(&ci->i_cap_delay_list)) {
515 if (ci->i_ceph_flags & CEPH_I_FLUSH)
517 list_del_init(&ci->i_cap_delay_list);
519 __cap_set_timeouts(mdsc, ci);
520 list_add_tail(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
532 struct ceph_inode_info *ci)
534 dout("__cap_delay_requeue_front %p\n", &ci->vfs_inode);
536 ci->i_ceph_flags |= CEPH_I_FLUSH;
537 if (!list_empty(&ci->i_cap_delay_list))
538 list_del_init(&ci->i_cap_delay_list);
539 list_add(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
549 struct ceph_inode_info *ci)
551 dout("__cap_delay_cancel %p\n", &ci->vfs_inode);
552 if (list_empty(&ci->i_cap_delay_list))
555 list_del_init(&ci->i_cap_delay_list);
560 static void __check_cap_issue(struct ceph_inode_info *ci, struct ceph_cap *cap,
563 unsigned had = __ceph_caps_issued(ci, NULL);
565 lockdep_assert_held(&ci->i_ceph_lock);
571 if (S_ISREG(ci->vfs_inode.i_mode) &&
574 ci->i_rdcache_gen++;
585 atomic_inc(&ci->i_shared_gen);
586 if (S_ISDIR(ci->vfs_inode.i_mode)) {
587 dout(" marking %p NOT complete\n", &ci->vfs_inode);
588 __ceph_dir_clear_complete(ci);
593 if (S_ISDIR(ci->vfs_inode.i_mode) && (had & CEPH_CAP_DIR_CREATE) &&
595 ceph_put_string(rcu_dereference_raw(ci->i_cached_layout.pool_ns));
596 memset(&ci->i_cached_layout, 0, sizeof(ci->i_cached_layout));
602 * @ci: inode to be moved
605 static void change_auth_cap_ses(struct ceph_inode_info *ci,
608 lockdep_assert_held(&ci->i_ceph_lock);
610 if (list_empty(&ci->i_dirty_item) && list_empty(&ci->i_flushing_item))
614 if (!list_empty(&ci->i_dirty_item))
615 list_move(&ci->i_dirty_item, &session->s_cap_dirty);
616 if (!list_empty(&ci->i_flushing_item))
617 list_move_tail(&ci->i_flushing_item, &session->s_cap_flushing);
624 * Caller should hold session snap_rwsem (read) and ci->i_ceph_lock
637 struct ceph_inode_info *ci = ceph_inode(inode);
643 lockdep_assert_held(&ci->i_ceph_lock);
652 cap = __get_cap_for_mds(ci, mds);
663 cap->ci = ci;
664 __insert_cap_node(ci, cap);
691 WARN_ON(cap != ci->i_auth_cap);
700 if (!ci->i_snap_realm ||
702 realmino != (u64)-1 && ci->i_snap_realm->ino != realmino)) {
709 struct ceph_snap_realm *oldrealm = ci->i_snap_realm;
712 list_del_init(&ci->i_snap_realm_item);
717 list_add(&ci->i_snap_realm_item,
719 ci->i_snap_realm = realm;
720 if (realm->ino == ci->i_vino.ino)
733 __check_cap_issue(ci, cap, issued);
740 actual_wanted = __ceph_caps_wanted(ci);
746 __cap_delay_requeue(mdsc, ci);
750 if (!ci->i_auth_cap ||
751 ceph_seq_cmp(ci->i_auth_cap->mseq, mseq) < 0) {
752 if (ci->i_auth_cap &&
753 ci->i_auth_cap->session != cap->session)
754 change_auth_cap_ses(ci, cap->session);
755 ci->i_auth_cap = cap;
759 WARN_ON(ci->i_auth_cap == cap);
795 "but STALE (gen %u vs %u)\n", &cap->ci->vfs_inode,
808 int __ceph_caps_issued(struct ceph_inode_info *ci, int *implemented)
810 int have = ci->i_snap_caps;
816 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
821 &ci->vfs_inode, cap, ceph_cap_string(cap->issued));
831 if (ci->i_auth_cap) {
832 cap = ci->i_auth_cap;
841 int __ceph_caps_issued_other(struct ceph_inode_info *ci, struct ceph_cap *ocap)
843 int have = ci->i_snap_caps;
847 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
868 dout("__touch_cap %p cap %p mds%d\n", &cap->ci->vfs_inode, cap,
873 &cap->ci->vfs_inode, cap, s->s_mds);
883 int __ceph_caps_issued_mask(struct ceph_inode_info *ci, int mask, int touch)
887 int have = ci->i_snap_caps;
891 " (mask %s)\n", ceph_ino(&ci->vfs_inode),
897 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
903 " (mask %s)\n", ceph_ino(&ci->vfs_inode), cap,
915 " (mask %s)\n", ceph_ino(&ci->vfs_inode),
923 for (q = rb_first(&ci->i_caps); q != p;
940 int __ceph_caps_issued_mask_metric(struct ceph_inode_info *ci, int mask,
943 struct ceph_fs_client *fsc = ceph_sb_to_client(ci->vfs_inode.i_sb);
946 r = __ceph_caps_issued_mask(ci, mask, touch);
957 int __ceph_caps_revoking_other(struct ceph_inode_info *ci,
963 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
972 int ceph_caps_revoking(struct ceph_inode_info *ci, int mask)
974 struct inode *inode = &ci->vfs_inode;
977 spin_lock(&ci->i_ceph_lock);
978 ret = __ceph_caps_revoking_other(ci, NULL, mask);
979 spin_unlock(&ci->i_ceph_lock);
985 int __ceph_caps_used(struct ceph_inode_info *ci)
988 if (ci->i_pin_ref)
990 if (ci->i_rd_ref)
992 if (ci->i_rdcache_ref ||
993 (S_ISREG(ci->vfs_inode.i_mode) &&
994 ci->vfs_inode.i_data.nrpages))
996 if (ci->i_wr_ref)
998 if (ci->i_wb_ref || ci->i_wrbuffer_ref)
1000 if (ci->i_fx_ref)
1010 int __ceph_caps_file_wanted(struct ceph_inode_info *ci)
1017 ceph_inode_to_client(&ci->vfs_inode)->mount_options;
1021 if (S_ISDIR(ci->vfs_inode.i_mode)) {
1025 if (ci->i_nr_by_mode[RD_SHIFT] > 0 ||
1026 time_after(ci->i_last_rd, used_cutoff))
1029 if (ci->i_nr_by_mode[WR_SHIFT] > 0 ||
1030 time_after(ci->i_last_wr, used_cutoff)) {
1036 if (want || ci->i_nr_by_mode[PIN_SHIFT] > 0)
1043 if (ci->i_nr_by_mode[RD_SHIFT] > 0) {
1044 if (ci->i_nr_by_mode[RD_SHIFT] >= FMODE_WAIT_BIAS ||
1045 time_after(ci->i_last_rd, used_cutoff))
1047 } else if (time_after(ci->i_last_rd, idle_cutoff)) {
1051 if (ci->i_nr_by_mode[WR_SHIFT] > 0) {
1052 if (ci->i_nr_by_mode[WR_SHIFT] >= FMODE_WAIT_BIAS ||
1053 time_after(ci->i_last_wr, used_cutoff))
1055 } else if (time_after(ci->i_last_wr, idle_cutoff)) {
1061 ci->i_nr_by_mode[LAZY_SHIFT] > 0)
1071 int __ceph_caps_wanted(struct ceph_inode_info *ci)
1073 int w = __ceph_caps_file_wanted(ci) | __ceph_caps_used(ci);
1074 if (S_ISDIR(ci->vfs_inode.i_mode)) {
1089 int __ceph_caps_mds_wanted(struct ceph_inode_info *ci, bool check)
1095 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
1099 if (cap == ci->i_auth_cap)
1109 struct ceph_inode_info *ci = ceph_inode(inode);
1112 spin_lock(&ci->i_ceph_lock);
1113 ret = __ceph_is_any_real_caps(ci);
1114 spin_unlock(&ci->i_ceph_lock);
1119 static void drop_inode_snap_realm(struct ceph_inode_info *ci)
1121 struct ceph_snap_realm *realm = ci->i_snap_realm;
1123 list_del_init(&ci->i_snap_realm_item);
1124 ci->i_snap_realm_counter++;
1125 ci->i_snap_realm = NULL;
1126 if (realm->ino == ci->i_vino.ino)
1129 ceph_put_snap_realm(ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc,
1142 struct ceph_inode_info *ci = cap->ci;
1146 /* 'ci' being NULL means the remove have already occurred */
1147 if (!ci) {
1152 dout("__ceph_remove_cap %p from %p\n", cap, &ci->vfs_inode);
1154 mdsc = ceph_inode_to_client(&ci->vfs_inode)->mdsc;
1157 rb_erase(&cap->ci_node, &ci->i_caps);
1158 if (ci->i_auth_cap == cap) {
1159 WARN_ON_ONCE(!list_empty(&ci->i_dirty_item));
1160 ci->i_auth_cap = NULL;
1177 cap->ci = NULL;
1193 cap->cap_ino = ci->i_vino.ino;
1200 if (!__ceph_is_any_real_caps(ci)) {
1205 if (ci->i_wr_ref == 0 && ci->i_snap_realm)
1206 drop_inode_snap_realm(ci);
1208 __cap_delay_cancel(mdsc, ci);
1329 void __ceph_remove_caps(struct ceph_inode_info *ci)
1335 spin_lock(&ci->i_ceph_lock);
1336 p = rb_first(&ci->i_caps);
1342 spin_unlock(&ci->i_ceph_lock);
1357 struct ceph_inode_info *ci = cap->ci;
1358 struct inode *inode = &ci->vfs_inode;
1361 lockdep_assert_held(&ci->i_ceph_lock);
1373 ci->i_ceph_flags &= ~CEPH_I_FLUSH;
1388 arg->follows = flushing ? ci->i_head_snapc->seq : 0;
1393 ci->i_reported_size = arg->size;
1394 arg->max_size = ci->i_wanted_max_size;
1395 if (cap == ci->i_auth_cap) {
1397 ci->i_requested_max_size = arg->max_size;
1399 ci->i_requested_max_size = 0;
1403 arg->old_xattr_buf = __ceph_build_xattrs_blob(ci);
1404 arg->xattr_version = ci->i_xattrs.version;
1405 arg->xattr_buf = ceph_buffer_get(ci->i_xattrs.blob);
1414 arg->btime = ci->i_btime;
1425 arg->time_warp_seq = ci->i_time_warp_seq;
1431 arg->inline_data = ci->i_inline_version != CEPH_INLINE_NONE;
1433 !list_empty(&ci->i_cap_snaps)) {
1435 list_for_each_entry_reverse(capsnap, &ci->i_cap_snaps, ci_item) {
1452 static void __send_cap(struct cap_msg_args *arg, struct ceph_inode_info *ci)
1455 struct inode *inode = &ci->vfs_inode;
1462 spin_lock(&ci->i_ceph_lock);
1463 __cap_delay_requeue(arg->session->s_mdsc, ci);
1464 spin_unlock(&ci->i_ceph_lock);
1473 wake_up_all(&ci->i_cap_wq);
1539 static void __ceph_flush_snaps(struct ceph_inode_info *ci,
1541 __releases(ci->i_ceph_lock)
1542 __acquires(ci->i_ceph_lock)
1544 struct inode *inode = &ci->vfs_inode;
1552 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
1575 if (list_empty(&ci->i_flushing_item)) {
1576 list_add_tail(&ci->i_flushing_item,
1582 &ci->i_cap_flush_list);
1589 ci->i_ceph_flags &= ~CEPH_I_FLUSH_SNAPS;
1592 struct ceph_cap *cap = ci->i_auth_cap;
1603 list_for_each_entry(cf, &ci->i_cap_flush_list, i_list) {
1616 spin_unlock(&ci->i_ceph_lock);
1630 spin_lock(&ci->i_ceph_lock);
1634 void ceph_flush_snaps(struct ceph_inode_info *ci,
1637 struct inode *inode = &ci->vfs_inode;
1647 spin_lock(&ci->i_ceph_lock);
1648 if (!(ci->i_ceph_flags & CEPH_I_FLUSH_SNAPS)) {
1652 if (!ci->i_auth_cap) {
1657 mds = ci->i_auth_cap->session->s_mds;
1665 spin_unlock(&ci->i_ceph_lock);
1677 if (ci->i_ceph_flags & CEPH_I_KICK_FLUSH)
1678 __kick_flushing_caps(mdsc, session, ci, 0);
1680 __ceph_flush_snaps(ci, session);
1682 spin_unlock(&ci->i_ceph_lock);
1692 if (!list_empty(&ci->i_snap_flush_item))
1694 list_del_init(&ci->i_snap_flush_item);
1706 int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask,
1710 ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc;
1711 struct inode *inode = &ci->vfs_inode;
1712 int was = ci->i_dirty_caps;
1715 lockdep_assert_held(&ci->i_ceph_lock);
1717 if (!ci->i_auth_cap) {
1724 dout("__mark_dirty_caps %p %s dirty %s -> %s\n", &ci->vfs_inode,
1727 ci->i_dirty_caps |= mask;
1729 struct ceph_mds_session *session = ci->i_auth_cap->session;
1731 WARN_ON_ONCE(ci->i_prealloc_cap_flush);
1732 swap(ci->i_prealloc_cap_flush, *pcf);
1734 if (!ci->i_head_snapc) {
1736 ci->i_head_snapc = ceph_get_snap_context(
1737 ci->i_snap_realm->cached_context);
1740 &ci->vfs_inode, ci->i_head_snapc, ci->i_auth_cap);
1741 BUG_ON(!list_empty(&ci->i_dirty_item));
1743 list_add(&ci->i_dirty_item, &session->s_cap_dirty);
1745 if (ci->i_flushing_caps == 0) {
1750 WARN_ON_ONCE(!ci->i_prealloc_cap_flush);
1752 BUG_ON(list_empty(&ci->i_dirty_item));
1753 if (((was | ci->i_flushing_caps) & CEPH_CAP_FILE_BUFFER) &&
1756 __cap_delay_requeue(mdsc, ci);
1808 static bool __detach_cap_flush_from_ci(struct ceph_inode_info *ci,
1814 if (wake && cf->i_list.prev != &ci->i_cap_flush_list) {
1834 struct ceph_inode_info *ci = ceph_inode(inode);
1838 lockdep_assert_held(&ci->i_ceph_lock);
1839 BUG_ON(ci->i_dirty_caps == 0);
1840 BUG_ON(list_empty(&ci->i_dirty_item));
1841 BUG_ON(!ci->i_prealloc_cap_flush);
1843 flushing = ci->i_dirty_caps;
1846 ceph_cap_string(ci->i_flushing_caps),
1847 ceph_cap_string(ci->i_flushing_caps | flushing));
1848 ci->i_flushing_caps |= flushing;
1849 ci->i_dirty_caps = 0;
1852 swap(cf, ci->i_prealloc_cap_flush);
1857 list_del_init(&ci->i_dirty_item);
1863 if (list_empty(&ci->i_flushing_item)) {
1864 list_add_tail(&ci->i_flushing_item, &session->s_cap_flushing);
1869 list_add_tail(&cf->i_list, &ci->i_cap_flush_list);
1878 __releases(ci->i_ceph_lock)
1879 __acquires(ci->i_ceph_lock)
1881 struct ceph_inode_info *ci = ceph_inode(inode);
1882 u32 invalidating_gen = ci->i_rdcache_gen;
1884 spin_unlock(&ci->i_ceph_lock);
1887 spin_lock(&ci->i_ceph_lock);
1890 invalidating_gen == ci->i_rdcache_gen) {
1894 ci->i_rdcache_revoking = ci->i_rdcache_gen - 1;
1901 bool __ceph_should_report_size(struct ceph_inode_info *ci)
1903 loff_t size = ci->vfs_inode.i_size;
1905 if (ci->i_flushing_caps & CEPH_CAP_FILE_WR)
1907 if (size >= ci->i_max_size)
1910 if (ci->i_max_size > ci->i_reported_size &&
1911 (size << 1) >= ci->i_max_size + ci->i_reported_size)
1925 void ceph_check_caps(struct ceph_inode_info *ci, int flags,
1928 struct inode *inode = &ci->vfs_inode;
1941 spin_lock(&ci->i_ceph_lock);
1942 if (ci->i_ceph_flags & CEPH_I_FLUSH)
1947 spin_lock(&ci->i_ceph_lock);
1950 file_wanted = __ceph_caps_file_wanted(ci);
1953 used = __ceph_caps_used(ci);
1961 issued = __ceph_caps_issued(ci, &implemented);
1973 __ceph_dir_is_complete(ci)) {
1994 if (ci->i_max_size == 0)
2002 ceph_cap_string(used), ceph_cap_string(ci->i_dirty_caps),
2003 ceph_cap_string(ci->i_flushing_caps),
2016 !(ci->i_wb_ref || ci->i_wrbuffer_ref) && /* no dirty pages... */
2025 ci->i_rdcache_revoking = ci->i_rdcache_gen;
2031 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
2039 ((flags & CHECK_CAPS_AUTHONLY) && cap != ci->i_auth_cap))
2049 if (ci->i_auth_cap && cap != ci->i_auth_cap)
2050 cap_used &= ~ci->i_auth_cap->issued;
2059 if (cap == ci->i_auth_cap &&
2062 if (ci->i_wanted_max_size > ci->i_max_size &&
2063 ci->i_wanted_max_size > ci->i_requested_max_size) {
2069 if (__ceph_should_report_size(ci)) {
2075 if (cap == ci->i_auth_cap) {
2076 if ((flags & CHECK_CAPS_FLUSH) && ci->i_dirty_caps) {
2080 if (ci->i_ceph_flags & CEPH_I_FLUSH_SNAPS) {
2117 spin_unlock(&ci->i_ceph_lock);
2140 if (cap == ci->i_auth_cap &&
2141 (ci->i_ceph_flags &
2143 if (ci->i_ceph_flags & CEPH_I_KICK_FLUSH)
2144 __kick_flushing_caps(mdsc, session, ci, 0);
2145 if (ci->i_ceph_flags & CEPH_I_FLUSH_SNAPS)
2146 __ceph_flush_snaps(ci, session);
2156 spin_unlock(&ci->i_ceph_lock);
2164 if (cap == ci->i_auth_cap && ci->i_dirty_caps) {
2165 flushing = ci->i_dirty_caps;
2183 spin_unlock(&ci->i_ceph_lock);
2185 __send_cap(&arg, ci);
2191 if (__ceph_is_any_real_caps(ci) &&
2192 list_empty(&ci->i_cap_delay_list) &&
2195 __cap_delay_requeue(mdsc, ci);
2198 spin_unlock(&ci->i_ceph_lock);
2215 struct ceph_inode_info *ci = ceph_inode(inode);
2221 spin_lock(&ci->i_ceph_lock);
2223 if (ci->i_dirty_caps && ci->i_auth_cap) {
2224 struct ceph_cap *cap = ci->i_auth_cap;
2228 spin_unlock(&ci->i_ceph_lock);
2236 spin_unlock(&ci->i_ceph_lock);
2240 if (ci->i_ceph_flags &
2242 if (ci->i_ceph_flags & CEPH_I_KICK_FLUSH)
2243 __kick_flushing_caps(mdsc, session, ci, 0);
2244 if (ci->i_ceph_flags & CEPH_I_FLUSH_SNAPS)
2245 __ceph_flush_snaps(ci, session);
2249 flushing = ci->i_dirty_caps;
2254 __ceph_caps_used(ci), __ceph_caps_wanted(ci),
2257 spin_unlock(&ci->i_ceph_lock);
2259 __send_cap(&arg, ci);
2261 if (!list_empty(&ci->i_cap_flush_list)) {
2263 list_last_entry(&ci->i_cap_flush_list,
2268 flushing = ci->i_flushing_caps;
2269 spin_unlock(&ci->i_ceph_lock);
2284 struct ceph_inode_info *ci = ceph_inode(inode);
2287 spin_lock(&ci->i_ceph_lock);
2288 if (!list_empty(&ci->i_cap_flush_list)) {
2290 list_first_entry(&ci->i_cap_flush_list,
2295 spin_unlock(&ci->i_ceph_lock);
2305 struct ceph_inode_info *ci = ceph_inode(inode);
2309 spin_lock(&ci->i_unsafe_lock);
2310 if (S_ISDIR(inode->i_mode) && !list_empty(&ci->i_unsafe_dirops)) {
2311 req1 = list_last_entry(&ci->i_unsafe_dirops,
2316 if (!list_empty(&ci->i_unsafe_iops)) {
2317 req2 = list_last_entry(&ci->i_unsafe_iops,
2322 spin_unlock(&ci->i_unsafe_lock);
2346 spin_lock(&ci->i_unsafe_lock);
2348 list_for_each_entry(req, &ci->i_unsafe_dirops,
2360 list_for_each_entry(req, &ci->i_unsafe_iops,
2371 spin_unlock(&ci->i_unsafe_lock);
2374 spin_lock(&ci->i_ceph_lock);
2375 if (ci->i_auth_cap) {
2376 s = ci->i_auth_cap->session;
2380 spin_unlock(&ci->i_ceph_lock);
2420 struct ceph_inode_info *ci = ceph_inode(inode);
2446 err = wait_event_interruptible(ci->i_cap_wq,
2469 struct ceph_inode_info *ci = ceph_inode(inode);
2479 err = wait_event_interruptible(ci->i_cap_wq,
2485 spin_lock(&ci->i_ceph_lock);
2486 if (__ceph_caps_dirty(ci))
2487 __cap_delay_requeue_front(mdsc, ci);
2488 spin_unlock(&ci->i_ceph_lock);
2495 struct ceph_inode_info *ci,
2497 __releases(ci->i_ceph_lock)
2498 __acquires(ci->i_ceph_lock)
2500 struct inode *inode = &ci->vfs_inode;
2507 ci->i_ceph_flags &= ~CEPH_I_KICK_FLUSH;
2509 list_for_each_entry_reverse(cf, &ci->i_cap_flush_list, i_list) {
2516 list_for_each_entry(cf, &ci->i_cap_flush_list, i_list) {
2520 cap = ci->i_auth_cap;
2537 __ceph_caps_used(ci),
2538 __ceph_caps_wanted(ci),
2541 spin_unlock(&ci->i_ceph_lock);
2542 __send_cap(&arg, ci);
2552 spin_unlock(&ci->i_ceph_lock);
2567 spin_lock(&ci->i_ceph_lock);
2574 struct ceph_inode_info *ci;
2584 list_for_each_entry(ci, &session->s_cap_flushing, i_flushing_item) {
2585 spin_lock(&ci->i_ceph_lock);
2586 cap = ci->i_auth_cap;
2589 &ci->vfs_inode, cap, session->s_mds);
2590 spin_unlock(&ci->i_ceph_lock);
2601 if ((cap->issued & ci->i_flushing_caps) !=
2602 ci->i_flushing_caps) {
2609 __kick_flushing_caps(mdsc, session, ci,
2612 ci->i_ceph_flags |= CEPH_I_KICK_FLUSH;
2615 spin_unlock(&ci->i_ceph_lock);
2622 struct ceph_inode_info *ci;
2634 list_for_each_entry(ci, &session->s_cap_flushing, i_flushing_item) {
2635 spin_lock(&ci->i_ceph_lock);
2636 cap = ci->i_auth_cap;
2639 &ci->vfs_inode, cap, session->s_mds);
2640 spin_unlock(&ci->i_ceph_lock);
2643 if (ci->i_ceph_flags & CEPH_I_KICK_FLUSH) {
2644 __kick_flushing_caps(mdsc, session, ci,
2647 spin_unlock(&ci->i_ceph_lock);
2652 struct ceph_inode_info *ci)
2655 struct ceph_cap *cap = ci->i_auth_cap;
2657 lockdep_assert_held(&ci->i_ceph_lock);
2659 dout("%s %p flushing %s\n", __func__, &ci->vfs_inode,
2660 ceph_cap_string(ci->i_flushing_caps));
2662 if (!list_empty(&ci->i_cap_flush_list)) {
2665 list_move_tail(&ci->i_flushing_item,
2670 __kick_flushing_caps(mdsc, session, ci, oldest_flush_tid);
2679 void ceph_take_cap_refs(struct ceph_inode_info *ci, int got,
2682 lockdep_assert_held(&ci->i_ceph_lock);
2685 ci->i_pin_ref++;
2687 ci->i_rd_ref++;
2689 ci->i_rdcache_ref++;
2691 ci->i_fx_ref++;
2693 if (ci->i_wr_ref == 0 && !ci->i_head_snapc) {
2695 ci->i_head_snapc = ceph_get_snap_context(
2696 ci->i_snap_realm->cached_context);
2698 ci->i_wr_ref++;
2701 if (ci->i_wb_ref == 0)
2702 ihold(&ci->vfs_inode);
2703 ci->i_wb_ref++;
2705 &ci->vfs_inode, ci->i_wb_ref-1, ci->i_wb_ref);
2731 struct ceph_inode_info *ci = ceph_inode(inode);
2741 spin_lock(&ci->i_ceph_lock);
2744 (ci->i_ceph_flags & CEPH_I_ERROR_FILELOCK)) {
2751 while (ci->i_truncate_pending) {
2752 spin_unlock(&ci->i_ceph_lock);
2758 spin_lock(&ci->i_ceph_lock);
2761 have = __ceph_caps_issued(ci, &implemented);
2764 if (endoff >= 0 && endoff > (loff_t)ci->i_max_size) {
2766 inode, endoff, ci->i_max_size);
2767 if (endoff > ci->i_requested_max_size)
2768 ret = ci->i_auth_cap ? -EFBIG : -ESTALE;
2775 if (__ceph_have_pending_cap_snap(ci)) {
2795 !ci->i_head_snapc &&
2807 spin_unlock(&ci->i_ceph_lock);
2821 ceph_disable_fscache_readpage(ci);
2822 ceph_take_cap_refs(ci, *got, true);
2828 if (ci->i_auth_cap &&
2830 struct ceph_mds_session *s = ci->i_auth_cap->session;
2837 inode, ceph_cap_string(need), ci->i_auth_cap->mds);
2847 mds_wanted = __ceph_caps_mds_wanted(ci, false);
2861 __ceph_touch_fmode(ci, mdsc, flags);
2863 spin_unlock(&ci->i_ceph_lock);
2884 struct ceph_inode_info *ci = ceph_inode(inode);
2888 spin_lock(&ci->i_ceph_lock);
2889 if (endoff >= ci->i_max_size && endoff > ci->i_wanted_max_size) {
2892 ci->i_wanted_max_size = endoff;
2895 if (ci->i_auth_cap &&
2896 (ci->i_auth_cap->issued & CEPH_CAP_FILE_WR) &&
2897 ci->i_wanted_max_size > ci->i_max_size &&
2898 ci->i_wanted_max_size > ci->i_requested_max_size)
2900 spin_unlock(&ci->i_ceph_lock);
2902 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL);
2951 struct ceph_inode_info *ci = ceph_inode(inode);
2988 ceph_get_fmode(ci, flags, FMODE_WAIT_BIAS);
2989 add_wait_queue(&ci->i_cap_wq, &wait);
3001 remove_wait_queue(&ci->i_cap_wq, &wait);
3002 ceph_put_fmode(ci, flags, FMODE_WAIT_BIAS);
3015 ceph_put_cap_refs(ci, _got);
3038 if (S_ISREG(ci->vfs_inode.i_mode) &&
3039 ci->i_inline_version != CEPH_INLINE_NONE &&
3055 ceph_put_cap_refs(ci, _got);
3072 if (S_ISREG(ci->vfs_inode.i_mode) &&
3074 ceph_fscache_revalidate_cookie(ci);
3084 void ceph_get_cap_refs(struct ceph_inode_info *ci, int caps)
3086 spin_lock(&ci->i_ceph_lock);
3087 ceph_take_cap_refs(ci, caps, false);
3088 spin_unlock(&ci->i_ceph_lock);
3096 static int ceph_try_drop_cap_snap(struct ceph_inode_info *ci,
3105 if (!list_is_last(&capsnap->ci_item, &ci->i_cap_snaps))
3106 ci->i_ceph_flags |= CEPH_I_FLUSH_SNAPS;
3124 static void __ceph_put_cap_refs(struct ceph_inode_info *ci, int had,
3127 struct inode *inode = &ci->vfs_inode;
3130 spin_lock(&ci->i_ceph_lock);
3132 --ci->i_pin_ref;
3134 if (--ci->i_rd_ref == 0)
3137 if (--ci->i_rdcache_ref == 0)
3140 if (--ci->i_fx_ref == 0)
3143 if (--ci->i_wb_ref == 0) {
3148 inode, ci->i_wb_ref+1, ci->i_wb_ref);
3151 if (--ci->i_wr_ref == 0) {
3153 if (__ceph_have_pending_cap_snap(ci)) {
3155 list_last_entry(&ci->i_cap_snaps,
3159 if (ceph_try_drop_cap_snap(ci, capsnap))
3161 else if (__ceph_finish_cap_snap(ci, capsnap))
3165 if (ci->i_wrbuffer_ref_head == 0 &&
3166 ci->i_dirty_caps == 0 &&
3167 ci->i_flushing_caps == 0) {
3168 BUG_ON(!ci->i_head_snapc);
3169 ceph_put_snap_context(ci->i_head_snapc);
3170 ci->i_head_snapc = NULL;
3173 if (!__ceph_is_any_real_caps(ci) && ci->i_snap_realm)
3174 drop_inode_snap_realm(ci);
3176 spin_unlock(&ci->i_ceph_lock);
3183 ceph_check_caps(ci, 0, NULL);
3185 ceph_flush_snaps(ci, NULL);
3188 wake_up_all(&ci->i_cap_wq);
3193 void ceph_put_cap_refs(struct ceph_inode_info *ci, int had)
3195 __ceph_put_cap_refs(ci, had, false);
3198 void ceph_put_cap_refs_no_check_caps(struct ceph_inode_info *ci, int had)
3200 __ceph_put_cap_refs(ci, had, true);
3210 void ceph_put_wrbuffer_cap_refs(struct ceph_inode_info *ci, int nr,
3213 struct inode *inode = &ci->vfs_inode;
3221 spin_lock(&ci->i_ceph_lock);
3222 ci->i_wrbuffer_ref -= nr;
3223 if (ci->i_wrbuffer_ref == 0) {
3228 if (ci->i_head_snapc == snapc) {
3229 ci->i_wrbuffer_ref_head -= nr;
3230 if (ci->i_wrbuffer_ref_head == 0 &&
3231 ci->i_wr_ref == 0 &&
3232 ci->i_dirty_caps == 0 &&
3233 ci->i_flushing_caps == 0) {
3234 BUG_ON(!ci->i_head_snapc);
3235 ceph_put_snap_context(ci->i_head_snapc);
3236 ci->i_head_snapc = NULL;
3240 ci->i_wrbuffer_ref+nr, ci->i_wrbuffer_ref_head+nr,
3241 ci->i_wrbuffer_ref, ci->i_wrbuffer_ref_head,
3244 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
3256 WARN_ON_ONCE(ci->i_auth_cap);
3264 if (ceph_try_drop_cap_snap(ci, capsnap)) {
3267 ci->i_ceph_flags |= CEPH_I_FLUSH_SNAPS;
3275 ci->i_wrbuffer_ref+nr, capsnap->dirty_pages + nr,
3276 ci->i_wrbuffer_ref, capsnap->dirty_pages,
3282 spin_unlock(&ci->i_ceph_lock);
3285 ceph_check_caps(ci, 0, NULL);
3287 ceph_flush_snaps(ci, NULL);
3290 wake_up_all(&ci->i_cap_wq);
3357 __releases(ci->i_ceph_lock)
3360 struct ceph_inode_info *ci = ceph_inode(inode);
3389 !(ci->i_wrbuffer_ref || ci->i_wb_ref)) {
3393 if (ci->i_rdcache_revoking != ci->i_rdcache_gen) {
3395 ci->i_rdcache_revoking = ci->i_rdcache_gen;
3412 WARN_ON(cap != ci->i_auth_cap);
3422 __check_cap_issue(ci, cap, newcaps);
3431 ci->i_btime = extra_info->btime;
3450 if (version > ci->i_xattrs.version) {
3453 if (ci->i_xattrs.blob)
3454 ceph_buffer_put(ci->i_xattrs.blob);
3455 ci->i_xattrs.blob = ceph_buffer_get(xattr_buf);
3456 ci->i_xattrs.version = version;
3474 ci->i_files = extra_info->nfiles;
3475 ci->i_subdirs = extra_info->nsubdirs;
3480 s64 old_pool = ci->i_layout.pool_id;
3483 ceph_file_layout_from_legacy(&ci->i_layout, &grant->layout);
3484 old_ns = rcu_dereference_protected(ci->i_layout.pool_ns,
3485 lockdep_is_held(&ci->i_ceph_lock));
3486 rcu_assign_pointer(ci->i_layout.pool_ns, extra_info->pool_ns);
3488 if (ci->i_layout.pool_id != old_pool ||
3490 ci->i_ceph_flags &= ~CEPH_I_POOL_PERM;
3501 if (ci->i_auth_cap == cap && (newcaps & CEPH_CAP_ANY_FILE_WR)) {
3502 if (max_size != ci->i_max_size) {
3504 ci->i_max_size, max_size);
3505 ci->i_max_size = max_size;
3506 if (max_size >= ci->i_wanted_max_size) {
3507 ci->i_wanted_max_size = 0; /* reset */
3508 ci->i_requested_max_size = 0;
3515 wanted = __ceph_caps_wanted(ci);
3516 used = __ceph_caps_used(ci);
3517 dirty = __ceph_caps_dirty(ci);
3553 else if (cap == ci->i_auth_cap)
3566 if (cap == ci->i_auth_cap &&
3567 __ceph_caps_revoking_other(ci, cap, newcaps))
3581 if (cap == ci->i_auth_cap)
3588 extra_info->inline_version >= ci->i_inline_version) {
3589 ci->i_inline_version = extra_info->inline_version;
3590 if (ci->i_inline_version != CEPH_INLINE_NONE &&
3596 if (ci->i_auth_cap == cap) {
3600 if (ci->i_requested_max_size > max_size ||
3603 ci->i_requested_max_size = 0;
3607 ceph_kick_flushing_inode_caps(session, ci);
3611 spin_unlock(&ci->i_ceph_lock);
3632 wake_up_all(&ci->i_cap_wq);
3635 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY | CHECK_CAPS_NOINVAL,
3638 ceph_check_caps(ci, CHECK_CAPS_NOINVAL, session);
3651 __releases(ci->i_ceph_lock)
3653 struct ceph_inode_info *ci = ceph_inode(inode);
3664 list_for_each_entry_safe(cf, tmp_cf, &ci->i_cap_flush_list, i_list) {
3678 wake_ci |= __detach_cap_flush_from_ci(ci, cf);
3694 ceph_cap_string(cleaned), ceph_cap_string(ci->i_flushing_caps),
3695 ceph_cap_string(ci->i_flushing_caps & ~cleaned));
3700 ci->i_flushing_caps &= ~cleaned;
3707 if (ci->i_flushing_caps == 0) {
3708 if (list_empty(&ci->i_cap_flush_list)) {
3709 list_del_init(&ci->i_flushing_item);
3721 if (ci->i_dirty_caps == 0) {
3723 BUG_ON(!list_empty(&ci->i_dirty_item));
3725 if (ci->i_wr_ref == 0 &&
3726 ci->i_wrbuffer_ref_head == 0) {
3727 BUG_ON(!ci->i_head_snapc);
3728 ceph_put_snap_context(ci->i_head_snapc);
3729 ci->i_head_snapc = NULL;
3732 BUG_ON(list_empty(&ci->i_dirty_item));
3738 spin_unlock(&ci->i_ceph_lock);
3749 wake_up_all(&ci->i_cap_wq);
3759 struct ceph_inode_info *ci = ceph_inode(inode);
3763 lockdep_assert_held(&ci->i_ceph_lock);
3765 dout("removing capsnap %p, inode %p ci %p\n", capsnap, inode, ci);
3768 ret = __detach_cap_flush_from_ci(ci, &capsnap->cap_flush);
3773 if (list_empty(&ci->i_cap_flush_list))
3774 list_del_init(&ci->i_flushing_item);
3785 struct ceph_inode_info *ci = ceph_inode(inode);
3787 lockdep_assert_held(&ci->i_ceph_lock);
3803 struct ceph_inode_info *ci = ceph_inode(inode);
3811 dout("handle_cap_flushsnap_ack inode %p ci %p mds%d follows %lld\n",
3812 inode, ci, session->s_mds, follows);
3814 spin_lock(&ci->i_ceph_lock);
3815 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
3832 spin_unlock(&ci->i_ceph_lock);
3838 wake_up_all(&ci->i_cap_wq);
3854 struct ceph_inode_info *ci = ceph_inode(inode);
3861 int dirty = __ceph_caps_dirty(ci);
3865 lockdep_assert_held(&ci->i_ceph_lock);
3891 struct ceph_inode_info *ci = ceph_inode(inode);
3908 dout("handle_cap_export inode %p ci %p mds%d mseq %d target %d\n",
3909 inode, ci, mds, mseq, target);
3911 spin_lock(&ci->i_ceph_lock);
3912 cap = __get_cap_for_mds(ci, mds);
3936 tcap = __get_cap_for_mds(ci, target);
3947 if (cap == ci->i_auth_cap) {
3948 ci->i_auth_cap = tcap;
3949 change_auth_cap_ses(ci, tcap->session);
3956 int flag = (cap == ci->i_auth_cap) ? CEPH_CAP_FLAG_AUTH : 0;
3961 if (!list_empty(&ci->i_cap_flush_list) &&
3962 ci->i_auth_cap == tcap) {
3964 list_move_tail(&ci->i_flushing_item,
3973 spin_unlock(&ci->i_ceph_lock);
3998 spin_unlock(&ci->i_ceph_lock);
4019 struct ceph_inode_info *ci = ceph_inode(inode);
4040 dout("handle_cap_import inode %p ci %p mds%d mseq %d peer %d\n",
4041 inode, ci, mds, mseq, peer);
4043 cap = __get_cap_for_mds(ci, mds);
4046 spin_unlock(&ci->i_ceph_lock);
4048 spin_lock(&ci->i_ceph_lock);
4059 __ceph_caps_issued(ci, &issued);
4060 issued |= __ceph_caps_dirty(ci);
4065 ocap = peer >= 0 ? __get_cap_for_mds(ci, peer) : NULL;
4098 struct ceph_inode_info *ci;
4210 ci = ceph_inode(inode);
4259 spin_lock(&ci->i_ceph_lock);
4270 spin_lock(&ci->i_ceph_lock);
4276 spin_unlock(&ci->i_ceph_lock);
4284 __ceph_caps_issued(ci, &extra_info.issued);
4285 extra_info.issued |= __ceph_caps_dirty(ci);
4297 spin_unlock(&ci->i_ceph_lock);
4303 spin_unlock(&ci->i_ceph_lock);
4335 * processed in this run. In this case, the ci->i_hold_caps_max will be
4341 struct ceph_inode_info *ci;
4350 ci = list_first_entry(&mdsc->cap_delay_list,
4353 if (time_before(loop_start, ci->i_hold_caps_max - delay_max)) {
4355 delay = ci->i_hold_caps_max;
4358 if ((ci->i_ceph_flags & CEPH_I_FLUSH) == 0 &&
4359 time_before(jiffies, ci->i_hold_caps_max))
4361 list_del_init(&ci->i_cap_delay_list);
4363 inode = igrab(&ci->vfs_inode);
4367 ceph_check_caps(ci, 0, NULL);
4384 struct ceph_inode_info *ci;
4390 ci = list_first_entry(&s->s_cap_dirty, struct ceph_inode_info,
4392 inode = &ci->vfs_inode;
4396 ceph_check_caps(ci, CHECK_CAPS_FLUSH, NULL);
4409 void __ceph_touch_fmode(struct ceph_inode_info *ci,
4414 ci->i_last_rd = now;
4416 ci->i_last_wr = now;
4419 __ceph_is_any_real_caps(ci) &&
4420 list_empty(&ci->i_cap_delay_list))
4421 __cap_delay_requeue(mdsc, ci);
4424 void ceph_get_fmode(struct ceph_inode_info *ci, int fmode, int count)
4426 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->vfs_inode.i_sb);
4434 spin_lock(&ci->i_ceph_lock);
4441 if (i && ci->i_nr_by_mode[i])
4445 ci->i_nr_by_mode[i] += count;
4450 spin_unlock(&ci->i_ceph_lock);
4458 void ceph_put_fmode(struct ceph_inode_info *ci, int fmode, int count)
4460 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->vfs_inode.i_sb);
4468 spin_lock(&ci->i_ceph_lock);
4471 BUG_ON(ci->i_nr_by_mode[i] < count);
4472 ci->i_nr_by_mode[i] -= count;
4480 if (i && ci->i_nr_by_mode[i])
4486 spin_unlock(&ci->i_ceph_lock);
4497 struct ceph_inode_info *ci = ceph_inode(inode);
4500 spin_lock(&ci->i_ceph_lock);
4502 drop |= ~(__ceph_caps_wanted(ci) | CEPH_CAP_PIN);
4504 if (__ceph_caps_dirty(ci)) {
4507 __cap_delay_requeue_front(mdsc, ci);
4510 spin_unlock(&ci->i_ceph_lock);
4525 struct ceph_inode_info *ci = ceph_inode(inode);
4531 spin_lock(&ci->i_ceph_lock);
4532 used = __ceph_caps_used(ci);
4533 dirty = __ceph_caps_dirty(ci);
4542 cap = __get_cap_for_mds(ci, mds);
4558 int wanted = __ceph_caps_wanted(ci);
4569 if (cap == ci->i_auth_cap &&
4571 ci->i_requested_max_size = 0;
4594 spin_unlock(&ci->i_ceph_lock);