/*

 *    s390 debug feature command for crash

 *

 *    Copyright (C) IBM Corp. 2006

 *    Author(s): Michael Holzheu <holzheu@de.ibm.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * 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 for more details.

 */

#if defined(S390) || defined(S390X)

#include "defs.h"

#include <iconv.h>

#include <ctype.h>

/*

 * Compat layer to integrate lcrash commands into crash

 * Maps lcrash API to crash functions

 */

#define KL_NBPW sizeof(long)

#define KL_ERRORFP stderr

#define MAX_ARGS 128

#define MAX_CMDLINE 256

#define C_FALSE         0x00000001   /* Command takes no arguments */

#define C_TRUE          0x00000002   /* Command requires arguments */

#define C_ALL           0x00000004   /* All elements */

#define C_PERM          0x00000008   /* Allocate perminant blocks */

#define C_TEMP          0x00000000   /* For completeness */

#define C_FULL          0x00000010   /* Full output */

#define C_LIST          0x00000020   /* List items */

#define C_NEXT          0x00000040   /* Follow links */

#define C_WRITE         0x00000080   /* Write output to file */

#define C_NO_OPCHECK    0x00000100   /* Don't reject bad cmd line options */

#define C_ITER          0x00000200   /* set iteration threshold */

#define C_LFLG_SHFT 12

#define KL_ARCH_S390 0

#define KL_ARCH_S390X 1

#ifdef __s390x__

#define KL_ARCH KL_ARCH_S390X

#define FMTPTR "l"

#define KL_PTRSZ 8

#else

#define KL_ARCH KL_ARCH_S390

#define FMTPTR "ll"

#define KL_PTRSZ 4

#endif

/* Start TOD time of kernel in usecs for relative time stamps */

static uint64_t tod_clock_base_us;

typedef unsigned long uaddr_t;

typedef unsigned long kaddr_t;

typedef struct _syment {

	char *s_name;

	kaddr_t s_addr;

} syment_t;

typedef struct option_s {

	struct option_s	*op_next;

	char		op_char;

	char		*op_arg;

} option_t;

typedef struct command_s {

	int		flags;

	char		cmdstr[MAX_CMDLINE];

	char		*command;

	char		*cmdline;

	option_t	*options;

	int		nargs;

	char		*args[MAX_ARGS];

	char		*pipe_cmd;

	FILE		*ofp;

	FILE		*efp;

} command_t;

static inline syment_t* kl_lkup_symaddr(kaddr_t addr)

{

	static syment_t sym;

	struct syment *crash_sym;

	crash_sym = value_search(addr, &sym.s_addr);

	if (!crash_sym)

		return NULL;

	sym.s_name = crash_sym->name;

	return &sy;;

}

static inline syment_t* kl_lkup_symname(char* name)

{

	static syment_t sym;

	sym.s_addr = symbol_value(name);

	sym.s_name = NULL;

	if(!sym.s_addr)

		return NULL;

	else

		return &sy;;

}

static inline void GET_BLOCK(kaddr_t addr, int size, void* ptr)

{

	readmem(addr, KVADDR,ptr,size,"GET_BLOCK",FAULT_ON_ERROR);

}

static inline kaddr_t KL_VREAD_PTR(kaddr_t addr)

{

	unsigned long ptr;

	readmem(addr, KVADDR,&ptr,sizeof(ptr),"GET_BLOCK",FAULT_ON_ERROR);

	return (kaddr_t)ptr;

}

static inline uint32_t KL_GET_UINT32(void* ptr)

{

	return *((uint32_t*)ptr);

}

static inline uint64_t KL_GET_UINT64(void* ptr)

{

	return *((uint64_t*)ptr);

}

static inline kaddr_t KL_GET_PTR(void* ptr)

{

	return *((kaddr_t*)ptr);

}

static inline void* K_PTR(void* addr, char* struct_name, char* member_name)

{

	return addr+MEMBER_OFFSET(struct_name,member_name);

}

static inline unsigned long KL_ULONG(void* ptr, char* struct_name, char*

				     member_name)

{

	return ULONG(ptr+MEMBER_OFFSET(struct_name,member_name));

}

static inline uint32_t KL_VREAD_UINT32(kaddr_t addr)

{

	uint32_t rc;

	readmem(addr, KVADDR,&rc,sizeof(rc),"KL_VREAD_UINT32",FAULT_ON_ERROR);

	return rc;

}

static inline uint32_t KL_INT(void* ptr, char* struct_name, char* member_name)

{

	return UINT(ptr+MEMBER_OFFSET(struct_name,member_name));

}

static inline int set_cmd_flags(command_t *cmd, int flags, char *extraops)

{

	return 0;

}

/* Time of day clock value for 1970/01/01 */

#define TOD_UNIX_EPOCH (0x8126d60e46000000LL - (0x3c26700LL * 1000000 * 4096))

/* Time of day clock value for 1970/01/01 in usecs */

#define TOD_UNIX_EPOCH_US (TOD_UNIX_EPOCH >> 12)

static inline void kl_s390tod_to_timeval(uint64_t todval, struct timeval *xtime)

{

	uint64_t todval_us;

	/* Convert TOD to usec (51th bit of TOD is us) */

	todval_us = todval >> 12;

	/* Add base if we have relative time stamps */

	todval_us += tod_clock_base_us;

	/* Subtract EPOCH that we get time in usec since 1970 */

	todval_us -= TOD_UNIX_EPOCH_US;

	xtime->tv_sec  = todval_us / 1000000;

	xtime->tv_usec = todval_us % 1000000;

}

static inline int kl_struct_len(char* struct_name)

{

	return STRUCT_SIZE(struct_name);

}

static inline kaddr_t kl_funcaddr(kaddr_t addr)

{

	struct syment *crash_sym;

	crash_sym = value_search(addr, &addr);

	if (!crash_sym)

		return -1;

	else

		return crash_sym->value;

}

#define CMD_USAGE(cmd, s) \

	fprintf(cmd->ofp, "Usage: %s %s\n", cmd->command, s); \

	fprintf(cmd->ofp, "Enter \"help %s\" for details.\n",cmd->command);

/*

 * s390 debug feature implementation

 */

#ifdef DBF_DYNAMIC_VIEWS	/* views defined in shared libs */

#include <dlfcn.h>

#endif

/* Local flags

 */

#define LOAD_FLAG (1 << C_LFLG_SHFT)

#define VIEWS_FLAG (2 << C_LFLG_SHFT)

#define SAVE_DBF_FLAG (4 << C_LFLG_SHFT)

#ifndef MIN

#define MIN(a,b) (((a)<(b))?(a):(b))

#endif

/* Stuff which has to match with include/asm-s390/debug.h */

#define DBF_VERSION_V1 1

#define DBF_VERSION_V2 2

#define PAGE_SIZE 4096

#define DEBUG_MAX_VIEWS	    10 /* max number of views in proc fs */

#define DEBUG_MAX_PROCF_LEN	64 /* max length for a proc file name */

#define DEBUG_SPRINTF_MAX_ARGS 10

/* define debug-structures for lcrash */

#define DEBUG_DATA(entry) (char*)(entry + 1)

typedef struct debug_view_s debug_view_t;

/* struct to hold contents of struct __debug_entry from dump

 */

typedef struct debug_entry_s{

	union {

		struct {

			unsigned long long clock:52;

			unsigned long long exception:1;

			unsigned long long level:3;

			unsigned long long cpuid:8;

		} fields;

		unsigned long long stck;

	} id;

	kaddr_t caller; /* changed from void* to kaddr_t */

} __attribute__((packed)) debug_entry_t;

/* typedef struct __debug_entry debug_entry_t; */

static unsigned int dbf_version;

/* struct is used to manage contents of structs debug_info from dump

 * in lcrash

 */

typedef struct debug_info_s {

	struct debug_info_s *next;

	struct debug_info_s *prev;

	kaddr_t next_dbi;   /* store next ptr of struct in dump */

	kaddr_t prev_dbi;   /* store prev ptr of struct in dump */

	int level;

	int nr_areas;

	int page_order;

	int buf_size;

	int entry_size;

	void **areas; /* contents of debug areas from dump */

	int active_area;

	int *active_entry; /* change to uint32_t ? */

	debug_view_t *views[DEBUG_MAX_VIEWS];

	char name[DEBUG_MAX_PROCF_LEN];

	kaddr_t addr;

	int pages_per_area_v2;

	void ***areas_v2;

} debug_info_t;

/* functions to generate dbf output

 */

typedef int (debug_header_proc_t) (debug_info_t* id, debug_view_t* view,

				   int area, debug_entry_t* entry,

				   char* out_buf);

typedef int (debug_format_proc_t) (debug_info_t* id, debug_view_t* view,

				   char* out_buf, const char* in_buf);

typedef int (debug_prolog_proc_t) (debug_info_t* id, debug_view_t* view,

				   char* out_buf);

struct debug_view_s {

	char name[DEBUG_MAX_PROCF_LEN];

	debug_prolog_proc_t* prolog_proc;

	debug_header_proc_t* header_proc;

	debug_format_proc_t* format_proc;

	void*		private_data;

};

#define LCRASH_DB_VIEWS 1000

static debug_info_t *debug_area_first = NULL;

static debug_info_t *debug_area_last  = NULL;

static debug_view_t *debug_views[LCRASH_DB_VIEWS];

static int initialized = 0;

static iconv_t ebcdic_ascii_conv = 0;

void s390dbf_usage(command_t * cmd);

static int add_lcrash_debug_view(debug_view_t *);

static int dbe_size = 0;

static void

EBCASC(char *inout, size_t len)

{

	iconv(ebcdic_ascii_conv, &inout, &len, &inout, &len;;

}

/*

 * prints header for debug entry

 */

static int

dflt_header_fn(debug_info_t * id, debug_view_t *view,

	       int area, debug_entry_t * entry, char *out_buf)

{

	struct timeval time_val;

	unsigned long long time;

	char *except_str;

	kaddr_t caller;

	int rc = 0;

	char *caller_name;

	int offset;

	char caller_buf[30];

	unsigned int level;

	syment_t *caller_sym;

	debug_entry_t lentry; /* store byte swapped values of entry */

	lentry.id.stck = KL_GET_UINT64(&entry->id);

	lentry.caller = KL_GET_PTR(&entry->caller);

	level = lentry.id.fields.level;

	time = lentry.id.stck;

	kl_s390tod_to_timeval(time, &time_val);

	if (lentry.id.fields.exception)

		except_str = "*";

	else

		except_str = "-";

	caller = lentry.caller;

	if(KL_ARCH == KL_ARCH_S390){

		caller &= 0x7fffffff;

	}

	caller_sym = kl_lkup_symaddr(caller);

	if(caller_sym){

		caller_name = caller_sym->s_name;

		offset = caller - kl_funcaddr(caller);

	}

	else {

		sprintf(caller_buf, "%llx", (unsigned long long)caller);

		caller_name = caller_buf;

		offset = 0;

	}

	if(KL_ARCH == KL_ARCH_S390X){

		rc += sprintf(out_buf, 

			      "%02i %011lu:%06lu %1u %1s %02i <%20s+%04i>  ",

			      area, time_val.tv_sec, time_val.tv_usec, level,

			      except_str, entry->id.fields.cpuid, caller_name,

			      offset);

	} else {

		rc += sprintf(out_buf,

			      "%02i %011lu:%06lu %1u %1s %02i <%-20s+%04i>  ",

			      area, time_val.tv_sec, time_val.tv_usec, level,

			      except_str, lentry.id.fields.cpuid, caller_name,

			      offset);

	}

	return rc;

}

/*

 * prints debug header in raw format

 */

static int

raw_header_fn(debug_info_t * id, debug_view_t *view,

	      int area, debug_entry_t * entry, char *out_buf)

{

	int rc;

	rc = sizeof(debug_entry_t);

	if (out_buf == NULL)

		goto out;

	memcpy(out_buf,entry,sizeof(debug_entry_t));

      out:

	return rc;

}

/*

 * prints debug data in raw format

 */

static int

raw_format_fn(debug_info_t * id, debug_view_t *view,

	      char *out_buf, const char *in_buf)

{

	int rc;

	rc = id->buf_size;

	if (out_buf == NULL || in_buf == NULL)

		goto out;

	memcpy(out_buf, in_buf, id->buf_size);

      out:

	return rc;

}

/*

 * prints debug data in hex/ascii format

 */

static int

hex_ascii_format_fn(debug_info_t * id, debug_view_t *view,

		    char *out_buf, const char *in_buf)

{

	int i, rc = 0;

	if (out_buf == NULL || in_buf == NULL) {

		rc = id->buf_size * 4 + 3;

		goto out;

	}

	for (i = 0; i < id->buf_size; i++) {

		rc += sprintf(out_buf + rc, "%02x ",

			      ((unsigned char *) in_buf)[i]);

	}

	rc += sprintf(out_buf + rc, "| ");

	for (i = 0; i < id->buf_size; i++) {

		unsigned char c = in_buf[i];

		if (isascii(c) && isprint(c))

			rc += sprintf(out_buf + rc, "%c", c);

		else

			rc += sprintf(out_buf + rc, ".");

	}

	rc += sprintf(out_buf + rc, "\n");

      out:

	return rc;

}

/*

 * prints debug data in sprintf format

 */

static int

sprintf_format_fn(debug_info_t * id, debug_view_t *view,

		  char *out_buf, const char *in_buf)

{

#define _BUFSIZE 1024

	char buf[_BUFSIZE];

	int i, k, rc = 0, num_longs = 0, num_strings = 0;

	int num_used_args ATTRIBUTE_UNUSED;

	/* use kaddr_t to store long values of 32bit and 64bit archs here */

	kaddr_t inbuf_cpy[DEBUG_SPRINTF_MAX_ARGS];

	/* store ptrs to strings to be deallocated at end of this function */

	uaddr_t to_dealloc[DEBUG_SPRINTF_MAX_ARGS];

	kaddr_t addr;

	memset(buf, 0, sizeof(buf));

	memset(inbuf_cpy, 0, sizeof(inbuf_cpy));

	memset(to_dealloc, 0, sizeof(to_dealloc));

	if (out_buf == NULL || in_buf == NULL) {

	      rc = id->buf_size * 4 + 3;

	      goto out;

	}

	/* get the format string into buf */

	addr = KL_GET_PTR((void*)in_buf);

	GET_BLOCK(addr, _BUFSIZE, buf);

	k = 0;

	for (i = 0; buf[i] && (buf[i] != '\n'); i++) {

		if (buf[i] != '%')

			continue;

		if (k == DEBUG_SPRINTF_MAX_ARGS) {

			fprintf(KL_ERRORFP,

				"\nToo much parameters in sprinf view (%i)\n"

				,k + 1);

			fprintf(KL_ERRORFP, "Format String: %s)\n", buf);

			break;

		}

		/* for sprintf we have only unsigned long values ... */

		if (buf[i+1] != 's'){

			/* we use KL_GET_PTR here to read ulong value */

			addr = KL_GET_PTR((void*) in_buf + ((k + 1)* KL_NBPW));

			inbuf_cpy[k] = addr;

		} else { /* ... or ptrs to strings in debug areas */

			inbuf_cpy[k] = (uaddr_t) malloc(_BUFSIZE);

			to_dealloc[num_strings++] = inbuf_cpy[k];

			addr = KL_GET_PTR((void*) in_buf + ((k + 1)* KL_NBPW));

			GET_BLOCK(addr, _BUFSIZE,

				  (void*)(uaddr_t)(inbuf_cpy[k]));

		}

		k++;

	}

	/* count of longs fit into one entry */

	num_longs = id->buf_size /  KL_NBPW; /* sizeof(long); */

	if(num_longs < 1)	  /* bufsize of entry too small */

		goto out;

	if(num_longs == 1) {	  /* no args, just print the format string */

		rc = sprintf(out_buf + rc, "%s", buf);

		goto out;

	}

	/* number of arguments used for sprintf (without the format string) */

	num_used_args = MIN(DEBUG_SPRINTF_MAX_ARGS, (num_longs - 1));

	rc = sprintf(out_buf + rc, buf, (uaddr_t)(inbuf_cpy[0]),

		     (uaddr_t)(inbuf_cpy[1]), (uaddr_t)(inbuf_cpy[2]),

		     (uaddr_t)(inbuf_cpy[3]), (uaddr_t)(inbuf_cpy[4]),

		     (uaddr_t)(inbuf_cpy[5]), (uaddr_t)(inbuf_cpy[6]),

		     (uaddr_t)(inbuf_cpy[7]), (uaddr_t)(inbuf_cpy[8]),

		     (uaddr_t)(inbuf_cpy[9]));

 out:

	while (num_strings--){

		free((char*)(to_dealloc[num_strings]));

	}

	return rc;

}

/***********************************

 * functions for debug-views

 ***********************************/

/*

 * prints out actual debug level

 */

static int

prolog_level_fn(debug_info_t * id,

		debug_view_t *view, char *out_buf)

{

	int rc = 0;

	if (out_buf == NULL) {

		rc = 2;

		goto out;

	}

	rc = sprintf(out_buf, "%i\n", id->level);

      out:

	return rc;

}

/*

 * prints out actual pages_per_area

 */

static int

prolog_pages_fn(debug_info_t * id,

		debug_view_t *view, char *out_buf)

{

	int rc = 0;

	if (out_buf == NULL) {

		rc = 2;

		goto out;

	}

	rc = sprintf(out_buf, "%i\n", id->pages_per_area_v2);

      out:

	return rc;

}

/*

 * prints out prolog

 */

static int

prolog_fn(debug_info_t * id,

	  debug_view_t *view, char *out_buf)

{

	int rc = 0;

	rc = sprintf(out_buf, "AREA TIME LEVEL EXCEPTION CP CALLING FUNCTION"

		     "   + OFFSET  DATA\n==================================="

		     "=======================================\n");

	return rc;

}

/*

 * prints debug data in hex format

 */

static int

hex_format_fn(debug_info_t * id, debug_view_t *view,

	      char *out_buf, const char *in_buf)

{

	int i, rc = 0;

	for (i = 0; i < id->buf_size; i++) {

		rc += sprintf(out_buf + rc, "%02x ",

			      ((unsigned char *) in_buf)[i]);

	}

	rc += sprintf(out_buf + rc, "\n");

	return rc;

}

/*

 * prints debug data in ascii format

 */

static int

ascii_format_fn(debug_info_t * id, debug_view_t *view,

		char *out_buf, const char *in_buf)

{

	int i, rc = 0;

	if (out_buf == NULL || in_buf == NULL) {

		rc = id->buf_size + 1;

		goto out;

	}

	for (i = 0; i < id->buf_size; i++) {

		unsigned char c = in_buf[i];

		if (!isprint(c))

			rc += sprintf(out_buf + rc, ".");

		else

			rc += sprintf(out_buf + rc, "%c", c);

	}

	rc += sprintf(out_buf + rc, "\n");

      out:

	return rc;

}

/*

 * prints debug data in ebcdic format

 */

static int

ebcdic_format_fn(debug_info_t * id, debug_view_t *view,

		 char *out_buf, const char *in_buf)

{

	int i, rc = 0;

	if (out_buf == NULL || in_buf == NULL) {

		rc = id->buf_size + 1;

		goto out;

	}

	for (i = 0; i < id->buf_size; i++) {

		char c = in_buf[i];

		EBCASC(&c, 1);

		if (!isprint(c))

			rc += sprintf(out_buf + rc, ".");

		else

			rc += sprintf(out_buf + rc, "%c", c);

	}

	rc += sprintf(out_buf + rc, "\n");

      out:

	return rc;

}

debug_view_t ascii_view = {

	"ascii",

	&prolog_fn,

	&dflt_header_fn,

	&ascii_format_fn,

};

debug_view_t ebcdic_view = {

	"ebcdic",

	&prolog_fn,

	&dflt_header_fn,

	&ebcdic_format_fn,

};

debug_view_t hex_view = {

	"hex",

	&prolog_fn,

	&dflt_header_fn,

	&hex_format_fn,

};

debug_view_t level_view = {

	"level",

	&prolog_level_fn,

	NULL,

	NULL,

};

debug_view_t pages_view = {

	"pages",

	&prolog_pages_fn,

	NULL,

	NULL,

};

debug_view_t raw_view = {

	"raw",

	NULL,

	&raw_header_fn,

	&raw_format_fn,

};

debug_view_t hex_ascii_view = {

	"hex_ascii",

	&prolog_fn,

	&dflt_header_fn,

	&hex_ascii_format_fn,

};

debug_view_t sprintf_view = {

	"sprintf",

	&prolog_fn,

	&dflt_header_fn,

	&sprintf_format_fn,

};

static debug_entry_t *

debug_find_oldest_entry(debug_entry_t *entries, int num, int entry_size)

{

	debug_entry_t *result, *current;

	int i;

	uint64_t clock1, clock2;

	result = entries;

	current = entries;

	for (i=0; i < num; i++) {

		if (current->id.stck == 0)

			break;

		clock1 = current->id.fields.clock;

		clock2 = result->id.fields.clock;

		clock1 = KL_GET_UINT64(&clock1);

		clock2 = KL_GET_UINT64(&clock2);

		if (clock1 < clock2)

			result = current;

		current = (debug_entry_t *) ((char *) current + entry_size);

	}

	return result;

}

/*

 * debug_format_output:

 * - calls prolog, header and format functions of view to format output

 */

static int

debug_format_output_v1(debug_info_t * debug_area, debug_view_t *view, 

			FILE * ofp)

{

	int i, j, len;

	int nr_of_entries;

	debug_entry_t *act_entry, *last_entry;

	char *act_entry_data;

	char buf[2048];

	size_t items ATTRIBUTE_UNUSED;

	/* print prolog */

	if (view->prolog_proc) {

		len = view->prolog_proc(debug_area, view, buf);

		items = fwrite(buf,len, 1, ofp);

		memset(buf, 0, 2048);

	}

	/* print debug records */

	if (!(view->format_proc) && !(view->header_proc))

		goto out;

	if(debug_area->entry_size <= 0){

		fprintf(ofp, "Invalid entry_size: %i\n",debug_area->entry_size);

		goto out;

	}

	nr_of_entries = (PAGE_SIZE << debug_area->page_order) / debug_area->entry_size;

	for (i = 0; i < debug_area->nr_areas; i++) {

		act_entry = debug_find_oldest_entry(debug_area->areas[i],

						    nr_of_entries,

						    debug_area->entry_size);

		last_entry = (debug_entry_t *) ((char *) debug_area->areas[i] +

			     (PAGE_SIZE << debug_area->page_order) -

			     debug_area->entry_size);

		for (j = 0; j < nr_of_entries; j++) {

			act_entry_data = (char*)act_entry + dbe_size;

			if (act_entry->id.stck == 0)

				break;	/* empty entry */

			if (view->header_proc) {

				len = view->header_proc(debug_area, view, i,

						  act_entry, buf);

				items = fwrite(buf,len, 1, ofp);

				memset(buf, 0, 2048);

			}

			if (view->format_proc) {

				len = view->format_proc(debug_area, view,

						  buf, act_entry_data);

				items = fwrite(buf,len, 1, ofp);

				memset(buf, 0, 2048); 

			}

			act_entry =

			    (debug_entry_t *) (((char *) act_entry) +

					       debug_area->entry_size);

			if (act_entry > last_entry)

				act_entry = debug_area->areas[i];

		}

	}

      out:

	return 1;

}

/*

 * debug_format_output_v2:

 * - calls prolog, header and format functions of view to format output

 */

static int

debug_format_output_v2(debug_info_t * debug_area,

		    debug_view_t *view, FILE * ofp)

{

	int i, j, k, len;

	debug_entry_t *act_entry;

	char *act_entry_data;

	char buf[2048];

	size_t items ATTRIBUTE_UNUSED;

	/* print prolog */

	if (view->prolog_proc) {

		len = view->prolog_proc(debug_area, view, buf);

		items = fwrite(buf,len, 1, ofp);

		memset(buf, 0, 2048);

	}

	/* print debug records */

	if (!(view->format_proc) && !(view->header_proc))

		goto out;

	if(debug_area->entry_size <= 0){

		fprintf(ofp, "Invalid entry_size: %i\n",debug_area->entry_size);

		goto out;

	}

	for (i = 0; i < debug_area->nr_areas; i++) {

		int nr_entries_per_page = PAGE_SIZE/debug_area->entry_size;

		for (j = 0; j < debug_area->pages_per_area_v2; j++) {

			act_entry = debug_area->areas_v2[i][j];

			for (k = 0; k < nr_entries_per_page; k++) {

				act_entry_data = (char*)act_entry + dbe_size;

				if (act_entry->id.stck == 0)

					break;	/* empty entry */

				if (view->header_proc) {

					len = view->header_proc(debug_area, 

						view, i, act_entry, buf);

					items = fwrite(buf,len, 1, ofp);

					memset(buf, 0, 2048);

				}

				if (view->format_proc) {

					len = view->format_proc(debug_area, 

						view, buf, act_entry_data);

					items = fwrite(buf,len, 1, ofp);

					memset(buf, 0, 2048); 

				}

				act_entry = (debug_entry_t *) (((char *) 

					act_entry) + debug_area->entry_size);

			}

		}

	}

out:

	return 1;

}

static debug_info_t *

find_debug_area(const char *area_name)

{

	debug_info_t* act_debug_info = debug_area_first;

	while(act_debug_info != NULL){

		if (strcmp(act_debug_info->name, area_name) == 0)

				return act_debug_info;

		act_debug_info = act_debug_info->next;

	}

	return NULL;

}

static void tod_clock_base_init(void)

{

	if (kernel_symbol_exists("tod_clock_base")) {

		/*

		 * Kernels >= 4.14 that contain 6e2ef5e4f6cc5734 ("s390/time:

		 * add support for the TOD clock epoch extension")

		 */

		get_symbol_data("tod_clock_base", sizeof(tod_clock_base_us),

				&tod_clock_base_us);

		/* Bit for usecs is at position 59 - therefore shift 4 */

		tod_clock_base_us >>= 4;

	} else if (kernel_symbol_exists("sched_clock_base_cc") &&

		   !kernel_symbol_exists("tod_to_timeval")) {

		/*

		 * Kernels >= 4.11 that contain ea417aa8a38bc7db ("s390/debug:

		 * make debug event time stamps relative to the boot TOD clock")

		 */

		get_symbol_data("sched_clock_base_cc",

				sizeof(tod_clock_base_us), &tod_clock_base_us);