For more detail, you can then use the ::print D command to print a list of the kernel memory segments structures.

>

kas ::walk seg ::print "struct seg"

{
    s_base = scb
    s_size = 0x8f2000
    s_szc = 0
    s_flags = 0
    s_as = kas
    s_tree = {
        avl_child = [ 0, 0 ]
        avl_pcb = 0x1835899
    }
    s_ops = segkmem_ops
    s_data = 0
}
{
    s_base = 0x18f2000
    s_size = 0x40e000
    s_szc = 0
    s_flags = 0
    s_as = kas
    s_tree = {
        avl_child = [ ktextseg+0x20, kvseg32+0x20 ]
        avl_pcb = 0x1843431
    }
    s_ops = segkmem_ops
    s_data = 0
}
...

The next figures illustrate Solaris 10 address space, as follows :

• Figure A.2 Solaris 10 sun4u 64-Bit Kernel Address Space

  Figure A.2. Solaris 10 sun4u 64-Bit Kernel Address Space

  

• Figure A.3 Solaris 10 amd64 64-Bit Kernel Address Space

  Figure A.3. Solaris 10 amd64 64-Bit Kernel Address Space

  

• Figure A.4 Solaris 10 x86 32-Bit Kernel Address Space

  Figure A.4. Solaris 10 x86 32-Bit Kernel Address Space

  

B.1.2. Writing the Syscall Handler

Next, we have to actually add the function that will get called when we invoke the system call. What we should really do is add a new file schrock.c to usr/src/uts/common/syscall.c , but instead, we'll just use code from getpid.c.

#include <sys/cmn_err.h>

int
schrock(void *arg)
{
        char    buf[1024];
        size_t  len;

        if (copyinstr(arg, buf, sizeof (buf), &len) != 0)
                return (set_errno(EFAULT));

        cmn_err(CE_WARN, "%s", buf);

        return (0);
}

Note that declaring a buffer of 1024 bytes on the stack is a very bad thing to do in the kernel. We have limited stack space, and a stack overflow will result in a panic. We also don't check that the length of the string was less than our scratch space. But this will suffice for illustrative purposes. The cmn_err() function is the simplest way to display messages from the kernel.

B.1.3. Adding an Entry to the Syscall Table

We need to place an entry in the system call table. This table lives in sysent.c , and makes heavy use of macros to simplify the source. Our system call takes a single argument and returns an integer, so we'll need to use the SYSENT_CI macro. We need to add a prototype for our syscall, and add an entry to the sysent and sysent32 tables.

int     rename();
void    rexit();
int     schrock();
int     semsys();
int     setgid();

/* ... */

        /* 54 */ SYSENT_CI("ioctl",             ioctl,           3),
        /* 55 */ SYSENT_CI("uadmin",            uadmin,          3),
        /* 56 */ SYSENT_CI("schrock",           schrock,         1),
        /* 57 */ IF_LP64(
                        SYSENT_2CI("utssys",    utssys64,        4),
                        SYSENT_2CI("utssys",    utssys32,        4)),

/* ... */

        /* 54 */ SYSENT_CI("ioctl",             ioctl,           3),
        /* 55 */ SYSENT_CI("uadmin",            uadmin,          3),
        /* 56 */ SYSENT_CI("schrock",           schrock,         1),
        /* 57 */ SYSENT_2CI("utssys",           utssys32,        4),

See usr/src/uts/common/os/sysent.c

B.1.4. Updating /etc/name_to_sysnum

At this point, we could write a program to invoke our system call, but the point here is to illustrate everything that needs to be done to integrate a system call, so we can't ignore the little things. One of these little things is /etc/name_to_sysnum , which provides a mapping between system call names and numbers, and is used by dtrace(1M) , truss (1) , and friends . Of course, there is one version for x86 and one for SPARC, so you will have to add the following lines to both the Intel and SPARC versions.

ioctl                    54
uadmin                   55
schrock                  56
utssys                   57
fdsync                   58

See /etc/name_to_sysnum

B.1.5. Updating TRuss(1)

Truss does fancy decoding of system call arguments. In order to do this, we need to maintain a table in truss that describes the type of each argument for every syscall. This table is found in systable.c. Since our syscall takes a single string, we add the following entry:

{"ioctl",       3, DEC, NOV, DEC, IOC, IOA},                     /*  54 */
{"uadmin",      3, DEC, NOV, DEC, DEC, DEC},                     /*  55 */
{"schrock",     1, DEC, NOV, STG},                               /*  56 */
{"utssys",      4, DEC, NOV, HEX, DEC, UTS, HEX},                /*  57 */
{"fdsync",      2, DEC, NOV, DEC, FFG},                          /*  58 */

See usr/src/cmd/truss/systable.c

Don't worry too much about the different constants. But be sure to read up on the truss source code if you're adding a complicated system call.

B.1.6. Updating proc_names.c

This is the file that gets missed the most often when adding a new syscall. Libproc uses the table in proc_names.c to translate between system call numbers and names. Why it doesn't make use of /etc/name_to_sysnum is anybody's guess, but for now you have to update the systable array in this file:

"ioctl",                 /* 54 */
"uadmin",                /* 55 */
"schrock",               /* 56 */
"utssys",                /* 57 */
"fdsync",                /* 58 */

See usr/src/lib/libproc/common/proc_names.c

B.1.7. Putting It All Together

Finally, everything is in place. We can test our system call with a simple program:

#include <sys/syscall.h>

int
main(int argc, char **argv)
{
        syscall(SYS_schrock, "OpenSolaris Rules!");
        return (0);
}

If we run this on our system, we'll see the following output on the console:

June 14 13:42:21 halcyon genunix: WARNING: OpenSolaris Rules!

Because we did all the extra work, we can actually observe the behavior using truss(1) , mdb(1) , or dtrace(1M) .