llog_swab.c revision d7e09d0397e84eefbabfd9cb353221f3c6448d83
1/* 2 * GPL HEADER START 3 * 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 only, 8 * as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License version 2 for more details (a copy is included 14 * in the LICENSE file that accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License 17 * version 2 along with this program; If not, see 18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf 19 * 20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 21 * CA 95054 USA or visit www.sun.com if you need additional information or 22 * have any questions. 23 * 24 * GPL HEADER END 25 */ 26/* 27 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 28 * Use is subject to license terms. 29 * 30 * Copyright (c) 2012, Intel Corporation. 31 */ 32/* 33 * This file is part of Lustre, http://www.lustre.org/ 34 * Lustre is a trademark of Sun Microsystems, Inc. 35 * 36 * lustre/obdclass/llog_swab.c 37 * 38 * Swabbing of llog datatypes (from disk or over the wire). 39 * 40 * Author: jacob berkman <jacob@clusterfs.com> 41 */ 42 43#define DEBUG_SUBSYSTEM S_LOG 44 45 46#include <lustre_log.h> 47 48static void print_llogd_body(struct llogd_body *d) 49{ 50 CDEBUG(D_OTHER, "llogd body: %p\n", d); 51 CDEBUG(D_OTHER, "\tlgd_logid.lgl_oi: "DOSTID"\n", 52 POSTID(&d->lgd_logid.lgl_oi)); 53 CDEBUG(D_OTHER, "\tlgd_logid.lgl_ogen: %#x\n", d->lgd_logid.lgl_ogen); 54 CDEBUG(D_OTHER, "\tlgd_ctxt_idx: %#x\n", d->lgd_ctxt_idx); 55 CDEBUG(D_OTHER, "\tlgd_llh_flags: %#x\n", d->lgd_llh_flags); 56 CDEBUG(D_OTHER, "\tlgd_index: %#x\n", d->lgd_index); 57 CDEBUG(D_OTHER, "\tlgd_saved_index: %#x\n", d->lgd_saved_index); 58 CDEBUG(D_OTHER, "\tlgd_len: %#x\n", d->lgd_len); 59 CDEBUG(D_OTHER, "\tlgd_cur_offset: "LPX64"\n", d->lgd_cur_offset); 60} 61 62void lustre_swab_lu_fid(struct lu_fid *fid) 63{ 64 __swab64s (&fid->f_seq); 65 __swab32s (&fid->f_oid); 66 __swab32s (&fid->f_ver); 67} 68EXPORT_SYMBOL(lustre_swab_lu_fid); 69 70void lustre_swab_ost_id(struct ost_id *oid) 71{ 72 if (fid_seq_is_mdt0(oid->oi.oi_seq)) { 73 __swab64s(&oid->oi.oi_id); 74 __swab64s(&oid->oi.oi_seq); 75 } else { 76 lustre_swab_lu_fid(&oid->oi_fid); 77 } 78} 79EXPORT_SYMBOL(lustre_swab_ost_id); 80 81void lustre_swab_llogd_body (struct llogd_body *d) 82{ 83 ENTRY; 84 print_llogd_body(d); 85 lustre_swab_ost_id(&d->lgd_logid.lgl_oi); 86 __swab32s (&d->lgd_logid.lgl_ogen); 87 __swab32s (&d->lgd_ctxt_idx); 88 __swab32s (&d->lgd_llh_flags); 89 __swab32s (&d->lgd_index); 90 __swab32s (&d->lgd_saved_index); 91 __swab32s (&d->lgd_len); 92 __swab64s (&d->lgd_cur_offset); 93 print_llogd_body(d); 94 EXIT; 95} 96EXPORT_SYMBOL(lustre_swab_llogd_body); 97 98void lustre_swab_llogd_conn_body (struct llogd_conn_body *d) 99{ 100 __swab64s (&d->lgdc_gen.mnt_cnt); 101 __swab64s (&d->lgdc_gen.conn_cnt); 102 lustre_swab_ost_id(&d->lgdc_logid.lgl_oi); 103 __swab32s (&d->lgdc_logid.lgl_ogen); 104 __swab32s (&d->lgdc_ctxt_idx); 105} 106EXPORT_SYMBOL(lustre_swab_llogd_conn_body); 107 108void lustre_swab_ll_fid(struct ll_fid *fid) 109{ 110 __swab64s (&fid->id); 111 __swab32s (&fid->generation); 112 __swab32s (&fid->f_type); 113} 114EXPORT_SYMBOL(lustre_swab_ll_fid); 115 116void lustre_swab_lu_seq_range(struct lu_seq_range *range) 117{ 118 __swab64s (&range->lsr_start); 119 __swab64s (&range->lsr_end); 120 __swab32s (&range->lsr_index); 121 __swab32s (&range->lsr_flags); 122} 123EXPORT_SYMBOL(lustre_swab_lu_seq_range); 124 125void lustre_swab_llog_rec(struct llog_rec_hdr *rec) 126{ 127 struct llog_rec_tail *tail = NULL; 128 129 __swab32s(&rec->lrh_len); 130 __swab32s(&rec->lrh_index); 131 __swab32s(&rec->lrh_type); 132 __swab32s(&rec->lrh_id); 133 134 switch (rec->lrh_type) { 135 case OST_SZ_REC: 136 { 137 struct llog_size_change_rec *lsc = 138 (struct llog_size_change_rec *)rec; 139 140 lustre_swab_ll_fid(&lsc->lsc_fid); 141 __swab32s(&lsc->lsc_ioepoch); 142 tail = &lsc->lsc_tail; 143 break; 144 } 145 case MDS_UNLINK_REC: 146 { 147 struct llog_unlink_rec *lur = (struct llog_unlink_rec *)rec; 148 149 __swab64s(&lur->lur_oid); 150 __swab32s(&lur->lur_oseq); 151 __swab32s(&lur->lur_count); 152 tail = &lur->lur_tail; 153 break; 154 } 155 case MDS_UNLINK64_REC: 156 { 157 struct llog_unlink64_rec *lur = 158 (struct llog_unlink64_rec *)rec; 159 160 lustre_swab_lu_fid(&lur->lur_fid); 161 __swab32s(&lur->lur_count); 162 tail = &lur->lur_tail; 163 break; 164 } 165 case CHANGELOG_REC: 166 { 167 struct llog_changelog_rec *cr = (struct llog_changelog_rec*)rec; 168 169 __swab16s(&cr->cr.cr_namelen); 170 __swab16s(&cr->cr.cr_flags); 171 __swab32s(&cr->cr.cr_type); 172 __swab64s(&cr->cr.cr_index); 173 __swab64s(&cr->cr.cr_prev); 174 __swab64s(&cr->cr.cr_time); 175 lustre_swab_lu_fid(&cr->cr.cr_tfid); 176 lustre_swab_lu_fid(&cr->cr.cr_pfid); 177 if (CHANGELOG_REC_EXTENDED(&cr->cr)) { 178 struct llog_changelog_ext_rec *ext = 179 (struct llog_changelog_ext_rec *)rec; 180 181 lustre_swab_lu_fid(&ext->cr.cr_sfid); 182 lustre_swab_lu_fid(&ext->cr.cr_spfid); 183 tail = &ext->cr_tail; 184 } else { 185 tail = &cr->cr_tail; 186 } 187 break; 188 } 189 case CHANGELOG_USER_REC: 190 { 191 struct llog_changelog_user_rec *cur = 192 (struct llog_changelog_user_rec*)rec; 193 194 __swab32s(&cur->cur_id); 195 __swab64s(&cur->cur_endrec); 196 tail = &cur->cur_tail; 197 break; 198 } 199 200 case MDS_SETATTR64_REC: 201 { 202 struct llog_setattr64_rec *lsr = 203 (struct llog_setattr64_rec *)rec; 204 205 lustre_swab_ost_id(&lsr->lsr_oi); 206 __swab32s(&lsr->lsr_uid); 207 __swab32s(&lsr->lsr_uid_h); 208 __swab32s(&lsr->lsr_gid); 209 __swab32s(&lsr->lsr_gid_h); 210 tail = &lsr->lsr_tail; 211 break; 212 } 213 case OBD_CFG_REC: 214 /* these are swabbed as they are consumed */ 215 break; 216 case LLOG_HDR_MAGIC: 217 { 218 struct llog_log_hdr *llh = (struct llog_log_hdr *)rec; 219 220 __swab64s(&llh->llh_timestamp); 221 __swab32s(&llh->llh_count); 222 __swab32s(&llh->llh_bitmap_offset); 223 __swab32s(&llh->llh_flags); 224 __swab32s(&llh->llh_size); 225 __swab32s(&llh->llh_cat_idx); 226 tail = &llh->llh_tail; 227 break; 228 } 229 case LLOG_LOGID_MAGIC: 230 { 231 struct llog_logid_rec *lid = (struct llog_logid_rec *)rec; 232 233 lustre_swab_ost_id(&lid->lid_id.lgl_oi); 234 __swab32s(&lid->lid_id.lgl_ogen); 235 tail = &lid->lid_tail; 236 break; 237 } 238 case LLOG_GEN_REC: 239 { 240 struct llog_gen_rec *lgr = (struct llog_gen_rec *)rec; 241 242 __swab64s(&lgr->lgr_gen.mnt_cnt); 243 __swab64s(&lgr->lgr_gen.conn_cnt); 244 tail = &lgr->lgr_tail; 245 break; 246 } 247 case LLOG_PAD_MAGIC: 248 break; 249 default: 250 CERROR("Unknown llog rec type %#x swabbing rec %p\n", 251 rec->lrh_type, rec); 252 } 253 254 if (tail) { 255 __swab32s(&tail->lrt_len); 256 __swab32s(&tail->lrt_index); 257 } 258} 259EXPORT_SYMBOL(lustre_swab_llog_rec); 260 261static void print_llog_hdr(struct llog_log_hdr *h) 262{ 263 CDEBUG(D_OTHER, "llog header: %p\n", h); 264 CDEBUG(D_OTHER, "\tllh_hdr.lrh_index: %#x\n", h->llh_hdr.lrh_index); 265 CDEBUG(D_OTHER, "\tllh_hdr.lrh_len: %#x\n", h->llh_hdr.lrh_len); 266 CDEBUG(D_OTHER, "\tllh_hdr.lrh_type: %#x\n", h->llh_hdr.lrh_type); 267 CDEBUG(D_OTHER, "\tllh_timestamp: "LPX64"\n", h->llh_timestamp); 268 CDEBUG(D_OTHER, "\tllh_count: %#x\n", h->llh_count); 269 CDEBUG(D_OTHER, "\tllh_bitmap_offset: %#x\n", h->llh_bitmap_offset); 270 CDEBUG(D_OTHER, "\tllh_flags: %#x\n", h->llh_flags); 271 CDEBUG(D_OTHER, "\tllh_size: %#x\n", h->llh_size); 272 CDEBUG(D_OTHER, "\tllh_cat_idx: %#x\n", h->llh_cat_idx); 273 CDEBUG(D_OTHER, "\tllh_tail.lrt_index: %#x\n", h->llh_tail.lrt_index); 274 CDEBUG(D_OTHER, "\tllh_tail.lrt_len: %#x\n", h->llh_tail.lrt_len); 275} 276 277void lustre_swab_llog_hdr (struct llog_log_hdr *h) 278{ 279 ENTRY; 280 print_llog_hdr(h); 281 282 lustre_swab_llog_rec(&h->llh_hdr); 283 284 print_llog_hdr(h); 285 EXIT; 286} 287EXPORT_SYMBOL(lustre_swab_llog_hdr); 288 289static void print_lustre_cfg(struct lustre_cfg *lcfg) 290{ 291 int i; 292 ENTRY; 293 294 if (!(libcfs_debug & D_OTHER)) /* don't loop on nothing */ 295 return; 296 CDEBUG(D_OTHER, "lustre_cfg: %p\n", lcfg); 297 CDEBUG(D_OTHER, "\tlcfg->lcfg_version: %#x\n", lcfg->lcfg_version); 298 299 CDEBUG(D_OTHER, "\tlcfg->lcfg_command: %#x\n", lcfg->lcfg_command); 300 CDEBUG(D_OTHER, "\tlcfg->lcfg_num: %#x\n", lcfg->lcfg_num); 301 CDEBUG(D_OTHER, "\tlcfg->lcfg_flags: %#x\n", lcfg->lcfg_flags); 302 CDEBUG(D_OTHER, "\tlcfg->lcfg_nid: %s\n", libcfs_nid2str(lcfg->lcfg_nid)); 303 304 CDEBUG(D_OTHER, "\tlcfg->lcfg_bufcount: %d\n", lcfg->lcfg_bufcount); 305 if (lcfg->lcfg_bufcount < LUSTRE_CFG_MAX_BUFCOUNT) 306 for (i = 0; i < lcfg->lcfg_bufcount; i++) 307 CDEBUG(D_OTHER, "\tlcfg->lcfg_buflens[%d]: %d\n", 308 i, lcfg->lcfg_buflens[i]); 309 EXIT; 310} 311 312void lustre_swab_lustre_cfg(struct lustre_cfg *lcfg) 313{ 314 int i; 315 ENTRY; 316 317 __swab32s(&lcfg->lcfg_version); 318 319 if (lcfg->lcfg_version != LUSTRE_CFG_VERSION) { 320 CERROR("not swabbing lustre_cfg version %#x (expecting %#x)\n", 321 lcfg->lcfg_version, LUSTRE_CFG_VERSION); 322 EXIT; 323 return; 324 } 325 326 __swab32s(&lcfg->lcfg_command); 327 __swab32s(&lcfg->lcfg_num); 328 __swab32s(&lcfg->lcfg_flags); 329 __swab64s(&lcfg->lcfg_nid); 330 __swab32s(&lcfg->lcfg_bufcount); 331 for (i = 0; i < lcfg->lcfg_bufcount && i < LUSTRE_CFG_MAX_BUFCOUNT; i++) 332 __swab32s(&lcfg->lcfg_buflens[i]); 333 334 print_lustre_cfg(lcfg); 335 EXIT; 336 return; 337} 338EXPORT_SYMBOL(lustre_swab_lustre_cfg); 339 340/* used only for compatibility with old on-disk cfg_marker data */ 341struct cfg_marker32 { 342 __u32 cm_step; 343 __u32 cm_flags; 344 __u32 cm_vers; 345 __u32 padding; 346 __u32 cm_createtime; 347 __u32 cm_canceltime; 348 char cm_tgtname[MTI_NAME_MAXLEN]; 349 char cm_comment[MTI_NAME_MAXLEN]; 350}; 351 352#define MTI_NAMELEN32 (MTI_NAME_MAXLEN - \ 353 (sizeof(struct cfg_marker) - sizeof(struct cfg_marker32))) 354 355void lustre_swab_cfg_marker(struct cfg_marker *marker, int swab, int size) 356{ 357 struct cfg_marker32 *cm32 = (struct cfg_marker32*)marker; 358 ENTRY; 359 360 if (swab) { 361 __swab32s(&marker->cm_step); 362 __swab32s(&marker->cm_flags); 363 __swab32s(&marker->cm_vers); 364 } 365 if (size == sizeof(*cm32)) { 366 __u32 createtime, canceltime; 367 /* There was a problem with the original declaration of 368 * cfg_marker on 32-bit systems because it used time_t as 369 * a wire protocol structure, and didn't verify this in 370 * wirecheck. We now have to convert the offsets of the 371 * later fields in order to work on 32- and 64-bit systems. 372 * 373 * Fortunately, the cm_comment field has no functional use 374 * so can be sacrificed when converting the timestamp size. 375 * 376 * Overwrite fields from the end first, so they are not 377 * clobbered, and use memmove() instead of memcpy() because 378 * the source and target buffers overlap. bug 16771 */ 379 createtime = cm32->cm_createtime; 380 canceltime = cm32->cm_canceltime; 381 memmove(marker->cm_comment, cm32->cm_comment, MTI_NAMELEN32); 382 marker->cm_comment[MTI_NAMELEN32 - 1] = '\0'; 383 memmove(marker->cm_tgtname, cm32->cm_tgtname, 384 sizeof(marker->cm_tgtname)); 385 if (swab) { 386 __swab32s(&createtime); 387 __swab32s(&canceltime); 388 } 389 marker->cm_createtime = createtime; 390 marker->cm_canceltime = canceltime; 391 CDEBUG(D_CONFIG, "Find old cfg_marker(Srv32b,Clt64b) " 392 "for target %s, converting\n", 393 marker->cm_tgtname); 394 } else if (swab) { 395 __swab64s(&marker->cm_createtime); 396 __swab64s(&marker->cm_canceltime); 397 } 398 399 EXIT; 400 return; 401} 402EXPORT_SYMBOL(lustre_swab_cfg_marker); 403