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