dir.c 22.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 * JFFS2 -- Journalling Flash File System, Version 2.
 *
4
 * Copyright © 2001-2007 Red Hat, Inc.
5
 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
L
Linus Torvalds 已提交
6 7 8 9 10 11 12 13 14 15 16 17
 *
 * Created by David Woodhouse <dwmw2@infradead.org>
 *
 * For licensing information, see the file 'LICENCE' in this directory.
 *
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/crc32.h>
#include <linux/jffs2.h>
18 19
#include "jffs2_fs_i.h"
#include "jffs2_fs_sb.h"
L
Linus Torvalds 已提交
20 21 22 23 24 25 26 27 28 29 30 31 32 33
#include <linux/time.h>
#include "nodelist.h"

static int jffs2_readdir (struct file *, void *, filldir_t);

static int jffs2_create (struct inode *,struct dentry *,int,
			 struct nameidata *);
static struct dentry *jffs2_lookup (struct inode *,struct dentry *,
				    struct nameidata *);
static int jffs2_link (struct dentry *,struct inode *,struct dentry *);
static int jffs2_unlink (struct inode *,struct dentry *);
static int jffs2_symlink (struct inode *,struct dentry *,const char *);
static int jffs2_mkdir (struct inode *,struct dentry *,int);
static int jffs2_rmdir (struct inode *,struct dentry *);
34
static int jffs2_mknod (struct inode *,struct dentry *,int,dev_t);
L
Linus Torvalds 已提交
35
static int jffs2_rename (struct inode *, struct dentry *,
D
David Woodhouse 已提交
36
			 struct inode *, struct dentry *);
L
Linus Torvalds 已提交
37

38
const struct file_operations jffs2_dir_operations =
L
Linus Torvalds 已提交
39 40 41
{
	.read =		generic_read_dir,
	.readdir =	jffs2_readdir,
S
Stoyan Gaydarov 已提交
42
	.unlocked_ioctl=jffs2_ioctl,
43 44
	.fsync =	jffs2_fsync,
	.llseek =	generic_file_llseek,
L
Linus Torvalds 已提交
45 46 47
};


48
const struct inode_operations jffs2_dir_inode_operations =
L
Linus Torvalds 已提交
49
{
50 51
	.create =	jffs2_create,
	.lookup =	jffs2_lookup,
L
Linus Torvalds 已提交
52 53 54 55 56 57 58
	.link =		jffs2_link,
	.unlink =	jffs2_unlink,
	.symlink =	jffs2_symlink,
	.mkdir =	jffs2_mkdir,
	.rmdir =	jffs2_rmdir,
	.mknod =	jffs2_mknod,
	.rename =	jffs2_rename,
59
	.check_acl =	jffs2_check_acl,
L
Linus Torvalds 已提交
60
	.setattr =	jffs2_setattr,
61 62 63 64
	.setxattr =	jffs2_setxattr,
	.getxattr =	jffs2_getxattr,
	.listxattr =	jffs2_listxattr,
	.removexattr =	jffs2_removexattr
L
Linus Torvalds 已提交
65 66 67 68 69 70
};

/***********************************************************************/


/* We keep the dirent list sorted in increasing order of name hash,
71
   and we use the same hash function as the dentries. Makes this
L
Linus Torvalds 已提交
72 73 74 75 76 77 78 79 80 81 82 83
   nice and simple
*/
static struct dentry *jffs2_lookup(struct inode *dir_i, struct dentry *target,
				   struct nameidata *nd)
{
	struct jffs2_inode_info *dir_f;
	struct jffs2_full_dirent *fd = NULL, *fd_list;
	uint32_t ino = 0;
	struct inode *inode = NULL;

	D1(printk(KERN_DEBUG "jffs2_lookup()\n"));

84 85 86
	if (target->d_name.len > JFFS2_MAX_NAME_LEN)
		return ERR_PTR(-ENAMETOOLONG);

L
Linus Torvalds 已提交
87 88
	dir_f = JFFS2_INODE_INFO(dir_i);

89
	mutex_lock(&dir_f->sem);
L
Linus Torvalds 已提交
90 91 92

	/* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */
	for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= target->d_name.hash; fd_list = fd_list->next) {
93
		if (fd_list->nhash == target->d_name.hash &&
L
Linus Torvalds 已提交
94 95 96 97 98 99 100 101
		    (!fd || fd_list->version > fd->version) &&
		    strlen(fd_list->name) == target->d_name.len &&
		    !strncmp(fd_list->name, target->d_name.name, target->d_name.len)) {
			fd = fd_list;
		}
	}
	if (fd)
		ino = fd->ino;
102
	mutex_unlock(&dir_f->sem);
L
Linus Torvalds 已提交
103
	if (ino) {
104 105
		inode = jffs2_iget(dir_i->i_sb, ino);
		if (IS_ERR(inode)) {
L
Linus Torvalds 已提交
106
			printk(KERN_WARNING "iget() failed for ino #%u\n", ino);
107
			return ERR_CAST(inode);
L
Linus Torvalds 已提交
108 109 110
		}
	}

111
	return d_splice_alias(inode, target);
L
Linus Torvalds 已提交
112 113 114 115 116 117 118 119
}

/***********************************************************************/


static int jffs2_readdir(struct file *filp, void *dirent, filldir_t filldir)
{
	struct jffs2_inode_info *f;
J
Josef Sipek 已提交
120
	struct inode *inode = filp->f_path.dentry->d_inode;
L
Linus Torvalds 已提交
121 122 123
	struct jffs2_full_dirent *fd;
	unsigned long offset, curofs;

J
Josef Sipek 已提交
124
	D1(printk(KERN_DEBUG "jffs2_readdir() for dir_i #%lu\n", filp->f_path.dentry->d_inode->i_ino));
L
Linus Torvalds 已提交
125 126 127 128 129 130 131 132 133 134 135 136

	f = JFFS2_INODE_INFO(inode);

	offset = filp->f_pos;

	if (offset == 0) {
		D1(printk(KERN_DEBUG "Dirent 0: \".\", ino #%lu\n", inode->i_ino));
		if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR) < 0)
			goto out;
		offset++;
	}
	if (offset == 1) {
J
Josef Sipek 已提交
137
		unsigned long pino = parent_ino(filp->f_path.dentry);
L
Linus Torvalds 已提交
138 139 140 141 142 143 144
		D1(printk(KERN_DEBUG "Dirent 1: \"..\", ino #%lu\n", pino));
		if (filldir(dirent, "..", 2, 1, pino, DT_DIR) < 0)
			goto out;
		offset++;
	}

	curofs=1;
145
	mutex_lock(&f->sem);
L
Linus Torvalds 已提交
146 147 148 149 150
	for (fd = f->dents; fd; fd = fd->next) {

		curofs++;
		/* First loop: curofs = 2; offset = 2 */
		if (curofs < offset) {
151
			D2(printk(KERN_DEBUG "Skipping dirent: \"%s\", ino #%u, type %d, because curofs %ld < offset %ld\n",
L
Linus Torvalds 已提交
152 153 154 155 156 157 158 159 160 161 162 163 164
				  fd->name, fd->ino, fd->type, curofs, offset));
			continue;
		}
		if (!fd->ino) {
			D2(printk(KERN_DEBUG "Skipping deletion dirent \"%s\"\n", fd->name));
			offset++;
			continue;
		}
		D2(printk(KERN_DEBUG "Dirent %ld: \"%s\", ino #%u, type %d\n", offset, fd->name, fd->ino, fd->type));
		if (filldir(dirent, fd->name, strlen(fd->name), offset, fd->ino, fd->type) < 0)
			break;
		offset++;
	}
165
	mutex_unlock(&f->sem);
L
Linus Torvalds 已提交
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
 out:
	filp->f_pos = offset;
	return 0;
}

/***********************************************************************/


static int jffs2_create(struct inode *dir_i, struct dentry *dentry, int mode,
			struct nameidata *nd)
{
	struct jffs2_raw_inode *ri;
	struct jffs2_inode_info *f, *dir_f;
	struct jffs2_sb_info *c;
	struct inode *inode;
	int ret;

	ri = jffs2_alloc_raw_inode();
	if (!ri)
		return -ENOMEM;
186

L
Linus Torvalds 已提交
187 188 189 190
	c = JFFS2_SB_INFO(dir_i->i_sb);

	D1(printk(KERN_DEBUG "jffs2_create()\n"));

191
	inode = jffs2_new_inode(dir_i, mode, ri);
L
Linus Torvalds 已提交
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206

	if (IS_ERR(inode)) {
		D1(printk(KERN_DEBUG "jffs2_new_inode() failed\n"));
		jffs2_free_raw_inode(ri);
		return PTR_ERR(inode);
	}

	inode->i_op = &jffs2_file_inode_operations;
	inode->i_fop = &jffs2_file_operations;
	inode->i_mapping->a_ops = &jffs2_file_address_operations;
	inode->i_mapping->nrpages = 0;

	f = JFFS2_INODE_INFO(inode);
	dir_f = JFFS2_INODE_INFO(dir_i);

207 208 209 210 211 212 213
	/* jffs2_do_create() will want to lock it, _after_ reserving
	   space and taking c-alloc_sem. If we keep it locked here,
	   lockdep gets unhappy (although it's a false positive;
	   nothing else will be looking at this inode yet so there's
	   no chance of AB-BA deadlock involving its f->sem). */
	mutex_unlock(&f->sem);

214
	ret = jffs2_do_create(c, dir_f, f, ri, &dentry->d_name);
215 216
	if (ret)
		goto fail;
L
Linus Torvalds 已提交
217 218 219 220 221 222

	dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime));

	jffs2_free_raw_inode(ri);

	D1(printk(KERN_DEBUG "jffs2_create: Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n",
223 224
		  inode->i_ino, inode->i_mode, inode->i_nlink,
		  f->inocache->pino_nlink, inode->i_mapping->nrpages));
225 226 227

	d_instantiate(dentry, inode);
	unlock_new_inode(inode);
L
Linus Torvalds 已提交
228
	return 0;
229 230

 fail:
A
Al Viro 已提交
231
	iget_failed(inode);
232 233
	jffs2_free_raw_inode(ri);
	return ret;
L
Linus Torvalds 已提交
234 235 236 237 238 239 240 241 242 243 244
}

/***********************************************************************/


static int jffs2_unlink(struct inode *dir_i, struct dentry *dentry)
{
	struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
	struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
	struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(dentry->d_inode);
	int ret;
245
	uint32_t now = get_seconds();
L
Linus Torvalds 已提交
246

247
	ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
248
			      dentry->d_name.len, dead_f, now);
L
Linus Torvalds 已提交
249
	if (dead_f->inocache)
250
		dentry->d_inode->i_nlink = dead_f->inocache->pino_nlink;
251 252
	if (!ret)
		dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
L
Linus Torvalds 已提交
253 254 255 256 257 258 259 260 261 262 263 264
	return ret;
}
/***********************************************************************/


static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry)
{
	struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_inode->i_sb);
	struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode);
	struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
	int ret;
	uint8_t type;
265
	uint32_t now;
L
Linus Torvalds 已提交
266 267 268 269 270 271 272 273 274 275 276 277

	/* Don't let people make hard links to bad inodes. */
	if (!f->inocache)
		return -EIO;

	if (S_ISDIR(old_dentry->d_inode->i_mode))
		return -EPERM;

	/* XXX: This is ugly */
	type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12;
	if (!type) type = DT_REG;

278 279
	now = get_seconds();
	ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, dentry->d_name.name, dentry->d_name.len, now);
L
Linus Torvalds 已提交
280 281

	if (!ret) {
282
		mutex_lock(&f->sem);
283
		old_dentry->d_inode->i_nlink = ++f->inocache->pino_nlink;
284
		mutex_unlock(&f->sem);
L
Linus Torvalds 已提交
285
		d_instantiate(dentry, old_dentry->d_inode);
286
		dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
A
Al Viro 已提交
287
		ihold(old_dentry->d_inode);
L
Linus Torvalds 已提交
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
	}
	return ret;
}

/***********************************************************************/

static int jffs2_symlink (struct inode *dir_i, struct dentry *dentry, const char *target)
{
	struct jffs2_inode_info *f, *dir_f;
	struct jffs2_sb_info *c;
	struct inode *inode;
	struct jffs2_raw_inode *ri;
	struct jffs2_raw_dirent *rd;
	struct jffs2_full_dnode *fn;
	struct jffs2_full_dirent *fd;
	int namelen;
304
	uint32_t alloclen;
305
	int ret, targetlen = strlen(target);
L
Linus Torvalds 已提交
306 307 308

	/* FIXME: If you care. We'd need to use frags for the target
	   if it grows much more than this */
309
	if (targetlen > 254)
310
		return -ENAMETOOLONG;
L
Linus Torvalds 已提交
311 312 313 314 315

	ri = jffs2_alloc_raw_inode();

	if (!ri)
		return -ENOMEM;
316

L
Linus Torvalds 已提交
317
	c = JFFS2_SB_INFO(dir_i->i_sb);
318 319 320

	/* Try to reserve enough space for both node and dirent.
	 * Just the node will do for now, though
L
Linus Torvalds 已提交
321 322
	 */
	namelen = dentry->d_name.len;
323 324
	ret = jffs2_reserve_space(c, sizeof(*ri) + targetlen, &alloclen,
				  ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
L
Linus Torvalds 已提交
325 326 327 328 329 330

	if (ret) {
		jffs2_free_raw_inode(ri);
		return ret;
	}

331
	inode = jffs2_new_inode(dir_i, S_IFLNK | S_IRWXUGO, ri);
L
Linus Torvalds 已提交
332 333 334 335 336 337 338 339 340 341 342

	if (IS_ERR(inode)) {
		jffs2_free_raw_inode(ri);
		jffs2_complete_reservation(c);
		return PTR_ERR(inode);
	}

	inode->i_op = &jffs2_symlink_inode_operations;

	f = JFFS2_INODE_INFO(inode);

343
	inode->i_size = targetlen;
L
Linus Torvalds 已提交
344 345 346 347 348
	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;
349
	ri->data_crc = cpu_to_je32(crc32(0, target, targetlen));
L
Linus Torvalds 已提交
350
	ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
351

352
	fn = jffs2_write_dnode(c, f, ri, target, targetlen, ALLOC_NORMAL);
L
Linus Torvalds 已提交
353 354 355 356 357

	jffs2_free_raw_inode(ri);

	if (IS_ERR(fn)) {
		/* Eeek. Wave bye bye */
358
		mutex_unlock(&f->sem);
L
Linus Torvalds 已提交
359
		jffs2_complete_reservation(c);
360 361
		ret = PTR_ERR(fn);
		goto fail;
L
Linus Torvalds 已提交
362
	}
363

364
	/* We use f->target field to store the target path. */
J
Julia Lawall 已提交
365
	f->target = kmemdup(target, targetlen + 1, GFP_KERNEL);
366
	if (!f->target) {
367
		printk(KERN_WARNING "Can't allocate %d bytes of memory\n", targetlen + 1);
368
		mutex_unlock(&f->sem);
369
		jffs2_complete_reservation(c);
370 371
		ret = -ENOMEM;
		goto fail;
372 373
	}

374
	D1(printk(KERN_DEBUG "jffs2_symlink: symlink's target '%s' cached\n", (char *)f->target));
375

376
	/* No data here. Only a metadata node, which will be
L
Linus Torvalds 已提交
377 378 379
	   obsoleted by the first data write
	*/
	f->metadata = fn;
380
	mutex_unlock(&f->sem);
L
Linus Torvalds 已提交
381 382

	jffs2_complete_reservation(c);
383

384
	ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
385 386 387
	if (ret)
		goto fail;

388
	ret = jffs2_init_acl_post(inode);
389 390
	if (ret)
		goto fail;
391

392 393
	ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
				  ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
394 395
	if (ret)
		goto fail;
L
Linus Torvalds 已提交
396 397 398 399 400

	rd = jffs2_alloc_raw_dirent();
	if (!rd) {
		/* Argh. Now we treat it like a normal delete */
		jffs2_complete_reservation(c);
401 402
		ret = -ENOMEM;
		goto fail;
L
Linus Torvalds 已提交
403 404 405
	}

	dir_f = JFFS2_INODE_INFO(dir_i);
406
	mutex_lock(&dir_f->sem);
L
Linus Torvalds 已提交
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421

	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(get_seconds());
	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, dentry->d_name.name, namelen));

422
	fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
L
Linus Torvalds 已提交
423 424

	if (IS_ERR(fd)) {
425
		/* dirent failed to write. Delete the inode normally
L
Linus Torvalds 已提交
426 427 428
		   as if it were the final unlink() */
		jffs2_complete_reservation(c);
		jffs2_free_raw_dirent(rd);
429
		mutex_unlock(&dir_f->sem);
430 431
		ret = PTR_ERR(fd);
		goto fail;
L
Linus Torvalds 已提交
432 433 434 435 436 437 438 439 440 441
	}

	dir_i->i_mtime = dir_i->i_ctime = ITIME(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);

442
	mutex_unlock(&dir_f->sem);
L
Linus Torvalds 已提交
443 444 445
	jffs2_complete_reservation(c);

	d_instantiate(dentry, inode);
446
	unlock_new_inode(inode);
L
Linus Torvalds 已提交
447
	return 0;
448 449

 fail:
A
Al Viro 已提交
450
	iget_failed(inode);
451
	return ret;
L
Linus Torvalds 已提交
452 453 454 455 456 457 458 459 460 461 462 463 464
}


static int jffs2_mkdir (struct inode *dir_i, struct dentry *dentry, int mode)
{
	struct jffs2_inode_info *f, *dir_f;
	struct jffs2_sb_info *c;
	struct inode *inode;
	struct jffs2_raw_inode *ri;
	struct jffs2_raw_dirent *rd;
	struct jffs2_full_dnode *fn;
	struct jffs2_full_dirent *fd;
	int namelen;
465
	uint32_t alloclen;
L
Linus Torvalds 已提交
466 467 468 469 470 471 472
	int ret;

	mode |= S_IFDIR;

	ri = jffs2_alloc_raw_inode();
	if (!ri)
		return -ENOMEM;
473

L
Linus Torvalds 已提交
474 475
	c = JFFS2_SB_INFO(dir_i->i_sb);

476 477
	/* Try to reserve enough space for both node and dirent.
	 * Just the node will do for now, though
L
Linus Torvalds 已提交
478 479
	 */
	namelen = dentry->d_name.len;
480 481
	ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
				  JFFS2_SUMMARY_INODE_SIZE);
L
Linus Torvalds 已提交
482 483 484 485 486 487

	if (ret) {
		jffs2_free_raw_inode(ri);
		return ret;
	}

488
	inode = jffs2_new_inode(dir_i, mode, ri);
L
Linus Torvalds 已提交
489 490 491 492 493 494 495 496 497 498 499 500

	if (IS_ERR(inode)) {
		jffs2_free_raw_inode(ri);
		jffs2_complete_reservation(c);
		return PTR_ERR(inode);
	}

	inode->i_op = &jffs2_dir_inode_operations;
	inode->i_fop = &jffs2_dir_operations;

	f = JFFS2_INODE_INFO(inode);

501 502 503 504 505
	/* Directories get nlink 2 at start */
	inode->i_nlink = 2;
	/* but ic->pino_nlink is the parent ino# */
	f->inocache->pino_nlink = dir_i->i_ino;

L
Linus Torvalds 已提交
506 507
	ri->data_crc = cpu_to_je32(0);
	ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
508

509
	fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
L
Linus Torvalds 已提交
510 511 512 513 514

	jffs2_free_raw_inode(ri);

	if (IS_ERR(fn)) {
		/* Eeek. Wave bye bye */
515
		mutex_unlock(&f->sem);
L
Linus Torvalds 已提交
516
		jffs2_complete_reservation(c);
517 518
		ret = PTR_ERR(fn);
		goto fail;
L
Linus Torvalds 已提交
519
	}
520
	/* No data here. Only a metadata node, which will be
L
Linus Torvalds 已提交
521 522 523
	   obsoleted by the first data write
	*/
	f->metadata = fn;
524
	mutex_unlock(&f->sem);
L
Linus Torvalds 已提交
525 526

	jffs2_complete_reservation(c);
527

528
	ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
529 530 531
	if (ret)
		goto fail;

532
	ret = jffs2_init_acl_post(inode);
533 534
	if (ret)
		goto fail;
535

536 537
	ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
				  ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
538 539
	if (ret)
		goto fail;
540

L
Linus Torvalds 已提交
541 542 543 544
	rd = jffs2_alloc_raw_dirent();
	if (!rd) {
		/* Argh. Now we treat it like a normal delete */
		jffs2_complete_reservation(c);
545 546
		ret = -ENOMEM;
		goto fail;
L
Linus Torvalds 已提交
547 548 549
	}

	dir_f = JFFS2_INODE_INFO(dir_i);
550
	mutex_lock(&dir_f->sem);
L
Linus Torvalds 已提交
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565

	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(get_seconds());
	rd->nsize = namelen;
	rd->type = DT_DIR;
	rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
	rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));

566
	fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
567

L
Linus Torvalds 已提交
568
	if (IS_ERR(fd)) {
569
		/* dirent failed to write. Delete the inode normally
L
Linus Torvalds 已提交
570 571 572
		   as if it were the final unlink() */
		jffs2_complete_reservation(c);
		jffs2_free_raw_dirent(rd);
573
		mutex_unlock(&dir_f->sem);
574 575
		ret = PTR_ERR(fd);
		goto fail;
L
Linus Torvalds 已提交
576 577 578
	}

	dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
579
	inc_nlink(dir_i);
L
Linus Torvalds 已提交
580 581 582 583 584 585 586

	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);

587
	mutex_unlock(&dir_f->sem);
L
Linus Torvalds 已提交
588 589 590
	jffs2_complete_reservation(c);

	d_instantiate(dentry, inode);
591
	unlock_new_inode(inode);
L
Linus Torvalds 已提交
592
	return 0;
593 594

 fail:
A
Al Viro 已提交
595
	iget_failed(inode);
596
	return ret;
L
Linus Torvalds 已提交
597 598 599 600
}

static int jffs2_rmdir (struct inode *dir_i, struct dentry *dentry)
{
601 602
	struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
	struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
L
Linus Torvalds 已提交
603 604 605
	struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode);
	struct jffs2_full_dirent *fd;
	int ret;
606
	uint32_t now = get_seconds();
L
Linus Torvalds 已提交
607 608 609 610 611

	for (fd = f->dents ; fd; fd = fd->next) {
		if (fd->ino)
			return -ENOTEMPTY;
	}
612 613 614 615 616 617

	ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name,
			      dentry->d_name.len, f, now);
	if (!ret) {
		dir_i->i_mtime = dir_i->i_ctime = ITIME(now);
		clear_nlink(dentry->d_inode);
618
		drop_nlink(dir_i);
619
	}
L
Linus Torvalds 已提交
620 621 622
	return ret;
}

623
static int jffs2_mknod (struct inode *dir_i, struct dentry *dentry, int mode, dev_t rdev)
L
Linus Torvalds 已提交
624 625 626 627 628 629 630 631 632
{
	struct jffs2_inode_info *f, *dir_f;
	struct jffs2_sb_info *c;
	struct inode *inode;
	struct jffs2_raw_inode *ri;
	struct jffs2_raw_dirent *rd;
	struct jffs2_full_dnode *fn;
	struct jffs2_full_dirent *fd;
	int namelen;
633
	union jffs2_device_node dev;
L
Linus Torvalds 已提交
634
	int devlen = 0;
635
	uint32_t alloclen;
L
Linus Torvalds 已提交
636 637
	int ret;

638
	if (!new_valid_dev(rdev))
L
Linus Torvalds 已提交
639 640 641 642 643
		return -EINVAL;

	ri = jffs2_alloc_raw_inode();
	if (!ri)
		return -ENOMEM;
644

L
Linus Torvalds 已提交
645
	c = JFFS2_SB_INFO(dir_i->i_sb);
646

647 648
	if (S_ISBLK(mode) || S_ISCHR(mode))
		devlen = jffs2_encode_dev(&dev, rdev);
649 650 651

	/* Try to reserve enough space for both node and dirent.
	 * Just the node will do for now, though
L
Linus Torvalds 已提交
652 653
	 */
	namelen = dentry->d_name.len;
654
	ret = jffs2_reserve_space(c, sizeof(*ri) + devlen, &alloclen,
655
				  ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
L
Linus Torvalds 已提交
656 657 658 659 660 661

	if (ret) {
		jffs2_free_raw_inode(ri);
		return ret;
	}

662
	inode = jffs2_new_inode(dir_i, mode, ri);
L
Linus Torvalds 已提交
663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680

	if (IS_ERR(inode)) {
		jffs2_free_raw_inode(ri);
		jffs2_complete_reservation(c);
		return PTR_ERR(inode);
	}
	inode->i_op = &jffs2_file_inode_operations;
	init_special_inode(inode, inode->i_mode, rdev);

	f = JFFS2_INODE_INFO(inode);

	ri->dsize = ri->csize = cpu_to_je32(devlen);
	ri->totlen = cpu_to_je32(sizeof(*ri) + devlen);
	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, &dev, devlen));
	ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
681

682
	fn = jffs2_write_dnode(c, f, ri, (char *)&dev, devlen, ALLOC_NORMAL);
L
Linus Torvalds 已提交
683 684 685 686 687

	jffs2_free_raw_inode(ri);

	if (IS_ERR(fn)) {
		/* Eeek. Wave bye bye */
688
		mutex_unlock(&f->sem);
L
Linus Torvalds 已提交
689
		jffs2_complete_reservation(c);
690 691
		ret = PTR_ERR(fn);
		goto fail;
L
Linus Torvalds 已提交
692
	}
693
	/* No data here. Only a metadata node, which will be
L
Linus Torvalds 已提交
694 695 696
	   obsoleted by the first data write
	*/
	f->metadata = fn;
697
	mutex_unlock(&f->sem);
L
Linus Torvalds 已提交
698 699

	jffs2_complete_reservation(c);
700

701
	ret = jffs2_init_security(inode, dir_i, &dentry->d_name);
702 703 704
	if (ret)
		goto fail;

705
	ret = jffs2_init_acl_post(inode);
706 707
	if (ret)
		goto fail;
708

709 710
	ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
				  ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
711 712
	if (ret)
		goto fail;
L
Linus Torvalds 已提交
713 714 715 716 717

	rd = jffs2_alloc_raw_dirent();
	if (!rd) {
		/* Argh. Now we treat it like a normal delete */
		jffs2_complete_reservation(c);
718 719
		ret = -ENOMEM;
		goto fail;
L
Linus Torvalds 已提交
720 721 722
	}

	dir_f = JFFS2_INODE_INFO(dir_i);
723
	mutex_lock(&dir_f->sem);
L
Linus Torvalds 已提交
724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741

	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(get_seconds());
	rd->nsize = namelen;

	/* XXX: This is ugly. */
	rd->type = (mode & S_IFMT) >> 12;

	rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
	rd->name_crc = cpu_to_je32(crc32(0, dentry->d_name.name, namelen));

742
	fd = jffs2_write_dirent(c, dir_f, rd, dentry->d_name.name, namelen, ALLOC_NORMAL);
743

L
Linus Torvalds 已提交
744
	if (IS_ERR(fd)) {
745
		/* dirent failed to write. Delete the inode normally
L
Linus Torvalds 已提交
746 747 748
		   as if it were the final unlink() */
		jffs2_complete_reservation(c);
		jffs2_free_raw_dirent(rd);
749
		mutex_unlock(&dir_f->sem);
750 751
		ret = PTR_ERR(fd);
		goto fail;
L
Linus Torvalds 已提交
752 753 754 755 756 757 758 759 760 761
	}

	dir_i->i_mtime = dir_i->i_ctime = ITIME(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);

762
	mutex_unlock(&dir_f->sem);
L
Linus Torvalds 已提交
763 764 765
	jffs2_complete_reservation(c);

	d_instantiate(dentry, inode);
766
	unlock_new_inode(inode);
L
Linus Torvalds 已提交
767
	return 0;
768 769

 fail:
A
Al Viro 已提交
770
	iget_failed(inode);
771
	return ret;
L
Linus Torvalds 已提交
772 773 774
}

static int jffs2_rename (struct inode *old_dir_i, struct dentry *old_dentry,
D
David Woodhouse 已提交
775
			 struct inode *new_dir_i, struct dentry *new_dentry)
L
Linus Torvalds 已提交
776 777 778 779 780
{
	int ret;
	struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
	struct jffs2_inode_info *victim_f = NULL;
	uint8_t type;
781
	uint32_t now;
L
Linus Torvalds 已提交
782

783
	/* The VFS will check for us and prevent trying to rename a
L
Linus Torvalds 已提交
784 785 786 787 788 789 790 791 792
	 * file over a directory and vice versa, but if it's a directory,
	 * the VFS can't check whether the victim is empty. The filesystem
	 * needs to do that for itself.
	 */
	if (new_dentry->d_inode) {
		victim_f = JFFS2_INODE_INFO(new_dentry->d_inode);
		if (S_ISDIR(new_dentry->d_inode->i_mode)) {
			struct jffs2_full_dirent *fd;

793
			mutex_lock(&victim_f->sem);
L
Linus Torvalds 已提交
794 795
			for (fd = victim_f->dents; fd; fd = fd->next) {
				if (fd->ino) {
796
					mutex_unlock(&victim_f->sem);
L
Linus Torvalds 已提交
797 798 799
					return -ENOTEMPTY;
				}
			}
800
			mutex_unlock(&victim_f->sem);
L
Linus Torvalds 已提交
801 802 803 804
		}
	}

	/* XXX: We probably ought to alloc enough space for
805
	   both nodes at the same time. Writing the new link,
L
Linus Torvalds 已提交
806 807 808 809
	   then getting -ENOSPC, is quite bad :)
	*/

	/* Make a hard link */
810

L
Linus Torvalds 已提交
811 812 813 814
	/* XXX: This is ugly */
	type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12;
	if (!type) type = DT_REG;

815
	now = get_seconds();
816
	ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
L
Linus Torvalds 已提交
817
			    old_dentry->d_inode->i_ino, type,
818
			    new_dentry->d_name.name, new_dentry->d_name.len, now);
L
Linus Torvalds 已提交
819 820 821 822 823 824

	if (ret)
		return ret;

	if (victim_f) {
		/* There was a victim. Kill it off nicely */
825
		drop_nlink(new_dentry->d_inode);
L
Linus Torvalds 已提交
826 827 828
		/* Don't oops if the victim was a dirent pointing to an
		   inode which didn't exist. */
		if (victim_f->inocache) {
829
			mutex_lock(&victim_f->sem);
830 831 832 833
			if (S_ISDIR(new_dentry->d_inode->i_mode))
				victim_f->inocache->pino_nlink = 0;
			else
				victim_f->inocache->pino_nlink--;
834
			mutex_unlock(&victim_f->sem);
L
Linus Torvalds 已提交
835 836 837
		}
	}

838
	/* If it was a directory we moved, and there was no victim,
L
Linus Torvalds 已提交
839 840
	   increase i_nlink on its new parent */
	if (S_ISDIR(old_dentry->d_inode->i_mode) && !victim_f)
841
		inc_nlink(new_dir_i);
L
Linus Torvalds 已提交
842 843

	/* Unlink the original */
844
	ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i),
845
			      old_dentry->d_name.name, old_dentry->d_name.len, NULL, now);
L
Linus Torvalds 已提交
846 847 848 849 850 851

	/* We don't touch inode->i_nlink */

	if (ret) {
		/* Oh shit. We really ought to make a single node which can do both atomically */
		struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode);
852
		mutex_lock(&f->sem);
853
		inc_nlink(old_dentry->d_inode);
854 855
		if (f->inocache && !S_ISDIR(old_dentry->d_inode->i_mode))
			f->inocache->pino_nlink++;
856
		mutex_unlock(&f->sem);
L
Linus Torvalds 已提交
857 858 859 860

		printk(KERN_NOTICE "jffs2_rename(): Link succeeded, unlink failed (err %d). You now have a hard link\n", ret);
		/* Might as well let the VFS know */
		d_instantiate(new_dentry, old_dentry->d_inode);
A
Al Viro 已提交
861
		ihold(old_dentry->d_inode);
862
		new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now);
L
Linus Torvalds 已提交
863 864 865 866
		return ret;
	}

	if (S_ISDIR(old_dentry->d_inode->i_mode))
867
		drop_nlink(old_dir_i);
L
Linus Torvalds 已提交
868

869 870
	new_dir_i->i_mtime = new_dir_i->i_ctime = old_dir_i->i_mtime = old_dir_i->i_ctime = ITIME(now);

L
Linus Torvalds 已提交
871 872 873
	return 0;
}