xref: /openbmc/linux/fs/jffs2/write.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  * JFFS2 -- Journalling Flash File System, Version 2.
3  *
4  * Copyright (C) 2001-2003 Red Hat, Inc.
5  *
6  * Created by David Woodhouse <dwmw2@infradead.org>
7  *
8  * For licensing information, see the file 'LICENCE' in this directory.
9  *
10  * $Id: write.c,v 1.92 2005/04/13 13:22:35 dwmw2 Exp $
11  *
12  */
13 
14 #include <linux/kernel.h>
15 #include <linux/fs.h>
16 #include <linux/crc32.h>
17 #include <linux/slab.h>
18 #include <linux/pagemap.h>
19 #include <linux/mtd/mtd.h>
20 #include "nodelist.h"
21 #include "compr.h"
22 
23 
24 int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri)
25 {
26 	struct jffs2_inode_cache *ic;
27 
28 	ic = jffs2_alloc_inode_cache();
29 	if (!ic) {
30 		return -ENOMEM;
31 	}
32 
33 	memset(ic, 0, sizeof(*ic));
34 
35 	f->inocache = ic;
36 	f->inocache->nlink = 1;
37 	f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
38 	f->inocache->state = INO_STATE_PRESENT;
39 
40 
41 	jffs2_add_ino_cache(c, f->inocache);
42 	D1(printk(KERN_DEBUG "jffs2_do_new_inode(): Assigned ino# %d\n", f->inocache->ino));
43 	ri->ino = cpu_to_je32(f->inocache->ino);
44 
45 	ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
46 	ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
47 	ri->totlen = cpu_to_je32(PAD(sizeof(*ri)));
48 	ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
49 	ri->mode = cpu_to_jemode(mode);
50 
51 	f->highest_version = 1;
52 	ri->version = cpu_to_je32(f->highest_version);
53 
54 	return 0;
55 }
56 
57 #if CONFIG_JFFS2_FS_DEBUG > 0
58 static void writecheck(struct jffs2_sb_info *c, uint32_t ofs)
59 {
60 	unsigned char buf[16];
61 	size_t retlen;
62 	int ret, i;
63 
64 	ret = jffs2_flash_read(c, ofs, 16, &retlen, buf);
65 	if (ret || (retlen != 16)) {
66 		D1(printk(KERN_DEBUG "read failed or short in writecheck(). ret %d, retlen %zd\n", ret, retlen));
67 		return;
68 	}
69 	ret = 0;
70 	for (i=0; i<16; i++) {
71 		if (buf[i] != 0xff)
72 			ret = 1;
73 	}
74 	if (ret) {
75 		printk(KERN_WARNING "ARGH. About to write node to 0x%08x on flash, but there are data already there:\n", ofs);
76 		printk(KERN_WARNING "0x%08x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
77 		       ofs,
78 		       buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
79 		       buf[8], buf[9], buf[10], buf[11], buf[12], buf[13], buf[14], buf[15]);
80 	}
81 }
82 #endif
83 
84 
85 /* jffs2_write_dnode - given a raw_inode, allocate a full_dnode for it,
86    write it to the flash, link it into the existing inode/fragment list */
87 
88 struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const unsigned char *data, uint32_t datalen, uint32_t flash_ofs, int alloc_mode)
89 
90 {
91 	struct jffs2_raw_node_ref *raw;
92 	struct jffs2_full_dnode *fn;
93 	size_t retlen;
94 	struct kvec vecs[2];
95 	int ret;
96 	int retried = 0;
97 	unsigned long cnt = 2;
98 
99 	D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) {
100 		printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dnode()\n");
101 		BUG();
102 	}
103 	   );
104 	vecs[0].iov_base = ri;
105 	vecs[0].iov_len = sizeof(*ri);
106 	vecs[1].iov_base = (unsigned char *)data;
107 	vecs[1].iov_len = datalen;
108 
109 	D1(writecheck(c, flash_ofs));
110 
111 	if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
112 		printk(KERN_WARNING "jffs2_write_dnode: ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n", je32_to_cpu(ri->totlen), sizeof(*ri), datalen);
113 	}
114 	raw = jffs2_alloc_raw_node_ref();
115 	if (!raw)
116 		return ERR_PTR(-ENOMEM);
117 
118 	fn = jffs2_alloc_full_dnode();
119 	if (!fn) {
120 		jffs2_free_raw_node_ref(raw);
121 		return ERR_PTR(-ENOMEM);
122 	}
123 
124 	fn->ofs = je32_to_cpu(ri->offset);
125 	fn->size = je32_to_cpu(ri->dsize);
126 	fn->frags = 0;
127 
128 	/* check number of valid vecs */
129 	if (!datalen || !data)
130 		cnt = 1;
131  retry:
132 	fn->raw = raw;
133 
134 	raw->flash_offset = flash_ofs;
135 	raw->__totlen = PAD(sizeof(*ri)+datalen);
136 	raw->next_phys = NULL;
137 
138 	if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
139 		BUG_ON(!retried);
140 		D1(printk(KERN_DEBUG "jffs2_write_dnode : dnode_version %d, "
141 				"highest version %d -> updating dnode\n",
142 				je32_to_cpu(ri->version), f->highest_version));
143 		ri->version = cpu_to_je32(++f->highest_version);
144 		ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
145 	}
146 
147 	ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
148 				 (alloc_mode==ALLOC_GC)?0:f->inocache->ino);
149 
150 	if (ret || (retlen != sizeof(*ri) + datalen)) {
151 		printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
152 		       sizeof(*ri)+datalen, flash_ofs, ret, retlen);
153 
154 		/* Mark the space as dirtied */
155 		if (retlen) {
156 			/* Doesn't belong to any inode */
157 			raw->next_in_ino = NULL;
158 
159 			/* Don't change raw->size to match retlen. We may have
160 			   written the node header already, and only the data will
161 			   seem corrupted, in which case the scan would skip over
162 			   any node we write before the original intended end of
163 			   this node */
164 			raw->flash_offset |= REF_OBSOLETE;
165 			jffs2_add_physical_node_ref(c, raw);
166 			jffs2_mark_node_obsolete(c, raw);
167 		} else {
168 			printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
169 			jffs2_free_raw_node_ref(raw);
170 		}
171 		if (!retried && alloc_mode != ALLOC_NORETRY && (raw = jffs2_alloc_raw_node_ref())) {
172 			/* Try to reallocate space and retry */
173 			uint32_t dummy;
174 			struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
175 
176 			retried = 1;
177 
178 			D1(printk(KERN_DEBUG "Retrying failed write.\n"));
179 
180 			ACCT_SANITY_CHECK(c,jeb);
181 			D1(ACCT_PARANOIA_CHECK(jeb));
182 
183 			if (alloc_mode == ALLOC_GC) {
184 				ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &flash_ofs, &dummy);
185 			} else {
186 				/* Locking pain */
187 				up(&f->sem);
188 				jffs2_complete_reservation(c);
189 
190 				ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &flash_ofs, &dummy, alloc_mode);
191 				down(&f->sem);
192 			}
193 
194 			if (!ret) {
195 				D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
196 
197 				ACCT_SANITY_CHECK(c,jeb);
198 				D1(ACCT_PARANOIA_CHECK(jeb));
199 
200 				goto retry;
201 			}
202 			D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
203 			jffs2_free_raw_node_ref(raw);
204 		}
205 		/* Release the full_dnode which is now useless, and return */
206 		jffs2_free_full_dnode(fn);
207 		return ERR_PTR(ret?ret:-EIO);
208 	}
209 	/* Mark the space used */
210 	/* If node covers at least a whole page, or if it starts at the
211 	   beginning of a page and runs to the end of the file, or if
212 	   it's a hole node, mark it REF_PRISTINE, else REF_NORMAL.
213 	*/
214 	if ((je32_to_cpu(ri->dsize) >= PAGE_CACHE_SIZE) ||
215 	    ( ((je32_to_cpu(ri->offset)&(PAGE_CACHE_SIZE-1))==0) &&
216 	      (je32_to_cpu(ri->dsize)+je32_to_cpu(ri->offset) ==  je32_to_cpu(ri->isize)))) {
217 		raw->flash_offset |= REF_PRISTINE;
218 	} else {
219 		raw->flash_offset |= REF_NORMAL;
220 	}
221 	jffs2_add_physical_node_ref(c, raw);
222 
223 	/* Link into per-inode list */
224 	spin_lock(&c->erase_completion_lock);
225 	raw->next_in_ino = f->inocache->nodes;
226 	f->inocache->nodes = raw;
227 	spin_unlock(&c->erase_completion_lock);
228 
229 	D1(printk(KERN_DEBUG "jffs2_write_dnode wrote node at 0x%08x(%d) with dsize 0x%x, csize 0x%x, node_crc 0x%08x, data_crc 0x%08x, totlen 0x%08x\n",
230 		  flash_ofs, ref_flags(raw), je32_to_cpu(ri->dsize),
231 		  je32_to_cpu(ri->csize), je32_to_cpu(ri->node_crc),
232 		  je32_to_cpu(ri->data_crc), je32_to_cpu(ri->totlen)));
233 
234 	if (retried) {
235 		ACCT_SANITY_CHECK(c,NULL);
236 	}
237 
238 	return fn;
239 }
240 
241 struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f, struct jffs2_raw_dirent *rd, const unsigned char *name, uint32_t namelen, uint32_t flash_ofs, int alloc_mode)
242 {
243 	struct jffs2_raw_node_ref *raw;
244 	struct jffs2_full_dirent *fd;
245 	size_t retlen;
246 	struct kvec vecs[2];
247 	int retried = 0;
248 	int ret;
249 
250 	D1(printk(KERN_DEBUG "jffs2_write_dirent(ino #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x)\n",
251 		  je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino),
252 		  je32_to_cpu(rd->name_crc)));
253 	D1(writecheck(c, flash_ofs));
254 
255 	D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) {
256 		printk(KERN_CRIT "Eep. CRC not correct in jffs2_write_dirent()\n");
257 		BUG();
258 	}
259 	   );
260 
261 	vecs[0].iov_base = rd;
262 	vecs[0].iov_len = sizeof(*rd);
263 	vecs[1].iov_base = (unsigned char *)name;
264 	vecs[1].iov_len = namelen;
265 
266 	raw = jffs2_alloc_raw_node_ref();
267 
268 	if (!raw)
269 		return ERR_PTR(-ENOMEM);
270 
271 	fd = jffs2_alloc_full_dirent(namelen+1);
272 	if (!fd) {
273 		jffs2_free_raw_node_ref(raw);
274 		return ERR_PTR(-ENOMEM);
275 	}
276 
277 	fd->version = je32_to_cpu(rd->version);
278 	fd->ino = je32_to_cpu(rd->ino);
279 	fd->nhash = full_name_hash(name, strlen(name));
280 	fd->type = rd->type;
281 	memcpy(fd->name, name, namelen);
282 	fd->name[namelen]=0;
283 
284  retry:
285 	fd->raw = raw;
286 
287 	raw->flash_offset = flash_ofs;
288 	raw->__totlen = PAD(sizeof(*rd)+namelen);
289 	raw->next_phys = NULL;
290 
291 	if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
292 		BUG_ON(!retried);
293 		D1(printk(KERN_DEBUG "jffs2_write_dirent : dirent_version %d, "
294 				     "highest version %d -> updating dirent\n",
295 				     je32_to_cpu(rd->version), f->highest_version));
296 		rd->version = cpu_to_je32(++f->highest_version);
297 		fd->version = je32_to_cpu(rd->version);
298 		rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
299 	}
300 
301 	ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
302 				 (alloc_mode==ALLOC_GC)?0:je32_to_cpu(rd->pino));
303 	if (ret || (retlen != sizeof(*rd) + namelen)) {
304 		printk(KERN_NOTICE "Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
305 			       sizeof(*rd)+namelen, flash_ofs, ret, retlen);
306 		/* Mark the space as dirtied */
307 		if (retlen) {
308 			raw->next_in_ino = NULL;
309 			raw->flash_offset |= REF_OBSOLETE;
310 			jffs2_add_physical_node_ref(c, raw);
311 			jffs2_mark_node_obsolete(c, raw);
312 		} else {
313 			printk(KERN_NOTICE "Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n", raw->flash_offset);
314 			jffs2_free_raw_node_ref(raw);
315 		}
316 		if (!retried && (raw = jffs2_alloc_raw_node_ref())) {
317 			/* Try to reallocate space and retry */
318 			uint32_t dummy;
319 			struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
320 
321 			retried = 1;
322 
323 			D1(printk(KERN_DEBUG "Retrying failed write.\n"));
324 
325 			ACCT_SANITY_CHECK(c,jeb);
326 			D1(ACCT_PARANOIA_CHECK(jeb));
327 
328 			if (alloc_mode == ALLOC_GC) {
329 				ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &flash_ofs, &dummy);
330 			} else {
331 				/* Locking pain */
332 				up(&f->sem);
333 				jffs2_complete_reservation(c);
334 
335 				ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &flash_ofs, &dummy, alloc_mode);
336 				down(&f->sem);
337 			}
338 
339 			if (!ret) {
340 				D1(printk(KERN_DEBUG "Allocated space at 0x%08x to retry failed write.\n", flash_ofs));
341 				ACCT_SANITY_CHECK(c,jeb);
342 				D1(ACCT_PARANOIA_CHECK(jeb));
343 				goto retry;
344 			}
345 			D1(printk(KERN_DEBUG "Failed to allocate space to retry failed write: %d!\n", ret));
346 			jffs2_free_raw_node_ref(raw);
347 		}
348 		/* Release the full_dnode which is now useless, and return */
349 		jffs2_free_full_dirent(fd);
350 		return ERR_PTR(ret?ret:-EIO);
351 	}
352 	/* Mark the space used */
353 	raw->flash_offset |= REF_PRISTINE;
354 	jffs2_add_physical_node_ref(c, raw);
355 
356 	spin_lock(&c->erase_completion_lock);
357 	raw->next_in_ino = f->inocache->nodes;
358 	f->inocache->nodes = raw;
359 	spin_unlock(&c->erase_completion_lock);
360 
361 	if (retried) {
362 		ACCT_SANITY_CHECK(c,NULL);
363 	}
364 
365 	return fd;
366 }
367 
368 /* The OS-specific code fills in the metadata in the jffs2_raw_inode for us, so that
369    we don't have to go digging in struct inode or its equivalent. It should set:
370    mode, uid, gid, (starting)isize, atime, ctime, mtime */
371 int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
372 			    struct jffs2_raw_inode *ri, unsigned char *buf,
373 			    uint32_t offset, uint32_t writelen, uint32_t *retlen)
374 {
375 	int ret = 0;
376 	uint32_t writtenlen = 0;
377 
378        	D1(printk(KERN_DEBUG "jffs2_write_inode_range(): Ino #%u, ofs 0x%x, len 0x%x\n",
379 		  f->inocache->ino, offset, writelen));
380 
381 	while(writelen) {
382 		struct jffs2_full_dnode *fn;
383 		unsigned char *comprbuf = NULL;
384 		uint16_t comprtype = JFFS2_COMPR_NONE;
385 		uint32_t phys_ofs, alloclen;
386 		uint32_t datalen, cdatalen;
387 		int retried = 0;
388 
389 	retry:
390 		D2(printk(KERN_DEBUG "jffs2_commit_write() loop: 0x%x to write to 0x%x\n", writelen, offset));
391 
392 		ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN, &phys_ofs, &alloclen, ALLOC_NORMAL);
393 		if (ret) {
394 			D1(printk(KERN_DEBUG "jffs2_reserve_space returned %d\n", ret));
395 			break;
396 		}
397 		down(&f->sem);
398 		datalen = min_t(uint32_t, writelen, PAGE_CACHE_SIZE - (offset & (PAGE_CACHE_SIZE-1)));
399 		cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
400 
401 		comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
402 
403 		ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
404 		ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
405 		ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
406 		ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
407 
408 		ri->ino = cpu_to_je32(f->inocache->ino);
409 		ri->version = cpu_to_je32(++f->highest_version);
410 		ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
411 		ri->offset = cpu_to_je32(offset);
412 		ri->csize = cpu_to_je32(cdatalen);
413 		ri->dsize = cpu_to_je32(datalen);
414 		ri->compr = comprtype & 0xff;
415 		ri->usercompr = (comprtype >> 8 ) & 0xff;
416 		ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
417 		ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
418 
419 		fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, phys_ofs, ALLOC_NORETRY);
420 
421 		jffs2_free_comprbuf(comprbuf, buf);
422 
423 		if (IS_ERR(fn)) {
424 			ret = PTR_ERR(fn);
425 			up(&f->sem);
426 			jffs2_complete_reservation(c);
427 			if (!retried) {
428 				/* Write error to be retried */
429 				retried = 1;
430 				D1(printk(KERN_DEBUG "Retrying node write in jffs2_write_inode_range()\n"));
431 				goto retry;
432 			}
433 			break;
434 		}
435 		ret = jffs2_add_full_dnode_to_inode(c, f, fn);
436 		if (f->metadata) {
437 			jffs2_mark_node_obsolete(c, f->metadata->raw);
438 			jffs2_free_full_dnode(f->metadata);
439 			f->metadata = NULL;
440 		}
441 		if (ret) {
442 			/* Eep */
443 			D1(printk(KERN_DEBUG "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n", ret));
444 			jffs2_mark_node_obsolete(c, fn->raw);
445 			jffs2_free_full_dnode(fn);
446 
447 			up(&f->sem);
448 			jffs2_complete_reservation(c);
449 			break;
450 		}
451 		up(&f->sem);
452 		jffs2_complete_reservation(c);
453 		if (!datalen) {
454 			printk(KERN_WARNING "Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
455 			ret = -EIO;
456 			break;
457 		}
458 		D1(printk(KERN_DEBUG "increasing writtenlen by %d\n", datalen));
459 		writtenlen += datalen;
460 		offset += datalen;
461 		writelen -= datalen;
462 		buf += datalen;
463 	}
464 	*retlen = writtenlen;
465 	return ret;
466 }
467 
468 int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const char *name, int namelen)
469 {
470 	struct jffs2_raw_dirent *rd;
471 	struct jffs2_full_dnode *fn;
472 	struct jffs2_full_dirent *fd;
473 	uint32_t alloclen, phys_ofs;
474 	int ret;
475 
476 	/* Try to reserve enough space for both node and dirent.
477 	 * Just the node will do for now, though
478 	 */
479 	ret = jffs2_reserve_space(c, sizeof(*ri), &phys_ofs, &alloclen, ALLOC_NORMAL);
480 	D1(printk(KERN_DEBUG "jffs2_do_create(): reserved 0x%x bytes\n", alloclen));
481 	if (ret) {
482 		up(&f->sem);
483 		return ret;
484 	}
485 
486 	ri->data_crc = cpu_to_je32(0);
487 	ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
488 
489 	fn = jffs2_write_dnode(c, f, ri, NULL, 0, phys_ofs, ALLOC_NORMAL);
490 
491 	D1(printk(KERN_DEBUG "jffs2_do_create created file with mode 0x%x\n",
492 		  jemode_to_cpu(ri->mode)));
493 
494 	if (IS_ERR(fn)) {
495 		D1(printk(KERN_DEBUG "jffs2_write_dnode() failed\n"));
496 		/* Eeek. Wave bye bye */
497 		up(&f->sem);
498 		jffs2_complete_reservation(c);
499 		return PTR_ERR(fn);
500 	}
501 	/* No data here. Only a metadata node, which will be
502 	   obsoleted by the first data write
503 	*/
504 	f->metadata = fn;
505 
506 	up(&f->sem);
507 	jffs2_complete_reservation(c);
508 	ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL);
509 
510 	if (ret) {
511 		/* Eep. */
512 		D1(printk(KERN_DEBUG "jffs2_reserve_space() for dirent failed\n"));
513 		return ret;
514 	}
515 
516 	rd = jffs2_alloc_raw_dirent();
517 	if (!rd) {
518 		/* Argh. Now we treat it like a normal delete */
519 		jffs2_complete_reservation(c);
520 		return -ENOMEM;
521 	}
522 
523 	down(&dir_f->sem);
524 
525 	rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
526 	rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
527 	rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
528 	rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
529 
530 	rd->pino = cpu_to_je32(dir_f->inocache->ino);
531 	rd->version = cpu_to_je32(++dir_f->highest_version);
532 	rd->ino = ri->ino;
533 	rd->mctime = ri->ctime;
534 	rd->nsize = namelen;
535 	rd->type = DT_REG;
536 	rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
537 	rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
538 
539 	fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_NORMAL);
540 
541 	jffs2_free_raw_dirent(rd);
542 
543 	if (IS_ERR(fd)) {
544 		/* dirent failed to write. Delete the inode normally
545 		   as if it were the final unlink() */
546 		jffs2_complete_reservation(c);
547 		up(&dir_f->sem);
548 		return PTR_ERR(fd);
549 	}
550 
551 	/* Link the fd into the inode's list, obsoleting an old
552 	   one if necessary. */
553 	jffs2_add_fd_to_list(c, fd, &dir_f->dents);
554 
555 	jffs2_complete_reservation(c);
556 	up(&dir_f->sem);
557 
558 	return 0;
559 }
560 
561 
562 int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f,
563 		    const char *name, int namelen, struct jffs2_inode_info *dead_f)
564 {
565 	struct jffs2_raw_dirent *rd;
566 	struct jffs2_full_dirent *fd;
567 	uint32_t alloclen, phys_ofs;
568 	int ret;
569 
570 	if (1 /* alternative branch needs testing */ ||
571 	    !jffs2_can_mark_obsolete(c)) {
572 		/* We can't mark stuff obsolete on the medium. We need to write a deletion dirent */
573 
574 		rd = jffs2_alloc_raw_dirent();
575 		if (!rd)
576 			return -ENOMEM;
577 
578 		ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_DELETION);
579 		if (ret) {
580 			jffs2_free_raw_dirent(rd);
581 			return ret;
582 		}
583 
584 		down(&dir_f->sem);
585 
586 		/* Build a deletion node */
587 		rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
588 		rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
589 		rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
590 		rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
591 
592 		rd->pino = cpu_to_je32(dir_f->inocache->ino);
593 		rd->version = cpu_to_je32(++dir_f->highest_version);
594 		rd->ino = cpu_to_je32(0);
595 		rd->mctime = cpu_to_je32(get_seconds());
596 		rd->nsize = namelen;
597 		rd->type = DT_UNKNOWN;
598 		rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
599 		rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
600 
601 		fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_DELETION);
602 
603 		jffs2_free_raw_dirent(rd);
604 
605 		if (IS_ERR(fd)) {
606 			jffs2_complete_reservation(c);
607 			up(&dir_f->sem);
608 			return PTR_ERR(fd);
609 		}
610 
611 		/* File it. This will mark the old one obsolete. */
612 		jffs2_add_fd_to_list(c, fd, &dir_f->dents);
613 		up(&dir_f->sem);
614 	} else {
615 		struct jffs2_full_dirent **prev = &dir_f->dents;
616 		uint32_t nhash = full_name_hash(name, namelen);
617 
618 		down(&dir_f->sem);
619 
620 		while ((*prev) && (*prev)->nhash <= nhash) {
621 			if ((*prev)->nhash == nhash &&
622 			    !memcmp((*prev)->name, name, namelen) &&
623 			    !(*prev)->name[namelen]) {
624 				struct jffs2_full_dirent *this = *prev;
625 
626 				D1(printk(KERN_DEBUG "Marking old dirent node (ino #%u) @%08x obsolete\n",
627 					  this->ino, ref_offset(this->raw)));
628 
629 				*prev = this->next;
630 				jffs2_mark_node_obsolete(c, (this->raw));
631 				jffs2_free_full_dirent(this);
632 				break;
633 			}
634 			prev = &((*prev)->next);
635 		}
636 		up(&dir_f->sem);
637 	}
638 
639 	/* dead_f is NULL if this was a rename not a real unlink */
640 	/* Also catch the !f->inocache case, where there was a dirent
641 	   pointing to an inode which didn't exist. */
642 	if (dead_f && dead_f->inocache) {
643 
644 		down(&dead_f->sem);
645 
646 		if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
647 			while (dead_f->dents) {
648 				/* There can be only deleted ones */
649 				fd = dead_f->dents;
650 
651 				dead_f->dents = fd->next;
652 
653 				if (fd->ino) {
654 					printk(KERN_WARNING "Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
655 					       dead_f->inocache->ino, fd->name, fd->ino);
656 				} else {
657 					D1(printk(KERN_DEBUG "Removing deletion dirent for \"%s\" from dir ino #%u\n",
658 						fd->name, dead_f->inocache->ino));
659 				}
660 				jffs2_mark_node_obsolete(c, fd->raw);
661 				jffs2_free_full_dirent(fd);
662 			}
663 		}
664 
665 		dead_f->inocache->nlink--;
666 		/* NB: Caller must set inode nlink if appropriate */
667 		up(&dead_f->sem);
668 	}
669 
670 	jffs2_complete_reservation(c);
671 
672 	return 0;
673 }
674 
675 
676 int jffs2_do_link (struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, uint32_t ino, uint8_t type, const char *name, int namelen)
677 {
678 	struct jffs2_raw_dirent *rd;
679 	struct jffs2_full_dirent *fd;
680 	uint32_t alloclen, phys_ofs;
681 	int ret;
682 
683 	rd = jffs2_alloc_raw_dirent();
684 	if (!rd)
685 		return -ENOMEM;
686 
687 	ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &phys_ofs, &alloclen, ALLOC_NORMAL);
688 	if (ret) {
689 		jffs2_free_raw_dirent(rd);
690 		return ret;
691 	}
692 
693 	down(&dir_f->sem);
694 
695 	/* Build a deletion node */
696 	rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
697 	rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
698 	rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
699 	rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
700 
701 	rd->pino = cpu_to_je32(dir_f->inocache->ino);
702 	rd->version = cpu_to_je32(++dir_f->highest_version);
703 	rd->ino = cpu_to_je32(ino);
704 	rd->mctime = cpu_to_je32(get_seconds());
705 	rd->nsize = namelen;
706 
707 	rd->type = type;
708 
709 	rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
710 	rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
711 
712 	fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, phys_ofs, ALLOC_NORMAL);
713 
714 	jffs2_free_raw_dirent(rd);
715 
716 	if (IS_ERR(fd)) {
717 		jffs2_complete_reservation(c);
718 		up(&dir_f->sem);
719 		return PTR_ERR(fd);
720 	}
721 
722 	/* File it. This will mark the old one obsolete. */
723 	jffs2_add_fd_to_list(c, fd, &dir_f->dents);
724 
725 	jffs2_complete_reservation(c);
726 	up(&dir_f->sem);
727 
728 	return 0;
729 }
730