r-linux 0.1.0

Capability-based Linux Runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#!/usr/bin/python3
"""Code Generator for x86

This script is used to generate some of the sources of this crate. It currently
generates the following data:

   * x86 (and x86_64) Syscall Numbers
     The system call numbers for x86 are kept in a simple table in the linux
     kernel sources. This table contains the system-call number, the ABI its
     included in, the system call name, and possibly the system call entry
     point.
     We fetch this table from `git.kernel.org`, parse it, and then generate the
     system call number definitions for the rust crate.
"""


import argparse
import sys
import urllib.request


def systbl_fetch(*, args):
    """Fetch Syscall Table

    Fetch the x86[_64] syscall-table from the official git repository.
    """

    host = "git.kernel.org"
    repo = "pub/scm/linux/kernel/git/torvalds/linux.git"
    path = "arch/x86/entry/syscalls"
    filename = "syscall_32.tbl" if args.arch == "x86" else "syscall_64.tbl"
    branch = "master"

    url = "".join([
        "https://",
        host,
        "/", repo,
        "/", "plain",
        "/", path,
        "/", filename,
        "?h=", branch,
    ])

    print("Fetching from:", url, file=sys.stderr)

    with urllib.request.urlopen(url) as req:
        systbl = req.read()

    return systbl


def systbl_parse(*, args, data):
    """Parse Syscall Table

    The x86 syscall table contains entries in the style of:
        0   common  read    sys_read
    The file can contain comments, and entries might lack the last
    column.
    """

    res = []
    abis = ["i386"] if args.arch == "x86" else ["common", "64"]

    lines = data.decode().splitlines()
    for line in lines:
        line = line.replace("\t", " ").strip()
        if not line or line.startswith("#"):
            continue

        fields = line.split()
        assert len(fields) >= 3

        if fields[1] in abis:
            res.append(fields)

    return sorted(res, key=lambda v: int(v[0]))


def systbl_emit(*, systbl):
    """Emit Rustified Syscall Table

    Emit rust code as expected by the crate, which contains the
    definitions of the system call numbers.
    """

    print("// This code is generated.")
    for entry in systbl:
        print(f"pub const {entry[2].upper()}: usize = {entry[0]};")


def systbl(args):
    print("Fetch System Table...", file=sys.stderr)
    data = systbl_fetch(args=args)
    print("Parse System Table...", file=sys.stderr)
    systbl = systbl_parse(args=args, data=data)
    print("Emit System Table...", file=sys.stderr)
    systbl_emit(systbl=systbl)


def parse_args(argv):
    parser = argparse.ArgumentParser(
        add_help=True,
        allow_abbrev=False,
        argument_default=None,
        description="Code Generator for x86",
        prog="generate.py",
    )

    parser.add_argument(
        "--arch",
        choices=["x86", "x86_64"],
        help="Which architecture to generate for",
        required=True,
        type=str,
    )

    parser.add_argument(
        "--generate",
        choices=["systbl"],
        help="What to generate",
        required=True,
        type=str,
    )

    return parser.parse_args(argv[1:])


def run(argv):
    args = parse_args(argv)

    if args.generate == "systbl":
        systbl(args)
    else:
        raise RuntimeError("Nothing to do")


if __name__ == "__main__":
    run(sys.argv)