X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Fllog_swab.c;h=c644efb64ac1fd0b1d982a25161b3648fb9a57b7;hp=3e62c570f130087d49bb4a5882e5be13c99da2ca;hb=1db90b29ad676c2cf1888ef5a7c623161ff23bf9;hpb=97fbb61dbe261a389897779ae376cfc3808442cf

diff --git a/lustre/obdclass/llog_swab.c b/lustre/obdclass/llog_swab.c
index 3e62c57..c644efb 100644
--- a/lustre/obdclass/llog_swab.c
+++ b/lustre/obdclass/llog_swab.c
@@ -23,7 +23,7 @@
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2012, 2015, Intel Corporation.
+ * Copyright (c) 2012, 2017, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -44,23 +44,23 @@
 
 static void print_llogd_body(struct llogd_body *d)
 {
-        CDEBUG(D_OTHER, "llogd body: %p\n", d);
-        CDEBUG(D_OTHER, "\tlgd_logid.lgl_oi: "DOSTID"\n",
-	       POSTID(&d->lgd_logid.lgl_oi));
-        CDEBUG(D_OTHER, "\tlgd_logid.lgl_ogen: %#x\n", d->lgd_logid.lgl_ogen);
-        CDEBUG(D_OTHER, "\tlgd_ctxt_idx: %#x\n", d->lgd_ctxt_idx);
-        CDEBUG(D_OTHER, "\tlgd_llh_flags: %#x\n", d->lgd_llh_flags);
-        CDEBUG(D_OTHER, "\tlgd_index: %#x\n", d->lgd_index);
-        CDEBUG(D_OTHER, "\tlgd_saved_index: %#x\n", d->lgd_saved_index);
-        CDEBUG(D_OTHER, "\tlgd_len: %#x\n", d->lgd_len);
+	CDEBUG(D_OTHER, "llogd body: %p\n", d);
+	CDEBUG(D_OTHER, "\tlgd_logid.lgl_oi.oi_fid: "DFID"\n",
+	       PFID(&d->lgd_logid.lgl_oi.oi_fid));
+	CDEBUG(D_OTHER, "\tlgd_logid.lgl_ogen: %#x\n", d->lgd_logid.lgl_ogen);
+	CDEBUG(D_OTHER, "\tlgd_ctxt_idx: %#x\n", d->lgd_ctxt_idx);
+	CDEBUG(D_OTHER, "\tlgd_llh_flags: %#x\n", d->lgd_llh_flags);
+	CDEBUG(D_OTHER, "\tlgd_index: %#x\n", d->lgd_index);
+	CDEBUG(D_OTHER, "\tlgd_saved_index: %#x\n", d->lgd_saved_index);
+	CDEBUG(D_OTHER, "\tlgd_len: %#x\n", d->lgd_len);
 	CDEBUG(D_OTHER, "\tlgd_cur_offset: %#llx\n", d->lgd_cur_offset);
 }
 
 void lustre_swab_lu_fid(struct lu_fid *fid)
 {
-        __swab64s (&fid->f_seq);
-        __swab32s (&fid->f_oid);
-        __swab32s (&fid->f_ver);
+	__swab64s(&fid->f_seq);
+	__swab32s(&fid->f_oid);
+	__swab32s(&fid->f_ver);
 }
 EXPORT_SYMBOL(lustre_swab_lu_fid);
 
@@ -80,47 +80,47 @@ void lustre_swab_llog_id(struct llog_logid *log_id)
 {
 	__swab64s(&log_id->lgl_oi.oi.oi_id);
 	__swab64s(&log_id->lgl_oi.oi.oi_seq);
-        __swab32s(&log_id->lgl_ogen);
+	__swab32s(&log_id->lgl_ogen);
 }
 
 void lustre_swab_llogd_body (struct llogd_body *d)
 {
-        ENTRY;
-        print_llogd_body(d);
+	ENTRY;
+	print_llogd_body(d);
 	lustre_swab_llog_id(&d->lgd_logid);
-        __swab32s (&d->lgd_ctxt_idx);
-        __swab32s (&d->lgd_llh_flags);
-        __swab32s (&d->lgd_index);
-        __swab32s (&d->lgd_saved_index);
-        __swab32s (&d->lgd_len);
-        __swab64s (&d->lgd_cur_offset);
-        print_llogd_body(d);
-        EXIT;
+	__swab32s(&d->lgd_ctxt_idx);
+	__swab32s(&d->lgd_llh_flags);
+	__swab32s(&d->lgd_index);
+	__swab32s(&d->lgd_saved_index);
+	__swab32s(&d->lgd_len);
+	__swab64s(&d->lgd_cur_offset);
+	print_llogd_body(d);
+	EXIT;
 }
 EXPORT_SYMBOL(lustre_swab_llogd_body);
 
 void lustre_swab_llogd_conn_body (struct llogd_conn_body *d)
 {
-        __swab64s (&d->lgdc_gen.mnt_cnt);
-        __swab64s (&d->lgdc_gen.conn_cnt);
+	__swab64s(&d->lgdc_gen.mnt_cnt);
+	__swab64s(&d->lgdc_gen.conn_cnt);
 	lustre_swab_llog_id(&d->lgdc_logid);
-        __swab32s (&d->lgdc_ctxt_idx);
+	__swab32s(&d->lgdc_ctxt_idx);
 }
 EXPORT_SYMBOL(lustre_swab_llogd_conn_body);
 
 void lustre_swab_ll_fid(struct ll_fid *fid)
 {
-        __swab64s (&fid->id);
-        __swab32s (&fid->generation);
-        __swab32s (&fid->f_type);
+	__swab64s(&fid->id);
+	__swab32s(&fid->generation);
+	__swab32s(&fid->f_type);
 }
 
 void lustre_swab_lu_seq_range(struct lu_seq_range *range)
 {
-        __swab64s (&range->lsr_start);
-        __swab64s (&range->lsr_end);
-        __swab32s (&range->lsr_index);
-        __swab32s (&range->lsr_flags);
+	__swab64s(&range->lsr_start);
+	__swab64s(&range->lsr_end);
+	__swab32s(&range->lsr_index);
+	__swab32s(&range->lsr_flags);
 }
 EXPORT_SYMBOL(lustre_swab_lu_seq_range);
 
@@ -143,32 +143,32 @@ void lustre_swab_llog_rec(struct llog_rec_hdr *rec)
 {
 	struct llog_rec_tail *tail = NULL;
 
-        __swab32s(&rec->lrh_len);
-        __swab32s(&rec->lrh_index);
-        __swab32s(&rec->lrh_type);
+	__swab32s(&rec->lrh_len);
+	__swab32s(&rec->lrh_index);
+	__swab32s(&rec->lrh_type);
 	__swab32s(&rec->lrh_id);
 
-        switch (rec->lrh_type) {
+	switch (rec->lrh_type) {
 	case OST_SZ_REC:
 	{
-                struct llog_size_change_rec *lsc =
-                        (struct llog_size_change_rec *)rec;
+		struct llog_size_change_rec *lsc =
+			(struct llog_size_change_rec *)rec;
 
-                lustre_swab_ll_fid(&lsc->lsc_fid);
-                __swab32s(&lsc->lsc_ioepoch);
+		lustre_swab_ll_fid(&lsc->lsc_fid);
+		__swab32s(&lsc->lsc_ioepoch);
 		tail = &lsc->lsc_tail;
-                break;
-        }
+		break;
+	}
 	case MDS_UNLINK_REC:
 	{
-                struct llog_unlink_rec *lur = (struct llog_unlink_rec *)rec;
+		struct llog_unlink_rec *lur = (struct llog_unlink_rec *)rec;
 
-                __swab64s(&lur->lur_oid);
-                __swab32s(&lur->lur_oseq);
-                __swab32s(&lur->lur_count);
+		__swab64s(&lur->lur_oid);
+		__swab32s(&lur->lur_oseq);
+		__swab32s(&lur->lur_count);
 		tail = &lur->lur_tail;
-                break;
-        }
+		break;
+	}
 	case MDS_UNLINK64_REC:
 	{
 		struct llog_unlink64_rec *lur =
@@ -199,8 +199,10 @@ void lustre_swab_llog_rec(struct llog_rec_hdr *rec)
 			lustre_swab_lu_fid(&rnm->cr_sfid);
 			lustre_swab_lu_fid(&rnm->cr_spfid);
 		}
-		/* Because the tail follows a variable-length structure we need
-		 * to compute its location at runtime */
+		/*
+		 * Because the tail follows a variable-length structure we need
+		 * to compute its location at runtime
+		 */
 		tail = (struct llog_rec_tail *)((char *)&cr->cr +
 						changelog_rec_size(&cr->cr) +
 						cr->cr.cr_namelen);
@@ -209,14 +211,15 @@ void lustre_swab_llog_rec(struct llog_rec_hdr *rec)
 
 	case CHANGELOG_USER_REC:
 	{
-                struct llog_changelog_user_rec *cur =
-                        (struct llog_changelog_user_rec*)rec;
+		struct llog_changelog_user_rec *cur =
+			(struct llog_changelog_user_rec *)rec;
 
-                __swab32s(&cur->cur_id);
-                __swab64s(&cur->cur_endrec);
+		__swab32s(&cur->cur_id);
+		__swab64s(&cur->cur_endrec);
+		__swab32s(&cur->cur_time);
 		tail = &cur->cur_tail;
-                break;
-        }
+		break;
+	}
 
 	case HSM_AGENT_REC: {
 		struct llog_agent_req_rec *arr =
@@ -230,8 +233,10 @@ void lustre_swab_llog_rec(struct llog_rec_hdr *rec)
 		__swab64s(&arr->arr_hai.hai_extent.offset);
 		__swab64s(&arr->arr_hai.hai_extent.length);
 		__swab64s(&arr->arr_hai.hai_gid);
-		/* no swabing for opaque data */
-		/* hai_data[0]; */
+		/*
+		 * no swabing for opaque data
+		 * hai_data[0];
+		 */
 		break;
 	}
 
@@ -249,9 +254,10 @@ void lustre_swab_llog_rec(struct llog_rec_hdr *rec)
 
 		if (rec->lrh_len > sizeof(struct llog_setattr64_rec)) {
 			struct llog_setattr64_rec_v2 *lsr2 =
-			(struct llog_setattr64_rec_v2 *)rec;
+				(struct llog_setattr64_rec_v2 *)rec;
 
 			__swab32s(&lsr2->lsr_projid);
+			__swab32s(&lsr2->lsr_layout_version);
 			tail = &lsr2->lsr_tail;
 		} else {
 			tail = &lsr->lsr_tail;
@@ -291,8 +297,8 @@ void lustre_swab_llog_rec(struct llog_rec_hdr *rec)
 		tail = &lgr->lgr_tail;
 		break;
 	}
-        case LLOG_PAD_MAGIC:
-                break;
+	case LLOG_PAD_MAGIC:
+		break;
 	case UPDATE_REC:
 	{
 		struct llog_update_record *lur =
@@ -312,10 +318,10 @@ void lustre_swab_llog_rec(struct llog_rec_hdr *rec)
 						update_records_size(record));
 		break;
 	}
-        default:
-                CERROR("Unknown llog rec type %#x swabbing rec %p\n",
-                       rec->lrh_type, rec);
-        }
+	default:
+		CERROR("Unknown llog rec type %#x swabbing rec %p\n",
+			rec->lrh_type, rec);
+	}
 
 	if (tail) {
 		__swab32s(&tail->lrt_len);
@@ -343,76 +349,84 @@ static void print_llog_hdr(struct llog_log_hdr *h)
 
 void lustre_swab_llog_hdr (struct llog_log_hdr *h)
 {
-        ENTRY;
-        print_llog_hdr(h);
+	ENTRY;
+	print_llog_hdr(h);
 
 	lustre_swab_llog_rec(&h->llh_hdr);
 
-        print_llog_hdr(h);
-        EXIT;
+	print_llog_hdr(h);
+	EXIT;
 }
 EXPORT_SYMBOL(lustre_swab_llog_hdr);
 
-static void print_lustre_cfg(struct lustre_cfg *lcfg)
+void print_lustre_cfg(struct lustre_cfg *lcfg)
 {
-        int i;
-        ENTRY;
-
-        if (!(libcfs_debug & D_OTHER)) /* don't loop on nothing */
-                return;
-        CDEBUG(D_OTHER, "lustre_cfg: %p\n", lcfg);
-        CDEBUG(D_OTHER, "\tlcfg->lcfg_version: %#x\n", lcfg->lcfg_version);
-
-        CDEBUG(D_OTHER, "\tlcfg->lcfg_command: %#x\n", lcfg->lcfg_command);
-        CDEBUG(D_OTHER, "\tlcfg->lcfg_num: %#x\n", lcfg->lcfg_num);
-        CDEBUG(D_OTHER, "\tlcfg->lcfg_flags: %#x\n", lcfg->lcfg_flags);
-        CDEBUG(D_OTHER, "\tlcfg->lcfg_nid: %s\n", libcfs_nid2str(lcfg->lcfg_nid));
-
-        CDEBUG(D_OTHER, "\tlcfg->lcfg_bufcount: %d\n", lcfg->lcfg_bufcount);
-        if (lcfg->lcfg_bufcount < LUSTRE_CFG_MAX_BUFCOUNT)
-                for (i = 0; i < lcfg->lcfg_bufcount; i++)
-                        CDEBUG(D_OTHER, "\tlcfg->lcfg_buflens[%d]: %d\n",
-                               i, lcfg->lcfg_buflens[i]);
-        EXIT;
+	int i;
+
+	ENTRY;
+
+	if (!(libcfs_debug & D_OTHER)) /* don't loop on nothing */
+		return;
+
+	CDEBUG(D_OTHER, "lustre_cfg: %p\n", lcfg);
+	CDEBUG(D_OTHER, "\tlcfg->lcfg_version: %#x\n", lcfg->lcfg_version);
+
+	CDEBUG(D_OTHER, "\tlcfg->lcfg_command: %#x\n", lcfg->lcfg_command);
+	CDEBUG(D_OTHER, "\tlcfg->lcfg_num: %#x\n", lcfg->lcfg_num);
+	CDEBUG(D_OTHER, "\tlcfg->lcfg_flags: %#x\n", lcfg->lcfg_flags);
+	CDEBUG(D_OTHER, "\tlcfg->lcfg_nid: %s\n",
+	       libcfs_nid2str(lcfg->lcfg_nid));
+
+	CDEBUG(D_OTHER, "\tlcfg->lcfg_bufcount: %d\n", lcfg->lcfg_bufcount);
+	if (lcfg->lcfg_bufcount < LUSTRE_CFG_MAX_BUFCOUNT)
+		for (i = 0; i < lcfg->lcfg_bufcount; i++) {
+			CDEBUG(D_OTHER, "\tlcfg->lcfg_buflens[%d]: %d %s\n",
+			       i, lcfg->lcfg_buflens[i],
+			       lustre_cfg_string(lcfg, i));
+		}
+
+	EXIT;
 }
+EXPORT_SYMBOL(print_lustre_cfg);
 
 void lustre_swab_lustre_cfg(struct lustre_cfg *lcfg)
 {
-        int i;
-        ENTRY;
-
-        __swab32s(&lcfg->lcfg_version);
-
-        if (lcfg->lcfg_version != LUSTRE_CFG_VERSION) {
-                CERROR("not swabbing lustre_cfg version %#x (expecting %#x)\n",
-                       lcfg->lcfg_version, LUSTRE_CFG_VERSION);
-                EXIT;
-                return;
-        }
-
-        __swab32s(&lcfg->lcfg_command);
-        __swab32s(&lcfg->lcfg_num);
-        __swab32s(&lcfg->lcfg_flags);
-        __swab64s(&lcfg->lcfg_nid);
-        __swab32s(&lcfg->lcfg_bufcount);
-        for (i = 0; i < lcfg->lcfg_bufcount && i < LUSTRE_CFG_MAX_BUFCOUNT; i++)
-                __swab32s(&lcfg->lcfg_buflens[i]);
-
-        print_lustre_cfg(lcfg);
-        EXIT;
-        return;
+	int i;
+
+	ENTRY;
+
+	__swab32s(&lcfg->lcfg_version);
+
+	if (lcfg->lcfg_version != LUSTRE_CFG_VERSION) {
+		CERROR("not swabbing lustre_cfg version %#x (expecting %#x)\n",
+			lcfg->lcfg_version, LUSTRE_CFG_VERSION);
+		EXIT;
+		return;
+	}
+
+	__swab32s(&lcfg->lcfg_command);
+	__swab32s(&lcfg->lcfg_num);
+	__swab32s(&lcfg->lcfg_flags);
+	__swab64s(&lcfg->lcfg_nid);
+	__swab32s(&lcfg->lcfg_bufcount);
+	for (i = 0; i < lcfg->lcfg_bufcount && i < LUSTRE_CFG_MAX_BUFCOUNT; i++)
+		__swab32s(&lcfg->lcfg_buflens[i]);
+
+	print_lustre_cfg(lcfg);
+	EXIT;
+	return;
 }
 
 /* used only for compatibility with old on-disk cfg_marker data */
 struct cfg_marker32 {
-        __u32   cm_step;
-        __u32   cm_flags;
-        __u32   cm_vers;
-        __u32   padding;
-        __u32   cm_createtime;
-        __u32   cm_canceltime;
-        char    cm_tgtname[MTI_NAME_MAXLEN];
-        char    cm_comment[MTI_NAME_MAXLEN];
+	__u32   cm_step;
+	__u32   cm_flags;
+	__u32   cm_vers;
+	__u32   padding;
+	__u32   cm_createtime;
+	__u32   cm_canceltime;
+	char    cm_tgtname[MTI_NAME_MAXLEN];
+	char    cm_comment[MTI_NAME_MAXLEN];
 };
 
 #define MTI_NAMELEN32    (MTI_NAME_MAXLEN - \
@@ -420,48 +434,51 @@ struct cfg_marker32 {
 
 void lustre_swab_cfg_marker(struct cfg_marker *marker, int swab, int size)
 {
-        struct cfg_marker32 *cm32 = (struct cfg_marker32*)marker;
-        ENTRY;
-
-        if (swab) {
-                __swab32s(&marker->cm_step);
-                __swab32s(&marker->cm_flags);
-                __swab32s(&marker->cm_vers);
-        }
-        if (size == sizeof(*cm32)) {
-                __u32 createtime, canceltime;
-                /* There was a problem with the original declaration of
-                 * cfg_marker on 32-bit systems because it used time_t as
-                 * a wire protocol structure, and didn't verify this in
-                 * wirecheck.  We now have to convert the offsets of the
-                 * later fields in order to work on 32- and 64-bit systems.
-                 *
-                 * Fortunately, the cm_comment field has no functional use
-                 * so can be sacrificed when converting the timestamp size.
-                 *
-                 * Overwrite fields from the end first, so they are not
-                 * clobbered, and use memmove() instead of memcpy() because
-                 * the source and target buffers overlap.  bug 16771 */
-                createtime = cm32->cm_createtime;
-                canceltime = cm32->cm_canceltime;
-                memmove(marker->cm_comment, cm32->cm_comment, MTI_NAMELEN32);
-                marker->cm_comment[MTI_NAMELEN32 - 1] = '\0';
-                memmove(marker->cm_tgtname, cm32->cm_tgtname,
-                        sizeof(marker->cm_tgtname));
-                if (swab) {
-                        __swab32s(&createtime);
-                        __swab32s(&canceltime);
-                }
-                marker->cm_createtime = createtime;
-                marker->cm_canceltime = canceltime;
-                CDEBUG(D_CONFIG, "Find old cfg_marker(Srv32b,Clt64b) "
-                       "for target %s, converting\n",
-                       marker->cm_tgtname);
-        } else if (swab) {
-                __swab64s(&marker->cm_createtime);
-                __swab64s(&marker->cm_canceltime);
-        }
-
-        EXIT;
-        return;
+	struct cfg_marker32 *cm32 = (struct cfg_marker32 *)marker;
+
+	ENTRY;
+
+	if (swab) {
+		__swab32s(&marker->cm_step);
+		__swab32s(&marker->cm_flags);
+		__swab32s(&marker->cm_vers);
+	}
+	if (size == sizeof(*cm32)) {
+		__u32 createtime, canceltime;
+		/*
+		 * There was a problem with the original declaration of
+		 * cfg_marker on 32-bit systems because it used time_t as
+		 * a wire protocol structure, and didn't verify this in
+		 * wirecheck.  We now have to convert the offsets of the
+		 * later fields in order to work on 32- and 64-bit systems.
+		 *
+		 * Fortunately, the cm_comment field has no functional use
+		 * so can be sacrificed when converting the timestamp size.
+		 *
+		 * Overwrite fields from the end first, so they are not
+		 * clobbered, and use memmove() instead of memcpy() because
+		 * the source and target buffers overlap.  bug 16771
+		 */
+		createtime = cm32->cm_createtime;
+		canceltime = cm32->cm_canceltime;
+		memmove(marker->cm_comment, cm32->cm_comment, MTI_NAMELEN32);
+		marker->cm_comment[MTI_NAMELEN32 - 1] = '\0';
+		memmove(marker->cm_tgtname, cm32->cm_tgtname,
+			sizeof(marker->cm_tgtname));
+		if (swab) {
+			__swab32s(&createtime);
+			__swab32s(&canceltime);
+		}
+		marker->cm_createtime = createtime;
+		marker->cm_canceltime = canceltime;
+		CDEBUG(D_CONFIG,
+		       "Find old cfg_marker(Srv32b,Clt64b) for target %s, converting\n",
+		       marker->cm_tgtname);
+	} else if (swab) {
+		__swab64s(&marker->cm_createtime);
+		__swab64s(&marker->cm_canceltime);
+	}
+
+	EXIT;
+	return;
 }