X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Futils%2Fllog_reader.c;h=2a1903b1c86204476de9ad53fe95c7f4f8ff77ab;hb=0d92e17afa7ff7024d3e18268a2e1a89cba4d5bd;hp=dec25e475fdb910f28c4dc2a8a3e6a5c3c5a2263;hpb=d2d56f38da01001c92a09afc6b52b5acbd9bc13c;p=fs%2Flustre-release.git diff --git a/lustre/utils/llog_reader.c b/lustre/utils/llog_reader.c index dec25e4..2a1903b 100644 --- a/lustre/utils/llog_reader.c +++ b/lustre/utils/llog_reader.c @@ -1,23 +1,37 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: +/* + * GPL HEADER START * - * Copyright (C) 2006 Cluster File Systems, Inc. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * This file is part of Lustre, http://www.lustre.org. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. * - * Lustre is free software; you can redistribute it and/or - * modify it under the terms of version 2 of the GNU General Public - * License as published by the Free Software Foundation. + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). * - * Lustre is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * You should have received a copy of the GNU General Public License + * version 2 along with this program; If not, see + * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf * - * You should have received a copy of the GNU General Public License - * along with Lustre; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. * + * GPL HEADER END + */ +/* + * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. + * Use is subject to license terms. + * + * Copyright (c) 2011, 2012, Intel Corporation. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. */ /* Interpret configuration llogs */ @@ -25,11 +39,23 @@ #include #include #include +#include #include #include -#include +#include #include +#include + +static inline int ext2_test_bit(int nr, const void *addr) +{ +#if __BYTE_ORDER == __BIG_ENDIAN + const unsigned char *tmp = addr; + return (tmp[nr >> 3] >> (nr & 7)) & 1; +#else + return test_bit(nr, addr); +#endif +} int llog_pack_buffer(int fd, struct llog_log_hdr **llog_buf, struct llog_rec_hdr ***recs, int *recs_number); @@ -153,16 +179,16 @@ int llog_pack_buffer(int fd, struct llog_log_hdr **llog, recs_pr[i] = cur_rec; if (ext2_test_bit(idx, (*llog)->llh_bitmap)) { - if (le32_to_cpu(cur_rec->lrh_type) != OBD_CFG_REC) + if (le32_to_cpu(cur_rec->lrh_type) != OBD_CFG_REC) printf("rec #%d type=%x len=%u\n", idx, cur_rec->lrh_type, cur_rec->lrh_len); } else { printf("Bit %d of %d not set\n", idx, recs_num); - cur_rec->padding = CANCELLED; + cur_rec->lrh_id = CANCELLED; /* The header counts only set records */ i--; } - + ptr += le32_to_cpu(cur_rec->lrh_len); if ((ptr - file_buf) > file_size) { printf("The log is corrupt (too big at %d)\n", i); @@ -336,7 +362,10 @@ void print_lustre_cfg(struct lustre_cfg *lcfg, int *skip) } case(LCFG_SET_TIMEOUT):{ printf("set_timeout=%d ", lcfg->lcfg_num); - print_1_cfg(lcfg); + break; + } + case(LCFG_SET_LDLM_TIMEOUT):{ + printf("set_ldlm_timeout=%d ", lcfg->lcfg_num); break; } case(LCFG_SET_UPCALL):{ @@ -344,14 +373,25 @@ void print_lustre_cfg(struct lustre_cfg *lcfg, int *skip) print_1_cfg(lcfg); break; } - case(LCFG_PARAM):{ - printf("param "); + case(LCFG_PARAM):{ + printf("param "); + print_1_cfg(lcfg); + break; + } + case(LCFG_SET_PARAM):{ + printf("set_param "); + print_1_cfg(lcfg); + break; + } + case(LCFG_SPTLRPC_CONF):{ + printf("sptlrpc_conf "); print_1_cfg(lcfg); break; } case(LCFG_MARKER):{ struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1); char createtime[26], canceltime[26] = ""; + time_t time_tmp; if (marker->cm_flags & CM_SKIP) { if (marker->cm_flags & CM_START) { @@ -362,18 +402,39 @@ void print_lustre_cfg(struct lustre_cfg *lcfg, int *skip) *skip = 0; } } + if (marker->cm_flags & CM_EXCLUDE) { - if (marker->cm_flags & CM_START) + if (marker->cm_flags & CM_START) printf("EXCLUDE START "); else printf("EXCLUDE END "); } - ctime_r(&marker->cm_createtime, createtime); - createtime[strlen(createtime) - 1] = 0; + + /* Handle overflow of 32-bit time_t gracefully. + * The copy to time_tmp is needed in any case to + * keep the pointer happy, even on 64-bit systems. */ + time_tmp = marker->cm_createtime; + if (time_tmp == marker->cm_createtime) { + ctime_r(&time_tmp, createtime); + createtime[strlen(createtime) - 1] = 0; + } else { + strcpy(createtime, "in the distant future"); + } + if (marker->cm_canceltime) { - ctime_r(&marker->cm_canceltime, canceltime); - canceltime[strlen(canceltime) - 1] = 0; + /* Like cm_createtime, we try to handle overflow of + * 32-bit time_t gracefully. The copy to time_tmp + * is also needed on 64-bit systems to keep the + * pointer happy, see bug 16771 */ + time_tmp = marker->cm_canceltime; + if (time_tmp == marker->cm_canceltime) { + ctime_r(&time_tmp, canceltime); + canceltime[strlen(canceltime) - 1] = 0; + } else { + strcpy(canceltime, "in the distant future"); + } } + printf("marker %3d (flags=%#04x, v%d.%d.%d.%d) %-15s '%s' %s-%s", marker->cm_step, marker->cm_flags, OBD_OCD_VERSION_MAJOR(marker->cm_vers), @@ -384,6 +445,26 @@ void print_lustre_cfg(struct lustre_cfg *lcfg, int *skip) createtime, canceltime); break; } + case(LCFG_POOL_NEW):{ + printf("pool new "); + print_1_cfg(lcfg); + break; + } + case(LCFG_POOL_ADD):{ + printf("pool add "); + print_1_cfg(lcfg); + break; + } + case(LCFG_POOL_REM):{ + printf("pool remove "); + print_1_cfg(lcfg); + break; + } + case(LCFG_POOL_DEL):{ + printf("pool destroy "); + print_1_cfg(lcfg); + break; + } default: printf("unsupported cmd_code = %x\n",cmd); } @@ -391,28 +472,72 @@ void print_lustre_cfg(struct lustre_cfg *lcfg, int *skip) return; } +static void print_logid(struct llog_logid_rec *lid) +{ + printf("ogen=%X name="DOSTID"\n", + lid->lid_id.lgl_ogen, + POSTID(&lid->lid_id.lgl_oi)); +} + +static void print_hsm_action(struct llog_agent_req_rec *larr) +{ + char buf[12]; + int sz; + + sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai); + printf("lrh=[type=%X len=%d idx=%d] fid="DFID + " compound/cookie="LPX64"/"LPX64 + " status=%s action=%s archive#=%d flags="LPX64 + " create="LPU64" change="LPU64 + " extent="LPX64"-"LPX64" gid="LPX64" datalen=%d" + " data=[%s]\n", + larr->arr_hdr.lrh_type, + larr->arr_hdr.lrh_len, larr->arr_hdr.lrh_index, + PFID(&larr->arr_hai.hai_fid), + larr->arr_compound_id, larr->arr_hai.hai_cookie, + agent_req_status2name(larr->arr_status), + hsm_copytool_action2name(larr->arr_hai.hai_action), + larr->arr_archive_id, + larr->arr_flags, + larr->arr_req_create, larr->arr_req_change, + larr->arr_hai.hai_extent.offset, + larr->arr_hai.hai_extent.length, + larr->arr_hai.hai_gid, sz, + hai_dump_data_field(&larr->arr_hai, buf, sizeof(buf))); +} + void print_records(struct llog_rec_hdr **recs, int rec_number) { - __u32 lopt; - int i, skip = 0; - - for(i = 0; i < rec_number; i++) { - printf("#%.2d (%.3d)", le32_to_cpu(recs[i]->lrh_index), - le32_to_cpu(recs[i]->lrh_len)); - - lopt = le32_to_cpu(recs[i]->lrh_type); - - if (recs[i]->padding == CANCELLED) - printf("NOT SET "); - - if (lopt == OBD_CFG_REC) { - struct lustre_cfg *lcfg; - lcfg = (struct lustre_cfg *)((char*)(recs[i]) + - sizeof(struct llog_rec_hdr)); - print_lustre_cfg(lcfg, &skip); - } else if (lopt == LLOG_PAD_MAGIC) { - printf("padding\n"); - } else - printf("unknown type %x\n", lopt); - } + __u32 lopt; + int i, skip = 0; + + for (i = 0; i < rec_number; i++) { + printf("#%.2d (%.3d)", le32_to_cpu(recs[i]->lrh_index), + le32_to_cpu(recs[i]->lrh_len)); + + lopt = le32_to_cpu(recs[i]->lrh_type); + + if (recs[i]->lrh_id == CANCELLED) + printf("NOT SET "); + + switch (lopt) { + case OBD_CFG_REC: + print_lustre_cfg( + (struct lustre_cfg *)((char *)(recs[i]) + + sizeof(struct llog_rec_hdr)), &skip); + break; + case LLOG_PAD_MAGIC: + printf("padding\n"); + break; + case LLOG_LOGID_MAGIC: + print_logid((struct llog_logid_rec *)recs[i]); + break; + case HSM_AGENT_REC: + print_hsm_action((struct llog_agent_req_rec *)recs[i]); + break; + default: + printf("unknown type %x\n", lopt); + break; + } + } }