kclient: drop cap lru

diff --git a/src/TODO b/src/TODO
index 4c6f6ffe05ff627694386094909d58c0bf04eb33..3c9cf3aa71929e7efa95618550222d6144bfad29 100644 (file)
--- a/src/TODO
+++ b/src/TODO
@@ -44,9 +44,8 @@ v0.8
 kclient caps
 /- two session lists: dirty_caps, clean_caps
 /- time out and release clean caps explicitly
-  - this makes open on client work better, since we care less about the mds 'wanted' value.
-    (we only need to update it if/when we release the caps we still want, or async on open
-     if we don't have them yet)
+
+- pin dirty caps only
 
 alternative #1:
 - keep CAP_PIN on _all_ inodes, and don't pin inodes with caps.
@@ -64,13 +63,12 @@ alternative #1:
 
 alternative #2:
 /- make clean_caps an lru
-- make open do an async wanted update
+/- make open do an async wanted update (if we want something that isn't mds_wanted or issued)
 - efficient cap release
 - touch caps on revalidate, getattr, etc.
   - that should avoid releasing caps just prior to getattr
 - maybe still pin cap inodes for now.
   - eventually avoid it, using the release on destroy_inode strategy above
-- periodic trimmer to efficiently release the oldest clean_caps in big batches
 
 
 

diff --git a/src/kernel/caps.c b/src/kernel/caps.c
index d05651d4fad2fb4f7eaa39e1976607a78e0aa6d2..f13561f4db2775c92ac79d65c6221837801838b5 100644 (file)
--- a/src/kernel/caps.c
+++ b/src/kernel/caps.c
@@ -166,57 +166,6 @@ static void __insert_cap_node(struct ceph_inode_info *ci,
        rb_insert_color(&new->ci_node, &ci->i_caps);
 }
 
-/*
- * Touch cap timestamp and, if clean, move to end of lru.
- */
-void __touch_cap(struct ceph_cap *cap)
-{
-       cap->last_used = jiffies;
-       if (!list_empty(&cap->session_clean_caps)) {
-               spin_lock(&cap->session->s_clean_caps_lock);
-               list_del_init(&cap->session_clean_caps);
-               list_add(&cap->session_clean_caps, &cap->session->s_clean_caps);
-               spin_unlock(&cap->session->s_clean_caps_lock);
-       }
-}
-
-/*
- * Remove or place the given cap on the session clean_caps list A cap
- * belongs on the clean caps list IFF wanted == 0 AND dirty == 0.
- *
- * Also touch the cap last_used (i.e., either call __touch_cap or
- * __adjust_cap_listing, but not both).
- *
- * Ignore auth/non-auth status for now.
- */
-static void __adjust_cap_listing(struct ceph_inode_info *ci,
-                                struct ceph_cap *cap,
-                                int wanted)
-{
-       struct ceph_mds_session *session = cap->session;
-       int dirty = cap->flushing | ci->i_dirty_caps;
-       
-       spin_lock(&session->s_clean_caps_lock);
-       if (wanted == 0 && dirty == 0) {
-               /* move to tail of clean_caps lru */
-               if (!list_empty(&cap->session_clean_caps))
-                       list_del_init(&cap->session_clean_caps);
-               else
-                       dout(20, "adjust_cap_listing %p %p clean\n",
-                            &ci->vfs_inode, cap);
-               list_add_tail(&cap->session_clean_caps, &session->s_clean_caps);
-               cap->last_used = jiffies;
-       } else {
-               /* remove from clean_caps */
-               if (!list_empty(&cap->session_clean_caps)) {
-                       dout(20, "adjust_cap_listing %p %p dirty (%s)\n",
-                            &ci->vfs_inode, cap, ceph_cap_string(dirty));
-                       list_del_init(&cap->session_clean_caps);
-               }
-       }
-       spin_unlock(&session->s_clean_caps_lock);
-}
-
 /*
  * (Re)queue cap at the end of the delayed cap release list.
  *
@@ -280,7 +229,6 @@ int ceph_add_cap(struct inode *inode,
        struct ceph_cap *cap;
        int mds = session->s_mds;
        int is_first = 0;
-       int all_wanted;
 
        dout(10, "add_cap %p mds%d cap %llx %s seq %d\n", inode,
             session->s_mds, cap_id, ceph_cap_string(issued), seq);
@@ -328,7 +276,6 @@ retry:
                cap->session = session;
                list_add(&cap->session_caps, &session->s_caps);
                session->s_nr_caps++;
-               INIT_LIST_HEAD(&cap->session_clean_caps);
        }
 
        if (!ci->i_snap_realm) {
@@ -362,10 +309,6 @@ retry:
        else if (ci->i_auth_cap == cap)
                ci->i_auth_cap = NULL;
 
-       /* Put cap on proper session list */
-       all_wanted = wanted | __ceph_caps_wanted(ci);
-       __adjust_cap_listing(ci, cap, all_wanted);
-
        dout(10, "add_cap inode %p (%llx.%llx) cap %p %s now %s seq %d mds%d\n",
             inode, ceph_vinop(inode), cap, ceph_cap_string(issued),
             ceph_cap_string(issued|cap->issued), seq, mds);
@@ -433,8 +376,6 @@ int __ceph_caps_issued(struct ceph_inode_info *ci, int *implemented)
                have |= cap->issued;
                if (implemented)
                        *implemented |= cap->implemented;
-
-               __touch_cap(cap);
        }
        return have;
 }
@@ -528,8 +469,6 @@ static int __ceph_remove_cap(struct ceph_cap *cap)
 
        /* remove from session list */
        list_del_init(&cap->session_caps);
-       if (!list_empty(&cap->session_clean_caps))
-               list_del_init(&cap->session_clean_caps);
        session->s_nr_caps--;
 
        /* remove from inode list */
@@ -877,7 +816,7 @@ retry_locked:
                 * So: always try to retain EXPIREABLE.  If caps are
                 * wanted, retain even more.
                 */
-               retain |= CEPH_CAP_EXPIREABLE;
+               retain |= CEPH_CAP_PIN | CEPH_CAP_EXPIREABLE;
                if (want)
                        retain |= CEPH_CAP_ANY_EXCL;
        }
@@ -1470,8 +1409,6 @@ start:
                wake = 1;
        }
 
-       __adjust_cap_listing(ci, cap, wanted);
-
        spin_unlock(&inode->i_lock);
        if (writeback) {
                /*
@@ -1524,8 +1461,6 @@ static void handle_cap_flush_ack(struct inode *inode,
                if (removed_last)
                        __cap_delay_cancel(&ceph_inode_to_client(inode)->mdsc,
                                           ci);
-       } else {
-               __adjust_cap_listing(ci, cap, __ceph_caps_wanted(ci));
        }
        spin_unlock(&inode->i_lock);
        if (removed_last)
@@ -1879,40 +1814,6 @@ void ceph_check_delayed_caps(struct ceph_mds_client *mdsc)
        spin_unlock(&mdsc->cap_delay_lock);
 }
 
-/*
- * Caller must hold session s_mutex.
- */
-void ceph_trim_session_clean_caps(struct ceph_mds_session *session)
-{
-       struct inode *inode;
-       struct ceph_cap *cap;
-       struct list_head *p, *n;
-       unsigned long cutoff = jiffies - HZ * 30;  /* fixme */
-
-       dout(10, "trim_clean_caps for mds%d\n", session->s_mds);
-       spin_lock(&session->s_clean_caps_lock);
-       list_for_each_safe(p, n, &session->s_clean_caps) {
-               cap = list_entry(p, struct ceph_cap, session_clean_caps);
-               inode = &cap->ci->vfs_inode;
-               igrab(inode);
-               spin_unlock(&session->s_clean_caps_lock);
-
-               spin_lock(&inode->i_lock);
-               if (time_before(cutoff, cap->last_used)) {
-                       dout(20, " stopping at %p cap %p last_used %lu > %lu\n",
-                            inode, cap, cap->last_used, cutoff);
-                       spin_unlock(&inode->i_lock);
-                       iput(inode);
-                       return;
-               }
-               spin_unlock(&inode->i_lock);
-               ceph_check_caps(cap->ci, 1, CEPH_CAP_ANY, session);
-               iput(inode);
-               spin_lock(&session->s_clean_caps_lock);
-       }
-       spin_unlock(&session->s_clean_caps_lock);
-}
-
 /*
  * Drop open file reference.  If we were the last open file,
  * we may need to release capabilities to the MDS (or schedule
@@ -1927,20 +1828,8 @@ void ceph_put_fmode(struct ceph_inode_info *ci, int fmode)
        dout(20, "put_fmode %p fmode %d %d -> %d\n", inode, fmode,
             ci->i_nr_by_mode[fmode], ci->i_nr_by_mode[fmode]-1);
        BUG_ON(ci->i_nr_by_mode[fmode] == 0);
-       if (--ci->i_nr_by_mode[fmode] == 0) {
+       if (--ci->i_nr_by_mode[fmode] == 0)
                last++;
-
-               /* maybe turn caps into rdcaps? */
-               if (__ceph_caps_wanted(ci) == 0) {
-                       struct rb_node *p;
-                       struct ceph_cap *cap;
-
-                       for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
-                               cap = rb_entry(p, struct ceph_cap, ci_node);
-                               __adjust_cap_listing(ci, cap, 0);
-                       }
-               }
-       }
        spin_unlock(&inode->i_lock);
 
        if (last && ci->i_vino.snap == CEPH_NOSNAP)

diff --git a/src/kernel/mds_client.c b/src/kernel/mds_client.c
index 7e606bd618c1941a2874c5dc08fda88eae05646a..03142adc6b09fac8b95aee7a89dd6e4ebf2d4566 100644 (file)
--- a/src/kernel/mds_client.c
+++ b/src/kernel/mds_client.c
@@ -295,8 +295,6 @@ static struct ceph_mds_session *register_session(struct ceph_mds_client *mdsc,
        s->s_cap_ttl = 0;
        s->s_renew_requested = 0;
        INIT_LIST_HEAD(&s->s_caps);
-       INIT_LIST_HEAD(&s->s_clean_caps);
-       spin_lock_init(&s->s_clean_caps_lock);
        s->s_nr_caps = 0;
        atomic_set(&s->s_ref, 1);
        INIT_LIST_HEAD(&s->s_waiting);
@@ -2115,7 +2113,6 @@ static void delayed_work(struct work_struct *work)
                mutex_lock(&s->s_mutex);
                if (renew_caps)
                        send_renew_caps(mdsc, s);
-               ceph_trim_session_clean_caps(s);
                mutex_unlock(&s->s_mutex);
                ceph_put_mds_session(s);
 

diff --git a/src/kernel/mds_client.h b/src/kernel/mds_client.h
index 09886f05ee5dc0ea5be84c1e970604a2d5608242..3f2a2a78db189efcba27d23356f2898ccd566bc0 100644 (file)
--- a/src/kernel/mds_client.h
+++ b/src/kernel/mds_client.h
@@ -116,8 +116,6 @@ struct ceph_mds_session {
        unsigned long     s_cap_ttl;  /* when session caps expire */
        unsigned long     s_renew_requested; /* last time we sent a renew req */
        struct list_head  s_caps;     /* all caps issued by this session */
-       struct list_head  s_clean_caps;       /* just the clean caps */
-       spinlock_t        s_clean_caps_lock;  /* protect s_clean_caps_lock */
        int               s_nr_caps;
        atomic_t          s_ref;
        struct list_head  s_waiting;  /* waiting requests */

diff --git a/src/kernel/super.h b/src/kernel/super.h
index 59fcd1dacdd043b4fade8d69f940cc765cbdcf76..f9499306b34004929741db8e6f44117b49793b18 100644 (file)
--- a/src/kernel/super.h
+++ b/src/kernel/super.h
@@ -146,7 +146,6 @@ struct ceph_cap {
        struct rb_node ci_node;         /* per-ci cap tree */
        struct ceph_mds_session *session;
        struct list_head session_caps;   /* per-session caplist */
-       struct list_head session_clean_caps; /* per-session clean caps */
        int mds;
        u64 cap_id;       /* unique cap id (mds provided) */
        int issued;       /* latest, from the mds */
@@ -751,8 +750,6 @@ extern void ceph_check_caps(struct ceph_inode_info *ci, int delayed, int drop,
                            struct ceph_mds_session *session);
 extern void ceph_check_delayed_caps(struct ceph_mds_client *mdsc);
 
-void ceph_trim_session_clean_caps(struct ceph_mds_session *session);
-
 static inline void ceph_release_caps(struct inode *inode, int mask)
 {
        ceph_check_caps(ceph_inode(inode), 1, mask, NULL);