capa_renew should increase the refc.

[fs/lustre-release.git] / lustre / mds / mds_capa.c

diff --git a/lustre/mds/mds_capa.c b/lustre/mds/mds_capa.c
index 23e349f..6f8d091 100644 (file)
--- a/lustre/mds/mds_capa.c
+++ b/lustre/mds/mds_capa.c
@@ -184,8 +184,10 @@ int mds_read_capa_key(struct obd_device *obd, struct file *file)
         expiry = CUR_CAPA_KEY_JIFFIES(mds);
         spin_lock(&mds_capa_lock);
         if (time_before(expiry, mds_eck_timer.expires) ||
-            !timer_pending(&mds_eck_timer))
+            !timer_pending(&mds_eck_timer)) {
                 mod_timer(&mds_eck_timer, expiry);
+                CDEBUG(D_INFO, "mds_eck_timer %lu", expiry);
+        }
         list_add_capa_key(&CUR_MDS_CAPA_KEY(mds), &mds_capa_key_list);
         spin_unlock(&mds_capa_lock);
 out:
@@ -256,8 +258,6 @@ mds_update_capa_key(struct obd_device *obd, struct mds_capa_key *mkey,
         if (rc2)
                 GOTO(out, rc2);
         
-        CDEBUG(D_INFO, "wrote capa keyid %u\n", keyid);
-
         spin_lock(&mds_capa_lock);
         list_del_init(&CUR_CAPA_KEY_LIST(mds));
         mds->mds_capa_key_idx = to_update;
@@ -265,8 +265,10 @@ mds_update_capa_key(struct obd_device *obd, struct mds_capa_key *mkey,
         list_add_capa_key(&CUR_MDS_CAPA_KEY(mds), &mds_capa_key_list);
 
         if (time_before(expiry, mds_eck_timer.expires) ||
-            !timer_pending(&mds_eck_timer))
+            !timer_pending(&mds_eck_timer)) {
                 mod_timer(&mds_eck_timer, expiry);
+                CDEBUG(D_INFO, "mds_eck_timer %lu\n", expiry);
+        }
         spin_unlock(&mds_capa_lock);
 
         DEBUG_MDS_CAPA_KEY(D_INFO, &CUR_MDS_CAPA_KEY(mds),
@@ -278,6 +280,7 @@ out:
 static inline int have_expired_capa_key(void)
 {
         struct mds_capa_key *key;
+        unsigned long expiry;
         int expired = 0;
         ENTRY;
 
@@ -286,8 +289,17 @@ static inline int have_expired_capa_key(void)
                 key = list_entry(mds_capa_key_list.next, struct mds_capa_key,
                                  k_list);
                 /* expiry is in sec, so in case it misses, the result will
-                 * minus HZ and then compare with jiffies. */
-                expired = time_before(CAPA_KEY_JIFFIES(key) - HZ, jiffies);
+                 * minus 5 sec and then compare with jiffies. (in case the
+                 * clock is innacurate) */
+                expiry = CAPA_KEY_JIFFIES(key);
+                expired = time_before(expiry - 5 * HZ, jiffies);
+                if (!expired) {
+                        if (time_before(expiry, mds_eck_timer.expires) ||
+                            !timer_pending(&mds_eck_timer)) {
+                                mod_timer(&mds_eck_timer, expiry);
+                                CDEBUG(D_INFO, "mds_eck_timer %lu", expiry);
+                        }
+                }
         }
         spin_unlock(&mds_capa_lock);
 
@@ -325,6 +337,7 @@ static int mds_capa_key_thread_main(void *arg)
 
         while (!mds_capa_key_check_stop()) {
                 struct l_wait_info lwi = { 0 };
+                unsigned long expiry;
                 struct mds_capa_key *key, *tmp, *next = NULL;
 
                 l_wait_event(mds_eck_thread.t_ctl_waitq,
@@ -350,8 +363,11 @@ static int mds_capa_key_thread_main(void *arg)
                         spin_lock(&mds_capa_lock);
                 }
 
-                if (next)
-                        mod_timer(&mds_eck_timer, CAPA_KEY_JIFFIES(next));
+                if (next) {
+                        expiry = CAPA_KEY_JIFFIES(next);
+                        mod_timer(&mds_eck_timer, expiry);
+                        CDEBUG(D_INFO, "mds_eck_timer %lu", expiry);
+                }
                 spin_unlock(&mds_capa_lock);
         }
 
@@ -450,8 +466,11 @@ static void mds_capa_reverse_map(struct mds_export_data *med,
 {
         uid_t uid;
 
-        if (!med->med_remote)
+        if (!med->med_remote) {
+                /* when not remote uid, ruid == uid */
+                capa->lc_ruid = capa->lc_uid;
                 return;
+        }
 
         ENTRY;
         uid = mds_idmap_lookup_uid(med->med_idmap, 1, capa->lc_uid);
@@ -494,20 +513,19 @@ int mds_pack_capa(struct obd_device *obd, struct mds_export_data *med,
 
                 mfd = mds_handle2mfd(&req_body->handle);
                 if (mfd == NULL) {
-                        CERROR("no handle for capa renewal ino "LPD64
-                               ": cookie "LPX64"\n",
-                               req_capa->lc_ino, req_body->handle.cookie);
+                        DEBUG_CAPA(D_INFO, req_capa, "no handle "LPX64" for",
+                                   req_body->handle.cookie);
                         RETURN(-ESTALE);
                 }
 
                 mode = accmode(mfd->mfd_mode);
                 if (!(req_capa->lc_op & mode)) {
-                        CERROR("invalid capa to renew ino "LPD64
-                               ": op %d mismatch with mode %d\n",
-                               req_capa->lc_ino, req_capa->lc_op,
-                               mfd->mfd_mode);
+                        DEBUG_CAPA(D_ERROR, req_capa, "accmode %d mismatch",
+                                   mode);
                         RETURN(-EACCES);
                 }
+
+                mds_mfd_put(mfd);
         }
 
         LASSERT(repmsg->buflens[*offset] == sizeof(*capa));
@@ -515,15 +533,15 @@ int mds_pack_capa(struct obd_device *obd, struct mds_export_data *med,
         LASSERT(capa != NULL);
 
         ocapa = capa_get(req_capa->lc_uid, req_capa->lc_op, req_capa->lc_mdsid,
-                         req_capa->lc_ino, MDS_CAPA, NULL, NULL, NULL);
+                         req_capa->lc_ino, req_capa->lc_igen, MDS_CAPA);
         if (ocapa) {
                 expired = capa_is_to_expire(ocapa);
                 if (!expired) {
                         capa_dup(capa, ocapa);
-                        capa_put(ocapa, MDS_CAPA);
+                        capa_put(ocapa);
                         GOTO(out, rc);
                 }
-                capa_put(ocapa, MDS_CAPA);
+                capa_put(ocapa);
         }
 
         memcpy(capa, req_capa, sizeof(*capa));
@@ -533,15 +551,19 @@ int mds_pack_capa(struct obd_device *obd, struct mds_export_data *med,
         capa->lc_keyid = le32_to_cpu(CUR_CAPA_KEY_ID(mds));
         capa->lc_expiry = round_expiry(mds->mds_capa_timeout);
         if (mds->mds_capa_timeout < CAPA_EXPIRY)
-                capa->lc_flags |= CAPA_FL_NOROUND;
+                capa->lc_flags |= CAPA_FL_SHORT;
         memcpy(key, CUR_CAPA_KEY(mds)->lk_key, sizeof(key));
         spin_unlock(&mds_capa_lock);
 
         capa_hmac(mds->mds_capa_hmac, key, capa);
 
-        rc = capa_renew(capa, MDS_CAPA);
+        ocapa = capa_renew(capa, MDS_CAPA);
+        if (!ocapa)
+                rc = -ENOMEM;
+        capa_put(ocapa);
 out:
         if (rc == 0)
                 body->valid |= OBD_MD_CAPA;
         RETURN(rc);
 }
+