xref: /linux/fs/jffs2/dir.c (revision 0ea5c948cb64bab5bc7a5516774eb8536f05aa0d)
1 /*
2  * JFFS2 -- Journalling Flash File System, Version 2.
3  *
4  * Copyright © 2001-2007 Red Hat, Inc.
5  * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
6  *
7  * Created by David Woodhouse <dwmw2@infradead.org>
8  *
9  * For licensing information, see the file 'LICENCE' in this directory.
10  *
11  */
12 
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 
15 #include <linux/kernel.h>
16 #include <linux/slab.h>
17 #include <linux/fs.h>
18 #include <linux/crc32.h>
19 #include <linux/jffs2.h>
20 #include "jffs2_fs_i.h"
21 #include "jffs2_fs_sb.h"
22 #include <linux/time.h>
23 #include "nodelist.h"
24 
25 static int jffs2_readdir (struct file *, struct dir_context *);
26 
27 static int jffs2_create (struct mnt_idmap *, struct inode *,
28 		         struct dentry *, umode_t, bool);
29 static struct dentry *jffs2_lookup (struct inode *,struct dentry *,
30 				    unsigned int);
31 static int jffs2_link (struct dentry *,struct inode *,struct dentry *);
32 static int jffs2_unlink (struct inode *,struct dentry *);
33 static int jffs2_symlink (struct mnt_idmap *, struct inode *,
34 			  struct dentry *, const char *);
35 static int jffs2_mkdir (struct mnt_idmap *, struct inode *,struct dentry *,
36 			umode_t);
37 static int jffs2_rmdir (struct inode *,struct dentry *);
38 static int jffs2_mknod (struct mnt_idmap *, struct inode *,struct dentry *,
39 			umode_t,dev_t);
40 static int jffs2_rename (struct mnt_idmap *, struct inode *,
41 			 struct dentry *, struct inode *, struct dentry *,
42 			 unsigned int);
43 
44 const struct file_operations jffs2_dir_operations =
45 {
46 	.read =		generic_read_dir,
47 	.iterate_shared=jffs2_readdir,
48 	.unlocked_ioctl=jffs2_ioctl,
49 	.fsync =	jffs2_fsync,
50 	.llseek =	generic_file_llseek,
51 };
52 
53 
54 const struct inode_operations jffs2_dir_inode_operations =
55 {
56 	.create =	jffs2_create,
57 	.lookup =	jffs2_lookup,
58 	.link =		jffs2_link,
59 	.unlink =	jffs2_unlink,
60 	.symlink =	jffs2_symlink,
61 	.mkdir =	jffs2_mkdir,
62 	.rmdir =	jffs2_rmdir,
63 	.mknod =	jffs2_mknod,
64 	.rename =	jffs2_rename,
65 	.get_inode_acl =	jffs2_get_acl,
66 	.set_acl =	jffs2_set_acl,
67 	.setattr =	jffs2_setattr,
68 	.listxattr =	jffs2_listxattr,
69 };
70 
71 /***********************************************************************/
72 
73 
74 /* We keep the dirent list sorted in increasing order of name hash,
75    and we use the same hash function as the dentries. Makes this
76    nice and simple
77 */
jffs2_lookup(struct inode * dir_i,struct dentry * target,unsigned int flags)78 static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
79 				   unsigned int flags)
80 {
81 	struct jffs2_inode_info *dir_f;
82 	struct jffs2_full_dirent *fd = NULL, *fd_list;
83 	uint32_t ino = 0;
84 	struct inode *inode = NULL;
85 	unsigned int nhash;
86 
87 	jffs2_dbg(1, "jffs2_lookup()\n");
88 
89 	if (target->d_name.len > JFFS2_MAX_NAME_LEN)
90 		return ERR_PTR(-ENAMETOOLONG);
91 
92 	dir_f = JFFS2_INODE_INFO(dir_i);
93 
94 	/* The 'nhash' on the fd_list is not the same as the dentry hash */
95 	nhash = full_name_hash(NULL, target->d_name.name, target->d_name.len);
96 
97 	mutex_lock(&dir_f->sem);
98 
99 	/* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */
100 	for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= nhash; fd_list = fd_list->next) {
101 		if (fd_list->nhash == nhash &&
102 		    (!fd || fd_list->version > fd->version) &&
103 		    strlen(fd_list->name) == target->d_name.len &&
104 		    !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) {
105 			fd = fd_list;
106 		}
107 	}
108 	if (fd)
109 		ino = fd->ino;
110 	mutex_unlock(&dir_f->sem);
111 	if (ino) {
112 		inode = jffs2_iget(dir_i->i_sb, ino);
113 		if (IS_ERR(inode))
114 			pr_warn("iget() failed for ino #%u\n", ino);
115 	}
116 
117 	return d_splice_alias(inode, target);
118 }
119 
120 /***********************************************************************/
121 
122 
jffs2_readdir(struct file * file,struct dir_context * ctx)123 static int jffs2_readdir(struct file *file, struct dir_context *ctx)
124 {
125 	struct inode *inode = file_inode(file);
126 	struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
127 	struct jffs2_full_dirent *fd;
128 	unsigned long curofs = 1;
129 
130 	jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", inode->i_ino);
131 
132 	if (!dir_emit_dots(file, ctx))
133 		return 0;
134 
135 	mutex_lock(&f->sem);
136 	for (fd = f->dents; fd; fd = fd->next) {
137 		curofs++;
138 		/* First loop: curofs = 2; pos = 2 */
139 		if (curofs < ctx->pos) {
140 			jffs2_dbg(2, "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n",
141 				  fd->name, fd->ino, fd->type, curofs, (unsigned long)ctx->pos);
142 			continue;
143 		}
144 		if (!fd->ino) {
145 			jffs2_dbg(2, "Skipping deletion dirent \"%s\"\n",
146 				  fd->name);
147 			ctx->pos++;
148 			continue;
149 		}
150 		jffs2_dbg(2, "Dirent %ld: \"%s\", ino #%u, type %d\n",
151 			  (unsigned long)ctx->pos, fd->name, fd->ino, fd->type);
152 		if (!dir_emit(ctx, fd->name, strlen(fd->name), fd->ino, fd->type))
153 			break;
154 		ctx->pos++;
155 	}
156 	mutex_unlock(&f->sem);
157 	return 0;
158 }
159 
160 /***********************************************************************/
161 
162 
jffs2_create(struct mnt_idmap * idmap,struct inode * dir_i,struct dentry * dentry,umode_t mode,bool excl)163 static int jffs2_create(struct mnt_idmap *idmap, struct inode *dir_i,
164 			struct dentry *dentry, umode_t mode, bool excl)
165 {
166 	struct jffs2_raw_inode *ri;
167 	struct jffs2_inode_info *f, *dir_f;
168 	struct jffs2_sb_info *c;
169 	struct inode *inode;
170 	int ret;
171 
172 	ri = jffs2_alloc_raw_inode();
173 	if (!ri)
174 		return -ENOMEM;
175 
176 	c = JFFS2_SB_INFO(dir_i->i_sb);
177 
178 	jffs2_dbg(1, "%s()\n", __func__);
179 
180 	inode = jffs2_new_inode(dir_i, mode, ri);
181 
182 	if (IS_ERR(inode)) {
183 		jffs2_dbg(1, "jffs2_new_inode() failed\n");
184 		jffs2_free_raw_inode(ri);
185 		return PTR_ERR(inode);
186 	}
187 
188 	inode->i_op = &jffs2_file_inode_operations;
189 	inode->i_fop = &jffs2_file_operations;
190 	inode->i_mapping->a_ops = &jffs2_file_address_operations;
191 	inode->i_mapping->nrpages = 0;
192 
193 	f = JFFS2_INODE_INFO(inode);
194 	dir_f = JFFS2_INODE_INFO(dir_i);
195 
196 	/* jffs2_do_create() will want to lock it, _after_ reserving
197 	   space and taking c-alloc_sem. If we keep it locked here,
198 	   lockdep gets unhappy (although it's a false positive;
199 	   nothing else will be looking at this inode yet so there's
200 	   no chance of AB-BA deadlock involving its f->sem). */
201 	mutex_unlock(&f->sem);
202 
203 	ret = jffs2_do_create(c, dir_f, f, ri, &dentry->d_name);
204 	if (ret)
205 		goto fail;
206 
207 	inode_set_mtime_to_ts(dir_i,
208 			      inode_set_ctime_to_ts(dir_i, ITIME(je32_to_cpu(ri->ctime))));
209 
210 	jffs2_free_raw_inode(ri);
211 
212 	jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n",
213 		  __func__, inode->i_ino, inode->i_mode, inode->i_nlink,
214 		  f->inocache->pino_nlink, inode->i_mapping->nrpages);
215 
216 	d_instantiate_new(dentry, inode);
217 	return 0;
218 
219  fail:
220 	iget_failed(inode);
221 	jffs2_free_raw_inode(ri);
222 	return ret;
223 }
224 
225 /***********************************************************************/
226 
227 
jffs2_unlink(struct inode * dir_i,struct dentry * dentry)228 static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry)
229 {
230 	struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
231 	struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
232 	struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry));
233 	int ret;
234 	uint32_t now = JFFS2_NOW();
235 
236 	ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
237 			      dentry->d_name.len, dead_f, now);
238 	if (dead_f->inocache)
239 		set_nlink(d_inode(dentry), dead_f->inocache->pino_nlink);
240 	if (!ret)
241 		inode_set_mtime_to_ts(dir_i,
242 				      inode_set_ctime_to_ts(dir_i, ITIME(now)));
243 	return ret;
244 }
245 /***********************************************************************/
246 
247 
jffs2_link(struct dentry * old_dentry,struct inode * dir_i,struct dentry * dentry)248 static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry)
249 {
250 	struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_sb);
251 	struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
252 	struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
253 	int ret;
254 	uint8_t type;
255 	uint32_t now;
256 
257 	/* Don't let people make hard links to bad inodes. */
258 	if (!f->inocache)
259 		return -EIO;
260 
261 	if (d_is_dir(old_dentry))
262 		return -EPERM;
263 
264 	/* XXX: This is ugly */
265 	type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;
266 	if (!type) type = DT_REG;
267 
268 	now = JFFS2_NOW();
269 	ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len, now);
270 
271 	if (!ret) {
272 		mutex_lock(&f->sem);
273 		set_nlink(d_inode(old_dentry), ++f->inocache->pino_nlink);
274 		mutex_unlock(&f->sem);
275 		d_instantiate(dentry, d_inode(old_dentry));
276 		inode_set_mtime_to_ts(dir_i,
277 				      inode_set_ctime_to_ts(dir_i, ITIME(now)));
278 		ihold(d_inode(old_dentry));
279 	}
280 	return ret;
281 }
282 
283 /***********************************************************************/
284 
jffs2_symlink(struct mnt_idmap * idmap,struct inode * dir_i,struct dentry * dentry,const char * target)285 static int jffs2_symlink (struct mnt_idmap *idmap, struct inode *dir_i,
286 			  struct dentry *dentry, const char *target)
287 {
288 	struct jffs2_inode_info *f, *dir_f;
289 	struct jffs2_sb_info *c;
290 	struct inode *inode;
291 	struct jffs2_raw_inode *ri;
292 	struct jffs2_raw_dirent *rd;
293 	struct jffs2_full_dnode *fn;
294 	struct jffs2_full_dirent *fd;
295 	int namelen;
296 	uint32_t alloclen;
297 	int ret, targetlen = strlen(target);
298 
299 	/* FIXME: If you care. We'd need to use frags for the target
300 	   if it grows much more than this */
301 	if (targetlen > 254)
302 		return -ENAMETOOLONG;
303 
304 	ri = jffs2_alloc_raw_inode();
305 
306 	if (!ri)
307 		return -ENOMEM;
308 
309 	c = JFFS2_SB_INFO(dir_i->i_sb);
310 
311 	/* Try to reserve enough space for both node and dirent.
312 	 * Just the node will do for now, though
313 	 */
314 	namelen = dentry->d_name.len;
315 	ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen,
316 				  ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
317 
318 	if (ret) {
319 		jffs2_free_raw_inode(ri);
320 		return ret;
321 	}
322 
323 	inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri);
324 
325 	if (IS_ERR(inode)) {
326 		jffs2_free_raw_inode(ri);
327 		jffs2_complete_reservation(c);
328 		return PTR_ERR(inode);
329 	}
330 
331 	inode->i_op = &jffs2_symlink_inode_operations;
332 
333 	f = JFFS2_INODE_INFO(inode);
334 
335 	inode->i_size = targetlen;
336 	ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
337 	ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
338 	ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
339 
340 	ri->compr = JFFS2_COMPR_NONE;
341 	ri->data_crc = cpu_to_je32(crc32(0, target, targetlen));
342 	ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
343 
344 	fn = jffs2_write_dnode(c, f, ri, target, targetlen, ALLOC_NORMAL);
345 
346 	jffs2_free_raw_inode(ri);
347 
348 	if (IS_ERR(fn)) {
349 		/* Eeek. Wave bye bye */
350 		mutex_unlock(&f->sem);
351 		jffs2_complete_reservation(c);
352 		ret = PTR_ERR(fn);
353 		goto fail;
354 	}
355 
356 	/* We use f->target field to store the target path. */
357 	f->target = kmemdup(target, targetlen + 1, GFP_KERNEL);
358 	if (!f->target) {
359 		pr_warn("Can't allocate %d bytes of memory\n", targetlen + 1);
360 		mutex_unlock(&f->sem);
361 		jffs2_complete_reservation(c);
362 		ret = -ENOMEM;
363 		goto fail;
364 	}
365 	inode->i_link = f->target;
366 
367 	jffs2_dbg(1, "%s(): symlink's target '%s' cached\n",
368 		  __func__, (char *)f->target);
369 
370 	/* No data here. Only a metadata node, which will be
371 	   obsoleted by the first data write
372 	*/
373 	f->metadata = fn;
374 	mutex_unlock(&f->sem);
375 
376 	jffs2_complete_reservation(c);
377 
378 	ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
379 	if (ret)
380 		goto fail;
381 
382 	ret = jffs2_init_acl_post(inode);
383 	if (ret)
384 		goto fail;
385 
386 	ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
387 				  ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
388 	if (ret)
389 		goto fail;
390 
391 	rd = jffs2_alloc_raw_dirent();
392 	if (!rd) {
393 		/* Argh. Now we treat it like a normal delete */
394 		jffs2_complete_reservation(c);
395 		ret = -ENOMEM;
396 		goto fail;
397 	}
398 
399 	dir_f = JFFS2_INODE_INFO(dir_i);
400 	mutex_lock(&dir_f->sem);
401 
402 	rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
403 	rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
404 	rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
405 	rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
406 
407 	rd->pino = cpu_to_je32(dir_i->i_ino);
408 	rd->version = cpu_to_je32(++dir_f->highest_version);
409 	rd->ino = cpu_to_je32(inode->i_ino);
410 	rd->mctime = cpu_to_je32(JFFS2_NOW());
411 	rd->nsize = namelen;
412 	rd->type = DT_LNK;
413 	rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
414 	rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
415 
416 	fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
417 
418 	if (IS_ERR(fd)) {
419 		/* dirent failed to write. Delete the inode normally
420 		   as if it were the final unlink() */
421 		jffs2_complete_reservation(c);
422 		jffs2_free_raw_dirent(rd);
423 		mutex_unlock(&dir_f->sem);
424 		ret = PTR_ERR(fd);
425 		goto fail;
426 	}
427 
428 	inode_set_mtime_to_ts(dir_i,
429 			      inode_set_ctime_to_ts(dir_i, ITIME(je32_to_cpu(rd->mctime))));
430 
431 	jffs2_free_raw_dirent(rd);
432 
433 	/* Link the fd into the inode's list, obsoleting an old
434 	   one if necessary. */
435 	jffs2_add_fd_to_list(c, fd, &dir_f->dents);
436 
437 	mutex_unlock(&dir_f->sem);
438 	jffs2_complete_reservation(c);
439 
440 	d_instantiate_new(dentry, inode);
441 	return 0;
442 
443  fail:
444 	iget_failed(inode);
445 	return ret;
446 }
447 
448 
jffs2_mkdir(struct mnt_idmap * idmap,struct inode * dir_i,struct dentry * dentry,umode_t mode)449 static int jffs2_mkdir (struct mnt_idmap *idmap, struct inode *dir_i,
450 		        struct dentry *dentry, umode_t mode)
451 {
452 	struct jffs2_inode_info *f, *dir_f;
453 	struct jffs2_sb_info *c;
454 	struct inode *inode;
455 	struct jffs2_raw_inode *ri;
456 	struct jffs2_raw_dirent *rd;
457 	struct jffs2_full_dnode *fn;
458 	struct jffs2_full_dirent *fd;
459 	int namelen;
460 	uint32_t alloclen;
461 	int ret;
462 
463 	mode |= S_IFDIR;
464 
465 	ri = jffs2_alloc_raw_inode();
466 	if (!ri)
467 		return -ENOMEM;
468 
469 	c = JFFS2_SB_INFO(dir_i->i_sb);
470 
471 	/* Try to reserve enough space for both node and dirent.
472 	 * Just the node will do for now, though
473 	 */
474 	namelen = dentry->d_name.len;
475 	ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
476 				  JFFS2_SUMMARY_INODE_SIZE);
477 
478 	if (ret) {
479 		jffs2_free_raw_inode(ri);
480 		return ret;
481 	}
482 
483 	inode = jffs2_new_inode(dir_i, mode, ri);
484 
485 	if (IS_ERR(inode)) {
486 		jffs2_free_raw_inode(ri);
487 		jffs2_complete_reservation(c);
488 		return PTR_ERR(inode);
489 	}
490 
491 	inode->i_op = &jffs2_dir_inode_operations;
492 	inode->i_fop = &jffs2_dir_operations;
493 
494 	f = JFFS2_INODE_INFO(inode);
495 
496 	/* Directories get nlink 2 at start */
497 	set_nlink(inode, 2);
498 	/* but ic->pino_nlink is the parent ino# */
499 	f->inocache->pino_nlink = dir_i->i_ino;
500 
501 	ri->data_crc = cpu_to_je32(0);
502 	ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
503 
504 	fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
505 
506 	jffs2_free_raw_inode(ri);
507 
508 	if (IS_ERR(fn)) {
509 		/* Eeek. Wave bye bye */
510 		mutex_unlock(&f->sem);
511 		jffs2_complete_reservation(c);
512 		ret = PTR_ERR(fn);
513 		goto fail;
514 	}
515 	/* No data here. Only a metadata node, which will be
516 	   obsoleted by the first data write
517 	*/
518 	f->metadata = fn;
519 	mutex_unlock(&f->sem);
520 
521 	jffs2_complete_reservation(c);
522 
523 	ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
524 	if (ret)
525 		goto fail;
526 
527 	ret = jffs2_init_acl_post(inode);
528 	if (ret)
529 		goto fail;
530 
531 	ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
532 				  ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
533 	if (ret)
534 		goto fail;
535 
536 	rd = jffs2_alloc_raw_dirent();
537 	if (!rd) {
538 		/* Argh. Now we treat it like a normal delete */
539 		jffs2_complete_reservation(c);
540 		ret = -ENOMEM;
541 		goto fail;
542 	}
543 
544 	dir_f = JFFS2_INODE_INFO(dir_i);
545 	mutex_lock(&dir_f->sem);
546 
547 	rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
548 	rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
549 	rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
550 	rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
551 
552 	rd->pino = cpu_to_je32(dir_i->i_ino);
553 	rd->version = cpu_to_je32(++dir_f->highest_version);
554 	rd->ino = cpu_to_je32(inode->i_ino);
555 	rd->mctime = cpu_to_je32(JFFS2_NOW());
556 	rd->nsize = namelen;
557 	rd->type = DT_DIR;
558 	rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
559 	rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
560 
561 	fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
562 
563 	if (IS_ERR(fd)) {
564 		/* dirent failed to write. Delete the inode normally
565 		   as if it were the final unlink() */
566 		jffs2_complete_reservation(c);
567 		jffs2_free_raw_dirent(rd);
568 		mutex_unlock(&dir_f->sem);
569 		ret = PTR_ERR(fd);
570 		goto fail;
571 	}
572 
573 	inode_set_mtime_to_ts(dir_i,
574 			      inode_set_ctime_to_ts(dir_i, ITIME(je32_to_cpu(rd->mctime))));
575 	inc_nlink(dir_i);
576 
577 	jffs2_free_raw_dirent(rd);
578 
579 	/* Link the fd into the inode's list, obsoleting an old
580 	   one if necessary. */
581 	jffs2_add_fd_to_list(c, fd, &dir_f->dents);
582 
583 	mutex_unlock(&dir_f->sem);
584 	jffs2_complete_reservation(c);
585 
586 	d_instantiate_new(dentry, inode);
587 	return 0;
588 
589  fail:
590 	iget_failed(inode);
591 	return ret;
592 }
593 
jffs2_rmdir(struct inode * dir_i,struct dentry * dentry)594 static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry)
595 {
596 	struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
597 	struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
598 	struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry));
599 	struct jffs2_full_dirent *fd;
600 	int ret;
601 	uint32_t now = JFFS2_NOW();
602 
603 	mutex_lock(&f->sem);
604 	for (fd = f->dents ; fd; fd = fd->next) {
605 		if (fd->ino) {
606 			mutex_unlock(&f->sem);
607 			return -ENOTEMPTY;
608 		}
609 	}
610 	mutex_unlock(&f->sem);
611 
612 	ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
613 			      dentry->d_name.len, f, now);
614 	if (!ret) {
615 		inode_set_mtime_to_ts(dir_i,
616 				      inode_set_ctime_to_ts(dir_i, ITIME(now)));
617 		clear_nlink(d_inode(dentry));
618 		drop_nlink(dir_i);
619 	}
620 	return ret;
621 }
622 
jffs2_mknod(struct mnt_idmap * idmap,struct inode * dir_i,struct dentry * dentry,umode_t mode,dev_t rdev)623 static int jffs2_mknod (struct mnt_idmap *idmap, struct inode *dir_i,
624 		        struct dentry *dentry, umode_t mode, dev_t rdev)
625 {
626 	struct jffs2_inode_info *f, *dir_f;
627 	struct jffs2_sb_info *c;
628 	struct inode *inode;
629 	struct jffs2_raw_inode *ri;
630 	struct jffs2_raw_dirent *rd;
631 	struct jffs2_full_dnode *fn;
632 	struct jffs2_full_dirent *fd;
633 	int namelen;
634 	union jffs2_device_node dev;
635 	int devlen = 0;
636 	uint32_t alloclen;
637 	int ret;
638 
639 	ri = jffs2_alloc_raw_inode();
640 	if (!ri)
641 		return -ENOMEM;
642 
643 	c = JFFS2_SB_INFO(dir_i->i_sb);
644 
645 	if (S_ISBLK(mode) || S_ISCHR(mode))
646 		devlen = jffs2_encode_dev(&dev, rdev);
647 
648 	/* Try to reserve enough space for both node and dirent.
649 	 * Just the node will do for now, though
650 	 */
651 	namelen = dentry->d_name.len;
652 	ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen,
653 				  ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
654 
655 	if (ret) {
656 		jffs2_free_raw_inode(ri);
657 		return ret;
658 	}
659 
660 	inode = jffs2_new_inode(dir_i, mode, ri);
661 
662 	if (IS_ERR(inode)) {
663 		jffs2_free_raw_inode(ri);
664 		jffs2_complete_reservation(c);
665 		return PTR_ERR(inode);
666 	}
667 	inode->i_op = &jffs2_file_inode_operations;
668 	init_special_inode(inode, inode->i_mode, rdev);
669 
670 	f = JFFS2_INODE_INFO(inode);
671 
672 	ri->dsize = ri->csize = cpu_to_je32(devlen);
673 	ri->totlen = cpu_to_je32(sizeof(*ri) + devlen);
674 	ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
675 
676 	ri->compr = JFFS2_COMPR_NONE;
677 	ri->data_crc = cpu_to_je32(crc32(0, &dev, devlen));
678 	ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
679 
680 	fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL);
681 
682 	jffs2_free_raw_inode(ri);
683 
684 	if (IS_ERR(fn)) {
685 		/* Eeek. Wave bye bye */
686 		mutex_unlock(&f->sem);
687 		jffs2_complete_reservation(c);
688 		ret = PTR_ERR(fn);
689 		goto fail;
690 	}
691 	/* No data here. Only a metadata node, which will be
692 	   obsoleted by the first data write
693 	*/
694 	f->metadata = fn;
695 	mutex_unlock(&f->sem);
696 
697 	jffs2_complete_reservation(c);
698 
699 	ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
700 	if (ret)
701 		goto fail;
702 
703 	ret = jffs2_init_acl_post(inode);
704 	if (ret)
705 		goto fail;
706 
707 	ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
708 				  ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
709 	if (ret)
710 		goto fail;
711 
712 	rd = jffs2_alloc_raw_dirent();
713 	if (!rd) {
714 		/* Argh. Now we treat it like a normal delete */
715 		jffs2_complete_reservation(c);
716 		ret = -ENOMEM;
717 		goto fail;
718 	}
719 
720 	dir_f = JFFS2_INODE_INFO(dir_i);
721 	mutex_lock(&dir_f->sem);
722 
723 	rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
724 	rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
725 	rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
726 	rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
727 
728 	rd->pino = cpu_to_je32(dir_i->i_ino);
729 	rd->version = cpu_to_je32(++dir_f->highest_version);
730 	rd->ino = cpu_to_je32(inode->i_ino);
731 	rd->mctime = cpu_to_je32(JFFS2_NOW());
732 	rd->nsize = namelen;
733 
734 	/* XXX: This is ugly. */
735 	rd->type = (mode & S_IFMT) >> 12;
736 
737 	rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
738 	rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));
739 
740 	fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
741 
742 	if (IS_ERR(fd)) {
743 		/* dirent failed to write. Delete the inode normally
744 		   as if it were the final unlink() */
745 		jffs2_complete_reservation(c);
746 		jffs2_free_raw_dirent(rd);
747 		mutex_unlock(&dir_f->sem);
748 		ret = PTR_ERR(fd);
749 		goto fail;
750 	}
751 
752 	inode_set_mtime_to_ts(dir_i,
753 			      inode_set_ctime_to_ts(dir_i, ITIME(je32_to_cpu(rd->mctime))));
754 
755 	jffs2_free_raw_dirent(rd);
756 
757 	/* Link the fd into the inode's list, obsoleting an old
758 	   one if necessary. */
759 	jffs2_add_fd_to_list(c, fd, &dir_f->dents);
760 
761 	mutex_unlock(&dir_f->sem);
762 	jffs2_complete_reservation(c);
763 
764 	d_instantiate_new(dentry, inode);
765 	return 0;
766 
767  fail:
768 	iget_failed(inode);
769 	return ret;
770 }
771 
jffs2_rename(struct mnt_idmap * idmap,struct inode * old_dir_i,struct dentry * old_dentry,struct inode * new_dir_i,struct dentry * new_dentry,unsigned int flags)772 static int jffs2_rename (struct mnt_idmap *idmap,
773 			 struct inode *old_dir_i, struct dentry *old_dentry,
774 			 struct inode *new_dir_i, struct dentry *new_dentry,
775 			 unsigned int flags)
776 {
777 	int ret;
778 	struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
779 	struct jffs2_inode_info *victim_f = NULL;
780 	uint8_t type;
781 	uint32_t now;
782 
783 	if (flags & ~RENAME_NOREPLACE)
784 		return -EINVAL;
785 
786 	/* The VFS will check for us and prevent trying to rename a
787 	 * file over a directory and vice versa, but if it's a directory,
788 	 * the VFS can't check whether the victim is empty. The filesystem
789 	 * needs to do that for itself.
790 	 */
791 	if (d_really_is_positive(new_dentry)) {
792 		victim_f = JFFS2_INODE_INFO(d_inode(new_dentry));
793 		if (d_is_dir(new_dentry)) {
794 			struct jffs2_full_dirent *fd;
795 
796 			mutex_lock(&victim_f->sem);
797 			for (fd = victim_f->dents; fd; fd = fd->next) {
798 				if (fd->ino) {
799 					mutex_unlock(&victim_f->sem);
800 					return -ENOTEMPTY;
801 				}
802 			}
803 			mutex_unlock(&victim_f->sem);
804 		}
805 	}
806 
807 	/* XXX: We probably ought to alloc enough space for
808 	   both nodes at the same time. Writing the new link,
809 	   then getting -ENOSPC, is quite bad :)
810 	*/
811 
812 	/* Make a hard link */
813 
814 	/* XXX: This is ugly */
815 	type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12;
816 	if (!type) type = DT_REG;
817 
818 	now = JFFS2_NOW();
819 	ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
820 			    d_inode(old_dentry)->i_ino, type,
821 			    new_dentry->d_name.name, new_dentry->d_name.len, now);
822 
823 	if (ret)
824 		return ret;
825 
826 	if (victim_f) {
827 		/* There was a victim. Kill it off nicely */
828 		if (d_is_dir(new_dentry))
829 			clear_nlink(d_inode(new_dentry));
830 		else
831 			drop_nlink(d_inode(new_dentry));
832 		/* Don't oops if the victim was a dirent pointing to an
833 		   inode which didn't exist. */
834 		if (victim_f->inocache) {
835 			mutex_lock(&victim_f->sem);
836 			if (d_is_dir(new_dentry))
837 				victim_f->inocache->pino_nlink = 0;
838 			else
839 				victim_f->inocache->pino_nlink--;
840 			mutex_unlock(&victim_f->sem);
841 		}
842 	}
843 
844 	/* If it was a directory we moved, and there was no victim,
845 	   increase i_nlink on its new parent */
846 	if (d_is_dir(old_dentry) && !victim_f)
847 		inc_nlink(new_dir_i);
848 
849 	/* Unlink the original */
850 	ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i),
851 			      old_dentry->d_name.name, old_dentry->d_name.len, NULL, now);
852 
853 	/* We don't touch inode->i_nlink */
854 
855 	if (ret) {
856 		/* Oh shit. We really ought to make a single node which can do both atomically */
857 		struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry));
858 		mutex_lock(&f->sem);
859 		inc_nlink(d_inode(old_dentry));
860 		if (f->inocache && !d_is_dir(old_dentry))
861 			f->inocache->pino_nlink++;
862 		mutex_unlock(&f->sem);
863 
864 		pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n",
865 			  __func__, ret);
866 		/*
867 		 * We can't keep the target in dcache after that.
868 		 * For one thing, we can't afford dentry aliases for directories.
869 		 * For another, if there was a victim, we _can't_ set new inode
870 		 * for that sucker and we have to trigger mount eviction - the
871 		 * caller won't do it on its own since we are returning an error.
872 		 */
873 		d_invalidate(new_dentry);
874 		inode_set_mtime_to_ts(new_dir_i,
875 				      inode_set_ctime_to_ts(new_dir_i, ITIME(now)));
876 		return ret;
877 	}
878 
879 	if (d_is_dir(old_dentry))
880 		drop_nlink(old_dir_i);
881 
882 	inode_set_mtime_to_ts(old_dir_i,
883 			      inode_set_ctime_to_ts(old_dir_i, ITIME(now)));
884 	inode_set_mtime_to_ts(new_dir_i,
885 			      inode_set_ctime_to_ts(new_dir_i, ITIME(now)));
886 
887 	return 0;
888 }
889 
890