/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*
* Copyright 2015 Nexenta Systems, Inc. All rights reserved.
*/
/*
* This program is used to generate the contents of the
* struct_layout_XXX.c files that contain per-archtecture
* structure layout information.
*
* Although not part of elfdump, it is built by the makefile
* along with it.
* To use it:
*
* 1) Run it, capturing the output in a file.
* 2) If this is a replacement for an existing file,
* diff the new and old copies to ensure only
* the changes you expected are present.
* 3) Put the new file in the common directory under the name
* struct_layout_XXX.c, where XXX is the name of
* the architecture (i386, amd64, sparc, sparcv9, etc).
* 2) Add any necessary header and copyright comments.
* 3) If this is a new architecture:
* - Add an extern statement for struct_layout_XXX()
* to struct_layout.h
* - Add a case for it to the function sl_struct_layout()
* in struct_layout.c.
*/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <err.h>
#include <sys/types.h>
#include <libctf.h>
/*
* This extracts CTF information from a temporary object file.
*
* START and END bracket a struct layout definition. They issue
* the typedef boilerplate, and the standard first element (sizeof)
* which captures the overall size of the structure.
*
* SCALAR_FIELD is for scalar struct fields
*
* ARRAY_FIELD is for array struct fields
*
* ARRAY_TYPE is for plain (non-struct) array types
*/
#define START(_name, _type) \
do_start(#_name, #_type)
#define END (void) \
do_end()
#define SCALAR_FIELD(_type, _field, _sign) \
do_scalar_field(#_type, #_field, _sign, NULL)
#define SCALAR_FIELD4(_type, _field, _sign, _rtype) \
do_scalar_field(#_type, #_field, _sign, _rtype)
#define ARRAY_FIELD(_type, _field, _sign) \
do_array_field(#_type, #_field, _sign, NULL)
#define ARRAY_TYPE(_type, _sign) \
do_array_type(#_type, "elt0", _sign)
static void do_start(char *_name, char *_type);
static void do_end(void);
static void do_start_name(char *name);
static void do_start_sizeof(char *_type, char *realtype);
static void do_scalar_field(char *_type, char *_field,
int _sign, char *dotfield);
static void do_array_field(char *_type, char *_field,
int _sign, char *dotfield);
static void do_array_type(char *_type, char *_field, int _sign);
static void get_ctf_file(char *fname);
static int get_field_info(char *tname, char *fname, char *dotname,
int *offp, int *sizep);
static ctf_file_t *ctf;
static char *objfile;
static char *machname;
/* auxv_t, <sys/auxv.h> */
static void
gen_auxv(void)
{
START(auxv, auxv_t);
SCALAR_FIELD(auxv_t, a_type, 1);
SCALAR_FIELD(auxv_t, a_un.a_val, 1);
SCALAR_FIELD(auxv_t, a_un.a_ptr, 0);
SCALAR_FIELD(auxv_t, a_un.a_fcn, 0);
END;
}
/* prgregset_t, <sys/prgregset.h> */
static void
gen_prgregset(void)
{
START(prgregset, prgregset_t);
ARRAY_TYPE(prgregset_t, 0);
END;
}
/* lwpstatus_t, <sys/procfs.h> */
static void
gen_lwpstatus(void)
{
START(lwpstatus, lwpstatus_t);
SCALAR_FIELD(lwpstatus_t, pr_flags, 0);
SCALAR_FIELD(lwpstatus_t, pr_lwpid, 0);
SCALAR_FIELD(lwpstatus_t, pr_why, 0);
SCALAR_FIELD(lwpstatus_t, pr_what, 0);
SCALAR_FIELD(lwpstatus_t, pr_cursig, 0);
SCALAR_FIELD(lwpstatus_t, pr_info, 0);
SCALAR_FIELD(lwpstatus_t, pr_lwppend, 0);
SCALAR_FIELD(lwpstatus_t, pr_lwphold, 0);
SCALAR_FIELD(lwpstatus_t, pr_action, 0);
SCALAR_FIELD(lwpstatus_t, pr_altstack, 0);
SCALAR_FIELD(lwpstatus_t, pr_oldcontext, 0);
SCALAR_FIELD(lwpstatus_t, pr_syscall, 0);
SCALAR_FIELD(lwpstatus_t, pr_nsysarg, 0);
SCALAR_FIELD(lwpstatus_t, pr_errno, 0);
ARRAY_FIELD(lwpstatus_t, pr_sysarg, 0);
SCALAR_FIELD(lwpstatus_t, pr_rval1, 0);
SCALAR_FIELD(lwpstatus_t, pr_rval2, 0);
ARRAY_FIELD(lwpstatus_t, pr_clname, 0);
SCALAR_FIELD(lwpstatus_t, pr_tstamp, 0);
SCALAR_FIELD(lwpstatus_t, pr_utime, 0);
SCALAR_FIELD(lwpstatus_t, pr_stime, 0);
SCALAR_FIELD(lwpstatus_t, pr_errpriv, 0);
SCALAR_FIELD(lwpstatus_t, pr_ustack, 0);
SCALAR_FIELD(lwpstatus_t, pr_instr, 0);
SCALAR_FIELD(lwpstatus_t, pr_reg, 0);
SCALAR_FIELD(lwpstatus_t, pr_fpreg, 0);
END;
}
/* pstatus_t, <sys/procfs.h> */
static void
gen_pstatus(void)
{
START(pstatus, pstatus_t);
SCALAR_FIELD(pstatus_t, pr_flags, 1);
SCALAR_FIELD(pstatus_t, pr_nlwp, 1);
SCALAR_FIELD(pstatus_t, pr_pid, 0);
SCALAR_FIELD(pstatus_t, pr_ppid, 0);
SCALAR_FIELD(pstatus_t, pr_pgid, 0);
SCALAR_FIELD(pstatus_t, pr_sid, 0);
SCALAR_FIELD(pstatus_t, pr_aslwpid, 1);
SCALAR_FIELD(pstatus_t, pr_agentid, 1);
SCALAR_FIELD(pstatus_t, pr_sigpend, 0);
SCALAR_FIELD(pstatus_t, pr_brkbase, 0);
SCALAR_FIELD(pstatus_t, pr_brksize, 0);
SCALAR_FIELD(pstatus_t, pr_stkbase, 0);
SCALAR_FIELD(pstatus_t, pr_stksize, 0);
SCALAR_FIELD(pstatus_t, pr_utime, 0);
SCALAR_FIELD(pstatus_t, pr_stime, 0);
SCALAR_FIELD(pstatus_t, pr_cutime, 0);
SCALAR_FIELD(pstatus_t, pr_cstime, 0);
SCALAR_FIELD(pstatus_t, pr_sigtrace, 0);
SCALAR_FIELD(pstatus_t, pr_flttrace, 0);
SCALAR_FIELD(pstatus_t, pr_sysentry, 0);
SCALAR_FIELD(pstatus_t, pr_sysexit, 0);
SCALAR_FIELD(pstatus_t, pr_dmodel, 0);
SCALAR_FIELD(pstatus_t, pr_taskid, 1);
SCALAR_FIELD(pstatus_t, pr_projid, 1);
SCALAR_FIELD(pstatus_t, pr_nzomb, 1);
SCALAR_FIELD(pstatus_t, pr_zoneid, 1);
SCALAR_FIELD(pstatus_t, pr_lwp, 0);
END;
}
/* prstatus_t, <sys/old_procfs.h> */
static void
gen_prstatus(void)
{
START(prstatus, prstatus_t);
SCALAR_FIELD(prstatus_t, pr_flags, 1);
SCALAR_FIELD(prstatus_t, pr_why, 1);
SCALAR_FIELD(prstatus_t, pr_what, 1);
SCALAR_FIELD(prstatus_t, pr_info, 0);
SCALAR_FIELD(prstatus_t, pr_cursig, 1);
SCALAR_FIELD(prstatus_t, pr_nlwp, 0);
SCALAR_FIELD(prstatus_t, pr_sigpend, 0);
SCALAR_FIELD(prstatus_t, pr_sighold, 0);
SCALAR_FIELD(prstatus_t, pr_altstack, 0);
SCALAR_FIELD(prstatus_t, pr_action, 0);
SCALAR_FIELD(prstatus_t, pr_pid, 0);
SCALAR_FIELD(prstatus_t, pr_ppid, 0);
SCALAR_FIELD(prstatus_t, pr_pgrp, 0);
SCALAR_FIELD(prstatus_t, pr_sid, 0);
SCALAR_FIELD(prstatus_t, pr_utime, 0);
SCALAR_FIELD(prstatus_t, pr_stime, 0);
SCALAR_FIELD(prstatus_t, pr_cutime, 0);
SCALAR_FIELD(prstatus_t, pr_cstime, 0);
ARRAY_FIELD(prstatus_t, pr_clname, 0);
SCALAR_FIELD(prstatus_t, pr_syscall, 1);
SCALAR_FIELD(prstatus_t, pr_nsysarg, 1);
ARRAY_FIELD(prstatus_t, pr_sysarg, 1);
SCALAR_FIELD(prstatus_t, pr_who, 0);
SCALAR_FIELD(prstatus_t, pr_lwppend, 0);
SCALAR_FIELD(prstatus_t, pr_oldcontext, 0);
SCALAR_FIELD(prstatus_t, pr_brkbase, 0);
SCALAR_FIELD(prstatus_t, pr_brksize, 0);
SCALAR_FIELD(prstatus_t, pr_stkbase, 0);
SCALAR_FIELD(prstatus_t, pr_stksize, 0);
SCALAR_FIELD(prstatus_t, pr_processor, 1);
SCALAR_FIELD(prstatus_t, pr_bind, 1);
SCALAR_FIELD(prstatus_t, pr_instr, 1);
SCALAR_FIELD(prstatus_t, pr_reg, 0);
END;
}
/* psinfo_t, <sys/procfs.h> */
static void
gen_psinfo(void)
{
START(psinfo, psinfo_t);
SCALAR_FIELD(psinfo_t, pr_flag, 1);
SCALAR_FIELD(psinfo_t, pr_nlwp, 1);
SCALAR_FIELD(psinfo_t, pr_pid, 0);
SCALAR_FIELD(psinfo_t, pr_ppid, 0);
SCALAR_FIELD(psinfo_t, pr_pgid, 0);
SCALAR_FIELD(psinfo_t, pr_sid, 0);
SCALAR_FIELD(psinfo_t, pr_uid, 0);
SCALAR_FIELD(psinfo_t, pr_euid, 0);
SCALAR_FIELD(psinfo_t, pr_gid, 0);
SCALAR_FIELD(psinfo_t, pr_egid, 0);
SCALAR_FIELD(psinfo_t, pr_addr, 0);
SCALAR_FIELD(psinfo_t, pr_size, 0);
SCALAR_FIELD(psinfo_t, pr_rssize, 0);
SCALAR_FIELD(psinfo_t, pr_ttydev, 0);
SCALAR_FIELD(psinfo_t, pr_pctcpu, 0);
SCALAR_FIELD(psinfo_t, pr_pctmem, 0);
SCALAR_FIELD(psinfo_t, pr_start, 0);
SCALAR_FIELD(psinfo_t, pr_time, 0);
SCALAR_FIELD(psinfo_t, pr_ctime, 0);
ARRAY_FIELD(psinfo_t, pr_fname, 0);
ARRAY_FIELD(psinfo_t, pr_psargs, 0);
SCALAR_FIELD(psinfo_t, pr_wstat, 1);
SCALAR_FIELD(psinfo_t, pr_argc, 1);
SCALAR_FIELD(psinfo_t, pr_argv, 0);
SCALAR_FIELD(psinfo_t, pr_envp, 0);
SCALAR_FIELD(psinfo_t, pr_dmodel, 0);
SCALAR_FIELD(psinfo_t, pr_taskid, 0);
SCALAR_FIELD(psinfo_t, pr_projid, 0);
SCALAR_FIELD(psinfo_t, pr_nzomb, 1);
SCALAR_FIELD(psinfo_t, pr_poolid, 0);
SCALAR_FIELD(psinfo_t, pr_zoneid, 0);
SCALAR_FIELD(psinfo_t, pr_contract, 0);
SCALAR_FIELD(psinfo_t, pr_lwp, 0);
END;
}
/* prpsinfo_t, <sys/old_procfs.h> */
static void
gen_prpsinfo(void)
{
START(prpsinfo, prpsinfo_t);
SCALAR_FIELD(prpsinfo_t, pr_state, 0);
SCALAR_FIELD(prpsinfo_t, pr_sname, 0);
SCALAR_FIELD(prpsinfo_t, pr_zomb, 0);
SCALAR_FIELD(prpsinfo_t, pr_nice, 0);
SCALAR_FIELD(prpsinfo_t, pr_flag, 0);
SCALAR_FIELD(prpsinfo_t, pr_uid, 0);
SCALAR_FIELD(prpsinfo_t, pr_gid, 0);
SCALAR_FIELD(prpsinfo_t, pr_pid, 0);
SCALAR_FIELD(prpsinfo_t, pr_ppid, 0);
SCALAR_FIELD(prpsinfo_t, pr_pgrp, 0);
SCALAR_FIELD(prpsinfo_t, pr_sid, 0);
SCALAR_FIELD(prpsinfo_t, pr_addr, 0);
SCALAR_FIELD(prpsinfo_t, pr_size, 0);
SCALAR_FIELD(prpsinfo_t, pr_rssize, 0);
SCALAR_FIELD(prpsinfo_t, pr_wchan, 0);
SCALAR_FIELD(prpsinfo_t, pr_start, 0);
SCALAR_FIELD(prpsinfo_t, pr_time, 0);
SCALAR_FIELD(prpsinfo_t, pr_pri, 1);
SCALAR_FIELD(prpsinfo_t, pr_oldpri, 0);
SCALAR_FIELD(prpsinfo_t, pr_cpu, 0);
SCALAR_FIELD(prpsinfo_t, pr_ottydev, 0);
SCALAR_FIELD(prpsinfo_t, pr_lttydev, 0);
ARRAY_FIELD(prpsinfo_t, pr_clname, 0);
ARRAY_FIELD(prpsinfo_t, pr_fname, 0);
ARRAY_FIELD(prpsinfo_t, pr_psargs, 0);
SCALAR_FIELD(prpsinfo_t, pr_syscall, 1);
SCALAR_FIELD(prpsinfo_t, pr_ctime, 0);
SCALAR_FIELD(prpsinfo_t, pr_bysize, 0);
SCALAR_FIELD(prpsinfo_t, pr_byrssize, 0);
SCALAR_FIELD(prpsinfo_t, pr_argc, 1);
SCALAR_FIELD(prpsinfo_t, pr_argv, 0);
SCALAR_FIELD(prpsinfo_t, pr_envp, 0);
SCALAR_FIELD(prpsinfo_t, pr_wstat, 1);
SCALAR_FIELD(prpsinfo_t, pr_pctcpu, 0);
SCALAR_FIELD(prpsinfo_t, pr_pctmem, 0);
SCALAR_FIELD(prpsinfo_t, pr_euid, 0);
SCALAR_FIELD(prpsinfo_t, pr_egid, 0);
SCALAR_FIELD(prpsinfo_t, pr_aslwpid, 0);
SCALAR_FIELD(prpsinfo_t, pr_dmodel, 0);
END;
}
/* lwpsinfo_t, <sys/procfs.h> */
static void
gen_lwpsinfo(void)
{
START(lwpsinfo, lwpsinfo_t);
SCALAR_FIELD(lwpsinfo_t, pr_flag, 1);
SCALAR_FIELD(lwpsinfo_t, pr_lwpid, 0);
SCALAR_FIELD(lwpsinfo_t, pr_addr, 0);
SCALAR_FIELD(lwpsinfo_t, pr_wchan, 0);
SCALAR_FIELD(lwpsinfo_t, pr_stype, 0);
SCALAR_FIELD(lwpsinfo_t, pr_state, 0);
SCALAR_FIELD(lwpsinfo_t, pr_sname, 0);
SCALAR_FIELD(lwpsinfo_t, pr_nice, 0);
SCALAR_FIELD(lwpsinfo_t, pr_syscall, 0);
SCALAR_FIELD(lwpsinfo_t, pr_oldpri, 0);
SCALAR_FIELD(lwpsinfo_t, pr_cpu, 0);
SCALAR_FIELD(lwpsinfo_t, pr_pri, 1);
SCALAR_FIELD(lwpsinfo_t, pr_pctcpu, 0);
SCALAR_FIELD(lwpsinfo_t, pr_start, 0);
SCALAR_FIELD(lwpsinfo_t, pr_time, 0);
ARRAY_FIELD(lwpsinfo_t, pr_clname, 0);
ARRAY_FIELD(lwpsinfo_t, pr_name, 0);
SCALAR_FIELD(lwpsinfo_t, pr_onpro, 1);
SCALAR_FIELD(lwpsinfo_t, pr_bindpro, 1);
SCALAR_FIELD(lwpsinfo_t, pr_bindpset, 1);
SCALAR_FIELD(lwpsinfo_t, pr_lgrp, 1);
END;
}
/* prcred_t, <sys/procfs.h> */
static void
gen_prcred(void)
{
START(prcred, prcred_t);
SCALAR_FIELD(prcred_t, pr_euid, 0);
SCALAR_FIELD(prcred_t, pr_ruid, 0);
SCALAR_FIELD(prcred_t, pr_suid, 0);
SCALAR_FIELD(prcred_t, pr_egid, 0);
SCALAR_FIELD(prcred_t, pr_rgid, 0);
SCALAR_FIELD(prcred_t, pr_sgid, 0);
SCALAR_FIELD(prcred_t, pr_ngroups, 1);
ARRAY_FIELD(prcred_t, pr_groups, 0);
END;
}
/* prpriv_t, <sys/procfs.h> */
static void
gen_prpriv(void)
{
START(prpriv, prpriv_t);
SCALAR_FIELD(prpriv_t, pr_nsets, 0);
SCALAR_FIELD(prpriv_t, pr_setsize, 0);
SCALAR_FIELD(prpriv_t, pr_infosize, 0);
ARRAY_FIELD(prpriv_t, pr_sets, 0);
END;
}
/* priv_impl_info_t, <sys/priv.h> */
static void
gen_priv_impl_info(void)
{
START(priv_impl_info, priv_impl_info_t);
SCALAR_FIELD(priv_impl_info_t, priv_headersize, 0);
SCALAR_FIELD(priv_impl_info_t, priv_flags, 0);
SCALAR_FIELD(priv_impl_info_t, priv_nsets, 0);
SCALAR_FIELD(priv_impl_info_t, priv_setsize, 0);
SCALAR_FIELD(priv_impl_info_t, priv_max, 0);
SCALAR_FIELD(priv_impl_info_t, priv_infosize, 0);
SCALAR_FIELD(priv_impl_info_t, priv_globalinfosize, 0);
END;
}
/* fltset_t, <sys/fault.h> */
static void
gen_fltset(void)
{
START(fltset, fltset_t);
ARRAY_FIELD(fltset_t, word, 0);
END;
}
/*
* Layout description of siginfo_t, <sys/siginfo.h>
*
* Note: many siginfo_t members are #defines mapping to
* long dotted members of sub-structs or unions, and
* we need the full member spec (with dots) for those.
*/
static void
gen_siginfo(void)
{
START(siginfo, siginfo_t);
SCALAR_FIELD(siginfo_t, si_signo, 0);
SCALAR_FIELD(siginfo_t, si_errno, 0);
SCALAR_FIELD(siginfo_t, si_code, 1);
SCALAR_FIELD4(siginfo_t, si_value.sival_int, 0,
"__data.__proc.__pdata.__kill.__value.sival_int");
SCALAR_FIELD4(siginfo_t, si_value.sival_ptr, 0,
"__data.__proc.__pdata.__kill.__value.sival_ptr");
SCALAR_FIELD4(siginfo_t, si_pid, 0,
"__data.__proc.__pid");
SCALAR_FIELD4(siginfo_t, si_uid, 0,
"__data.__proc.__pdata.__kill.__uid");
SCALAR_FIELD4(siginfo_t, si_ctid, 0,
"__data.__proc.__ctid");
SCALAR_FIELD4(siginfo_t, si_zoneid, 0,
"__data.__proc.__zoneid");
SCALAR_FIELD4(siginfo_t, si_entity, 0,
"__data.__rctl.__entity");
SCALAR_FIELD4(siginfo_t, si_addr, 0,
"__data.__fault.__addr");
SCALAR_FIELD4(siginfo_t, si_status, 0,
"__data.__proc.__pdata.__cld.__status");
SCALAR_FIELD4(siginfo_t, si_band, 0,
"__data.__file.__band");
END;
}
/* sigset_t, <sys/signal.h> */
static void
gen_sigset(void)
{
START(sigset, sigset_t);
ARRAY_FIELD(sigset_t, __sigbits, 0);
END;
}
/* struct sigaction, <sys/signal.h> */
static void
gen_sigaction(void)
{
START(sigaction, struct sigaction);
SCALAR_FIELD(struct sigaction, sa_flags, 0);
SCALAR_FIELD4(struct sigaction, sa_handler, 0,
"_funcptr._handler");
SCALAR_FIELD4(struct sigaction, sa_sigaction, 0,
"_funcptr._sigaction");
SCALAR_FIELD(struct sigaction, sa_mask, 0);
END;
}
/* stack_t, <sys/signal.h> */
static void
gen_stack(void)
{
START(stack, stack_t);
SCALAR_FIELD(stack_t, ss_sp, 0);
SCALAR_FIELD(stack_t, ss_size, 0);
SCALAR_FIELD(stack_t, ss_flags, 0);
END;
}
/* sysset_t, <sys/syscall.h> */
static void
gen_sysset(void)
{
START(sysset, sysset_t);
ARRAY_FIELD(sysset_t, word, 0);
END;
}
/* timestruc_t, <sys/time_impl.h> */
static void
gen_timestruc(void)
{
START(timestruc, timestruc_t);
SCALAR_FIELD(timestruc_t, tv_sec, 0);
SCALAR_FIELD(timestruc_t, tv_nsec, 0);
END;
}
/* struct utsname, <sys/utsname.h> */
static void
gen_utsname(void)
{
START(utsname, struct utsname);
ARRAY_FIELD(struct utsname, sysname, 0);
ARRAY_FIELD(struct utsname, nodename, 0);
ARRAY_FIELD(struct utsname, release, 0);
ARRAY_FIELD(struct utsname, version, 0);
ARRAY_FIELD(struct utsname, machine, 0);
END;
}
static void
gen_prfdinfo(void)
{
START(prfdinfo, prfdinfo_t);
SCALAR_FIELD(prfdinfo_t, pr_fd, 0);
SCALAR_FIELD(prfdinfo_t, pr_mode, 0);
SCALAR_FIELD(prfdinfo_t, pr_uid, 0);
SCALAR_FIELD(prfdinfo_t, pr_gid, 0);
SCALAR_FIELD(prfdinfo_t, pr_major, 0);
SCALAR_FIELD(prfdinfo_t, pr_minor, 0);
SCALAR_FIELD(prfdinfo_t, pr_rmajor, 0);
SCALAR_FIELD(prfdinfo_t, pr_rminor, 0);
SCALAR_FIELD(prfdinfo_t, pr_ino, 0);
SCALAR_FIELD(prfdinfo_t, pr_offset, 0);
SCALAR_FIELD(prfdinfo_t, pr_size, 0);
SCALAR_FIELD(prfdinfo_t, pr_fileflags, 0);
SCALAR_FIELD(prfdinfo_t, pr_fdflags, 0);
ARRAY_FIELD(prfdinfo_t, pr_path, 0);
END;
}
static void
gen_prsecflags(void)
{
START(prsecflags, prsecflags_t);
SCALAR_FIELD(prsecflags_t, pr_version, 0);
SCALAR_FIELD(prsecflags_t, pr_effective, 0);
SCALAR_FIELD(prsecflags_t, pr_inherit, 0);
SCALAR_FIELD(prsecflags_t, pr_lower, 0);
SCALAR_FIELD(prsecflags_t, pr_upper, 0);
END;
}
/*ARGSUSED*/
int
main(int argc, char *argv[])
{
const char *fmt = "\t&%s_layout,\n";
/* get obj file for input */
if (argc < 3) {
(void) fprintf(stderr,
"usage: %s {object_file} {MACH}\n", argv[0]);
exit(1);
}
objfile = argv[1];
machname = argv[2];
get_ctf_file(objfile);
(void) printf("#include <struct_layout.h>\n");
gen_auxv();
gen_prgregset();
gen_lwpstatus();
gen_pstatus();
gen_prstatus();
gen_psinfo();
gen_prpsinfo();
gen_lwpsinfo();
gen_prcred();
gen_prpriv();
gen_priv_impl_info();
gen_fltset();
gen_siginfo();
gen_sigset();
gen_sigaction();
gen_stack();
gen_sysset();
gen_timestruc();
gen_utsname();
gen_prfdinfo();
gen_prsecflags();
/*
* Generate the full arch_layout description
*/
(void) printf(
"\n\n\n\nstatic const sl_arch_layout_t layout_%s = {\n",
machname);
(void) printf(fmt, "auxv");
(void) printf(fmt, "fltset");
(void) printf(fmt, "lwpsinfo");
(void) printf(fmt, "lwpstatus");
(void) printf(fmt, "prcred");
(void) printf(fmt, "priv_impl_info");
(void) printf(fmt, "prpriv");
(void) printf(fmt, "psinfo");
(void) printf(fmt, "pstatus");
(void) printf(fmt, "prgregset");
(void) printf(fmt, "prpsinfo");
(void) printf(fmt, "prstatus");
(void) printf(fmt, "sigaction");
(void) printf(fmt, "siginfo");
(void) printf(fmt, "sigset");
(void) printf(fmt, "stack");
(void) printf(fmt, "sysset");
(void) printf(fmt, "timestruc");
(void) printf(fmt, "utsname");
(void) printf(fmt, "prfdinfo");
(void) printf(fmt, "prsecflags");
(void) printf("};\n");
/*
* A public function, to make the information available
*/
(void) printf("\n\nconst sl_arch_layout_t *\n");
(void) printf("struct_layout_%s(void)\n", machname);
(void) printf("{\n\treturn (&layout_%s);\n}\n", machname);
return (0);
}
/*
* Helper functions using the CTF library to get type info.
*/
static void
get_ctf_file(char *fname)
{
int ctferr;
objfile = fname;
if ((ctf = ctf_open(objfile, &ctferr)) == NULL) {
errx(1, "Couldn't open object file %s: %s\n", objfile,
ctf_errmsg(ctferr));
}
}
static void
print_row(int boff, int eltlen, int nelts, int issigned, char *comment)
{
(void) printf("\t{ %d,\t%d,\t%d,\t%d },\t\t/* %s */\n",
boff, eltlen, nelts, issigned, comment);
}
static void
do_start(char *sname, char *tname)
{
do_start_name(sname);
do_start_sizeof(tname, NULL);
}
static void
do_start_name(char *sname)
{
(void) printf("\n\nstatic const sl_%s_layout_t %s_layout = {\n",
sname, sname);
}
static void
do_end(void)
{
(void) printf("};\n");
}
static void
do_start_sizeof(char *tname, char *rtname)
{
char comment[100];
ctf_id_t stype;
int sz;
if (rtname == NULL)
rtname = tname;
if ((stype = ctf_lookup_by_name(ctf, rtname)) == CTF_ERR)
errx(1, "Couldn't find type %s", rtname);
if ((stype = ctf_type_resolve(ctf, stype)) == CTF_ERR)
errx(1, "Couldn't resolve type %s", tname);
if ((sz = (int)ctf_type_size(ctf, stype)) < 0) {
errx(1, "Couldn't get size for type %s", tname);
} else if (sz == 0) {
errx(1, "Invalid type size 0 for %s", tname);
}
(void) snprintf(comment, sizeof (comment), "sizeof (%s)", tname);
print_row(0, sz, 0, 0, comment);
}
static void
do_scalar_field(char *tname, char *fname, int _sign, char *dotfield)
{
int rc, off, sz, ftype;
rc = get_field_info(tname, fname, dotfield, &off, &ftype);
if (rc < 0)
errx(1, "Can't get field info for %s->%s", tname, fname);
if ((ftype = ctf_type_resolve(ctf, ftype)) == CTF_ERR)
errx(1, "Couldn't resolve type of %s->%s", tname, fname);
if ((sz = (int)ctf_type_size(ctf, ftype)) < 0) {
errx(1, "Couldn't get size for type ID %d", ftype);
} else if (sz == 0) {
errx(1, "Invalid type size 0 for type ID %d", ftype);
}
print_row(off, sz, 0, _sign, fname);
}
static void
do_array_field(char *tname, char *fname,
int _sign, char *dotfield)
{
char comment[100];
ctf_arinfo_t ai;
int typekind;
int esz, rc, off, ftype;
rc = get_field_info(tname, fname, dotfield, &off, &ftype);
if (rc < 0)
errx(1, "Can't get field info for %s->%s", tname, fname);
if ((ftype = ctf_type_resolve(ctf, ftype)) == CTF_ERR)
errx(1, "Couldn't resolve type of %s->%s", tname, fname);
typekind = ctf_type_kind(ctf, ftype);
if (typekind != CTF_K_ARRAY)
errx(1, "Wrong type for %s->%s", tname, fname);
rc = ctf_array_info(ctf, ftype, &ai);
if (rc != 0)
errx(1, "Can't get array info for %s->%s\n", tname, fname);
esz = ctf_type_size(ctf, ai.ctr_contents);
if (esz < 0)
errx(1, "Can't get element size for %s->%s\n", tname, fname);
(void) snprintf(comment, sizeof (comment), "%s[]", fname);
print_row(off, esz, ai.ctr_nelems, _sign, comment);
}
static void
do_array_type(char *tname, char *fname, int _sign)
{
ctf_arinfo_t ai;
int stype, typekind;
int esz, rc;
if ((stype = ctf_lookup_by_name(ctf, tname)) == CTF_ERR)
errx(1, "Couldn't find type %s", tname);
if ((stype = ctf_type_resolve(ctf, stype)) == CTF_ERR)
errx(1, "Couldn't resolve type %s", tname);
typekind = ctf_type_kind(ctf, stype);
if (typekind != CTF_K_ARRAY)
errx(1, "Wrong type for %s->%s", tname, fname);
rc = ctf_array_info(ctf, stype, &ai);
if (rc != 0)
errx(1, "Can't get array info for %s->%s\n", tname, fname);
esz = ctf_type_size(ctf, ai.ctr_contents);
if (esz < 0)
errx(1, "Can't get element size for %s->%s\n", tname, fname);
print_row(0, esz, ai.ctr_nelems, _sign, fname);
}
struct gfinfo {
char *tname; /* top type name, i.e. the struct */
char *fname; /* field name */
char *dotname; /* full field name with dots (optional) */
char *prefix; /* current field search prefix */
int base_off;
int fld_off;
int fld_type;
};
static int gfi_iter(const char *fname, ctf_id_t mbrtid,
ulong_t off, void *varg);
/*
* Lookup field "fname" in type "tname". If "dotname" is non-NULL,
* that's the full field name with dots, i.e. a_un.un_foo, which
* we must search for by walking the struct CTF recursively.
*/
static int
get_field_info(char *tname, char *fname, char *dotname,
int *offp, int *tidp)
{
struct gfinfo gfi;
ctf_id_t stype;
int typekind;
int rc;
if ((stype = ctf_lookup_by_name(ctf, tname)) == CTF_ERR)
errx(1, "Couldn't find type %s", tname);
if ((stype = ctf_type_resolve(ctf, stype)) == CTF_ERR)
errx(1, "Couldn't resolve type %s", tname);
/* If fname has a dot, use it as dotname too. */
if (dotname == NULL && strchr(fname, '.') != NULL)
dotname = fname;
gfi.tname = tname;
gfi.fname = fname;
gfi.dotname = dotname;
gfi.prefix = "";
gfi.base_off = 0;
gfi.fld_off = 0;
gfi.fld_type = 0;
typekind = ctf_type_kind(ctf, stype);
switch (typekind) {
case CTF_K_STRUCT:
case CTF_K_UNION:
rc = ctf_member_iter(ctf, stype, gfi_iter, &gfi);
break;
default:
errx(1, "Unexpected top-level type for %s", tname);
break;
}
if (rc < 0)
errx(1, "Error getting info for %s.%s", stype, fname);
if (rc == 0)
errx(1, "Did not find %s.%s", tname, fname);
*offp = gfi.fld_off;
*tidp = gfi.fld_type;
return (0);
}
/*
* Iteration callback for ctf_member_iter
* Return <0 on error, 0 to keep looking, >0 for found.
*
* If no dotname, simple search for fieldname.
* If we're asked to search with dotname, we need to do a full
* recursive walk of the types under the dotname.
*/
int
gfi_iter(const char *fieldname, ctf_id_t mbrtid, ulong_t off, void *varg)
{
char namebuf[100];
struct gfinfo *gfi = varg;
char *saveprefix;
int saveoff;
int typekind;
int byteoff;
int len, rc;
byteoff = gfi->base_off + (int)(off >> 3);
/* Easy cases first: no dotname */
if (gfi->dotname == NULL) {
if (strcmp(gfi->fname, fieldname) == 0) {
gfi->fld_off = byteoff;
gfi->fld_type = mbrtid;
return (1);
}
return (0);
}
/* Exact match on the dotname? */
(void) snprintf(namebuf, sizeof (namebuf), "%s%s",
gfi->prefix, fieldname);
if (strcmp(gfi->dotname, namebuf) == 0) {
gfi->fld_off = byteoff;
gfi->fld_type = mbrtid;
return (1);
}
/*
* May need to recurse under this field, but
* only if there's a match through '.'
*/
(void) strlcat(namebuf, ".", sizeof (namebuf));
len = strlen(namebuf);
if (strncmp(gfi->dotname, namebuf, len) != 0)
return (0);
typekind = ctf_type_kind(ctf, mbrtid);
switch (typekind) {
case CTF_K_STRUCT:
case CTF_K_UNION:
break;
default:
return (0);
}
/* Recursively walk members */
saveprefix = gfi->prefix;
saveoff = gfi->base_off;
gfi->prefix = namebuf;
gfi->base_off = byteoff;
rc = ctf_member_iter(ctf, mbrtid, gfi_iter, gfi);
gfi->prefix = saveprefix;
gfi->base_off = saveoff;
return (rc);
}