#include <sys/sysmacros.h>
#include <sys/types.h>
-// Enable legacy logging
-#define PAKFIRE_LEGACY_LOGGING
-
#include <pakfire/arch.h>
#include <pakfire/logging.h>
#include <pakfire/pakfire.h>
return 1;
}
-int pakfire_mount_make_mounpoint(struct pakfire* pakfire, const char* path) {
+int pakfire_mount_make_mounpoint(struct pakfire_ctx* ctx, struct pakfire* pakfire,
+ const char* path) {
int r;
// Check if path already is a mountpoint
break;
default:
- ERROR(pakfire, "Could not determine whether %s is a mountpoint: %m\n", path);
+ CTX_ERROR(ctx, "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) {
- ERROR(pakfire, "Could not make %s a mountpoint: %m\n", path);
+ CTX_ERROR(ctx, "Could not make %s a mountpoint: %m\n", path);
return r;
}
return 0;
}
-static int pakfire_mount(struct pakfire* pakfire, const char* source, const char* target,
- const char* fstype, unsigned long mflags, const void* data) {
+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) {
const char* options = (const char*)data;
// Check for some basic inputs
return 1;
}
- DEBUG(pakfire, "Mounting %s from %s (%s - %s)\n", target, source, fstype, options);
+ CTX_DEBUG(ctx, "Mounting %s from %s (%s - %s)\n", target, source, fstype, options);
// Perform mount()
int r = mount(source, target, fstype, mflags, data);
if (r) {
- ERROR(pakfire, "Could not mount %s: %m\n", target);
+ CTX_ERROR(ctx, "Could not mount %s: %m\n", target);
}
return r;
return pakfire_parse_file("/proc/self/mounts", __pakfire_mount_list, ctx);
}
-int pakfire_populate_dev(struct pakfire* pakfire, int flags) {
+int pakfire_populate_dev(struct pakfire_ctx* ctx, struct pakfire* pakfire, int flags) {
char path[PATH_MAX];
// Create device nodes
for (const struct pakfire_devnode* devnode = devnodes; devnode->path; devnode++) {
- DEBUG(pakfire, "Creating device node %s\n", devnode->path);
+ CTX_DEBUG(ctx, "Creating device node %s\n", devnode->path);
// Check if flags match
if (devnode->flags && !(flags & devnode->flags))
goto MOUNT;
// Otherwise log an error and end
- ERROR(pakfire, "Could not create %s: %m\n", devnode->path);
+ CTX_ERROR(ctx, "Could not create %s: %m\n", devnode->path);
return r;
MOUNT:
// Create an empty file
r = pakfire_touch(path, 0444);
if (r) {
- ERROR(pakfire, "Could not create %s: %m\n", path);
+ CTX_ERROR(ctx, "Could not create %s: %m\n", path);
return r;
}
// Create a bind-mount over the file
- r = pakfire_mount(pakfire, devnode->path, path, "bind", MS_BIND, NULL);
+ r = pakfire_mount(ctx, pakfire, devnode->path, path, "bind", MS_BIND, NULL);
if (r)
return r;
}
// Create symlinks
for (const struct pakfire_symlink* s = symlinks; s->target; s++) {
- DEBUG(pakfire, "Creating symlink %s -> %s\n", s->path, s->target);
+ CTX_DEBUG(ctx, "Creating symlink %s -> %s\n", s->path, s->target);
int r = pakfire_path(pakfire, path, "%s", s->path);
if (r)
r = symlink(s->target, path);
if (r) {
- ERROR(pakfire, "Could not create symlink %s: %m\n", s->path);
+ CTX_ERROR(ctx, "Could not create symlink %s: %m\n", s->path);
return r;
}
}
return 0;
}
-int pakfire_mount_interpreter(struct pakfire* pakfire) {
+int pakfire_mount_interpreter(struct pakfire_ctx* ctx, struct pakfire* pakfire) {
char target[PATH_MAX];
// Fetch the target architecture
if (!interpreter)
return 0;
- DEBUG(pakfire, "Mounting interpreter %s for %s\n", interpreter, arch);
+ CTX_DEBUG(ctx, "Mounting interpreter %s for %s\n", interpreter, arch);
// Where to mount this?
int r = pakfire_path(pakfire, target, "%s", interpreter);
return 1;
fclose(f);
- r = pakfire_mount(pakfire, interpreter, target, NULL, MS_BIND|MS_RDONLY, NULL);
+ r = pakfire_mount(ctx, pakfire, interpreter, target, NULL, MS_BIND|MS_RDONLY, NULL);
if (r)
- ERROR(pakfire, "Could not mount interpreter %s to %s: %m\n", interpreter, target);
+ CTX_ERROR(ctx, "Could not mount interpreter %s to %s: %m\n", interpreter, target);
return r;
}
-int pakfire_mount_all(struct pakfire* pakfire, pakfire_mntns_t ns, int flags) {
+int pakfire_mount_all(struct pakfire_ctx* ctx, struct pakfire* pakfire, pakfire_mntns_t ns, int flags) {
char target[PATH_MAX];
int r;
if (!pakfire_path_exists(target)) {
r = pakfire_mkdir(target, 0755);
if (r) {
- ERROR(pakfire, "Could not create %s: %m\n", target);
+ CTX_ERROR(ctx, "Could not create %s: %m\n", target);
return r;
}
}
// Perform mount()
- r = pakfire_mount(pakfire, mp->source, target, mp->fstype, mp->flags, mp->options);
+ r = pakfire_mount(ctx, pakfire, mp->source, target,
+ mp->fstype, mp->flags, mp->options);
if (r)
return r;
}
return 0;
}
-int pakfire_make_ramdisk(struct pakfire* pakfire, char* path, const char* args) {
+int pakfire_make_ramdisk(struct pakfire_ctx* ctx, struct pakfire* pakfire,
+ char* path, const char* args) {
int r;
// Create a new temporary directory
return -errno;
// Mount the ramdisk
- r = pakfire_mount(pakfire, "pakfire_ramdisk", p, "tmpfs", 0, args);
+ r = pakfire_mount(ctx, pakfire, "pakfire_ramdisk", p, "tmpfs", 0, args);
if (r) {
- ERROR_ERRNO(pakfire, r, "Could not mount ramdisk at %s (%s): %m\n", p, args);
+ CTX_ERROR(ctx, "Could not mount ramdisk at %s (%s): %s\n",
+ p, args, strerror(errno));
return r;
}
- DEBUG(pakfire, "Ramdisk mounted at %s (%s)\n", p, args);
+ CTX_DEBUG(ctx, "Ramdisk mounted at %s (%s)\n", p, args);
return 0;
}
-int pakfire_bind(struct pakfire* pakfire, const char* src, const char* dst, int flags) {
+int pakfire_bind(struct pakfire_ctx* ctx, struct pakfire* pakfire,
+ const char* src, const char* dst, int flags) {
struct stat st;
char mountpoint[PATH_MAX];
if (r)
return r;
- DEBUG(pakfire, "Bind-mounting %s to %s\n", src, mountpoint);
+ CTX_DEBUG(ctx, "Bind-mounting %s to %s\n", src, mountpoint);
r = stat(src, &st);
if (r < 0) {
- ERROR(pakfire, "Could not stat %s: %m\n", src);
+ CTX_ERROR(ctx, "Could not stat %s: %m\n", src);
return 1;
}
// 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(pakfire, src, mountpoint, "bind", MS_BIND|MS_REC, NULL);
+ r = pakfire_mount(ctx, pakfire, src, mountpoint, "bind", MS_BIND|MS_REC, NULL);
if (r)
return r;
}
// Perform mount
- return pakfire_mount(pakfire, src, mountpoint, "bind", flags|MS_BIND|MS_REC, NULL);
+ return pakfire_mount(ctx, pakfire, src, mountpoint, "bind", flags|MS_BIND|MS_REC, NULL);
}
projects / people / ms / pakfire.git / blobdiff