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