static void
print_caddr_t(const void *data)
{
    printf("%s", (const char *)data);
}

C_SYSINIT(trademark, SI_SUB_COPYRIGHT, SI_ORDER_SECOND, print_caddr_t,
    trademark);

/*
 * The two following SYSINIT's are proc0 specific glue code.  I am not
 * convinced that they can not be safely combined, but their order of
 * operation has been maintained as the same as the original init_main.c
 * for right now.
 */
/* ARGSUSED*/
static void
proc0_init(void *dummy __unused)
{
    struct proc *p;
    struct thread *td;
    struct ucred *newcred;
    struct uidinfo tmpuinfo;
    struct loginclass tmplc = {
        .lc_name = "",
    };
    vm_paddr_t pageablemem;
    int i;

GIANT_REQUIRED;
p = &proc0;
td = &thread0;

/*
 * Initialize magic number and osrel.
 */
p->p_magic = P_MAGIC;
p->p_osrel = osreldate;

/*
 * Initialize thread and process structures.
 */
procinit(); /* set up proc zone */
threadinit();   /* set up UMA zones */

/*
 * Initialise scheduler resources.
 * Add scheduler specific parts to proc, thread as needed.
 */
schedinit();    /* scheduler gets its house in order */

/*
 * Create process 0.
 */
LIST_INSERT_HEAD(&allproc, p, p_list);
LIST_INSERT_HEAD(PIDHASH(0), p, p_hash);
mtx_init(&pgrp0.pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
sx_init(&pgrp0.pg_killsx, "killpg racer");
p->p_pgrp = &pgrp0;
LIST_INSERT_HEAD(PGRPHASH(0), &pgrp0, pg_hash);
LIST_INIT(&pgrp0.pg_members);
LIST_INSERT_HEAD(&pgrp0.pg_members, p, p_pglist);

pgrp0.pg_session = &session0;
mtx_init(&session0.s_mtx, "session", NULL, MTX_DEF);
refcount_init(&session0.s_count, 1);
session0.s_leader = p;

// ...
td->td_cpuset = cpuset_thread0();
// ...
strncpy(p->p_comm, "kernel", sizeof (p->p_comm));
strncpy(td->td_name, "kernel", sizeof (td->td_name));
// ...

/* Create credentials. */
newcred = crget();
newcred->cr_ngroups = 1;    /* group 0 */
// ...
/* Create sigacts. */
p->p_sigacts = sigacts_alloc();

/* Initialize signal state for process 0. */
siginit(&proc0);

/* Create the file descriptor table. */
p->p_pd = pdinit(NULL, false);
p->p_fd = fdinit();
p->p_fdtol = NULL;

/* Create the limits structures. */
p->p_limit = lim_alloc();
// ...

/* Initialize resource accounting structures. */
racct_create(&p->p_racct);

p->p_stats = pstats_alloc();

/* Allocate a prototype map so we have something to fork. */
p->p_vmspace = &vmspace0;
refcount_init(&vmspace0.vm_refcnt, 1);
pmap_pinit0(vmspace_pmap(&vmspace0));

/*
 * proc0 is not expected to enter usermode, so there is no special
 * handling for sv_minuser here, like is done for exec_new_vmspace().
 */
vm_map_init(&vmspace0.vm_map, vmspace_pmap(&vmspace0),
    p->p_sysent->sv_minuser, p->p_sysent->sv_maxuser);

    /*
     * Call the init and ctor for the new thread and proc.  We wait
     * to do this until all other structures are fairly sane.
     */
    EVENTHANDLER_DIRECT_INVOKE(process_init, p);
    EVENTHANDLER_DIRECT_INVOKE(thread_init, td);
#ifdef KDTRACE_HOOKS
    kdtrace_proc_ctor(p);
    kdtrace_thread_ctor(td);
#endif
    EVENTHANDLER_DIRECT_INVOKE(process_ctor, p);
    EVENTHANDLER_DIRECT_INVOKE(thread_ctor, td);

    /*
     * Charge root for one process.
     */
    (void)chgproccnt(p->p_ucred->cr_ruidinfo, 1, 0);
    PROC_LOCK(p);
    racct_add_force(p, RACCT_NPROC, 1);
    PROC_UNLOCK(p);
}
SYSINIT(p0init, SI_SUB_INTRINSIC, SI_ORDER_FIRST, proc0_init, NULL);

/*
 * Start the initial user process; try exec'ing each pathname in init_path.
 * The program is invoked with one argument containing the boot flags.
 */
static void
start_init(void *dummy)
{
    vfs_mountroot();

    /* Wipe GELI passphrase from the environment. */
    kern_unsetenv("kern.geom.eli.passphrase");

    while ((path = strsep(&tmp_init_path, ":")) != NULL) {
        error = exec_alloc_args(&args);
        error = exec_args_add_fname(&args, path, UIO_SYSSPACE);
        error = exec_args_add_arg(&args, path, UIO_SYSSPACE);
        /*
         * Now try to exec the program.  If can't for any reason
         * other than it doesn't exist, complain.
         *
         * Otherwise, return via fork_trampoline() all the way
         * to user mode as init!
         */
        error = kern_execve(td, &args, NULL, oldvmspace);
    }
    panic("no init");
}

/*
 * Like kproc_create(), but runs in its own address space.  We do this
 * early to reserve pid 1.  Note special case - do not make it
 * runnable yet, init execution is started when userspace can be served.
 */
static void
create_init(const void *udata __unused)
{
    fr.fr_procp = &initproc;
    error = fork1(&thread0, &fr);
    cpu_fork_kthread_handler(FIRST_THREAD_IN_PROC(initproc),
        start_init, NULL);
}
SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL);

/*
 * Make it runnable now.
 */
static void
kick_init(const void *udata __unused)
{
    td = FIRST_THREAD_IN_PROC(initproc);
    TD_SET_CAN_RUN(td);
    sched_add(td, SRQ_BORING);
}
SYSINIT(kickinit, SI_SUB_KTHREAD_INIT, SI_ORDER_MIDDLE, kick_init, NULL);