libbpf: Extract and generalize CPU mask parsing logic (6803ee25) · Commits · 戴 / test

tools/lib/bpf/libbpf.c

+84 −41

Original line number	Diff line number	Diff line
		@@ -6523,61 +6523,104 @@ void bpf_program__bpil_offs_to_addr(struct bpf_prog_info_linear *info_linear)
		}
		}

		int libbpf_num_possible_cpus(void)
		int parse_cpu_mask_str(const char s, bool mask, int mask_sz)
		{
		static const char *fcpu = "/sys/devices/system/cpu/possible";
		int len = 0, n = 0, il = 0, ir = 0;
		unsigned int start = 0, end = 0;
		int tmp_cpus = 0;
		static int cpus;
		char buf[128];
		int error = 0;
		int fd = -1;
		int err = 0, n, len, start, end = -1;
		bool *tmp;

		tmp_cpus = READ_ONCE(cpus);
		if (tmp_cpus > 0)
		return tmp_cpus;
		*mask = NULL;
		*mask_sz = 0;

		/* Each sub string separated by ',' has format \d+-\d+ or \d+ */
		while (*s) {
		if (s == ',' \|\| s == '\n') {
		s++;
		continue;
		}
		n = sscanf(s, "%d%n-%d%n", &start, &len, &end, &len);
		if (n <= 0 \|\| n > 2) {
		pr_warn("Failed to get CPU range %s: %d\n", s, n);
		err = -EINVAL;
		goto cleanup;
		} else if (n == 1) {
		end = start;
		}
		if (start < 0 \|\| start > end) {
		pr_warn("Invalid CPU range [%d,%d] in %s\n",
		start, end, s);
		err = -EINVAL;
		goto cleanup;
		}
		tmp = realloc(*mask, end + 1);
		if (!tmp) {
		err = -ENOMEM;
		goto cleanup;
		}
		*mask = tmp;
		memset(tmp + mask_sz, 0, start - mask_sz);
		memset(tmp + start, 1, end - start + 1);
		*mask_sz = end + 1;
		s += len;
		}
		if (!*mask_sz) {
		pr_warn("Empty CPU range\n");
		return -EINVAL;
		}
		return 0;
		cleanup:
		free(*mask);
		*mask = NULL;
		return err;
		}

		int parse_cpu_mask_file(const char fcpu, bool mask, int mask_sz)
		{
		int fd, err = 0, len;
		char buf[128];

		fd = open(fcpu, O_RDONLY);
		if (fd < 0) {
		error = errno;
		pr_warn("Failed to open file %s: %s\n", fcpu, strerror(error));
		return -error;
		err = -errno;
		pr_warn("Failed to open cpu mask file %s: %d\n", fcpu, err);
		return err;
		}
		len = read(fd, buf, sizeof(buf));
		close(fd);
		if (len <= 0) {
		error = len ? errno : EINVAL;
		pr_warn("Failed to read # of possible cpus from %s: %s\n",
		fcpu, strerror(error));
		return -error;
		err = len ? -errno : -EINVAL;
		pr_warn("Failed to read cpu mask from %s: %d\n", fcpu, err);
		return err;
		}
		if (len == sizeof(buf)) {
		pr_warn("File %s size overflow\n", fcpu);
		return -EOVERFLOW;
		if (len >= sizeof(buf)) {
		pr_warn("CPU mask is too big in file %s\n", fcpu);
		return -E2BIG;
		}
		buf[len] = '\0';

		for (ir = 0, tmp_cpus = 0; ir <= len; ir++) {
		/* Each sub string separated by ',' has format \d+-\d+ or \d+ */
		if (buf[ir] == ',' \|\| buf[ir] == '\0') {
		buf[ir] = '\0';
		n = sscanf(&buf[il], "%u-%u", &start, &end);
		if (n <= 0) {
		pr_warn("Failed to get # CPUs from %s\n",
		&buf[il]);
		return -EINVAL;
		} else if (n == 1) {
		end = start;
		}
		tmp_cpus += end - start + 1;
		il = ir + 1;
		}
		return parse_cpu_mask_str(buf, mask, mask_sz);
		}
		if (tmp_cpus <= 0) {
		pr_warn("Invalid #CPUs %d from %s\n", tmp_cpus, fcpu);
		return -EINVAL;

		int libbpf_num_possible_cpus(void)
		{
		static const char *fcpu = "/sys/devices/system/cpu/possible";
		static int cpus;
		int err, n, i, tmp_cpus;
		bool *mask;

		tmp_cpus = READ_ONCE(cpus);
		if (tmp_cpus > 0)
		return tmp_cpus;

		err = parse_cpu_mask_file(fcpu, &mask, &n);
		if (err)
		return err;

		tmp_cpus = 0;
		for (i = 0; i < n; i++) {
		if (mask[i])
		tmp_cpus++;
		}
		free(mask);

		WRITE_ONCE(cpus, tmp_cpus);
		return tmp_cpus;

tools/lib/bpf/libbpf_internal.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -95,6 +95,8 @@ static inline bool libbpf_validate_opts(const char *opts,
		#define OPTS_GET(opts, field, fallback_value) \
		(OPTS_HAS(opts, field) ? (opts)->field : fallback_value)

		int parse_cpu_mask_str(const char s, bool mask, int mask_sz);
		int parse_cpu_mask_file(const char fcpu, bool mask, int mask_sz);
		int libbpf__load_raw_btf(const char *raw_types, size_t types_len,
		const char *str_sec, size_t str_len);

Admin message