Skip to contentSkip to conversation

user-cr: Add UTS support

PATCH New Dan Smith 1 participant 3 messages Mar 23, 2009 1 message not in the archive

lore
Share & tools
lore

Dan Smith

author
#0 lore raw

This is the latest version of the UTS change to mktree.c and the matching test program. It also includes the bits necessary to read and consume the IPC namespace record so that the resulting stream is able to be fed to the kernel.

A message that is not in the archive (sent off-list or not yet received): 1237836868-20452-1-git-send-email-danms-r/[email protected]

author
#2 lore raw

PATCH 1/2 Add UTS support to mktree (v5)

Read the namespace records from the restore stream and do the unshare() necessary to create a new namespace. For UTS, set hostname and domainname to match what was stored in the checkpoint.

Changes:
- Check return of sethostname() and setdomainname()
- Update to match new struct name and header type to kernel patch
- Update the method used to read the node and domain names to match what the updated kernel patch is doing
- Change the logic used to detect when we need to do an unshare() to track the objref of the namespace (and bail if nested for now)
- Add stubs for IPC namespace records

---
 mktree.c |  163 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 163 insertions(+), 0 deletions(-)
mktree.c +163 -0
index 55149dd..2a0cbae 100644
@@ -14,6 +14,7 @@
 #include <unistd.h>
 #include <errno.h>
 #include <signal.h>
+#include <sched.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <asm/unistd.h>
@@ -79,6 +80,10 @@ struct cr_ctx {
 	char tree[BUFSIZE];
 	char buf[BUFSIZE];
 	struct args *args;
+	struct {
+		int uts;
+		int ipc;
+	} ns;
 };
 
 static int cr_make_tree(struct cr_ctx *ctx, pid_t pid, int pos);
@@ -98,9 +103,11 @@ static int cr_write_tree(struct cr_ctx *ctx);
 static int cr_read(int fd, void *buf, int count);
 static int cr_read_obj(struct cr_ctx *ctx, struct cr_hdr *h, void *buf, int n);
 static int cr_read_obj_type(struct cr_ctx *ctx, void *buf, int n, int type);
+static int cr_read_string(struct cr_ctx *ctx, char **buf, int len);
 
 static int cr_read_head(struct cr_ctx *ctx);
 static int cr_read_head_arch(struct cr_ctx *ctx);
+static int cr_read_namespaces(struct cr_ctx *ctx);
 static int cr_read_tree(struct cr_ctx *ctx);
 
 struct pid_swap {
@@ -170,6 +177,7 @@ int main(int argc, char *argv[])
 
 	ctx.init_pid = getpid();
 	ctx.args = &args;
+	ctx.ns.uts = ctx.ns.ipc = -1;
 
 	setpgrp();
 
@@ -191,6 +199,12 @@ int main(int argc, char *argv[])
 		exit(1);
 	}
 
+	ret = cr_read_namespaces(&ctx);
+	if (ret < 0) {
+		perror("read c/r namespaces");
+		exit(1);
+	}
+
 	ret = cr_fork_feeder(&ctx);
 	if (ret < 0)
 		exit(1);
@@ -511,6 +525,30 @@ static int cr_read_obj_type(struct cr_ctx *ctx, void *buf, int n, int type)
 	return ret;
 }
 
+static int cr_read_string(struct cr_ctx *ctx, char **buf, int len)
+{
+	struct cr_hdr *h = (struct cr_hdr *) ctx->buf;
+	int ret;
+
+	ret = cr_read(STDIN_FILENO, h, sizeof(*h));
+	if (ret < 0)
+		return ret;
+	if (h->type != CR_HDR_STRING)
+		return -1;
+
+	*buf = (char *) malloc(len);
+	if (!*buf)
+		return -ENOMEM;
+
+	ret = cr_read(STDIN_FILENO, *buf, len);
+	if (ret < 0) {
+		free(*buf);
+		*buf = NULL;
+	}
+
+	return ret;
+}
+
 /*
  * read/write the checkpoint image: similar to in-kernel code
  */
@@ -557,6 +595,131 @@ static int cr_read_head_arch(struct cr_ctx *ctx)
 	return 0;
 }
 
+static int cr_read_task_utsns(struct cr_ctx *ctx)
+{
+	int parent;
+	struct cr_hdr_utsns hh;
+	char *namebuf = NULL;
+	int ret = 0;
+
+	parent = cr_read_obj_type(ctx, &hh, sizeof(hh), CR_HDR_UTSNS);
+	if (parent < 0)
+		return parent;
+	else if (parent != 0) {
+		errno = -EINVAL;
+		return -1;
+	}
+
+	ret = cr_read_string(ctx, &namebuf, hh.nodename_len);
+	if (ret < 0)
+		goto out;
+
+	if (sethostname(namebuf, strlen(namebuf)) < 0) {
+		perror("sethostname");
+		goto out;
+	}
+
+	free(namebuf);
+	namebuf = NULL;
+
+	ret = cr_read_string(ctx, &namebuf, hh.domainname_len);
+	if (ret < 0)
+		goto out;
+
+	if (setdomainname(namebuf, strlen(namebuf)) < 0)
+		perror("setdomainname");
+ out:
+	free(namebuf);
+
+	return 0;
+}
+
+static int cr_read_task_ipcns(struct cr_ctx *ctx)
+{
+	int parent;
+	struct cr_hdr_ipcns hh;
+
+	parent = cr_read_obj_type(ctx, &hh, sizeof(hh), CR_HDR_IPCNS);
+	if (parent < 0)
+		return parent;
+	else if (parent != 0) {
+		errno = -EINVAL;
+		return -1;
+	}
+
+	return 0;
+}
+
+static int cr_read_task_namespaces(struct cr_ctx *ctx)
+{
+	struct cr_hdr_namespaces hh;
+	int parent;
+	int ret;
+	unsigned long flags = 0;
+
+	parent = cr_read_obj_type(ctx, &hh, sizeof(hh), CR_HDR_NS);
+	if (parent < 0)
+		return parent;
+	else if (parent != 0) {
+		errno = -EINVAL;
+		return -1;
+	}
+
+	if (ctx->ns.uts == -1) {
+		flags |= CLONE_NEWUTS;
+		ctx->ns.uts = hh.uts_ref;
+	} else if (ctx->ns.uts != hh.uts_ref) {
+		cr_dbg("Unsupported nested UTS ns\n");
+		return -1;
+	}
+
+	if (ctx->ns.ipc == -1) {
+		flags |= CLONE_NEWIPC;
+		ctx->ns.ipc = hh.ipc_ref;
+	} else if (ctx->ns.ipc != hh.ipc_ref) {
+		cr_dbg("Unsupported nested IPC ns\n");
+		return -1;
+	}
+
+	if (flags == 0)
+		return 0; /* No unshare() needed here */
+
+	if (unshare(flags) != 0) {
+		perror("unshare()");
+		return -1;
+	}
+
+	if (flags & CLONE_NEWUTS) {
+		ret = cr_read_task_utsns(ctx);
+		if (ret < 0)
+			return ret;
+	}
+
+	if (flags & CLONE_NEWIPC) {
+		ret = cr_read_task_ipcns(ctx);
+		if (ret < 0)
+			return ret;
+	}
+
+	/* Read other namespaces here */
+
+	return 0;
+}
+
+static int cr_read_namespaces(struct cr_ctx *ctx)
+{
+	int n;
+	int ret = 0;
+
+	for (n = 0; n < ctx->pids_nr; n++) {
+		ret = cr_read_task_namespaces(ctx);
+		if (ret < 0)
+			break;
+	}
+
+	return ret;
+}
+
 static int cr_read_tree(struct cr_ctx *ctx)
 {
 	struct cr_hdr *h = (struct cr_hdr *) ctx->buf;
Signature · 1 line
1.5.6.3
author
#3 lore raw

PATCH 2/2 Add a simple UTS test program

In reply to a message not in the archive

This program creates a top-level UTS namespace and then forks a child. The parent sets the hostname to a different value every second and the child prints the value. If the child's value changes with the parent, even after restart, then the pair are running in the same UTS namespace. The test self-checkpoints every iteration.

---
 utstest.c |  114 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 114 insertions(+), 0 deletions(-)
 create mode 100644 utstest.c
utstest.c new file +114 -0
new file mode 100644
index 0000000..1afca49
@@ -0,0 +1,114 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sched.h>
+#include <string.h>
+#include <stdlib.h>
+#include <asm/unistd.h>
+
+#define OUTFILE "/tmp/cr-test.out"
+#define CKPTDIR "/tmp"
+
+int ckpt = 0;
+
+int do_checkpoint(void)
+{
+	char fn[256];
+	int fd;
+	int ret;
+
+	snprintf(fn, sizeof(fn)-1, CKPTDIR "/ckpt-%i", ckpt++);
+
+	fd = open(fn, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+	if (fd < 0) {
+		perror(fn);
+		return -1;
+	}
+
+	ret = syscall(__NR_checkpoint, getpid(), fd, 0);
+	if (ret < 0)
+		printf("Checkpoint to %s returned %i (%m)\n", fn, ret);
+
+	close(fd);
+
+	return ret;
+}
+
+void child(int fd, int subunshare)
+{
+	char hostname[256] = "foo";
+	int ret;
+
+	if (subunshare) {
+		ret = unshare(CLONE_NEWUTS);
+		if (ret) {
+			printf("unshare: %m");
+			exit(1);
+		}
+	}
+
+	while (1) {
+		ret = gethostname(hostname, sizeof(hostname));
+		if (ret) {
+			perror("gethostname");
+			_exit(1);
+		}
+
+		printf("Hostname in child is:  %s\n", hostname);
+		sleep(1);
+	}
+}
+
+int main(int argc, char **argv)
+{
+	int ret;
+	int fd;
+	int i = 0;
+	int subunshare = 0;
+
+#ifndef NOUTS
+	ret = unshare(CLONE_NEWUTS);
+	if (ret) {
+		perror("unshare");
+		return 1;
+	}
+#endif
+
+	/* Pass '-u' to test nested namespace */
+	if ((argc == 2) && (strcmp(argv[1], "-u") == 0))
+		subunshare = 1;
+
+	fd = open(OUTFILE, O_RDWR | O_CREAT | O_TRUNC, 0666);
+	if (fd < 0) {
+		perror(OUTFILE);
+		return 1;
+	}
+
+	dup2(fd, 1);
+	dup2(fd, 2);
+	close(0);
+
+	setlinebuf(stdout);
+	setlinebuf(stderr);
+
+	if (fork() == 0)
+		child(fd, subunshare);
+
+	while (1) {
+#ifndef NOUTS
+		char hostname[256];
+
+		snprintf(hostname, sizeof(hostname)-1, "test%i", i++);
+		ret = sethostname(hostname, strlen(hostname));
+		if (ret) {
+			perror("sethostname");
+			return 1;
+		}
+
+		printf("Hostname in parent is: %s\n", hostname);
+#endif
+		do_checkpoint();
+		sleep(1);
+	}
+}
Signature · 1 line
1.5.6.3