fs: add symlink and readlink support

index 8ab1a3a..dc9deae 100644
@@ -890,6 +890,64 @@ int close(int fd)
 }
 EXPORT_SYMBOL(close);
 
+int readlink(const char *pathname, char *buf, size_t bufsiz)
+{
+	struct fs_driver_d *fsdrv;
+	struct fs_device_d *fsdev;
+	char *p = normalise_path(pathname);
+	char *freep = p;
+	int ret;
+	size_t len = 0;
+	char tmp[PATH_MAX];
+
+	memset(tmp, 0, PATH_MAX);
+
+	buf[0] = 0;
+
+	ret = path_check_prereq(pathname, S_IFLNK);
+	if (ret)
+		goto out;
+
+	fsdev = get_fs_device_and_root_path(&p);
+	if (!fsdev) {
+		ret = -ENODEV;
+		goto out;
+	}
+	fsdrv = fsdev->driver;
+
+	len = min(bufsiz, (size_t)(PATH_MAX - 1));
+	if (fsdrv->readlink)
+		ret = fsdrv->readlink(&fsdev->dev, p, tmp, len);
+	else
+		ret = -ENOSYS;
+
+	if (ret)
+		goto out;
+
+	if (tmp[0] == '/') {
+		int l = strlen(fsdev->path);
+
+		if (fsdev->path[l - 1] == '/')
+			l--;
+
+		if (l) {
+			len -= l;
+			strncat(buf, fsdev->path, l);
+		}
+	}
+
+	strncat(buf, tmp, len);
+
+out:
+	free(freep);
+
+	if (ret)
+		errno = -ret;
+
+	return ret;
+}
+EXPORT_SYMBOL(readlink);
+
 static int fs_match(struct device_d *dev, struct driver_d *drv)
 {
 	return strcmp(dev->name, drv->name) ? -1 : 0;

index 22470e6..96fe9be 100644
@@ -51,6 +51,9 @@ struct fs_driver_d {
 	/* Truncate a file to given size */
 	int (*truncate)(struct device_d *dev, FILE *f, ulong size);
 
+	int (*readlink)(struct device_d *dev, const char *pathname, char *name,
+			size_t size);
+
 	int (*open)(struct device_d *dev, FILE *f, const char *pathname);
 	int (*close)(struct device_d *dev, FILE *f);
 	int (*read)(struct device_d *dev, FILE *f, void *buf, size_t size);

@@ -129,6 +132,8 @@ DIR *opendir(const char *pathname);
 struct dirent *readdir(DIR *dir);
 int closedir(DIR *dir);
 
+int readlink(const char *path, char *buf, size_t bufsiz);
+
 int mount (const char *device, const char *fsname, const char *path);
 int umount(const char *pathname);
 

index dc9deae..f357a98 100644
@@ -392,7 +392,7 @@ static int path_check_prereq(const char *path, unsigned int flags)
 	unsigned int m;
 	int ret = 0;
 
-	if (stat(path, &s)) {
+	if (lstat(path, &s)) {
 		if (flags & S_UB_DOES_NOT_EXIST)
 			goto out;
 		ret = -ENOENT;

@@ -434,7 +434,7 @@ static int parent_check_directory(const char *path)
 	int ret;
 	char *dir = dirname(xstrdup(path));
 
-	ret = stat(dir, &s);
+	ret = lstat(dir, &s);
 
 	free(dir);
 

@@ -523,7 +523,7 @@ int open(const char *pathname, int flags, ...)
 	char *freep = path;
 	int ret;
 
-	exist_err = stat(path, &s);
+	exist_err = lstat(path, &s);
 
 	if (!exist_err && S_ISDIR(s.st_mode)) {
 		ret = -EISDIR;

@@ -1216,7 +1216,7 @@ int closedir(DIR *dir)
 }
 EXPORT_SYMBOL(closedir);
 
-int stat(const char *filename, struct stat *s)
+int lstat(const char *filename, struct stat *s)
 {
 	struct device_d *dev;
 	struct fs_driver_d *fsdrv;

@@ -1255,7 +1255,7 @@ out:
 
 	return ret;
 }
-EXPORT_SYMBOL(stat);
+EXPORT_SYMBOL(lstat);
 
 int mkdir (const char *pathname, mode_t mode)
 {

index 96fe9be..4316d68 100644
@@ -109,7 +109,11 @@ int creat(const char *pathname, mode_t mode);
 int unlink(const char *pathname);
 int close(int fd);
 int flush(int fd);
-int stat(const char *filename, struct stat *s);
+int lstat(const char *filename, struct stat *s);
+static inline int stat(const char *filename, struct stat *s)
+{
+	return lstat(filename, s);
+}
 int read(int fd, void *buf, size_t count);
 int ioctl(int fd, int request, void *buf);
 ssize_t write(int fd, const void *buf, size_t count);

index f357a98..291e879 100644
@@ -948,6 +948,50 @@ out:
 }
 EXPORT_SYMBOL(readlink);
 
+int symlink(const char *pathname, const char *newpath)
+{
+	struct fs_driver_d *fsdrv;
+	struct fs_device_d *fsdev;
+	char *p = normalise_path(pathname);
+	int ret;
+	struct stat s;
+
+	if (!stat(p, &s) && S_ISDIR(s.st_mode)) {
+		ret = -ENOSYS;
+		goto out;
+	}
+
+	free(p);
+	p = normalise_path(newpath);
+
+	ret = stat(p, &s);
+	if (!ret) {
+		ret = -EEXIST;
+		goto out;
+	}
+
+	fsdev = get_fs_device_and_root_path(&p);
+	if (!fsdev) {
+		ret = -ENODEV;
+		goto out;
+	}
+	fsdrv = fsdev->driver;
+
+	if (fsdrv->symlink) {
+		ret = fsdrv->symlink(&fsdev->dev, pathname, p);
+	} else {
+		ret = -EPERM;
+	}
+
+out:
+	free(p);
+	if (ret)
+		errno = -ret;
+
+	return ret;
+}
+EXPORT_SYMBOL(symlink);
+
 static int fs_match(struct device_d *dev, struct driver_d *drv)
 {
 	return strcmp(dev->name, drv->name) ? -1 : 0;

index 4316d68..4f7a158 100644
@@ -51,6 +51,8 @@ struct fs_driver_d {
 	/* Truncate a file to given size */
 	int (*truncate)(struct device_d *dev, FILE *f, ulong size);
 
+	int (*symlink)(struct device_d *dev, const char *pathname,
+		       const char *newpath);
 	int (*readlink)(struct device_d *dev, const char *pathname, char *name,
 			size_t size);
 

@@ -136,6 +138,7 @@ DIR *opendir(const char *pathname);
 struct dirent *readdir(DIR *dir);
 int closedir(DIR *dir);
 
+int symlink(const char *pathname, const char *newpath);
 int readlink(const char *path, char *buf, size_t bufsiz);
 
 int mount (const char *device, const char *fsname, const char *path);

index 291e879..e31065f 100644
@@ -26,6 +26,7 @@
 #include <errno.h>
 #include <malloc.h>
 #include <linux/stat.h>
+#include <linux/err.h>
 #include <fcntl.h>
 #include <xfuncs.h>
 #include <init.h>

@@ -111,6 +112,58 @@ static int init_cwd(void)
 
 postcore_initcall(init_cwd);
 
+char *normalise_link(const char *pathname, const char *symlink)
+{
+	const char *buf = symlink;
+	char *path_free, *path;
+	char *absolute_path;
+	int point = 0;
+	int dir = 1;
+	int len;
+
+	if (symlink[0] == '/')
+		return strdup(symlink);
+
+	path = path_free = strdup(pathname);
+
+	while (*buf == '.' || *buf == '/') {
+		if (*buf == '.') {
+			point++;
+		} else if (*buf == '/') {
+			point = 0;
+			dir++;
+		}
+		if (point > 2) {
+			buf -= 2;
+			break;
+		}
+		buf++;
+	}
+
+	while(dir) {
+		path = dirname(path);
+		dir--;
+	}
+
+	len = strlen(buf) + strlen(path) + 1;
+	if (buf[0] != '/')
+		len++;
+
+	absolute_path = calloc(sizeof(char), len);
+
+	if (!absolute_path)
+		return NULL;
+
+	strcat(absolute_path, path);
+	if (buf[0] != '/')
+		strcat(absolute_path, "/");
+	strcat(absolute_path, buf);
+
+	free(path_free);
+
+	return absolute_path;
+}
+
 char *normalise_path(const char *pathname)
 {
 	char *path = xzalloc(strlen(pathname) + strlen(cwd) + 2);

@@ -512,6 +565,42 @@ out:
 }
 EXPORT_SYMBOL(unlink);
 
+static char* realfile(const char *pathname, struct stat *s)
+{
+	char *path = normalise_path(pathname);
+	int ret;
+
+	ret = lstat(path, s);
+	if (ret)
+		goto out;
+
+	if (S_ISLNK(s->st_mode)) {
+		char tmp[PATH_MAX];
+		char *new_path;
+
+		memset(tmp, 0, PATH_MAX);
+
+		ret = readlink(path, tmp, PATH_MAX - 1);
+		if (ret < 0)
+			goto out;
+
+		new_path = normalise_link(path, tmp);
+		free(path);
+		if (!new_path)
+			return ERR_PTR(-ENOMEM);
+		path = new_path;
+
+		ret = lstat(path, s);
+	}
+
+	if (!ret)
+		return path;
+
+out:
+	free(path);
+	return ERR_PTR(ret);
+}
+
 int open(const char *pathname, int flags, ...)
 {
 	struct fs_device_d *fsdev;

@@ -1260,6 +1349,19 @@ int closedir(DIR *dir)
 }
 EXPORT_SYMBOL(closedir);
 
+int stat(const char *filename, struct stat *s)
+{
+	char *f;
+
+	f = realfile(filename, s);
+	if (IS_ERR(f))
+		return PTR_ERR(f);
+
+	free(f);
+	return 0;
+}
+EXPORT_SYMBOL(stat);
+
 int lstat(const char *filename, struct stat *s)
 {
 	struct device_d *dev;

index 4f7a158..ae6c464 100644
@@ -112,10 +112,7 @@ int unlink(const char *pathname);
 int close(int fd);
 int flush(int fd);
 int lstat(const char *filename, struct stat *s);
-static inline int stat(const char *filename, struct stat *s)
-{
-	return lstat(filename, s);
-}
+int stat(const char *filename, struct stat *s);
 int read(int fd, void *buf, size_t count);
 int ioctl(int fd, int request, void *buf);
 ssize_t write(int fd, const void *buf, size_t count);

@@ -174,6 +171,7 @@ void *read_file(const char *filename, size_t *size);
  * of "..", "." and double slashes. The returned string must be freed wit free().
  */
 char *normalise_path(const char *path);
+char *normalise_link(const char *pathname, const char* symlink);
 
 /* Register a new filesystem driver */
 int register_fs_driver(struct fs_driver_d *fsdrv);

index e31065f..6da2ef8 100644
@@ -606,13 +606,20 @@ int open(const char *pathname, int flags, ...)
 	struct fs_device_d *fsdev;
 	struct fs_driver_d *fsdrv;
 	FILE *f;
-	int exist_err;
+	int exist_err = 0;
 	struct stat s;
-	char *path = normalise_path(pathname);
-	char *freep = path;
+	char *path;
+	char *freep;
 	int ret;
 
-	exist_err = lstat(path, &s);
+	path = realfile(pathname, &s);
+
+	if (IS_ERR(path)) {
+		exist_err = PTR_ERR(path);
+		path = normalise_path(pathname);
+	}
+
+	freep = path;
 
 	if (!exist_err && S_ISDIR(s.st_mode)) {
 		ret = -EISDIR;

index 6da2ef8..0f49993 100644
@@ -240,6 +240,15 @@ static struct fs_device_d *get_fsdevice_by_path(const char *path)
 	return fs_dev_root;
 }
 
+char *get_mounted_path(const char *path)
+{
+	struct fs_device_d *fdev;
+
+	fdev = get_fsdevice_by_path(path);
+
+	return fdev->path;
+}
+
 static FILE files[MAX_FILES];
 
 static FILE *get_file(void)

index ae6c464..3d5714c 100644
@@ -173,6 +173,8 @@ void *read_file(const char *filename, size_t *size);
 char *normalise_path(const char *path);
 char *normalise_link(const char *pathname, const char* symlink);
 
+char *get_mounted_path(const char *path);
+
 /* Register a new filesystem driver */
 int register_fs_driver(struct fs_driver_d *fsdrv);
 

index 91d06b8..beea564 100644
@@ -42,6 +42,7 @@ struct ramfs_inode {
 	struct ramfs_inode *parent;
 	struct ramfs_inode *next;
 	struct ramfs_inode *child;
+	char *symlink;
 	ulong mode;
 
 	struct handle_d *handle;

@@ -176,6 +177,7 @@ static void ramfs_put_inode(struct ramfs_inode *node)
 		data = tmp;
 	}
 
+	free(node->symlink);
 	free(node->name);
 	free(node);
 }

@@ -212,18 +214,36 @@ static struct ramfs_inode* node_insert(struct ramfs_inode *parent_node, const ch
 
 /* ---------------------------------------------------------------*/
 
-static int ramfs_create(struct device_d *dev, const char *pathname, mode_t mode)
+static int __ramfs_create(struct device_d *dev, const char *pathname,
+			  mode_t mode, const char *symlink)
 {
 	struct ramfs_priv *priv = dev->priv;
 	struct ramfs_inode *node;
 	char *file;
 
 	node = rlookup_parent(priv, pathname, &file);
-	if (node) {
-		node_insert(node, file, mode);
+	if (!node)
+		return -ENOENT;
+
+	node = node_insert(node, file, mode);
+	if (!node)
+		return -ENOMEM;
+
+	if (!symlink)
 		return 0;
+
+	node->symlink = strdup(symlink);
+	if (!node->symlink) {
+		ramfs_put_inode(node);
+		return -ENOMEM;
 	}
-	return -ENOENT;
+
+	return 0;
+}
+
+static int ramfs_create(struct device_d *dev, const char *pathname, mode_t mode)
+{
+	return __ramfs_create(dev, pathname, mode, NULL);
 }
 
 static int ramfs_unlink(struct device_d *dev, const char *pathname)

@@ -532,12 +552,37 @@ static int ramfs_stat(struct device_d *dev, const char *filename, struct stat *s
 	if (!node)
 		return -ENOENT;
 
-	s->st_size = node->size;
+	s->st_size = node->symlink ? strlen(node->symlink) : node->size;
 	s->st_mode = node->mode;
 
 	return 0;
 }
 
+static int ramfs_symlink(struct device_d *dev, const char *pathname,
+		       const char *newpath)
+{
+	mode_t mode = S_IFLNK | S_IRWXU | S_IRWXG | S_IRWXO;
+
+	return __ramfs_create(dev, newpath, mode, pathname);
+}
+
+static int ramfs_readlink(struct device_d *dev, const char *pathname,
+			char *buf, size_t bufsiz)
+{
+	struct ramfs_priv *priv = dev->priv;
+	struct ramfs_inode *node = rlookup(priv, pathname);
+	int len;
+
+	if (!node || !node->symlink)
+		return -ENOENT;
+
+	len = min(bufsiz, strlen(node->symlink));
+
+	memcpy(buf, node->symlink, len);
+
+	return 0;
+}
+
 static int ramfs_probe(struct device_d *dev)
 {
 	struct ramfs_inode *n;

@@ -584,6 +629,8 @@ static struct fs_driver_d ramfs_driver = {
 	.readdir   = ramfs_readdir,
 	.closedir  = ramfs_closedir,
 	.stat      = ramfs_stat,
+	.symlink   = ramfs_symlink,
+	.readlink  = ramfs_readlink,
 	.flags     = FS_DRIVER_NO_DEV,
 	.drv = {
 		.probe  = ramfs_probe,

104 lines not on this page · raw message

index 9ffa892..56e8c52 100644
@@ -44,6 +44,7 @@ typedef enum {
 	OPT_FILE,
 	OPT_EXISTS,
 	OPT_MAX,
+	OPT_SYMBOLIC_LINK,
 } test_opts;
 
 static char *test_options[] = {

@@ -62,6 +63,7 @@ static char *test_options[] = {
 	[OPT_FILE]			= "-f",
 	[OPT_DIRECTORY]			= "-d",
 	[OPT_EXISTS]			= "-e",
+	[OPT_SYMBOLIC_LINK]		= "-L",
 };
 
 static int parse_opt(const char *opt)

@@ -140,9 +142,10 @@ static int do_test(int argc, char *argv[])
 		case OPT_FILE:
 		case OPT_DIRECTORY:
 		case OPT_EXISTS:
+		case OPT_SYMBOLIC_LINK:
 			adv = 2;
 			if (ap[1] && *ap[1] != ']' && strlen(ap[1])) {
-				expr = stat(ap[1], &statbuf);
+				expr = (opt == OPT_SYMBOLIC_LINK ? lstat : stat)(ap[1], &statbuf);
 				if (expr < 0) {
 					expr = 0;
 					break;

@@ -160,6 +163,10 @@ static int do_test(int argc, char *argv[])
 					expr = 1;
 					break;
 				}
+				if (opt == OPT_SYMBOLIC_LINK && S_ISLNK(statbuf.st_mode)) {
+					expr = 1;
+					break;
+				}
 			}
 			break;
 

@@ -224,7 +231,7 @@ static const char *test_aliases[] = { "[", NULL};
 
 static const __maybe_unused char cmd_test_help[] =
 "Usage: test [OPTIONS]\n"
-"options: !, =, !=, -eq, -ne, -ge, -gt, -le, -lt, -o, -a, -z, -n, -d, -e, -f\n"
+"options: !, =, !=, -eq, -ne, -ge, -gt, -le, -lt, -o, -a, -z, -n, -d, -e, -f, -L\n"
 "see 'man test' on your PC for more information.\n";
 
 static const __maybe_unused char cmd_test_usage[] = "minimal test like /bin/sh";

80 lines not on this page · raw message

51 lines not on this page · raw message

index fbcbadc..d36ef57 100644
@@ -29,13 +29,24 @@
 #include <getopt.h>
 #include <stringlist.h>
 
-static void ls_one(const char *path, struct stat *s)
+static void ls_one(const char *path, const char* fullname, struct stat *s)
 {
 	char modestr[11];
 	unsigned int namelen = strlen(path);
 
 	mkmodestr(s->st_mode, modestr);
-	printf("%s %10llu %*.*s\n", modestr, s->st_size, namelen, namelen, path);
+	printf("%s %10llu %*.*s", modestr, s->st_size, namelen, namelen, path);
+
+	if (S_ISLNK(s->st_mode)) {
+		char realname[PATH_MAX];
+
+		memset(realname, 0, PATH_MAX);
+
+		if (readlink(fullname, realname, PATH_MAX - 1) >= 0)
+			printf(" -> %s", realname);
+	}
+
+	puts("\n");
 }
 
 int ls(const char *path, ulong flags)

@@ -48,14 +59,14 @@ int ls(const char *path, ulong flags)
 
 	string_list_init(&sl);
 
-	if (stat(path, &s))
+	if (lstat(path, &s))
 		return -errno;
 
 	if (flags & LS_SHOWARG && s.st_mode & S_IFDIR)
 		printf("%s:\n", path);
 
 	if (!(s.st_mode & S_IFDIR)) {
-		ls_one(path, &s);
+		ls_one(path, path, &s);
 		return 0;
 	}
 

@@ -65,12 +76,12 @@ int ls(const char *path, ulong flags)
 
 	while ((d = readdir(dir))) {
 		sprintf(tmp, "%s/%s", path, d->d_name);
-		if (stat(tmp, &s))
+		if (lstat(tmp, &s))
 			goto out;
 		if (flags & LS_COLUMN)
 			string_list_add_sorted(&sl, d->d_name);
 		else
-			ls_one(d->d_name, &s);
+			ls_one(d->d_name, tmp, &s);
 	}
 
 	closedir(dir);

@@ -97,7 +108,7 @@ int ls(const char *path, ulong flags)
 			continue;
 		sprintf(tmp, "%s/%s", path, d->d_name);
 
-		if (stat(tmp, &s))
+		if (lstat(tmp, &s))
 			goto out;
 		if (s.st_mode & S_IFDIR) {
 			char *norm = normalise_path(tmp);

@@ -146,7 +157,7 @@ static int do_ls(int argc, char *argv[])
 
 	/* first pass: all files */
 	while (o < argc) {
-		ret = stat(argv[o], &s);
+		ret = lstat(argv[o], &s);
 		if (ret) {
 			printf("%s: %s: %s\n", argv[0],
 					argv[o], errno_str());

@@ -158,7 +169,7 @@ static int do_ls(int argc, char *argv[])
 			if (flags & LS_COLUMN)
 				string_list_add_sorted(&sl, argv[o]);
 			else
-				ls_one(argv[o], &s);
+				ls_one(argv[o], argv[o], &s);
 		}
 
 		o++;

@@ -173,7 +184,7 @@ static int do_ls(int argc, char *argv[])
 
 	/* second pass: directories */
 	while (o < argc) {
-		ret = stat(argv[o], &s);
+		ret = lstat(argv[o], &s);
 		if (ret) {
 			o++;
 			continue;

index cf1d0a0..f34d88d 100644
@@ -24,20 +24,38 @@
 #include <command.h>
 #include <libgen.h>
 #include <environment.h>
+#include <fs.h>
+#include <getopt.h>
 
 static int do_dirname(int argc, char *argv[])
 {
-	if (argc != 3)
+	int opt;
+	int path_fs = 0;
+	int len = 0;
+
+	while ((opt = getopt(argc, argv, "V")) > 0) {
+		switch (opt) {
+		case 'V':
+			path_fs = 1;
+			break;
+		}
+	}
+
+	if (argc < optind + 2)
 		return COMMAND_ERROR_USAGE;
 
-	setenv(argv[2], dirname(argv[1]));
+	if (path_fs)
+		len = strlen(get_mounted_path(argv[optind]));
+
+	setenv(argv[optind + 1], dirname(argv[optind]) + len);
 
 	return 0;
 }
 
 BAREBOX_CMD_HELP_START(dirname)
-BAREBOX_CMD_HELP_USAGE("dirname NAME DIRNAME\n")
+BAREBOX_CMD_HELP_USAGE("dirname [-V] NAME DIRNAME\n")
 BAREBOX_CMD_HELP_SHORT("strip last componext of NAME and store into $DIRNAME\n")
+BAREBOX_CMD_HELP_SHORT("-V return the path relative to the mountpoint.\n")
 BAREBOX_CMD_HELP_END
 
 BAREBOX_CMD_START(dirname)

index 110e8ec..47b2e08 100644
@@ -14,7 +14,7 @@ char* last_char_is(const char *s, int c);
 
 enum {
 	ACTION_RECURSE     = (1 << 0),
-	/* ACTION_FOLLOWLINKS = (1 << 1), - unused */
+	ACTION_FOLLOWLINKS    = (1 << 1),
 	ACTION_DEPTHFIRST  = (1 << 2),
 	/*ACTION_REVERSE   = (1 << 3), - unused */
 };

index 1ef758d..5bc2595 100644
@@ -54,14 +54,19 @@ int recursive_action(const char *fileName,
 		const unsigned depth)
 {
 	struct stat statbuf;
+	unsigned follow;
 	int status;
 	DIR *dir;
 	struct dirent *next;
 
 	if (!fileAction) fileAction = true_action;
 	if (!dirAction) dirAction = true_action;
-	status = stat(fileName, &statbuf);
 
+	follow = ACTION_FOLLOWLINKS;
+	if (depth == 0)
+		follow = ACTION_FOLLOWLINKS;
+	follow &= flags;
+	status = (follow ? stat : lstat)(fileName, &statbuf);
 	if (status < 0) {
 #ifdef DEBUG_RECURS_ACTION
 		bb_error_msg("status=%d followLinks=%d TRUE=%d",

index 866e345..f7f5351 100644
@@ -73,7 +73,7 @@ char* last_char_is(const char *s, int c)
 
 enum {
 	ACTION_RECURSE     = (1 << 0),
-	/* ACTION_FOLLOWLINKS = (1 << 1), - unused */
+	ACTION_FOLLOWLINKS = (1 << 1),
 	ACTION_DEPTHFIRST  = (1 << 2),
 	/*ACTION_REVERSE   = (1 << 3), - unused */
 };

index 52ce0de..8efed97 100644
@@ -125,6 +125,8 @@ int envfs_save(char *filename, char *dirname)
 
 	super = (struct envfs_super *)buf;
 	super->magic = ENVFS_32(ENVFS_MAGIC);
+	super->major = ENVFS_MAJOR;
+	super->minor = ENVFS_MINOR;
 	super->size = ENVFS_32(size);
 
 	/* second pass: copy files to buffer */

index ba976d6..c6df8c5 100644
@@ -5,6 +5,9 @@
 #include <asm/byteorder.h>
 #endif
 
+#define ENVFS_MAJOR		0
+#define ENVFS_MINOR		1
+
 #define ENVFS_MAGIC		    0x798fba79	/* some random number */
 #define ENVFS_INODE_MAGIC	0x67a8c78d
 #define ENVFS_END_MAGIC		0x6a87d6cd

@@ -29,8 +32,10 @@ struct envfs_super {
 	uint32_t priority;
 	uint32_t crc;			/* crc for the data */
 	uint32_t size;			/* size of data */
+	uint8_t major;			/* major */
+	uint8_t minor;			/* minor */
+	uint16_t future;		/* reserved for future use */
 	uint32_t flags;			/* feature flags */
-	uint32_t future;		/* reserved for future use */
 	uint32_t sb_crc;		/* crc for the superblock */
 };
 

index 8efed97..fc5c57e 100644
@@ -53,6 +53,7 @@ int file_size_action(const char *filename, struct stat *statbuf,
 
 	data->writep += sizeof(struct envfs_inode);
 	data->writep += PAD4(strlen(filename) + 1 - strlen(data->base));
+	data->writep += sizeof(struct envfs_inode_end);
 	data->writep += PAD4(statbuf->st_size);
 	return 1;
 }

@@ -62,6 +63,7 @@ int file_save_action(const char *filename, struct stat *statbuf,
 {
 	struct action_data *data = userdata;
 	struct envfs_inode *inode;
+	struct envfs_inode_end *inode_end;
 	int fd;
 	int namelen = strlen(filename) + 1 - strlen(data->base);
 

@@ -70,12 +72,16 @@ int file_save_action(const char *filename, struct stat *statbuf,
 
 	inode = (struct envfs_inode*)data->writep;
 	inode->magic = ENVFS_32(ENVFS_INODE_MAGIC);
-	inode->namelen = ENVFS_32(namelen);
+	inode->headerlen = ENVFS_32(PAD4(namelen + sizeof(struct envfs_inode_end)));
 	inode->size = ENVFS_32(statbuf->st_size);
 	data->writep += sizeof(struct envfs_inode);
 
 	strcpy(data->writep, filename + strlen(data->base));
 	data->writep += PAD4(namelen);
+	inode_end = (struct envfs_inode_end*)data->writep;
+	data->writep += sizeof(struct envfs_inode_end);
+	inode_end->magic = ENVFS_32(ENVFS_INODE_END_MAGIC);
+	inode_end->mode = ENVFS_32(S_IRWXU | S_IRWXG | S_IRWXO);
 
 	fd = open(filename, O_RDONLY);
 	if (fd < 0) {

@@ -176,8 +182,13 @@ int envfs_load(char *filename, char *dir)
 	int envfd;
 	int fd, ret = 0;
 	char *str, *tmp;
-	int namelen_full;
+	int headerlen_full;
 	unsigned long size;
+	/* for envfs < 1.0 */
+	struct envfs_inode_end inode_end_dummy;
+
+	inode_end_dummy.mode = ENVFS_32(S_IRWXU | S_IRWXG | S_IRWXO);
+	inode_end_dummy.magic = ENVFS_32(ENVFS_INODE_END_MAGIC);
 
 	envfd = open(filename, O_RDONLY);
 	if (envfd < 0) {

@@ -223,11 +234,18 @@ int envfs_load(char *filename, char *dir)
 		goto out;
 	}
 
+	if (super.major < ENVFS_MAJOR)
+		printf("envfs version %d.%d loaded into %d.%d\n",
+			super.major, super.minor,
+			ENVFS_MAJOR, ENVFS_MINOR);
+
 	while (size) {
 		struct envfs_inode *inode;
-		uint32_t inode_size, inode_namelen;
+		struct envfs_inode_end *inode_end;
+		uint32_t inode_size, inode_headerlen, namelen;
 
 		inode = (struct envfs_inode *)buf;
+		buf += sizeof(struct envfs_inode);
 
 		if (ENVFS_32(inode->magic) != ENVFS_INODE_MAGIC) {
 			printf("envfs: wrong magic on %s\n", filename);

@@ -235,16 +253,30 @@ int envfs_load(char *filename, char *dir)
 			goto out;
 		}
 		inode_size = ENVFS_32(inode->size);
-		inode_namelen = ENVFS_32(inode->namelen);
+		inode_headerlen = ENVFS_32(inode->headerlen);
+		namelen = strlen(inode->data) + 1;
+		if (super.major < 1)
+			inode_end = &inode_end_dummy;
+		else
+			inode_end = (struct envfs_inode_end *)(buf + PAD4(namelen));
 
-		debug("loading %s size %d namelen %d\n", inode->data,
-			inode_size, inode_namelen);
+		debug("loading %s size %d namelen %d headerlen %d\n", inode->data,
+			inode_size, namelen, inode_headerlen);
 
 		str = concat_path_file(dir, inode->data);
 		tmp = strdup(str);
 		make_directory(dirname(tmp));
 		free(tmp);
 
+		headerlen_full = PAD4(inode_headerlen);
+		buf += headerlen_full;
+
+		if (ENVFS_32(inode_end->magic) != ENVFS_INODE_END_MAGIC) {
+			printf("envfs: wrong inode_end_magic on %s\n", filename);
+			ret = -EIO;
+			goto out;
+		}
+
 		fd = open(str, O_WRONLY | O_CREAT | O_TRUNC, 0644);
 		free(str);
 		if (fd < 0) {

@@ -253,9 +285,7 @@ int envfs_load(char *filename, char *dir)
 			goto out;
 		}
 
-		namelen_full = PAD4(inode_namelen);
-		ret = write(fd, buf + namelen_full + sizeof(struct envfs_inode),
-				inode_size);
+		ret = write(fd, buf, inode_size);
 		if (ret < inode_size) {
 			perror("write");
 			ret = -errno;

@@ -264,9 +294,8 @@ int envfs_load(char *filename, char *dir)
 		}
 		close(fd);
 
-		buf += PAD4(inode_namelen) + PAD4(inode_size) +
-				sizeof(struct envfs_inode);
-		size -= PAD4(inode_namelen) + PAD4(inode_size) +
+		buf += PAD4(inode_size);
+		size -= headerlen_full + PAD4(inode_size) +
 				sizeof(struct envfs_inode);
 	}
 

index c6df8c5..3d14fcb 100644
@@ -5,18 +5,19 @@
 #include <asm/byteorder.h>
 #endif
 
-#define ENVFS_MAJOR		0
-#define ENVFS_MINOR		1
+#define ENVFS_MAJOR		1
+#define ENVFS_MINOR		0
 
 #define ENVFS_MAGIC		    0x798fba79	/* some random number */
 #define ENVFS_INODE_MAGIC	0x67a8c78d
+#define ENVFS_INODE_END_MAGIC	0x68a8c78d
 #define ENVFS_END_MAGIC		0x6a87d6cd
 #define ENVFS_SIGNATURE	"barebox envfs"
 
 struct envfs_inode {
 	uint32_t magic;	/* ENVFS_INODE_MAGIC */
 	uint32_t size;	/* data size in bytes  */
-	uint32_t namelen; /* The length of the filename _including_ a trailing 0 */
+	uint32_t headerlen; /* The length of the filename _including_ a trailing 0 */
 	char data[0];	/* The filename (zero terminated) + padding to 4 byte boundary
 			 * followed by the data for this inode.
 			 * The next inode follows after the data + padding to 4 byte

@@ -24,6 +25,11 @@ struct envfs_inode {
 			 */
 };
 
+struct envfs_inode_end {
+	uint32_t magic;	/* ENVFS_INODE_END_MAGIC */
+	uint32_t mode;	/* file mode */
+};
+
 /*
  * Superblock information at the beginning of the FS.
  */

index fc5c57e..ce46f4a 100644
@@ -54,7 +54,20 @@ int file_size_action(const char *filename, struct stat *statbuf,
 	data->writep += sizeof(struct envfs_inode);
 	data->writep += PAD4(strlen(filename) + 1 - strlen(data->base));
 	data->writep += sizeof(struct envfs_inode_end);
-	data->writep += PAD4(statbuf->st_size);
+	if (S_ISLNK(statbuf->st_mode)) {
+		char path[PATH_MAX];
+
+		memset(path, 0, PATH_MAX);
+
+		if (readlink(filename, path, PATH_MAX - 1) < 0) {
+			perror("read");
+			return 0;
+		}
+		data->writep += PAD4(strlen(path) + 1);
+	} else {
+		data->writep += PAD4(statbuf->st_size);
+	}
+
 	return 1;
 }
 

@@ -67,13 +80,9 @@ int file_save_action(const char *filename, struct stat *statbuf,
 	int fd;
 	int namelen = strlen(filename) + 1 - strlen(data->base);
 
-	debug("handling file %s size %ld namelen %d\n", filename + strlen(data->base),
-		statbuf->st_size, namelen);
-
 	inode = (struct envfs_inode*)data->writep;
 	inode->magic = ENVFS_32(ENVFS_INODE_MAGIC);
 	inode->headerlen = ENVFS_32(PAD4(namelen + sizeof(struct envfs_inode_end)));
-	inode->size = ENVFS_32(statbuf->st_size);
 	data->writep += sizeof(struct envfs_inode);
 
 	strcpy(data->writep, filename + strlen(data->base));

@@ -83,19 +92,44 @@ int file_save_action(const char *filename, struct stat *statbuf,
 	inode_end->magic = ENVFS_32(ENVFS_INODE_END_MAGIC);
 	inode_end->mode = ENVFS_32(S_IRWXU | S_IRWXG | S_IRWXO);
 
-	fd = open(filename, O_RDONLY);
-	if (fd < 0) {
-		printf("Open %s %s\n", filename, errno_str());
-		goto out;
-	}
+	if (S_ISLNK(statbuf->st_mode)) {
+		char path[PATH_MAX];
+		int len;
 
-	if (read(fd, data->writep, statbuf->st_size) < statbuf->st_size) {
-		perror("read");
-		goto out;
-	}
-	close(fd);
+		memset(path, 0, PATH_MAX);
+
+		if (readlink(filename, path, PATH_MAX - 1) < 0) {
+			perror("read");
+			goto out;
+		}
+		len = strlen(path) + 1;
+
+		inode_end->mode |= ENVFS_32(S_IFLNK);
 
-	data->writep += PAD4(statbuf->st_size);
+		memcpy(data->writep, path, len);
+		inode->size = ENVFS_32(len);
+		data->writep += PAD4(len);
+		debug("handling symlink %s size %ld namelen %d headerlen %d\n", filename + strlen(data->base),
+			len, namelen, ENVFS_32(inode->headerlen));
+	} else {
+		debug("handling file %s size %ld namelen %d headerlen %d\n", filename + strlen(data->base),
+			statbuf->st_size, namelen, ENVFS_32(inode->headerlen));
+
+		inode->size = ENVFS_32(statbuf->st_size);
+		fd = open(filename, O_RDONLY);
+		if (fd < 0) {
+			printf("Open %s %s\n", filename, errno_str());
+			goto out;
+		}
+
+		if (read(fd, data->writep, statbuf->st_size) < statbuf->st_size) {
+			perror("read");
+			goto out;
+		}
+		close(fd);
+
+		data->writep += PAD4(statbuf->st_size);
+	}
 
 out:
 	return 1;

@@ -277,22 +311,31 @@ int envfs_load(char *filename, char *dir)
 			goto out;
 		}
 
-		fd = open(str, O_WRONLY | O_CREAT | O_TRUNC, 0644);
-		free(str);
-		if (fd < 0) {
-			printf("Open %s\n", errno_str());
-			ret = fd;
-			goto out;
-		}
-
-		ret = write(fd, buf, inode_size);
-		if (ret < inode_size) {
-			perror("write");
-			ret = -errno;
+		if (S_ISLNK(ENVFS_32(inode_end->mode))) {
+			debug("symlink: %s -> %s\n", str, (char*)buf);
+			if (symlink((char*)buf, str) < 0) {
+				printf("symlink: %s -> %s :", str, (char*)buf);
+				perror("");
+			}
+			free(str);
+		} else {
+			fd = open(str, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+			free(str);
+			if (fd < 0) {
+				printf("Open %s\n", errno_str());
+				ret = fd;
+				goto out;
+			}
+
+			ret = write(fd, buf, inode_size);
+			if (ret < inode_size) {
+				perror("write");
+				ret = -errno;
+				close(fd);
+				goto out;
+			}
 			close(fd);
-			goto out;
 		}
-		close(fd);
 
 		buf += PAD4(inode_size);
 		size -= headerlen_full + PAD4(inode_size) +

index 05a1b85..53d8316 100644
@@ -1060,17 +1060,24 @@ int symlink(const char *pathname, const char *newpath)
 {
 	struct fs_driver_d *fsdrv;
 	struct fs_device_d *fsdev;
-	char *p = normalise_path(pathname);
+	char *p;
+	char *freep = normalise_path(pathname);
 	int ret;
 	struct stat s;
 
-	if (!stat(p, &s) && S_ISDIR(s.st_mode)) {
+	if (!freep)
+		return -ENOMEM;
+
+	if (!stat(freep, &s) && S_ISDIR(s.st_mode)) {
 		ret = -ENOSYS;
 		goto out;
 	}
 
-	free(p);
-	p = normalise_path(newpath);
+	free(freep);
+	freep = p = normalise_path(newpath);
+
+	if (!p)
+		return -ENOMEM;
 
 	ret = stat(p, &s);
 	if (!ret) {

@@ -1092,7 +1099,7 @@ int symlink(const char *pathname, const char *newpath)
 	}
 
 out:
-	free(p);
+	free(freep);
 	if (ret)
 		errno = -ret;