tools/testing/selftests/bpf/benchs/bench_bpf_crypto.c

Source file repositories/reference/linux-study-clean/tools/testing/selftests/bpf/benchs/bench_bpf_crypto.c

File Facts

System
Linux kernel
Corpus path
tools/testing/selftests/bpf/benchs/bench_bpf_crypto.c
Extension
.c
Size
4237 bytes
Lines
186
Domain
Support Tooling And Documentation
Bucket
tools
Inferred role
Support Tooling And Documentation: implementation source
Status
source implementation candidate

Why This File Exists

Repository support layer: documentation, build tooling, samples, user-space helper tools, generated initramfs support, licenses, and validation utilities.

Dependency Surface

Detected Declarations

Annotated Snippet

strlen(args.crypto_cipher) > MAX_CIPHER_LEN) {
			fprintf(stderr, "Invalid crypto cipher len (limit %d)\n",
				MAX_CIPHER_LEN);
			argp_usage(state);
		}
		break;
	default:
		return ARGP_ERR_UNKNOWN;
	}

	return 0;
}

const struct argp bench_crypto_argp = {
	.options = opts,
	.parser = crypto_parse_arg,
};

static void crypto_validate(void)
{
	if (env.consumer_cnt != 0) {
		fprintf(stderr, "bpf crypto benchmark doesn't support consumer!\n");
		exit(1);
	}
}

static void crypto_setup(void)
{
	LIBBPF_OPTS(bpf_test_run_opts, opts);

	int err, pfd;
	size_t i, sz;

	sz = args.crypto_len;
	if (!sz || sz > sizeof(ctx.skel->bss->dst)) {
		fprintf(stderr, "invalid encrypt buffer size (source %zu, target %zu)\n",
			sz, sizeof(ctx.skel->bss->dst));
		exit(1);
	}

	setup_libbpf();

	ctx.skel = crypto_bench__open();
	if (!ctx.skel) {
		fprintf(stderr, "failed to open skeleton\n");
		exit(1);
	}

	snprintf(ctx.skel->bss->cipher, 128, "%s", args.crypto_cipher);
	memcpy(ctx.skel->bss->key, "12345678testtest", 16);
	ctx.skel->bss->key_len = 16;
	ctx.skel->bss->authsize = 0;

	srandom(time(NULL));
	input = malloc(sz);
	for (i = 0; i < sz - 1; i++)
		input[i] = '1' + random() % 9;
	input[sz - 1] = '\0';

	ctx.skel->rodata->len = args.crypto_len;

	err = crypto_bench__load(ctx.skel);
	if (err) {
		fprintf(stderr, "failed to load skeleton\n");
		crypto_bench__destroy(ctx.skel);
		exit(1);
	}

	pfd = bpf_program__fd(ctx.skel->progs.crypto_setup);
	if (pfd < 0) {
		fprintf(stderr, "failed to get fd for setup prog\n");
		crypto_bench__destroy(ctx.skel);
		exit(1);
	}

	err = bpf_prog_test_run_opts(pfd, &opts);
	if (err || ctx.skel->bss->status) {
		fprintf(stderr, "failed to run setup prog: err %d, status %d\n",
			err, ctx.skel->bss->status);
		crypto_bench__destroy(ctx.skel);
		exit(1);
	}
}

static void crypto_encrypt_setup(void)
{
	crypto_setup();
	ctx.pfd = bpf_program__fd(ctx.skel->progs.crypto_encrypt);
}

Annotation

Implementation Notes