LU-7232 statahead: lock leaks if statahead file recreated

[fs/lustre-release.git] / lustre / llite / lcommon_misc.c

diff --git a/lustre/llite/lcommon_misc.c b/lustre/llite/lcommon_misc.c
index fa76dd0..6bd4d3e 100644 (file)
--- a/lustre/llite/lcommon_misc.c
+++ b/lustre/llite/lcommon_misc.c
@@ -27,7 +27,7 @@
  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2012, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -41,47 +41,39 @@
 #include <obd_support.h>
 #include <obd.h>
 #include <cl_object.h>
-#include <lclient.h>
 
 #include "llite_internal.h"
 
-
 /* Initialize the default and maximum LOV EA and cookie sizes.  This allows
  * us to make MDS RPCs with large enough reply buffers to hold the
  * maximum-sized (= maximum striped) EA and cookie without having to
  * calculate this (via a call into the LOV + OSCs) each time we make an RPC. */
-int cl_init_ea_size(struct obd_export *md_exp, struct obd_export *dt_exp)
+static int cl_init_ea_size(struct obd_export *md_exp, struct obd_export *dt_exp)
 {
-       struct lov_stripe_md lsm = { .lsm_magic = LOV_MAGIC_V3 };
-       __u32 valsize = sizeof(struct lov_desc);
-       int rc, easize, def_easize, cookiesize;
-       struct lov_desc desc;
-       __u16 stripes, def_stripes;
+       u32 val_size;
+       u32 max_easize;
+       u32 def_easize;
+       int rc;
        ENTRY;
 
-        rc = obd_get_info(NULL, dt_exp, sizeof(KEY_LOVDESC), KEY_LOVDESC,
-                          &valsize, &desc, NULL);
-        if (rc)
-                RETURN(rc);
-
-        stripes = min(desc.ld_tgt_count, (__u32)LOV_MAX_STRIPE_COUNT);
-        lsm.lsm_stripe_count = stripes;
-        easize = obd_size_diskmd(dt_exp, &lsm);
+       val_size = sizeof(max_easize);
+       rc = obd_get_info(NULL, dt_exp, sizeof(KEY_MAX_EASIZE), KEY_MAX_EASIZE,
+                         &val_size, &max_easize);
+       if (rc != 0)
+               RETURN(rc);
 
-       def_stripes = min_t(__u32, desc.ld_default_stripe_count,
-                           LOV_MAX_STRIPE_COUNT);
-       lsm.lsm_stripe_count = def_stripes;
-       def_easize = obd_size_diskmd(dt_exp, &lsm);
-
-       cookiesize = stripes * sizeof(struct llog_cookie);
+       val_size = sizeof(def_easize);
+       rc = obd_get_info(NULL, dt_exp, sizeof(KEY_DEFAULT_EASIZE),
+                         KEY_DEFAULT_EASIZE, &val_size, &def_easize);
+       if (rc != 0)
+               RETURN(rc);
 
        /* default cookiesize is 0 because from 2.4 server doesn't send
         * llog cookies to client. */
-       CDEBUG(D_HA,
-              "updating def/max_easize: %d/%d def/max_cookiesize: 0/%d\n",
-              def_easize, easize, cookiesize);
+       CDEBUG(D_HA, "updating def/max_easize: %d/%d\n",
+              def_easize, max_easize);
 
-       rc = md_init_ea_size(md_exp, easize, def_easize, cookiesize, 0);
+       rc = md_init_ea_size(md_exp, max_easize, def_easize);
        RETURN(rc);
 }
 
@@ -127,7 +119,7 @@ int cl_ocd_update(struct obd_device *host,
 #define GROUPLOCK_SCOPE "grouplock"
 
 int cl_get_grouplock(struct cl_object *obj, unsigned long gid, int nonblock,
-                     struct ccc_grouplock *cg)
+                    struct ll_grouplock *lg)
 {
         struct lu_env          *env;
         struct cl_io           *io;
@@ -141,21 +133,22 @@ int cl_get_grouplock(struct cl_object *obj, unsigned long gid, int nonblock,
         if (IS_ERR(env))
                 return PTR_ERR(env);
 
-        io = ccc_env_thread_io(env);
+       io = vvp_env_thread_io(env);
         io->ci_obj = obj;
        io->ci_ignore_layout = 1;
 
        rc = cl_io_init(env, io, CIT_MISC, io->ci_obj);
-       if (rc) {
+       if (rc != 0) {
                cl_io_fini(env, io);
                cl_env_put(env, &refcheck);
                /* Does not make sense to take GL for released layout */
                if (rc > 0)
                        rc = -ENOTSUPP;
                return rc;
-        }
+       }
 
-        descr = &ccc_env_info(env)->cti_descr;
+       lock = vvp_env_lock(env);
+       descr = &lock->cll_descr;
         descr->cld_obj = obj;
         descr->cld_start = 0;
         descr->cld_end = CL_PAGE_EOF;
@@ -165,39 +158,37 @@ int cl_get_grouplock(struct cl_object *obj, unsigned long gid, int nonblock,
        enqflags = CEF_MUST | (nonblock ? CEF_NONBLOCK : 0);
        descr->cld_enq_flags = enqflags;
 
-       lock = cl_lock_request(env, io, descr, GROUPLOCK_SCOPE, current);
-       if (IS_ERR(lock)) {
+       rc = cl_lock_request(env, io, lock);
+       if (rc < 0) {
                cl_io_fini(env, io);
                cl_env_put(env, &refcheck);
-               return PTR_ERR(lock);
+               return rc;
        }
 
-        cg->cg_env  = cl_env_get(&refcheck);
-        cg->cg_io   = io;
-        cg->cg_lock = lock;
-        cg->cg_gid  = gid;
-        LASSERT(cg->cg_env == env);
+       lg->lg_env = cl_env_get(&refcheck);
+       lg->lg_io = io;
+       lg->lg_lock = lock;
+       lg->lg_gid = gid;
+       LASSERT(lg->lg_env == env);
 
-        cl_env_unplant(env, &refcheck);
-        return 0;
+       cl_env_unplant(env, &refcheck);
+       return 0;
 }
 
-void cl_put_grouplock(struct ccc_grouplock *cg)
+void cl_put_grouplock(struct ll_grouplock *lg)
 {
-       struct lu_env  *env  = cg->cg_env;
-       struct cl_io   *io   = cg->cg_io;
-       struct cl_lock *lock = cg->cg_lock;
+       struct lu_env  *env  = lg->lg_env;
+       struct cl_io   *io   = lg->lg_io;
+       struct cl_lock *lock = lg->lg_lock;
        int             refcheck;
 
-       LASSERT(cg->cg_env);
-       LASSERT(cg->cg_gid);
+       LASSERT(lg->lg_env != NULL);
+       LASSERT(lg->lg_gid != 0);
 
        cl_env_implant(env, &refcheck);
        cl_env_put(env, &refcheck);
 
-       cl_unuse(env, lock);
-       cl_lock_release(env, lock, GROUPLOCK_SCOPE, current);
+       cl_lock_release(env, lock);
        cl_io_fini(env, io);
        cl_env_put(env, NULL);
 }
-