static int
handle_license(const char *dev)
{
static struct {
const char *dev;
const char *lic;
} licdev[] = {
{ "iwi", "/libdata/firmware/if_iwi/LICENSE.ipw2200-fw" },
{ "ipw", "/libdata/firmware/if_ipw/LICENSE" },
};
size_t i;
for (i = 0; i < __arraycount(licdev); i++)
if (strncmp(dev, licdev[i].dev, 3) == 0) {
char buf[64];
int val;
size_t len = sizeof(int);
(void)snprintf(buf, sizeof(buf), "hw.%s.accept_eula",
licdev[i].dev);
if (sysctlbyname(buf, &val, &len, NULL, 0) != -1
&& val != 0)
return 1;
msg_display(MSG_license, dev, licdev[i].lic);
process_menu(MENU_yesno, NULL);
if (yesno) {
val = 1;
if (sysctlbyname(buf, NULL, NULL, &val,
0) == -1)
return 0;
add_sysctl_conf("%s=1", buf);
return 1;
} else
return 0;
}
return 1;
}
static void
gpp_establish_irq(struct pic_ops *pic, int irq, int type, int pri)
{
struct gpppic_ops * const gpp = (void *)pic;
const uint32_t mask = 1 << irq;
KASSERT((unsigned) irq < 32);
#ifdef GPP_EDGE
KASSERT(type == IST_EDGE);
#else
KASSERT(type == IST_LEVEL);
#endif
/*
* Set pin to input and active low.
*/
val = bus_space_read_4(gpp->gpp_memt, gpp->gpp_memh, GT_GPP_IO_Control);
val &= ~mask;
bus_space_write_4(gpp->gpp_memt, gpp->gpp_memh, GT_GPP_IO_Control, val);
val = bus_space_read_4(gpp->gpp_memt, gpp->gpp_memh, GT_GPP_Level_Control);
val |= mask;
bus_space_write_4(&gpp->gpp_memt, gpp->gpp_memh, GT_GPP_Level_Control, val);
gpp->gpp_priority[irq] = pri;
/*
* recalculate the maxpriority of an interrupt. This is highest
* priority interrupt from itself to gpp0.
*/
pri = IPL_NONE;
for (i = 0; i < __arraycount(gpp->gpp_priority); i++) {
if (gpp->gpp_priority[i] > pri)
pri = gpp->gpp_priority[i];
gpp->gpp_maxpriority[i] = pri;
}
}
ATF_TC_BODY(inet_addr_err, tc)
{
static const char *addrs[] = {
". . . .", "1.2.3.", "0.0.0.256", "255.255.255.256",
"................................................",
"a.b.c.d", "0x0.0x1.0x2.0x3", "-1.-1.-1.-1", "", " "};
struct in_addr ia;
const char *ian;
in_addr_t addr;
size_t i;
for (i = 0; i < __arraycount(addrs); i++) {
(void)fprintf(stderr, "checking %s\n", addrs[i]);;
addr = inet_addr(addrs[i]);
ia.s_addr = addr;
ian = inet_ntoa(ia);
ATF_REQUIRE(ian != NULL);
ATF_CHECK(strcmp(ian, addrs[i]) != 0);
}
}
__guard_setup(void)
{
#if !defined(__minix)
static const int mib[2] = { CTL_KERN, KERN_ARND };
size_t len;
#endif /* !defined(__minix) */
if (__stack_chk_guard[0] != 0)
return;
#if !defined(__minix)
len = sizeof(__stack_chk_guard);
if (__sysctl(mib, (u_int)__arraycount(mib), __stack_chk_guard, &len,
NULL, 0) == -1 || len != sizeof(__stack_chk_guard)) {
#endif /* !defined(__minix) */
/* If sysctl was unsuccessful, use the "terminator canary". */
((unsigned char *)(void *)__stack_chk_guard)[0] = 0;
((unsigned char *)(void *)__stack_chk_guard)[1] = 0;
((unsigned char *)(void *)__stack_chk_guard)[2] = '\n';
((unsigned char *)(void *)__stack_chk_guard)[3] = 255;
#if !defined(__minix)
}
#endif /* !defined(__minix) */
}
void
tegraio_attach(device_t parent, device_t self, void *aux)
{
tegraio_found = true;
aprint_naive("\n");
aprint_normal(": %s\n", tegra_chip_name());
tegraio_scan(self, tegra_ppsb_bsh,
tegra_ppsb_locators, __arraycount(tegra_ppsb_locators));
tegraio_scan(self, tegra_apb_bsh,
tegra_apb_locators, __arraycount(tegra_apb_locators));
tegraio_scan(self, tegra_ahb_a2_bsh,
tegra_ahb_a2_locators, __arraycount(tegra_ahb_a2_locators));
tegraio_scan(self, (bus_space_handle_t)NULL,
tegra_host1x_locators, __arraycount(tegra_host1x_locators));
tegraio_scan(self, (bus_space_handle_t)NULL,
tegra_ghost_locators, __arraycount(tegra_ghost_locators));
tegraio_scan(self, (bus_space_handle_t)NULL,
tegra_pcie_locators, __arraycount(tegra_pcie_locators));
}
/*-
* main --
* The main function, for obvious reasons. Initializes variables
* and a few modules, then parses the arguments give it in the
* environment and on the command line. Reads the system makefile
* followed by either Makefile, makefile or the file given by the
* -f argument. Sets the .MAKEFLAGS PMake variable based on all the
* flags it has received by then uses either the Make or the Compat
* module to create the initial list of targets.
*
* Results:
* If -q was given, exits -1 if anything was out-of-date. Else it exits
* 0.
*
* Side Effects:
* The program exits when done. Targets are created. etc. etc. etc.
*/
int
main(int argc, char **argv)
{
Lst targs; /* target nodes to create -- passed to Make_Init */
Boolean outOfDate = FALSE; /* FALSE if all targets up to date */
struct stat sb, sa;
char *p1, *path;
char mdpath[MAXPATHLEN];
#ifdef FORCE_MACHINE
const char *machine = FORCE_MACHINE;
#else
const char *machine = getenv("MACHINE");
#endif
const char *machine_arch = getenv("MACHINE_ARCH");
char *syspath = getenv("MAKESYSPATH");
Lst sysMkPath; /* Path of sys.mk */
char *cp = NULL, *start;
/* avoid faults on read-only strings */
static char defsyspath[] = _PATH_DEFSYSPATH;
char found_path[MAXPATHLEN + 1]; /* for searching for sys.mk */
struct timeval rightnow; /* to initialize random seed */
struct utsname utsname;
/* default to writing debug to stderr */
debug_file = stderr;
#ifdef SIGINFO
(void)bmake_signal(SIGINFO, siginfo);
#endif
/*
* Set the seed to produce a different random sequence
* on each program execution.
*/
gettimeofday(&rightnow, NULL);
srandom(rightnow.tv_sec + rightnow.tv_usec);
if ((progname = strrchr(argv[0], '/')) != NULL)
progname++;
else
progname = argv[0];
#if defined(MAKE_NATIVE) || (defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE))
/*
* get rid of resource limit on file descriptors
*/
{
struct rlimit rl;
if (getrlimit(RLIMIT_NOFILE, &rl) != -1 &&
rl.rlim_cur != rl.rlim_max) {
rl.rlim_cur = rl.rlim_max;
(void)setrlimit(RLIMIT_NOFILE, &rl);
}
}
#endif
if (uname(&utsname) == -1) {
(void)fprintf(stderr, "%s: uname failed (%s).\n", progname,
strerror(errno));
exit(2);
}
/*
* Get the name of this type of MACHINE from utsname
* so we can share an executable for similar machines.
* (i.e. m68k: amiga hp300, mac68k, sun3, ...)
*
* Note that both MACHINE and MACHINE_ARCH are decided at
* run-time.
*/
if (!machine) {
#ifdef MAKE_NATIVE
machine = utsname.machine;
#else
#ifdef MAKE_MACHINE
machine = MAKE_MACHINE;
#else
machine = "unknown";
#endif
#endif
}
if (!machine_arch) {
#if defined(MAKE_NATIVE) && defined(HAVE_SYSCTL) && defined(CTL_HW) && defined(HW_MACHINE_ARCH)
static char machine_arch_buf[sizeof(utsname.machine)];
int mib[2] = { CTL_HW, HW_MACHINE_ARCH };
size_t len = sizeof(machine_arch_buf);
if (sysctl(mib, __arraycount(mib), machine_arch_buf,
&len, NULL, 0) < 0) {
(void)fprintf(stderr, "%s: sysctl failed (%s).\n", progname,
strerror(errno));
exit(2);
}
machine_arch = machine_arch_buf;
#else
#ifndef MACHINE_ARCH
#ifdef MAKE_MACHINE_ARCH
machine_arch = MAKE_MACHINE_ARCH;
#else
machine_arch = "unknown";
#endif
#else
machine_arch = MACHINE_ARCH;
#endif
#endif
}
myPid = getpid(); /* remember this for vFork() */
/*
* Just in case MAKEOBJDIR wants us to do something tricky.
*/
Var_Init(); /* Initialize the lists of variables for
* parsing arguments */
Var_Set(".MAKE.OS", utsname.sysname, VAR_GLOBAL, 0);
Var_Set("MACHINE", machine, VAR_GLOBAL, 0);
Var_Set("MACHINE_ARCH", machine_arch, VAR_GLOBAL, 0);
#ifdef MAKE_VERSION
Var_Set("MAKE_VERSION", MAKE_VERSION, VAR_GLOBAL, 0);
#endif
Var_Set(".newline", "\n", VAR_GLOBAL, 0); /* handy for :@ loops */
/*
* This is the traditional preference for makefiles.
*/
#ifndef MAKEFILE_PREFERENCE_LIST
# define MAKEFILE_PREFERENCE_LIST "makefile Makefile"
#endif
Var_Set(MAKEFILE_PREFERENCE, MAKEFILE_PREFERENCE_LIST,
VAR_GLOBAL, 0);
Var_Set(MAKE_DEPENDFILE, ".depend", VAR_GLOBAL, 0);
create = Lst_Init(FALSE);
makefiles = Lst_Init(FALSE);
printVars = FALSE;
debugVflag = FALSE;
variables = Lst_Init(FALSE);
beSilent = FALSE; /* Print commands as executed */
ignoreErrors = FALSE; /* Pay attention to non-zero returns */
noExecute = FALSE; /* Execute all commands */
noRecursiveExecute = FALSE; /* Execute all .MAKE targets */
keepgoing = FALSE; /* Stop on error */
allPrecious = FALSE; /* Remove targets when interrupted */
queryFlag = FALSE; /* This is not just a check-run */
noBuiltins = FALSE; /* Read the built-in rules */
touchFlag = FALSE; /* Actually update targets */
debug = 0; /* No debug verbosity, please. */
jobsRunning = FALSE;
maxJobs = DEFMAXLOCAL; /* Set default local max concurrency */
maxJobTokens = maxJobs;
compatMake = FALSE; /* No compat mode */
ignorePWD = FALSE;
/*
* Initialize the parsing, directory and variable modules to prepare
* for the reading of inclusion paths and variable settings on the
* command line
*/
/*
* Initialize various variables.
* MAKE also gets this name, for compatibility
* .MAKEFLAGS gets set to the empty string just in case.
* MFLAGS also gets initialized empty, for compatibility.
*/
Parse_Init();
if (argv[0][0] == '/' || strchr(argv[0], '/') == NULL) {
/*
* Leave alone if it is an absolute path, or if it does
* not contain a '/' in which case we need to find it in
* the path, like execvp(3) and the shells do.
*/
p1 = argv[0];
} else {
/*
* A relative path, canonicalize it.
*/
p1 = cached_realpath(argv[0], mdpath);
if (!p1 || *p1 != '/' || stat(p1, &sb) < 0) {
p1 = argv[0]; /* realpath failed */
}
}
Var_Set("MAKE", p1, VAR_GLOBAL, 0);
Var_Set(".MAKE", p1, VAR_GLOBAL, 0);
Var_Set(MAKEFLAGS, "", VAR_GLOBAL, 0);
Var_Set(MAKEOVERRIDES, "", VAR_GLOBAL, 0);
Var_Set("MFLAGS", "", VAR_GLOBAL, 0);
Var_Set(".ALLTARGETS", "", VAR_GLOBAL, 0);
/* some makefiles need to know this */
Var_Set(MAKE_LEVEL ".ENV", MAKE_LEVEL_ENV, VAR_CMD, 0);
/*
* Set some other useful macros
*/
{
char tmp[64], *ep;
makelevel = ((ep = getenv(MAKE_LEVEL_ENV)) && *ep) ? atoi(ep) : 0;
if (makelevel < 0)
makelevel = 0;
snprintf(tmp, sizeof(tmp), "%d", makelevel);
Var_Set(MAKE_LEVEL, tmp, VAR_GLOBAL, 0);
snprintf(tmp, sizeof(tmp), "%u", myPid);
Var_Set(".MAKE.PID", tmp, VAR_GLOBAL, 0);
snprintf(tmp, sizeof(tmp), "%u", getppid());
Var_Set(".MAKE.PPID", tmp, VAR_GLOBAL, 0);
}
if (makelevel > 0) {
char pn[1024];
snprintf(pn, sizeof(pn), "%s[%d]", progname, makelevel);
progname = bmake_strdup(pn);
}
#ifdef USE_META
meta_init();
#endif
/*
* First snag any flags out of the MAKE environment variable.
* (Note this is *not* MAKEFLAGS since /bin/make uses that and it's
* in a different format).
*/
#ifdef POSIX
p1 = explode(getenv("MAKEFLAGS"));
Main_ParseArgLine(p1);
free(p1);
#else
Main_ParseArgLine(getenv("MAKE"));
#endif
/*
* Find where we are (now).
* We take care of PWD for the automounter below...
*/
if (getcwd(curdir, MAXPATHLEN) == NULL) {
(void)fprintf(stderr, "%s: getcwd: %s.\n",
progname, strerror(errno));
exit(2);
}
MainParseArgs(argc, argv);
if (enterFlag)
printf("%s: Entering directory `%s'\n", progname, curdir);
/*
* Verify that cwd is sane.
*/
if (stat(curdir, &sa) == -1) {
(void)fprintf(stderr, "%s: %s: %s.\n",
progname, curdir, strerror(errno));
exit(2);
}
/*
* All this code is so that we know where we are when we start up
* on a different machine with pmake.
* Overriding getcwd() with $PWD totally breaks MAKEOBJDIRPREFIX
* since the value of curdir can vary depending on how we got
* here. Ie sitting at a shell prompt (shell that provides $PWD)
* or via subdir.mk in which case its likely a shell which does
* not provide it.
* So, to stop it breaking this case only, we ignore PWD if
* MAKEOBJDIRPREFIX is set or MAKEOBJDIR contains a transform.
*/
#ifndef NO_PWD_OVERRIDE
if (!ignorePWD) {
char *pwd, *ptmp1 = NULL, *ptmp2 = NULL;
if ((pwd = getenv("PWD")) != NULL &&
Var_Value("MAKEOBJDIRPREFIX", VAR_CMD, &ptmp1) == NULL) {
const char *makeobjdir = Var_Value("MAKEOBJDIR",
VAR_CMD, &ptmp2);
if (makeobjdir == NULL || !strchr(makeobjdir, '$')) {
if (stat(pwd, &sb) == 0 &&
sa.st_ino == sb.st_ino &&
sa.st_dev == sb.st_dev)
(void)strncpy(curdir, pwd, MAXPATHLEN);
}
}
free(ptmp1);
free(ptmp2);
}
#endif
Var_Set(".CURDIR", curdir, VAR_GLOBAL, 0);
/*
* Find the .OBJDIR. If MAKEOBJDIRPREFIX, or failing that,
* MAKEOBJDIR is set in the environment, try only that value
* and fall back to .CURDIR if it does not exist.
*
* Otherwise, try _PATH_OBJDIR.MACHINE, _PATH_OBJDIR, and
* finally _PATH_OBJDIRPREFIX`pwd`, in that order. If none
* of these paths exist, just use .CURDIR.
*/
Dir_Init(curdir);
(void)Main_SetObjdir(curdir);
if ((path = Var_Value("MAKEOBJDIRPREFIX", VAR_CMD, &p1)) != NULL) {
(void)snprintf(mdpath, MAXPATHLEN, "%s%s", path, curdir);
(void)Main_SetObjdir(mdpath);
free(p1);
} else if ((path = Var_Value("MAKEOBJDIR", VAR_CMD, &p1)) != NULL) {
(void)Main_SetObjdir(path);
free(p1);
} else {
(void)snprintf(mdpath, MAXPATHLEN, "%s.%s", _PATH_OBJDIR, machine);
if (!Main_SetObjdir(mdpath) && !Main_SetObjdir(_PATH_OBJDIR)) {
(void)snprintf(mdpath, MAXPATHLEN, "%s%s",
_PATH_OBJDIRPREFIX, curdir);
(void)Main_SetObjdir(mdpath);
}
}
/*
* Initialize archive, target and suffix modules in preparation for
* parsing the makefile(s)
*/
Arch_Init();
Targ_Init();
Suff_Init();
Trace_Init(tracefile);
DEFAULT = NULL;
(void)time(&now);
Trace_Log(MAKESTART, NULL);
/*
* Set up the .TARGETS variable to contain the list of targets to be
* created. If none specified, make the variable empty -- the parser
* will fill the thing in with the default or .MAIN target.
*/
if (!Lst_IsEmpty(create)) {
LstNode ln;
for (ln = Lst_First(create); ln != NULL;
ln = Lst_Succ(ln)) {
char *name = (char *)Lst_Datum(ln);
Var_Append(".TARGETS", name, VAR_GLOBAL);
}
} else
Var_Set(".TARGETS", "", VAR_GLOBAL, 0);
/*
* If no user-supplied system path was given (through the -m option)
* add the directories from the DEFSYSPATH (more than one may be given
* as dir1:...:dirn) to the system include path.
*/
if (syspath == NULL || *syspath == '\0')
syspath = defsyspath;
else
syspath = bmake_strdup(syspath);
for (start = syspath; *start != '\0'; start = cp) {
for (cp = start; *cp != '\0' && *cp != ':'; cp++)
continue;
if (*cp == ':') {
*cp++ = '\0';
}
/* look for magic parent directory search string */
if (strncmp(".../", start, 4) != 0) {
(void)Dir_AddDir(defIncPath, start);
} else {
if (Dir_FindHereOrAbove(curdir, start+4,
found_path, sizeof(found_path))) {
(void)Dir_AddDir(defIncPath, found_path);
}
}
}
if (syspath != defsyspath)
free(syspath);
/*
* Read in the built-in rules first, followed by the specified
* makefile, if it was (makefile != NULL), or the default
* makefile and Makefile, in that order, if it wasn't.
*/
if (!noBuiltins) {
LstNode ln;
sysMkPath = Lst_Init(FALSE);
Dir_Expand(_PATH_DEFSYSMK,
Lst_IsEmpty(sysIncPath) ? defIncPath : sysIncPath,
sysMkPath);
if (Lst_IsEmpty(sysMkPath))
Fatal("%s: no system rules (%s).", progname,
_PATH_DEFSYSMK);
ln = Lst_Find(sysMkPath, NULL, ReadMakefile);
if (ln == NULL)
Fatal("%s: cannot open %s.", progname,
(char *)Lst_Datum(ln));
}
if (!Lst_IsEmpty(makefiles)) {
LstNode ln;
ln = Lst_Find(makefiles, NULL, ReadAllMakefiles);
if (ln != NULL)
Fatal("%s: cannot open %s.", progname,
(char *)Lst_Datum(ln));
} else {
p1 = Var_Subst(NULL, "${" MAKEFILE_PREFERENCE "}",
VAR_CMD, VARF_WANTRES);
if (p1) {
(void)str2Lst_Append(makefiles, p1, NULL);
(void)Lst_Find(makefiles, NULL, ReadMakefile);
free(p1);
}
}
/* In particular suppress .depend for '-r -V .OBJDIR -f /dev/null' */
if (!noBuiltins || !printVars) {
makeDependfile = Var_Subst(NULL, "${.MAKE.DEPENDFILE:T}",
VAR_CMD, VARF_WANTRES);
doing_depend = TRUE;
(void)ReadMakefile(makeDependfile, NULL);
doing_depend = FALSE;
}
if (enterFlagObj)
printf("%s: Entering directory `%s'\n", progname, objdir);
MakeMode(NULL);
Var_Append("MFLAGS", Var_Value(MAKEFLAGS, VAR_GLOBAL, &p1), VAR_GLOBAL);
free(p1);
if (!forceJobs && !compatMake &&
Var_Exists(".MAKE.JOBS", VAR_GLOBAL)) {
char *value;
int n;
value = Var_Subst(NULL, "${.MAKE.JOBS}", VAR_GLOBAL, VARF_WANTRES);
n = strtol(value, NULL, 0);
if (n < 1) {
(void)fprintf(stderr, "%s: illegal value for .MAKE.JOBS -- must be positive integer!\n",
progname);
exit(1);
}
if (n != maxJobs) {
Var_Append(MAKEFLAGS, "-j", VAR_GLOBAL);
Var_Append(MAKEFLAGS, value, VAR_GLOBAL);
}
maxJobs = n;
maxJobTokens = maxJobs;
forceJobs = TRUE;
free(value);
}
/*
* Be compatible if user did not specify -j and did not explicitly
* turned compatibility on
*/
if (!compatMake && !forceJobs) {
compatMake = TRUE;
}
if (!compatMake)
Job_ServerStart(maxJobTokens, jp_0, jp_1);
if (DEBUG(JOB))
fprintf(debug_file, "job_pipe %d %d, maxjobs %d, tokens %d, compat %d\n",
jp_0, jp_1, maxJobs, maxJobTokens, compatMake);
Main_ExportMAKEFLAGS(TRUE); /* initial export */
/*
* For compatibility, look at the directories in the VPATH variable
* and add them to the search path, if the variable is defined. The
* variable's value is in the same format as the PATH envariable, i.e.
* <directory>:<directory>:<directory>...
*/
if (Var_Exists("VPATH", VAR_CMD)) {
char *vpath, savec;
/*
* GCC stores string constants in read-only memory, but
* Var_Subst will want to write this thing, so store it
* in an array
*/
static char VPATH[] = "${VPATH}";
vpath = Var_Subst(NULL, VPATH, VAR_CMD, VARF_WANTRES);
path = vpath;
do {
/* skip to end of directory */
for (cp = path; *cp != ':' && *cp != '\0'; cp++)
continue;
/* Save terminator character so know when to stop */
savec = *cp;
*cp = '\0';
/* Add directory to search path */
(void)Dir_AddDir(dirSearchPath, path);
*cp = savec;
path = cp + 1;
} while (savec == ':');
free(vpath);
}
/*
* Now that all search paths have been read for suffixes et al, it's
* time to add the default search path to their lists...
*/
Suff_DoPaths();
/*
* Propagate attributes through :: dependency lists.
*/
Targ_Propagate();
/* print the initial graph, if the user requested it */
if (DEBUG(GRAPH1))
Targ_PrintGraph(1);
/* print the values of any variables requested by the user */
if (printVars) {
LstNode ln;
Boolean expandVars;
if (debugVflag)
expandVars = FALSE;
else
expandVars = getBoolean(".MAKE.EXPAND_VARIABLES", FALSE);
for (ln = Lst_First(variables); ln != NULL;
ln = Lst_Succ(ln)) {
char *var = (char *)Lst_Datum(ln);
char *value;
if (strchr(var, '$')) {
value = p1 = Var_Subst(NULL, var, VAR_GLOBAL,
VARF_WANTRES);
} else if (expandVars) {
char tmp[128];
if (snprintf(tmp, sizeof(tmp), "${%s}", var) >= (int)(sizeof(tmp)))
Fatal("%s: variable name too big: %s",
progname, var);
value = p1 = Var_Subst(NULL, tmp, VAR_GLOBAL,
VARF_WANTRES);
} else {
value = Var_Value(var, VAR_GLOBAL, &p1);
}
printf("%s\n", value ? value : "");
free(p1);
}
} else {
/*
* Have now read the entire graph and need to make a list of
* targets to create. If none was given on the command line,
* we consult the parsing module to find the main target(s)
* to create.
*/
if (Lst_IsEmpty(create))
targs = Parse_MainName();
else
targs = Targ_FindList(create, TARG_CREATE);
if (!compatMake) {
/*
* Initialize job module before traversing the graph
* now that any .BEGIN and .END targets have been read.
* This is done only if the -q flag wasn't given
* (to prevent the .BEGIN from being executed should
* it exist).
*/
if (!queryFlag) {
Job_Init();
jobsRunning = TRUE;
}
/* Traverse the graph, checking on all the targets */
outOfDate = Make_Run(targs);
} else {
/*
* Compat_Init will take care of creating all the
* targets as well as initializing the module.
*/
Compat_Run(targs);
}
}
#ifdef CLEANUP
Lst_Destroy(targs, NULL);
Lst_Destroy(variables, NULL);
Lst_Destroy(makefiles, NULL);
Lst_Destroy(create, (FreeProc *)free);
#endif
/* print the graph now it's been processed if the user requested it */
if (DEBUG(GRAPH2))
Targ_PrintGraph(2);
Trace_Log(MAKEEND, 0);
if (enterFlagObj)
printf("%s: Leaving directory `%s'\n", progname, objdir);
if (enterFlag)
printf("%s: Leaving directory `%s'\n", progname, curdir);
#ifdef USE_META
meta_finish();
#endif
Suff_End();
Targ_End();
Arch_End();
Var_End();
Parse_End();
Dir_End();
Job_End();
Trace_End();
return outOfDate ? 1 : 0;
}
};
uint16_t hf_services[] = {
SDP_SERVICE_CLASS_HANDSFREE_AUDIO_GATEWAY,
};
static struct {
const char *name;
int (*handler)(prop_dictionary_t, sdp_data_t *);
const char *description;
uint16_t *services;
size_t nservices;
} cfgtype[] = {
{
"HID", config_hid, "Human Interface Device",
hid_services, __arraycount(hid_services),
},
{
"HSET", config_hset, "Headset",
hset_services, __arraycount(hset_services),
},
{
"HF", config_hf, "Handsfree",
hf_services, __arraycount(hf_services),
},
};
#define MAX_SSP (2 + 1 * 3) /* largest nservices is 1 */
static bool
cfg_ssa(sdp_session_t ss, uint16_t *services, size_t nservices, sdp_data_t *rsp)
/* ARGSUSED */
int
compat_16_sys___sigreturn14(struct lwp *l, const struct compat_16_sys___sigreturn14_args *uap, register_t *retval)
{
/* {
syscallarg(struct sigcontext *) sigcntxp;
} */
struct sigcontext *scp, ksc;
struct trapframe * const tf = l->l_md.md_utf;
struct proc * const p = l->l_proc;
struct pcb * const pcb = lwp_getpcb(l);
int error;
#if !defined(__mips_o32)
if (p->p_md.md_abi != _MIPS_BSD_API_O32)
return ENOSYS;
#endif
/*
* The trampoline code hands us the context.
* It is unsafe to keep track of it ourselves, in the event that a
* program jumps out of a signal handler.
*/
scp = SCARG(uap, sigcntxp);
#ifdef DEBUG
if (sigdebug & SDB_FOLLOW)
printf("sigreturn: pid %d, scp %p\n", l->l_proc->p_pid, scp);
#endif
if ((error = copyin(scp, &ksc, sizeof(ksc))) != 0)
return (error);
if ((u_int) ksc.sc_regs[_R_ZERO] != 0xacedbadeU)/* magic number */
return (EINVAL);
/* Restore the register context. */
tf->tf_regs[_R_PC] = ksc.sc_pc;
tf->tf_regs[_R_MULLO] = ksc.mullo;
tf->tf_regs[_R_MULHI] = ksc.mulhi;
#if defined(__mips_o32)
memcpy(&tf->tf_regs[1], &scp->sc_regs[1],
sizeof(scp->sc_regs) - sizeof(scp->sc_regs[0]));
#else
for (size_t i = 1; i < __arraycount(ksc.sc_regs); i++)
tf->tf_regs[i] = ksc.sc_regs[i];
#endif
#if !defined(NOFPU)
if (scp->sc_fpused) {
fpu_discard();
}
#endif
*(struct fpreg *)&pcb->pcb_fpregs = *(struct fpreg *)scp->sc_fpregs;
mutex_enter(p->p_lock);
/* Restore signal stack. */
if (ksc.sc_onstack & SS_ONSTACK)
l->l_sigstk.ss_flags |= SS_ONSTACK;
else
l->l_sigstk.ss_flags &= ~SS_ONSTACK;
/* Restore signal mask. */
(void) sigprocmask1(l, SIG_SETMASK, &ksc.sc_mask, 0);
mutex_exit(p->p_lock);
return (EJUSTRETURN);
}
static void ctcommand(dev_t, int, int);
static const struct ctinfo {
short hwid;
short punit;
const char *desc;
} ctinfo[] = {
{ CT7946ID, 1, "7946A" },
{ CT7912PID, 1, "7912P" },
{ CT7914PID, 1, "7914P" },
{ CT9144ID, 0, "9144" },
{ CT9145ID, 0, "9145" },
{ CT35401ID, 0, "35401A"},
};
static const int nctinfo = __arraycount(ctinfo);
#define CT_NOREW 4
#define CT_STREAM 8
#define UNIT(x) (minor(x) & 3)
#define ctpunit(x) ((x) & 7)
#ifdef DEBUG
int ctdebug = 0;
#define CDB_FILES 0x01
#define CT_BSF 0x02
#endif
static int
ctmatch(device_t parent, cfdata_t cf, void *aux)
{
INTEL_VGA_DEVICE(0x0155, &intel_valleyview_d_info),
#ifdef __NetBSD__
{0, 0, 0, 0, 0, 0, 0}
#else
{0, 0, 0}
#endif
};
#if defined(CONFIG_DRM_I915_KMS)
MODULE_DEVICE_TABLE(pci, pciidlist);
#endif
#ifdef __NetBSD__
/* XXX Kludge to expose this to NetBSD driver attachment goop. */
const struct pci_device_id *const i915_device_ids = pciidlist;
const size_t i915_n_device_ids = __arraycount(pciidlist);
#endif
void intel_detect_pch(struct drm_device *dev)
{
struct drm_i915_private *dev_priv = dev->dev_private;
struct pci_dev *pch;
/*
* The reason to probe ISA bridge instead of Dev31:Fun0 is to
* make graphics device passthrough work easy for VMM, that only
* need to expose ISA bridge to let driver know the real hardware
* underneath. This is a requirement from virtualization team.
*/
pch = pci_get_class(PCI_CLASS_BRIDGE_ISA << 8, NULL);
if (pch) {
void
rumprun_config(char *cmdline)
{
char *cfg;
struct rumprun_exec *rre;
jsmn_parser p;
jsmntok_t *tokens = NULL;
jsmntok_t *t;
size_t cmdline_len;
unsigned int i;
int ntok;
/* is the config file on rootfs? if so, mount & dig it out */
cfg = rumprun_config_path(cmdline);
if (cfg != NULL) {
cmdline = getcmdlinefromroot(cfg);
if (cmdline == NULL)
errx(1, "could not get cfg from rootfs");
}
while (*cmdline != '{') {
if (*cmdline == '\0') {
warnx("could not find start of json. no config?");
makeargv(strdup("rumprun"));
return;
}
cmdline++;
}
cmdline_len = strlen(cmdline);
jsmn_init(&p);
ntok = jsmn_parse(&p, cmdline, cmdline_len, NULL, 0);
if (ntok <= 0) {
errx(1, "json parse failed 1");
}
tokens = malloc(ntok * sizeof(*t));
if (!tokens) {
errx(1, "failed to allocate jsmn tokens");
}
jsmn_init(&p);
if ((ntok = jsmn_parse(&p, cmdline, cmdline_len, tokens, ntok)) < 1) {
errx(1, "json parse failed 2");
}
T_CHECKTYPE(tokens, cmdline, JSMN_OBJECT, __func__);
for (t = &tokens[0]; t < &tokens[ntok]; ) {
/* allow multiple levels of object nesting */
if (t->type == JSMN_OBJECT) {
t++;
continue;
}
T_CHECKTYPE(t, cmdline, JSMN_STRING, __func__);
for (i = 0; i < __arraycount(parsers); i++) {
if (T_STREQ(t, cmdline, parsers[i].name)) {
int left;
t++;
left = &tokens[ntok] - t;
t += parsers[i].handler(t, left, cmdline);
break;
}
}
if (i == __arraycount(parsers))
errx(1, "no match for key \"%.*s\"",
T_PRINTFSTAR(t, cmdline));
}
/*
* Before we start running things, perform some sanity checks
*/
rre = TAILQ_LAST(&rumprun_execs, rumprun_execs);
if (rre == NULL) {
errx(1, "rumprun_config: no bins");
}
if (rre->rre_flags & RUMPRUN_EXEC_PIPE) {
errx(1, "rumprun_config: last bin may not output to pipe");
}
free(tokens);
}
ATF_TC_BODY(glob_star, tc)
{
run("a/**", GLOB_STAR, glob_star, __arraycount(glob_star));
}
static struct gl_file b[] = {
{ "x", 0 },
{ "y", 0 },
{ "z", 0 },
{ "w", 0 },
};
struct gl_dir {
const char *name; /* directory name */
const struct gl_file *dir;
size_t len, pos;
};
static struct gl_dir d[] = {
{ "a", a, __arraycount(a), 0 },
{ "a/b", b, __arraycount(b), 0 },
};
#ifdef GLOB_STAR
static const char *glob_star[] = {
"a/1", "a/3", "a/4", "a/b", "a/b/w", "a/b/x", "a/b/y", "a/b/z",
};
#endif
static const char *glob_star_not[] = {
"a/1", "a/3", "a/4", "a/b",
};
static void
trim(char *buf, size_t len, const char *name)
/*
* Attach the mainbus.
*
* Our main job is to attach the CPU (the root node we got in configure())
* and iterate down the list of `mainbus devices' (children of that node).
* We also record the `node id' of the default frame buffer, if any.
*/
static void
mainbus_attach(device_t parent, device_t dev, void *aux)
{
extern struct sparc_bus_dma_tag mainbus_dma_tag;
extern struct sparc_bus_space_tag mainbus_space_tag;
struct mainbus_attach_args ma;
char sbuf[32];
const char *const *ssp, *sp = NULL;
char *c;
int node0, node, rv, i;
static const char *const openboot_special[] = {
/* ignore these (end with NULL) */
/*
* These are _root_ devices to ignore. Others must be handled
* elsewhere.
*/
"virtual-memory",
"aliases",
"memory",
"openprom",
"options",
"packages",
"chosen",
NULL
};
if (OF_getprop(findroot(), "banner-name", machine_banner,
sizeof machine_banner) < 0)
i = 0;
else {
i = 1;
if (((c = strchr(machine_banner, '(')) != NULL) &&
c != &machine_banner[0]) {
while (*c == '(' || *c == ' ') {
*c = '\0';
c--;
}
}
}
OF_getprop(findroot(), "name", machine_model, sizeof machine_model);
prom_getidprom();
if (i)
aprint_normal(": %s (%s): hostid %lx\n", machine_model,
machine_banner, hostid);
else
aprint_normal(": %s: hostid %lx\n", machine_model, hostid);
aprint_naive("\n");
/*
* Locate and configure the ``early'' devices. These must be
* configured before we can do the rest. For instance, the
* EEPROM contains the Ethernet address for the LANCE chip.
* If the device cannot be located or configured, panic.
*/
if (sparc_ncpus == 0)
panic("None of the CPUs found");
/*
* Init static interrupt eventcounters
*/
for (i = 0; i < __arraycount(intr_evcnts); i++)
evcnt_attach_static(&intr_evcnts[i]);
node = findroot();
/* first early device to be configured is the CPU */
for (node = OF_child(node); node; node = OF_peer(node)) {
if (OF_getprop(node, "device_type", sbuf, sizeof(sbuf)) <= 0)
continue;
if (strcmp(sbuf, "cpu") != 0)
continue;
memset(&ma, 0, sizeof(ma));
ma.ma_bustag = &mainbus_space_tag;
ma.ma_dmatag = &mainbus_dma_tag;
ma.ma_node = node;
ma.ma_name = "cpu";
config_found(dev, &ma, mbprint);
}
node = findroot(); /* re-init root node */
/* Find the "options" node */
node0 = OF_child(node);
/*
* Configure the devices, in PROM order. Skip
* PROM entries that are not for devices, or which must be
* done before we get here.
*/
for (node = node0; node; node = OF_peer(node)) {
int portid;
DPRINTF(ACDB_PROBE, ("Node: %x", node));
if ((OF_getprop(node, "device_type", sbuf, sizeof(sbuf)) > 0) &&
strcmp(sbuf, "cpu") == 0)
continue;
OF_getprop(node, "name", sbuf, sizeof(sbuf));
DPRINTF(ACDB_PROBE, (" name %s\n", sbuf));
for (ssp = openboot_special; (sp = *ssp) != NULL; ssp++)
if (strcmp(sbuf, sp) == 0)
break;
if (sp != NULL)
continue; /* an "early" device already configured */
memset(&ma, 0, sizeof ma);
ma.ma_bustag = &mainbus_space_tag;
ma.ma_dmatag = &mainbus_dma_tag;
ma.ma_name = sbuf;
ma.ma_node = node;
if (OF_getprop(node, "upa-portid", &portid, sizeof(portid)) !=
sizeof(portid) &&
OF_getprop(node, "portid", &portid, sizeof(portid)) !=
sizeof(portid))
portid = -1;
ma.ma_upaid = portid;
if (prom_getprop(node, "reg", sizeof(*ma.ma_reg),
&ma.ma_nreg, &ma.ma_reg) != 0)
continue;
#ifdef DEBUG
if (autoconf_debug & ACDB_PROBE) {
if (ma.ma_nreg)
printf(" reg %08lx.%08lx\n",
(long)ma.ma_reg->ur_paddr,
(long)ma.ma_reg->ur_len);
else
printf(" no reg\n");
}
#endif
rv = prom_getprop(node, "interrupts", sizeof(*ma.ma_interrupts),
&ma.ma_ninterrupts, &ma.ma_interrupts);
if (rv != 0 && rv != ENOENT) {
free(ma.ma_reg, M_DEVBUF);
continue;
}
#ifdef DEBUG
if (autoconf_debug & ACDB_PROBE) {
if (ma.ma_interrupts)
printf(" interrupts %08x\n", *ma.ma_interrupts);
else
printf(" no interrupts\n");
}
#endif
rv = prom_getprop(node, "address", sizeof(*ma.ma_address),
&ma.ma_naddress, &ma.ma_address);
if (rv != 0 && rv != ENOENT) {
free(ma.ma_reg, M_DEVBUF);
if (ma.ma_ninterrupts)
free(ma.ma_interrupts, M_DEVBUF);
continue;
}
#ifdef DEBUG
if (autoconf_debug & ACDB_PROBE) {
if (ma.ma_naddress)
printf(" address %08x\n", *ma.ma_address);
else
printf(" no address\n");
}
#endif
(void) config_found(dev, (void *)&ma, mbprint);
free(ma.ma_reg, M_DEVBUF);
if (ma.ma_ninterrupts)
free(ma.ma_interrupts, M_DEVBUF);
if (ma.ma_naddress)
free(ma.ma_address, M_DEVBUF);
}
/* Try to attach PROM console */
memset(&ma, 0, sizeof ma);
ma.ma_name = "pcons";
(void) config_found(dev, (void *)&ma, mbprint);
}
.k_type = KW_T_BOOL, .k_bool = true, .k_negbool = false,
.k_exec = sethidessid}
, {.k_word = "apbridge", .k_key = "apbridge", .k_neg = true,
.k_type = KW_T_BOOL, .k_bool = true, .k_negbool = false,
.k_exec = setapbridge}
, {.k_word = "powersave", .k_key = "powersave", .k_neg = true,
.k_type = KW_T_BOOL, .k_bool = true, .k_negbool = false,
.k_exec = setifpowersave}
};
static const struct kwinst listskw[] = {
{.k_word = "scan", .k_exec = scan_exec}
};
static struct pkw lists = PKW_INITIALIZER(&lists, "ieee80211 lists", NULL,
"list", listskw, __arraycount(listskw), &command_root.pb_parser);
static const struct kwinst kw80211kw[] = {
{.k_word = "bssid", .k_nextparser = &parse_bssid.ps_parser}
, {.k_word = "-bssid", .k_exec = unsetifbssid,
.k_nextparser = &command_root.pb_parser}
, {.k_word = "chan", .k_nextparser = &parse_chan.pi_parser}
, {.k_word = "-chan", .k_key = "chan", .k_type = KW_T_UINT,
.k_uint = IEEE80211_CHAN_ANY, .k_exec = setifchan,
.k_nextparser = &command_root.pb_parser}
, {.k_word = "frag", .k_nextparser = &parse_frag.pi_parser}
, {.k_word = "-frag", .k_key = "frag", .k_type = KW_T_INT,
.k_int = IEEE80211_FRAG_MAX, .k_exec = setiffrag,
.k_nextparser = &command_root.pb_parser}
, {.k_word = "list", .k_nextparser = &lists.pk_parser}
, {.k_word = "nwid", .k_nextparser = &parse_ssid.ps_parser}
static int
handle_blk(jsmntok_t *t, int left, char *data)
{
const char *source, *origpath, *fstype;
char *mp, *path;
jsmntok_t *key, *value;
int i, objsize;
T_CHECKTYPE(t, data, JSMN_OBJECT, __func__);
/* we expect straight key-value pairs */
objsize = t->size;
if (left < 2*objsize + 1) {
return -1;
}
t++;
fstype = source = origpath = mp = path = NULL;
for (i = 0; i < objsize; i++, t+=2) {
char *valuestr;
key = t;
value = t+1;
T_CHECKTYPE(key, data, JSMN_STRING, __func__);
T_CHECKSIZE(key, data, 1, __func__);
T_CHECKTYPE(value, data, JSMN_STRING, __func__);
T_CHECKSIZE(value, data, 0, __func__);
valuestr = token2cstr(value, data);
if (T_STREQ(key, data, "source")) {
source = valuestr;
} else if (T_STREQ(key, data, "path")) {
origpath = path = valuestr;
} else if (T_STREQ(key, data, "fstype")) {
fstype = valuestr;
} else if (T_STREQ(key, data, "mountpoint")) {
mp = valuestr;
} else {
errx(1, "unexpected key \"%.*s\" in \"%s\"",
T_PRINTFSTAR(key, data), __func__);
}
}
if (!source || !path) {
errx(1, "blk cfg missing vital data");
}
if (strcmp(source, "dev") == 0) {
/* nothing to do here */
} else if (strcmp(source, "vnd") == 0) {
path = configvnd(path);
} else if (strcmp(source, "etfs") == 0) {
path = configetfs(path, 1);
} else {
errx(1, "unsupported blk source \"%s\"", source);
}
/* we only need to do something only if a mountpoint is specified */
if (mp) {
char *chunk;
unsigned mi;
if (!fstype) {
errx(1, "no fstype for mountpoint \"%s\"\n", mp);
}
for (chunk = mp;;) {
bool end;
/* find & terminate the next chunk */
chunk += strspn(chunk, "/");
chunk += strcspn(chunk, "/");
end = (*chunk == '\0');
*chunk = '\0';
if (mkdir(mp, 0755) == -1) {
if (errno != EEXIST)
err(1, "failed to create mp dir \"%s\"",
chunk);
}
/* restore path */
if (!end)
*chunk = '/';
else
break;
}
for (mi = 0; mi < __arraycount(mounters); mi++) {
if (strcmp(fstype, mounters[mi].mt_fstype) == 0) {
if (!mounters[mi].mt_mount(path, mp))
errx(1, "failed to mount fs type "
"\"%s\" from \"%s\" to \"%s\"",
fstype, path, mp);
break;
}
}
if (mi == __arraycount(mounters))
errx(1, "unknown fstype \"%s\"", fstype);
}
if (path != origpath)
free(path);
return 2*objsize + 1;
}
static char *
getcmdlinefromroot(const char *cfgname)
{
const char *tryroot[] = {
"/dev/ld0a",
"/dev/sd0a",
};
struct stat sb;
unsigned int i;
int fd;
char *p;
if (mkdir("/rootfs", 0777) == -1)
err(1, "mkdir /rootfs failed");
/*
* XXX: should not be hardcoded to cd9660. but it is for now.
* Maybe use mountroot() here somehow?
*/
for (i = 0; i < __arraycount(tryroot); i++) {
if (mount_blk(tryroot[i], "/rootfs"))
break;
}
/* didn't find it that way. one more try: etfs for sda1 (EC2) */
if (i == __arraycount(tryroot)) {
char *devpath;
devpath = configetfs("sda1", 0);
if (!devpath)
errx(1, "failed to mount rootfs from image");
if (!mount_blk(devpath, "/rootfs"))
errx(1, "failed to mount /rootfs");
}
/*
* Ok, we've successfully mounted /rootfs. Now get the config.
*/
while (*cfgname == '/')
cfgname++;
if (chdir("/rootfs") == -1)
err(1, "chdir rootfs");
if ((fd = open(cfgname, O_RDONLY)) == -1)
err(1, "open %s", cfgname);
if (stat(cfgname, &sb) == -1)
err(1, "stat %s", cfgname);
if (sb.st_size > CFGMAXSIZE)
errx(1, "unbelievable cfg file size, increase CFGMAXSIZE");
if ((p = malloc(sb.st_size+1)) == NULL)
err(1, "cfgname storage");
if (read(fd, p, sb.st_size) != sb.st_size)
err(1, "read cfgfile");
close(fd);
p[sb.st_size] = '\0';
return p;
}
ATF_TC_BODY(glob_star_not, tc)
{
run("a/**", 0, glob_star_not, __arraycount(glob_star_not));
}
static void
awinio_attach(device_t parent, device_t self, void *aux)
{
struct awinio_softc * const sc = &awinio_sc;
const bool a10_p = CPU_ID_CORTEX_A8_P(curcpu()->ci_arm_cpuid);
const bool a20_p = CPU_ID_CORTEX_A7_P(curcpu()->ci_arm_cpuid);
prop_dictionary_t dict = device_properties(self);
sc->sc_dev = self;
sc->sc_bst = &awin_bs_tag;
sc->sc_a4x_bst = &awin_a4x_bs_tag;
sc->sc_bsh = awin_core_bsh;
sc->sc_dmat = &awin_dma_tag;
bus_space_subregion(sc->sc_bst, sc->sc_bsh, AWIN_CCM_OFFSET, 0x1000,
&sc->sc_ccm_bsh);
aprint_naive("\n");
aprint_normal("\n");
const struct awin_locators * const eloc =
awin_locators + __arraycount(awin_locators);
for (const struct awin_locators *loc = awin_locators; loc < eloc; loc++) {
char prop_name[31];
bool skip;
if (loc->loc_port == AWINIOCF_PORT_DEFAULT) {
snprintf(prop_name, sizeof(prop_name),
"no-%s", loc->loc_name);
} else {
snprintf(prop_name, sizeof(prop_name),
"no-%s-%d", loc->loc_name, loc->loc_port);
}
if (prop_dictionary_get_bool(dict, prop_name, &skip) && skip)
continue;
if (loc->loc_flags & AWINIO_ONLY) {
if (a10_p && !(loc->loc_flags & AWINIO_ONLY_A10))
continue;
if (a20_p && !(loc->loc_flags & AWINIO_ONLY_A20))
continue;
}
struct awinio_attach_args aio = {
.aio_loc = *loc,
.aio_core_bst = sc->sc_bst,
.aio_core_a4x_bst = sc->sc_a4x_bst,
.aio_core_bsh = sc->sc_bsh,
.aio_ccm_bsh = sc->sc_ccm_bsh,
.aio_dmat = sc->sc_dmat,
};
cfdata_t cf = config_search_ia(awinio_find,
sc->sc_dev, "awinio", &aio);
if (cf == NULL) {
if (loc->loc_flags & AWINIO_REQUIRED)
panic("%s: failed to find %s!", __func__,
loc->loc_name);
continue;
}
config_attach(sc->sc_dev, cf, &aio, awinio_print);
}
}
int
main(int argc, char **argv)
{
int ch, status;
unsigned int i;
int cflag, Cflag, Dflag, Uflag, wflag;
char *dir, *p;
FILE *spec1, *spec2;
setprogname(argv[0]);
cflag = Cflag = Dflag = Uflag = wflag = 0;
dir = NULL;
init_excludes();
spec1 = stdin;
spec2 = NULL;
while ((ch = getopt(argc, argv,
"bcCdDeE:f:F:I:ijk:K:lLmMnN:O:p:PqrR:s:StuUwWxX:"))
!= -1) {
switch((char)ch) {
case 'b':
bflag = 1;
break;
case 'c':
cflag = 1;
break;
case 'C':
Cflag = 1;
break;
case 'd':
dflag = 1;
break;
case 'D':
Dflag = 1;
break;
case 'E':
parsetags(&excludetags, optarg);
break;
case 'e':
eflag = 1;
break;
case 'f':
if (spec1 == stdin) {
spec1 = fopen(optarg, "r");
if (spec1 == NULL)
mtree_err("%s: %s", optarg,
strerror(errno));
} else if (spec2 == NULL) {
spec2 = fopen(optarg, "r");
if (spec2 == NULL)
mtree_err("%s: %s", optarg,
strerror(errno));
} else
usage();
break;
case 'F':
for (i = 0; i < __arraycount(flavors); i++)
if (strcmp(optarg, flavors[i].name) == 0) {
flavor = flavors[i].flavor;
break;
}
if (i == __arraycount(flavors))
usage();
break;
case 'i':
iflag = 1;
break;
case 'I':
parsetags(&includetags, optarg);
break;
case 'j':
jflag = 1;
break;
case 'k':
keys = F_TYPE;
while ((p = strsep(&optarg, " \t,")) != NULL)
if (*p != '\0')
keys |= parsekey(p, NULL);
break;
case 'K':
while ((p = strsep(&optarg, " \t,")) != NULL)
if (*p != '\0')
keys |= parsekey(p, NULL);
break;
case 'l':
lflag = 1;
break;
case 'L':
ftsoptions &= ~FTS_PHYSICAL;
ftsoptions |= FTS_LOGICAL;
break;
case 'm':
mflag = 1;
break;
case 'M':
mtree_Mflag = 1;
break;
case 'n':
nflag = 1;
break;
case 'N':
if (! setup_getid(optarg))
mtree_err(
"Unable to use user and group databases in `%s'",
optarg);
break;
case 'O':
load_only(optarg);
break;
case 'p':
dir = optarg;
break;
case 'P':
ftsoptions &= ~FTS_LOGICAL;
ftsoptions |= FTS_PHYSICAL;
break;
case 'q':
qflag = 1;
break;
case 'r':
rflag++;
break;
case 'R':
while ((p = strsep(&optarg, " \t,")) != NULL)
if (*p != '\0')
keys &= ~parsekey(p, NULL);
break;
case 's':
sflag = 1;
crc_total = ~strtol(optarg, &p, 0);
if (*p)
mtree_err("illegal seed value -- %s", optarg);
break;
case 'S':
mtree_Sflag = 1;
break;
case 't':
tflag = 1;
break;
case 'u':
uflag = 1;
break;
case 'U':
Uflag = uflag = 1;
break;
case 'w':
wflag = 1;
break;
case 'W':
mtree_Wflag = 1;
break;
case 'x':
ftsoptions |= FTS_XDEV;
break;
case 'X':
read_excludes_file(optarg);
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc)
usage();
switch (flavor) {
case F_FREEBSD9:
if (cflag && iflag) {
warnx("-c and -i passed, replacing -i with -j for "
"FreeBSD compatibility");
iflag = 0;
jflag = 1;
}
if (dflag && !bflag) {
warnx("Adding -b to -d for FreeBSD compatibility");
bflag = 1;
}
if (uflag && !iflag) {
warnx("Adding -i to -%c for FreeBSD compatibility",
Uflag ? 'U' : 'u');
iflag = 1;
}
if (uflag && !tflag) {
warnx("Adding -t to -%c for FreeBSD compatibility",
Uflag ? 'U' : 'u');
tflag = 1;
}
if (wflag)
warnx("The -w flag is a no-op");
break;
default:
if (wflag)
usage();
}
if (spec2 && (cflag || Cflag || Dflag))
mtree_err("Double -f, -c, -C and -D flags are mutually "
"exclusive");
if (dir && spec2)
mtree_err("Double -f and -p flags are mutually exclusive");
if (dir && chdir(dir))
mtree_err("%s: %s", dir, strerror(errno));
if ((cflag || sflag) && !getcwd(fullpath, sizeof(fullpath)))
mtree_err("%s", strerror(errno));
if ((cflag && Cflag) || (cflag && Dflag) || (Cflag && Dflag))
mtree_err("-c, -C and -D flags are mutually exclusive");
if (iflag && mflag)
mtree_err("-i and -m flags are mutually exclusive");
if (lflag && uflag)
mtree_err("-l and -u flags are mutually exclusive");
if (cflag) {
cwalk(stdout);
exit(0);
}
if (Cflag || Dflag) {
dump_nodes(stdout, "", spec(spec1), Dflag);
exit(0);
}
if (spec2 != NULL)
status = mtree_specspec(spec1, spec2);
else
status = verify(spec1);
if (Uflag && (status == MISMATCHEXIT))
status = 0;
exit(status);
}
void
pcic_attach(struct pcic_softc *sc)
{
int i, reg, chip, socket;
struct pcic_handle *h;
device_t self;
DPRINTF(("pcic ident regs:"));
self = sc->dev;
mutex_init(&sc->sc_pcic_lock, MUTEX_DEFAULT, IPL_NONE);
/* find and configure for the available sockets */
for (i = 0; i < __arraycount(sc->handle); i++) {
h = &sc->handle[i];
chip = i / 2;
socket = i % 2;
h->ph_parent = self;
h->chip = chip;
h->socket = socket;
h->sock = chip * PCIC_CHIP_OFFSET + socket * PCIC_SOCKET_OFFSET;
h->laststate = PCIC_LASTSTATE_EMPTY;
/* initialize pcic_read and pcic_write functions */
h->ph_read = st_pcic_read;
h->ph_write = st_pcic_write;
h->ph_bus_t = sc->iot;
h->ph_bus_h = sc->ioh;
h->flags = 0;
/* need to read vendor -- for cirrus to report no xtra chip */
if (socket == 0) {
h->vendor = pcic_vendor(h);
if (i < __arraycount(sc->handle) - 1)
(h + 1)->vendor = h->vendor;
}
switch (h->vendor) {
case PCIC_VENDOR_NONE:
/* no chip */
continue;
case PCIC_VENDOR_CIRRUS_PD67XX:
reg = pcic_read(h, PCIC_CIRRUS_CHIP_INFO);
if (socket == 0 ||
(reg & PCIC_CIRRUS_CHIP_INFO_SLOTS))
h->flags = PCIC_FLAG_SOCKETP;
break;
default:
/*
* During the socket probe, read the ident register
* twice. I don't understand why, but sometimes the
* clone chips in hpcmips boxes read all-0s the first
* time. -- mycroft
*/
reg = pcic_read(h, PCIC_IDENT);
DPRINTF(("socket %d ident reg 0x%02x\n", i, reg));
reg = pcic_read(h, PCIC_IDENT);
DPRINTF(("socket %d ident reg 0x%02x\n", i, reg));
if (pcic_ident_ok(reg))
h->flags = PCIC_FLAG_SOCKETP;
break;
}
}
for (i = 0; i < __arraycount(sc->handle); i++) {
h = &sc->handle[i];
if (h->flags & PCIC_FLAG_SOCKETP) {
SIMPLEQ_INIT(&h->events);
/* disable interrupts and leave socket in reset */
pcic_write(h, PCIC_INTR, 0);
/* zero out the address windows */
pcic_write(h, PCIC_ADDRWIN_ENABLE, 0);
/* power down the socket */
pcic_write(h, PCIC_PWRCTL, 0);
pcic_write(h, PCIC_CSC_INTR, 0);
(void) pcic_read(h, PCIC_CSC);
}
}
/* print detected info */
for (i = 0; i < __arraycount(sc->handle) - 1; i += 2) {
h = &sc->handle[i];
chip = i / 2;
if (h->vendor == PCIC_VENDOR_NONE)
continue;
aprint_normal_dev(self, "controller %d (%s) has ",
chip, pcic_vendor_to_string(sc->handle[i].vendor));
if ((h->flags & PCIC_FLAG_SOCKETP) &&
((h + 1)->flags & PCIC_FLAG_SOCKETP))
aprint_normal("sockets A and B\n");
else if (h->flags & PCIC_FLAG_SOCKETP)
aprint_normal("socket A only\n");
else if ((h + 1)->flags & PCIC_FLAG_SOCKETP)
aprint_normal("socket B only\n");
else
aprint_normal("no sockets\n");
}
}
static void
awinio_attach(device_t parent, device_t self, void *aux)
{
struct awinio_softc * const sc = &awinio_sc;
uint16_t chip_id = awin_chip_id();
const char *chip_name = awin_chip_name();
const bool a10_p = chip_id == AWIN_CHIP_ID_A10;
const bool a20_p = chip_id == AWIN_CHIP_ID_A20;
const bool a31_p = chip_id == AWIN_CHIP_ID_A31;
const bool a80_p = chip_id == AWIN_CHIP_ID_A80;
prop_dictionary_t dict = device_properties(self);
sc->sc_dev = self;
sc->sc_bst = &armv7_generic_bs_tag;
sc->sc_a4x_bst = &armv7_generic_a4x_bs_tag;
sc->sc_bsh = awin_core_bsh;
sc->sc_dmat = &awin_dma_tag;
sc->sc_coherent_dmat = &awin_coherent_dma_tag;
switch (awin_chip_id()) {
#ifdef ALLWINNER_A80
case AWIN_CHIP_ID_A80:
sc->sc_a80_core2_bsh = awin_core2_bsh;
sc->sc_a80_rcpus_bsh = awin_rcpus_bsh;
bus_space_subregion(sc->sc_bst, sc->sc_bsh,
AWIN_A80_CCU_SCLK_OFFSET, 0x1000, &sc->sc_ccm_bsh);
bus_space_map(sc->sc_bst, AWIN_A80_USB_PBASE,
AWIN_A80_USB_SIZE, 0, &sc->sc_a80_usb_bsh);
break;
#endif
default:
bus_space_subregion(sc->sc_bst, sc->sc_bsh, AWIN_CCM_OFFSET,
0x1000, &sc->sc_ccm_bsh);
break;
}
aprint_naive("\n");
aprint_normal(": %s (0x%04x)\n", chip_name, chip_id);
const struct awin_locators * const eloc =
awin_locators + __arraycount(awin_locators);
for (const struct awin_locators *loc = awin_locators; loc < eloc; loc++) {
char prop_name[31];
bool skip;
if (loc->loc_port == AWINIOCF_PORT_DEFAULT) {
snprintf(prop_name, sizeof(prop_name),
"no-%s", loc->loc_name);
} else {
snprintf(prop_name, sizeof(prop_name),
"no-%s-%d", loc->loc_name, loc->loc_port);
}
if (prop_dictionary_get_bool(dict, prop_name, &skip) && skip)
continue;
if (loc->loc_flags & AWINIO_ONLY) {
if (a10_p && !(loc->loc_flags & AWINIO_ONLY_A10))
continue;
if (a20_p && !(loc->loc_flags & AWINIO_ONLY_A20))
continue;
if (a31_p && !(loc->loc_flags & AWINIO_ONLY_A31))
continue;
if (a80_p && !(loc->loc_flags & AWINIO_ONLY_A80))
continue;
}
struct awinio_attach_args aio = {
.aio_loc = *loc,
.aio_core_bst = sc->sc_bst,
.aio_core_a4x_bst = sc->sc_a4x_bst,
.aio_core_bsh = sc->sc_bsh,
.aio_ccm_bsh = sc->sc_ccm_bsh,
.aio_a80_usb_bsh = sc->sc_a80_usb_bsh,
.aio_a80_core2_bsh = sc->sc_a80_core2_bsh,
.aio_a80_rcpus_bsh = sc->sc_a80_rcpus_bsh,
.aio_dmat = sc->sc_dmat,
.aio_coherent_dmat = sc->sc_coherent_dmat,
};
cfdata_t cf = config_search_ia(awinio_find,
sc->sc_dev, "awinio", &aio);
if (cf == NULL) {
if (loc->loc_flags & AWINIO_REQUIRED)
panic("%s: failed to find %s!", __func__,
loc->loc_name);
continue;
}
config_attach(sc->sc_dev, cf, &aio, awinio_print);
}
}
__FBSDID("$FreeBSD$");
#include <sys/types.h>
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/libkern.h>
long __stack_chk_guard[8] = {};
void __stack_chk_fail(void);
void
__stack_chk_fail(void)
{
panic("stack overflow detected; backtrace may be corrupted");
}
#define __arraycount(__x) (sizeof(__x) / sizeof(__x[0]))
static void
__stack_chk_init(void *dummy __unused)
{
size_t i;
long guard[__arraycount(__stack_chk_guard)];
arc4rand(guard, sizeof(guard), 0);
for (i = 0; i < __arraycount(guard); i++)
__stack_chk_guard[i] = guard[i];
}
SYSINIT(stack_chk, SI_SUB_RANDOM, SI_ORDER_ANY, __stack_chk_init, NULL);
void
ums_attach(device_t parent, device_t self, void *aux)
{
struct ums_softc *sc = device_private(self);
struct uhidev_attach_arg *uha = aux;
struct wsmousedev_attach_args a;
int size;
void *desc;
uint32_t flags, quirks;
int i, hl;
struct hid_location *zloc;
bool isdigitizer;
aprint_naive("\n");
sc->sc_hdev.sc_dev = self;
sc->sc_hdev.sc_intr = ums_intr;
sc->sc_hdev.sc_parent = uha->parent;
sc->sc_hdev.sc_report_id = uha->reportid;
quirks = usbd_get_quirks(uha->parent->sc_udev)->uq_flags;
if (quirks & UQ_MS_REVZ)
sc->flags |= UMS_REVZ;
if (quirks & UQ_SPUR_BUT_UP)
sc->flags |= UMS_SPUR_BUT_UP;
uhidev_get_report_desc(uha->parent, &desc, &size);
isdigitizer = hid_is_collection(desc, size, uha->reportid,
HID_USAGE2(HUP_DIGITIZERS, 0x0002));
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
if (!hid_locate(desc, size, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X),
uha->reportid, hid_input, &sc->sc_loc_x, &flags)) {
aprint_error("\n%s: mouse has no X report\n",
device_xname(sc->sc_hdev.sc_dev));
return;
}
switch (flags & MOUSE_FLAGS_MASK) {
case 0:
sc->flags |= UMS_ABS;
break;
case HIO_RELATIVE:
break;
default:
aprint_error("\n%s: X report 0x%04x not supported\n",
device_xname(sc->sc_hdev.sc_dev), flags);
return;
}
if (!hid_locate(desc, size, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y),
uha->reportid, hid_input, &sc->sc_loc_y, &flags)) {
aprint_error("\n%s: mouse has no Y report\n",
device_xname(sc->sc_hdev.sc_dev));
return;
}
switch (flags & MOUSE_FLAGS_MASK) {
case 0:
sc->flags |= UMS_ABS;
break;
case HIO_RELATIVE:
break;
default:
aprint_error("\n%s: Y report 0x%04x not supported\n",
device_xname(sc->sc_hdev.sc_dev), flags);
return;
}
/* Try the wheel first as the Z activator since it's tradition. */
hl = hid_locate(desc,
size,
HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_WHEEL),
uha->reportid,
hid_input,
&sc->sc_loc_z,
&flags);
zloc = &sc->sc_loc_z;
if (hl) {
if ((flags & MOUSE_FLAGS_MASK) != HIO_RELATIVE) {
aprint_verbose("\n%s: Wheel report 0x%04x not "
"supported\n", device_xname(sc->sc_hdev.sc_dev),
flags);
sc->sc_loc_z.size = 0; /* Bad Z coord, ignore it */
} else {
sc->flags |= UMS_Z;
/* Wheels need the Z axis reversed. */
sc->flags ^= UMS_REVZ;
/* Put Z on the W coordinate */
zloc = &sc->sc_loc_w;
}
}
hl = hid_locate(desc,
size,
HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Z),
uha->reportid,
hid_input,
zloc,
&flags);
/*
* The horizontal component of the scrollball can also be given by
* Application Control Pan in the Consumer page, so if we didnt see
* any Z then check that.
*/
if (!hl) {
hl = hid_locate(desc,
size,
HID_USAGE2(HUP_CONSUMER, HUC_AC_PAN),
uha->reportid,
hid_input,
zloc,
&flags);
}
if (hl) {
if ((flags & MOUSE_FLAGS_MASK) != HIO_RELATIVE) {
aprint_verbose("\n%s: Z report 0x%04x not supported\n",
device_xname(sc->sc_hdev.sc_dev), flags);
zloc->size = 0; /* Bad Z coord, ignore it */
} else {
if (sc->flags & UMS_Z)
sc->flags |= UMS_W;
else
sc->flags |= UMS_Z;
}
}
if (uha->uiaa->uiaa_vendor == USB_VENDOR_MICROSOFT) {
int fixpos;
/*
* The Microsoft Wireless Laser Mouse 6000 v2.0 and the
* Microsoft Comfort Mouse 2.0 report a bad position for
* the wheel and wheel tilt controls -- should be in bytes
* 3 & 4 of the report. Fix this if necessary.
*/
switch (uha->uiaa->uiaa_product) {
case USB_PRODUCT_MICROSOFT_24GHZ_XCVR10:
case USB_PRODUCT_MICROSOFT_24GHZ_XCVR20:
fixpos = 24;
break;
case USB_PRODUCT_MICROSOFT_CM6000:
fixpos = 40;
break;
default:
fixpos = 0;
break;
}
if (fixpos) {
if ((sc->flags & UMS_Z) && sc->sc_loc_z.pos == 0)
sc->sc_loc_z.pos = fixpos;
if ((sc->flags & UMS_W) && sc->sc_loc_w.pos == 0)
sc->sc_loc_w.pos = sc->sc_loc_z.pos + 8;
}
}
/* figure out the number of buttons */
for (i = 1; i <= MAX_BUTTONS; i++)
if (!hid_locate(desc, size, HID_USAGE2(HUP_BUTTON, i),
uha->reportid, hid_input, &sc->sc_loc_btn[i - 1], 0))
break;
if (isdigitizer) {
for (size_t j = 0; j < __arraycount(digbut); j++) {
if (hid_locate(desc, size, HID_USAGE2(HUP_DIGITIZERS,
digbut[j].feature), uha->reportid, hid_input,
&sc->sc_loc_btn[i - 1], 0)) {
if (i <= MAX_BUTTONS) {
i++;
sc->flags |= digbut[j].flag;
} else
aprint_error_dev(self,
"ran out of buttons\n");
}
}
}
sc->nbuttons = i - 1;
aprint_normal(": %d button%s%s%s%s%s%s%s%s%s\n",
sc->nbuttons, sc->nbuttons == 1 ? "" : "s",
sc->flags & UMS_W ? ", W" : "",
sc->flags & UMS_Z ? " and Z dir" : "",
sc->flags & UMS_W ? "s" : "",
isdigitizer ? " digitizer" : "",
sc->flags & UMS_TIP_SWITCH ? ", tip" : "",
sc->flags & UMS_SEC_TIP_SWITCH ? ", sec tip" : "",
sc->flags & UMS_BARREL_SWITCH ? ", barrel" : "",
sc->flags & UMS_ERASER ? ", eraser" : "");
#ifdef UMS_DEBUG
DPRINTF(("ums_attach: sc=%p\n", sc));
DPRINTF(("ums_attach: X\t%d/%d\n",
sc->sc_loc_x.pos, sc->sc_loc_x.size));
DPRINTF(("ums_attach: Y\t%d/%d\n",
sc->sc_loc_y.pos, sc->sc_loc_y.size));
if (sc->flags & UMS_Z)
DPRINTF(("ums_attach: Z\t%d/%d\n",
sc->sc_loc_z.pos, sc->sc_loc_z.size));
if (sc->flags & UMS_W)
DPRINTF(("ums_attach: W\t%d/%d\n",
sc->sc_loc_w.pos, sc->sc_loc_w.size));
for (i = 1; i <= sc->nbuttons; i++) {
DPRINTF(("ums_attach: B%d\t%d/%d\n",
i, sc->sc_loc_btn[i-1].pos,sc->sc_loc_btn[i-1].size));
}
#endif
a.accessops = &ums_accessops;
a.accesscookie = sc;
sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint);
return;
}
*/
static ssize_t
mib_vm_loadavg(struct mib_call * call __unused,
struct mib_node * node __unused, struct mib_oldp * oldp,
struct mib_newp * newp __unused)
{
struct loadavg loadavg;
struct loadinfo loadinfo;
unsigned long proc_load;
u32_t ticks_per_slot, ticks;
unsigned int p;
int unfilled_ticks;
int h, slots, latest, slot;
int minutes[3] = { 1, 5, 15 };
assert(__arraycount(loadavg.ldavg) == __arraycount(minutes));
if (sys_getloadinfo(&loadinfo) != OK)
return EINVAL;
memset(&loadavg, 0, sizeof(loadavg));
/*
* The following code is inherited from the old MINIX libc.
*/
/* How many ticks are missing from the newest-filled slot? */
ticks_per_slot = _LOAD_UNIT_SECS * sys_hz();
unfilled_ticks =
ticks_per_slot - (loadinfo.last_clock % ticks_per_slot);
static void
printaddrinfo(struct addrinfo *addrinfo)
{
struct addrinfo *ai;
char buf[1024];
int n;
struct protoent *protoent;
for (ai = addrinfo; ai != NULL; ai = ai->ai_next) {
/* Print the socket type. */
if ((ai->ai_socktype >= 0) &&
((size_t)ai->ai_socktype < __arraycount(socket_types)) &&
(socket_types[ai->ai_socktype] != NULL))
n = printf("%s", socket_types[ai->ai_socktype]);
else
n = printf("%d", ai->ai_socktype);
if (n < 0)
err(1, "printf");
/* Print the address family. */
if ((ai->ai_family >= 0) &&
((size_t)ai->ai_family < __arraycount(address_families)) &&
(address_families[ai->ai_family] != NULL))
n = printf(" %s", address_families[ai->ai_family]);
else
n = printf(" %d", ai->ai_family);
if (n < 0)
err(1, "printf");
/* Print the protocol number. */
protoent = getprotobynumber(ai->ai_protocol);
if (protoent == NULL)
n = printf(" %d", ai->ai_protocol);
else
n = printf(" %s", protoent->p_name);
if (n < 0)
err(1, "printf");
/* Format the sockaddr. */
switch (ai->ai_family) {
case AF_INET:
case AF_INET6:
n = sockaddr_snprintf(buf, sizeof(buf), " %a %p",
ai->ai_addr);
break;
default:
n = sockaddr_snprintf(buf, sizeof(buf),
"%a %p %I %F %R %S", ai->ai_addr);
}
/*
* Check for sockaddr_snprintf failure.
*
* XXX sockaddr_snprintf's error reporting is botched
* -- man page says it sets errno, but if getnameinfo
* fails, errno is not where it reports the error...
*/
if (n < 0) {
warnx("sockaddr_snprintf failed");
continue;
}
if (sizeof(buf) <= (size_t)n)
warnx("truncated sockaddr_snprintf output");
/* Print the formatted sockaddr. */
if (printf("%s\n", buf) < 0)
err(1, "printf");
}
}
};
struct pinteger parse_snpaoffset = PINTEGER_INITIALIZER1(&snpaoffset,
"snpaoffset", INT_MIN, INT_MAX, 10, NULL, "snpaoffset",
&command_root.pb_parser);
struct pinteger parse_nsellength = PINTEGER_INITIALIZER1(&nsellength,
"nsellength", 0, UINT8_MAX, 10, setnsellength, "nsellength",
&command_root.pb_parser);
static const struct kwinst isokw[] = {
{.k_word = "nsellength", .k_nextparser = &parse_nsellength.pi_parser}
, {.k_word = "snpaoffset", .k_nextparser = &parse_snpaoffset.pi_parser}
};
struct pkw iso = PKW_INITIALIZER(&iso, "ISO", NULL, NULL,
isokw, __arraycount(isokw), NULL);
static cmdloop_branch_t branch;
static void
fixnsel(struct sockaddr_iso *siso, uint8_t nsellength)
{
siso->siso_tlen = nsellength;
}
/* fixup mask */
static int
iso_pre_aifaddr(prop_dictionary_t env, const struct afparam *param)
{
struct sockaddr_iso *siso;
static void
test2(const char *title, bool dense)
{
struct radix_tree s;
struct radix_tree *t = &s;
struct testnode *n;
unsigned int i;
unsigned int nnodes = 100000;
unsigned int removed;
radix_tree_tagid_t tag;
unsigned int ntagged[RADIX_TREE_TAG_ID_MAX];
struct testnode *nodes;
struct timeval stv;
struct timeval etv;
nodes = malloc(nnodes * sizeof(*nodes));
for (tag = 0; tag < RADIX_TREE_TAG_ID_MAX; tag++) {
ntagged[tag] = 0;
}
radix_tree_init_tree(t);
for (i = 0; i < nnodes; i++) {
n = &nodes[i];
n->idx = random();
if (sizeof(long) == 4) {
n->idx <<= 32;
n->idx |= (uint32_t)random();
}
if (dense) {
n->idx %= nnodes * 2;
}
while (radix_tree_lookup_node(t, n->idx) != NULL) {
n->idx++;
}
radix_tree_insert_node(t, n->idx, n);
for (tag = 0; tag < RADIX_TREE_TAG_ID_MAX; tag++) {
n->tagged[tag] = test2_should_tag(i, tag);
if (n->tagged[tag]) {
radix_tree_set_tag(t, n->idx, tag);
ntagged[tag]++;
}
assert(n->tagged[tag] ==
radix_tree_get_tag(t, n->idx, tag));
}
}
gettimeofday(&stv, NULL);
for (i = 0; i < nnodes; i++) {
n = &nodes[i];
assert(radix_tree_lookup_node(t, n->idx) == n);
}
gettimeofday(&etv, NULL);
printops(title, "lookup", 0, nnodes, &stv, &etv);
for (tag = 0; tag < RADIX_TREE_TAG_ID_MAX; tag++) {
unsigned int count = 0;
gettimeofday(&stv, NULL);
for (i = 0; i < nnodes; i++) {
bool tagged;
n = &nodes[i];
tagged = radix_tree_get_tag(t, n->idx, tag);
assert(n->tagged[tag] == tagged);
if (tagged) {
count++;
}
}
gettimeofday(&etv, NULL);
assert(ntagged[tag] == count);
printops(title, "get_tag", tag, nnodes, &stv, &etv);
}
gettimeofday(&stv, NULL);
for (i = 0; i < nnodes; i++) {
n = &nodes[i];
radix_tree_remove_node(t, n->idx);
}
gettimeofday(&etv, NULL);
printops(title, "remove", 0, nnodes, &stv, &etv);
gettimeofday(&stv, NULL);
for (i = 0; i < nnodes; i++) {
n = &nodes[i];
radix_tree_insert_node(t, n->idx, n);
}
gettimeofday(&etv, NULL);
printops(title, "insert", 0, nnodes, &stv, &etv);
for (tag = 0; tag < RADIX_TREE_TAG_ID_MAX; tag++) {
ntagged[tag] = 0;
gettimeofday(&stv, NULL);
for (i = 0; i < nnodes; i++) {
n = &nodes[i];
if (n->tagged[tag]) {
radix_tree_set_tag(t, n->idx, tag);
ntagged[tag]++;
}
}
gettimeofday(&etv, NULL);
printops(title, "set_tag", tag, ntagged[tag], &stv, &etv);
}
gettimeofday(&stv, NULL);
{
struct testnode *results[TEST2_GANG_LOOKUP_NODES];
uint64_t nextidx;
unsigned int nfound;
unsigned int total;
nextidx = 0;
total = 0;
while ((nfound = radix_tree_gang_lookup_node(t, nextidx,
(void *)results, __arraycount(results))) > 0) {
nextidx = results[nfound - 1]->idx + 1;
total += nfound;
if (nextidx == 0) {
break;
}
}
assert(total == nnodes);
}
gettimeofday(&etv, NULL);
printops(title, "ganglookup", 0, nnodes, &stv, &etv);
gettimeofday(&stv, NULL);
{
struct testnode *results[TEST2_GANG_LOOKUP_NODES];
uint64_t nextidx;
unsigned int nfound;
unsigned int total;
nextidx = UINT64_MAX;
total = 0;
while ((nfound = radix_tree_gang_lookup_node_reverse(t, nextidx,
(void *)results, __arraycount(results))) > 0) {
nextidx = results[nfound - 1]->idx - 1;
total += nfound;
if (nextidx == UINT64_MAX) {
break;
}
}
assert(total == nnodes);
}
gettimeofday(&etv, NULL);
printops(title, "ganglookup_reverse", 0, nnodes, &stv, &etv);
for (tag = 0; tag < RADIX_TREE_TAG_ID_MAX; tag++) {
gettimeofday(&stv, NULL);
{
struct testnode *results[TEST2_GANG_LOOKUP_NODES];
uint64_t nextidx;
unsigned int nfound;
unsigned int total;
nextidx = 0;
total = 0;
while ((nfound = radix_tree_gang_lookup_tagged_node(t,
nextidx, (void *)results, __arraycount(results),
tag)) > 0) {
nextidx = results[nfound - 1]->idx + 1;
total += nfound;
}
assert(total == ntagged[tag]);
}
gettimeofday(&etv, NULL);
printops(title, "ganglookup_tag", tag, ntagged[tag], &stv,
&etv);
}
for (tag = 0; tag < RADIX_TREE_TAG_ID_MAX; tag++) {
gettimeofday(&stv, NULL);
{
struct testnode *results[TEST2_GANG_LOOKUP_NODES];
uint64_t nextidx;
unsigned int nfound;
unsigned int total;
nextidx = UINT64_MAX;
total = 0;
while ((nfound =
radix_tree_gang_lookup_tagged_node_reverse(t,
nextidx, (void *)results, __arraycount(results),
tag)) > 0) {
nextidx = results[nfound - 1]->idx - 1;
total += nfound;
if (nextidx == UINT64_MAX) {
break;
}
}
assert(total == ntagged[tag]);
}
gettimeofday(&etv, NULL);
printops(title, "ganglookup_tag_reverse", tag, ntagged[tag],
&stv, &etv);
}
removed = 0;
for (tag = 0; tag < RADIX_TREE_TAG_ID_MAX; tag++) {
unsigned int total;
total = 0;
gettimeofday(&stv, NULL);
{
struct testnode *results[TEST2_GANG_LOOKUP_NODES];
uint64_t nextidx;
unsigned int nfound;
nextidx = 0;
while ((nfound = radix_tree_gang_lookup_tagged_node(t,
nextidx, (void *)results, __arraycount(results),
tag)) > 0) {
for (i = 0; i < nfound; i++) {
radix_tree_remove_node(t,
results[i]->idx);
}
nextidx = results[nfound - 1]->idx + 1;
total += nfound;
if (nextidx == 0) {
break;
}
}
assert(tag != 0 || total == ntagged[tag]);
assert(total <= ntagged[tag]);
}
gettimeofday(&etv, NULL);
printops(title, "ganglookup_tag+remove", tag, total, &stv,
&etv);
removed += total;
}
gettimeofday(&stv, NULL);
{
struct testnode *results[TEST2_GANG_LOOKUP_NODES];
uint64_t nextidx;
unsigned int nfound;
unsigned int total;
nextidx = 0;
total = 0;
while ((nfound = radix_tree_gang_lookup_node(t, nextidx,
(void *)results, __arraycount(results))) > 0) {
for (i = 0; i < nfound; i++) {
assert(results[i] == radix_tree_remove_node(t,
results[i]->idx));
}
nextidx = results[nfound - 1]->idx + 1;
total += nfound;
if (nextidx == 0) {
break;
}
}
assert(total == nnodes - removed);
}
gettimeofday(&etv, NULL);
printops(title, "ganglookup+remove", 0, nnodes - removed, &stv, &etv);
assert(radix_tree_empty_tree_p(t));
assert(radix_tree_empty_tagged_tree_p(t, 0));
assert(radix_tree_empty_tagged_tree_p(t, 1));
radix_tree_fini_tree(t);
free(nodes);
}
ATF_TC_BODY(randlock, tc)
{
int i, j, fd;
int pipe_fd[2];
pid_t *pid;
int status;
char pipe_in, pipe_out;
const char pipe_errmsg[] = "child: pipe write failed\n";
(void)unlink(lockfile);
fd = open (lockfile, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0666);
ATF_REQUIRE_MSG(fd >= 0, "open(%s): %s", lockfile, strerror(errno));
ATF_REQUIRE_MSG(ftruncate(fd, filesize) >= 0,
"ftruncate(%s): %s", lockfile, strerror(errno));
ATF_REQUIRE_MSG(pipe(pipe_fd) == 0, "pipe: %s", strerror(errno));
fsync(fd);
close(fd);
pid = malloc(nprocs * sizeof(pid_t));
for (i = 0; i < nprocs; i++) {
pipe_out = (char)('A' + i);
pid[i] = fork();
switch (pid[i]) {
case 0:
if (write(pipe_fd[1], &pipe_out, 1) != 1)
write(STDERR_FILENO, pipe_errmsg,
__arraycount(pipe_errmsg) - 1);
else
trylocks(i);
_exit(0);
break;
case -1:
atf_tc_fail("fork %d failed", i);
break;
default:
ATF_REQUIRE_MSG(read(pipe_fd[0], &pipe_in, 1) == 1,
"parent: read_pipe(%i): %s", i, strerror(errno));
ATF_REQUIRE_MSG(pipe_in == pipe_out,
"parent: pipe does not match");
break;
}
}
for (j = 0; j < npasses; j++) {
printf("parent: run %i\n", j+1);
for (i = 0; i < nprocs; i++) {
ATF_REQUIRE_MSG(ptrace(PT_ATTACH, pid[i], 0, 0) >= 0,
"ptrace attach %d", pid[i]);
ATF_REQUIRE_MSG(waitpid(pid[i], &status, WUNTRACED) >= 0,
"waitpid(ptrace)");
usleep(sleeptime / 3);
ATF_REQUIRE_MSG(ptrace(PT_DETACH, pid[i], (caddr_t)1,
0) >= 0,
"ptrace detach %d", pid[i]);
usleep(sleeptime / 3);
}
}
for (i = 0; i < nprocs; i++) {
printf("reap %d: ", i);
fflush(stdout);
kill(pid[i], SIGINT);
waitpid(pid[i], &status, 0);
printf(" status %d\n", status);
}
atf_tc_pass();
}
char *
captoinfo(char *cap)
{
char *info, *ip, *token, *val, *p, tok[3];
const char *name;
size_t len, lp, nl, vl, rl;
int defs[__arraycount(def_infos)], fv;
_DIAGASSERT(cap != NULL);
len = strlen(cap) * 2;
len += __arraycount(def_infos) * (5 + 4 + 3); /* reserve for defs */
info = ip = malloc(len);
if (info == NULL)
return NULL;
memset(defs, 0, sizeof(defs));
lp = 0;
tok[2] = '\0';
for (token = _ti_get_token(&cap, ':');
token != NULL;
token = _ti_get_token(&cap, ':'))
{
if (token[0] == '\0')
continue;
name = token;
val = p = NULL;
fv = nl = 0;
if (token[1] != '\0') {
tok[0] = token[0];
tok[1] = token[1];
nl = 1;
if (token[2] == '\0') {
name = flagname(tok);
val = NULL;
} else if (token[2] == '#') {
name = numname(tok);
val = token + 2;
} else if (token[2] == '=') {
name = strname(tok);
val = strval(token + 2);
fv = 1;
} else
nl = 0;
}
/* If not matched we may need to convert padding still. */
if (nl == 0) {
p = strchr(name, '=');
if (p != NULL) {
val = strval(p);
*p = '\0';
fv = 1;
}
}
/* See if this sets a default. */
for (nl = 0; nl < __arraycount(def_infos); nl++) {
if (strcmp(name, def_infos[nl].name) == 0) {
defs[nl] = 1;
break;
}
}
nl = strlen(name);
if (val == NULL)
vl = 0;
else
vl = strlen(val);
rl = nl + vl + 3; /* , \0 */
if (lp + rl > len) {
if (rl < 256)
len += 256;
else
len += rl;
p = realloc(info, len);
if (p == NULL) {
if (fv == 1)
free(val);
return NULL;
}
info = p;
}
if (ip != info) {
*ip++ = ',';
*ip++ = ' ';
}
strcpy(ip, name);
ip += nl;
if (val != NULL) {
strcpy(ip, val);
ip += vl;
if (fv == 1)
free(val);
}
}
/* Add any defaults not set above. */
for (nl = 0; nl < __arraycount(def_infos); nl++) {
if (defs[nl] == 0) {
*ip++ = ',';
*ip++ = ' ';
strcpy(ip, def_infos[nl].name);
ip += strlen(def_infos[nl].name);
*ip++ = '=';
strcpy(ip, def_infos[nl].cap);
ip += strlen(def_infos[nl].cap);
}
}
*ip = '\0';
return info;
}