mount: Remove the excessive parameter passing

Signed-off-by: Michael Tremer <michael.tremer@ipfire.org>

diff --git a/src/libpakfire/include/pakfire/mount.h b/src/libpakfire/include/pakfire/mount.h
index dfaac970beb88b0cee8962f856cf68f58ece2fd5..6e90a93b9e1c2993363ca70baecf4f7929298546 100644 (file)
--- a/src/libpakfire/include/pakfire/mount.h
+++ b/src/libpakfire/include/pakfire/mount.h
@@ -31,29 +31,25 @@ typedef enum pakfire_mntns {
        PAKFIRE_MNTNS_OUTER = (2 << 0),
 } pakfire_mntns_t;
 
-int pakfire_mount_change_propagation(struct pakfire_ctx* ctx, const char* path, int propagation);
+int pakfire_mount_change_propagation(struct pakfire* pakfire, const char* path, int propagation);
 
-int pakfire_mount_make_mounpoint(struct pakfire_ctx* ctx,
-       struct pakfire* pakfire, const char* path);
+int pakfire_mount_make_mounpoint(struct pakfire* pakfire, const char* path);
 
-int pakfire_make_ramdisk(struct pakfire_ctx* ctx,
-       struct pakfire* pakfire, char* path, const char* args);
+int pakfire_make_ramdisk(struct pakfire* pakfire, char* path, const char* args);
 
-int pakfire_bind(struct pakfire_ctx* ctx, struct pakfire* pakfire,
-       const char* src, const char* dst, int flags);
+int pakfire_bind(struct pakfire* pakfire, const char* src, const char* dst, int flags);
 
-int pakfire_mount_list(struct pakfire_ctx* ctx);
+int pakfire_mount_list(struct pakfire* pakfire);
 
-int pakfire_populate_dev(struct pakfire_ctx* ctx, struct pakfire* pakfire, int flags);
+int pakfire_populate_dev(struct pakfire* pakfire, int flags);
 
-int pakfire_mount_interpreter(struct pakfire_ctx* ctx, struct pakfire* pakfire);
+int pakfire_mount_interpreter(struct pakfire* pakfire);
 
 enum pakfire_mount_flags {
        PAKFIRE_MOUNT_LOOP_DEVICES = (1 << 0),
 };
 
-int pakfire_mount_all(struct pakfire_ctx* ctx, struct pakfire* pakfire,
-       pakfire_mntns_t ns, int flags);
+int pakfire_mount_all(struct pakfire* pakfire, pakfire_mntns_t ns, int flags);
 
 #endif /* PAKFIRE_PRIVATE */
 

diff --git a/src/libpakfire/jail.c b/src/libpakfire/jail.c
index b42c623881813a734bbb9b2db226ae07b18e75a5..64388bab87176567ba57e14e1196af0773c34205 100644 (file)
--- a/src/libpakfire/jail.c
+++ b/src/libpakfire/jail.c
@@ -1680,7 +1680,7 @@ static int pakfire_jail_mount_networking(struct pakfire_jail* jail) {
 
        // Bind-mount all paths read-only
        for (const char** path = paths; *path; path++) {
-               r = pakfire_bind(jail->ctx, jail->pakfire, *path, NULL, MS_RDONLY);
+               r = pakfire_bind(jail->pakfire, *path, NULL, MS_RDONLY);
                if (r) {
                        switch (errno) {
                                // Ignore if we don't have permission
@@ -1710,17 +1710,17 @@ static int pakfire_jail_mount(struct pakfire_jail* jail, struct pakfire_jail_exe
                flags |= PAKFIRE_MOUNT_LOOP_DEVICES;
 
        // Mount all default stuff
-       r = pakfire_mount_all(jail->ctx, jail->pakfire, PAKFIRE_MNTNS_OUTER, flags);
+       r = pakfire_mount_all(jail->pakfire, PAKFIRE_MNTNS_OUTER, flags);
        if (r)
                return r;
 
        // Populate /dev
-       r = pakfire_populate_dev(jail->ctx, jail->pakfire, flags);
+       r = pakfire_populate_dev(jail->pakfire, flags);
        if (r)
                return r;
 
        // Mount the interpreter (if needed)
-       r = pakfire_mount_interpreter(jail->ctx, jail->pakfire);
+       r = pakfire_mount_interpreter(jail->pakfire);
        if (r)
                return r;
 
@@ -1737,7 +1737,7 @@ static int pakfire_jail_mount(struct pakfire_jail* jail, struct pakfire_jail_exe
                mp = &jail->mountpoints[i];
 
                // Mount it
-               r = pakfire_bind(jail->ctx, jail->pakfire, mp->source, mp->target, mp->flags);
+               r = pakfire_bind(jail->pakfire, mp->source, mp->target, mp->flags);
                if (r)
                        return r;
        }
@@ -2129,7 +2129,7 @@ static int pakfire_jail_child(struct pakfire_jail* jail, struct pakfire_jail_exe
        DEBUG(jail->pakfire, "  GID: %u (effective %u)\n", gid, egid);
 
        // Log all mountpoints
-       pakfire_mount_list(jail->ctx);
+       pakfire_mount_list(jail->pakfire);
 
        // Fail if we are not PID 1
        if (pid != 1) {
@@ -2146,7 +2146,7 @@ static int pakfire_jail_child(struct pakfire_jail* jail, struct pakfire_jail_exe
        const int socket_send = pakfire_jail_get_pipe_to_write(jail, &ctx->socket);
 
        // Mount all default stuff
-       r = pakfire_mount_all(jail->ctx, jail->pakfire, PAKFIRE_MNTNS_INNER, 0);
+       r = pakfire_mount_all(jail->pakfire, PAKFIRE_MNTNS_INNER, 0);
        if (r)
                return 126;
 
@@ -2154,17 +2154,17 @@ static int pakfire_jail_child(struct pakfire_jail* jail, struct pakfire_jail_exe
        const char* arch = pakfire_get_effective_arch(jail->pakfire);
 
        // Change mount propagation to slave to receive anything from the parent namespace
-       r = pakfire_mount_change_propagation(jail->ctx, "/", MS_SLAVE);
+       r = pakfire_mount_change_propagation(jail->pakfire, "/", MS_SLAVE);
        if (r)
                return r;
 
        // Make root a mountpoint in the new mount namespace
-       r = pakfire_mount_make_mounpoint(jail->ctx, jail->pakfire, root);
+       r = pakfire_mount_make_mounpoint(jail->pakfire, root);
        if (r)
                return r;
 
        // Change mount propagation to private
-       r = pakfire_mount_change_propagation(jail->ctx, root, MS_PRIVATE);
+       r = pakfire_mount_change_propagation(jail->pakfire, root, MS_PRIVATE);
        if (r)
                return r;
 

diff --git a/src/libpakfire/mount.c b/src/libpakfire/mount.c
index 6bfab280cc93b93952590864faa8994b8ef3ad86..0f7559c25995506a3950fa6885d0e39c6db6a695 100644 (file)
--- a/src/libpakfire/mount.c
+++ b/src/libpakfire/mount.c
@@ -261,12 +261,12 @@ static const struct pakfire_symlink {
        { NULL },
 };
 
-int pakfire_mount_change_propagation(struct pakfire_ctx* ctx, const char* path, int propagation) {
-       CTX_DEBUG(ctx, "Changing mount propagation on %s\n", path);
+int pakfire_mount_change_propagation(struct pakfire* pakfire, const char* path, int propagation) {
+       PAKFIRE_DEBUG(pakfire, "Changing mount propagation on %s\n", path);
 
        int r = mount(NULL, path, NULL, propagation|MS_REC, NULL);
        if (r)
-               CTX_ERROR(ctx, "Failed to change mount propagation on %s: %m\n", path);
+               PAKFIRE_ERROR(pakfire, "Failed to change mount propagation on %s: %m\n", path);
 
        return r;
 }
@@ -276,8 +276,7 @@ static int pakfire_mount_is_mountpoint(struct pakfire* pakfire, const char* path
        return 1;
 }
 
-int pakfire_mount_make_mounpoint(struct pakfire_ctx* ctx, struct pakfire* pakfire,
-               const char* path) {
+int pakfire_mount_make_mounpoint(struct pakfire* pakfire, const char* path) {
        int r;
 
        // Check if path already is a mountpoint
@@ -292,22 +291,22 @@ int pakfire_mount_make_mounpoint(struct pakfire_ctx* ctx, struct pakfire* pakfir
                        break;
 
                default:
-                       CTX_ERROR(ctx, "Could not determine whether %s is a mountpoint: %m\n", path);
+                       PAKFIRE_ERROR(pakfire, "Could not determine whether %s is a mountpoint: %m\n", path);
                        return r;
        }
 
        // Bind-mount to self
        r = mount(path, path, NULL, MS_BIND|MS_REC, NULL);
        if (r) {
-               CTX_ERROR(ctx, "Could not make %s a mountpoint: %m\n", path);
+               PAKFIRE_ERROR(pakfire, "Could not make %s a mountpoint: %m\n", path);
                return r;
        }
 
        return 0;
 }
 
-static int pakfire_mount(struct pakfire_ctx* ctx, struct pakfire* pakfire, const char* source,
-               const char* target, const char* fstype, unsigned long mflags, const void* data) {
+static int pakfire_mount(struct pakfire* pakfire, const char* source, const char* target,
+               const char* fstype, unsigned long mflags, const void* data) {
        const char* options = (const char*)data;
 
        // Check for some basic inputs
@@ -316,38 +315,38 @@ static int pakfire_mount(struct pakfire_ctx* ctx, struct pakfire* pakfire, const
                return 1;
        }
 
-       CTX_DEBUG(ctx, "Mounting %s from %s (%s - %s)\n", target, source, fstype, options);
+       PAKFIRE_DEBUG(pakfire, "Mounting %s from %s (%s - %s)\n", target, source, fstype, options);
 
        // Perform mount()
        int r = mount(source, target, fstype, mflags, data);
        if (r) {
-               CTX_ERROR(ctx, "Could not mount %s: %m\n", target);
+               PAKFIRE_ERROR(pakfire, "Could not mount %s: %m\n", target);
        }
 
        return r;
 }
 
 static int __pakfire_mount_list(char* line, size_t length, void* data) {
-       struct pakfire_ctx* ctx = data;
+       struct pakfire* pakfire = data;
 
        // Send the line to the logger
-       CTX_DEBUG(ctx, "  %.*s", (int)length, line);
+       PAKFIRE_DEBUG(pakfire, "  %.*s", (int)length, line);
 
        return 0;
 }
 
-int pakfire_mount_list(struct pakfire_ctx* ctx) {
-       CTX_DEBUG(ctx, "Mountpoints:\n");
+int pakfire_mount_list(struct pakfire* pakfire) {
+       PAKFIRE_DEBUG(pakfire, "Mountpoints:\n");
 
-       return pakfire_parse_file("/proc/self/mounts", __pakfire_mount_list, ctx);
+       return pakfire_parse_file("/proc/self/mounts", __pakfire_mount_list, pakfire);
 }
 
-int pakfire_populate_dev(struct pakfire_ctx* ctx, struct pakfire* pakfire, int flags) {
+int pakfire_populate_dev(struct pakfire* pakfire, int flags) {
        char path[PATH_MAX];
 
        // Create device nodes
        for (const struct pakfire_devnode* devnode = devnodes; devnode->path; devnode++) {
-               CTX_DEBUG(ctx, "Creating device node %s\n", devnode->path);
+               PAKFIRE_DEBUG(pakfire, "Creating device node %s\n", devnode->path);
 
                // Check if flags match
                if (devnode->flags && !(flags & devnode->flags))
@@ -372,26 +371,26 @@ int pakfire_populate_dev(struct pakfire_ctx* ctx, struct pakfire* pakfire, int f
                        goto MOUNT;
 
                // Otherwise log an error and end
-               CTX_ERROR(ctx, "Could not create %s: %m\n", devnode->path);
+               PAKFIRE_ERROR(pakfire, "Could not create %s: %m\n", devnode->path);
                return r;
 
 MOUNT:
                // Create an empty file
                r = pakfire_touch(path, 0444);
                if (r) {
-                       CTX_ERROR(ctx, "Could not create %s: %m\n", path);
+                       PAKFIRE_ERROR(pakfire, "Could not create %s: %m\n", path);
                        return r;
                }
 
                // Create a bind-mount over the file
-               r = pakfire_mount(ctx, pakfire, devnode->path, path, "bind", MS_BIND, NULL);
+               r = pakfire_mount(pakfire, devnode->path, path, "bind", MS_BIND, NULL);
                if (r)
                        return r;
        }
 
        // Create symlinks
        for (const struct pakfire_symlink* s = symlinks; s->target; s++) {
-               CTX_DEBUG(ctx, "Creating symlink %s -> %s\n", s->path, s->target);
+               PAKFIRE_DEBUG(pakfire, "Creating symlink %s -> %s\n", s->path, s->target);
 
                int r = pakfire_path(pakfire, path, "%s", s->path);
                if (r)
@@ -399,7 +398,7 @@ MOUNT:
 
                r = symlink(s->target, path);
                if (r) {
-                       CTX_ERROR(ctx, "Could not create symlink %s: %m\n", s->path);
+                       PAKFIRE_ERROR(pakfire, "Could not create symlink %s: %m\n", s->path);
                        return r;
                }
        }
@@ -407,7 +406,7 @@ MOUNT:
        return 0;
 }
 
-int pakfire_mount_interpreter(struct pakfire_ctx* ctx, struct pakfire* pakfire) {
+int pakfire_mount_interpreter(struct pakfire* pakfire) {
        char target[PATH_MAX];
 
        // Fetch the target architecture
@@ -420,7 +419,7 @@ int pakfire_mount_interpreter(struct pakfire_ctx* ctx, struct pakfire* pakfire)
        if (!interpreter)
                return 0;
 
-       CTX_DEBUG(ctx, "Mounting interpreter %s for %s\n", interpreter, arch);
+       PAKFIRE_DEBUG(pakfire, "Mounting interpreter %s for %s\n", interpreter, arch);
 
        // Where to mount this?
        int r = pakfire_path(pakfire, target, "%s", interpreter);
@@ -438,14 +437,14 @@ int pakfire_mount_interpreter(struct pakfire_ctx* ctx, struct pakfire* pakfire)
                return 1;
        fclose(f);
 
-       r = pakfire_mount(ctx, pakfire, interpreter, target, NULL, MS_BIND|MS_RDONLY, NULL);
+       r = pakfire_mount(pakfire, interpreter, target, NULL, MS_BIND|MS_RDONLY, NULL);
        if (r)
-               CTX_ERROR(ctx, "Could not mount interpreter %s to %s: %m\n", interpreter, target);
+               PAKFIRE_ERROR(pakfire, "Could not mount interpreter %s to %s: %m\n", interpreter, target);
 
        return r;
 }
 
-int pakfire_mount_all(struct pakfire_ctx* ctx, struct pakfire* pakfire, pakfire_mntns_t ns, int flags) {
+int pakfire_mount_all(struct pakfire* pakfire, pakfire_mntns_t ns, int flags) {
        char target[PATH_MAX];
        int r;
 
@@ -468,14 +467,13 @@ int pakfire_mount_all(struct pakfire_ctx* ctx, struct pakfire* pakfire, pakfire_
                if (!pakfire_path_exists(target)) {
                        r = pakfire_mkdir(target, 0755);
                        if (r) {
-                               CTX_ERROR(ctx, "Could not create %s: %m\n", target);
+                               PAKFIRE_ERROR(pakfire, "Could not create %s: %m\n", target);
                                return r;
                        }
                }
 
                // Perform mount()
-               r = pakfire_mount(ctx, pakfire, mp->source, target,
-                       mp->fstype, mp->flags, mp->options);
+               r = pakfire_mount(pakfire, mp->source, target, mp->fstype, mp->flags, mp->options);
                if (r)
                        return r;
        }
@@ -483,8 +481,7 @@ int pakfire_mount_all(struct pakfire_ctx* ctx, struct pakfire* pakfire, pakfire_
        return 0;
 }
 
-int pakfire_make_ramdisk(struct pakfire_ctx* ctx, struct pakfire* pakfire,
-               char* path, const char* args) {
+int pakfire_make_ramdisk(struct pakfire* pakfire, char* path, const char* args) {
        int r;
 
        // Create a new temporary directory
@@ -493,20 +490,19 @@ int pakfire_make_ramdisk(struct pakfire_ctx* ctx, struct pakfire* pakfire,
                return -errno;
 
        // Mount the ramdisk
-       r = pakfire_mount(ctx, pakfire, "pakfire_ramdisk", p, "tmpfs", 0, args);
+       r = pakfire_mount(pakfire, "pakfire_ramdisk", p, "tmpfs", 0, args);
        if (r) {
-               CTX_ERROR(ctx, "Could not mount ramdisk at %s (%s): %s\n",
+               PAKFIRE_ERROR(pakfire, "Could not mount ramdisk at %s (%s): %s\n",
                        p, args, strerror(errno));
                return r;
        }
 
-       CTX_DEBUG(ctx, "Ramdisk mounted at %s (%s)\n", p, args);
+       PAKFIRE_DEBUG(pakfire, "Ramdisk mounted at %s (%s)\n", p, args);
 
        return 0;
 }
 
-int pakfire_bind(struct pakfire_ctx* ctx, struct pakfire* pakfire,
-               const char* src, const char* dst, int flags) {
+int pakfire_bind(struct pakfire* pakfire, const char* src, const char* dst, int flags) {
        struct stat st;
        char mountpoint[PATH_MAX];
 
@@ -517,11 +513,11 @@ int pakfire_bind(struct pakfire_ctx* ctx, struct pakfire* pakfire,
        if (r)
                return r;
 
-       CTX_DEBUG(ctx, "Bind-mounting %s to %s\n", src, mountpoint);
+       PAKFIRE_DEBUG(pakfire, "Bind-mounting %s to %s\n", src, mountpoint);
 
        r = stat(src, &st);
        if (r < 0) {
-               CTX_ERROR(ctx, "Could not stat %s: %m\n", src);
+               PAKFIRE_ERROR(pakfire, "Could not stat %s: %m\n", src);
                return 1;
        }
 
@@ -556,7 +552,7 @@ int pakfire_bind(struct pakfire_ctx* ctx, struct pakfire* pakfire,
        // as read-only and requires us to mount the source first, and then remount it
        // again using MS_RDONLY.
        if (flags & MS_RDONLY) {
-               r = pakfire_mount(ctx, pakfire, src, mountpoint, "bind", MS_BIND|MS_REC, NULL);
+               r = pakfire_mount(pakfire, src, mountpoint, "bind", MS_BIND|MS_REC, NULL);
                if (r)
                        return r;
 
@@ -565,5 +561,5 @@ int pakfire_bind(struct pakfire_ctx* ctx, struct pakfire* pakfire,
        }
 
        // Perform mount
-       return pakfire_mount(ctx, pakfire, src, mountpoint, "bind", flags|MS_BIND|MS_REC, NULL);
+       return pakfire_mount(pakfire, src, mountpoint, "bind", flags|MS_BIND|MS_REC, NULL);
 }

diff --git a/src/libpakfire/pakfire.c b/src/libpakfire/pakfire.c
index fd674e113d045666c1a75385e4c033bb6a30d225..b82dc4e06e216e0c0938759237126685cca421b6 100644 (file)
--- a/src/libpakfire/pakfire.c
+++ b/src/libpakfire/pakfire.c
@@ -814,7 +814,7 @@ PAKFIRE_EXPORT int pakfire_create(struct pakfire** pakfire, struct pakfire_ctx*
 
        // Create a ramdisk if no path was given
        if (!path) {
-               r = pakfire_make_ramdisk(p->ctx, p, tempdir, NULL);
+               r = pakfire_make_ramdisk(p, tempdir, NULL);
                if (r)
                        goto ERROR;