LU-1302 llog: llog test update and fixes

- port llog_test fixed from Orion
- remove unneeded include files
- remove llog init/fini from lmv, it is not used
- add new test_7 for llog_test
- add unlink64 handling

Signed-off-by: Mikhail Pershin <tappro@whamcloud.com>
Change-Id: I4793bb02748f2aaab33d67d0f04c8767e7f5ffb9
Reviewed-on: http://review.whamcloud.com/3825
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Tested-by: Hudson
Reviewed-by: Yu Jian <yujian@whamcloud.com>
Tested-by: Maloo <whamcloud.maloo@gmail.com>

diff --git a/lustre/include/lustre/lustre_idl.h b/lustre/include/lustre/lustre_idl.h
index 02a4e23..d051631 100644 (file)
--- a/lustre/include/lustre/lustre_idl.h
+++ b/lustre/include/lustre/lustre_idl.h
@@ -2633,74 +2633,57 @@ struct llog_rec_hdr {
 };
 
 struct llog_rec_tail {
 };
 
 struct llog_rec_tail {

-        __u32 lrt_len;
-        __u32 lrt_index;
+       __u32   lrt_len;
+       __u32   lrt_index;

 };
 
 struct llog_logid_rec {
 };
 
 struct llog_logid_rec {

-        struct llog_rec_hdr     lid_hdr;
-        struct llog_logid       lid_id;
-        __u32                   lid_padding1;
-        __u32                   lid_padding2;
-        __u32                   lid_padding3;
-        __u32                   lid_padding4;
-        __u32                   lid_padding5;
-        struct llog_rec_tail    lid_tail;
-} __attribute__((packed));
-
-struct llog_create_rec {
-        struct llog_rec_hdr     lcr_hdr;
-        struct ll_fid           lcr_fid;
-        obd_id                  lcr_oid;
-        obd_count               lcr_oseq;
-        __u32                   lcr_padding;
-        struct llog_rec_tail    lcr_tail;
-} __attribute__((packed));
-
-struct llog_orphan_rec {
-        struct llog_rec_hdr     lor_hdr;
-        obd_id                  lor_oid;
-        obd_count               lor_ogen;
-        __u32                   lor_padding;
-        struct llog_rec_tail    lor_tail;
+       struct llog_rec_hdr     lid_hdr;
+       struct llog_logid       lid_id;
+       __u32                   lid_padding1;
+       __u64                   lid_padding2;
+       __u64                   lid_padding3;
+       struct llog_rec_tail    lid_tail;

 } __attribute__((packed));
 
 struct llog_unlink_rec {
 } __attribute__((packed));
 
 struct llog_unlink_rec {

-        struct llog_rec_hdr     lur_hdr;
-        obd_id                  lur_oid;
-        obd_count               lur_oseq;
-        obd_count               lur_count;
-        struct llog_rec_tail    lur_tail;
+       struct llog_rec_hdr     lur_hdr;
+       obd_id                  lur_oid;
+       obd_count               lur_oseq;
+       obd_count               lur_count;
+       struct llog_rec_tail    lur_tail;

 } __attribute__((packed));
 
 } __attribute__((packed));
 

-struct llog_setattr_rec {
-        struct llog_rec_hdr     lsr_hdr;
-        obd_id                  lsr_oid;
-        obd_count               lsr_oseq;
-        __u32                   lsr_uid;
-        __u32                   lsr_gid;
-        __u32                   lsr_padding;
-        struct llog_rec_tail    lsr_tail;
+struct llog_unlink64_rec {
+       struct llog_rec_hdr     lur_hdr;
+       struct lu_fid           lur_fid;
+       obd_count               lur_count; /* to destroy the lost precreated */
+       __u32                   lur_padding1;
+       __u64                   lur_padding2;
+       __u64                   lur_padding3;
+       struct llog_rec_tail    lur_tail;

 } __attribute__((packed));
 
 struct llog_setattr64_rec {
 } __attribute__((packed));
 
 struct llog_setattr64_rec {

-        struct llog_rec_hdr     lsr_hdr;
-        obd_id                  lsr_oid;
-        obd_count               lsr_oseq;
-        __u32                   lsr_padding;
-        __u32                   lsr_uid;
-        __u32                   lsr_uid_h;
-        __u32                   lsr_gid;
-        __u32                   lsr_gid_h;
-        struct llog_rec_tail    lsr_tail;
+       struct llog_rec_hdr     lsr_hdr;
+       obd_id                  lsr_oid;
+       obd_seq                 lsr_oseq;
+       __u32                   lsr_uid;
+       __u32                   lsr_uid_h;
+       __u32                   lsr_gid;
+       __u32                   lsr_gid_h;
+       __u64                   lsr_padding;
+       struct llog_rec_tail    lsr_tail;

 } __attribute__((packed));
 
 struct llog_size_change_rec {
 } __attribute__((packed));
 
 struct llog_size_change_rec {

-        struct llog_rec_hdr     lsc_hdr;
-        struct ll_fid           lsc_fid;
-        __u32                   lsc_ioepoch;
-        __u32                   lsc_padding;
-        struct llog_rec_tail    lsc_tail;
+       struct llog_rec_hdr     lsc_hdr;
+       struct ll_fid           lsc_fid;
+       __u32                   lsc_ioepoch;
+       __u32                   lsc_padding1;
+       __u64                   lsc_padding2;
+       __u64                   lsc_padding3;
+       struct llog_rec_tail    lsc_tail;

 } __attribute__((packed));
 
 #define CHANGELOG_MAGIC 0xca103000
 } __attribute__((packed));
 
 #define CHANGELOG_MAGIC 0xca103000


@@ -2743,16 +2726,21 @@ struct llog_changelog_user_rec {
         struct llog_rec_tail  cur_tail;
 } __attribute__((packed));
 
         struct llog_rec_tail  cur_tail;
 } __attribute__((packed));
 

+/* Old llog gen for compatibility */

 struct llog_gen {
 struct llog_gen {

-        __u64 mnt_cnt;
-        __u64 conn_cnt;
+       __u64 mnt_cnt;
+       __u64 conn_cnt;

 } __attribute__((packed));
 
 struct llog_gen_rec {
 } __attribute__((packed));
 
 struct llog_gen_rec {

-        struct llog_rec_hdr     lgr_hdr;
-        struct llog_gen         lgr_gen;
-        struct llog_rec_tail    lgr_tail;
+       struct llog_rec_hdr     lgr_hdr;
+       struct llog_gen         lgr_gen;
+       __u64                   padding1;
+       __u64                   padding2;
+       __u64                   padding3;
+       struct llog_rec_tail    lgr_tail;

 };
 };

+

 /* On-disk header structure of each log object, stored in little endian order */
 #define LLOG_CHUNK_SIZE         8192
 #define LLOG_HEADER_SIZE        (96)
 /* On-disk header structure of each log object, stored in little endian order */
 #define LLOG_CHUNK_SIZE         8192
 #define LLOG_HEADER_SIZE        (96)


@@ -2761,9 +2749,11 @@ struct llog_gen_rec {
 #define LLOG_MIN_REC_SIZE       (24) /* round(llog_rec_hdr + llog_rec_tail) */
 
 /* flags for the logs */
 #define LLOG_MIN_REC_SIZE       (24) /* round(llog_rec_hdr + llog_rec_tail) */
 
 /* flags for the logs */

-#define LLOG_F_ZAP_WHEN_EMPTY   0x1
-#define LLOG_F_IS_CAT           0x2
-#define LLOG_F_IS_PLAIN         0x4
+enum llog_flag {
+       LLOG_F_ZAP_WHEN_EMPTY   = 0x1,
+       LLOG_F_IS_CAT           = 0x2,
+       LLOG_F_IS_PLAIN         = 0x4,
+};

 
 struct llog_log_hdr {
         struct llog_rec_hdr     llh_hdr;
 
 struct llog_log_hdr {
         struct llog_rec_hdr     llh_hdr;


@@ -2780,9 +2770,9 @@ struct llog_log_hdr {
         struct llog_rec_tail    llh_tail;
 } __attribute__((packed));
 
         struct llog_rec_tail    llh_tail;
 } __attribute__((packed));
 

-#define LLOG_BITMAP_SIZE(llh)  ((llh->llh_hdr.lrh_len -         \
-                                 llh->llh_bitmap_offset -       \
-                                 sizeof(llh->llh_tail)) * 8)
+#define LLOG_BITMAP_SIZE(llh)  (__u32)((llh->llh_hdr.lrh_len -         \
+                                       llh->llh_bitmap_offset -        \
+                                       sizeof(llh->llh_tail)) * 8)

 
 /** log cookies are used to reference a specific log file and a record therein */
 struct llog_cookie {
 
 /** log cookies are used to reference a specific log file and a record therein */
 struct llog_cookie {


@@ -2922,7 +2912,7 @@ extern void lustre_swab_lov_mds_md(struct lov_mds_md *lmm);
 extern void lustre_swab_llogd_body (struct llogd_body *d);
 extern void lustre_swab_llog_hdr (struct llog_log_hdr *h);
 extern void lustre_swab_llogd_conn_body (struct llogd_conn_body *d);
 extern void lustre_swab_llogd_body (struct llogd_body *d);
 extern void lustre_swab_llog_hdr (struct llog_log_hdr *h);
 extern void lustre_swab_llogd_conn_body (struct llogd_conn_body *d);

-extern void lustre_swab_llog_rec(struct llog_rec_hdr  *rec);
+extern void lustre_swab_llog_rec(struct llog_rec_hdr *rec);

 
 struct lustre_cfg;
 extern void lustre_swab_lustre_cfg(struct lustre_cfg *lcfg);
 
 struct lustre_cfg;
 extern void lustre_swab_lustre_cfg(struct lustre_cfg *lcfg);

diff --git a/lustre/include/lustre_mdc.h b/lustre/include/lustre_mdc.h
index 8b10c64..e302dcd 100644 (file)
--- a/lustre/include/lustre_mdc.h
+++ b/lustre/include/lustre_mdc.h
@@ -58,10 +58,10 @@
 #endif /* __KERNEL__ */
 #include <lustre_handles.h>
 #include <libcfs/libcfs.h>
 #endif /* __KERNEL__ */
 #include <lustre_handles.h>
 #include <libcfs/libcfs.h>

+#include <obd_class.h>

 #include <lustre/lustre_idl.h>
 #include <lustre_lib.h>
 #include <lustre_dlm.h>
 #include <lustre/lustre_idl.h>
 #include <lustre_lib.h>
 #include <lustre_dlm.h>

-#include <lustre_log.h>

 #include <lustre_export.h>
 
 struct ptlrpc_client;
 #include <lustre_export.h>
 
 struct ptlrpc_client;

diff --git a/lustre/include/lustre_mds.h b/lustre/include/lustre_mds.h
index 00e6a40..b72e7a9 100644 (file)
--- a/lustre/include/lustre_mds.h
+++ b/lustre/include/lustre_mds.h
@@ -52,7 +52,6 @@
 #include <lustre/lustre_idl.h>
 #include <lustre_lib.h>
 #include <lustre_dlm.h>
 #include <lustre/lustre_idl.h>
 #include <lustre_lib.h>
 #include <lustre_dlm.h>

-#include <lustre_log.h>

 #include <lustre_export.h>
 
 #if defined(__linux__)
 #include <lustre_export.h>
 
 #if defined(__linux__)

diff --git a/lustre/ldlm/ldlm_lib.c b/lustre/ldlm/ldlm_lib.c
index c49e887..2fa220b 100644 (file)
--- a/lustre/ldlm/ldlm_lib.c
+++ b/lustre/ldlm/ldlm_lib.c
@@ -42,7 +42,7 @@
 # include <liblustre.h>
 #endif
 #include <obd.h>
 # include <liblustre.h>
 #endif
 #include <obd.h>

-#include <lustre_mds.h>
+#include <obd_class.h>

 #include <lustre_dlm.h>
 #include <lustre_net.h>
 #include <lustre_sec.h>
 #include <lustre_dlm.h>
 #include <lustre_net.h>
 #include <lustre_sec.h>

diff --git a/lustre/liblustre/llite_lib.c b/lustre/liblustre/llite_lib.c
index df524f1..b197f7e 100644 (file)
--- a/lustre/liblustre/llite_lib.c
+++ b/lustre/liblustre/llite_lib.c
@@ -46,6 +46,7 @@
 
 #include <liblustre.h>
 #include <lnet/lnetctl.h>     /* needed for parse_dump */
 
 #include <liblustre.h>
 #include <lnet/lnetctl.h>     /* needed for parse_dump */

+#include <lustre_log.h>

 
 #include "lutil.h"
 #include "llite_lib.h"
 
 #include "lutil.h"
 #include "llite_lib.h"

diff --git a/lustre/lmv/lmv_obd.c b/lustre/lmv/lmv_obd.c
index 1cd161b..a80bf66 100644 (file)
--- a/lustre/lmv/lmv_obd.c
+++ b/lustre/lmv/lmv_obd.c
@@ -49,7 +49,6 @@
 #include <liblustre.h>
 #endif
 
 #include <liblustre.h>
 #endif
 

-#include <lustre_log.h>

 #include <obd_support.h>
 #include <lustre_lib.h>
 #include <lustre_net.h>
 #include <obd_support.h>
 #include <lustre_lib.h>
 #include <lustre_net.h>


@@ -514,12 +513,6 @@ int lmv_add_target(struct obd_device *obd, struct obd_uuid *tgt_uuid)
                         CERROR("Target %s not attached\n", tgt_uuid->uuid);
                         RETURN(-EINVAL);
                 }
                         CERROR("Target %s not attached\n", tgt_uuid->uuid);
                         RETURN(-EINVAL);
                 }

-
-                rc = obd_llog_init(obd, &obd->obd_olg, mdc_obd, NULL);
-                if (rc) {
-                        lmv_init_unlock(lmv);
-                        CERROR("lmv failed to setup llogging subsystems\n");
-                }

         }
         cfs_spin_lock(&lmv->lmv_lock);
         tgt = lmv->tgts + lmv->desc.ld_tgt_count++;
         }
         cfs_spin_lock(&lmv->lmv_lock);
         tgt = lmv->tgts + lmv->desc.ld_tgt_count++;


@@ -2636,9 +2629,6 @@ static int lmv_precleanup(struct obd_device *obd, enum obd_cleanup_stage stage)
         case OBD_CLEANUP_EXPORTS:
                 fld_client_proc_fini(&lmv->lmv_fld);
                 lprocfs_obd_cleanup(obd);
         case OBD_CLEANUP_EXPORTS:
                 fld_client_proc_fini(&lmv->lmv_fld);
                 lprocfs_obd_cleanup(obd);

-                rc = obd_llog_finish(obd, 0);
-                if (rc != 0)
-                        CERROR("failed to cleanup llogging subsystems\n");

                 break;
         default:
                 break;
                 break;
         default:
                 break;

diff --git a/lustre/lov/lov_ea.c b/lustre/lov/lov_ea.c
index c2c804c..48dfef6 100644 (file)
--- a/lustre/lov/lov_ea.c
+++ b/lustre/lov/lov_ea.c
@@ -50,7 +50,6 @@
 #include <obd_class.h>
 #include <obd_lov.h>
 #include <lustre/lustre_idl.h>
 #include <obd_class.h>
 #include <obd_lov.h>
 #include <lustre/lustre_idl.h>

-#include <lustre_log.h>

 
 #include "lov_internal.h"
 
 
 #include "lov_internal.h"
 

diff --git a/lustre/lov/lov_log.c b/lustre/lov/lov_log.c
index 97b3ca8..0f02e55 100644 (file)
--- a/lustre/lov/lov_log.c
+++ b/lustre/lov/lov_log.c
@@ -55,6 +55,7 @@
 #include <obd_lov.h>
 #include <obd_ost.h>
 #include <lprocfs_status.h>
 #include <obd_lov.h>
 #include <obd_ost.h>
 #include <lprocfs_status.h>

+#include <lustre_log.h>

 
 #include "lov_internal.h"
 
 
 #include "lov_internal.h"
 


@@ -101,6 +102,7 @@ static int lov_llog_origin_add(const struct lu_env *env,
                 default:
                         break;
                 }
                 default:
                         break;
                 }

+

                 /* inject error in llog_add() below */
                 if (OBD_FAIL_CHECK(OBD_FAIL_MDS_FAIL_LOV_LOG_ADD)) {
                         llog_ctxt_put(cctxt);
                 /* inject error in llog_add() below */
                 if (OBD_FAIL_CHECK(OBD_FAIL_MDS_FAIL_LOV_LOG_ADD)) {
                         llog_ctxt_put(cctxt);

diff --git a/lustre/lov/lov_obd.c b/lustre/lov/lov_obd.c
index c0ee782..48a5d7a 100644 (file)
--- a/lustre/lov/lov_obd.c
+++ b/lustre/lov/lov_obd.c
@@ -62,6 +62,7 @@
 #include <lustre_param.h>
 #include <cl_object.h>
 #include <lustre/ll_fiemap.h>
 #include <lustre_param.h>
 #include <cl_object.h>
 #include <lustre/ll_fiemap.h>

+#include <lustre_log.h>

 
 #include "lov_internal.h"
 
 
 #include "lov_internal.h"
 

diff --git a/lustre/mdc/lproc_mdc.c b/lustre/mdc/lproc_mdc.c
index cb497e3..7c06298 100644 (file)
--- a/lustre/mdc/lproc_mdc.c
+++ b/lustre/mdc/lproc_mdc.c
@@ -39,7 +39,6 @@
 #include <linux/vfs.h>
 #include <obd_class.h>
 #include <lprocfs_status.h>
 #include <linux/vfs.h>
 #include <obd_class.h>
 #include <lprocfs_status.h>

-#include <lustre_log.h>

 
 #ifdef LPROCFS
 
 
 #ifdef LPROCFS
 

diff --git a/lustre/mdc/mdc_request.c b/lustre/mdc/mdc_request.c
index 02ef0f2..4dd35b6 100644 (file)
--- a/lustre/mdc/mdc_request.c
+++ b/lustre/mdc/mdc_request.c
@@ -47,13 +47,13 @@
 
 #include <lustre_acl.h>
 #include <obd_class.h>
 
 #include <lustre_acl.h>
 #include <obd_class.h>

-#include <lustre_dlm.h>

 #include <lustre_fid.h>
 #include <md_object.h>
 #include <lprocfs_status.h>
 #include <lustre_param.h>
 #include <lustre_fid.h>
 #include <md_object.h>
 #include <lprocfs_status.h>
 #include <lustre_param.h>

+#include <lustre_log.h>
+

 #include "mdc_internal.h"
 #include "mdc_internal.h"

-#include <lustre/lustre_idl.h>

 
 #define REQUEST_MINOR 244
 
 
 #define REQUEST_MINOR 244
 

diff --git a/lustre/mdd/mdd_internal.h b/lustre/mdd/mdd_internal.h
index fb1cd9a..b6c03aa 100644 (file)
--- a/lustre/mdd/mdd_internal.h
+++ b/lustre/mdd/mdd_internal.h
@@ -43,17 +43,17 @@
 
 #include <lustre_acl.h>
 #include <lustre_eacl.h>
 
 #include <lustre_acl.h>
 #include <lustre_eacl.h>

-#include <obd.h>

 #include <md_object.h>
 #include <dt_object.h>
 #include <md_object.h>
 #include <dt_object.h>

-#include <linux/sched.h>
-#include <linux/capability.h>

 #ifdef HAVE_QUOTA_SUPPORT
 # include <lustre_quota.h>
 #endif
 #include <lustre_fsfilt.h>
 #include <lustre/lustre_lfsck_user.h>
 #include <lustre_fid.h>
 #ifdef HAVE_QUOTA_SUPPORT
 # include <lustre_quota.h>
 #endif
 #include <lustre_fsfilt.h>
 #include <lustre/lustre_lfsck_user.h>
 #include <lustre_fid.h>

+#include <lustre_capa.h>
+#include <lprocfs_status.h>
+#include <lustre_log.h>

 
 #ifdef HAVE_QUOTA_SUPPORT
 /* quota stuff */
 
 #ifdef HAVE_QUOTA_SUPPORT
 /* quota stuff */

diff --git a/lustre/mdd/mdd_lproc.c b/lustre/mdd/mdd_lproc.c
index a85c9fc..44e3b8f 100644 (file)
--- a/lustre/mdd/mdd_lproc.c
+++ b/lustre/mdd/mdd_lproc.c
@@ -40,16 +40,11 @@
 
 #define DEBUG_SUBSYSTEM S_MDS
 
 
 #define DEBUG_SUBSYSTEM S_MDS
 

-#include <linux/module.h>
-#include <linux/poll.h>

 #include <obd.h>
 #include <obd_class.h>
 #include <obd.h>
 #include <obd_class.h>

-#include <lustre_ver.h>

 #include <obd_support.h>
 #include <lprocfs_status.h>
 #include <lu_time.h>
 #include <obd_support.h>
 #include <lprocfs_status.h>
 #include <lu_time.h>

-#include <lustre_log.h>
-#include <lustre/lustre_idl.h>

 #include <libcfs/libcfs_string.h>
 
 #include "mdd_internal.h"
 #include <libcfs/libcfs_string.h>
 
 #include "mdd_internal.h"

diff --git a/lustre/mds/handler.c b/lustre/mds/handler.c
index 182100e..a9c0560 100644 (file)
--- a/lustre/mds/handler.c
+++ b/lustre/mds/handler.c
@@ -58,6 +58,7 @@
 #include <lprocfs_status.h>
 #include <lustre_disk.h>
 #include <lustre_param.h>
 #include <lprocfs_status.h>
 #include <lustre_disk.h>
 #include <lustre_param.h>

+#include <lustre_log.h>

 
 #include "mds_internal.h"
 
 
 #include "mds_internal.h"
 

diff --git a/lustre/mds/mds_log.c b/lustre/mds/mds_log.c
index 225b33f..eceaa9b 100644 (file)
--- a/lustre/mds/mds_log.c
+++ b/lustre/mds/mds_log.c
@@ -50,6 +50,7 @@
 #include <lustre_fsfilt.h>
 #include <lustre_mds.h>
 #include <lustre_log.h>
 #include <lustre_fsfilt.h>
 #include <lustre_mds.h>
 #include <lustre_log.h>

+

 #include "mds_internal.h"
 
 static int mds_llog_origin_add(const struct lu_env *env,
 #include "mds_internal.h"
 
 static int mds_llog_origin_add(const struct lu_env *env,

diff --git a/lustre/mds/mds_lov.c b/lustre/mds/mds_lov.c
index c2b58cb..4258633 100644 (file)
--- a/lustre/mds/mds_lov.c
+++ b/lustre/mds/mds_lov.c
@@ -50,6 +50,7 @@
 #include <lustre_lib.h>
 #include <lustre_fsfilt.h>
 #include <obd_cksum.h>
 #include <lustre_lib.h>
 #include <lustre_fsfilt.h>
 #include <obd_cksum.h>

+#include <lustre_log.h>

 
 #include "mds_internal.h"
 
 
 #include "mds_internal.h"
 

diff --git a/lustre/mdt/mdt_handler.c b/lustre/mdt/mdt_handler.c
index ef39c28..b385a1a 100644 (file)
--- a/lustre/mdt/mdt_handler.c
+++ b/lustre/mdt/mdt_handler.c
@@ -63,13 +63,13 @@
 #include <dt_object.h>
 #include <lustre_mds.h>
 #include <lustre_mdt.h>
 #include <dt_object.h>
 #include <lustre_mds.h>
 #include <lustre_mdt.h>

+#include <lustre_log.h>

 #include "mdt_internal.h"
 #ifdef HAVE_QUOTA_SUPPORT
 # include <lustre_quota.h>
 #endif
 #include <lustre_acl.h>
 #include <lustre_param.h>
 #include "mdt_internal.h"
 #ifdef HAVE_QUOTA_SUPPORT
 # include <lustre_quota.h>
 #endif
 #include <lustre_acl.h>
 #include <lustre_param.h>

-#include <lustre_fsfilt.h>

 
 mdl_mode_t mdt_mdl_lock_modes[] = {
         [LCK_MINMODE] = MDL_MINMODE,
 
 mdl_mode_t mdt_mdl_lock_modes[] = {
         [LCK_MINMODE] = MDL_MINMODE,

diff --git a/lustre/mgs/mgs_handler.c b/lustre/mgs/mgs_handler.c
index f7f737e..4840c31 100644 (file)
--- a/lustre/mgs/mgs_handler.c
+++ b/lustre/mgs/mgs_handler.c
@@ -55,8 +55,10 @@
 #include <lprocfs_status.h>
 #include <lustre_fsfilt.h>
 #include <lustre_disk.h>
 #include <lprocfs_status.h>
 #include <lustre_fsfilt.h>
 #include <lustre_disk.h>

-#include "mgs_internal.h"

 #include <lustre_param.h>
 #include <lustre_param.h>

+#include <lustre_log.h>
+
+#include "mgs_internal.h"

 
 /* Establish a connection to the MGS.*/
 static int mgs_connect(const struct lu_env *env,
 
 /* Establish a connection to the MGS.*/
 static int mgs_connect(const struct lu_env *env,


@@ -924,6 +926,12 @@ int mgs_handle(struct ptlrpc_request *req)
                                 &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK);
                 rc = llog_origin_handle_next_block(req);
                 break;
                                 &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK);
                 rc = llog_origin_handle_next_block(req);
                 break;

+       case LLOG_ORIGIN_HANDLE_PREV_BLOCK:
+               DEBUG_REQ(D_MGS, req, "llog prev block");
+               req_capsule_set(&req->rq_pill,
+                               &RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK);
+               rc = llog_origin_handle_prev_block(req);
+               break;

         case LLOG_ORIGIN_HANDLE_READ_HEADER:
                 DEBUG_REQ(D_MGS, req, "llog read header");
                 req_capsule_set(&req->rq_pill,
         case LLOG_ORIGIN_HANDLE_READ_HEADER:
                 DEBUG_REQ(D_MGS, req, "llog read header");
                 req_capsule_set(&req->rq_pill,

diff --git a/lustre/mgs/mgs_internal.h b/lustre/mgs/mgs_internal.h
index 301b1f9..2585a2e 100644 (file)
--- a/lustre/mgs/mgs_internal.h
+++ b/lustre/mgs/mgs_internal.h
@@ -37,14 +37,7 @@
 #ifndef _MGS_INTERNAL_H
 #define _MGS_INTERNAL_H
 
 #ifndef _MGS_INTERNAL_H
 #define _MGS_INTERNAL_H
 

-#ifdef __KERNEL__
-# include <linux/fs.h>
-#endif

 #include <libcfs/libcfs.h>
 #include <libcfs/libcfs.h>

-#include <lustre/lustre_idl.h>
-#include <lustre_lib.h>
-#include <lustre_dlm.h>
-#include <lustre_log.h>

 #include <lustre_export.h>
 
 #define MGSSELF_NAME    "_mgs"
 #include <lustre_export.h>
 
 #define MGSSELF_NAME    "_mgs"

diff --git a/lustre/mgs/mgs_llog.c b/lustre/mgs/mgs_llog.c
index c11a170..d0ff8f3 100644 (file)
--- a/lustre/mgs/mgs_llog.c
+++ b/lustre/mgs/mgs_llog.c
@@ -43,24 +43,13 @@
 #define DEBUG_SUBSYSTEM S_MGS
 #define D_MGS D_CONFIG
 
 #define DEBUG_SUBSYSTEM S_MGS
 #define D_MGS D_CONFIG
 

-#ifdef __KERNEL__
-#include <linux/module.h>
-#include <linux/pagemap.h>
-#include <linux/fs.h>
-#endif
-

 #include <obd.h>
 #include <obd_lov.h>
 #include <obd.h>
 #include <obd_lov.h>

-#include <obd_class.h>
-#include <lustre_log.h>
-#include <obd_ost.h>
-#include <libcfs/list.h>
-#include <linux/lvfs.h>
-#include <lustre_fsfilt.h>
-#include <lustre_disk.h>

 #include <lustre_param.h>
 #include <lustre_sec.h>
 #include <lquota.h>
 #include <lustre_param.h>
 #include <lustre_sec.h>
 #include <lquota.h>

+#include <lustre_log.h>
+

 #include "mgs_internal.h"
 
 /********************** Class functions ********************/
 #include "mgs_internal.h"
 
 /********************** Class functions ********************/

diff --git a/lustre/mgs/mgs_nids.c b/lustre/mgs/mgs_nids.c
index 0f0c83a..d62f600 100644 (file)
--- a/lustre/mgs/mgs_nids.c
+++ b/lustre/mgs/mgs_nids.c
@@ -44,21 +44,14 @@
 #define D_MGS D_CONFIG
 
 #ifdef __KERNEL__
 #define D_MGS D_CONFIG
 
 #ifdef __KERNEL__

-#include <linux/module.h>

 #include <linux/pagemap.h>
 #include <linux/pagemap.h>

-#include <linux/fs.h>

 #endif
 
 #include <obd.h>
 #endif
 
 #include <obd.h>

-#include <obd_lov.h>

 #include <obd_class.h>
 #include <obd_class.h>

-#include <lustre_log.h>
-#include <obd_ost.h>
-#include <libcfs/list.h>
-#include <linux/lvfs.h>

 #include <lustre_fsfilt.h>
 #include <lustre_disk.h>
 #include <lustre_fsfilt.h>
 #include <lustre_disk.h>

-#include <lustre_param.h>
+

 #include "mgs_internal.h"
 
 static unsigned int ir_timeout;
 #include "mgs_internal.h"
 
 static unsigned int ir_timeout;

diff --git a/lustre/obdclass/llog_lvfs.c b/lustre/obdclass/llog_lvfs.c
index 763649b..6046ec5 100644 (file)
--- a/lustre/obdclass/llog_lvfs.c
+++ b/lustre/obdclass/llog_lvfs.c
@@ -266,12 +266,7 @@ static int llog_lvfs_write_rec(const struct lu_env *env,
                 if (rc || idx == 0)
                         RETURN(rc);
 
                 if (rc || idx == 0)
                         RETURN(rc);
 

-                /* Assumes constant lrh_len */
-                saved_offset = sizeof(*llh) + (idx - 1) * reclen;
-

                 if (buf) {
                 if (buf) {

-                        struct llog_rec_hdr check;
-

                         /* We assume that caller has set lgh_cur_* */
                         saved_offset = loghandle->lgh_cur_offset;
                         CDEBUG(D_OTHER,
                         /* We assume that caller has set lgh_cur_* */
                         saved_offset = loghandle->lgh_cur_offset;
                         CDEBUG(D_OTHER,


@@ -285,19 +280,10 @@ static int llog_lvfs_write_rec(const struct lu_env *env,
                                        idx, loghandle->lgh_cur_idx);
                                 RETURN(-EFAULT);
                         }
                                        idx, loghandle->lgh_cur_idx);
                                 RETURN(-EFAULT);
                         }

-#if 1  /* FIXME remove this safety check at some point */
-                        /* Verify that the record we're modifying is the
-                           right one. */
-                        rc = llog_lvfs_read_blob(obd, file, &check,
-                                                 sizeof(check), saved_offset);
-                        if (check.lrh_index != idx || check.lrh_len != reclen) {
-                                CERROR("Bad modify idx %u/%u size %u/%u (%d)\n",
-                                       idx, check.lrh_index, reclen,
-                                       check.lrh_len, rc);
-                                RETURN(-EFAULT);
-                        }
-#endif
-                }
+               } else {
+                       /* Assumes constant lrh_len */
+                       saved_offset = sizeof(*llh) + (idx - 1) * reclen;
+               }

 
                 rc = llog_lvfs_write_blob(obd, file, rec, buf, saved_offset);
                 if (rc == 0 && reccookie) {
 
                 rc = llog_lvfs_write_blob(obd, file, rec, buf, saved_offset);
                 if (rc == 0 && reccookie) {


@@ -342,11 +328,14 @@ static int llog_lvfs_write_rec(const struct lu_env *env,
         /*The caller should make sure only 1 process access the lgh_last_idx,
          *Otherwise it might hit the assert.*/
         LASSERT(index < LLOG_BITMAP_SIZE(llh));
         /*The caller should make sure only 1 process access the lgh_last_idx,
          *Otherwise it might hit the assert.*/
         LASSERT(index < LLOG_BITMAP_SIZE(llh));

-        if (ext2_set_bit(index, llh->llh_bitmap)) {
-                CERROR("argh, index %u already set in log bitmap?\n", index);
-                LBUG(); /* should never happen */
-        }
-        llh->llh_count++;
+       cfs_spin_lock(&loghandle->lgh_hdr_lock);
+       if (ext2_set_bit(index, llh->llh_bitmap)) {
+               CERROR("argh, index %u already set in log bitmap?\n", index);
+               cfs_spin_unlock(&loghandle->lgh_hdr_lock);
+               LBUG(); /* should never happen */
+       }
+       llh->llh_count++;
+       cfs_spin_unlock(&loghandle->lgh_hdr_lock);

         llh->llh_tail.lrt_index = index;
 
         rc = llog_lvfs_write_blob(obd, file, &llh->llh_hdr, NULL, 0);
         llh->llh_tail.lrt_index = index;
 
         rc = llog_lvfs_write_blob(obd, file, &llh->llh_hdr, NULL, 0);


@@ -412,17 +401,20 @@ static int llog_lvfs_next_block(const struct lu_env *env,
                next_idx, *cur_idx, *cur_offset);
 
         while (*cur_offset < i_size_read(loghandle->lgh_file->f_dentry->d_inode)) {
                next_idx, *cur_idx, *cur_offset);
 
         while (*cur_offset < i_size_read(loghandle->lgh_file->f_dentry->d_inode)) {

-                struct llog_rec_hdr *rec;
-                struct llog_rec_tail *tail;
-                loff_t ppos;
-
-                llog_skip_over(cur_offset, *cur_idx, next_idx);
-
-                ppos = *cur_offset;
-                rc = fsfilt_read_record(loghandle->lgh_ctxt->loc_exp->exp_obd,
-                                        loghandle->lgh_file, buf, len,
-                                        &ppos);
-                if (rc) {
+               struct llog_rec_hdr *rec, *last_rec;
+               struct llog_rec_tail *tail;
+               loff_t ppos;
+               int llen;
+
+               llog_skip_over(cur_offset, *cur_idx, next_idx);
+
+               /* read up to next LLOG_CHUNK_SIZE block */
+               ppos = *cur_offset;
+               llen = LLOG_CHUNK_SIZE - (*cur_offset & (LLOG_CHUNK_SIZE - 1));
+               rc = fsfilt_read_record(loghandle->lgh_ctxt->loc_exp->exp_obd,
+                                       loghandle->lgh_file, buf, llen,
+                                       cur_offset);
+               if (rc < 0) {

                         CERROR("Cant read llog block at log id "LPU64
                                "/%u offset "LPU64"\n",
                                loghandle->lgh_id.lgl_oid,
                         CERROR("Cant read llog block at log id "LPU64
                                "/%u offset "LPU64"\n",
                                loghandle->lgh_id.lgl_oid,


@@ -432,9 +424,7 @@ static int llog_lvfs_next_block(const struct lu_env *env,
                 }
 
                 /* put number of bytes read into rc to make code simpler */
                 }
 
                 /* put number of bytes read into rc to make code simpler */

-                rc = ppos - *cur_offset;
-                *cur_offset = ppos;
-
+               rc = *cur_offset - ppos;

                 if (rc < len) {
                         /* signal the end of the valid buffer to llog_process */
                         memset(buf + rc, 0, len - rc);
                 if (rc < len) {
                         /* signal the end of the valid buffer to llog_process */
                         memset(buf + rc, 0, len - rc);


@@ -451,12 +441,20 @@ static int llog_lvfs_next_block(const struct lu_env *env,
                 }
 
                 rec = buf;
                 }
 
                 rec = buf;

-                tail = (struct llog_rec_tail *)((char *)buf + rc -
-                                                sizeof(struct llog_rec_tail));
-

                if (LLOG_REC_HDR_NEEDS_SWABBING(rec))
                        lustre_swab_llog_rec(rec);
 
                if (LLOG_REC_HDR_NEEDS_SWABBING(rec))
                        lustre_swab_llog_rec(rec);
 

+               tail = (struct llog_rec_tail *)(buf + rc -
+                                               sizeof(struct llog_rec_tail));
+
+               /* get the last record in block */
+               last_rec = (struct llog_rec_hdr *)(buf + rc -
+                                                  le32_to_cpu(tail->lrt_len));
+
+               if (LLOG_REC_HDR_NEEDS_SWABBING(last_rec))
+                       lustre_swab_llog_rec(last_rec);
+               LASSERT(last_rec->lrh_index == tail->lrt_index);
+

                 *cur_idx = tail->lrt_index;
 
                 /* this shouldn't happen */
                 *cur_idx = tail->lrt_index;
 
                 /* this shouldn't happen */


@@ -498,16 +496,14 @@ static int llog_lvfs_prev_block(const struct lu_env *env,
         llog_skip_over(&cur_offset, 0, prev_idx);
 
         while (cur_offset < i_size_read(loghandle->lgh_file->f_dentry->d_inode)) {
         llog_skip_over(&cur_offset, 0, prev_idx);
 
         while (cur_offset < i_size_read(loghandle->lgh_file->f_dentry->d_inode)) {

-                struct llog_rec_hdr *rec;
-                struct llog_rec_tail *tail;
-                loff_t ppos;
-
-                ppos = cur_offset;
-
-                rc = fsfilt_read_record(loghandle->lgh_ctxt->loc_exp->exp_obd,
-                                        loghandle->lgh_file, buf, len,
-                                        &ppos);
-                if (rc) {
+               struct llog_rec_hdr *rec, *last_rec;
+               struct llog_rec_tail *tail;
+               loff_t ppos = cur_offset;
+
+               rc = fsfilt_read_record(loghandle->lgh_ctxt->loc_exp->exp_obd,
+                                       loghandle->lgh_file, buf, len,
+                                       &cur_offset);
+               if (rc < 0) {

                         CERROR("Cant read llog block at log id "LPU64
                                "/%u offset "LPU64"\n",
                                loghandle->lgh_id.lgl_oid,
                         CERROR("Cant read llog block at log id "LPU64
                                "/%u offset "LPU64"\n",
                                loghandle->lgh_id.lgl_oid,


@@ -517,8 +513,7 @@ static int llog_lvfs_prev_block(const struct lu_env *env,
                 }
 
                 /* put number of bytes read into rc to make code simpler */
                 }
 
                 /* put number of bytes read into rc to make code simpler */

-                rc = ppos - cur_offset;
-                cur_offset = ppos;
+               rc = cur_offset - ppos;

 
                 if (rc == 0) /* end of file, nothing to do */
                         RETURN(0);
 
                 if (rc == 0) /* end of file, nothing to do */
                         RETURN(0);


@@ -530,7 +525,20 @@ static int llog_lvfs_prev_block(const struct lu_env *env,
                         RETURN(-EINVAL);
                 }
 
                         RETURN(-EINVAL);
                 }
 

-                tail = buf + rc - sizeof(struct llog_rec_tail);
+               rec = buf;
+               if (LLOG_REC_HDR_NEEDS_SWABBING(rec))
+                       lustre_swab_llog_rec(rec);
+
+               tail = (struct llog_rec_tail *)(buf + rc -
+                                               sizeof(struct llog_rec_tail));
+
+               /* get the last record in block */
+               last_rec = (struct llog_rec_hdr *)(buf + rc -
+                                                  le32_to_cpu(tail->lrt_len));
+
+               if (LLOG_REC_HDR_NEEDS_SWABBING(last_rec))
+                       lustre_swab_llog_rec(last_rec);
+               LASSERT(last_rec->lrh_index == tail->lrt_index);

 
                 /* this shouldn't happen */
                 if (tail->lrt_index == 0) {
 
                 /* this shouldn't happen */
                 if (tail->lrt_index == 0) {


@@ -539,15 +547,14 @@ static int llog_lvfs_prev_block(const struct lu_env *env,
                                loghandle->lgh_id.lgl_ogen, cur_offset);
                         RETURN(-EINVAL);
                 }
                                loghandle->lgh_id.lgl_ogen, cur_offset);
                         RETURN(-EINVAL);
                 }

-                if (le32_to_cpu(tail->lrt_index) < prev_idx)
+               if (tail->lrt_index < prev_idx)

                         continue;
 
                 /* sanity check that the start of the new buffer is no farther
                  * than the record that we wanted.  This shouldn't happen. */
                         continue;
 
                 /* sanity check that the start of the new buffer is no farther
                  * than the record that we wanted.  This shouldn't happen. */

-                rec = buf;
-                if (le32_to_cpu(rec->lrh_index) > prev_idx) {
-                        CERROR("missed desired record? %u > %u\n",
-                               le32_to_cpu(rec->lrh_index), prev_idx);
+               if (rec->lrh_index > prev_idx) {
+                       CERROR("missed desired record? %u > %u\n",
+                              rec->lrh_index, prev_idx);

                         RETURN(-ENOENT);
                 }
                 RETURN(0);
                         RETURN(-ENOENT);
                 }
                 RETURN(0);


@@ -757,8 +764,10 @@ static int llog_lvfs_close(const struct lu_env *env,
                       handle->lgh_id.lgl_oid, handle->lgh_id.lgl_oseq,
                       handle->lgh_id.lgl_ogen, rc);
        handle->lgh_file = NULL;
                       handle->lgh_id.lgl_oid, handle->lgh_id.lgl_oseq,
                       handle->lgh_id.lgl_ogen, rc);
        handle->lgh_file = NULL;

-       if (handle->lgh_name)
+       if (handle->lgh_name) {

                OBD_FREE(handle->lgh_name, strlen(handle->lgh_name) + 1);
                OBD_FREE(handle->lgh_name, strlen(handle->lgh_name) + 1);

+               handle->lgh_name = NULL;
+       }

        RETURN(rc);
 }
 
        RETURN(rc);
 }
 

diff --git a/lustre/obdclass/llog_swab.c b/lustre/obdclass/llog_swab.c
index 3a49fdc..d2197cf 100644 (file)
--- a/lustre/obdclass/llog_swab.c
+++ b/lustre/obdclass/llog_swab.c
@@ -144,6 +144,16 @@ void lustre_swab_llog_rec(struct llog_rec_hdr *rec)
                tail = &lur->lur_tail;
                 break;
         }
                tail = &lur->lur_tail;
                 break;
         }

+       case MDS_UNLINK64_REC:
+       {
+               struct llog_unlink64_rec *lur =
+                       (struct llog_unlink64_rec *)rec;
+
+               lustre_swab_lu_fid(&lur->lur_fid);
+               __swab32s(&lur->lur_count);
+               tail = &lur->lur_tail;
+               break;
+       }

        case CHANGELOG_REC:
        {
                 struct llog_changelog_rec *cr = (struct llog_changelog_rec*)rec;
        case CHANGELOG_REC:
        {
                 struct llog_changelog_rec *cr = (struct llog_changelog_rec*)rec;


@@ -184,14 +194,14 @@ void lustre_swab_llog_rec(struct llog_rec_hdr *rec)
                struct llog_setattr64_rec *lsr =
                        (struct llog_setattr64_rec *)rec;
 
                struct llog_setattr64_rec *lsr =
                        (struct llog_setattr64_rec *)rec;
 

-                __swab64s(&lsr->lsr_oid);
-                __swab32s(&lsr->lsr_oseq);
-                __swab32s(&lsr->lsr_uid);
+               __swab64s(&lsr->lsr_oid);
+               __swab64s(&lsr->lsr_oseq);
+               __swab32s(&lsr->lsr_uid);

                __swab32s(&lsr->lsr_uid_h);
                __swab32s(&lsr->lsr_uid_h);

-                __swab32s(&lsr->lsr_gid);
+               __swab32s(&lsr->lsr_gid);

                __swab32s(&lsr->lsr_gid_h);
                tail = &lsr->lsr_tail;
                __swab32s(&lsr->lsr_gid_h);
                tail = &lsr->lsr_tail;

-                break;
+               break;

         }
         case OBD_CFG_REC:
                 /* these are swabbed as they are consumed */
         }
         case OBD_CFG_REC:
                 /* these are swabbed as they are consumed */

diff --git a/lustre/obdclass/llog_test.c b/lustre/obdclass/llog_test.c
index 037e0a7..2ab53d0 100644 (file)
--- a/lustre/obdclass/llog_test.c
+++ b/lustre/obdclass/llog_test.c
@@ -26,6 +26,8 @@
 /*
  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
 /*
  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.

+ *
+ * Copyright (c) 2011, 2012, Intel, Inc.

  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/


@@ -34,6 +36,7 @@
  * lustre/obdclass/llog_test.c
  *
  * Author: Phil Schwan <phil@clusterfs.com>
  * lustre/obdclass/llog_test.c
  *
  * Author: Phil Schwan <phil@clusterfs.com>

+ * Author: Mikhail Pershin <mike.pershin@intel.com>

  */
 
 #define DEBUG_SUBSYSTEM S_CLASS
  */
 
 #define DEBUG_SUBSYSTEM S_CLASS


@@ -42,8 +45,14 @@
 #include <linux/init.h>
 
 #include <obd_class.h>
 #include <linux/init.h>
 
 #include <obd_class.h>

+#include <lustre_fid.h>

 #include <lustre_log.h>
 
 #include <lustre_log.h>
 

+/* This is slightly more than the number of records that can fit into a
+ * single llog file, because the llog_log_header takes up some of the
+ * space in the first block that cannot be used for the bitmap. */
+#define LLOG_TEST_RECNUM  (LLOG_CHUNK_SIZE * 8)
+

 static int llog_test_rand;
 static struct obd_uuid uuid = { .uuid = "test_uuid" };
 static struct llog_logid cat_logid;
 static int llog_test_rand;
 static struct obd_uuid uuid = { .uuid = "test_uuid" };
 static struct llog_logid cat_logid;


@@ -88,591 +97,870 @@ static int verify_handle(char *test, struct llog_handle *llh, int num_recs)
 }
 
 /* Test named-log create/open, close */
 }
 
 /* Test named-log create/open, close */

-static int llog_test_1(struct obd_device *obd, char *name)
+static int llog_test_1(const struct lu_env *env,
+                      struct obd_device *obd, char *name)

 {
 {

-        struct llog_handle *llh;
-        struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
-        int rc;
-        int rc2;
-        ENTRY;
-
-        CWARN("1a: create a log with name: %s\n", name);
-        LASSERT(ctxt);
-
-       rc = llog_open_create(NULL, ctxt, &llh, NULL, name);
-        if (rc) {
-                CERROR("1a: llog_create with name %s failed: %d\n", name, rc);
-                llog_ctxt_put(ctxt);
-                RETURN(rc);
-        }
-       llog_init_handle(NULL, llh, LLOG_F_IS_PLAIN, &uuid);
-
-        if ((rc = verify_handle("1", llh, 1)))
-                GOTO(out, rc);
-
- out:
-        CWARN("1b: close newly-created log\n");
-       rc2 = llog_close(NULL, llh);
-        llog_ctxt_put(ctxt);
-        if (rc2) {
-                CERROR("1b: close log %s failed: %d\n", name, rc2);
-                if (rc == 0)
-                        rc = rc2;
-        }
-        RETURN(rc);
+       struct llog_handle      *llh;
+       struct llog_ctxt        *ctxt;
+       int rc;
+       int rc2;
+
+       ENTRY;
+
+       CWARN("1a: create a log with name: %s\n", name);
+       ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
+       LASSERT(ctxt);
+
+       rc = llog_open_create(env, ctxt, &llh, NULL, name);
+       if (rc) {
+               CERROR("1a: llog_create with name %s failed: %d\n", name, rc);
+               GOTO(out, rc);
+       }
+       rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, &uuid);
+       if (rc) {
+               CERROR("1a: can't init llog handle: %d\n", rc);
+               GOTO(out_close, rc);
+       }
+
+       rc = verify_handle("1", llh, 1);
+
+       CWARN("1b: close newly-created log\n");
+out_close:
+       rc2 = llog_close(env, llh);
+       if (rc2) {
+               CERROR("1b: close log %s failed: %d\n", name, rc2);
+               if (rc == 0)
+                       rc = rc2;
+       }
+out:
+       llog_ctxt_put(ctxt);
+       RETURN(rc);

 }
 
 /* Test named-log reopen; returns opened log on success */
 }
 
 /* Test named-log reopen; returns opened log on success */

-static int llog_test_2(struct obd_device *obd, char *name,
-                       struct llog_handle **llh)
+static int llog_test_2(const struct lu_env *env, struct obd_device *obd,
+                      char *name, struct llog_handle **llh)

 {
 {

-        struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
-        int rc;
-        ENTRY;
-
-        CWARN("2a: re-open a log with name: %s\n", name);
-       rc = llog_open(NULL, ctxt, llh, NULL, name, LLOG_OPEN_EXISTS);
-        if (rc) {
-                CERROR("2a: re-open log with name %s failed: %d\n", name, rc);
-                GOTO(out, rc);
-        }
-       llog_init_handle(NULL, *llh, LLOG_F_IS_PLAIN, &uuid);
-
-        if ((rc = verify_handle("2", *llh, 1)))
-                GOTO(out, rc);
-#if 0
-        CWARN("2b: create a log without specified NAME & LOGID\n");
-        rc = llog_create(ctxt, &loghandle, NULL, NULL);
-        if (rc) {
-                CERROR("2b: create log failed\n");
-                GOTO(out, rc);
-        }
-        llog_init_handle(loghandle, LLOG_F_IS_PLAIN, &uuid);
-        logid = loghandle->lgh_id;
-        llog_close(loghandle);
-
-        CWARN("2b: re-open the log by LOGID\n");
-        rc = llog_create(ctxt, &loghandle, &logid, NULL);
-        if (rc) {
-                CERROR("2b: re-open log by LOGID failed\n");
-                GOTO(out, rc);
-        }
-        llog_init_handle(loghandle, LLOG_F_IS_PLAIN, &uuid);
-
-        CWARN("2b: destroy this log\n");
-        rc = llog_destroy(loghandle);
-        if (rc) {
-                CERROR("2b: destroy log failed\n");
-                GOTO(out, rc);
-        }
-        llog_free_handle(loghandle);
-#endif
-out:
-        llog_ctxt_put(ctxt);
-
-        RETURN(rc);
+       struct llog_ctxt        *ctxt;
+       struct llog_handle      *loghandle;
+       struct llog_logid        logid;
+       int                      rc;
+
+       ENTRY;
+
+       CWARN("2a: re-open a log with name: %s\n", name);
+       ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
+       LASSERT(ctxt);
+
+       rc = llog_open(env, ctxt, llh, NULL, name, LLOG_OPEN_EXISTS);
+       if (rc) {
+               CERROR("2a: re-open log with name %s failed: %d\n", name, rc);
+               GOTO(out_put, rc);
+       }
+
+       llog_init_handle(env, *llh, LLOG_F_IS_PLAIN, &uuid);
+       if (rc) {
+               CERROR("2a: can't init llog handle: %d\n", rc);
+               GOTO(out_close_llh, rc);
+       }
+
+       rc = verify_handle("2", *llh, 1);
+       if (rc)
+               GOTO(out_close_llh, rc);
+
+       /* XXX: there is known issue with tests 2b, MGS is not able to create
+        * anonymous llog, exit now to allow following tests run.
+        * It is fixed in upcoming llog over OSD code */
+       GOTO(out_put, rc);
+
+       CWARN("2b: create a log without specified NAME & LOGID\n");
+       rc = llog_open_create(env, ctxt, &loghandle, NULL, NULL);
+       if (rc) {
+               CERROR("2b: create log failed\n");
+               GOTO(out_close_llh, rc);
+       }
+       rc = llog_init_handle(env, loghandle, LLOG_F_IS_PLAIN, &uuid);
+       if (rc) {
+               CERROR("2b: can't init llog handle: %d\n", rc);
+               GOTO(out_close, rc);
+       }
+
+       logid = loghandle->lgh_id;
+       llog_close(env, loghandle);
+
+       CWARN("2c: re-open the log by LOGID\n");
+       rc = llog_open(env, ctxt, &loghandle, &logid, NULL, LLOG_OPEN_EXISTS);
+       if (rc) {
+               CERROR("2c: re-open log by LOGID failed\n");
+               GOTO(out_close_llh, rc);
+       }
+
+       rc = llog_init_handle(env, loghandle, LLOG_F_IS_PLAIN, &uuid);
+       if (rc) {
+               CERROR("2c: can't init llog handle: %d\n", rc);
+               GOTO(out_close, rc);
+       }
+
+       CWARN("2b: destroy this log\n");
+       rc = llog_destroy(env, loghandle);
+       if (rc)
+               CERROR("2d: destroy log failed\n");
+out_close:
+       llog_close(env, loghandle);
+out_close_llh:
+       if (rc)
+               llog_close(env, *llh);
+out_put:
+       llog_ctxt_put(ctxt);
+
+       RETURN(rc);

 }
 
 /* Test record writing, single and in bulk */
 }
 
 /* Test record writing, single and in bulk */

-static int llog_test_3(struct obd_device *obd, struct llog_handle *llh)
+static int llog_test_3(const struct lu_env *env, struct obd_device *obd,
+                      struct llog_handle *llh)

 {
 {

-        struct llog_create_rec lcr;
-        int rc, i;
-        int num_recs = 1;       /* 1 for the header */
-        ENTRY;
-
-        lcr.lcr_hdr.lrh_len = lcr.lcr_tail.lrt_len = sizeof(lcr);
-        lcr.lcr_hdr.lrh_type = OST_SZ_REC;
-
-        CWARN("3a: write one create_rec\n");
-       rc = llog_write_rec(NULL, llh,  &lcr.lcr_hdr, NULL, 0, NULL, -1);
-        num_recs++;
-        if (rc) {
-                CERROR("3a: write one log record failed: %d\n", rc);
-                RETURN(rc);
-        }
-
-        if ((rc = verify_handle("3a", llh, num_recs)))
-                RETURN(rc);
-
-        CWARN("3b: write 10 cfg log records with 8 bytes bufs\n");
-        for (i = 0; i < 10; i++) {
-                struct llog_rec_hdr hdr;
-                char buf[8];
-                hdr.lrh_len = 8;
-                hdr.lrh_type = OBD_CFG_REC;
-                memset(buf, 0, sizeof buf);
-               rc = llog_write_rec(NULL, llh, &hdr, NULL, 0, buf, -1);
-                if (rc) {
-                        CERROR("3b: write 10 records failed at #%d: %d\n",
-                               i + 1, rc);
-                        RETURN(rc);
-                }
-                num_recs++;
-                if ((rc = verify_handle("3c", llh, num_recs)))
-                        RETURN(rc);
-        }
-
-        if ((rc = verify_handle("3b", llh, num_recs)))
-                RETURN(rc);
-
-        CWARN("3c: write 1000 more log records\n");
-        for (i = 0; i < 1000; i++) {
-               rc = llog_write_rec(NULL, llh, &lcr.lcr_hdr, NULL, 0, NULL,
+       struct llog_gen_rec      lgr;
+       int                      rc, i;
+       int                      num_recs = 1; /* 1 for the header */
+
+       ENTRY;
+
+       lgr.lgr_hdr.lrh_len = lgr.lgr_tail.lrt_len = sizeof(lgr);
+       lgr.lgr_hdr.lrh_type = LLOG_GEN_REC;
+
+       CWARN("3a: write one create_rec\n");
+       rc = llog_write_rec(env, llh,  &lgr.lgr_hdr, NULL, 0, NULL, -1);
+       num_recs++;
+       if (rc < 0) {
+               CERROR("3a: write one log record failed: %d\n", rc);
+               RETURN(rc);
+       }
+
+       rc = verify_handle("3a", llh, num_recs);
+       if (rc)
+               RETURN(rc);
+
+       CWARN("3b: write 10 cfg log records with 8 bytes bufs\n");
+       for (i = 0; i < 10; i++) {
+               struct llog_rec_hdr     hdr;
+               char                    buf[8];
+
+               hdr.lrh_len = 8;
+               hdr.lrh_type = OBD_CFG_REC;
+               memset(buf, 0, sizeof buf);
+               rc = llog_write_rec(env, llh, &hdr, NULL, 0, buf, -1);
+               if (rc < 0) {
+                       CERROR("3b: write 10 records failed at #%d: %d\n",
+                              i + 1, rc);
+                       RETURN(rc);
+               }
+               num_recs++;
+       }
+
+       rc = verify_handle("3b", llh, num_recs);
+       if (rc)
+               RETURN(rc);
+
+       CWARN("3c: write 1000 more log records\n");
+       for (i = 0; i < 1000; i++) {
+               rc = llog_write_rec(env, llh, &lgr.lgr_hdr, NULL, 0, NULL,

                                    -1);
                                    -1);

-                if (rc) {
-                        CERROR("3c: write 1000 records failed at #%d: %d\n",
-                               i + 1, rc);
-                        RETURN(rc);
-                }
-                num_recs++;
-                if ((rc = verify_handle("3b", llh, num_recs)))
-                        RETURN(rc);
-        }
-
-        if ((rc = verify_handle("3c", llh, num_recs)))
-                RETURN(rc);
-
-        CWARN("3d: write log more than BITMAP_SIZE, return -ENOSPC\n");
-        for (i = 0; i < LLOG_BITMAP_SIZE(llh->lgh_hdr) + 1; i++) {
-                struct llog_rec_hdr hdr;
-                char buf_even[24];
-                char buf_odd[32];
-
-                memset(buf_odd, 0, sizeof buf_odd);
-                memset(buf_even, 0, sizeof buf_even);
-                if ((i % 2) == 0) {
-                        hdr.lrh_len = 24;
-                        hdr.lrh_type = OBD_CFG_REC;
-                       rc = llog_write_rec(NULL, llh, &hdr, NULL, 0, buf_even,
+               if (rc < 0) {
+                       CERROR("3c: write 1000 records failed at #%d: %d\n",
+                              i + 1, rc);
+                       RETURN(rc);
+               }
+               num_recs++;
+       }
+
+       rc = verify_handle("3c", llh, num_recs);
+       if (rc)
+               RETURN(rc);
+
+       CWARN("3d: write log more than BITMAP_SIZE, return -ENOSPC\n");
+       for (i = 0; i < LLOG_BITMAP_SIZE(llh->lgh_hdr) + 1; i++) {
+               struct llog_rec_hdr     hdr;
+               char                    buf_even[24];
+               char                    buf_odd[32];
+
+               memset(buf_odd, 0, sizeof buf_odd);
+               memset(buf_even, 0, sizeof buf_even);
+               if ((i % 2) == 0) {
+                       hdr.lrh_len = 24;
+                       hdr.lrh_type = OBD_CFG_REC;
+                       rc = llog_write_rec(env, llh, &hdr, NULL, 0, buf_even,

                                            -1);
                                            -1);

-                } else {
-                        hdr.lrh_len = 32;
-                        hdr.lrh_type = OBD_CFG_REC;
-                       rc = llog_write_rec(NULL, llh, &hdr, NULL, 0, buf_odd,
+               } else {
+                       hdr.lrh_len = 32;
+                       hdr.lrh_type = OBD_CFG_REC;
+                       rc = llog_write_rec(env, llh, &hdr, NULL, 0, buf_odd,

                                            -1);
                                            -1);

-                }
-                if (rc) {
-                        if (rc == -ENOSPC) {
-                                break;
-                        } else {
-                                CERROR("3c: write recs failed at #%d: %d\n",
-                                        i + 1, rc);
-                                RETURN(rc);
-                        }
-                }
-                num_recs++;
-        }
-        if (rc != -ENOSPC) {
-                CWARN("3d: write record more than BITMAP size!\n");
-                RETURN(-EINVAL);
-        }
-        if ((rc = verify_handle("3d", llh, num_recs)))
-                RETURN(rc);
-
-        RETURN(rc);
+               }
+               if (rc == -ENOSPC) {
+                       break;
+               } else if (rc < 0) {
+                       CERROR("3d: write recs failed at #%d: %d\n",
+                              i + 1, rc);
+                       RETURN(rc);
+               }
+               num_recs++;
+       }
+       if (rc != -ENOSPC) {
+               CWARN("3d: write record more than BITMAP size!\n");
+               RETURN(-EINVAL);
+       }
+       CWARN("3d: wrote %d more records before end of llog is reached\n",
+             num_recs);
+
+       rc = verify_handle("3d", llh, num_recs);
+
+       RETURN(rc);

 }
 
 /* Test catalogue additions */
 }
 
 /* Test catalogue additions */

-static int llog_test_4(struct obd_device *obd)
+static int llog_test_4(const struct lu_env *env, struct obd_device *obd)

 {
 {

-        struct llog_handle *cath;
-        char name[10];
-        int rc, i, buflen;
-        struct llog_mini_rec lmr;
-        struct llog_cookie cookie;
-        struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
-        int num_recs = 0;
-        char *buf;
-        struct llog_rec_hdr rec;
-
-        ENTRY;
-
-        lmr.lmr_hdr.lrh_len = lmr.lmr_tail.lrt_len = LLOG_MIN_REC_SIZE;
-        lmr.lmr_hdr.lrh_type = 0xf00f00;
-
-        sprintf(name, "%x", llog_test_rand+1);
-        CWARN("4a: create a catalog log with name: %s\n", name);
-       rc = llog_open_create(NULL, ctxt, &cath, NULL, name);
-        if (rc) {
-                CERROR("1a: llog_create with name %s failed: %d\n", name, rc);
-                GOTO(out, rc);
-        }
-       llog_init_handle(NULL, cath, LLOG_F_IS_CAT, &uuid);
-        num_recs++;
-        cat_logid = cath->lgh_id;
-
-        CWARN("4b: write 1 record into the catalog\n");
-       rc = llog_cat_add_rec(NULL, cath, &lmr.lmr_hdr, &cookie, NULL);
-        if (rc != 1) {
-                CERROR("4b: write 1 catalog record failed at: %d\n", rc);
-                GOTO(out, rc);
+       struct llog_handle      *cath;
+       char                     name[10];
+       int                      rc, rc2, i, buflen;
+       struct llog_mini_rec     lmr;
+       struct llog_cookie       cookie;
+       struct llog_ctxt        *ctxt;
+       int                      num_recs = 0;
+       char                    *buf;
+       struct llog_rec_hdr      rec;
+
+       ENTRY;
+
+       ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
+       LASSERT(ctxt);
+
+       lmr.lmr_hdr.lrh_len = lmr.lmr_tail.lrt_len = LLOG_MIN_REC_SIZE;
+       lmr.lmr_hdr.lrh_type = 0xf00f00;
+
+       sprintf(name, "%x", llog_test_rand + 1);
+       CWARN("4a: create a catalog log with name: %s\n", name);
+       rc = llog_open_create(env, ctxt, &cath, NULL, name);
+       if (rc) {
+               CERROR("4a: llog_create with name %s failed: %d\n", name, rc);
+               GOTO(ctxt_release, rc);

         }
         }

-        num_recs++;
-        if ((rc = verify_handle("4b", cath, 2)))
-                GOTO(ctxt_release, rc);
-
-        if ((rc = verify_handle("4b", cath->u.chd.chd_current_log, num_recs)))
-                GOTO(ctxt_release, rc);
-
-        CWARN("4c: cancel 1 log record\n");
-       rc = llog_cat_cancel_records(NULL, cath, 1, &cookie);
-        if (rc) {
-                CERROR("4c: cancel 1 catalog based record failed: %d\n", rc);
-                GOTO(out, rc);
-        }
-        num_recs--;
-
-        if ((rc = verify_handle("4c", cath->u.chd.chd_current_log, num_recs)))
-                GOTO(ctxt_release, rc);
-
-        CWARN("4d: write 40,000 more log records\n");
-        for (i = 0; i < 40000; i++) {
-               rc = llog_cat_add_rec(NULL, cath, &lmr.lmr_hdr, NULL, NULL);
-                if (rc) {
-                        CERROR("4d: write 40000 records failed at #%d: %d\n",
-                               i + 1, rc);
-                        GOTO(out, rc);
-                }
-                num_recs++;
-        }
-
-        CWARN("4e: add 5 large records, one record per block\n");
-        buflen = LLOG_CHUNK_SIZE - sizeof(struct llog_rec_hdr)
-                        - sizeof(struct llog_rec_tail);
-        OBD_ALLOC(buf, buflen);
-        if (buf == NULL)
-                GOTO(out, rc = -ENOMEM);
-        for (i = 0; i < 5; i++) {
-                rec.lrh_len = buflen;
-                rec.lrh_type = OBD_CFG_REC;
-               rc = llog_cat_add_rec(NULL, cath, &rec, NULL, buf);
-                if (rc) {
-                        CERROR("4e: write 5 records failed at #%d: %d\n",
-                               i + 1, rc);
-                        OBD_FREE(buf, buflen);
-                        GOTO(out, rc);
-                }
-                num_recs++;
-        }
-        OBD_FREE(buf, buflen);
-
- out:
-        CWARN("4f: put newly-created catalog\n");
-       rc = llog_cat_close(NULL, cath);
+       llog_init_handle(env, cath, LLOG_F_IS_CAT, &uuid);
+       if (rc) {
+               CERROR("4a: can't init llog handle: %d\n", rc);
+               GOTO(out, rc);
+       }
+
+       num_recs++;
+       cat_logid = cath->lgh_id;
+
+       /* XXX: there is known issue with tests 4b, MGS is not able to add
+        * anonymous plain llog, si we exit now to allow following tests run.
+        * It is fixed in upcoming llog over OSD code */
+       GOTO(out, rc);
+
+       CWARN("4b: write 1 record into the catalog\n");
+       rc = llog_cat_add_rec(env, cath, &lmr.lmr_hdr, &cookie, NULL);
+       if (rc != 1) {
+               CERROR("4b: write 1 catalog record failed at: %d\n", rc);
+               GOTO(out, rc);
+       }
+       num_recs++;
+       rc = verify_handle("4b", cath, 2);
+       if (rc)
+               GOTO(out, rc);
+
+       rc = verify_handle("4b", cath->u.chd.chd_current_log, num_recs);
+       if (rc)
+               GOTO(out, rc);
+
+       CWARN("4c: cancel 1 log record\n");
+       rc = llog_cat_cancel_records(env, cath, 1, &cookie);
+       if (rc) {
+               CERROR("4c: cancel 1 catalog based record failed: %d\n", rc);
+               GOTO(out, rc);
+       }
+       num_recs--;
+
+       rc = verify_handle("4c", cath->u.chd.chd_current_log, num_recs);
+       if (rc)
+               GOTO(out, rc);
+
+       CWARN("4d: write %d more log records\n", LLOG_TEST_RECNUM);
+       for (i = 0; i < LLOG_TEST_RECNUM; i++) {
+               rc = llog_cat_add_rec(env, cath, &lmr.lmr_hdr, NULL, NULL);
+               if (rc) {
+                       CERROR("4d: write %d records failed at #%d: %d\n",
+                              LLOG_TEST_RECNUM, i + 1, rc);
+                       GOTO(out, rc);
+               }
+               num_recs++;
+       }
+
+       /* make sure new plain llog appears */
+       rc = verify_handle("4d", cath, 3);
+       if (rc)
+               GOTO(out, rc);
+
+       CWARN("4e: add 5 large records, one record per block\n");
+       buflen = LLOG_CHUNK_SIZE - sizeof(struct llog_rec_hdr) -
+                sizeof(struct llog_rec_tail);
+       OBD_ALLOC(buf, buflen);
+       if (buf == NULL)
+               GOTO(out, rc = -ENOMEM);
+       for (i = 0; i < 5; i++) {
+               rec.lrh_len = buflen;
+               rec.lrh_type = OBD_CFG_REC;
+               rc = llog_cat_add_rec(env, cath, &rec, NULL, buf);
+               if (rc) {
+                       CERROR("4e: write 5 records failed at #%d: %d\n",
+                              i + 1, rc);
+                       GOTO(out_free, rc);
+               }
+               num_recs++;
+       }
+out_free:
+       OBD_FREE(buf, buflen);
+out:
+       CWARN("4f: put newly-created catalog\n");
+       rc2 = llog_cat_close(env, cath);
+       if (rc2) {
+               CERROR("4: close log %s failed: %d\n", name, rc2);
+               if (rc == 0)
+                       rc = rc2;
+       }

 ctxt_release:
 ctxt_release:

-        llog_ctxt_put(ctxt);
-        if (rc)
-                CERROR("1b: close log %s failed: %d\n", name, rc);
-        RETURN(rc);
+       llog_ctxt_put(ctxt);
+       RETURN(rc);

 }
 
 }
 

+static int cat_counter;
+

 static int cat_print_cb(const struct lu_env *env, struct llog_handle *llh,
                        struct llog_rec_hdr *rec, void *data)
 {
 static int cat_print_cb(const struct lu_env *env, struct llog_handle *llh,
                        struct llog_rec_hdr *rec, void *data)
 {

-        struct llog_logid_rec *lir = (struct llog_logid_rec *)rec;
+       struct llog_logid_rec   *lir = (struct llog_logid_rec *)rec;

 
 

-        if (rec->lrh_type != LLOG_LOGID_MAGIC) {
-                CERROR("invalid record in catalog\n");
-                RETURN(-EINVAL);
-        }
+       if (rec->lrh_type != LLOG_LOGID_MAGIC) {
+               CERROR("invalid record in catalog\n");
+               RETURN(-EINVAL);
+       }

 
 

-        CWARN("seeing record at index %d - "LPX64":%x in log "LPX64"\n",
-               rec->lrh_index, lir->lid_id.lgl_oid,
-               lir->lid_id.lgl_ogen, llh->lgh_id.lgl_oid);
-        RETURN(0);
+       CWARN("seeing record at index %d - "LPX64":%x in log "LPX64"\n",
+             rec->lrh_index, lir->lid_id.lgl_oid,
+             lir->lid_id.lgl_ogen, llh->lgh_id.lgl_oid);
+
+       cat_counter++;
+
+       RETURN(0);

 }
 
 }
 

+static int plain_counter;
+

 static int plain_print_cb(const struct lu_env *env, struct llog_handle *llh,
                          struct llog_rec_hdr *rec, void *data)
 {
 static int plain_print_cb(const struct lu_env *env, struct llog_handle *llh,
                          struct llog_rec_hdr *rec, void *data)
 {

-        if (!(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN)) {
-                CERROR("log is not plain\n");
-                RETURN(-EINVAL);
-        }
+       if (!(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN)) {
+               CERROR("log is not plain\n");
+               RETURN(-EINVAL);
+       }

 
 

-        CWARN("seeing record at index %d in log "LPX64"\n",
-               rec->lrh_index, llh->lgh_id.lgl_oid);
-        RETURN(0);
+       CDEBUG(D_INFO, "seeing record at index %d in log "LPX64"\n",
+             rec->lrh_index, llh->lgh_id.lgl_oid);
+
+       plain_counter++;
+
+       RETURN(0);

 }
 
 }
 

+static int cancel_count;
+

 static int llog_cancel_rec_cb(const struct lu_env *env,
                              struct llog_handle *llh,
                              struct llog_rec_hdr *rec, void *data)
 {
 static int llog_cancel_rec_cb(const struct lu_env *env,
                              struct llog_handle *llh,
                              struct llog_rec_hdr *rec, void *data)
 {

-        struct llog_cookie cookie;
-        static int i = 0;
+       struct llog_cookie cookie;

 
 

-        if (!(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN)) {
-                CERROR("log is not plain\n");
-                RETURN(-EINVAL);
-        }
+       if (!(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN)) {
+               CERROR("log is not plain\n");
+               RETURN(-EINVAL);
+       }

 
 

-        cookie.lgc_lgl = llh->lgh_id;
-        cookie.lgc_index = rec->lrh_index;
+       cookie.lgc_lgl = llh->lgh_id;
+       cookie.lgc_index = rec->lrh_index;

 
 

-       llog_cat_cancel_records(NULL, llh->u.phd.phd_cat_handle, 1, &cookie);
-        i++;
-        if (i == 40000)
-                RETURN(-4711);
-        RETURN(0);
+       llog_cat_cancel_records(env, llh->u.phd.phd_cat_handle, 1, &cookie);
+       cancel_count++;
+       if (cancel_count == LLOG_TEST_RECNUM)
+               RETURN(-LLOG_EEMPTY);
+       RETURN(0);

 }
 
 /* Test log and catalogue processing */
 }
 
 /* Test log and catalogue processing */

-static int llog_test_5(struct obd_device *obd)
+static int llog_test_5(const struct lu_env *env, struct obd_device *obd)

 {
 {

-        struct llog_handle *llh = NULL;
-        char name[10];
-        int rc;
-        struct llog_mini_rec lmr;
-        struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
-
-        ENTRY;
+       struct llog_handle      *llh = NULL;
+       char                     name[10];
+       int                      rc, rc2;
+       struct llog_mini_rec     lmr;
+       struct llog_ctxt        *ctxt;
+
+       ENTRY;
+
+       ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
+       LASSERT(ctxt);
+
+       lmr.lmr_hdr.lrh_len = lmr.lmr_tail.lrt_len = LLOG_MIN_REC_SIZE;
+       lmr.lmr_hdr.lrh_type = 0xf00f00;
+
+       CWARN("5a: re-open catalog by id\n");
+       rc = llog_open(env, ctxt, &llh, &cat_logid, NULL, LLOG_OPEN_EXISTS);
+       if (rc) {
+               CERROR("5a: llog_create with logid failed: %d\n", rc);
+               GOTO(out_put, rc);
+       }
+
+       llog_init_handle(env, llh, LLOG_F_IS_CAT, &uuid);
+       if (rc) {
+               CERROR("5a: can't init llog handle: %d\n", rc);
+               GOTO(out, rc);
+       }
+
+       /* XXX: depends on tests 4 which is not working yet */
+       GOTO(out, rc);
+
+       CWARN("5b: print the catalog entries.. we expect 2\n");
+       cat_counter = 0;
+       rc = llog_process(env, llh, cat_print_cb, "test 5", NULL);
+       if (rc) {
+               CERROR("5b: process with cat_print_cb failed: %d\n", rc);
+               GOTO(out, rc);
+       }
+       if (cat_counter != 2) {
+               CERROR("5b: %d entries in catalog\n", cat_counter);
+               GOTO(out, rc = -EINVAL);
+       }
+
+       CWARN("5c: Cancel %d records, see one log zapped\n", LLOG_TEST_RECNUM);
+       cancel_count = 0;
+       rc = llog_cat_process(env, llh, llog_cancel_rec_cb, "foobar", 0, 0);
+       if (rc != -LLOG_EEMPTY) {
+               CERROR("5c: process with cat_cancel_cb failed: %d\n", rc);
+               GOTO(out, rc);
+       }
+
+       CWARN("5c: print the catalog entries.. we expect 1\n");
+       cat_counter = 0;
+       rc = llog_process(env, llh, cat_print_cb, "test 5", NULL);
+       if (rc) {
+               CERROR("5c: process with cat_print_cb failed: %d\n", rc);
+               GOTO(out, rc);
+       }
+       if (cat_counter != 1) {
+               CERROR("5c: %d entries in catalog\n", cat_counter);
+               GOTO(out, rc = -EINVAL);
+       }
+
+       CWARN("5d: add 1 record to the log with many canceled empty pages\n");
+       rc = llog_cat_add_rec(env, llh, &lmr.lmr_hdr, NULL, NULL);
+       if (rc) {
+               CERROR("5d: add record to the log with many canceled empty "
+                      "pages failed\n");
+               GOTO(out, rc);
+       }
+
+       CWARN("5e: print plain log entries.. expect 6\n");
+       plain_counter = 0;
+       rc = llog_cat_process(env, llh, plain_print_cb, "foobar", 0, 0);
+       if (rc) {
+               CERROR("5e: process with plain_print_cb failed: %d\n", rc);
+               GOTO(out, rc);
+       }
+       if (plain_counter != 6) {
+               CERROR("5e: found %d records\n", plain_counter);
+               GOTO(out, rc = -EINVAL);
+       }
+
+       CWARN("5f: print plain log entries reversely.. expect 6\n");
+       plain_counter = 0;
+       rc = llog_cat_reverse_process(env, llh, plain_print_cb, "foobar");
+       if (rc) {
+               CERROR("5f: reversely process with plain_print_cb failed:"
+                      "%d\n", rc);
+               GOTO(out, rc);
+       }
+       if (plain_counter != 6) {
+               CERROR("5f: found %d records\n", plain_counter);
+               GOTO(out, rc = -EINVAL);
+       }

 
 

-        lmr.lmr_hdr.lrh_len = lmr.lmr_tail.lrt_len = LLOG_MIN_REC_SIZE;
-        lmr.lmr_hdr.lrh_type = 0xf00f00;
-
-        CWARN("5a: re-open catalog by id\n");
-       rc = llog_open(NULL, ctxt, &llh, &cat_logid, NULL, LLOG_OPEN_EXISTS);
-        if (rc) {
-                CERROR("5a: llog_create with logid failed: %d\n", rc);
-                GOTO(out, rc);
-        }
-       llog_init_handle(NULL, llh, LLOG_F_IS_CAT, &uuid);
-
-        CWARN("5b: print the catalog entries.. we expect 2\n");
-       rc = llog_process(NULL, llh, cat_print_cb, "test 5", NULL);
-        if (rc) {
-                CERROR("5b: process with cat_print_cb failed: %d\n", rc);
-                GOTO(out, rc);
-        }
-
-        CWARN("5c: Cancel 40000 records, see one log zapped\n");
-       rc = llog_cat_process(NULL, llh, llog_cancel_rec_cb, "foobar", 0, 0);
-        if (rc != -4711) {
-                CERROR("5c: process with cat_cancel_cb failed: %d\n", rc);
-                GOTO(out, rc);
-        }
-
-        CWARN("5d: add 1 record to the log with many canceled empty pages\n");
-       rc = llog_cat_add_rec(NULL, llh, &lmr.lmr_hdr, NULL, NULL);
-        if (rc) {
-                CERROR("5d: add record to the log with many canceled empty\
-                       pages failed\n");
-                GOTO(out, rc);
-        }
-
-        CWARN("5b: print the catalog entries.. we expect 1\n");
-       rc = llog_process(NULL, llh, cat_print_cb, "test 5", NULL);
-        if (rc) {
-                CERROR("5b: process with cat_print_cb failed: %d\n", rc);
-                GOTO(out, rc);
-        }
-
-        CWARN("5e: print plain log entries.. expect 6\n");
-       rc = llog_cat_process(NULL, llh, plain_print_cb, "foobar", 0, 0);
-        if (rc) {
-                CERROR("5e: process with plain_print_cb failed: %d\n", rc);
-                GOTO(out, rc);
-        }
-
-        CWARN("5f: print plain log entries reversely.. expect 6\n");
-       rc = llog_cat_reverse_process(NULL, llh, plain_print_cb, "foobar");
-        if (rc) {
-                CERROR("5f: reversely process with plain_print_cb failed: %d\n", rc);
-                GOTO(out, rc);
-        }
-
- out:
-        CWARN("5: close re-opened catalog\n");
-        if (llh)
-               rc = llog_cat_close(NULL, llh);
-        if (rc)
-                CERROR("1b: close log %s failed: %d\n", name, rc);
-        llog_ctxt_put(ctxt);
-
-        RETURN(rc);
+out:
+       CWARN("5g: close re-opened catalog\n");
+       rc2 = llog_cat_close(env, llh);
+       if (rc2) {
+               CERROR("5g: close log %s failed: %d\n", name, rc2);
+               if (rc == 0)
+                       rc = rc2;
+       }
+out_put:
+       llog_ctxt_put(ctxt);
+
+       RETURN(rc);

 }
 
 /* Test client api; open log by name and process */
 }
 
 /* Test client api; open log by name and process */

-static int llog_test_6(struct obd_device *obd, char *name)
+static int llog_test_6(const struct lu_env *env, struct obd_device *obd,
+                      char *name)

 {
 {

-        struct obd_device *mgc_obd;
-        struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
-        struct obd_uuid *mgs_uuid = &ctxt->loc_exp->exp_obd->obd_uuid;
-        struct obd_export *exp;
-        struct obd_uuid uuid = {"LLOG_TEST6_UUID"};
-        struct llog_handle *llh = NULL;
-        struct llog_ctxt *nctxt;
-        int rc;
-
-        CWARN("6a: re-open log %s using client API\n", name);
-        mgc_obd = class_find_client_obd(mgs_uuid, LUSTRE_MGC_NAME, NULL);
-        if (mgc_obd == NULL) {
-                CERROR("6: no MGC devices connected to %s found.\n",
-                       mgs_uuid->uuid);
-                GOTO(ctxt_release, rc = -ENOENT);
-        }
-
-        rc = obd_connect(NULL, &exp, mgc_obd, &uuid,
-                         NULL /* obd_connect_data */, NULL);
-        if (rc != -EALREADY) {
-                CERROR("6: connect on connected MDC (%s) failed to return"
-                       " -EALREADY", mgc_obd->obd_name);
-                if (rc == 0)
-                        obd_disconnect(exp);
-                GOTO(ctxt_release, rc = -EINVAL);
-        }
-
-        nctxt = llog_get_context(mgc_obd, LLOG_CONFIG_REPL_CTXT);
-       rc = llog_open(NULL, nctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
-        if (rc) {
-                CERROR("6: llog_create failed %d\n", rc);
-                llog_ctxt_put(nctxt);
-                GOTO(ctxt_release, rc);
-        }
-
-       rc = llog_init_handle(NULL, llh, LLOG_F_IS_PLAIN, NULL);
-        if (rc) {
-                CERROR("6: llog_init_handle failed %d\n", rc);
-                GOTO(parse_out, rc);
-        }
-
-       rc = llog_process(NULL, llh, plain_print_cb, NULL, NULL);
-        if (rc)
-                CERROR("6: llog_process failed %d\n", rc);
-
-       rc = llog_reverse_process(NULL, llh, plain_print_cb, NULL, NULL);
-        if (rc)
-                CERROR("6: llog_reverse_process failed %d\n", rc);
+       struct obd_device       *mgc_obd;
+       struct llog_ctxt        *ctxt;
+       struct obd_uuid         *mgs_uuid;
+       struct obd_export       *exp;
+       struct obd_uuid          uuid = { "LLOG_TEST6_UUID" };
+       struct llog_handle      *llh = NULL;
+       struct llog_ctxt        *nctxt;
+       int                      rc, rc2;
+
+       ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
+       LASSERT(ctxt);
+       mgs_uuid = &ctxt->loc_exp->exp_obd->obd_uuid;
+
+       CWARN("6a: re-open log %s using client API\n", name);
+       mgc_obd = class_find_client_obd(mgs_uuid, LUSTRE_MGC_NAME, NULL);
+       if (mgc_obd == NULL) {
+               CERROR("6a: no MGC devices connected to %s found.\n",
+                      mgs_uuid->uuid);
+               GOTO(ctxt_release, rc = -ENOENT);
+       }
+
+       rc = obd_connect(NULL, &exp, mgc_obd, &uuid,
+                        NULL /* obd_connect_data */, NULL);
+       if (rc != -EALREADY) {
+               CERROR("6a: connect on connected MDC (%s) failed to return"
+                      " -EALREADY", mgc_obd->obd_name);
+               if (rc == 0)
+                       obd_disconnect(exp);
+               GOTO(ctxt_release, rc = -EINVAL);
+       }
+
+       nctxt = llog_get_context(mgc_obd, LLOG_CONFIG_REPL_CTXT);
+       rc = llog_open(env, nctxt, &llh, NULL, name, LLOG_OPEN_EXISTS);
+       if (rc) {
+               CERROR("6a: llog_open failed %d\n", rc);
+               GOTO(nctxt_put, rc);
+       }
+
+       rc = llog_init_handle(env, llh, LLOG_F_IS_PLAIN, NULL);
+       if (rc) {
+               CERROR("6a: llog_init_handle failed %d\n", rc);
+               GOTO(parse_out, rc);
+       }
+
+       plain_counter = 1; /* llog header is first record */
+       CWARN("6b: process log %s using client API\n", name);
+       rc = llog_process(env, llh, plain_print_cb, NULL, NULL);
+       if (rc)
+               CERROR("6b: llog_process failed %d\n", rc);
+       CWARN("6b: processed %d records\n", plain_counter);
+
+       rc = verify_handle("6b", llh, plain_counter);
+       if (rc)
+               GOTO(parse_out, rc);
+
+       plain_counter = 1; /* llog header is first record */
+       CWARN("6c: process log %s reversely using client API\n", name);
+       rc = llog_reverse_process(env, llh, plain_print_cb, NULL, NULL);
+       if (rc)
+               CERROR("6c: llog_reverse_process failed %d\n", rc);
+       CWARN("6c: processed %d records\n", plain_counter);
+
+       rc = verify_handle("6c", llh, plain_counter);
+       if (rc)
+               GOTO(parse_out, rc);

 
 parse_out:
 
 parse_out:

-       rc = llog_close(NULL, llh);
-        llog_ctxt_put(nctxt);
-        if (rc) {
-                CERROR("6: llog_close failed: rc = %d\n", rc);
-        }
+       rc2 = llog_close(env, llh);
+       if (rc2) {
+               CERROR("6: llog_close failed: rc = %d\n", rc2);
+               if (rc == 0)
+                       rc = rc2;
+       }
+nctxt_put:
+       llog_ctxt_put(nctxt);

 ctxt_release:
 ctxt_release:

-        llog_ctxt_put(ctxt);
-        RETURN(rc);
+       llog_ctxt_put(ctxt);
+       RETURN(rc);

 }
 
 }
 

-static int llog_test_7(struct obd_device *obd)
+static union {
+       struct llog_rec_hdr             lrh;   /* common header */
+       struct llog_logid_rec           llr;   /* LLOG_LOGID_MAGIC */
+       struct llog_unlink64_rec        lur;   /* MDS_UNLINK64_REC */
+       struct llog_setattr64_rec       lsr64; /* MDS_SETATTR64_REC */
+       struct llog_size_change_rec     lscr;  /* OST_SZ_REC */
+       struct llog_changelog_rec       lcr;   /* CHANGELOG_REC */
+       struct llog_changelog_user_rec  lcur;  /* CHANGELOG_USER_REC */
+       struct llog_gen_rec             lgr;   /* LLOG_GEN_REC */
+} llog_records;
+
+static int test_7_print_cb(const struct lu_env *env, struct llog_handle *llh,
+                          struct llog_rec_hdr *rec, void *data)

 {
 {

-        struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
-        struct llog_handle *llh;
-        struct llog_create_rec lcr;
-        char name[10];
-        int rc;
-        ENTRY;
+       struct lu_fid fid;

 
 

-        sprintf(name, "%x", llog_test_rand+2);
-        CWARN("7: create a log with name: %s\n", name);
-        LASSERT(ctxt);
+       logid_to_fid(&llh->lgh_id, &fid);

 
 

-       rc = llog_open_create(NULL, ctxt, &llh, NULL, name);
-        if (rc) {
-                CERROR("7: llog_create with name %s failed: %d\n", name, rc);
-                GOTO(ctxt_release, rc);
-        }
-       llog_init_handle(NULL, llh, LLOG_F_IS_PLAIN, &uuid);
-
-        lcr.lcr_hdr.lrh_len = lcr.lcr_tail.lrt_len = sizeof(lcr);
-        lcr.lcr_hdr.lrh_type = OST_SZ_REC;
-       rc = llog_write_rec(NULL, llh,  &lcr.lcr_hdr, NULL, 0, NULL, -1);
-        if (rc) {
-                CERROR("7: write one log record failed: %d\n", rc);
-                GOTO(ctxt_release, rc);
-        }
+       CDEBUG(D_OTHER, "record type %#x at index %d in log "DFID"\n",
+              rec->lrh_type, rec->lrh_index, PFID(&fid));

 
 

-       rc = llog_destroy(NULL, llh);
-        if (rc)
-                CERROR("7: llog_destroy failed: %d\n", rc);
-       llog_close(NULL, llh);
-ctxt_release:
-        llog_ctxt_put(ctxt);
-        RETURN(rc);
+       plain_counter++;
+       return 0;

 }
 
 }
 

-/* -------------------------------------------------------------------------
- * Tests above, boring obd functions below
- * ------------------------------------------------------------------------- */
-static int llog_run_tests(struct obd_device *obd)
+static int test_7_cancel_cb(const struct lu_env *env, struct llog_handle *llh,
+                           struct llog_rec_hdr *rec, void *data)

 {
 {

-        struct llog_handle *llh;
-        struct lvfs_run_ctxt saved;
-        struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
-        int rc, err, cleanup_phase = 0;
-        char name[10];
-        ENTRY;
-
-        sprintf(name, "%x", llog_test_rand);
-        push_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL);
-
-        rc = llog_test_1(obd, name);
-        if (rc)
-                GOTO(cleanup, rc);
-
-        rc = llog_test_2(obd, name, &llh);
-        if (rc)
-                GOTO(cleanup, rc);
-        cleanup_phase = 1; /* close llh */
-
-        rc = llog_test_3(obd, llh);
-        if (rc)
-                GOTO(cleanup, rc);
-
-        rc = llog_test_4(obd);
-        if (rc)
-                GOTO(cleanup, rc);
-
-        rc = llog_test_5(obd);
-        if (rc)
-                GOTO(cleanup, rc);
-
-        rc = llog_test_6(obd, name);
-        if (rc)
-                GOTO(cleanup, rc);
-
-        rc = llog_test_7(obd);
-        if (rc)
-                GOTO(cleanup, rc);
-
- cleanup:
-        switch (cleanup_phase) {
-        case 1:
-               err = llog_close(NULL, llh);
-                if (err)
-                        CERROR("cleanup: llog_close failed: %d\n", err);
-                if (!rc)
-                        rc = err;
-        case 0:
-                pop_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL);
-        }
-        llog_ctxt_put(ctxt);
-        return rc;
+       plain_counter++;
+       /* test LLOG_DEL_RECORD is working */
+       return LLOG_DEL_RECORD;

 }
 
 }
 

-static int llog_test_llog_init(struct obd_device *obd,
-                               struct obd_llog_group *olg,
-                               struct obd_device *tgt, int *index)
+static int llog_test_7_sub(const struct lu_env *env, struct llog_ctxt *ctxt)

 {
 {

-        int rc;
-        ENTRY;
-
-        rc = llog_setup(obd, &obd->obd_olg, LLOG_TEST_ORIG_CTXT, tgt, 0, NULL,
-                        &llog_lvfs_ops);
-        RETURN(rc);
+       struct llog_handle      *llh;
+       int                      rc = 0, i, process_count;
+       int                      num_recs = 0;
+
+       ENTRY;
+
+       rc = llog_open_create(env, ctxt, &llh, NULL, "llt_test7");
+       if (rc) {
+               CERROR("7_sub: create log failed\n");
+               RETURN(rc);
+       }
+
+       rc = llog_init_handle(env, llh,
+                             LLOG_F_IS_PLAIN | LLOG_F_ZAP_WHEN_EMPTY,
+                             &uuid);
+       if (rc) {
+               CERROR("7_sub: can't init llog handle: %d\n", rc);
+               GOTO(out_close, rc);
+       }
+       for (i = 0; i < LLOG_BITMAP_SIZE(llh->lgh_hdr); i++) {
+               rc = llog_write_rec(env, llh, &llog_records.lrh, NULL, 0,
+                                   NULL, -1);
+               if (rc == -ENOSPC) {
+                       break;
+               } else if (rc < 0) {
+                       CERROR("7_sub: write recs failed at #%d: %d\n",
+                              i + 1, rc);
+                       GOTO(out_close, rc);
+               }
+               num_recs++;
+       }
+       if (rc != -ENOSPC) {
+               CWARN("7_sub: write record more than BITMAP size!\n");
+               GOTO(out_close, rc = -EINVAL);
+       }
+
+       rc = verify_handle("7_sub", llh, num_recs + 1);
+       if (rc) {
+               CERROR("7_sub: verify handle failed: %d\n", rc);
+               GOTO(out_close, rc);
+       }
+       if (num_recs < LLOG_BITMAP_SIZE(llh->lgh_hdr) - 1)
+               CWARN("7_sub: records are not aligned, written %d from %u\n",
+                     num_recs, LLOG_BITMAP_SIZE(llh->lgh_hdr) - 1);
+
+       plain_counter = 0;
+       rc = llog_process(env, llh, test_7_print_cb, "test 7", NULL);
+       if (rc) {
+               CERROR("7_sub: llog process failed: %d\n", rc);
+               GOTO(out_close, rc);
+       }
+       process_count = plain_counter;
+       if (process_count != num_recs) {
+               CERROR("7_sub: processed %d records from %d total\n",
+                      process_count, num_recs);
+               GOTO(out_close, rc = -EINVAL);
+       }
+
+       plain_counter = 0;
+       rc = llog_reverse_process(env, llh, test_7_cancel_cb, "test 7", NULL);
+       if (rc) {
+               CERROR("7_sub: reverse llog process failed: %d\n", rc);
+               GOTO(out_close, rc);
+       }
+       if (process_count != plain_counter) {
+               CERROR("7_sub: Reverse/direct processing found different"
+                      "number of records: %d/%d\n",
+                      plain_counter, process_count);
+               GOTO(out_close, rc = -EINVAL);
+       }
+       if (llog_exist(llh)) {
+               CERROR("7_sub: llog exists but should be zapped\n");
+               GOTO(out_close, rc = -EEXIST);
+       }
+
+       rc = verify_handle("7_sub", llh, 1);
+out_close:
+       if (rc)
+               llog_destroy(env, llh);
+       llog_close(env, llh);
+       RETURN(rc);

 }
 
 }
 

-static int llog_test_llog_finish(struct obd_device *obd, int count)
+/* Test all llog records writing and processing */
+static int llog_test_7(const struct lu_env *env, struct obd_device *obd)

 {
 {

-        int rc;
-        ENTRY;
+       struct llog_ctxt        *ctxt;
+       int                      rc;
+
+       ENTRY;
+
+       ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
+
+       CWARN("7a: test llog_logid_rec\n");
+       llog_records.llr.lid_hdr.lrh_len = sizeof(llog_records.llr);
+       llog_records.llr.lid_tail.lrt_len = sizeof(llog_records.llr);
+       llog_records.llr.lid_hdr.lrh_type = LLOG_LOGID_MAGIC;
+
+       rc = llog_test_7_sub(env, ctxt);
+       if (rc) {
+               CERROR("7a: llog_logid_rec test failed\n");
+               GOTO(out, rc);
+       }
+
+       CWARN("7b: test llog_unlink64_rec\n");
+       llog_records.lur.lur_hdr.lrh_len = sizeof(llog_records.lur);
+       llog_records.lur.lur_tail.lrt_len = sizeof(llog_records.lur);
+       llog_records.lur.lur_hdr.lrh_type = MDS_UNLINK64_REC;
+
+       rc = llog_test_7_sub(env, ctxt);
+       if (rc) {
+               CERROR("7b: llog_unlink_rec test failed\n");
+               GOTO(out, rc);
+       }
+
+       CWARN("7c: test llog_setattr64_rec\n");
+       llog_records.lsr64.lsr_hdr.lrh_len = sizeof(llog_records.lsr64);
+       llog_records.lsr64.lsr_tail.lrt_len = sizeof(llog_records.lsr64);
+       llog_records.lsr64.lsr_hdr.lrh_type = MDS_SETATTR64_REC;
+
+       rc = llog_test_7_sub(env, ctxt);
+       if (rc) {
+               CERROR("7c: llog_setattr64_rec test failed\n");
+               GOTO(out, rc);
+       }
+
+       CWARN("7d: test llog_size_change_rec\n");
+       llog_records.lscr.lsc_hdr.lrh_len = sizeof(llog_records.lscr);
+       llog_records.lscr.lsc_tail.lrt_len = sizeof(llog_records.lscr);
+       llog_records.lscr.lsc_hdr.lrh_type = OST_SZ_REC;
+
+       rc = llog_test_7_sub(env, ctxt);
+       if (rc) {
+               CERROR("7d: llog_size_change_rec test failed\n");
+               GOTO(out, rc);
+       }
+
+       CWARN("7e: test llog_changelog_rec\n");
+       llog_records.lcr.cr_hdr.lrh_len = sizeof(llog_records.lcr);
+       llog_records.lcr.cr_tail.lrt_len = sizeof(llog_records.lcr);
+       llog_records.lcr.cr_hdr.lrh_type = CHANGELOG_REC;
+
+       rc = llog_test_7_sub(env, ctxt);
+       if (rc) {
+               CERROR("7e: llog_changelog_rec test failed\n");
+               GOTO(out, rc);
+       }
+
+       CWARN("7f: test llog_changelog_user_rec\n");
+       llog_records.lcur.cur_hdr.lrh_len = sizeof(llog_records.lcur);
+       llog_records.lcur.cur_tail.lrt_len = sizeof(llog_records.lcur);
+       llog_records.lcur.cur_hdr.lrh_type = CHANGELOG_USER_REC;
+
+       rc = llog_test_7_sub(env, ctxt);
+       if (rc) {
+               CERROR("7f: llog_changelog_user_rec test failed\n");
+               GOTO(out, rc);
+       }
+
+       CWARN("7g: test llog_gen_rec\n");
+       llog_records.lgr.lgr_hdr.lrh_len = sizeof(llog_records.lgr);
+       llog_records.lgr.lgr_tail.lrt_len = sizeof(llog_records.lgr);
+       llog_records.lgr.lgr_hdr.lrh_type = LLOG_GEN_REC;
+
+       rc = llog_test_7_sub(env, ctxt);
+       if (rc) {
+               CERROR("7g: llog_size_change_rec test failed\n");
+               GOTO(out, rc);
+       }
+out:
+       llog_ctxt_put(ctxt);
+       RETURN(rc);
+}

 
 

-        rc = llog_cleanup(llog_get_context(obd, LLOG_TEST_ORIG_CTXT));
-        RETURN(rc);
+/* -------------------------------------------------------------------------
+ * Tests above, boring obd functions below
+ * ------------------------------------------------------------------------- */
+static int llog_run_tests(const struct lu_env *env, struct obd_device *obd)
+{
+       struct llog_handle      *llh = NULL;
+       struct lvfs_run_ctxt     saved;
+       struct llog_ctxt        *ctxt;
+       int                      rc, err;
+       char                     name[10];
+
+       ENTRY;
+       ctxt = llog_get_context(obd, LLOG_TEST_ORIG_CTXT);
+       LASSERT(ctxt);
+
+       sprintf(name, "%x", llog_test_rand);
+       push_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL);
+
+       rc = llog_test_1(env, obd, name);
+       if (rc)
+               GOTO(cleanup_ctxt, rc);
+
+       rc = llog_test_2(env, obd, name, &llh);
+       if (rc)
+               GOTO(cleanup_ctxt, rc);
+
+       rc = llog_test_3(env, obd, llh);
+       if (rc)
+               GOTO(cleanup, rc);
+
+       rc = llog_test_4(env, obd);
+       if (rc)
+               GOTO(cleanup, rc);
+
+       rc = llog_test_5(env, obd);
+       if (rc)
+               GOTO(cleanup, rc);
+
+       rc = llog_test_6(env, obd, name);
+       if (rc)
+               GOTO(cleanup, rc);
+
+       rc = llog_test_7(env, obd);
+       if (rc)
+               GOTO(cleanup, rc);
+
+cleanup:
+       err = llog_destroy(env, llh);
+       if (err)
+               CERROR("cleanup: llog_destroy failed: %d\n", err);
+       llog_close(env, llh);
+       if (rc == 0)
+               rc = err;
+cleanup_ctxt:
+       pop_ctxt(&saved, &ctxt->loc_exp->exp_obd->obd_lvfs_ctxt, NULL);
+       llog_ctxt_put(ctxt);
+       return rc;

 }
 }

+

 #ifdef LPROCFS
 static struct lprocfs_vars lprocfs_llog_test_obd_vars[] = { {0} };
 static struct lprocfs_vars lprocfs_llog_test_module_vars[] = { {0} };
 #ifdef LPROCFS
 static struct lprocfs_vars lprocfs_llog_test_obd_vars[] = { {0} };
 static struct lprocfs_vars lprocfs_llog_test_module_vars[] = { {0} };


@@ -685,20 +973,20 @@ static void lprocfs_llog_test_init_vars(struct lprocfs_static_vars *lvars)
 
 static int llog_test_cleanup(struct obd_device *obd)
 {
 
 static int llog_test_cleanup(struct obd_device *obd)
 {

-        int rc = obd_llog_finish(obd, 0);
-        if (rc)
-                CERROR("failed to llog_test_llog_finish: %d\n", rc);
-
-        lprocfs_obd_cleanup(obd);
+       int rc;

 
 

-        return rc;
+       rc = llog_cleanup(llog_get_context(obd, LLOG_TEST_ORIG_CTXT));
+       if (rc)
+               CERROR("failed to llog_test_llog_finish: %d\n", rc);
+       return rc;

 }
 
 static int llog_test_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
 {
 }
 
 static int llog_test_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
 {

-        struct lprocfs_static_vars lvars;

         struct obd_device *tgt;
         struct obd_device *tgt;

+       struct lu_env env;

         int rc;
         int rc;

+

         ENTRY;
 
         if (lcfg->lcfg_bufcount < 2) {
         ENTRY;
 
         if (lcfg->lcfg_bufcount < 2) {


@@ -719,42 +1007,46 @@ static int llog_test_setup(struct obd_device *obd, struct lustre_cfg *lcfg)
                 RETURN(-EINVAL);
         }
 
                 RETURN(-EINVAL);
         }
 

-        rc = obd_llog_init(obd, NULL, tgt, NULL);
-        if (rc)
-                RETURN(rc);
+       rc = lu_env_init(&env, LCT_LOCAL | LCT_MG_THREAD);
+       if (rc)
+               RETURN(rc);

 
 

-        llog_test_rand = cfs_rand();
+       CWARN("Setup llog-test device over %s device\n",
+             lustre_cfg_string(lcfg, 1));

 
 

-        rc = llog_run_tests(obd);
-        if (rc)
-                llog_test_cleanup(obd);
+       rc = llog_setup(obd, &obd->obd_olg, LLOG_TEST_ORIG_CTXT, tgt, 0, NULL,
+                       &llog_lvfs_ops);
+       if (rc)
+               GOTO(cleanup_env, rc);

 
 

-        lprocfs_llog_test_init_vars(&lvars);
-        lprocfs_obd_setup(obd, lvars.obd_vars);
+       llog_test_rand = cfs_rand();

 
 

-        RETURN(rc);
+       rc = llog_run_tests(&env, obd);
+       if (rc)
+               llog_test_cleanup(obd);
+cleanup_env:
+       lu_env_fini(&env);
+       RETURN(rc);

 }
 
 static struct obd_ops llog_obd_ops = {
         .o_owner       = THIS_MODULE,
         .o_setup       = llog_test_setup,
         .o_cleanup     = llog_test_cleanup,
 }
 
 static struct obd_ops llog_obd_ops = {
         .o_owner       = THIS_MODULE,
         .o_setup       = llog_test_setup,
         .o_cleanup     = llog_test_cleanup,

-        .o_llog_init   = llog_test_llog_init,
-        .o_llog_finish = llog_test_llog_finish,

 };
 
 static int __init llog_test_init(void)
 {
 };
 
 static int __init llog_test_init(void)
 {

-        struct lprocfs_static_vars lvars;
+       struct lprocfs_static_vars lvars;

 
 

-        lprocfs_llog_test_init_vars(&lvars);
-        return class_register_type(&llog_obd_ops, NULL,
-                                   lvars.module_vars,"llog_test", NULL);
+       lprocfs_llog_test_init_vars(&lvars);
+       return class_register_type(&llog_obd_ops, NULL,
+                                  lvars.module_vars, "llog_test", NULL);

 }
 
 static void __exit llog_test_exit(void)
 {
 }
 
 static void __exit llog_test_exit(void)
 {

-        class_unregister_type("llog_test");
+       class_unregister_type("llog_test");

 }
 
 MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
 }
 
 MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");

diff --git a/lustre/obdclass/obd_config.c b/lustre/obdclass/obd_config.c
index 54984f5..96460bb 100644 (file)
--- a/lustre/obdclass/obd_config.c
+++ b/lustre/obdclass/obd_config.c
@@ -48,6 +48,8 @@
 #include <obd_class.h>
 #include <obd.h>
 #endif
 #include <obd_class.h>
 #include <obd.h>
 #endif

+#include <lustre_log.h>
+#include <lprocfs_status.h>

 #include <lustre_param.h>
 
 #include "llog_internal.h"
 #include <lustre_param.h>
 
 #include "llog_internal.h"

diff --git a/lustre/ptlrpc/wiretest.c b/lustre/ptlrpc/wiretest.c
index 1501413..c39eea5 100644 (file)
--- a/lustre/ptlrpc/wiretest.c
+++ b/lustre/ptlrpc/wiretest.c
@@ -3119,77 +3119,17 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding1));
         LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding2) == 40, "found %lld\n",
                  (long long)(int)offsetof(struct llog_logid_rec, lid_padding2));
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding1));
         LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding2) == 40, "found %lld\n",
                  (long long)(int)offsetof(struct llog_logid_rec, lid_padding2));

-        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding2) == 4, "found %lld\n",
+        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding2) == 8, "found %lld\n",

                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding2));
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding2));

-        LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding3) == 44, "found %lld\n",
+        LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding3) == 48, "found %lld\n",

                  (long long)(int)offsetof(struct llog_logid_rec, lid_padding3));
                  (long long)(int)offsetof(struct llog_logid_rec, lid_padding3));

-        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding3) == 4, "found %lld\n",
+        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding3) == 8, "found %lld\n",

                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding3));
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding3));

-        LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding4) == 48, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_logid_rec, lid_padding4));
-        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding4) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding4));
-        LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding5) == 52, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_logid_rec, lid_padding5));
-        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding5) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding5));

         LASSERTF((int)offsetof(struct llog_logid_rec, lid_tail) == 56, "found %lld\n",
                  (long long)(int)offsetof(struct llog_logid_rec, lid_tail));
         LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_tail));
 
         LASSERTF((int)offsetof(struct llog_logid_rec, lid_tail) == 56, "found %lld\n",
                  (long long)(int)offsetof(struct llog_logid_rec, lid_tail));
         LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_tail));
 

-        /* Checks for struct llog_create_rec */
-        LASSERTF((int)sizeof(struct llog_create_rec) == 56, "found %lld\n",
-                 (long long)(int)sizeof(struct llog_create_rec));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_hdr) == 0, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_hdr));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_hdr) == 16, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_hdr));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_fid) == 16, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_fid));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_fid) == 16, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_fid));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_oid) == 32, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_oid));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_oid) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_oid));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_oseq) == 40, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_oseq));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_oseq) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_oseq));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_padding) == 44, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_padding));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_padding) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_padding));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_tail) == 48, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_tail));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_tail) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_tail));
-
-        /* Checks for struct llog_orphan_rec */
-        LASSERTF((int)sizeof(struct llog_orphan_rec) == 40, "found %lld\n",
-                 (long long)(int)sizeof(struct llog_orphan_rec));
-        LASSERTF((int)offsetof(struct llog_orphan_rec, lor_hdr) == 0, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_orphan_rec, lor_hdr));
-        LASSERTF((int)sizeof(((struct llog_orphan_rec *)0)->lor_hdr) == 16, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_orphan_rec *)0)->lor_hdr));
-        LASSERTF((int)offsetof(struct llog_orphan_rec, lor_oid) == 16, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_orphan_rec, lor_oid));
-        LASSERTF((int)sizeof(((struct llog_orphan_rec *)0)->lor_oid) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_orphan_rec *)0)->lor_oid));
-        LASSERTF((int)offsetof(struct llog_orphan_rec, lor_ogen) == 24, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_orphan_rec, lor_ogen));
-        LASSERTF((int)sizeof(((struct llog_orphan_rec *)0)->lor_ogen) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_orphan_rec *)0)->lor_ogen));
-        LASSERTF((int)offsetof(struct llog_orphan_rec, lor_padding) == 28, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_orphan_rec, lor_padding));
-        LASSERTF((int)sizeof(((struct llog_orphan_rec *)0)->lor_padding) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_orphan_rec *)0)->lor_padding));
-        LASSERTF((int)offsetof(struct llog_orphan_rec, lor_tail) == 32, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_orphan_rec, lor_tail));
-        LASSERTF((int)sizeof(((struct llog_orphan_rec *)0)->lor_tail) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_orphan_rec *)0)->lor_tail));
-

         /* Checks for struct llog_unlink_rec */
         LASSERTF((int)sizeof(struct llog_unlink_rec) == 40, "found %lld\n",
                  (long long)(int)sizeof(struct llog_unlink_rec));
         /* Checks for struct llog_unlink_rec */
         LASSERTF((int)sizeof(struct llog_unlink_rec) == 40, "found %lld\n",
                  (long long)(int)sizeof(struct llog_unlink_rec));


@@ -3213,41 +3153,40 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)offsetof(struct llog_unlink_rec, lur_tail));
         LASSERTF((int)sizeof(((struct llog_unlink_rec *)0)->lur_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_unlink_rec *)0)->lur_tail));
                  (long long)(int)offsetof(struct llog_unlink_rec, lur_tail));
         LASSERTF((int)sizeof(((struct llog_unlink_rec *)0)->lur_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_unlink_rec *)0)->lur_tail));

-
-        /* Checks for struct llog_setattr_rec */
-        LASSERTF((int)sizeof(struct llog_setattr_rec) == 48, "found %lld\n",
-                 (long long)(int)sizeof(struct llog_setattr_rec));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_hdr) == 0, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_hdr));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_hdr) == 16, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_hdr));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_oid) == 16, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_oid));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_oid) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_oid));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_oseq) == 24, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_oseq));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_oseq) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_oseq));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_uid) == 28, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_uid));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_uid) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_uid));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_gid) == 32, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_gid));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_gid) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_gid));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_padding) == 36, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_padding));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_padding) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_padding));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_tail) == 40, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_tail));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_tail) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_tail));
+        /* Checks for struct llog_unlink64_rec */
+        LASSERTF((int)sizeof(struct llog_unlink64_rec) == 64, "found %lld\n",
+                 (long long)(int)sizeof(struct llog_unlink64_rec));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_hdr) == 0, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_hdr));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_hdr) == 16, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_hdr));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_fid) == 16, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_fid));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_fid) == 16, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_fid));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_count) == 32, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_count));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_count) == 4, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_count));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_tail) == 56, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_tail));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_tail) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_tail));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_padding1) == 36, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_padding1));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding1) == 4, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding1));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_padding2) == 40, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_padding2));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding2) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding2));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_padding3) == 48, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_padding3));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding3) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding3));

 
         /* Checks for struct llog_setattr64_rec */
 
         /* Checks for struct llog_setattr64_rec */

-        LASSERTF((int)sizeof(struct llog_setattr64_rec) == 56, "found %lld\n",
+        LASSERTF((int)sizeof(struct llog_setattr64_rec) == 64, "found %lld\n",

                  (long long)(int)sizeof(struct llog_setattr64_rec));
         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_hdr));
                  (long long)(int)sizeof(struct llog_setattr64_rec));
         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_hdr));


@@ -3259,12 +3198,8 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oid));
         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_oseq) == 24, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_oseq));
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oid));
         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_oseq) == 24, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_oseq));

-        LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oseq) == 4, "found %lld\n",
+        LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oseq) == 8, "found %lld\n",

                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oseq));
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oseq));

-        LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_padding) == 28, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr64_rec, lsr_padding));
-        LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_padding) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_padding));

         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_uid) == 32, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_uid));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_uid) == 4, "found %lld\n",
         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_uid) == 32, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_uid));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_uid) == 4, "found %lld\n",


@@ -3281,13 +3216,17 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_gid_h));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_gid_h) == 4, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_gid_h));
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_gid_h));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_gid_h) == 4, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_gid_h));

-        LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_tail) == 48, "found %lld\n",
+        LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_padding) == 48, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_setattr64_rec, lsr_padding));
+        LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_padding) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_padding));
+        LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_tail) == 56, "found %lld\n",

                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_tail));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_tail));
 
         /* Checks for struct llog_size_change_rec */
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_tail));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_tail));
 
         /* Checks for struct llog_size_change_rec */

-        LASSERTF((int)sizeof(struct llog_size_change_rec) == 48, "found %lld\n",
+        LASSERTF((int)sizeof(struct llog_size_change_rec) == 64, "found %lld\n",

                  (long long)(int)sizeof(struct llog_size_change_rec));
         LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_hdr));
                  (long long)(int)sizeof(struct llog_size_change_rec));
         LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_hdr));


@@ -3301,11 +3240,19 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_ioepoch));
         LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_ioepoch) == 4, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_ioepoch));
                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_ioepoch));
         LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_ioepoch) == 4, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_ioepoch));

-        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_padding) == 36, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_size_change_rec, lsc_padding));
-        LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding));
-        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_tail) == 40, "found %lld\n",
+        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_padding1) == 36, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_size_change_rec, lsc_padding1));
+        LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding1) == 4, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding1));
+        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_padding2) == 40, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_size_change_rec, lsc_padding2));
+        LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding2) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding2));
+        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_padding3) == 48, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_size_change_rec, lsc_padding3));
+        LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding3) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding3));
+        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_tail) == 56, "found %lld\n",

                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_tail));
         LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_tail));
                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_tail));
         LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_tail));


@@ -3455,7 +3402,7 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)sizeof(((struct llog_gen *)0)->conn_cnt));
 
         /* Checks for struct llog_gen_rec */
                  (long long)(int)sizeof(((struct llog_gen *)0)->conn_cnt));
 
         /* Checks for struct llog_gen_rec */

-        LASSERTF((int)sizeof(struct llog_gen_rec) == 40, "found %lld\n",
+        LASSERTF((int)sizeof(struct llog_gen_rec) == 64, "found %lld\n",

                  (long long)(int)sizeof(struct llog_gen_rec));
         LASSERTF((int)offsetof(struct llog_gen_rec, lgr_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_gen_rec, lgr_hdr));
                  (long long)(int)sizeof(struct llog_gen_rec));
         LASSERTF((int)offsetof(struct llog_gen_rec, lgr_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_gen_rec, lgr_hdr));


@@ -3465,7 +3412,7 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)offsetof(struct llog_gen_rec, lgr_gen));
         LASSERTF((int)sizeof(((struct llog_gen_rec *)0)->lgr_gen) == 16, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_gen_rec *)0)->lgr_gen));
                  (long long)(int)offsetof(struct llog_gen_rec, lgr_gen));
         LASSERTF((int)sizeof(((struct llog_gen_rec *)0)->lgr_gen) == 16, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_gen_rec *)0)->lgr_gen));

-        LASSERTF((int)offsetof(struct llog_gen_rec, lgr_tail) == 32, "found %lld\n",
+        LASSERTF((int)offsetof(struct llog_gen_rec, lgr_tail) == 56, "found %lld\n",

                  (long long)(int)offsetof(struct llog_gen_rec, lgr_tail));
         LASSERTF((int)sizeof(((struct llog_gen_rec *)0)->lgr_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_gen_rec *)0)->lgr_tail));
                  (long long)(int)offsetof(struct llog_gen_rec, lgr_tail));
         LASSERTF((int)sizeof(((struct llog_gen_rec *)0)->lgr_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_gen_rec *)0)->lgr_tail));


@@ -3795,66 +3742,6 @@ void lustre_assert_wire_constants(void)
         LASSERTF((int)sizeof(((struct getinfo_fid2path *)0)->gf_path[0]) == 1, "found %lld\n",
                  (long long)(int)sizeof(((struct getinfo_fid2path *)0)->gf_path[0]));
 
         LASSERTF((int)sizeof(((struct getinfo_fid2path *)0)->gf_path[0]) == 1, "found %lld\n",
                  (long long)(int)sizeof(((struct getinfo_fid2path *)0)->gf_path[0]));
 

-        /* Checks for struct lustre_disk_data */
-        LASSERTF((int)sizeof(struct lustre_disk_data) == 12288, "found %lld\n",
-                 (long long)(int)sizeof(struct lustre_disk_data));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_magic) == 0, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_magic));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_magic) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_magic));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_feature_compat) == 4, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_feature_compat));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_compat) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_compat));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_feature_rocompat) == 8, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_feature_rocompat));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_rocompat) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_rocompat));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_feature_incompat) == 12, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_feature_incompat));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_incompat) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_incompat));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_config_ver) == 16, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_config_ver));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_config_ver) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_config_ver));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_flags) == 20, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_flags));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_flags) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_flags));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_svindex) == 24, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_svindex));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_svindex) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_svindex));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_mount_type) == 28, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_mount_type));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_mount_type) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_mount_type));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_fsname) == 32, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_fsname));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_fsname) == 64, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_fsname));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_svname) == 96, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_svname));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_svname) == 64, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_svname));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_uuid) == 160, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_uuid));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_uuid) == 40, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_uuid));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_userdata) == 200, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_userdata));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_userdata) == 824, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_userdata));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_mount_opts) == 4096, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_mount_opts));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_mount_opts) == 4096, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_mount_opts));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_params) == 8192, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_params));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_params) == 4096, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_params));
-

         /* Checks for struct ll_user_fiemap */
         LASSERTF((int)sizeof(struct ll_user_fiemap) == 32, "found %lld\n",
                  (long long)(int)sizeof(struct ll_user_fiemap));
         /* Checks for struct ll_user_fiemap */
         LASSERTF((int)sizeof(struct ll_user_fiemap) == 32, "found %lld\n",
                  (long long)(int)sizeof(struct ll_user_fiemap));

diff --git a/lustre/utils/wirecheck.c b/lustre/utils/wirecheck.c
index 79655ac..5ce41b2 100644 (file)
--- a/lustre/utils/wirecheck.c
+++ b/lustre/utils/wirecheck.c
@@ -1361,37 +1361,10 @@ check_llog_logid_rec(void)
         CHECK_MEMBER(llog_logid_rec, lid_padding1);
         CHECK_MEMBER(llog_logid_rec, lid_padding2);
         CHECK_MEMBER(llog_logid_rec, lid_padding3);
         CHECK_MEMBER(llog_logid_rec, lid_padding1);
         CHECK_MEMBER(llog_logid_rec, lid_padding2);
         CHECK_MEMBER(llog_logid_rec, lid_padding3);

-        CHECK_MEMBER(llog_logid_rec, lid_padding4);
-        CHECK_MEMBER(llog_logid_rec, lid_padding5);

         CHECK_MEMBER(llog_logid_rec, lid_tail);
 }
 
 static void
         CHECK_MEMBER(llog_logid_rec, lid_tail);
 }
 
 static void

-check_llog_create_rec(void)
-{
-        BLANK_LINE();
-        CHECK_STRUCT(llog_create_rec);
-        CHECK_MEMBER(llog_create_rec, lcr_hdr);
-        CHECK_MEMBER(llog_create_rec, lcr_fid);
-        CHECK_MEMBER(llog_create_rec, lcr_oid);
-        CHECK_MEMBER(llog_create_rec, lcr_oseq);
-        CHECK_MEMBER(llog_create_rec, lcr_padding);
-        CHECK_MEMBER(llog_create_rec, lcr_tail);
-}
-
-static void
-check_llog_orphan_rec(void)
-{
-        BLANK_LINE();
-        CHECK_STRUCT(llog_orphan_rec);
-        CHECK_MEMBER(llog_orphan_rec, lor_hdr);
-        CHECK_MEMBER(llog_orphan_rec, lor_oid);
-        CHECK_MEMBER(llog_orphan_rec, lor_ogen);
-        CHECK_MEMBER(llog_orphan_rec, lor_padding);
-        CHECK_MEMBER(llog_orphan_rec, lor_tail);
-}
-
-static void

 check_llog_unlink_rec(void)
 {
         BLANK_LINE();
 check_llog_unlink_rec(void)
 {
         BLANK_LINE();


@@ -1404,17 +1377,16 @@ check_llog_unlink_rec(void)
 }
 
 static void
 }
 
 static void

-check_llog_setattr_rec(void)
+check_llog_unlink64_rec(void)

 {
 {

-        BLANK_LINE();
-        CHECK_STRUCT(llog_setattr_rec);
-        CHECK_MEMBER(llog_setattr_rec, lsr_hdr);
-        CHECK_MEMBER(llog_setattr_rec, lsr_oid);
-        CHECK_MEMBER(llog_setattr_rec, lsr_oseq);
-        CHECK_MEMBER(llog_setattr_rec, lsr_uid);
-        CHECK_MEMBER(llog_setattr_rec, lsr_gid);
-        CHECK_MEMBER(llog_setattr_rec, lsr_padding);
-        CHECK_MEMBER(llog_setattr_rec, lsr_tail);
+       CHECK_STRUCT(llog_unlink64_rec);
+       CHECK_MEMBER(llog_unlink64_rec, lur_hdr);
+       CHECK_MEMBER(llog_unlink64_rec, lur_fid);
+       CHECK_MEMBER(llog_unlink64_rec, lur_count);
+       CHECK_MEMBER(llog_unlink64_rec, lur_tail);
+       CHECK_MEMBER(llog_unlink64_rec, lur_padding1);
+       CHECK_MEMBER(llog_unlink64_rec, lur_padding2);
+       CHECK_MEMBER(llog_unlink64_rec, lur_padding3);

 }
 
 static void
 }
 
 static void


@@ -1425,24 +1397,26 @@ check_llog_setattr64_rec(void)
         CHECK_MEMBER(llog_setattr64_rec, lsr_hdr);
         CHECK_MEMBER(llog_setattr64_rec, lsr_oid);
         CHECK_MEMBER(llog_setattr64_rec, lsr_oseq);
         CHECK_MEMBER(llog_setattr64_rec, lsr_hdr);
         CHECK_MEMBER(llog_setattr64_rec, lsr_oid);
         CHECK_MEMBER(llog_setattr64_rec, lsr_oseq);

-        CHECK_MEMBER(llog_setattr64_rec, lsr_padding);

         CHECK_MEMBER(llog_setattr64_rec, lsr_uid);
         CHECK_MEMBER(llog_setattr64_rec, lsr_uid_h);
         CHECK_MEMBER(llog_setattr64_rec, lsr_gid);
         CHECK_MEMBER(llog_setattr64_rec, lsr_gid_h);
         CHECK_MEMBER(llog_setattr64_rec, lsr_uid);
         CHECK_MEMBER(llog_setattr64_rec, lsr_uid_h);
         CHECK_MEMBER(llog_setattr64_rec, lsr_gid);
         CHECK_MEMBER(llog_setattr64_rec, lsr_gid_h);

-        CHECK_MEMBER(llog_setattr64_rec, lsr_tail);
+       CHECK_MEMBER(llog_setattr64_rec, lsr_padding);
+       CHECK_MEMBER(llog_setattr64_rec, lsr_tail);

 }
 
 static void
 check_llog_size_change_rec(void)
 {
 }
 
 static void
 check_llog_size_change_rec(void)
 {

-        BLANK_LINE();
-        CHECK_STRUCT(llog_size_change_rec);
-        CHECK_MEMBER(llog_size_change_rec, lsc_hdr);
-        CHECK_MEMBER(llog_size_change_rec, lsc_fid);
-        CHECK_MEMBER(llog_size_change_rec, lsc_ioepoch);
-        CHECK_MEMBER(llog_size_change_rec, lsc_padding);
-        CHECK_MEMBER(llog_size_change_rec, lsc_tail);
+       BLANK_LINE();
+       CHECK_STRUCT(llog_size_change_rec);
+       CHECK_MEMBER(llog_size_change_rec, lsc_hdr);
+       CHECK_MEMBER(llog_size_change_rec, lsc_fid);
+       CHECK_MEMBER(llog_size_change_rec, lsc_ioepoch);
+       CHECK_MEMBER(llog_size_change_rec, lsc_padding1);
+       CHECK_MEMBER(llog_size_change_rec, lsc_padding2);
+       CHECK_MEMBER(llog_size_change_rec, lsc_padding3);
+       CHECK_MEMBER(llog_size_change_rec, lsc_tail);

 }
 
 static void
 }
 
 static void


@@ -1674,27 +1648,6 @@ check_getinfo_fid2path(void)
 }
 
 static void
 }
 
 static void

-check_lustre_disk_data(void)
-{
-        BLANK_LINE();
-        CHECK_STRUCT(lustre_disk_data);
-        CHECK_MEMBER(lustre_disk_data, ldd_magic);
-        CHECK_MEMBER(lustre_disk_data, ldd_feature_compat);
-        CHECK_MEMBER(lustre_disk_data, ldd_feature_rocompat);
-        CHECK_MEMBER(lustre_disk_data, ldd_feature_incompat);
-        CHECK_MEMBER(lustre_disk_data, ldd_config_ver);
-        CHECK_MEMBER(lustre_disk_data, ldd_flags);
-        CHECK_MEMBER(lustre_disk_data, ldd_svindex);
-        CHECK_MEMBER(lustre_disk_data, ldd_mount_type);
-        CHECK_MEMBER(lustre_disk_data, ldd_fsname);
-        CHECK_MEMBER(lustre_disk_data, ldd_svname);
-        CHECK_MEMBER(lustre_disk_data, ldd_uuid);
-        CHECK_MEMBER(lustre_disk_data, ldd_userdata);
-        CHECK_MEMBER(lustre_disk_data, ldd_mount_opts);
-        CHECK_MEMBER(lustre_disk_data, ldd_params);
-}
-
-static void

 check_posix_acl_xattr_entry(void)
 {
         BLANK_LINE();
 check_posix_acl_xattr_entry(void)
 {
         BLANK_LINE();


@@ -2138,13 +2091,11 @@ main(int argc, char **argv)
         check_llog_rec_hdr();
         check_llog_rec_tail();
         check_llog_logid_rec();
         check_llog_rec_hdr();
         check_llog_rec_tail();
         check_llog_logid_rec();

-        check_llog_create_rec();
-        check_llog_orphan_rec();

         check_llog_unlink_rec();
         check_llog_unlink_rec();

-        check_llog_setattr_rec();
-        check_llog_setattr64_rec();
-        check_llog_size_change_rec();
-        check_changelog_rec();
+       check_llog_unlink64_rec();
+       check_llog_setattr64_rec();
+       check_llog_size_change_rec();
+       check_changelog_rec();

        check_changelog_rec_ext();
         check_changelog_setinfo();
         check_llog_changelog_rec();
        check_changelog_rec_ext();
         check_changelog_setinfo();
         check_llog_changelog_rec();


@@ -2162,7 +2113,6 @@ main(int argc, char **argv)
         check_lustre_capa();
         check_lustre_capa_key();
         check_getinfo_fid2path();
         check_lustre_capa();
         check_lustre_capa_key();
         check_getinfo_fid2path();

-        check_lustre_disk_data();

         check_ll_user_fiemap();
         check_ll_fiemap_extent();
         printf("#ifdef LIBLUSTRE_POSIX_ACL\n");
         check_ll_user_fiemap();
         check_ll_fiemap_extent();
         printf("#ifdef LIBLUSTRE_POSIX_ACL\n");

diff --git a/lustre/utils/wiretest.c b/lustre/utils/wiretest.c
index b1c8c5d..16de235 100644 (file)
--- a/lustre/utils/wiretest.c
+++ b/lustre/utils/wiretest.c
@@ -3127,77 +3127,17 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding1));
         LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding2) == 40, "found %lld\n",
                  (long long)(int)offsetof(struct llog_logid_rec, lid_padding2));
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding1));
         LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding2) == 40, "found %lld\n",
                  (long long)(int)offsetof(struct llog_logid_rec, lid_padding2));

-        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding2) == 4, "found %lld\n",
+        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding2) == 8, "found %lld\n",

                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding2));
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding2));

-        LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding3) == 44, "found %lld\n",
+        LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding3) == 48, "found %lld\n",

                  (long long)(int)offsetof(struct llog_logid_rec, lid_padding3));
                  (long long)(int)offsetof(struct llog_logid_rec, lid_padding3));

-        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding3) == 4, "found %lld\n",
+        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding3) == 8, "found %lld\n",

                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding3));
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding3));

-        LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding4) == 48, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_logid_rec, lid_padding4));
-        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding4) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding4));
-        LASSERTF((int)offsetof(struct llog_logid_rec, lid_padding5) == 52, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_logid_rec, lid_padding5));
-        LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_padding5) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_padding5));

         LASSERTF((int)offsetof(struct llog_logid_rec, lid_tail) == 56, "found %lld\n",
                  (long long)(int)offsetof(struct llog_logid_rec, lid_tail));
         LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_tail));
 
         LASSERTF((int)offsetof(struct llog_logid_rec, lid_tail) == 56, "found %lld\n",
                  (long long)(int)offsetof(struct llog_logid_rec, lid_tail));
         LASSERTF((int)sizeof(((struct llog_logid_rec *)0)->lid_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_logid_rec *)0)->lid_tail));
 

-        /* Checks for struct llog_create_rec */
-        LASSERTF((int)sizeof(struct llog_create_rec) == 56, "found %lld\n",
-                 (long long)(int)sizeof(struct llog_create_rec));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_hdr) == 0, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_hdr));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_hdr) == 16, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_hdr));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_fid) == 16, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_fid));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_fid) == 16, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_fid));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_oid) == 32, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_oid));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_oid) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_oid));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_oseq) == 40, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_oseq));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_oseq) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_oseq));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_padding) == 44, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_padding));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_padding) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_padding));
-        LASSERTF((int)offsetof(struct llog_create_rec, lcr_tail) == 48, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_create_rec, lcr_tail));
-        LASSERTF((int)sizeof(((struct llog_create_rec *)0)->lcr_tail) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_create_rec *)0)->lcr_tail));
-
-        /* Checks for struct llog_orphan_rec */
-        LASSERTF((int)sizeof(struct llog_orphan_rec) == 40, "found %lld\n",
-                 (long long)(int)sizeof(struct llog_orphan_rec));
-        LASSERTF((int)offsetof(struct llog_orphan_rec, lor_hdr) == 0, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_orphan_rec, lor_hdr));
-        LASSERTF((int)sizeof(((struct llog_orphan_rec *)0)->lor_hdr) == 16, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_orphan_rec *)0)->lor_hdr));
-        LASSERTF((int)offsetof(struct llog_orphan_rec, lor_oid) == 16, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_orphan_rec, lor_oid));
-        LASSERTF((int)sizeof(((struct llog_orphan_rec *)0)->lor_oid) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_orphan_rec *)0)->lor_oid));
-        LASSERTF((int)offsetof(struct llog_orphan_rec, lor_ogen) == 24, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_orphan_rec, lor_ogen));
-        LASSERTF((int)sizeof(((struct llog_orphan_rec *)0)->lor_ogen) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_orphan_rec *)0)->lor_ogen));
-        LASSERTF((int)offsetof(struct llog_orphan_rec, lor_padding) == 28, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_orphan_rec, lor_padding));
-        LASSERTF((int)sizeof(((struct llog_orphan_rec *)0)->lor_padding) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_orphan_rec *)0)->lor_padding));
-        LASSERTF((int)offsetof(struct llog_orphan_rec, lor_tail) == 32, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_orphan_rec, lor_tail));
-        LASSERTF((int)sizeof(((struct llog_orphan_rec *)0)->lor_tail) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_orphan_rec *)0)->lor_tail));
-

         /* Checks for struct llog_unlink_rec */
         LASSERTF((int)sizeof(struct llog_unlink_rec) == 40, "found %lld\n",
                  (long long)(int)sizeof(struct llog_unlink_rec));
         /* Checks for struct llog_unlink_rec */
         LASSERTF((int)sizeof(struct llog_unlink_rec) == 40, "found %lld\n",
                  (long long)(int)sizeof(struct llog_unlink_rec));


@@ -3221,41 +3161,40 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)offsetof(struct llog_unlink_rec, lur_tail));
         LASSERTF((int)sizeof(((struct llog_unlink_rec *)0)->lur_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_unlink_rec *)0)->lur_tail));
                  (long long)(int)offsetof(struct llog_unlink_rec, lur_tail));
         LASSERTF((int)sizeof(((struct llog_unlink_rec *)0)->lur_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_unlink_rec *)0)->lur_tail));

-
-        /* Checks for struct llog_setattr_rec */
-        LASSERTF((int)sizeof(struct llog_setattr_rec) == 48, "found %lld\n",
-                 (long long)(int)sizeof(struct llog_setattr_rec));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_hdr) == 0, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_hdr));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_hdr) == 16, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_hdr));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_oid) == 16, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_oid));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_oid) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_oid));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_oseq) == 24, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_oseq));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_oseq) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_oseq));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_uid) == 28, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_uid));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_uid) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_uid));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_gid) == 32, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_gid));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_gid) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_gid));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_padding) == 36, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_padding));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_padding) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_padding));
-        LASSERTF((int)offsetof(struct llog_setattr_rec, lsr_tail) == 40, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr_rec, lsr_tail));
-        LASSERTF((int)sizeof(((struct llog_setattr_rec *)0)->lsr_tail) == 8, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr_rec *)0)->lsr_tail));
+        /* Checks for struct llog_unlink64_rec */
+        LASSERTF((int)sizeof(struct llog_unlink64_rec) == 64, "found %lld\n",
+                 (long long)(int)sizeof(struct llog_unlink64_rec));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_hdr) == 0, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_hdr));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_hdr) == 16, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_hdr));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_fid) == 16, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_fid));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_fid) == 16, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_fid));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_count) == 32, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_count));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_count) == 4, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_count));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_tail) == 56, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_tail));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_tail) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_tail));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_padding1) == 36, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_padding1));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding1) == 4, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding1));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_padding2) == 40, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_padding2));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding2) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding2));
+        LASSERTF((int)offsetof(struct llog_unlink64_rec, lur_padding3) == 48, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_unlink64_rec, lur_padding3));
+        LASSERTF((int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding3) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_unlink64_rec *)0)->lur_padding3));

 
         /* Checks for struct llog_setattr64_rec */
 
         /* Checks for struct llog_setattr64_rec */

-        LASSERTF((int)sizeof(struct llog_setattr64_rec) == 56, "found %lld\n",
+        LASSERTF((int)sizeof(struct llog_setattr64_rec) == 64, "found %lld\n",

                  (long long)(int)sizeof(struct llog_setattr64_rec));
         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_hdr));
                  (long long)(int)sizeof(struct llog_setattr64_rec));
         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_hdr));


@@ -3267,12 +3206,8 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oid));
         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_oseq) == 24, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_oseq));
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oid));
         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_oseq) == 24, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_oseq));

-        LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oseq) == 4, "found %lld\n",
+        LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oseq) == 8, "found %lld\n",

                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oseq));
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_oseq));

-        LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_padding) == 28, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_setattr64_rec, lsr_padding));
-        LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_padding) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_padding));

         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_uid) == 32, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_uid));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_uid) == 4, "found %lld\n",
         LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_uid) == 32, "found %lld\n",
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_uid));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_uid) == 4, "found %lld\n",


@@ -3289,13 +3224,17 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_gid_h));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_gid_h) == 4, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_gid_h));
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_gid_h));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_gid_h) == 4, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_gid_h));

-        LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_tail) == 48, "found %lld\n",
+        LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_padding) == 48, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_setattr64_rec, lsr_padding));
+        LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_padding) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_padding));
+        LASSERTF((int)offsetof(struct llog_setattr64_rec, lsr_tail) == 56, "found %lld\n",

                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_tail));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_tail));
 
         /* Checks for struct llog_size_change_rec */
                  (long long)(int)offsetof(struct llog_setattr64_rec, lsr_tail));
         LASSERTF((int)sizeof(((struct llog_setattr64_rec *)0)->lsr_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_setattr64_rec *)0)->lsr_tail));
 
         /* Checks for struct llog_size_change_rec */

-        LASSERTF((int)sizeof(struct llog_size_change_rec) == 48, "found %lld\n",
+        LASSERTF((int)sizeof(struct llog_size_change_rec) == 64, "found %lld\n",

                  (long long)(int)sizeof(struct llog_size_change_rec));
         LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_hdr));
                  (long long)(int)sizeof(struct llog_size_change_rec));
         LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_hdr));


@@ -3309,11 +3248,19 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_ioepoch));
         LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_ioepoch) == 4, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_ioepoch));
                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_ioepoch));
         LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_ioepoch) == 4, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_ioepoch));

-        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_padding) == 36, "found %lld\n",
-                 (long long)(int)offsetof(struct llog_size_change_rec, lsc_padding));
-        LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding));
-        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_tail) == 40, "found %lld\n",
+        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_padding1) == 36, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_size_change_rec, lsc_padding1));
+        LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding1) == 4, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding1));
+        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_padding2) == 40, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_size_change_rec, lsc_padding2));
+        LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding2) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding2));
+        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_padding3) == 48, "found %lld\n",
+                 (long long)(int)offsetof(struct llog_size_change_rec, lsc_padding3));
+        LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding3) == 8, "found %lld\n",
+                 (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_padding3));
+        LASSERTF((int)offsetof(struct llog_size_change_rec, lsc_tail) == 56, "found %lld\n",

                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_tail));
         LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_tail));
                  (long long)(int)offsetof(struct llog_size_change_rec, lsc_tail));
         LASSERTF((int)sizeof(((struct llog_size_change_rec *)0)->lsc_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_size_change_rec *)0)->lsc_tail));


@@ -3463,7 +3410,7 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)sizeof(((struct llog_gen *)0)->conn_cnt));
 
         /* Checks for struct llog_gen_rec */
                  (long long)(int)sizeof(((struct llog_gen *)0)->conn_cnt));
 
         /* Checks for struct llog_gen_rec */

-        LASSERTF((int)sizeof(struct llog_gen_rec) == 40, "found %lld\n",
+        LASSERTF((int)sizeof(struct llog_gen_rec) == 64, "found %lld\n",

                  (long long)(int)sizeof(struct llog_gen_rec));
         LASSERTF((int)offsetof(struct llog_gen_rec, lgr_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_gen_rec, lgr_hdr));
                  (long long)(int)sizeof(struct llog_gen_rec));
         LASSERTF((int)offsetof(struct llog_gen_rec, lgr_hdr) == 0, "found %lld\n",
                  (long long)(int)offsetof(struct llog_gen_rec, lgr_hdr));


@@ -3473,7 +3420,7 @@ void lustre_assert_wire_constants(void)
                  (long long)(int)offsetof(struct llog_gen_rec, lgr_gen));
         LASSERTF((int)sizeof(((struct llog_gen_rec *)0)->lgr_gen) == 16, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_gen_rec *)0)->lgr_gen));
                  (long long)(int)offsetof(struct llog_gen_rec, lgr_gen));
         LASSERTF((int)sizeof(((struct llog_gen_rec *)0)->lgr_gen) == 16, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_gen_rec *)0)->lgr_gen));

-        LASSERTF((int)offsetof(struct llog_gen_rec, lgr_tail) == 32, "found %lld\n",
+        LASSERTF((int)offsetof(struct llog_gen_rec, lgr_tail) == 56, "found %lld\n",

                  (long long)(int)offsetof(struct llog_gen_rec, lgr_tail));
         LASSERTF((int)sizeof(((struct llog_gen_rec *)0)->lgr_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_gen_rec *)0)->lgr_tail));
                  (long long)(int)offsetof(struct llog_gen_rec, lgr_tail));
         LASSERTF((int)sizeof(((struct llog_gen_rec *)0)->lgr_tail) == 8, "found %lld\n",
                  (long long)(int)sizeof(((struct llog_gen_rec *)0)->lgr_tail));


@@ -3803,66 +3750,6 @@ void lustre_assert_wire_constants(void)
         LASSERTF((int)sizeof(((struct getinfo_fid2path *)0)->gf_path[0]) == 1, "found %lld\n",
                  (long long)(int)sizeof(((struct getinfo_fid2path *)0)->gf_path[0]));
 
         LASSERTF((int)sizeof(((struct getinfo_fid2path *)0)->gf_path[0]) == 1, "found %lld\n",
                  (long long)(int)sizeof(((struct getinfo_fid2path *)0)->gf_path[0]));
 

-        /* Checks for struct lustre_disk_data */
-        LASSERTF((int)sizeof(struct lustre_disk_data) == 12288, "found %lld\n",
-                 (long long)(int)sizeof(struct lustre_disk_data));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_magic) == 0, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_magic));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_magic) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_magic));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_feature_compat) == 4, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_feature_compat));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_compat) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_compat));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_feature_rocompat) == 8, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_feature_rocompat));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_rocompat) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_rocompat));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_feature_incompat) == 12, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_feature_incompat));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_incompat) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_feature_incompat));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_config_ver) == 16, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_config_ver));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_config_ver) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_config_ver));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_flags) == 20, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_flags));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_flags) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_flags));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_svindex) == 24, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_svindex));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_svindex) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_svindex));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_mount_type) == 28, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_mount_type));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_mount_type) == 4, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_mount_type));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_fsname) == 32, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_fsname));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_fsname) == 64, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_fsname));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_svname) == 96, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_svname));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_svname) == 64, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_svname));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_uuid) == 160, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_uuid));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_uuid) == 40, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_uuid));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_userdata) == 200, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_userdata));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_userdata) == 824, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_userdata));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_mount_opts) == 4096, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_mount_opts));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_mount_opts) == 4096, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_mount_opts));
-        LASSERTF((int)offsetof(struct lustre_disk_data, ldd_params) == 8192, "found %lld\n",
-                 (long long)(int)offsetof(struct lustre_disk_data, ldd_params));
-        LASSERTF((int)sizeof(((struct lustre_disk_data *)0)->ldd_params) == 4096, "found %lld\n",
-                 (long long)(int)sizeof(((struct lustre_disk_data *)0)->ldd_params));
-

         /* Checks for struct ll_user_fiemap */
         LASSERTF((int)sizeof(struct ll_user_fiemap) == 32, "found %lld\n",
                  (long long)(int)sizeof(struct ll_user_fiemap));
         /* Checks for struct ll_user_fiemap */
         LASSERTF((int)sizeof(struct ll_user_fiemap) == 32, "found %lld\n",
                  (long long)(int)sizeof(struct ll_user_fiemap));