feat: support jffs2 link/symlink/readlink

新增link/symlink/readlink接口的系统调用及内核实现，当前仅支持jffs2文件系统。具体接口说明如下：

一、hard link
接口原型：
int link(const char *oldpath, const char *newpath);
int linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath, int flags);

作用：
创建oldpath的硬链接，名为newpath。

功能说明：
1、newpath与oldpath必须在同一挂载分区内。
2、若newpath已存在，不会覆盖，错误码EEXIST。
3、oldpath必须为普通文件或者软链接文件。
4、如果oldpath是一个软链接文件，那么：
若调用link接口或者linkat（flags=0），创建出软链接文件的硬链接；
若调用linkat（flags = AT_SYMLINK_FOLLOW），创建出软链接所指向源文件的硬链接。
5、oldpath与newpath对应同一个文件，对oldpath与newpath任一名字的操作都是直接操作文件，没有“原始文件”的说法。
6、使用cp命令拷贝一个硬链接文件，生成文件的拷贝，新文件的nlink数为1。
7、删除oldpath或newpath，底层文件仍存在，可以通过另一个path访问。只有当两个path都删除之后，才会真正将文件删除，空间释放。

二、symbol link
接口原型：
int symlink(const char *target, const char *linkpath);
int symlinkat(const char *target, int newdirfd, const char *linkpath);

作用：
创建一个软链接文件linkpath，存储字符串target。

功能说明：
1、target可以为任意字符串（长度小于PATH_MAX）。
2、若linkpath文件名已存在，不会覆盖，错误码EEXIST。
3、用readlink函数可读取软链接的target内容。
4、软链接文件本身大小为target长度。
5、ls时软链接文件类型显示为 'l'。
6、symlink最大循环次数为CONFIG_FS_MAX_LNK_CNT（目前为40），超出则返回错误，错误码ELOOP。
7、使用cp命令拷贝一个软链接文件：
若target是一个文件：创建一个源文件的拷贝，类型为普通文件；
若target非文件：拷贝失败。

三、readlink
接口原型：
ssize_t readlink(const char *pathname, char *buf, size_t bufsiz);
ssize_t readlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz);

作用：
读取软链接文件存放的的target内容。

功能说明：
1、pathname必须为软链接文件，否则错误码EINVAL。
2、如果bufsiz小于target长度，则截断target。

close #I3Q0OD

Change-Id: I621884b0ec773eb86a7ed3b340d6134cfeb9d971
Signed-off-by: chenjing <chenjing139@huawei.com>

fs/jffs2/dir.c

@@ -104,6 +104,167 @@ int jffs2_link(struct jffs2_inode *old_d_inode, struct jffs2_inode *dir_i, const
 	return ret;
 }
 
+int jffs2_symlink(struct jffs2_inode *dir_i, struct jffs2_inode **d_inode, const unsigned char *d_name, const char *target)
+{
+	struct jffs2_inode_info *f, *dir_f;
+	struct jffs2_sb_info *c;
+	struct jffs2_inode *inode;
+	struct jffs2_raw_inode *ri;
+	struct jffs2_raw_dirent *rd;
+	struct jffs2_full_dnode *fn;
+	struct jffs2_full_dirent *fd;
+	int namelen;
+	uint32_t alloclen;
+	int ret, targetlen = strlen(target);
+
+	/* FIXME: If you care. We'd need to use frags for the target
+	   if it grows much more than this */
+	if (targetlen > 254)
+		return -ENAMETOOLONG;
+
+	ri = jffs2_alloc_raw_inode();
+
+	if (!ri)
+		return -ENOMEM;
+
+	c = JFFS2_SB_INFO(dir_i->i_sb);
+
+	/* Try to reserve enough space for both node and dirent.
+	 * Just the node will do for now, though
+	 */
+	namelen = strlen((char *)d_name);
+	ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen,
+				  ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
+
+	if (ret) {
+		jffs2_free_raw_inode(ri);
+		return ret;
+	}
+
+	inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri);
+
+	if (IS_ERR(inode)) {
+		jffs2_free_raw_inode(ri);
+		jffs2_complete_reservation(c);
+		return PTR_ERR(inode);
+	}
+
+	f = JFFS2_INODE_INFO(inode);
+
+	inode->i_size = targetlen;
+	ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
+	ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
+	ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
+
+	ri->compr = JFFS2_COMPR_NONE;
+	ri->data_crc = cpu_to_je32(crc32(0, target, targetlen));
+	ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
+
+	fn = jffs2_write_dnode(c, f, ri, (const unsigned char *)target, targetlen, ALLOC_NORMAL);
+
+	jffs2_free_raw_inode(ri);
+
+	if (IS_ERR(fn)) {
+		/* Eeek. Wave bye bye */
+		mutex_unlock(&f->sem);
+		jffs2_complete_reservation(c);
+		ret = PTR_ERR(fn);
+		goto fail;
+	}
+
+	/* We use f->target field to store the target path. */
+
+	f->target = (unsigned char *)malloc(targetlen + 1);
+	if (!f->target) {
+		pr_warn("Can't allocate %d bytes of memory\n", targetlen + 1);
+		mutex_unlock(&f->sem);
+		jffs2_complete_reservation(c);
+		ret = -ENOMEM;
+		goto fail;
+	}
+
+	ret = LOS_CopyToKernel((char *)f->target, targetlen + 1, target, targetlen + 1);
+	if (ret != EOK) {
+		(void)free(f->target);
+		f->target = NULL;
+		mutex_unlock(&f->sem);
+		jffs2_complete_reservation(c);
+		goto fail;
+	}
+
+	jffs2_dbg(1, "%s(): symlink's target '%s' cached\n",
+		  __func__, (char *)f->target);
+
+	/* No data here. Only a metadata node, which will be
+	   obsoleted by the first data write
+	*/
+	f->metadata = fn;
+	mutex_unlock(&f->sem);
+
+	jffs2_complete_reservation(c);
+
+	ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
+				  ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
+	if (ret)
+		goto fail;
+
+	rd = jffs2_alloc_raw_dirent();
+	if (!rd) {
+		/* Argh. Now we treat it like a normal delete */
+		jffs2_complete_reservation(c);
+		ret = -ENOMEM;
+		goto fail;
+	}
+
+	dir_f = JFFS2_INODE_INFO(dir_i);
+	mutex_lock(&dir_f->sem);
+
+	rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
+	rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
+	rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
+	rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
+
+	rd->pino = cpu_to_je32(dir_i->i_ino);
+	rd->version = cpu_to_je32(++dir_f->highest_version);
+	rd->ino = cpu_to_je32(inode->i_ino);
+	rd->mctime = cpu_to_je32(Jffs2CurSec());
+	rd->nsize = namelen;
+	rd->type = DT_LNK;
+	rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
+	rd->name_crc = cpu_to_je32(crc32(0, (const char *)d_name, namelen));
+
+	fd = jffs2_write_dirent(c, dir_f, rd, (const unsigned char *)d_name, namelen, ALLOC_NORMAL);
+
+	if (IS_ERR(fd)) {
+		/* dirent failed to write. Delete the inode normally
+		   as if it were the final unlink() */
+		jffs2_complete_reservation(c);
+		jffs2_free_raw_dirent(rd);
+		mutex_unlock(&dir_f->sem);
+		ret = PTR_ERR(fd);
+		goto fail;
+	}
+
+	dir_i->i_mtime = dir_i->i_ctime = je32_to_cpu(rd->mctime);
+
+	jffs2_free_raw_dirent(rd);
+
+	/* Link the fd into the inode's list, obsoleting an old
+	   one if necessary. */
+	jffs2_add_fd_to_list(c, fd, &dir_f->dents);
+
+	mutex_unlock(&dir_f->sem);
+	jffs2_complete_reservation(c);
+
+	*d_inode = inode;
+	return 0;
+
+ fail:
+	inode->i_nlink = 0;
+	jffs2_iput(inode);
+	return ret;
+}
+
 int jffs2_mkdir(struct jffs2_inode *dir_i, const unsigned char *d_name, int mode, struct jffs2_inode **new_i)
 {
 	struct jffs2_inode_info *f, *dir_f;

fs/jffs2/jffs2_fs_i.h

@@ -68,7 +68,6 @@ struct jffs2_inode {
 	time_t i_atime;
 	time_t i_mtime;
 	time_t i_ctime;
-	struct Vnode *i_vnode;
 	off_t i_size;
 	struct super_block *i_sb;
 	LOS_DL_LIST i_hashlist;

fs/jffs2/os-linux.h

@@ -150,6 +150,7 @@ struct jffs2_inode *jffs2_lookup(struct jffs2_inode *dir_i, const unsigned char
 int jffs2_create(struct jffs2_inode *dir_i, const unsigned char *d_name, int mode, struct jffs2_inode **new_i);
 int jffs2_mkdir (struct jffs2_inode *dir_i, const unsigned char *d_name, int mode, struct jffs2_inode **new_i);
 int jffs2_link (struct jffs2_inode *old_d_inode, struct jffs2_inode *dir_i, const unsigned char *d_name);
+int jffs2_symlink(struct jffs2_inode *dir_i, struct jffs2_inode **d_inode, const unsigned char *d_name, const char *target);
 int jffs2_unlink(struct jffs2_inode *dir_i, struct jffs2_inode *d_inode, const unsigned char *d_name);
 int jffs2_rmdir (struct jffs2_inode *dir_i, struct jffs2_inode *d_inode, const unsigned char *d_name);
 int jffs2_rename (struct jffs2_inode *old_dir_i, struct jffs2_inode *d_inode, const unsigned char *old_d_name,