basic-solutions: Implement basic04 Assignment 2

Signed-off-by: Xun Gu <xugu@redhat.com>

Author: Xun Gu

basic-solutions/xdp_loader.c

@@ -22,6 +22,7 @@ static const char *__doc__ = "XDP loader\n"
 #include "../common/common_params.h"
 #include "../common/common_user_bpf_xdp.h"
 #include "../common/common_libbpf.h"
+#include "common_kern_user.h"
 
 static const char *default_filename = "xdp_prog_kern.o";
 
@@ -45,11 +46,8 @@ static const struct option_wrapper long_options[] = {
 	{{"force",       no_argument,		NULL, 'F' },
 	 "Force install, replacing existing program on interface"},
 
-	{{"unload",      no_argument,		NULL, 'U' },
-	 "Unload XDP program instead of loading"},
-
-	{{"reuse-maps",  no_argument,		NULL, 'M' },
-	 "Reuse pinned maps"},
+	{{"unload",      required_argument,	NULL, 'U' },
+	 "Unload XDP program <id> instead of loading", "<id>"},
 
 	{{"quiet",       no_argument,		NULL, 'q' },
 	 "Quiet mode (no output)"},
@@ -70,14 +68,98 @@ static const struct option_wrapper long_options[] = {
 const char *pin_basedir =  "/sys/fs/bpf";
 const char *map_name    =  "xdp_stats_map";
 
+
+/* Load BPF and XDP program with map reuse using libxdp */
+struct xdp_program *load_bpf_and_xdp_attach_reuse_maps(struct config *cfg, const char *pin_dir, bool *map_reused)
+{
+	int err = 0;
+
+	if (!cfg || !cfg->filename[0] || !cfg->progname[0] || !pin_dir || !map_reused) {
+		fprintf(stderr, "ERR: invalid arguments\n");
+		return NULL;
+	}
+
+	*map_reused = false;
+
+	/* 1) First, try to reuse maps by opening object and reusing before libxdp creates it */
+	struct bpf_object *obj = NULL;
+	DECLARE_LIBBPF_OPTS(bpf_object_open_opts, open_opts);
+	obj = bpf_object__open_file(cfg->filename, &open_opts);
+	if (libbpf_get_error(obj)) {
+		err = -libbpf_get_error(obj);
+		fprintf(stderr, "ERR: bpf_object__open_file(%s): %s\n",
+			cfg->filename, strerror(-err));
+		return NULL;
+	}
+
+	/* 2) Try to reuse the specific map */
+	struct bpf_map *map = bpf_object__find_map_by_name(obj, map_name);
+	if (map) {
+		char map_path[PATH_MAX];
+		int len = snprintf(map_path, PATH_MAX, "%s/%s", pin_dir, map_name);
+		if (len < 0 || len >= PATH_MAX) {
+			fprintf(stderr, "ERR: map path too long\n");
+			bpf_object__close(obj);
+			return NULL;
+		}
+
+		int pinned_map_fd = bpf_obj_get(map_path);
+		if (pinned_map_fd >= 0) {
+			err = bpf_map__reuse_fd(map, pinned_map_fd);
+			if (err) {
+				close(pinned_map_fd);
+				fprintf(stderr, "ERR: bpf_map__reuse_fd: %s\n", strerror(-err));
+				bpf_object__close(obj);
+				return NULL;
+			}
+			*map_reused = true;
+			if (verbose)
+				printf(" - Reusing pinned map: %s\n", map_path);
+		}
+	}
+
+	/* 3) Now use libxdp with the pre-opened object */
+	DECLARE_LIBXDP_OPTS(xdp_program_opts, xdp_opts, 0);
+	/* Use our object with reused maps */
+	xdp_opts.obj = obj;
+	xdp_opts.prog_name = cfg->progname;
+
+	struct xdp_program *prog = xdp_program__create(&xdp_opts);
+	err = libxdp_get_error(prog);
+	if (err) {
+		char errmsg[1024];
+		libxdp_strerror(err, errmsg, sizeof(errmsg));
+		fprintf(stderr, "ERR: loading program: %s\n", errmsg);
+		bpf_object__close(obj);
+		return NULL;
+	}
+
+	/* 4) Attach using libxdp */
+	err = xdp_program__attach(prog, cfg->ifindex, cfg->attach_mode, 0);
+	if (err) {
+		fprintf(stderr, "ERR: xdp_program__attach: %s\n", strerror(-err));
+		xdp_program__close(prog);
+		return NULL;
+	}
+
+	return prog;
+}
+
 /* Pinning maps under /sys/fs/bpf in subdir */
-int pin_maps_in_bpf_object(struct bpf_object *bpf_obj, struct config *cfg)
+int pin_maps_in_bpf_object(struct bpf_object *bpf_obj, const char *subdir)
 {
 	char map_filename[PATH_MAX];
+	char pin_dir[PATH_MAX];
 	int err, len;
 
+	len = snprintf(pin_dir, PATH_MAX, "%s/%s", pin_basedir, subdir);
+	if (len < 0) {
+		fprintf(stderr, "ERR: creating pin dirname\n");
+		return EXIT_FAIL_OPTION;
+	}
+
 	len = snprintf(map_filename, PATH_MAX, "%s/%s/%s",
-		       cfg->pin_dir, cfg->ifname, map_name);
+		       pin_basedir, subdir, map_name);
 	if (len < 0) {
 		fprintf(stderr, "ERR: creating map_name\n");
 		return EXIT_FAIL_OPTION;
@@ -87,38 +169,39 @@ int pin_maps_in_bpf_object(struct bpf_object *bpf_obj, struct config *cfg)
 	if (access(map_filename, F_OK) != -1 ) {
 		if (verbose)
 			printf(" - Unpinning (remove) prev maps in %s/\n",
-			       cfg->pin_dir);
+			       pin_dir);
 
 		/* Basically calls unlink(3) on map_filename */
-		err = bpf_object__unpin_maps(bpf_obj, cfg->pin_dir);
+		err = bpf_object__unpin_maps(bpf_obj, pin_dir);
 		if (err) {
-			fprintf(stderr, "ERR: UNpinning maps in %s\n", cfg->pin_dir);
+			fprintf(stderr, "ERR: UNpinning maps in %s\n", pin_dir);
 			return EXIT_FAIL_BPF;
 		}
 	}
 	if (verbose)
-		printf(" - Pinning maps in %s/\n", cfg->pin_dir);
+		printf(" - Pinning maps in %s/\n", pin_dir);
 
 	/* This will pin all maps in our bpf_object */
-	err = bpf_object__pin_maps(bpf_obj, cfg->pin_dir);
-	if (err) {
-		fprintf(stderr, "ERR: Pinning maps in %s\n", cfg->pin_dir);
+	err = bpf_object__pin_maps(bpf_obj, pin_dir);
+	if (err)
 		return EXIT_FAIL_BPF;
-	}
 
 	return 0;
 }
 
 int main(int argc, char **argv)
 {
-	struct xdp_program *program;
 	int err, len;
+	struct xdp_program *program;
+	bool map_reused = false;
+	char path[PATH_MAX];
 
 	struct config cfg = {
 		.attach_mode = XDP_MODE_NATIVE,
 		.ifindex     = -1,
 		.do_unload   = false,
 	};
+
 	/* Set default BPF-ELF object file and BPF program name */
 	strncpy(cfg.filename, default_filename, sizeof(cfg.filename));
 	/* Cmdline options can change progname */
@@ -131,23 +214,51 @@ int main(int argc, char **argv)
 		return EXIT_FAIL_OPTION;
 	}
 	if (cfg.do_unload) {
-		if (!cfg.reuse_maps) {
-		/* TODO: Miss unpin of maps on unload */
+		/* unpin the maps */
+		len = snprintf(path, PATH_MAX, "%s/%s/%s", pin_basedir,
+			       cfg.ifname, map_name);
+		if (len < 0) {
+			fprintf(stderr, "ERR: creating map filename for unload\n");
+			return EXIT_FAIL_OPTION;
+		}
+
+		/* If the map file exists, unpin it */
+		if (access(path, F_OK) == 0) {
+			if (verbose)
+				printf(" - Unpinning map %s\n", path);
+
+			/* Use unlink to remove the pinned map file */
+			err = unlink(path);
+			if (err) {
+				fprintf(stderr, "ERR: Failed to unpin map %s: %s\n",
+					path, strerror(errno));
+			}
+		}
+
+		/* unload the program */
+		err = do_unload(&cfg);
+		if (err) {
+			char errmsg[1024];
+			libxdp_strerror(err, errmsg, sizeof(errmsg));
+			fprintf(stderr, "Couldn't unload XDP program: %s\n", errmsg);
+			return err;
 		}
-		/* return xdp_link_detach(cfg.ifindex, cfg.xdp_flags, 0); */
+
+		printf("Success: Unloaded XDP program\n");
+		return EXIT_OK;
 	}
 
-	/* Initialize the pin_dir configuration */
-	len = snprintf(cfg.pin_dir, 512, "%s/%s", pin_basedir, cfg.ifname);
+	/* Try to reuse existing pinned maps before loading */
+	len = snprintf(path, PATH_MAX, "%s/%s", pin_basedir, cfg.ifname);
 	if (len < 0) {
 		fprintf(stderr, "ERR: creating pin dirname\n");
 		return EXIT_FAIL_OPTION;
 	}
 
-
-	program = load_bpf_and_xdp_attach(&cfg);
-	if (!program)
+	program = load_bpf_and_xdp_attach_reuse_maps(&cfg, path, &map_reused);
+	if (!program) {
 		return EXIT_FAIL_BPF;
+	}
 
 	if (verbose) {
 		printf("Success: Loaded BPF-object(%s) and used program(%s)\n",
@@ -156,9 +267,9 @@ int main(int argc, char **argv)
 		       cfg.ifname, cfg.ifindex);
 	}
 
-	/* Use the --dev name as subdir for exporting/pinning maps */
-	if (!cfg.reuse_maps) {
-		err = pin_maps_in_bpf_object(xdp_program__bpf_obj(program), &cfg);
+	if (!map_reused) {
+		/* Use the --dev name as subdir for exporting/pinning maps */
+		err = pin_maps_in_bpf_object(xdp_program__bpf_obj(program), cfg.ifname);
 		if (err) {
 			fprintf(stderr, "ERR: pinning maps\n");
 			return err;