1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 /* Copyright (C) 2020 Facebook */ 3 4 #include <errno.h> 5 #include <net/if.h> 6 #include <stdio.h> 7 #include <unistd.h> 8 9 #include <bpf/bpf.h> 10 11 #include "json_writer.h" 12 #include "main.h" 13 14 static const char * const link_type_name[] = { 15 [BPF_LINK_TYPE_UNSPEC] = "unspec", 16 [BPF_LINK_TYPE_RAW_TRACEPOINT] = "raw_tracepoint", 17 [BPF_LINK_TYPE_TRACING] = "tracing", 18 [BPF_LINK_TYPE_CGROUP] = "cgroup", 19 [BPF_LINK_TYPE_ITER] = "iter", 20 [BPF_LINK_TYPE_NETNS] = "netns", 21 }; 22 23 static int link_parse_fd(int *argc, char ***argv) 24 { 25 int fd; 26 27 if (is_prefix(**argv, "id")) { 28 unsigned int id; 29 char *endptr; 30 31 NEXT_ARGP(); 32 33 id = strtoul(**argv, &endptr, 0); 34 if (*endptr) { 35 p_err("can't parse %s as ID", **argv); 36 return -1; 37 } 38 NEXT_ARGP(); 39 40 fd = bpf_link_get_fd_by_id(id); 41 if (fd < 0) 42 p_err("failed to get link with ID %d: %s", id, strerror(errno)); 43 return fd; 44 } else if (is_prefix(**argv, "pinned")) { 45 char *path; 46 47 NEXT_ARGP(); 48 49 path = **argv; 50 NEXT_ARGP(); 51 52 return open_obj_pinned_any(path, BPF_OBJ_LINK); 53 } 54 55 p_err("expected 'id' or 'pinned', got: '%s'?", **argv); 56 return -1; 57 } 58 59 static void 60 show_link_header_json(struct bpf_link_info *info, json_writer_t *wtr) 61 { 62 jsonw_uint_field(wtr, "id", info->id); 63 if (info->type < ARRAY_SIZE(link_type_name)) 64 jsonw_string_field(wtr, "type", link_type_name[info->type]); 65 else 66 jsonw_uint_field(wtr, "type", info->type); 67 68 jsonw_uint_field(json_wtr, "prog_id", info->prog_id); 69 } 70 71 static void show_link_attach_type_json(__u32 attach_type, json_writer_t *wtr) 72 { 73 if (attach_type < ARRAY_SIZE(attach_type_name)) 74 jsonw_string_field(wtr, "attach_type", 75 attach_type_name[attach_type]); 76 else 77 jsonw_uint_field(wtr, "attach_type", attach_type); 78 } 79 80 static int get_prog_info(int prog_id, struct bpf_prog_info *info) 81 { 82 __u32 len = sizeof(*info); 83 int err, prog_fd; 84 85 prog_fd = bpf_prog_get_fd_by_id(prog_id); 86 if (prog_fd < 0) 87 return prog_fd; 88 89 memset(info, 0, sizeof(*info)); 90 err = bpf_obj_get_info_by_fd(prog_fd, info, &len); 91 if (err) 92 p_err("can't get prog info: %s", strerror(errno)); 93 close(prog_fd); 94 return err; 95 } 96 97 static int show_link_close_json(int fd, struct bpf_link_info *info) 98 { 99 struct bpf_prog_info prog_info; 100 int err; 101 102 jsonw_start_object(json_wtr); 103 104 show_link_header_json(info, json_wtr); 105 106 switch (info->type) { 107 case BPF_LINK_TYPE_RAW_TRACEPOINT: 108 jsonw_string_field(json_wtr, "tp_name", 109 u64_to_ptr(info->raw_tracepoint.tp_name)); 110 break; 111 case BPF_LINK_TYPE_TRACING: 112 err = get_prog_info(info->prog_id, &prog_info); 113 if (err) 114 return err; 115 116 if (prog_info.type < prog_type_name_size) 117 jsonw_string_field(json_wtr, "prog_type", 118 prog_type_name[prog_info.type]); 119 else 120 jsonw_uint_field(json_wtr, "prog_type", 121 prog_info.type); 122 123 show_link_attach_type_json(info->tracing.attach_type, 124 json_wtr); 125 break; 126 case BPF_LINK_TYPE_CGROUP: 127 jsonw_lluint_field(json_wtr, "cgroup_id", 128 info->cgroup.cgroup_id); 129 show_link_attach_type_json(info->cgroup.attach_type, json_wtr); 130 break; 131 case BPF_LINK_TYPE_NETNS: 132 jsonw_uint_field(json_wtr, "netns_ino", 133 info->netns.netns_ino); 134 show_link_attach_type_json(info->netns.attach_type, json_wtr); 135 break; 136 default: 137 break; 138 } 139 140 if (!hash_empty(link_table.table)) { 141 struct pinned_obj *obj; 142 143 jsonw_name(json_wtr, "pinned"); 144 jsonw_start_array(json_wtr); 145 hash_for_each_possible(link_table.table, obj, hash, info->id) { 146 if (obj->id == info->id) 147 jsonw_string(json_wtr, obj->path); 148 } 149 jsonw_end_array(json_wtr); 150 } 151 152 emit_obj_refs_json(&refs_table, info->id, json_wtr); 153 154 jsonw_end_object(json_wtr); 155 156 return 0; 157 } 158 159 static void show_link_header_plain(struct bpf_link_info *info) 160 { 161 printf("%u: ", info->id); 162 if (info->type < ARRAY_SIZE(link_type_name)) 163 printf("%s ", link_type_name[info->type]); 164 else 165 printf("type %u ", info->type); 166 167 printf("prog %u ", info->prog_id); 168 } 169 170 static void show_link_attach_type_plain(__u32 attach_type) 171 { 172 if (attach_type < ARRAY_SIZE(attach_type_name)) 173 printf("attach_type %s ", attach_type_name[attach_type]); 174 else 175 printf("attach_type %u ", attach_type); 176 } 177 178 static int show_link_close_plain(int fd, struct bpf_link_info *info) 179 { 180 struct bpf_prog_info prog_info; 181 int err; 182 183 show_link_header_plain(info); 184 185 switch (info->type) { 186 case BPF_LINK_TYPE_RAW_TRACEPOINT: 187 printf("\n\ttp '%s' ", 188 (const char *)u64_to_ptr(info->raw_tracepoint.tp_name)); 189 break; 190 case BPF_LINK_TYPE_TRACING: 191 err = get_prog_info(info->prog_id, &prog_info); 192 if (err) 193 return err; 194 195 if (prog_info.type < prog_type_name_size) 196 printf("\n\tprog_type %s ", 197 prog_type_name[prog_info.type]); 198 else 199 printf("\n\tprog_type %u ", prog_info.type); 200 201 show_link_attach_type_plain(info->tracing.attach_type); 202 break; 203 case BPF_LINK_TYPE_CGROUP: 204 printf("\n\tcgroup_id %zu ", (size_t)info->cgroup.cgroup_id); 205 show_link_attach_type_plain(info->cgroup.attach_type); 206 break; 207 case BPF_LINK_TYPE_NETNS: 208 printf("\n\tnetns_ino %u ", info->netns.netns_ino); 209 show_link_attach_type_plain(info->netns.attach_type); 210 break; 211 default: 212 break; 213 } 214 215 if (!hash_empty(link_table.table)) { 216 struct pinned_obj *obj; 217 218 hash_for_each_possible(link_table.table, obj, hash, info->id) { 219 if (obj->id == info->id) 220 printf("\n\tpinned %s", obj->path); 221 } 222 } 223 emit_obj_refs_plain(&refs_table, info->id, "\n\tpids "); 224 225 printf("\n"); 226 227 return 0; 228 } 229 230 static int do_show_link(int fd) 231 { 232 struct bpf_link_info info; 233 __u32 len = sizeof(info); 234 char raw_tp_name[256]; 235 int err; 236 237 memset(&info, 0, sizeof(info)); 238 again: 239 err = bpf_obj_get_info_by_fd(fd, &info, &len); 240 if (err) { 241 p_err("can't get link info: %s", 242 strerror(errno)); 243 close(fd); 244 return err; 245 } 246 if (info.type == BPF_LINK_TYPE_RAW_TRACEPOINT && 247 !info.raw_tracepoint.tp_name) { 248 info.raw_tracepoint.tp_name = (unsigned long)&raw_tp_name; 249 info.raw_tracepoint.tp_name_len = sizeof(raw_tp_name); 250 goto again; 251 } 252 253 if (json_output) 254 show_link_close_json(fd, &info); 255 else 256 show_link_close_plain(fd, &info); 257 258 close(fd); 259 return 0; 260 } 261 262 static int do_show(int argc, char **argv) 263 { 264 __u32 id = 0; 265 int err, fd; 266 267 if (show_pinned) 268 build_pinned_obj_table(&link_table, BPF_OBJ_LINK); 269 build_obj_refs_table(&refs_table, BPF_OBJ_LINK); 270 271 if (argc == 2) { 272 fd = link_parse_fd(&argc, &argv); 273 if (fd < 0) 274 return fd; 275 return do_show_link(fd); 276 } 277 278 if (argc) 279 return BAD_ARG(); 280 281 if (json_output) 282 jsonw_start_array(json_wtr); 283 while (true) { 284 err = bpf_link_get_next_id(id, &id); 285 if (err) { 286 if (errno == ENOENT) 287 break; 288 p_err("can't get next link: %s%s", strerror(errno), 289 errno == EINVAL ? " -- kernel too old?" : ""); 290 break; 291 } 292 293 fd = bpf_link_get_fd_by_id(id); 294 if (fd < 0) { 295 if (errno == ENOENT) 296 continue; 297 p_err("can't get link by id (%u): %s", 298 id, strerror(errno)); 299 break; 300 } 301 302 err = do_show_link(fd); 303 if (err) 304 break; 305 } 306 if (json_output) 307 jsonw_end_array(json_wtr); 308 309 delete_obj_refs_table(&refs_table); 310 311 return errno == ENOENT ? 0 : -1; 312 } 313 314 static int do_pin(int argc, char **argv) 315 { 316 int err; 317 318 err = do_pin_any(argc, argv, link_parse_fd); 319 if (!err && json_output) 320 jsonw_null(json_wtr); 321 return err; 322 } 323 324 static int do_detach(int argc, char **argv) 325 { 326 int err, fd; 327 328 if (argc != 2) { 329 p_err("link specifier is invalid or missing\n"); 330 return 1; 331 } 332 333 fd = link_parse_fd(&argc, &argv); 334 if (fd < 0) 335 return 1; 336 337 err = bpf_link_detach(fd); 338 if (err) 339 err = -errno; 340 close(fd); 341 if (err) { 342 p_err("failed link detach: %s", strerror(-err)); 343 return 1; 344 } 345 346 if (json_output) 347 jsonw_null(json_wtr); 348 349 return 0; 350 } 351 352 static int do_help(int argc, char **argv) 353 { 354 if (json_output) { 355 jsonw_null(json_wtr); 356 return 0; 357 } 358 359 fprintf(stderr, 360 "Usage: %1$s %2$s { show | list } [LINK]\n" 361 " %1$s %2$s pin LINK FILE\n" 362 " %1$s %2$s detach LINK\n" 363 " %1$s %2$s help\n" 364 "\n" 365 " " HELP_SPEC_LINK "\n" 366 " " HELP_SPEC_OPTIONS "\n" 367 "", 368 bin_name, argv[-2]); 369 370 return 0; 371 } 372 373 static const struct cmd cmds[] = { 374 { "show", do_show }, 375 { "list", do_show }, 376 { "help", do_help }, 377 { "pin", do_pin }, 378 { "detach", do_detach }, 379 { 0 } 380 }; 381 382 int do_link(int argc, char **argv) 383 { 384 return cmd_select(cmds, argc, argv, do_help); 385 } 386