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
|
// Copyright 2019 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package control
import (
"fmt"
"gvisor.dev/gvisor/pkg/log"
"gvisor.dev/gvisor/pkg/sentry/strace"
"gvisor.dev/gvisor/pkg/tcpip/link/sniffer"
)
// LoggingArgs are the arguments to use for changing the logging
// level and strace list.
type LoggingArgs struct {
// SetLevel is a flag used to indicate that we should update
// the logging level. We should be able to change the strace
// list without affecting the logging level and vice versa.
SetLevel bool
// Level is the log level that will be set if SetLevel is true.
Level log.Level
// SetLogPackets indicates that we should update the log packets flag.
SetLogPackets bool
// LogPackets is the actual value to set for LogPackets.
// SetLogPackets must be enabled to indicate that we're changing
// the value.
LogPackets bool
// SetStrace is a flag used to indicate that strace related
// arguments were passed in.
SetStrace bool
// EnableStrace is a flag from the CLI that specifies whether to
// enable strace at all. If this flag is false then a completely
// pristine copy of the syscall table will be swapped in. This
// approach is used to remain consistent with an empty strace
// allowlist meaning trace all system calls.
EnableStrace bool
// Strace is the allowlist of syscalls to trace to log. If this
// and StraceEventAllowlist are empty trace all system calls.
StraceAllowlist []string
// SetEventStrace is a flag used to indicate that event strace
// related arguments were passed in.
SetEventStrace bool
// StraceEventAllowlist is the allowlist of syscalls to trace
// to event log.
StraceEventAllowlist []string
}
// Logging provides functions related to logging.
type Logging struct{}
// Change will change the log level and strace arguments. Although
// this functions signature requires an error it never actually
// returns an error. It's required by the URPC interface.
// Additionally, it may look odd that this is the only method
// attached to an empty struct but this is also part of how
// URPC dispatches.
func (l *Logging) Change(args *LoggingArgs, code *int) error {
if args.SetLevel {
// Logging uses an atomic for the level so this is thread safe.
log.SetLevel(args.Level)
}
if args.SetLogPackets {
if args.LogPackets {
sniffer.LogPackets.Store(1)
} else {
sniffer.LogPackets.Store(0)
}
log.Infof("LogPackets set to: %v", sniffer.LogPackets.Load())
}
if args.SetStrace {
if err := l.configureStrace(args); err != nil {
return fmt.Errorf("error configuring strace: %v", err)
}
}
if args.SetEventStrace {
if err := l.configureEventStrace(args); err != nil {
return fmt.Errorf("error configuring event strace: %v", err)
}
}
return nil
}
func (l *Logging) configureStrace(args *LoggingArgs) error {
if args.EnableStrace {
// Install the allowlist specified.
if len(args.StraceAllowlist) > 0 {
if err := strace.Enable(args.StraceAllowlist, strace.SinkTypeLog); err != nil {
return err
}
} else {
// For convenience, if strace is enabled but allowlist
// is empty, enable everything to log.
strace.EnableAll(strace.SinkTypeLog)
}
} else {
// Uninstall all strace functions.
strace.Disable(strace.SinkTypeLog)
}
return nil
}
func (l *Logging) configureEventStrace(args *LoggingArgs) error {
if len(args.StraceEventAllowlist) > 0 {
if err := strace.Enable(args.StraceEventAllowlist, strace.SinkTypeEvent); err != nil {
return err
}
} else {
strace.Disable(strace.SinkTypeEvent)
}
return nil
}
|
