hstrace 0.0.5

Syscall tracing from command line and as a library
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
139
140

use super::prelude::*;
use serde::Serialize;

pub(crate) fn get_definitions(inp: &mut Definitions) {
    inp.add(
        Ident::Readlink,
        vec!["pathname", "buf", "bufsiz"],
        vec![AV::CString(In), AV::BufferFromReturn(Out), AV::SizeT(In)], // FIXME get buf size from exit
        AV::SSizeT(Out),
    );

    inp.add(
        Ident::Access,
        vec!["pathname", "mode"],
        vec![AV::CString(In), AV::AccessMode(In)],
        AV::Int(Out),
    );

    inp.add(
        Ident::Getcwd,
        vec!["buf", "size"],
        vec![AV::CString(Out), AV::Int(In)],
        AV::Int(Out),
    );

    inp.add(Ident::Close, vec!["fd"], vec![AV::Int(In)], AV::SSizeT(Out));

    inp.add(
        Ident::Brk,
        vec!["addr"],
        vec![AV::MemoryAddress(In)],
        AV::MemoryAddress(Out),
    );

    inp.add(
        Ident::Chdir,
        vec!["path"],
        vec![AV::CString(Out)],
        AV::Int(Out),
    );

    inp.add(
        Ident::Read,
        vec!["fd", "buf", "count"],
        vec![AV::Int(In), AV::BufferFromReturn(Out), AV::SizeT(In)],
        AV::SSizeT(Out),
    );

    inp.add(
        Ident::Write,
        vec!["fd", "buf", "count"],
        vec![AV::Int(In), AV::BufferFromArgPosition(In, 2), AV::SizeT(In)],
        AV::SSizeT(Out),
    );

    inp.add(
        Ident::Fork,
        vec![],
        vec![],       // FIXME TODO!
        AV::Int(Out), // FIXME <-- should be pid_t
    );

    inp.add(
        Ident::ExitGroup,
        vec!["status"],
        vec![AV::Int(In)],
        AV::Void(Out),
    );

    inp.add(
        Ident::Lseek,
        vec!["fd", "offset", "whence"],
        vec![AV::Int(In), AV::OffT(In), AV::Int(In)],
        AV::OffT(Out),
    );
}

/// Syscall: Read value of a symbolic link
#[derive(Debug, PartialEq, FromPtrace, Serialize)]
#[hstrace(hmz("{:?} symlink points to {:?}", self.src, self.dst))]
pub struct Readlink {
    /// Source file
    #[hstrace]
    pub src: String,

    /// Destination file
    #[hstrace]
    pub dst: Option<String>,
}

#[derive(Debug, PartialEq, FromPtrace, Serialize)]
#[hstrace(hmz("Check path {:?} permissions for mode {:?}", self.pathname, self.mode))]
pub struct Access {
    #[hstrace]
    pub pathname: String,

    #[hstrace]
    pub mode: AccessMode,
}

#[derive(Debug, PartialEq, FromPtrace, Serialize)]
#[hstrace(hmz("Resolved current path to {:?}", self.pathname))]
pub struct Getcwd {
    #[hstrace]
    pub pathname: Option<String>,
}

#[derive(Debug, PartialEq, FromPtrace, Serialize)]
#[hstrace(hmz("Closed file descriptor {:?}", self.fd))]
pub struct Close {
    /// File descriptor
    #[hstrace]
    pub fd: isize,
}

#[derive(Debug, PartialEq, FromPtrace, Serialize)]
#[hstrace(hmz("Request memory address expansion to {:?}", self.addr))]
pub struct Brk {
    /// Expand to memory address
    #[hstrace]
    pub addr: MemoryAddress,
}

#[derive(Debug, PartialEq, FromPtrace, Serialize)]
#[hstrace(hmz("Change working directory to {:?}", self.path))]
pub struct Chdir {
    /// Working directory
    #[hstrace]
    pub path: String,
}

bitflags! {
    #[derive(Serialize)]
    pub struct AccessMode: isize {
        const R_OK = 4;
        const W_OK = 2;
        const X_OK = 1;
        const F_OK = 0;
    }
}