Whamcloud - gitweb
6ebbe02c78810fa2b64fe1cc1d0c04e98a1d4036
[fs/lustre-release.git] / lustre / utils / llog_reader.c
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) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2015, 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 /** \defgroup llog_reader Lustre Log Reader
37  *
38  * Interpret llogs used for storing configuration and changelog data
39  *
40  * @{
41  */
42
43 #include <stdio.h>
44 #include <sys/types.h>
45 #include <sys/stat.h>
46 #ifdef HAVE_ENDIAN_H
47 # include <endian.h>
48 #endif
49 #include <unistd.h>
50 #include <fcntl.h>
51 #include <sys/vfs.h>
52 #include <linux/magic.h>
53
54 #include <time.h>
55 #include <lnet/nidstr.h>
56 #include <lustre/lustre_idl.h>
57 #include <lustre/lustreapi.h>
58 #include <lustre_log_user.h>
59 #include <lustre_cfg.h>
60
61 static inline int ext2_test_bit(int nr, const void *addr)
62 {
63 #if __BYTE_ORDER == __BIG_ENDIAN
64         const unsigned char *tmp = addr;
65         return (tmp[nr >> 3] >> (nr & 7)) & 1;
66 #else
67         const unsigned long *tmp = addr;
68         return ((1UL << (nr & (BITS_PER_LONG - 1))) &
69                 ((tmp)[nr / BITS_PER_LONG])) != 0;
70 #endif
71 }
72
73 int llog_pack_buffer(int fd, struct llog_log_hdr **llog_buf,
74                      struct llog_rec_hdr ***recs, int *recs_number);
75
76 void print_llog_header(struct llog_log_hdr *llog_buf);
77 static void print_records(struct llog_rec_hdr **recs_buf,
78                           int rec_number, int is_ext);
79 void llog_unpack_buffer(int fd, struct llog_log_hdr *llog_buf,
80                         struct llog_rec_hdr **recs_buf);
81
82 #define CANCELLED 0x678
83
84 #define PTL_CMD_BASE 100
85 char* portals_command[17]=
86 {
87         "REGISTER_PEER_FD",
88         "CLOSE_CONNECTION",
89         "REGISTER_MYNID",
90         "PUSH_CONNECTION",
91         "GET_CONN",
92         "DEL_PEER",
93         "ADD_PEER",
94         "GET_PEER",
95         "GET_TXDESC",
96         "ADD_ROUTE",
97         "DEL_ROUTE",
98         "GET_ROUTE",
99         "NOTIFY_ROUTER",
100         "ADD_INTERFACE",
101         "DEL_INTERFACE",
102         "GET_INTERFACE",
103         ""
104 };
105
106 int is_fstype_ext(int fd)
107 {
108         struct statfs           st;
109         int                     rc;
110
111         rc = fstatfs(fd, &st);
112         if (rc < 0) {
113                 llapi_error(LLAPI_MSG_ERROR, rc, "Got statfs error.");
114                 return -errno;
115         }
116
117         return (st.f_type == EXT4_SUPER_MAGIC);
118 }
119
120
121 /**
122  * Attempt to display a path to the object (file) containing changelog entries,
123  * referred to by this changelog_catalog record.
124  *
125  * This path depends on the implementation of the OSD device; zfs-osd and
126  * ldiskfs-osd are different.
127  *
128  * Assumes that if the file system containing the changelog_catalog is
129  * ext{2,3,4}, the backend is ldiskfs-osd; otherwise it is either zfs-osd or at
130  * least names objects based on FID and the zfs-osd path (which includes the
131  * FID) will be sufficient.
132  *
133  * The Object ID stored in the record is also displayed untranslated.
134  */
135 #define OSD_OI_FID_NR         (1UL << 7)
136 static void print_log_path(struct llog_logid_rec *lid, int is_ext)
137 {
138
139         char                    object_path[255];
140         struct lu_fid           fid_from_logid;
141
142         logid_to_fid(&lid->lid_id, &fid_from_logid);
143
144         if (is_ext)
145                 snprintf(object_path, sizeof(object_path),
146                          "O/"LPU64"/d%u/%u", fid_from_logid.f_seq,
147                          fid_from_logid.f_oid % 32, fid_from_logid.f_oid);
148         else
149                 snprintf(object_path, sizeof(object_path),
150                          "oi."LPU64"/"DFID_NOBRACE,
151                          fid_from_logid.f_seq & (OSD_OI_FID_NR - 1) ,
152                          PFID(&fid_from_logid));
153
154         printf("ogen=%X id="DOSTID" path=%s\n",
155                 lid->lid_id.lgl_ogen, POSTID(&lid->lid_id.lgl_oi),
156                 object_path);
157 }
158
159 int main(int argc, char **argv)
160 {
161         int rc = 0;
162         int is_ext;
163         int fd, rec_number;
164         struct llog_log_hdr *llog_buf = NULL;
165         struct llog_rec_hdr **recs_buf = NULL;
166
167         setlinebuf(stdout);
168
169         if (argc != 2) {
170                 printf("Usage: llog_reader filename\n");
171                 return -1;
172         }
173
174         fd = open(argv[1], O_RDONLY);
175         if (fd < 0) {
176                 rc = -errno;
177                 llapi_error(LLAPI_MSG_ERROR, rc, "Could not open the file %s.",
178                             argv[1]);
179                 goto out;
180         }
181
182         is_ext = is_fstype_ext(fd);
183         if (is_ext < 0) {
184                 printf("Unable to determine type of filesystem containing %s\n",
185                        argv[1]);
186                 goto out;
187         }
188
189         rc = llog_pack_buffer(fd, &llog_buf, &recs_buf, &rec_number);
190         if (rc < 0) {
191                 llapi_error(LLAPI_MSG_ERROR, rc, "Could not pack buffer.");
192                 goto out_fd;
193         }
194
195         print_llog_header(llog_buf);
196         print_records(recs_buf, rec_number, is_ext);
197         llog_unpack_buffer(fd, llog_buf, recs_buf);
198
199 out_fd:
200         close(fd);
201 out:
202         return rc;
203 }
204
205
206
207 int llog_pack_buffer(int fd, struct llog_log_hdr **llog,
208                      struct llog_rec_hdr ***recs,
209                      int *recs_number)
210 {
211         int rc = 0, recs_num, rd;
212         off_t file_size;
213         struct stat st;
214         char *file_buf = NULL, *recs_buf = NULL;
215         struct llog_rec_hdr **recs_pr = NULL;
216         char *ptr = NULL;
217         int i;
218
219         rc = fstat(fd, &st);
220         if (rc < 0) {
221                 rc = -errno;
222                 llapi_error(LLAPI_MSG_ERROR, rc, "Got file stat error.");
223                 goto out;
224         }
225         file_size = st.st_size;
226         if (file_size == 0) {
227                 rc = -1;
228                 llapi_error(LLAPI_MSG_ERROR, rc, "File is empty.");
229                 goto out;
230         }
231
232         file_buf = malloc(file_size);
233         if (file_buf == NULL) {
234                 rc = -ENOMEM;
235                 llapi_error(LLAPI_MSG_ERROR, rc, "Memory Alloc for file_buf.");
236                 goto out;
237         }
238         *llog = (struct llog_log_hdr *)file_buf;
239
240         rd = read(fd, file_buf, file_size);
241         if (rd < file_size) {
242                 rc = -EIO; /*FIXME*/
243                 llapi_error(LLAPI_MSG_ERROR, rc, "Read file error.");
244                 goto clear_file_buf;
245         }
246
247         /* the llog header not countable here.*/
248         recs_num = le32_to_cpu((*llog)->llh_count) - 1;
249
250         recs_buf = malloc(recs_num * sizeof(struct llog_rec_hdr *));
251         if (recs_buf == NULL) {
252                 rc = -ENOMEM;
253                 llapi_error(LLAPI_MSG_ERROR, rc, "Memory Alloc for recs_buf.");
254                 goto clear_file_buf;
255         }
256         recs_pr = (struct llog_rec_hdr **)recs_buf;
257
258         ptr = file_buf + le32_to_cpu((*llog)->llh_hdr.lrh_len);
259         i = 0;
260
261         while (ptr < (file_buf + file_size)) {
262                 struct llog_rec_hdr *cur_rec;
263                 int idx;
264                 unsigned long offset;
265
266                 if (ptr + sizeof(struct llog_rec_hdr) >
267                     file_buf + file_size) {
268                         rc = -EINVAL;
269                         llapi_error(LLAPI_MSG_ERROR, rc,
270                                     "The log is corrupt (too big at %d)", i);
271                         goto clear_recs_buf;
272                 }
273
274                 cur_rec = (struct llog_rec_hdr *)ptr;
275                 idx = le32_to_cpu(cur_rec->lrh_index);
276                 recs_pr[i] = cur_rec;
277                 offset = (unsigned long)ptr - (unsigned long)file_buf;
278                 if (cur_rec->lrh_len == 0 ||
279                     cur_rec->lrh_len > (*llog)->llh_hdr.lrh_len) {
280                         cur_rec->lrh_len = (*llog)->llh_hdr.lrh_len -
281                                 offset % (*llog)->llh_hdr.lrh_len;
282                         printf("off %lu skip %u to next chunk.\n", offset,
283                                cur_rec->lrh_len);
284                         i--;
285                 } else if (ext2_test_bit(idx, LLOG_HDR_BITMAP(*llog))) {
286                         printf("rec #%d type=%x len=%u offset %lu\n", idx,
287                                cur_rec->lrh_type, cur_rec->lrh_len, offset);
288                 } else {
289                         printf("Bit %d of %d not set\n", idx, recs_num);
290                         cur_rec->lrh_id = CANCELLED;
291                         /* The header counts only set records */
292                         i--;
293                 }
294
295                 ptr += le32_to_cpu(cur_rec->lrh_len);
296                 if ((ptr - file_buf) > file_size) {
297                         printf("The log is corrupt (too big at %d)\n", i);
298                         rc = -EINVAL;
299                         goto clear_recs_buf;
300                 }
301                 i++;
302         }
303
304         *recs = recs_pr;
305         *recs_number = recs_num;
306
307 out:
308         return rc;
309
310 clear_recs_buf:
311         free(recs_buf);
312
313 clear_file_buf:
314         free(file_buf);
315
316         *llog = NULL;
317         goto out;
318 }
319
320 void llog_unpack_buffer(int fd, struct llog_log_hdr *llog_buf,
321                         struct llog_rec_hdr **recs_buf)
322 {
323         free(llog_buf);
324         free(recs_buf);
325         return;
326 }
327
328 void print_llog_header(struct llog_log_hdr *llog_buf)
329 {
330         time_t t;
331
332         printf("Header size : %u\n",
333                le32_to_cpu(llog_buf->llh_hdr.lrh_len));
334
335         t = le64_to_cpu(llog_buf->llh_timestamp);
336         printf("Time : %s", ctime(&t));
337
338         printf("Number of records: %u\n",
339                le32_to_cpu(llog_buf->llh_count)-1);
340
341         printf("Target uuid : %s \n",
342                (char *)(&llog_buf->llh_tgtuuid));
343
344         /* Add the other info you want to view here */
345
346         printf("-----------------------\n");
347         return;
348 }
349
350 static void print_1_cfg(struct lustre_cfg *lcfg)
351 {
352         int i;
353
354         if (lcfg->lcfg_nid)
355                 printf("nid=%s("LPX64")  ", libcfs_nid2str(lcfg->lcfg_nid),
356                        lcfg->lcfg_nid);
357         if (lcfg->lcfg_nal)
358                 printf("nal=%d ", lcfg->lcfg_nal);
359         for (i = 0; i <  lcfg->lcfg_bufcount; i++)
360                 printf("%d:%.*s  ", i, lcfg->lcfg_buflens[i],
361                        (char*)lustre_cfg_buf(lcfg, i));
362         return;
363 }
364
365
366 static void print_setup_cfg(struct lustre_cfg *lcfg)
367 {
368         struct lov_desc *desc;
369
370         if ((lcfg->lcfg_bufcount == 2) &&
371             (lcfg->lcfg_buflens[1] == sizeof(*desc))) {
372                 printf("lov_setup ");
373                 printf("0:%s  ", lustre_cfg_string(lcfg, 0));
374                 printf("1:(struct lov_desc)\n");
375                 desc = (struct lov_desc*)(lustre_cfg_string(lcfg, 1));
376                 printf("\t\tuuid=%s  ", (char*)desc->ld_uuid.uuid);
377                 printf("stripe:cnt=%u ", desc->ld_default_stripe_count);
378                 printf("size="LPU64" ", desc->ld_default_stripe_size);
379                 printf("offset="LPU64" ", desc->ld_default_stripe_offset);
380                 printf("pattern=%#x", desc->ld_pattern);
381         } else {
382                 printf("setup     ");
383                 print_1_cfg(lcfg);
384         }
385
386         return;
387 }
388
389 void print_lustre_cfg(struct lustre_cfg *lcfg, int *skip)
390 {
391         enum lcfg_command_type cmd = le32_to_cpu(lcfg->lcfg_command);
392
393         if (*skip > 0)
394                 printf("SKIP ");
395
396         switch(cmd){
397         case(LCFG_ATTACH):{
398                 printf("attach    ");
399                 print_1_cfg(lcfg);
400                 break;
401         }
402         case(LCFG_SETUP):{
403                 print_setup_cfg(lcfg);
404                 break;
405         }
406         case(LCFG_DETACH):{
407                 printf("detach    ");
408                 print_1_cfg(lcfg);
409                 break;
410         }
411         case(LCFG_CLEANUP):{
412                 printf("cleanup   ");
413                 print_1_cfg(lcfg);
414                 break;
415         }
416         case(LCFG_ADD_UUID):{
417                 printf("add_uuid  ");
418                 print_1_cfg(lcfg);
419                 break;
420         }
421         case(LCFG_DEL_UUID):{
422                 printf("del_uuid  ");
423                 print_1_cfg(lcfg);
424                 break;
425         }
426         case(LCFG_ADD_CONN):{
427                 printf("add_conn  ");
428                 print_1_cfg(lcfg);
429                 break;
430         }
431         case(LCFG_DEL_CONN):{
432                 printf("del_conn  ");
433                 print_1_cfg(lcfg);
434                 break;
435         }
436         case(LCFG_LOV_ADD_OBD):{
437                 printf("lov_modify_tgts add ");
438                 print_1_cfg(lcfg);
439                 break;
440         }
441         case(LCFG_LOV_DEL_OBD):{
442                 printf("lov_modify_tgts del ");
443                 print_1_cfg(lcfg);
444                 break;
445         }
446         case(LCFG_ADD_MDC):{
447                 printf("modify_mdc_tgts add ");
448                 print_1_cfg(lcfg);
449                 break;
450         }
451         case(LCFG_DEL_MDC):{
452                 printf("modify_mdc_tgts del ");
453                 print_1_cfg(lcfg);
454                 break;
455         }
456         case(LCFG_MOUNTOPT):{
457                 printf("mount_option ");
458                 print_1_cfg(lcfg);
459                 break;
460         }
461         case(LCFG_DEL_MOUNTOPT):{
462                 printf("del_mount_option ");
463                 print_1_cfg(lcfg);
464                 break;
465         }
466         case(LCFG_SET_TIMEOUT):{
467                 printf("set_timeout=%d ", lcfg->lcfg_num);
468                 break;
469         }
470         case(LCFG_SET_LDLM_TIMEOUT):{
471                 printf("set_ldlm_timeout=%d ", lcfg->lcfg_num);
472                 break;
473         }
474         case(LCFG_SET_UPCALL):{
475                 printf("set_lustre_upcall ");
476                 print_1_cfg(lcfg);
477                 break;
478         }
479         case(LCFG_PARAM):{
480                 printf("param ");
481                 print_1_cfg(lcfg);
482                 break;
483         }
484         case(LCFG_SET_PARAM):{
485                 printf("set_param ");
486                 print_1_cfg(lcfg);
487                 break;
488         }
489         case(LCFG_SPTLRPC_CONF):{
490                 printf("sptlrpc_conf ");
491                 print_1_cfg(lcfg);
492                 break;
493         }
494         case(LCFG_MARKER):{
495                 struct cfg_marker *marker = lustre_cfg_buf(lcfg, 1);
496                 char createtime[26], canceltime[26] = "";
497                 time_t time_tmp;
498
499                 if (marker->cm_flags & CM_START &&
500                     marker->cm_flags & CM_SKIP) {
501                         printf("SKIP START ");
502                         (*skip)++;
503                 } else if (marker->cm_flags & CM_END) {
504                         printf(     "END   ");
505                         *skip = 0;
506                 }
507
508                 if (marker->cm_flags & CM_EXCLUDE) {
509                         if (marker->cm_flags & CM_START)
510                                 printf("EXCLUDE START ");
511                         else
512                                 printf("EXCLUDE END   ");
513                 }
514
515                 /* Handle overflow of 32-bit time_t gracefully.
516                  * The copy to time_tmp is needed in any case to
517                  * keep the pointer happy, even on 64-bit systems. */
518                 time_tmp = marker->cm_createtime;
519                 if (time_tmp == marker->cm_createtime) {
520                         ctime_r(&time_tmp, createtime);
521                         createtime[strlen(createtime) - 1] = 0;
522                 } else {
523                         strcpy(createtime, "in the distant future");
524                 }
525
526                 if (marker->cm_canceltime) {
527                         /* Like cm_createtime, we try to handle overflow of
528                          * 32-bit time_t gracefully. The copy to time_tmp
529                          * is also needed on 64-bit systems to keep the
530                          * pointer happy, see bug 16771 */
531                         time_tmp = marker->cm_canceltime;
532                         if (time_tmp == marker->cm_canceltime) {
533                                 ctime_r(&time_tmp, canceltime);
534                                 canceltime[strlen(canceltime) - 1] = 0;
535                         } else {
536                                 strcpy(canceltime, "in the distant future");
537                         }
538                 }
539
540                 printf("marker %3d (flags=%#04x, v%d.%d.%d.%d) %-15s '%s' %s-%s",
541                        marker->cm_step, marker->cm_flags,
542                        OBD_OCD_VERSION_MAJOR(marker->cm_vers),
543                        OBD_OCD_VERSION_MINOR(marker->cm_vers),
544                        OBD_OCD_VERSION_PATCH(marker->cm_vers),
545                        OBD_OCD_VERSION_FIX(marker->cm_vers),
546                        marker->cm_tgtname, marker->cm_comment,
547                        createtime, canceltime);
548                 break;
549         }
550         case(LCFG_POOL_NEW):{
551                 printf("pool new ");
552                 print_1_cfg(lcfg);
553                 break;
554         }
555         case(LCFG_POOL_ADD):{
556                 printf("pool add ");
557                 print_1_cfg(lcfg);
558                 break;
559         }
560         case(LCFG_POOL_REM):{
561                 printf("pool remove ");
562                 print_1_cfg(lcfg);
563                 break;
564         }
565         case(LCFG_POOL_DEL):{
566                 printf("pool destroy ");
567                 print_1_cfg(lcfg);
568                 break;
569         }
570         default:
571                 printf("unsupported cmd_code = %x\n",cmd);
572         }
573         printf("\n");
574         return;
575 }
576
577 static void print_hsm_action(struct llog_agent_req_rec *larr)
578 {
579         char    buf[12];
580         int     sz;
581
582         sz = larr->arr_hai.hai_len - sizeof(larr->arr_hai);
583         printf("lrh=[type=%X len=%d idx=%d] fid="DFID
584                " compound/cookie="LPX64"/"LPX64
585                " status=%s action=%s archive#=%d flags="LPX64
586                " create="LPU64" change="LPU64
587                " extent="LPX64"-"LPX64" gid="LPX64" datalen=%d"
588                " data=[%s]\n",
589                larr->arr_hdr.lrh_type,
590                larr->arr_hdr.lrh_len, larr->arr_hdr.lrh_index,
591                PFID(&larr->arr_hai.hai_fid),
592                larr->arr_compound_id, larr->arr_hai.hai_cookie,
593                agent_req_status2name(larr->arr_status),
594                hsm_copytool_action2name(larr->arr_hai.hai_action),
595                larr->arr_archive_id,
596                larr->arr_flags,
597                larr->arr_req_create, larr->arr_req_change,
598                larr->arr_hai.hai_extent.offset,
599                larr->arr_hai.hai_extent.length,
600                larr->arr_hai.hai_gid, sz,
601                hai_dump_data_field(&larr->arr_hai, buf, sizeof(buf)));
602 }
603
604 void print_changelog_rec(struct llog_changelog_rec *rec)
605 {
606         printf("changelog record id:0x%x cr_flags:0x%x cr_type:%s(0x%x)\n",
607                le32_to_cpu(rec->cr_hdr.lrh_id),
608                le32_to_cpu(rec->cr.cr_flags),
609                changelog_type2str(le32_to_cpu(rec->cr.cr_type)),
610                le32_to_cpu(rec->cr.cr_type));
611 }
612
613 static void print_records(struct llog_rec_hdr **recs,
614                           int rec_number, int is_ext)
615 {
616         __u32 lopt;
617         int i, skip = 0;
618
619         for (i = 0; i < rec_number; i++) {
620                 printf("#%.2d (%.3d)", le32_to_cpu(recs[i]->lrh_index),
621                        le32_to_cpu(recs[i]->lrh_len));
622
623                 lopt = le32_to_cpu(recs[i]->lrh_type);
624
625                 if (recs[i]->lrh_id == CANCELLED)
626                         printf("NOT SET ");
627
628                 switch (lopt) {
629                 case OBD_CFG_REC:
630                         print_lustre_cfg(
631                                 (struct lustre_cfg *)((char *)(recs[i]) +
632                                 sizeof(struct llog_rec_hdr)), &skip);
633                         break;
634                 case LLOG_PAD_MAGIC:
635                         printf("padding\n");
636                         break;
637                 case LLOG_LOGID_MAGIC:
638                         print_log_path((struct llog_logid_rec *)recs[i],
639                                        is_ext);
640                         break;
641                 case HSM_AGENT_REC:
642                         print_hsm_action((struct llog_agent_req_rec *)recs[i]);
643                         break;
644                 case CHANGELOG_REC:
645                         print_changelog_rec((struct llog_changelog_rec *)
646                                             recs[i]);
647                         break;
648                 case CHANGELOG_USER_REC:
649                         printf("changelog_user record id:0x%x\n",
650                                le32_to_cpu(recs[i]->lrh_id));
651                         break;
652                 default:
653                         printf("unknown type %x\n", lopt);
654                         break;
655                 }
656         }
657 }
658
659 /** @} llog_reader */