aboutsummaryrefslogtreecommitdiffstats
path: root/fs/jffs/inode-v23.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/jffs/inode-v23.c')
-rw-r--r--fs/jffs/inode-v23.c1847
1 files changed, 1847 insertions, 0 deletions
diff --git a/fs/jffs/inode-v23.c b/fs/jffs/inode-v23.c
new file mode 100644
index 000000000000..bfbeb4c86e03
--- /dev/null
+++ b/fs/jffs/inode-v23.c
@@ -0,0 +1,1847 @@
1/*
2 * JFFS -- Journalling Flash File System, Linux implementation.
3 *
4 * Copyright (C) 1999, 2000 Axis Communications AB.
5 *
6 * Created by Finn Hakansson <finn@axis.com>.
7 *
8 * This is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * $Id: inode-v23.c,v 1.70 2001/10/02 09:16:02 dwmw2 Exp $
14 *
15 * Ported to Linux 2.3.x and MTD:
16 * Copyright (C) 2000 Alexander Larsson (alex@cendio.se), Cendio Systems AB
17 *
18 * Copyright 2000, 2001 Red Hat, Inc.
19 */
20
21/* inode.c -- Contains the code that is called from the VFS. */
22
23/* TODO-ALEX:
24 * uid and gid are just 16 bit.
25 * jffs_file_write reads from user-space pointers without xx_from_user
26 * maybe other stuff do to.
27 */
28
29#include <linux/time.h>
30
31#include <linux/module.h>
32#include <linux/init.h>
33#include <linux/types.h>
34#include <linux/errno.h>
35#include <linux/slab.h>
36#include <linux/jffs.h>
37#include <linux/fs.h>
38#include <linux/smp_lock.h>
39#include <linux/ioctl.h>
40#include <linux/stat.h>
41#include <linux/blkdev.h>
42#include <linux/quotaops.h>
43#include <linux/highmem.h>
44#include <linux/vfs.h>
45#include <asm/semaphore.h>
46#include <asm/byteorder.h>
47#include <asm/uaccess.h>
48
49#include "jffs_fm.h"
50#include "intrep.h"
51#ifdef CONFIG_JFFS_PROC_FS
52#include "jffs_proc.h"
53#endif
54
55static int jffs_remove(struct inode *dir, struct dentry *dentry, int type);
56
57static struct super_operations jffs_ops;
58static struct file_operations jffs_file_operations;
59static struct inode_operations jffs_file_inode_operations;
60static struct file_operations jffs_dir_operations;
61static struct inode_operations jffs_dir_inode_operations;
62static struct address_space_operations jffs_address_operations;
63
64kmem_cache_t *node_cache = NULL;
65kmem_cache_t *fm_cache = NULL;
66
67/* Called by the VFS at mount time to initialize the whole file system. */
68static int jffs_fill_super(struct super_block *sb, void *data, int silent)
69{
70 struct inode *root_inode;
71 struct jffs_control *c;
72
73 sb->s_flags |= MS_NODIRATIME;
74
75 D1(printk(KERN_NOTICE "JFFS: Trying to mount device %s.\n",
76 sb->s_id));
77
78 if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) {
79 printk(KERN_WARNING "JFFS: Trying to mount a "
80 "non-mtd device.\n");
81 return -EINVAL;
82 }
83
84 sb->s_blocksize = PAGE_CACHE_SIZE;
85 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
86 sb->s_fs_info = (void *) 0;
87 sb->s_maxbytes = 0xFFFFFFFF;
88
89 /* Build the file system. */
90 if (jffs_build_fs(sb) < 0) {
91 goto jffs_sb_err1;
92 }
93
94 /*
95 * set up enough so that we can read an inode
96 */
97 sb->s_magic = JFFS_MAGIC_SB_BITMASK;
98 sb->s_op = &jffs_ops;
99
100 root_inode = iget(sb, JFFS_MIN_INO);
101 if (!root_inode)
102 goto jffs_sb_err2;
103
104 /* Get the root directory of this file system. */
105 if (!(sb->s_root = d_alloc_root(root_inode))) {
106 goto jffs_sb_err3;
107 }
108
109 c = (struct jffs_control *) sb->s_fs_info;
110
111#ifdef CONFIG_JFFS_PROC_FS
112 /* Set up the jffs proc file system. */
113 if (jffs_register_jffs_proc_dir(MINOR(sb->s_dev), c) < 0) {
114 printk(KERN_WARNING "JFFS: Failed to initialize the JFFS "
115 "proc file system for device %s.\n",
116 sb->s_id);
117 }
118#endif
119
120 /* Set the Garbage Collection thresholds */
121
122 /* GC if free space goes below 5% of the total size */
123 c->gc_minfree_threshold = c->fmc->flash_size / 20;
124
125 if (c->gc_minfree_threshold < c->fmc->sector_size)
126 c->gc_minfree_threshold = c->fmc->sector_size;
127
128 /* GC if dirty space exceeds 33% of the total size. */
129 c->gc_maxdirty_threshold = c->fmc->flash_size / 3;
130
131 if (c->gc_maxdirty_threshold < c->fmc->sector_size)
132 c->gc_maxdirty_threshold = c->fmc->sector_size;
133
134
135 c->thread_pid = kernel_thread (jffs_garbage_collect_thread,
136 (void *) c,
137 CLONE_KERNEL);
138 D1(printk(KERN_NOTICE "JFFS: GC thread pid=%d.\n", (int) c->thread_pid));
139
140 D1(printk(KERN_NOTICE "JFFS: Successfully mounted device %s.\n",
141 sb->s_id));
142 return 0;
143
144jffs_sb_err3:
145 iput(root_inode);
146jffs_sb_err2:
147 jffs_cleanup_control((struct jffs_control *)sb->s_fs_info);
148jffs_sb_err1:
149 printk(KERN_WARNING "JFFS: Failed to mount device %s.\n",
150 sb->s_id);
151 return -EINVAL;
152}
153
154
155/* This function is called when the file system is umounted. */
156static void
157jffs_put_super(struct super_block *sb)
158{
159 struct jffs_control *c = (struct jffs_control *) sb->s_fs_info;
160
161 D2(printk("jffs_put_super()\n"));
162
163#ifdef CONFIG_JFFS_PROC_FS
164 jffs_unregister_jffs_proc_dir(c);
165#endif
166
167 if (c->gc_task) {
168 D1(printk (KERN_NOTICE "jffs_put_super(): Telling gc thread to die.\n"));
169 send_sig(SIGKILL, c->gc_task, 1);
170 }
171 wait_for_completion(&c->gc_thread_comp);
172
173 D1(printk (KERN_NOTICE "jffs_put_super(): Successfully waited on thread.\n"));
174
175 jffs_cleanup_control((struct jffs_control *)sb->s_fs_info);
176 D1(printk(KERN_NOTICE "JFFS: Successfully unmounted device %s.\n",
177 sb->s_id));
178}
179
180
181/* This function is called when user commands like chmod, chgrp and
182 chown are executed. System calls like trunc() results in a call
183 to this function. */
184static int
185jffs_setattr(struct dentry *dentry, struct iattr *iattr)
186{
187 struct inode *inode = dentry->d_inode;
188 struct jffs_raw_inode raw_inode;
189 struct jffs_control *c;
190 struct jffs_fmcontrol *fmc;
191 struct jffs_file *f;
192 struct jffs_node *new_node;
193 int update_all;
194 int res = 0;
195 int recoverable = 0;
196
197 lock_kernel();
198
199 if ((res = inode_change_ok(inode, iattr)))
200 goto out;
201
202 c = (struct jffs_control *)inode->i_sb->s_fs_info;
203 fmc = c->fmc;
204
205 D3(printk (KERN_NOTICE "notify_change(): down biglock\n"));
206 down(&fmc->biglock);
207
208 f = jffs_find_file(c, inode->i_ino);
209
210 ASSERT(if (!f) {
211 printk("jffs_setattr(): Invalid inode number: %lu\n",
212 inode->i_ino);
213 D3(printk (KERN_NOTICE "notify_change(): up biglock\n"));
214 up(&fmc->biglock);
215 res = -EINVAL;
216 goto out;
217 });
218
219 D1(printk("***jffs_setattr(): file: \"%s\", ino: %u\n",
220 f->name, f->ino));
221
222 update_all = iattr->ia_valid & ATTR_FORCE;
223
224 if ( (update_all || iattr->ia_valid & ATTR_SIZE)
225 && (iattr->ia_size + 128 < f->size) ) {
226 /* We're shrinking the file by more than 128 bytes.
227 We'll be able to GC and recover this space, so
228 allow it to go into the reserved space. */
229 recoverable = 1;
230 }
231
232 if (!(new_node = jffs_alloc_node())) {
233 D(printk("jffs_setattr(): Allocation failed!\n"));
234 D3(printk (KERN_NOTICE "notify_change(): up biglock\n"));
235 up(&fmc->biglock);
236 res = -ENOMEM;
237 goto out;
238 }
239
240 new_node->data_offset = 0;
241 new_node->removed_size = 0;
242 raw_inode.magic = JFFS_MAGIC_BITMASK;
243 raw_inode.ino = f->ino;
244 raw_inode.pino = f->pino;
245 raw_inode.mode = f->mode;
246 raw_inode.uid = f->uid;
247 raw_inode.gid = f->gid;
248 raw_inode.atime = f->atime;
249 raw_inode.mtime = f->mtime;
250 raw_inode.ctime = f->ctime;
251 raw_inode.dsize = 0;
252 raw_inode.offset = 0;
253 raw_inode.rsize = 0;
254 raw_inode.dsize = 0;
255 raw_inode.nsize = f->nsize;
256 raw_inode.nlink = f->nlink;
257 raw_inode.spare = 0;
258 raw_inode.rename = 0;
259 raw_inode.deleted = 0;
260
261 if (update_all || iattr->ia_valid & ATTR_MODE) {
262 raw_inode.mode = iattr->ia_mode;
263 inode->i_mode = iattr->ia_mode;
264 }
265 if (update_all || iattr->ia_valid & ATTR_UID) {
266 raw_inode.uid = iattr->ia_uid;
267 inode->i_uid = iattr->ia_uid;
268 }
269 if (update_all || iattr->ia_valid & ATTR_GID) {
270 raw_inode.gid = iattr->ia_gid;
271 inode->i_gid = iattr->ia_gid;
272 }
273 if (update_all || iattr->ia_valid & ATTR_SIZE) {
274 int len;
275 D1(printk("jffs_notify_change(): Changing size "
276 "to %lu bytes!\n", (long)iattr->ia_size));
277 raw_inode.offset = iattr->ia_size;
278
279 /* Calculate how many bytes need to be removed from
280 the end. */
281 if (f->size < iattr->ia_size) {
282 len = 0;
283 }
284 else {
285 len = f->size - iattr->ia_size;
286 }
287
288 raw_inode.rsize = len;
289
290 /* The updated node will be a removal node, with
291 base at the new size and size of the nbr of bytes
292 to be removed. */
293 new_node->data_offset = iattr->ia_size;
294 new_node->removed_size = len;
295 inode->i_size = iattr->ia_size;
296 inode->i_blocks = (inode->i_size + 511) >> 9;
297
298 if (len) {
299 invalidate_inode_pages(inode->i_mapping);
300 }
301 inode->i_ctime = CURRENT_TIME_SEC;
302 inode->i_mtime = inode->i_ctime;
303 }
304 if (update_all || iattr->ia_valid & ATTR_ATIME) {
305 raw_inode.atime = iattr->ia_atime.tv_sec;
306 inode->i_atime = iattr->ia_atime;
307 }
308 if (update_all || iattr->ia_valid & ATTR_MTIME) {
309 raw_inode.mtime = iattr->ia_mtime.tv_sec;
310 inode->i_mtime = iattr->ia_mtime;
311 }
312 if (update_all || iattr->ia_valid & ATTR_CTIME) {
313 raw_inode.ctime = iattr->ia_ctime.tv_sec;
314 inode->i_ctime = iattr->ia_ctime;
315 }
316
317 /* Write this node to the flash. */
318 if ((res = jffs_write_node(c, new_node, &raw_inode, f->name, NULL, recoverable, f)) < 0) {
319 D(printk("jffs_notify_change(): The write failed!\n"));
320 jffs_free_node(new_node);
321 D3(printk (KERN_NOTICE "n_c(): up biglock\n"));
322 up(&c->fmc->biglock);
323 goto out;
324 }
325
326 jffs_insert_node(c, f, &raw_inode, NULL, new_node);
327
328 mark_inode_dirty(inode);
329 D3(printk (KERN_NOTICE "n_c(): up biglock\n"));
330 up(&c->fmc->biglock);
331out:
332 unlock_kernel();
333 return res;
334} /* jffs_notify_change() */
335
336
337static struct inode *
338jffs_new_inode(const struct inode * dir, struct jffs_raw_inode *raw_inode,
339 int * err)
340{
341 struct super_block * sb;
342 struct inode * inode;
343 struct jffs_control *c;
344 struct jffs_file *f;
345
346 sb = dir->i_sb;
347 inode = new_inode(sb);
348 if (!inode) {
349 *err = -ENOMEM;
350 return NULL;
351 }
352
353 c = (struct jffs_control *)sb->s_fs_info;
354
355 inode->i_ino = raw_inode->ino;
356 inode->i_mode = raw_inode->mode;
357 inode->i_nlink = raw_inode->nlink;
358 inode->i_uid = raw_inode->uid;
359 inode->i_gid = raw_inode->gid;
360 inode->i_size = raw_inode->dsize;
361 inode->i_atime.tv_sec = raw_inode->atime;
362 inode->i_mtime.tv_sec = raw_inode->mtime;
363 inode->i_ctime.tv_sec = raw_inode->ctime;
364 inode->i_ctime.tv_nsec = 0;
365 inode->i_mtime.tv_nsec = 0;
366 inode->i_atime.tv_nsec = 0;
367 inode->i_blksize = PAGE_SIZE;
368 inode->i_blocks = (inode->i_size + 511) >> 9;
369
370 f = jffs_find_file(c, raw_inode->ino);
371
372 inode->u.generic_ip = (void *)f;
373 insert_inode_hash(inode);
374
375 return inode;
376}
377
378/* Get statistics of the file system. */
379static int
380jffs_statfs(struct super_block *sb, struct kstatfs *buf)
381{
382 struct jffs_control *c = (struct jffs_control *) sb->s_fs_info;
383 struct jffs_fmcontrol *fmc;
384
385 lock_kernel();
386
387 fmc = c->fmc;
388
389 D2(printk("jffs_statfs()\n"));
390
391 buf->f_type = JFFS_MAGIC_SB_BITMASK;
392 buf->f_bsize = PAGE_CACHE_SIZE;
393 buf->f_blocks = (fmc->flash_size / PAGE_CACHE_SIZE)
394 - (fmc->min_free_size / PAGE_CACHE_SIZE);
395 buf->f_bfree = (jffs_free_size1(fmc) + jffs_free_size2(fmc) +
396 fmc->dirty_size - fmc->min_free_size)
397 >> PAGE_CACHE_SHIFT;
398 buf->f_bavail = buf->f_bfree;
399
400 /* Find out how many files there are in the filesystem. */
401 buf->f_files = jffs_foreach_file(c, jffs_file_count);
402 buf->f_ffree = buf->f_bfree;
403 /* buf->f_fsid = 0; */
404 buf->f_namelen = JFFS_MAX_NAME_LEN;
405
406 unlock_kernel();
407
408 return 0;
409}
410
411
412/* Rename a file. */
413static int
414jffs_rename(struct inode *old_dir, struct dentry *old_dentry,
415 struct inode *new_dir, struct dentry *new_dentry)
416{
417 struct jffs_raw_inode raw_inode;
418 struct jffs_control *c;
419 struct jffs_file *old_dir_f;
420 struct jffs_file *new_dir_f;
421 struct jffs_file *del_f;
422 struct jffs_file *f;
423 struct jffs_node *node;
424 struct inode *inode;
425 int result = 0;
426 __u32 rename_data = 0;
427
428 D2(printk("***jffs_rename()\n"));
429
430 D(printk("jffs_rename(): old_dir: 0x%p, old name: 0x%p, "
431 "new_dir: 0x%p, new name: 0x%p\n",
432 old_dir, old_dentry->d_name.name,
433 new_dir, new_dentry->d_name.name));
434
435 lock_kernel();
436 c = (struct jffs_control *)old_dir->i_sb->s_fs_info;
437 ASSERT(if (!c) {
438 printk(KERN_ERR "jffs_rename(): The old_dir inode "
439 "didn't have a reference to a jffs_file struct\n");
440 unlock_kernel();
441 return -EIO;
442 });
443
444 result = -ENOTDIR;
445 if (!(old_dir_f = (struct jffs_file *)old_dir->u.generic_ip)) {
446 D(printk("jffs_rename(): Old dir invalid.\n"));
447 goto jffs_rename_end;
448 }
449
450 /* Try to find the file to move. */
451 result = -ENOENT;
452 if (!(f = jffs_find_child(old_dir_f, old_dentry->d_name.name,
453 old_dentry->d_name.len))) {
454 goto jffs_rename_end;
455 }
456
457 /* Find the new directory. */
458 result = -ENOTDIR;
459 if (!(new_dir_f = (struct jffs_file *)new_dir->u.generic_ip)) {
460 D(printk("jffs_rename(): New dir invalid.\n"));
461 goto jffs_rename_end;
462 }
463 D3(printk (KERN_NOTICE "rename(): down biglock\n"));
464 down(&c->fmc->biglock);
465 /* Create a node and initialize as much as needed. */
466 result = -ENOMEM;
467 if (!(node = jffs_alloc_node())) {
468 D(printk("jffs_rename(): Allocation failed: node == 0\n"));
469 goto jffs_rename_end;
470 }
471 node->data_offset = 0;
472 node->removed_size = 0;
473
474 /* Initialize the raw inode. */
475 raw_inode.magic = JFFS_MAGIC_BITMASK;
476 raw_inode.ino = f->ino;
477 raw_inode.pino = new_dir_f->ino;
478/* raw_inode.version = f->highest_version + 1; */
479 raw_inode.mode = f->mode;
480 raw_inode.uid = current->fsuid;
481 raw_inode.gid = current->fsgid;
482#if 0
483 raw_inode.uid = f->uid;
484 raw_inode.gid = f->gid;
485#endif
486 raw_inode.atime = get_seconds();
487 raw_inode.mtime = raw_inode.atime;
488 raw_inode.ctime = f->ctime;
489 raw_inode.offset = 0;
490 raw_inode.dsize = 0;
491 raw_inode.rsize = 0;
492 raw_inode.nsize = new_dentry->d_name.len;
493 raw_inode.nlink = f->nlink;
494 raw_inode.spare = 0;
495 raw_inode.rename = 0;
496 raw_inode.deleted = 0;
497
498 /* See if there already exists a file with the same name as
499 new_name. */
500 if ((del_f = jffs_find_child(new_dir_f, new_dentry->d_name.name,
501 new_dentry->d_name.len))) {
502 raw_inode.rename = 1;
503 raw_inode.dsize = sizeof(__u32);
504 rename_data = del_f->ino;
505 }
506
507 /* Write the new node to the flash memory. */
508 if ((result = jffs_write_node(c, node, &raw_inode,
509 new_dentry->d_name.name,
510 (unsigned char*)&rename_data, 0, f)) < 0) {
511 D(printk("jffs_rename(): Failed to write node to flash.\n"));
512 jffs_free_node(node);
513 goto jffs_rename_end;
514 }
515 raw_inode.dsize = 0;
516
517 if (raw_inode.rename) {
518 /* The file with the same name must be deleted. */
519 //FIXME deadlock down(&c->fmc->gclock);
520 if ((result = jffs_remove(new_dir, new_dentry,
521 del_f->mode)) < 0) {
522 /* This is really bad. */
523 printk(KERN_ERR "JFFS: An error occurred in "
524 "rename().\n");
525 }
526 // up(&c->fmc->gclock);
527 }
528
529 if (old_dir_f != new_dir_f) {
530 /* Remove the file from its old position in the
531 filesystem tree. */
532 jffs_unlink_file_from_tree(f);
533 }
534
535 /* Insert the new node into the file system. */
536 if ((result = jffs_insert_node(c, f, &raw_inode,
537 new_dentry->d_name.name, node)) < 0) {
538 D(printk(KERN_ERR "jffs_rename(): jffs_insert_node() "
539 "failed!\n"));
540 }
541
542 if (old_dir_f != new_dir_f) {
543 /* Insert the file to its new position in the
544 file system. */
545 jffs_insert_file_into_tree(f);
546 }
547
548 /* This is a kind of update of the inode we're about to make
549 here. This is what they do in ext2fs. Kind of. */
550 if ((inode = iget(new_dir->i_sb, f->ino))) {
551 inode->i_ctime = CURRENT_TIME_SEC;
552 mark_inode_dirty(inode);
553 iput(inode);
554 }
555
556jffs_rename_end:
557 D3(printk (KERN_NOTICE "rename(): up biglock\n"));
558 up(&c->fmc->biglock);
559 unlock_kernel();
560 return result;
561} /* jffs_rename() */
562
563
564/* Read the contents of a directory. Used by programs like `ls'
565 for instance. */
566static int
567jffs_readdir(struct file *filp, void *dirent, filldir_t filldir)
568{
569 struct jffs_file *f;
570 struct dentry *dentry = filp->f_dentry;
571 struct inode *inode = dentry->d_inode;
572 struct jffs_control *c = (struct jffs_control *)inode->i_sb->s_fs_info;
573 int j;
574 int ddino;
575 lock_kernel();
576 D3(printk (KERN_NOTICE "readdir(): down biglock\n"));
577 down(&c->fmc->biglock);
578
579 D2(printk("jffs_readdir(): inode: 0x%p, filp: 0x%p\n", inode, filp));
580 if (filp->f_pos == 0) {
581 D3(printk("jffs_readdir(): \".\" %lu\n", inode->i_ino));
582 if (filldir(dirent, ".", 1, filp->f_pos, inode->i_ino, DT_DIR) < 0) {
583 D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
584 up(&c->fmc->biglock);
585 unlock_kernel();
586 return 0;
587 }
588 filp->f_pos = 1;
589 }
590 if (filp->f_pos == 1) {
591 if (inode->i_ino == JFFS_MIN_INO) {
592 ddino = JFFS_MIN_INO;
593 }
594 else {
595 ddino = ((struct jffs_file *)
596 inode->u.generic_ip)->pino;
597 }
598 D3(printk("jffs_readdir(): \"..\" %u\n", ddino));
599 if (filldir(dirent, "..", 2, filp->f_pos, ddino, DT_DIR) < 0) {
600 D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
601 up(&c->fmc->biglock);
602 unlock_kernel();
603 return 0;
604 }
605 filp->f_pos++;
606 }
607 f = ((struct jffs_file *)inode->u.generic_ip)->children;
608
609 j = 2;
610 while(f && (f->deleted || j++ < filp->f_pos )) {
611 f = f->sibling_next;
612 }
613
614 while (f) {
615 D3(printk("jffs_readdir(): \"%s\" ino: %u\n",
616 (f->name ? f->name : ""), f->ino));
617 if (filldir(dirent, f->name, f->nsize,
618 filp->f_pos , f->ino, DT_UNKNOWN) < 0) {
619 D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
620 up(&c->fmc->biglock);
621 unlock_kernel();
622 return 0;
623 }
624 filp->f_pos++;
625 do {
626 f = f->sibling_next;
627 } while(f && f->deleted);
628 }
629 D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
630 up(&c->fmc->biglock);
631 unlock_kernel();
632 return filp->f_pos;
633} /* jffs_readdir() */
634
635
636/* Find a file in a directory. If the file exists, return its
637 corresponding dentry. */
638static struct dentry *
639jffs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
640{
641 struct jffs_file *d;
642 struct jffs_file *f;
643 struct jffs_control *c = (struct jffs_control *)dir->i_sb->s_fs_info;
644 int len;
645 int r = 0;
646 const char *name;
647 struct inode *inode = NULL;
648
649 len = dentry->d_name.len;
650 name = dentry->d_name.name;
651
652 lock_kernel();
653
654 D3({
655 char *s = (char *)kmalloc(len + 1, GFP_KERNEL);
656 memcpy(s, name, len);
657 s[len] = '\0';
658 printk("jffs_lookup(): dir: 0x%p, name: \"%s\"\n", dir, s);
659 kfree(s);
660 });
661
662 D3(printk (KERN_NOTICE "lookup(): down biglock\n"));
663 down(&c->fmc->biglock);
664
665 r = -ENAMETOOLONG;
666 if (len > JFFS_MAX_NAME_LEN) {
667 goto jffs_lookup_end;
668 }
669
670 r = -EACCES;
671 if (!(d = (struct jffs_file *)dir->u.generic_ip)) {
672 D(printk("jffs_lookup(): No such inode! (%lu)\n",
673 dir->i_ino));
674 goto jffs_lookup_end;
675 }
676
677 /* Get the corresponding inode to the file. */
678
679 /* iget calls jffs_read_inode, so we need to drop the biglock
680 before calling iget. Unfortunately, the GC has a tendency
681 to sneak in here, because iget sometimes calls schedule ().
682 */
683
684 if ((len == 1) && (name[0] == '.')) {
685 D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
686 up(&c->fmc->biglock);
687 if (!(inode = iget(dir->i_sb, d->ino))) {
688 D(printk("jffs_lookup(): . iget() ==> NULL\n"));
689 goto jffs_lookup_end_no_biglock;
690 }
691 D3(printk (KERN_NOTICE "lookup(): down biglock\n"));
692 down(&c->fmc->biglock);
693 } else if ((len == 2) && (name[0] == '.') && (name[1] == '.')) {
694 D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
695 up(&c->fmc->biglock);
696 if (!(inode = iget(dir->i_sb, d->pino))) {
697 D(printk("jffs_lookup(): .. iget() ==> NULL\n"));
698 goto jffs_lookup_end_no_biglock;
699 }
700 D3(printk (KERN_NOTICE "lookup(): down biglock\n"));
701 down(&c->fmc->biglock);
702 } else if ((f = jffs_find_child(d, name, len))) {
703 D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
704 up(&c->fmc->biglock);
705 if (!(inode = iget(dir->i_sb, f->ino))) {
706 D(printk("jffs_lookup(): iget() ==> NULL\n"));
707 goto jffs_lookup_end_no_biglock;
708 }
709 D3(printk (KERN_NOTICE "lookup(): down biglock\n"));
710 down(&c->fmc->biglock);
711 } else {
712 D3(printk("jffs_lookup(): Couldn't find the file. "
713 "f = 0x%p, name = \"%s\", d = 0x%p, d->ino = %u\n",
714 f, name, d, d->ino));
715 inode = NULL;
716 }
717
718 d_add(dentry, inode);
719 D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
720 up(&c->fmc->biglock);
721 unlock_kernel();
722 return NULL;
723
724jffs_lookup_end:
725 D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
726 up(&c->fmc->biglock);
727
728jffs_lookup_end_no_biglock:
729 unlock_kernel();
730 return ERR_PTR(r);
731} /* jffs_lookup() */
732
733
734/* Try to read a page of data from a file. */
735static int
736jffs_do_readpage_nolock(struct file *file, struct page *page)
737{
738 void *buf;
739 unsigned long read_len;
740 int result;
741 struct inode *inode = (struct inode*)page->mapping->host;
742 struct jffs_file *f = (struct jffs_file *)inode->u.generic_ip;
743 struct jffs_control *c = (struct jffs_control *)inode->i_sb->s_fs_info;
744 int r;
745 loff_t offset;
746
747 D2(printk("***jffs_readpage(): file = \"%s\", page->index = %lu\n",
748 (f->name ? f->name : ""), (long)page->index));
749
750 get_page(page);
751 /* Don't SetPageLocked(page), should be locked already */
752 ClearPageUptodate(page);
753 ClearPageError(page);
754
755 D3(printk (KERN_NOTICE "readpage(): down biglock\n"));
756 down(&c->fmc->biglock);
757
758 read_len = 0;
759 result = 0;
760 offset = page->index << PAGE_CACHE_SHIFT;
761
762 kmap(page);
763 buf = page_address(page);
764 if (offset < inode->i_size) {
765 read_len = min_t(long, inode->i_size - offset, PAGE_SIZE);
766 r = jffs_read_data(f, buf, offset, read_len);
767 if (r != read_len) {
768 result = -EIO;
769 D(
770 printk("***jffs_readpage(): Read error! "
771 "Wanted to read %lu bytes but only "
772 "read %d bytes.\n", read_len, r);
773 );
774 }
775
776 }
777
778 /* This handles the case of partial or no read in above */
779 if(read_len < PAGE_SIZE)
780 memset(buf + read_len, 0, PAGE_SIZE - read_len);
781 flush_dcache_page(page);
782 kunmap(page);
783
784 D3(printk (KERN_NOTICE "readpage(): up biglock\n"));
785 up(&c->fmc->biglock);
786
787 if (result) {
788 SetPageError(page);
789 }else {
790 SetPageUptodate(page);
791 }
792
793 page_cache_release(page);
794
795 D3(printk("jffs_readpage(): Leaving...\n"));
796
797 return result;
798} /* jffs_do_readpage_nolock() */
799
800static int jffs_readpage(struct file *file, struct page *page)
801{
802 int ret = jffs_do_readpage_nolock(file, page);
803 unlock_page(page);
804 return ret;
805}
806
807/* Create a new directory. */
808static int
809jffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
810{
811 struct jffs_raw_inode raw_inode;
812 struct jffs_control *c;
813 struct jffs_node *node;
814 struct jffs_file *dir_f;
815 struct inode *inode;
816 int dir_mode;
817 int result = 0;
818 int err;
819
820 D1({
821 int len = dentry->d_name.len;
822 char *_name = (char *) kmalloc(len + 1, GFP_KERNEL);
823 memcpy(_name, dentry->d_name.name, len);
824 _name[len] = '\0';
825 printk("***jffs_mkdir(): dir = 0x%p, name = \"%s\", "
826 "len = %d, mode = 0x%08x\n", dir, _name, len, mode);
827 kfree(_name);
828 });
829
830 lock_kernel();
831 dir_f = (struct jffs_file *)dir->u.generic_ip;
832
833 ASSERT(if (!dir_f) {
834 printk(KERN_ERR "jffs_mkdir(): No reference to a "
835 "jffs_file struct in inode.\n");
836 unlock_kernel();
837 return -EIO;
838 });
839
840 c = dir_f->c;
841 D3(printk (KERN_NOTICE "mkdir(): down biglock\n"));
842 down(&c->fmc->biglock);
843
844 dir_mode = S_IFDIR | (mode & (S_IRWXUGO|S_ISVTX)
845 & ~current->fs->umask);
846 if (dir->i_mode & S_ISGID) {
847 dir_mode |= S_ISGID;
848 }
849
850 /* Create a node and initialize it as much as needed. */
851 if (!(node = jffs_alloc_node())) {
852 D(printk("jffs_mkdir(): Allocation failed: node == 0\n"));
853 result = -ENOMEM;
854 goto jffs_mkdir_end;
855 }
856 node->data_offset = 0;
857 node->removed_size = 0;
858
859 /* Initialize the raw inode. */
860 raw_inode.magic = JFFS_MAGIC_BITMASK;
861 raw_inode.ino = c->next_ino++;
862 raw_inode.pino = dir_f->ino;
863 raw_inode.version = 1;
864 raw_inode.mode = dir_mode;
865 raw_inode.uid = current->fsuid;
866 raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
867 /* raw_inode.gid = current->fsgid; */
868 raw_inode.atime = get_seconds();
869 raw_inode.mtime = raw_inode.atime;
870 raw_inode.ctime = raw_inode.atime;
871 raw_inode.offset = 0;
872 raw_inode.dsize = 0;
873 raw_inode.rsize = 0;
874 raw_inode.nsize = dentry->d_name.len;
875 raw_inode.nlink = 1;
876 raw_inode.spare = 0;
877 raw_inode.rename = 0;
878 raw_inode.deleted = 0;
879
880 /* Write the new node to the flash. */
881 if ((result = jffs_write_node(c, node, &raw_inode,
882 dentry->d_name.name, NULL, 0, NULL)) < 0) {
883 D(printk("jffs_mkdir(): jffs_write_node() failed.\n"));
884 jffs_free_node(node);
885 goto jffs_mkdir_end;
886 }
887
888 /* Insert the new node into the file system. */
889 if ((result = jffs_insert_node(c, NULL, &raw_inode, dentry->d_name.name,
890 node)) < 0) {
891 goto jffs_mkdir_end;
892 }
893
894 inode = jffs_new_inode(dir, &raw_inode, &err);
895 if (inode == NULL) {
896 result = err;
897 goto jffs_mkdir_end;
898 }
899
900 inode->i_op = &jffs_dir_inode_operations;
901 inode->i_fop = &jffs_dir_operations;
902
903 mark_inode_dirty(dir);
904 d_instantiate(dentry, inode);
905
906 result = 0;
907jffs_mkdir_end:
908 D3(printk (KERN_NOTICE "mkdir(): up biglock\n"));
909 up(&c->fmc->biglock);
910 unlock_kernel();
911 return result;
912} /* jffs_mkdir() */
913
914
915/* Remove a directory. */
916static int
917jffs_rmdir(struct inode *dir, struct dentry *dentry)
918{
919 struct jffs_control *c = (struct jffs_control *)dir->i_sb->s_fs_info;
920 int ret;
921 D3(printk("***jffs_rmdir()\n"));
922 D3(printk (KERN_NOTICE "rmdir(): down biglock\n"));
923 lock_kernel();
924 down(&c->fmc->biglock);
925 ret = jffs_remove(dir, dentry, S_IFDIR);
926 D3(printk (KERN_NOTICE "rmdir(): up biglock\n"));
927 up(&c->fmc->biglock);
928 unlock_kernel();
929 return ret;
930}
931
932
933/* Remove any kind of file except for directories. */
934static int
935jffs_unlink(struct inode *dir, struct dentry *dentry)
936{
937 struct jffs_control *c = (struct jffs_control *)dir->i_sb->s_fs_info;
938 int ret;
939
940 lock_kernel();
941 D3(printk("***jffs_unlink()\n"));
942 D3(printk (KERN_NOTICE "unlink(): down biglock\n"));
943 down(&c->fmc->biglock);
944 ret = jffs_remove(dir, dentry, 0);
945 D3(printk (KERN_NOTICE "unlink(): up biglock\n"));
946 up(&c->fmc->biglock);
947 unlock_kernel();
948 return ret;
949}
950
951
952/* Remove a JFFS entry, i.e. plain files, directories, etc. Here we
953 shouldn't test for free space on the device. */
954static int
955jffs_remove(struct inode *dir, struct dentry *dentry, int type)
956{
957 struct jffs_raw_inode raw_inode;
958 struct jffs_control *c;
959 struct jffs_file *dir_f; /* The file-to-remove's parent. */
960 struct jffs_file *del_f; /* The file to remove. */
961 struct jffs_node *del_node;
962 struct inode *inode = NULL;
963 int result = 0;
964
965 D1({
966 int len = dentry->d_name.len;
967 const char *name = dentry->d_name.name;
968 char *_name = (char *) kmalloc(len + 1, GFP_KERNEL);
969 memcpy(_name, name, len);
970 _name[len] = '\0';
971 printk("***jffs_remove(): file = \"%s\", ino = %ld\n", _name, dentry->d_inode->i_ino);
972 kfree(_name);
973 });
974
975 dir_f = (struct jffs_file *) dir->u.generic_ip;
976 c = dir_f->c;
977
978 result = -ENOENT;
979 if (!(del_f = jffs_find_child(dir_f, dentry->d_name.name,
980 dentry->d_name.len))) {
981 D(printk("jffs_remove(): jffs_find_child() failed.\n"));
982 goto jffs_remove_end;
983 }
984
985 if (S_ISDIR(type)) {
986 struct jffs_file *child = del_f->children;
987 while(child) {
988 if( !child->deleted ) {
989 result = -ENOTEMPTY;
990 goto jffs_remove_end;
991 }
992 child = child->sibling_next;
993 }
994 }
995 else if (S_ISDIR(del_f->mode)) {
996 D(printk("jffs_remove(): node is a directory "
997 "but it shouldn't be.\n"));
998 result = -EPERM;
999 goto jffs_remove_end;
1000 }
1001
1002 inode = dentry->d_inode;
1003
1004 result = -EIO;
1005 if (del_f->ino != inode->i_ino)
1006 goto jffs_remove_end;
1007
1008 if (!inode->i_nlink) {
1009 printk("Deleting nonexistent file inode: %lu, nlink: %d\n",
1010 inode->i_ino, inode->i_nlink);
1011 inode->i_nlink=1;
1012 }
1013
1014 /* Create a node for the deletion. */
1015 result = -ENOMEM;
1016 if (!(del_node = jffs_alloc_node())) {
1017 D(printk("jffs_remove(): Allocation failed!\n"));
1018 goto jffs_remove_end;
1019 }
1020 del_node->data_offset = 0;
1021 del_node->removed_size = 0;
1022
1023 /* Initialize the raw inode. */
1024 raw_inode.magic = JFFS_MAGIC_BITMASK;
1025 raw_inode.ino = del_f->ino;
1026 raw_inode.pino = del_f->pino;
1027/* raw_inode.version = del_f->highest_version + 1; */
1028 raw_inode.mode = del_f->mode;
1029 raw_inode.uid = current->fsuid;
1030 raw_inode.gid = current->fsgid;
1031 raw_inode.atime = get_seconds();
1032 raw_inode.mtime = del_f->mtime;
1033 raw_inode.ctime = raw_inode.atime;
1034 raw_inode.offset = 0;
1035 raw_inode.dsize = 0;
1036 raw_inode.rsize = 0;
1037 raw_inode.nsize = 0;
1038 raw_inode.nlink = del_f->nlink;
1039 raw_inode.spare = 0;
1040 raw_inode.rename = 0;
1041 raw_inode.deleted = 1;
1042
1043 /* Write the new node to the flash memory. */
1044 if (jffs_write_node(c, del_node, &raw_inode, NULL, NULL, 1, del_f) < 0) {
1045 jffs_free_node(del_node);
1046 result = -EIO;
1047 goto jffs_remove_end;
1048 }
1049
1050 /* Update the file. This operation will make the file disappear
1051 from the in-memory file system structures. */
1052 jffs_insert_node(c, del_f, &raw_inode, NULL, del_node);
1053
1054 dir->i_ctime = dir->i_mtime = CURRENT_TIME_SEC;
1055 mark_inode_dirty(dir);
1056 inode->i_nlink--;
1057 inode->i_ctime = dir->i_ctime;
1058 mark_inode_dirty(inode);
1059
1060 d_delete(dentry); /* This also frees the inode */
1061
1062 result = 0;
1063jffs_remove_end:
1064 return result;
1065} /* jffs_remove() */
1066
1067
1068static int
1069jffs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
1070{
1071 struct jffs_raw_inode raw_inode;
1072 struct jffs_file *dir_f;
1073 struct jffs_node *node = NULL;
1074 struct jffs_control *c;
1075 struct inode *inode;
1076 int result = 0;
1077 u16 data = old_encode_dev(rdev);
1078 int err;
1079
1080 D1(printk("***jffs_mknod()\n"));
1081
1082 if (!old_valid_dev(rdev))
1083 return -EINVAL;
1084 lock_kernel();
1085 dir_f = (struct jffs_file *)dir->u.generic_ip;
1086 c = dir_f->c;
1087
1088 D3(printk (KERN_NOTICE "mknod(): down biglock\n"));
1089 down(&c->fmc->biglock);
1090
1091 /* Create and initialize a new node. */
1092 if (!(node = jffs_alloc_node())) {
1093 D(printk("jffs_mknod(): Allocation failed!\n"));
1094 result = -ENOMEM;
1095 goto jffs_mknod_err;
1096 }
1097 node->data_offset = 0;
1098 node->removed_size = 0;
1099
1100 /* Initialize the raw inode. */
1101 raw_inode.magic = JFFS_MAGIC_BITMASK;
1102 raw_inode.ino = c->next_ino++;
1103 raw_inode.pino = dir_f->ino;
1104 raw_inode.version = 1;
1105 raw_inode.mode = mode;
1106 raw_inode.uid = current->fsuid;
1107 raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
1108 /* raw_inode.gid = current->fsgid; */
1109 raw_inode.atime = get_seconds();
1110 raw_inode.mtime = raw_inode.atime;
1111 raw_inode.ctime = raw_inode.atime;
1112 raw_inode.offset = 0;
1113 raw_inode.dsize = 2;
1114 raw_inode.rsize = 0;
1115 raw_inode.nsize = dentry->d_name.len;
1116 raw_inode.nlink = 1;
1117 raw_inode.spare = 0;
1118 raw_inode.rename = 0;
1119 raw_inode.deleted = 0;
1120
1121 /* Write the new node to the flash. */
1122 if ((err = jffs_write_node(c, node, &raw_inode, dentry->d_name.name,
1123 (unsigned char *)&data, 0, NULL)) < 0) {
1124 D(printk("jffs_mknod(): jffs_write_node() failed.\n"));
1125 result = err;
1126 goto jffs_mknod_err;
1127 }
1128
1129 /* Insert the new node into the file system. */
1130 if ((err = jffs_insert_node(c, NULL, &raw_inode, dentry->d_name.name,
1131 node)) < 0) {
1132 result = err;
1133 goto jffs_mknod_end;
1134 }
1135
1136 inode = jffs_new_inode(dir, &raw_inode, &err);
1137 if (inode == NULL) {
1138 result = err;
1139 goto jffs_mknod_end;
1140 }
1141
1142 init_special_inode(inode, mode, rdev);
1143
1144 d_instantiate(dentry, inode);
1145
1146 goto jffs_mknod_end;
1147
1148jffs_mknod_err:
1149 if (node) {
1150 jffs_free_node(node);
1151 }
1152
1153jffs_mknod_end:
1154 D3(printk (KERN_NOTICE "mknod(): up biglock\n"));
1155 up(&c->fmc->biglock);
1156 unlock_kernel();
1157 return result;
1158} /* jffs_mknod() */
1159
1160
1161static int
1162jffs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1163{
1164 struct jffs_raw_inode raw_inode;
1165 struct jffs_control *c;
1166 struct jffs_file *dir_f;
1167 struct jffs_node *node;
1168 struct inode *inode;
1169
1170 int symname_len = strlen(symname);
1171 int err;
1172
1173 lock_kernel();
1174 D1({
1175 int len = dentry->d_name.len;
1176 char *_name = (char *)kmalloc(len + 1, GFP_KERNEL);
1177 char *_symname = (char *)kmalloc(symname_len + 1, GFP_KERNEL);
1178 memcpy(_name, dentry->d_name.name, len);
1179 _name[len] = '\0';
1180 memcpy(_symname, symname, symname_len);
1181 _symname[symname_len] = '\0';
1182 printk("***jffs_symlink(): dir = 0x%p, "
1183 "dentry->dname.name = \"%s\", "
1184 "symname = \"%s\"\n", dir, _name, _symname);
1185 kfree(_name);
1186 kfree(_symname);
1187 });
1188
1189 dir_f = (struct jffs_file *)dir->u.generic_ip;
1190 ASSERT(if (!dir_f) {
1191 printk(KERN_ERR "jffs_symlink(): No reference to a "
1192 "jffs_file struct in inode.\n");
1193 unlock_kernel();
1194 return -EIO;
1195 });
1196
1197 c = dir_f->c;
1198
1199 /* Create a node and initialize it as much as needed. */
1200 if (!(node = jffs_alloc_node())) {
1201 D(printk("jffs_symlink(): Allocation failed: node = NULL\n"));
1202 unlock_kernel();
1203 return -ENOMEM;
1204 }
1205 D3(printk (KERN_NOTICE "symlink(): down biglock\n"));
1206 down(&c->fmc->biglock);
1207
1208 node->data_offset = 0;
1209 node->removed_size = 0;
1210
1211 /* Initialize the raw inode. */
1212 raw_inode.magic = JFFS_MAGIC_BITMASK;
1213 raw_inode.ino = c->next_ino++;
1214 raw_inode.pino = dir_f->ino;
1215 raw_inode.version = 1;
1216 raw_inode.mode = S_IFLNK | S_IRWXUGO;
1217 raw_inode.uid = current->fsuid;
1218 raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
1219 raw_inode.atime = get_seconds();
1220 raw_inode.mtime = raw_inode.atime;
1221 raw_inode.ctime = raw_inode.atime;
1222 raw_inode.offset = 0;
1223 raw_inode.dsize = symname_len;
1224 raw_inode.rsize = 0;
1225 raw_inode.nsize = dentry->d_name.len;
1226 raw_inode.nlink = 1;
1227 raw_inode.spare = 0;
1228 raw_inode.rename = 0;
1229 raw_inode.deleted = 0;
1230
1231 /* Write the new node to the flash. */
1232 if ((err = jffs_write_node(c, node, &raw_inode, dentry->d_name.name,
1233 (const unsigned char *)symname, 0, NULL)) < 0) {
1234 D(printk("jffs_symlink(): jffs_write_node() failed.\n"));
1235 jffs_free_node(node);
1236 goto jffs_symlink_end;
1237 }
1238
1239 /* Insert the new node into the file system. */
1240 if ((err = jffs_insert_node(c, NULL, &raw_inode, dentry->d_name.name,
1241 node)) < 0) {
1242 goto jffs_symlink_end;
1243 }
1244
1245 inode = jffs_new_inode(dir, &raw_inode, &err);
1246 if (inode == NULL) {
1247 goto jffs_symlink_end;
1248 }
1249 err = 0;
1250 inode->i_op = &page_symlink_inode_operations;
1251 inode->i_mapping->a_ops = &jffs_address_operations;
1252
1253 d_instantiate(dentry, inode);
1254 jffs_symlink_end:
1255 D3(printk (KERN_NOTICE "symlink(): up biglock\n"));
1256 up(&c->fmc->biglock);
1257 unlock_kernel();
1258 return err;
1259} /* jffs_symlink() */
1260
1261
1262/* Create an inode inside a JFFS directory (dir) and return it.
1263 *
1264 * By the time this is called, we already have created
1265 * the directory cache entry for the new file, but it
1266 * is so far negative - it has no inode.
1267 *
1268 * If the create succeeds, we fill in the inode information
1269 * with d_instantiate().
1270 */
1271static int
1272jffs_create(struct inode *dir, struct dentry *dentry, int mode,
1273 struct nameidata *nd)
1274{
1275 struct jffs_raw_inode raw_inode;
1276 struct jffs_control *c;
1277 struct jffs_node *node;
1278 struct jffs_file *dir_f; /* JFFS representation of the directory. */
1279 struct inode *inode;
1280 int err;
1281
1282 lock_kernel();
1283 D1({
1284 int len = dentry->d_name.len;
1285 char *s = (char *)kmalloc(len + 1, GFP_KERNEL);
1286 memcpy(s, dentry->d_name.name, len);
1287 s[len] = '\0';
1288 printk("jffs_create(): dir: 0x%p, name: \"%s\"\n", dir, s);
1289 kfree(s);
1290 });
1291
1292 dir_f = (struct jffs_file *)dir->u.generic_ip;
1293 ASSERT(if (!dir_f) {
1294 printk(KERN_ERR "jffs_create(): No reference to a "
1295 "jffs_file struct in inode.\n");
1296 unlock_kernel();
1297 return -EIO;
1298 });
1299
1300 c = dir_f->c;
1301
1302 /* Create a node and initialize as much as needed. */
1303 if (!(node = jffs_alloc_node())) {
1304 D(printk("jffs_create(): Allocation failed: node == 0\n"));
1305 unlock_kernel();
1306 return -ENOMEM;
1307 }
1308 D3(printk (KERN_NOTICE "create(): down biglock\n"));
1309 down(&c->fmc->biglock);
1310
1311 node->data_offset = 0;
1312 node->removed_size = 0;
1313
1314 /* Initialize the raw inode. */
1315 raw_inode.magic = JFFS_MAGIC_BITMASK;
1316 raw_inode.ino = c->next_ino++;
1317 raw_inode.pino = dir_f->ino;
1318 raw_inode.version = 1;
1319 raw_inode.mode = mode;
1320 raw_inode.uid = current->fsuid;
1321 raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
1322 raw_inode.atime = get_seconds();
1323 raw_inode.mtime = raw_inode.atime;
1324 raw_inode.ctime = raw_inode.atime;
1325 raw_inode.offset = 0;
1326 raw_inode.dsize = 0;
1327 raw_inode.rsize = 0;
1328 raw_inode.nsize = dentry->d_name.len;
1329 raw_inode.nlink = 1;
1330 raw_inode.spare = 0;
1331 raw_inode.rename = 0;
1332 raw_inode.deleted = 0;
1333
1334 /* Write the new node to the flash. */
1335 if ((err = jffs_write_node(c, node, &raw_inode,
1336 dentry->d_name.name, NULL, 0, NULL)) < 0) {
1337 D(printk("jffs_create(): jffs_write_node() failed.\n"));
1338 jffs_free_node(node);
1339 goto jffs_create_end;
1340 }
1341
1342 /* Insert the new node into the file system. */
1343 if ((err = jffs_insert_node(c, NULL, &raw_inode, dentry->d_name.name,
1344 node)) < 0) {
1345 goto jffs_create_end;
1346 }
1347
1348 /* Initialize an inode. */
1349 inode = jffs_new_inode(dir, &raw_inode, &err);
1350 if (inode == NULL) {
1351 goto jffs_create_end;
1352 }
1353 err = 0;
1354 inode->i_op = &jffs_file_inode_operations;
1355 inode->i_fop = &jffs_file_operations;
1356 inode->i_mapping->a_ops = &jffs_address_operations;
1357 inode->i_mapping->nrpages = 0;
1358
1359 d_instantiate(dentry, inode);
1360 jffs_create_end:
1361 D3(printk (KERN_NOTICE "create(): up biglock\n"));
1362 up(&c->fmc->biglock);
1363 unlock_kernel();
1364 return err;
1365} /* jffs_create() */
1366
1367
1368/* Write, append or rewrite data to an existing file. */
1369static ssize_t
1370jffs_file_write(struct file *filp, const char *buf, size_t count,
1371 loff_t *ppos)
1372{
1373 struct jffs_raw_inode raw_inode;
1374 struct jffs_control *c;
1375 struct jffs_file *f;
1376 struct jffs_node *node;
1377 struct dentry *dentry = filp->f_dentry;
1378 struct inode *inode = dentry->d_inode;
1379 int recoverable = 0;
1380 size_t written = 0;
1381 __u32 thiscount = count;
1382 loff_t pos = *ppos;
1383 int err;
1384
1385 inode = filp->f_dentry->d_inode;
1386
1387 D2(printk("***jffs_file_write(): inode: 0x%p (ino: %lu), "
1388 "filp: 0x%p, buf: 0x%p, count: %d\n",
1389 inode, inode->i_ino, filp, buf, count));
1390
1391#if 0
1392 if (inode->i_sb->s_flags & MS_RDONLY) {
1393 D(printk("jffs_file_write(): MS_RDONLY\n"));
1394 err = -EROFS;
1395 goto out_isem;
1396 }
1397#endif
1398 err = -EINVAL;
1399
1400 if (!S_ISREG(inode->i_mode)) {
1401 D(printk("jffs_file_write(): inode->i_mode == 0x%08x\n",
1402 inode->i_mode));
1403 goto out_isem;
1404 }
1405
1406 if (!(f = (struct jffs_file *)inode->u.generic_ip)) {
1407 D(printk("jffs_file_write(): inode->u.generic_ip = 0x%p\n",
1408 inode->u.generic_ip));
1409 goto out_isem;
1410 }
1411
1412 c = f->c;
1413
1414 /*
1415 * This will never trigger with sane page sizes. leave it in
1416 * anyway, since I'm thinking about how to merge larger writes
1417 * (the current idea is to poke a thread that does the actual
1418 * I/O and starts by doing a down(&inode->i_sem). then we
1419 * would need to get the page cache pages and have a list of
1420 * I/O requests and do write-merging here.
1421 * -- prumpf
1422 */
1423 thiscount = min(c->fmc->max_chunk_size - sizeof(struct jffs_raw_inode), count);
1424
1425 D3(printk (KERN_NOTICE "file_write(): down biglock\n"));
1426 down(&c->fmc->biglock);
1427
1428 /* Urgh. POSIX says we can do short writes if we feel like it.
1429 * In practice, we can't. Nothing will cope. So we loop until
1430 * we're done.
1431 *
1432 * <_Anarchy_> posix and reality are not interconnected on this issue
1433 */
1434 while (count) {
1435 /* Things are going to be written so we could allocate and
1436 initialize the necessary data structures now. */
1437 if (!(node = jffs_alloc_node())) {
1438 D(printk("jffs_file_write(): node == 0\n"));
1439 err = -ENOMEM;
1440 goto out;
1441 }
1442
1443 node->data_offset = pos;
1444 node->removed_size = 0;
1445
1446 /* Initialize the raw inode. */
1447 raw_inode.magic = JFFS_MAGIC_BITMASK;
1448 raw_inode.ino = f->ino;
1449 raw_inode.pino = f->pino;
1450
1451 raw_inode.mode = f->mode;
1452
1453 raw_inode.uid = f->uid;
1454 raw_inode.gid = f->gid;
1455 raw_inode.atime = get_seconds();
1456 raw_inode.mtime = raw_inode.atime;
1457 raw_inode.ctime = f->ctime;
1458 raw_inode.offset = pos;
1459 raw_inode.dsize = thiscount;
1460 raw_inode.rsize = 0;
1461 raw_inode.nsize = f->nsize;
1462 raw_inode.nlink = f->nlink;
1463 raw_inode.spare = 0;
1464 raw_inode.rename = 0;
1465 raw_inode.deleted = 0;
1466
1467 if (pos < f->size) {
1468 node->removed_size = raw_inode.rsize = min(thiscount, (__u32)(f->size - pos));
1469
1470 /* If this node is going entirely over the top of old data,
1471 we can allow it to go into the reserved space, because
1472 we know that GC can reclaim the space later.
1473 */
1474 if (pos + thiscount < f->size) {
1475 /* If all the data we're overwriting are _real_,
1476 not just holes, then:
1477 recoverable = 1;
1478 */
1479 }
1480 }
1481
1482 /* Write the new node to the flash. */
1483 /* NOTE: We would be quite happy if jffs_write_node() wrote a
1484 smaller node than we were expecting. There's no need for it
1485 to waste the space at the end of the flash just because it's
1486 a little smaller than what we asked for. But that's a whole
1487 new can of worms which I'm not going to open this week.
1488 -- dwmw2.
1489 */
1490 if ((err = jffs_write_node(c, node, &raw_inode, f->name,
1491 (const unsigned char *)buf,
1492 recoverable, f)) < 0) {
1493 D(printk("jffs_file_write(): jffs_write_node() failed.\n"));
1494 jffs_free_node(node);
1495 goto out;
1496 }
1497
1498 written += err;
1499 buf += err;
1500 count -= err;
1501 pos += err;
1502
1503 /* Insert the new node into the file system. */
1504 if ((err = jffs_insert_node(c, f, &raw_inode, NULL, node)) < 0) {
1505 goto out;
1506 }
1507
1508 D3(printk("jffs_file_write(): new f_pos %ld.\n", (long)pos));
1509
1510 thiscount = min(c->fmc->max_chunk_size - sizeof(struct jffs_raw_inode), count);
1511 }
1512 out:
1513 D3(printk (KERN_NOTICE "file_write(): up biglock\n"));
1514 up(&c->fmc->biglock);
1515
1516 /* Fix things in the real inode. */
1517 if (pos > inode->i_size) {
1518 inode->i_size = pos;
1519 inode->i_blocks = (inode->i_size + 511) >> 9;
1520 }
1521 inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
1522 mark_inode_dirty(inode);
1523 invalidate_inode_pages(inode->i_mapping);
1524
1525 out_isem:
1526 return err;
1527} /* jffs_file_write() */
1528
1529static int
1530jffs_prepare_write(struct file *filp, struct page *page,
1531 unsigned from, unsigned to)
1532{
1533 /* FIXME: we should detect some error conditions here */
1534
1535 /* Bugger that. We should make sure the page is uptodate */
1536 if (!PageUptodate(page) && (from || to < PAGE_CACHE_SIZE))
1537 return jffs_do_readpage_nolock(filp, page);
1538
1539 return 0;
1540} /* jffs_prepare_write() */
1541
1542static int
1543jffs_commit_write(struct file *filp, struct page *page,
1544 unsigned from, unsigned to)
1545{
1546 void *addr = page_address(page) + from;
1547 /* XXX: PAGE_CACHE_SHIFT or PAGE_SHIFT */
1548 loff_t pos = (page->index<<PAGE_CACHE_SHIFT) + from;
1549
1550 return jffs_file_write(filp, addr, to-from, &pos);
1551} /* jffs_commit_write() */
1552
1553/* This is our ioctl() routine. */
1554static int
1555jffs_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1556 unsigned long arg)
1557{
1558 struct jffs_control *c;
1559 int ret = 0;
1560
1561 D2(printk("***jffs_ioctl(): cmd = 0x%08x, arg = 0x%08lx\n",
1562 cmd, arg));
1563
1564 if (!(c = (struct jffs_control *)inode->i_sb->s_fs_info)) {
1565 printk(KERN_ERR "JFFS: Bad inode in ioctl() call. "
1566 "(cmd = 0x%08x)\n", cmd);
1567 return -EIO;
1568 }
1569 D3(printk (KERN_NOTICE "ioctl(): down biglock\n"));
1570 down(&c->fmc->biglock);
1571
1572 switch (cmd) {
1573 case JFFS_PRINT_HASH:
1574 jffs_print_hash_table(c);
1575 break;
1576 case JFFS_PRINT_TREE:
1577 jffs_print_tree(c->root, 0);
1578 break;
1579 case JFFS_GET_STATUS:
1580 {
1581 struct jffs_flash_status fst;
1582 struct jffs_fmcontrol *fmc = c->fmc;
1583 printk("Flash status -- ");
1584 if (!access_ok(VERIFY_WRITE,
1585 (struct jffs_flash_status __user *)arg,
1586 sizeof(struct jffs_flash_status))) {
1587 D(printk("jffs_ioctl(): Bad arg in "
1588 "JFFS_GET_STATUS ioctl!\n"));
1589 ret = -EFAULT;
1590 break;
1591 }
1592 fst.size = fmc->flash_size;
1593 fst.used = fmc->used_size;
1594 fst.dirty = fmc->dirty_size;
1595 fst.begin = fmc->head->offset;
1596 fst.end = fmc->tail->offset + fmc->tail->size;
1597 printk("size: %d, used: %d, dirty: %d, "
1598 "begin: %d, end: %d\n",
1599 fst.size, fst.used, fst.dirty,
1600 fst.begin, fst.end);
1601 if (copy_to_user((struct jffs_flash_status __user *)arg,
1602 &fst,
1603 sizeof(struct jffs_flash_status))) {
1604 ret = -EFAULT;
1605 }
1606 }
1607 break;
1608 default:
1609 ret = -ENOTTY;
1610 }
1611 D3(printk (KERN_NOTICE "ioctl(): up biglock\n"));
1612 up(&c->fmc->biglock);
1613 return ret;
1614} /* jffs_ioctl() */
1615
1616
1617static struct address_space_operations jffs_address_operations = {
1618 .readpage = jffs_readpage,
1619 .prepare_write = jffs_prepare_write,
1620 .commit_write = jffs_commit_write,
1621};
1622
1623static int jffs_fsync(struct file *f, struct dentry *d, int datasync)
1624{
1625 /* We currently have O_SYNC operations at all times.
1626 Do nothing.
1627 */
1628 return 0;
1629}
1630
1631
1632extern int generic_file_open(struct inode *, struct file *) __attribute__((weak));
1633extern loff_t generic_file_llseek(struct file *, loff_t, int) __attribute__((weak));
1634
1635static struct file_operations jffs_file_operations =
1636{
1637 .open = generic_file_open,
1638 .llseek = generic_file_llseek,
1639 .read = generic_file_read,
1640 .write = generic_file_write,
1641 .ioctl = jffs_ioctl,
1642 .mmap = generic_file_readonly_mmap,
1643 .fsync = jffs_fsync,
1644 .sendfile = generic_file_sendfile,
1645};
1646
1647
1648static struct inode_operations jffs_file_inode_operations =
1649{
1650 .lookup = jffs_lookup, /* lookup */
1651 .setattr = jffs_setattr,
1652};
1653
1654
1655static struct file_operations jffs_dir_operations =
1656{
1657 .readdir = jffs_readdir,
1658};
1659
1660
1661static struct inode_operations jffs_dir_inode_operations =
1662{
1663 .create = jffs_create,
1664 .lookup = jffs_lookup,
1665 .unlink = jffs_unlink,
1666 .symlink = jffs_symlink,
1667 .mkdir = jffs_mkdir,
1668 .rmdir = jffs_rmdir,
1669 .mknod = jffs_mknod,
1670 .rename = jffs_rename,
1671 .setattr = jffs_setattr,
1672};
1673
1674
1675/* Initialize an inode for the VFS. */
1676static void
1677jffs_read_inode(struct inode *inode)
1678{
1679 struct jffs_file *f;
1680 struct jffs_control *c;
1681
1682 D3(printk("jffs_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
1683
1684 if (!inode->i_sb) {
1685 D(printk("jffs_read_inode(): !inode->i_sb ==> "
1686 "No super block!\n"));
1687 return;
1688 }
1689 c = (struct jffs_control *)inode->i_sb->s_fs_info;
1690 D3(printk (KERN_NOTICE "read_inode(): down biglock\n"));
1691 down(&c->fmc->biglock);
1692 if (!(f = jffs_find_file(c, inode->i_ino))) {
1693 D(printk("jffs_read_inode(): No such inode (%lu).\n",
1694 inode->i_ino));
1695 D3(printk (KERN_NOTICE "read_inode(): up biglock\n"));
1696 up(&c->fmc->biglock);
1697 return;
1698 }
1699 inode->u.generic_ip = (void *)f;
1700 inode->i_mode = f->mode;
1701 inode->i_nlink = f->nlink;
1702 inode->i_uid = f->uid;
1703 inode->i_gid = f->gid;
1704 inode->i_size = f->size;
1705 inode->i_atime.tv_sec = f->atime;
1706 inode->i_mtime.tv_sec = f->mtime;
1707 inode->i_ctime.tv_sec = f->ctime;
1708 inode->i_atime.tv_nsec =
1709 inode->i_mtime.tv_nsec =
1710 inode->i_ctime.tv_nsec = 0;
1711
1712 inode->i_blksize = PAGE_SIZE;
1713 inode->i_blocks = (inode->i_size + 511) >> 9;
1714 if (S_ISREG(inode->i_mode)) {
1715 inode->i_op = &jffs_file_inode_operations;
1716 inode->i_fop = &jffs_file_operations;
1717 inode->i_mapping->a_ops = &jffs_address_operations;
1718 }
1719 else if (S_ISDIR(inode->i_mode)) {
1720 inode->i_op = &jffs_dir_inode_operations;
1721 inode->i_fop = &jffs_dir_operations;
1722 }
1723 else if (S_ISLNK(inode->i_mode)) {
1724 inode->i_op = &page_symlink_inode_operations;
1725 inode->i_mapping->a_ops = &jffs_address_operations;
1726 }
1727 else {
1728 /* If the node is a device of some sort, then the number of
1729 the device should be read from the flash memory and then
1730 added to the inode's i_rdev member. */
1731 u16 val;
1732 jffs_read_data(f, (char *)&val, 0, 2);
1733 init_special_inode(inode, inode->i_mode,
1734 old_decode_dev(val));
1735 }
1736
1737 D3(printk (KERN_NOTICE "read_inode(): up biglock\n"));
1738 up(&c->fmc->biglock);
1739}
1740
1741
1742static void
1743jffs_delete_inode(struct inode *inode)
1744{
1745 struct jffs_file *f;
1746 struct jffs_control *c;
1747 D3(printk("jffs_delete_inode(): inode->i_ino == %lu\n",
1748 inode->i_ino));
1749
1750 lock_kernel();
1751 inode->i_size = 0;
1752 inode->i_blocks = 0;
1753 inode->u.generic_ip = NULL;
1754 clear_inode(inode);
1755 if (inode->i_nlink == 0) {
1756 c = (struct jffs_control *) inode->i_sb->s_fs_info;
1757 f = (struct jffs_file *) jffs_find_file (c, inode->i_ino);
1758 jffs_possibly_delete_file(f);
1759 }
1760
1761 unlock_kernel();
1762}
1763
1764
1765static void
1766jffs_write_super(struct super_block *sb)
1767{
1768 struct jffs_control *c = (struct jffs_control *)sb->s_fs_info;
1769 lock_kernel();
1770 jffs_garbage_collect_trigger(c);
1771 unlock_kernel();
1772}
1773
1774static int jffs_remount(struct super_block *sb, int *flags, char *data)
1775{
1776 *flags |= MS_NODIRATIME;
1777 return 0;
1778}
1779
1780static struct super_operations jffs_ops =
1781{
1782 .read_inode = jffs_read_inode,
1783 .delete_inode = jffs_delete_inode,
1784 .put_super = jffs_put_super,
1785 .write_super = jffs_write_super,
1786 .statfs = jffs_statfs,
1787 .remount_fs = jffs_remount,
1788};
1789
1790static struct super_block *jffs_get_sb(struct file_system_type *fs_type,
1791 int flags, const char *dev_name, void *data)
1792{
1793 return get_sb_bdev(fs_type, flags, dev_name, data, jffs_fill_super);
1794}
1795
1796static struct file_system_type jffs_fs_type = {
1797 .owner = THIS_MODULE,
1798 .name = "jffs",
1799 .get_sb = jffs_get_sb,
1800 .kill_sb = kill_block_super,
1801 .fs_flags = FS_REQUIRES_DEV,
1802};
1803
1804static int __init
1805init_jffs_fs(void)
1806{
1807 printk(KERN_INFO "JFFS version " JFFS_VERSION_STRING
1808 ", (C) 1999, 2000 Axis Communications AB\n");
1809
1810#ifdef CONFIG_JFFS_PROC_FS
1811 jffs_proc_root = proc_mkdir("jffs", proc_root_fs);
1812 if (!jffs_proc_root) {
1813 printk(KERN_WARNING "cannot create /proc/jffs entry\n");
1814 }
1815#endif
1816 fm_cache = kmem_cache_create("jffs_fm", sizeof(struct jffs_fm),
1817 0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
1818 NULL, NULL);
1819 if (!fm_cache) {
1820 return -ENOMEM;
1821 }
1822
1823 node_cache = kmem_cache_create("jffs_node",sizeof(struct jffs_node),
1824 0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
1825 NULL, NULL);
1826 if (!node_cache) {
1827 kmem_cache_destroy(fm_cache);
1828 return -ENOMEM;
1829 }
1830
1831 return register_filesystem(&jffs_fs_type);
1832}
1833
1834static void __exit
1835exit_jffs_fs(void)
1836{
1837 unregister_filesystem(&jffs_fs_type);
1838 kmem_cache_destroy(fm_cache);
1839 kmem_cache_destroy(node_cache);
1840}
1841
1842module_init(init_jffs_fs)
1843module_exit(exit_jffs_fs)
1844
1845MODULE_DESCRIPTION("The Journalling Flash File System");
1846MODULE_AUTHOR("Axis Communications AB.");
1847MODULE_LICENSE("GPL");
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-04 08:15:32 -0500