Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
tracing: Add events/ root files to trace remotes
Just like for the kernel events directory, add 'enable', 'header_page'
and 'header_event' at the root of the trace remote events/ directory.
Link: https://patch.msgid.link/20260309162516.2623589-11-vdonnefort@google.com
Reviewed-by: Steven Rostedt (Google) <rostedt@goodmis.org>
Signed-off-by: Vincent Donnefort <vdonnefort@google.com>
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>
authored by
Vincent Donnefort
and committed by
Steven Rostedt (Google)
775cb093
07252915
+139
-2
+2
-1
kernel/trace/ring_buffer.c
+2
-1
kernel/trace/ring_buffer.c
···
640
640
trace_seq_printf(s, "\tfield: char data;\t"
641
641
"offset:%u;\tsize:%u;\tsigned:%u;\n",
642
642
(unsigned int)offsetof(typeof(field), data),
643
-
(unsigned int)buffer->subbuf_size,
643
+
(unsigned int)(buffer ? buffer->subbuf_size :
644
+
PAGE_SIZE - BUF_PAGE_HDR_SIZE),
644
645
(unsigned int)is_signed_type(char));
645
646
646
647
return !trace_seq_has_overflowed(s);
+137
-1
kernel/trace/trace_remote.c
+137
-1
kernel/trace/trace_remote.c
···
1125
1125
return 0;
1126
1126
}
1127
1127
1128
+
static ssize_t remote_events_dir_enable_write(struct file *filp, const char __user *ubuf,
1129
+
size_t count, loff_t *ppos)
1130
+
{
1131
+
struct trace_remote *remote = file_inode(filp)->i_private;
1132
+
int i, ret;
1133
+
u8 enable;
1134
+
1135
+
ret = kstrtou8_from_user(ubuf, count, 10, &enable);
1136
+
if (ret)
1137
+
return ret;
1138
+
1139
+
guard(mutex)(&remote->lock);
1140
+
1141
+
for (i = 0; i < remote->nr_events; i++) {
1142
+
struct remote_event *evt = &remote->events[i];
1143
+
1144
+
trace_remote_enable_event(remote, evt, enable);
1145
+
}
1146
+
1147
+
return count;
1148
+
}
1149
+
1150
+
static ssize_t remote_events_dir_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
1151
+
loff_t *ppos)
1152
+
{
1153
+
struct trace_remote *remote = file_inode(filp)->i_private;
1154
+
const char enabled_char[] = {'0', '1', 'X'};
1155
+
char enabled_str[] = " \n";
1156
+
int i, enabled = -1;
1157
+
1158
+
guard(mutex)(&remote->lock);
1159
+
1160
+
for (i = 0; i < remote->nr_events; i++) {
1161
+
struct remote_event *evt = &remote->events[i];
1162
+
1163
+
if (enabled == -1) {
1164
+
enabled = evt->enabled;
1165
+
} else if (enabled != evt->enabled) {
1166
+
enabled = 2;
1167
+
break;
1168
+
}
1169
+
}
1170
+
1171
+
enabled_str[0] = enabled_char[enabled == -1 ? 0 : enabled];
1172
+
1173
+
return simple_read_from_buffer(ubuf, cnt, ppos, enabled_str, 2);
1174
+
}
1175
+
1176
+
static const struct file_operations remote_events_dir_enable_fops = {
1177
+
.write = remote_events_dir_enable_write,
1178
+
.read = remote_events_dir_enable_read,
1179
+
};
1180
+
1181
+
static ssize_t
1182
+
remote_events_dir_header_page_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1183
+
{
1184
+
struct trace_seq *s;
1185
+
int ret;
1186
+
1187
+
s = kmalloc(sizeof(*s), GFP_KERNEL);
1188
+
if (!s)
1189
+
return -ENOMEM;
1190
+
1191
+
trace_seq_init(s);
1192
+
1193
+
ring_buffer_print_page_header(NULL, s);
1194
+
ret = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, trace_seq_used(s));
1195
+
kfree(s);
1196
+
1197
+
return ret;
1198
+
}
1199
+
1200
+
static const struct file_operations remote_events_dir_header_page_fops = {
1201
+
.read = remote_events_dir_header_page_read,
1202
+
};
1203
+
1204
+
static ssize_t
1205
+
remote_events_dir_header_event_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1206
+
{
1207
+
struct trace_seq *s;
1208
+
int ret;
1209
+
1210
+
s = kmalloc(sizeof(*s), GFP_KERNEL);
1211
+
if (!s)
1212
+
return -ENOMEM;
1213
+
1214
+
trace_seq_init(s);
1215
+
1216
+
ring_buffer_print_entry_header(s);
1217
+
ret = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, trace_seq_used(s));
1218
+
kfree(s);
1219
+
1220
+
return ret;
1221
+
}
1222
+
1223
+
static const struct file_operations remote_events_dir_header_event_fops = {
1224
+
.read = remote_events_dir_header_event_read,
1225
+
};
1226
+
1227
+
static int remote_events_dir_callback(const char *name, umode_t *mode, void **data,
1228
+
const struct file_operations **fops)
1229
+
{
1230
+
if (!strcmp(name, "enable")) {
1231
+
*mode = TRACEFS_MODE_WRITE;
1232
+
*fops = &remote_events_dir_enable_fops;
1233
+
return 1;
1234
+
}
1235
+
1236
+
if (!strcmp(name, "header_page")) {
1237
+
*mode = TRACEFS_MODE_READ;
1238
+
*fops = &remote_events_dir_header_page_fops;
1239
+
return 1;
1240
+
}
1241
+
1242
+
if (!strcmp(name, "header_event")) {
1243
+
*mode = TRACEFS_MODE_READ;
1244
+
*fops = &remote_events_dir_header_event_fops;
1245
+
return 1;
1246
+
}
1247
+
1248
+
return 0;
1249
+
}
1250
+
1128
1251
static int trace_remote_init_eventfs(const char *remote_name, struct trace_remote *remote,
1129
1252
struct remote_event *evt)
1130
1253
{
1131
1254
struct eventfs_inode *eventfs = remote->eventfs;
1255
+
static struct eventfs_entry dir_entries[] = {
1256
+
{
1257
+
.name = "enable",
1258
+
.callback = remote_events_dir_callback,
1259
+
}, {
1260
+
.name = "header_page",
1261
+
.callback = remote_events_dir_callback,
1262
+
}, {
1263
+
.name = "header_event",
1264
+
.callback = remote_events_dir_callback,
1265
+
}
1266
+
};
1132
1267
static struct eventfs_entry entries[] = {
1133
1268
{
1134
1269
.name = "enable",
···
1279
1144
bool eventfs_create = false;
1280
1145
1281
1146
if (!eventfs) {
1282
-
eventfs = eventfs_create_events_dir("events", remote->dentry, NULL, 0, NULL);
1147
+
eventfs = eventfs_create_events_dir("events", remote->dentry, dir_entries,
1148
+
ARRAY_SIZE(dir_entries), remote);
1283
1149
if (IS_ERR(eventfs))
1284
1150
return PTR_ERR(eventfs);
1285
1151