tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <test_progs.h>
   3
   4 #define nr_iters 2
   5
   6 void test_bpf_obj_id(void)
   7 {
   8         const __u64 array_magic_value = 0xfaceb00c;
   9         const __u32 array_key = 0;
  10         const char *file = "./test_obj_id.o";
  11         const char *expected_prog_name = "test_obj_id";
  12         const char *expected_map_name = "test_map_id";
  13         const __u64 nsec_per_sec = 1000000000;
  14
  15         struct bpf_object *objs[nr_iters] = {};
  16         struct bpf_link *links[nr_iters] = {};
  17         struct bpf_program *prog;
  18         int prog_fds[nr_iters], map_fds[nr_iters];
  19         /* +1 to test for the info_len returned by kernel */
  20         struct bpf_prog_info prog_infos[nr_iters + 1];
  21         struct bpf_map_info map_infos[nr_iters + 1];
  22         struct bpf_link_info link_infos[nr_iters + 1];
  23         /* Each prog only uses one map. +1 to test nr_map_ids
  24          * returned by kernel.
  25          */
  26         __u32 map_ids[nr_iters + 1];
  27         char jited_insns[128], xlated_insns[128], zeros[128], tp_name[128];
  28         __u32 i, next_id, info_len, nr_id_found, duration = 0;
  29         struct timespec real_time_ts, boot_time_ts;
  30         int err = 0;
  31         __u64 array_value;
  32         uid_t my_uid = getuid();
  33         time_t now, load_time;
  34
  35         err = bpf_prog_get_fd_by_id(0);
  36         CHECK(err >= 0 || errno != ENOENT,
  37               "get-fd-by-notexist-prog-id", "err %d errno %d\n", err, errno);
  38
  39         err = bpf_map_get_fd_by_id(0);
  40         CHECK(err >= 0 || errno != ENOENT,
  41               "get-fd-by-notexist-map-id", "err %d errno %d\n", err, errno);
  42
  43         err = bpf_link_get_fd_by_id(0);
  44         CHECK(err >= 0 || errno != ENOENT,
  45               "get-fd-by-notexist-link-id", "err %d errno %d\n", err, errno);
  46
  47         /* Check bpf_obj_get_info_by_fd() */
  48         bzero(zeros, sizeof(zeros));
  49         for (i = 0; i < nr_iters; i++) {
  50                 now = time(NULL);
  51                 err = bpf_prog_load(file, BPF_PROG_TYPE_RAW_TRACEPOINT,
  52                                     &objs[i], &prog_fds[i]);
  53                 /* test_obj_id.o is a dumb prog. It should never fail
  54                  * to load.
  55                  */
  56                 if (CHECK_FAIL(err))
  57                         continue;
  58
  59                 /* Insert a magic value to the map */
  60                 map_fds[i] = bpf_find_map(__func__, objs[i], "test_map_id");
  61                 if (CHECK_FAIL(map_fds[i] < 0))
  62                         goto done;
  63                 err = bpf_map_update_elem(map_fds[i], &array_key,
  64                                           &array_magic_value, 0);
  65                 if (CHECK_FAIL(err))
  66                         goto done;
  67
  68                 prog = bpf_object__find_program_by_title(objs[i],
  69                                                          "raw_tp/sys_enter");
  70                 if (CHECK_FAIL(!prog))
  71                         goto done;
  72                 links[i] = bpf_program__attach(prog);
  73                 err = libbpf_get_error(links[i]);
  74                 if (CHECK(err, "prog_attach", "prog #%d, err %d\n", i, err)) {
  75                         links[i] = NULL;
  76                         goto done;
  77                 }
  78
  79                 /* Check getting map info */
  80                 info_len = sizeof(struct bpf_map_info) * 2;
  81                 bzero(&map_infos[i], info_len);
  82                 err = bpf_obj_get_info_by_fd(map_fds[i], &map_infos[i],
  83                                              &info_len);
  84                 if (CHECK(err ||
  85                           map_infos[i].type != BPF_MAP_TYPE_ARRAY ||
  86                           map_infos[i].key_size != sizeof(__u32) ||
  87                           map_infos[i].value_size != sizeof(__u64) ||
  88                           map_infos[i].max_entries != 1 ||
  89                           map_infos[i].map_flags != 0 ||
  90                           info_len != sizeof(struct bpf_map_info) ||
  91                           strcmp((char *)map_infos[i].name, expected_map_name),
  92                           "get-map-info(fd)",
  93                           "err %d errno %d type %d(%d) info_len %u(%zu) key_size %u value_size %u max_entries %u map_flags %X name %s(%s)\n",
  94                           err, errno,
  95                           map_infos[i].type, BPF_MAP_TYPE_ARRAY,
  96                           info_len, sizeof(struct bpf_map_info),
  97                           map_infos[i].key_size,
  98                           map_infos[i].value_size,
  99                           map_infos[i].max_entries,
 100                           map_infos[i].map_flags,
 101                           map_infos[i].name, expected_map_name))
 102                         goto done;
 103
 104                 /* Check getting prog info */
 105                 info_len = sizeof(struct bpf_prog_info) * 2;
 106                 bzero(&prog_infos[i], info_len);
 107                 bzero(jited_insns, sizeof(jited_insns));
 108                 bzero(xlated_insns, sizeof(xlated_insns));
 109                 prog_infos[i].jited_prog_insns = ptr_to_u64(jited_insns);
 110                 prog_infos[i].jited_prog_len = sizeof(jited_insns);
 111                 prog_infos[i].xlated_prog_insns = ptr_to_u64(xlated_insns);
 112                 prog_infos[i].xlated_prog_len = sizeof(xlated_insns);
 113                 prog_infos[i].map_ids = ptr_to_u64(map_ids + i);
 114                 prog_infos[i].nr_map_ids = 2;
 115                 err = clock_gettime(CLOCK_REALTIME, &real_time_ts);
 116                 if (CHECK_FAIL(err))
 117                         goto done;
 118                 err = clock_gettime(CLOCK_BOOTTIME, &boot_time_ts);
 119                 if (CHECK_FAIL(err))
 120                         goto done;
 121                 err = bpf_obj_get_info_by_fd(prog_fds[i], &prog_infos[i],
 122                                              &info_len);
 123                 load_time = (real_time_ts.tv_sec - boot_time_ts.tv_sec)
 124                         + (prog_infos[i].load_time / nsec_per_sec);
 125                 if (CHECK(err ||
 126                           prog_infos[i].type != BPF_PROG_TYPE_RAW_TRACEPOINT ||
 127                           info_len != sizeof(struct bpf_prog_info) ||
 128                           (env.jit_enabled && !prog_infos[i].jited_prog_len) ||
 129                           (env.jit_enabled &&
 130                            !memcmp(jited_insns, zeros, sizeof(zeros))) ||
 131                           !prog_infos[i].xlated_prog_len ||
 132                           !memcmp(xlated_insns, zeros, sizeof(zeros)) ||
 133                           load_time < now - 60 || load_time > now + 60 ||
 134                           prog_infos[i].created_by_uid != my_uid ||
 135                           prog_infos[i].nr_map_ids != 1 ||
 136                           *(int *)(long)prog_infos[i].map_ids != map_infos[i].id ||
 137                           strcmp((char *)prog_infos[i].name, expected_prog_name),
 138                           "get-prog-info(fd)",
 139                           "err %d errno %d i %d type %d(%d) info_len %u(%zu) "
 140                           "jit_enabled %d jited_prog_len %u xlated_prog_len %u "
 141                           "jited_prog %d xlated_prog %d load_time %lu(%lu) "
 142                           "uid %u(%u) nr_map_ids %u(%u) map_id %u(%u) "
 143                           "name %s(%s)\n",
 144                           err, errno, i,
 145                           prog_infos[i].type, BPF_PROG_TYPE_SOCKET_FILTER,
 146                           info_len, sizeof(struct bpf_prog_info),
 147                           env.jit_enabled,
 148                           prog_infos[i].jited_prog_len,
 149                           prog_infos[i].xlated_prog_len,
 150                           !!memcmp(jited_insns, zeros, sizeof(zeros)),
 151                           !!memcmp(xlated_insns, zeros, sizeof(zeros)),
 152                           load_time, now,
 153                           prog_infos[i].created_by_uid, my_uid,
 154                           prog_infos[i].nr_map_ids, 1,
 155                           *(int *)(long)prog_infos[i].map_ids, map_infos[i].id,
 156                           prog_infos[i].name, expected_prog_name))
 157                         goto done;
 158
 159                 /* Check getting link info */
 160                 info_len = sizeof(struct bpf_link_info) * 2;
 161                 bzero(&link_infos[i], info_len);
 162                 link_infos[i].raw_tracepoint.tp_name = ptr_to_u64(&tp_name);
 163                 link_infos[i].raw_tracepoint.tp_name_len = sizeof(tp_name);
 164                 err = bpf_obj_get_info_by_fd(bpf_link__fd(links[i]),
 165                                              &link_infos[i], &info_len);
 166                 if (CHECK(err ||
 167                           link_infos[i].type != BPF_LINK_TYPE_RAW_TRACEPOINT ||
 168                           link_infos[i].prog_id != prog_infos[i].id ||
 169                           link_infos[i].raw_tracepoint.tp_name != ptr_to_u64(&tp_name) ||
 170                           strcmp(u64_to_ptr(link_infos[i].raw_tracepoint.tp_name),
 171                                  "sys_enter") ||
 172                           info_len != sizeof(struct bpf_link_info),
 173                           "get-link-info(fd)",
 174                           "err %d errno %d info_len %u(%zu) type %d(%d) id %d "
 175                           "prog_id %d (%d) tp_name %s(%s)\n",
 176                           err, errno,
 177                           info_len, sizeof(struct bpf_link_info),
 178                           link_infos[i].type, BPF_LINK_TYPE_RAW_TRACEPOINT,
 179                           link_infos[i].id,
 180                           link_infos[i].prog_id, prog_infos[i].id,
 181                           (const char *)u64_to_ptr(link_infos[i].raw_tracepoint.tp_name),
 182                           "sys_enter"))
 183                         goto done;
 184
 185         }
 186
 187         /* Check bpf_prog_get_next_id() */
 188         nr_id_found = 0;
 189         next_id = 0;
 190         while (!bpf_prog_get_next_id(next_id, &next_id)) {
 191                 struct bpf_prog_info prog_info = {};
 192                 __u32 saved_map_id;
 193                 int prog_fd;
 194
 195                 info_len = sizeof(prog_info);
 196
 197                 prog_fd = bpf_prog_get_fd_by_id(next_id);
 198                 if (prog_fd < 0 && errno == ENOENT)
 199                         /* The bpf_prog is in the dead row */
 200                         continue;
 201                 if (CHECK(prog_fd < 0, "get-prog-fd(next_id)",
 202                           "prog_fd %d next_id %d errno %d\n",
 203                           prog_fd, next_id, errno))
 204                         break;
 205
 206                 for (i = 0; i < nr_iters; i++)
 207                         if (prog_infos[i].id == next_id)
 208                                 break;
 209
 210                 if (i == nr_iters)
 211                         continue;
 212
 213                 nr_id_found++;
 214
 215                 /* Negative test:
 216                  * prog_info.nr_map_ids = 1
 217                  * prog_info.map_ids = NULL
 218                  */
 219                 prog_info.nr_map_ids = 1;
 220                 err = bpf_obj_get_info_by_fd(prog_fd, &prog_info, &info_len);
 221                 if (CHECK(!err || errno != EFAULT,
 222                           "get-prog-fd-bad-nr-map-ids", "err %d errno %d(%d)",
 223                           err, errno, EFAULT))
 224                         break;
 225                 bzero(&prog_info, sizeof(prog_info));
 226                 info_len = sizeof(prog_info);
 227
 228                 saved_map_id = *(int *)((long)prog_infos[i].map_ids);
 229                 prog_info.map_ids = prog_infos[i].map_ids;
 230                 prog_info.nr_map_ids = 2;
 231                 err = bpf_obj_get_info_by_fd(prog_fd, &prog_info, &info_len);
 232                 prog_infos[i].jited_prog_insns = 0;
 233                 prog_infos[i].xlated_prog_insns = 0;
 234                 CHECK(err || info_len != sizeof(struct bpf_prog_info) ||
 235                       memcmp(&prog_info, &prog_infos[i], info_len) ||
 236                       *(int *)(long)prog_info.map_ids != saved_map_id,
 237                       "get-prog-info(next_id->fd)",
 238                       "err %d errno %d info_len %u(%zu) memcmp %d map_id %u(%u)\n",
 239                       err, errno, info_len, sizeof(struct bpf_prog_info),
 240                       memcmp(&prog_info, &prog_infos[i], info_len),
 241                       *(int *)(long)prog_info.map_ids, saved_map_id);
 242                 close(prog_fd);
 243         }
 244         CHECK(nr_id_found != nr_iters,
 245               "check total prog id found by get_next_id",
 246               "nr_id_found %u(%u)\n",
 247               nr_id_found, nr_iters);
 248
 249         /* Check bpf_map_get_next_id() */
 250         nr_id_found = 0;
 251         next_id = 0;
 252         while (!bpf_map_get_next_id(next_id, &next_id)) {
 253                 struct bpf_map_info map_info = {};
 254                 int map_fd;
 255
 256                 info_len = sizeof(map_info);
 257
 258                 map_fd = bpf_map_get_fd_by_id(next_id);
 259                 if (map_fd < 0 && errno == ENOENT)
 260                         /* The bpf_map is in the dead row */
 261                         continue;
 262                 if (CHECK(map_fd < 0, "get-map-fd(next_id)",
 263                           "map_fd %d next_id %u errno %d\n",
 264                           map_fd, next_id, errno))
 265                         break;
 266
 267                 for (i = 0; i < nr_iters; i++)
 268                         if (map_infos[i].id == next_id)
 269                                 break;
 270
 271                 if (i == nr_iters)
 272                         continue;
 273
 274                 nr_id_found++;
 275
 276                 err = bpf_map_lookup_elem(map_fd, &array_key, &array_value);
 277                 if (CHECK_FAIL(err))
 278                         goto done;
 279
 280                 err = bpf_obj_get_info_by_fd(map_fd, &map_info, &info_len);
 281                 CHECK(err || info_len != sizeof(struct bpf_map_info) ||
 282                       memcmp(&map_info, &map_infos[i], info_len) ||
 283                       array_value != array_magic_value,
 284                       "check get-map-info(next_id->fd)",
 285                       "err %d errno %d info_len %u(%zu) memcmp %d array_value %llu(%llu)\n",
 286                       err, errno, info_len, sizeof(struct bpf_map_info),
 287                       memcmp(&map_info, &map_infos[i], info_len),
 288                       array_value, array_magic_value);
 289
 290                 close(map_fd);
 291         }
 292         CHECK(nr_id_found != nr_iters,
 293               "check total map id found by get_next_id",
 294               "nr_id_found %u(%u)\n",
 295               nr_id_found, nr_iters);
 296
 297         /* Check bpf_link_get_next_id() */
 298         nr_id_found = 0;
 299         next_id = 0;
 300         while (!bpf_link_get_next_id(next_id, &next_id)) {
 301                 struct bpf_link_info link_info;
 302                 int link_fd, cmp_res;
 303
 304                 info_len = sizeof(link_info);
 305                 memset(&link_info, 0, info_len);
 306
 307                 link_fd = bpf_link_get_fd_by_id(next_id);
 308                 if (link_fd < 0 && errno == ENOENT)
 309                         /* The bpf_link is in the dead row */
 310                         continue;
 311                 if (CHECK(link_fd < 0, "get-link-fd(next_id)",
 312                           "link_fd %d next_id %u errno %d\n",
 313                           link_fd, next_id, errno))
 314                         break;
 315
 316                 for (i = 0; i < nr_iters; i++)
 317                         if (link_infos[i].id == next_id)
 318                                 break;
 319
 320                 if (i == nr_iters)
 321                         continue;
 322
 323                 nr_id_found++;
 324
 325                 err = bpf_obj_get_info_by_fd(link_fd, &link_info, &info_len);
 326                 cmp_res = memcmp(&link_info, &link_infos[i],
 327                                 offsetof(struct bpf_link_info, raw_tracepoint));
 328                 CHECK(err || info_len != sizeof(link_info) || cmp_res,
 329                       "check get-link-info(next_id->fd)",
 330                       "err %d errno %d info_len %u(%zu) memcmp %d\n",
 331                       err, errno, info_len, sizeof(struct bpf_link_info),
 332                       cmp_res);
 333
 334                 close(link_fd);
 335         }
 336         CHECK(nr_id_found != nr_iters,
 337               "check total link id found by get_next_id",
 338               "nr_id_found %u(%u)\n", nr_id_found, nr_iters);
 339
 340 done:
 341         for (i = 0; i < nr_iters; i++) {
 342                 bpf_link__destroy(links[i]);
 343                 bpf_object__close(objs[i]);
 344         }
 345 }