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 }; 20 21 static int link_parse_fd(int *argc, char ***argv) 22 { 23 if (is_prefix(**argv, "id")) { 24 unsigned int id; 25 char *endptr; 26 27 NEXT_ARGP(); 28 29 id = strtoul(**argv, &endptr, 0); 30 if (*endptr) { 31 p_err("can't parse %s as ID", **argv); 32 return -1; 33 } 34 NEXT_ARGP(); 35 36 return bpf_link_get_fd_by_id(id); 37 } else if (is_prefix(**argv, "pinned")) { 38 char *path; 39 40 NEXT_ARGP(); 41 42 path = **argv; 43 NEXT_ARGP(); 44 45 return open_obj_pinned_any(path, BPF_OBJ_LINK); 46 } 47 48 p_err("expected 'id' or 'pinned', got: '%s'?", **argv); 49 return -1; 50 } 51 52 static void 53 show_link_header_json(struct bpf_link_info *info, json_writer_t *wtr) 54 { 55 jsonw_uint_field(wtr, "id", info->id); 56 if (info->type < ARRAY_SIZE(link_type_name)) 57 jsonw_string_field(wtr, "type", link_type_name[info->type]); 58 else 59 jsonw_uint_field(wtr, "type", info->type); 60 61 jsonw_uint_field(json_wtr, "prog_id", info->prog_id); 62 } 63 64 static int get_prog_info(int prog_id, struct bpf_prog_info *info) 65 { 66 __u32 len = sizeof(*info); 67 int err, prog_fd; 68 69 prog_fd = bpf_prog_get_fd_by_id(prog_id); 70 if (prog_fd < 0) 71 return prog_fd; 72 73 memset(info, 0, sizeof(*info)); 74 err = bpf_obj_get_info_by_fd(prog_fd, info, &len); 75 if (err) 76 p_err("can't get prog info: %s", strerror(errno)); 77 close(prog_fd); 78 return err; 79 } 80 81 static int show_link_close_json(int fd, struct bpf_link_info *info) 82 { 83 struct bpf_prog_info prog_info; 84 int err; 85 86 jsonw_start_object(json_wtr); 87 88 show_link_header_json(info, json_wtr); 89 90 switch (info->type) { 91 case BPF_LINK_TYPE_RAW_TRACEPOINT: 92 jsonw_string_field(json_wtr, "tp_name", 93 (const char *)info->raw_tracepoint.tp_name); 94 break; 95 case BPF_LINK_TYPE_TRACING: 96 err = get_prog_info(info->prog_id, &prog_info); 97 if (err) 98 return err; 99 100 if (prog_info.type < ARRAY_SIZE(prog_type_name)) 101 jsonw_string_field(json_wtr, "prog_type", 102 prog_type_name[prog_info.type]); 103 else 104 jsonw_uint_field(json_wtr, "prog_type", 105 prog_info.type); 106 107 if (info->tracing.attach_type < ARRAY_SIZE(attach_type_name)) 108 jsonw_string_field(json_wtr, "attach_type", 109 attach_type_name[info->tracing.attach_type]); 110 else 111 jsonw_uint_field(json_wtr, "attach_type", 112 info->tracing.attach_type); 113 break; 114 case BPF_LINK_TYPE_CGROUP: 115 jsonw_lluint_field(json_wtr, "cgroup_id", 116 info->cgroup.cgroup_id); 117 if (info->cgroup.attach_type < ARRAY_SIZE(attach_type_name)) 118 jsonw_string_field(json_wtr, "attach_type", 119 attach_type_name[info->cgroup.attach_type]); 120 else 121 jsonw_uint_field(json_wtr, "attach_type", 122 info->cgroup.attach_type); 123 break; 124 default: 125 break; 126 } 127 128 if (!hash_empty(link_table.table)) { 129 struct pinned_obj *obj; 130 131 jsonw_name(json_wtr, "pinned"); 132 jsonw_start_array(json_wtr); 133 hash_for_each_possible(link_table.table, obj, hash, info->id) { 134 if (obj->id == info->id) 135 jsonw_string(json_wtr, obj->path); 136 } 137 jsonw_end_array(json_wtr); 138 } 139 jsonw_end_object(json_wtr); 140 141 return 0; 142 } 143 144 static void show_link_header_plain(struct bpf_link_info *info) 145 { 146 printf("%u: ", info->id); 147 if (info->type < ARRAY_SIZE(link_type_name)) 148 printf("%s ", link_type_name[info->type]); 149 else 150 printf("type %u ", info->type); 151 152 printf("prog %u ", info->prog_id); 153 } 154 155 static int show_link_close_plain(int fd, struct bpf_link_info *info) 156 { 157 struct bpf_prog_info prog_info; 158 int err; 159 160 show_link_header_plain(info); 161 162 switch (info->type) { 163 case BPF_LINK_TYPE_RAW_TRACEPOINT: 164 printf("\n\ttp '%s' ", 165 (const char *)info->raw_tracepoint.tp_name); 166 break; 167 case BPF_LINK_TYPE_TRACING: 168 err = get_prog_info(info->prog_id, &prog_info); 169 if (err) 170 return err; 171 172 if (prog_info.type < ARRAY_SIZE(prog_type_name)) 173 printf("\n\tprog_type %s ", 174 prog_type_name[prog_info.type]); 175 else 176 printf("\n\tprog_type %u ", prog_info.type); 177 178 if (info->tracing.attach_type < ARRAY_SIZE(attach_type_name)) 179 printf("attach_type %s ", 180 attach_type_name[info->tracing.attach_type]); 181 else 182 printf("attach_type %u ", info->tracing.attach_type); 183 break; 184 case BPF_LINK_TYPE_CGROUP: 185 printf("\n\tcgroup_id %zu ", (size_t)info->cgroup.cgroup_id); 186 if (info->cgroup.attach_type < ARRAY_SIZE(attach_type_name)) 187 printf("attach_type %s ", 188 attach_type_name[info->cgroup.attach_type]); 189 else 190 printf("attach_type %u ", info->cgroup.attach_type); 191 break; 192 default: 193 break; 194 } 195 196 if (!hash_empty(link_table.table)) { 197 struct pinned_obj *obj; 198 199 hash_for_each_possible(link_table.table, obj, hash, info->id) { 200 if (obj->id == info->id) 201 printf("\n\tpinned %s", obj->path); 202 } 203 } 204 205 printf("\n"); 206 207 return 0; 208 } 209 210 static int do_show_link(int fd) 211 { 212 struct bpf_link_info info; 213 __u32 len = sizeof(info); 214 char raw_tp_name[256]; 215 int err; 216 217 memset(&info, 0, sizeof(info)); 218 again: 219 err = bpf_obj_get_info_by_fd(fd, &info, &len); 220 if (err) { 221 p_err("can't get link info: %s", 222 strerror(errno)); 223 close(fd); 224 return err; 225 } 226 if (info.type == BPF_LINK_TYPE_RAW_TRACEPOINT && 227 !info.raw_tracepoint.tp_name) { 228 info.raw_tracepoint.tp_name = (unsigned long)&raw_tp_name; 229 info.raw_tracepoint.tp_name_len = sizeof(raw_tp_name); 230 goto again; 231 } 232 233 if (json_output) 234 show_link_close_json(fd, &info); 235 else 236 show_link_close_plain(fd, &info); 237 238 close(fd); 239 return 0; 240 } 241 242 static int do_show(int argc, char **argv) 243 { 244 __u32 id = 0; 245 int err, fd; 246 247 if (show_pinned) 248 build_pinned_obj_table(&link_table, BPF_OBJ_LINK); 249 250 if (argc == 2) { 251 fd = link_parse_fd(&argc, &argv); 252 if (fd < 0) 253 return fd; 254 return do_show_link(fd); 255 } 256 257 if (argc) 258 return BAD_ARG(); 259 260 if (json_output) 261 jsonw_start_array(json_wtr); 262 while (true) { 263 err = bpf_link_get_next_id(id, &id); 264 if (err) { 265 if (errno == ENOENT) 266 break; 267 p_err("can't get next link: %s%s", strerror(errno), 268 errno == EINVAL ? " -- kernel too old?" : ""); 269 break; 270 } 271 272 fd = bpf_link_get_fd_by_id(id); 273 if (fd < 0) { 274 if (errno == ENOENT) 275 continue; 276 p_err("can't get link by id (%u): %s", 277 id, strerror(errno)); 278 break; 279 } 280 281 err = do_show_link(fd); 282 if (err) 283 break; 284 } 285 if (json_output) 286 jsonw_end_array(json_wtr); 287 288 return errno == ENOENT ? 0 : -1; 289 } 290 291 static int do_pin(int argc, char **argv) 292 { 293 int err; 294 295 err = do_pin_any(argc, argv, link_parse_fd); 296 if (!err && json_output) 297 jsonw_null(json_wtr); 298 return err; 299 } 300 301 static int do_help(int argc, char **argv) 302 { 303 if (json_output) { 304 jsonw_null(json_wtr); 305 return 0; 306 } 307 308 fprintf(stderr, 309 "Usage: %1$s %2$s { show | list } [LINK]\n" 310 " %1$s %2$s pin LINK FILE\n" 311 " %1$s %2$s help\n" 312 "\n" 313 " " HELP_SPEC_LINK "\n" 314 " " HELP_SPEC_PROGRAM "\n" 315 " " HELP_SPEC_OPTIONS "\n" 316 "", 317 bin_name, argv[-2]); 318 319 return 0; 320 } 321 322 static const struct cmd cmds[] = { 323 { "show", do_show }, 324 { "list", do_show }, 325 { "help", do_help }, 326 { "pin", do_pin }, 327 { 0 } 328 }; 329 330 int do_link(int argc, char **argv) 331 { 332 return cmd_select(cmds, argc, argv, do_help); 333 } 334