v2.4.8 -> v2.4.8.1
[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
331         sb = dir->i_sb;
332         inode = new_inode(sb);
333         if (!inode) {
334                 *err = -ENOMEM;
335                 return NULL;
336         }
337
338         c = (struct jffs_control *)sb->u.generic_sbp;
339
340         inode->i_ino = raw_inode->ino;
341         inode->i_mode = raw_inode->mode;
342         inode->i_nlink = raw_inode->nlink;
343         inode->i_uid = raw_inode->uid;
344         inode->i_gid = raw_inode->gid;
345         inode->i_rdev = 0;
346         inode->i_size = raw_inode->dsize;
347         inode->i_atime = raw_inode->atime;
348         inode->i_mtime = raw_inode->mtime;
349         inode->i_ctime = raw_inode->ctime;
350         inode->i_blksize = PAGE_SIZE;
351         inode->i_blocks = (inode->i_size + 511) >> 9;
352         inode->i_version = 0;
353         inode->u.generic_ip = (void *)jffs_find_file(c, raw_inode->ino);
354
355         insert_inode_hash(inode);
356
357         return inode;
358 }
359
360 /* Get statistics of the file system.  */
361 int
362 jffs_statfs(struct super_block *sb, struct statfs *buf)
363 {
364         struct jffs_control *c = (struct jffs_control *) sb->u.generic_sbp;
365         struct jffs_fmcontrol *fmc = c->fmc;
366
367         D2(printk("jffs_statfs()\n"));
368
369         buf->f_type = JFFS_MAGIC_SB_BITMASK;
370         buf->f_bsize = PAGE_CACHE_SIZE;
371         buf->f_blocks = (fmc->flash_size / PAGE_CACHE_SIZE)
372                        - (fmc->min_free_size / PAGE_CACHE_SIZE);
373         buf->f_bfree = (jffs_free_size1(fmc) / PAGE_CACHE_SIZE
374                        + jffs_free_size2(fmc) / PAGE_CACHE_SIZE)
375                       - (fmc->min_free_size / PAGE_CACHE_SIZE);
376         buf->f_bavail = buf->f_bfree;
377
378         /* Find out how many files there are in the filesystem.  */
379         buf->f_files = jffs_foreach_file(c, jffs_file_count);
380         buf->f_ffree = buf->f_bfree;
381         /* buf->f_fsid = 0; */
382         buf->f_namelen = JFFS_MAX_NAME_LEN;
383         return 0;
384 }
385
386
387 /* Rename a file.  */
388 int
389 jffs_rename(struct inode *old_dir, struct dentry *old_dentry,
390             struct inode *new_dir, struct dentry *new_dentry)
391 {
392         struct jffs_raw_inode raw_inode;
393         struct jffs_control *c;
394         struct jffs_file *old_dir_f;
395         struct jffs_file *new_dir_f;
396         struct jffs_file *del_f;
397         struct jffs_file *f;
398         struct jffs_node *node;
399         struct inode *inode;
400         int result = 0;
401         __u32 rename_data = 0;
402
403         D2(printk("***jffs_rename()\n"));
404         
405         D(printk("jffs_rename(): old_dir: 0x%p, old name: 0x%p, "
406                  "new_dir: 0x%p, new name: 0x%p\n",
407                  old_dir, old_dentry->d_name.name,
408                  new_dir, new_dentry->d_name.name));
409
410         c = (struct jffs_control *)old_dir->i_sb->u.generic_sbp;
411         ASSERT(if (!c) {
412                 printk(KERN_ERR "jffs_rename(): The old_dir inode "
413                        "didn't have a reference to a jffs_file struct\n");
414                 return -EIO;
415         });
416
417         result = -ENOTDIR;
418         if (!(old_dir_f = (struct jffs_file *)old_dir->u.generic_ip)) {
419                 D(printk("jffs_rename(): Old dir invalid.\n"));
420                 goto jffs_rename_end;
421         }
422
423         /* Try to find the file to move.  */
424         result = -ENOENT;
425         if (!(f = jffs_find_child(old_dir_f, old_dentry->d_name.name,
426                                   old_dentry->d_name.len))) {
427                 goto jffs_rename_end;
428         }
429
430         /* Find the new directory.  */
431         result = -ENOTDIR;
432         if (!(new_dir_f = (struct jffs_file *)new_dir->u.generic_ip)) {
433                 D(printk("jffs_rename(): New dir invalid.\n"));
434                 goto jffs_rename_end;
435         }
436         D3(printk (KERN_NOTICE "rename(): down biglock\n"));
437         down(&c->fmc->biglock);
438         /* Create a node and initialize as much as needed.  */
439         result = -ENOMEM;
440         if (!(node = (struct jffs_node *) kmalloc(sizeof(struct jffs_node),
441                                                   GFP_KERNEL))) {
442                 D(printk("jffs_rename(): Allocation failed: node == 0\n"));
443                 goto jffs_rename_end;
444         }
445         DJM(no_jffs_node++);
446         node->data_offset = 0;
447         node->removed_size = 0;
448
449         /* Initialize the raw inode.  */
450         raw_inode.magic = JFFS_MAGIC_BITMASK;
451         raw_inode.ino = f->ino;
452         raw_inode.pino = new_dir_f->ino;
453 /*      raw_inode.version = f->highest_version + 1; */
454         raw_inode.mode = f->mode;
455         raw_inode.uid = current->fsuid;
456         raw_inode.gid = current->fsgid;
457 #if 0
458         raw_inode.uid = f->uid;
459         raw_inode.gid = f->gid;
460 #endif
461         raw_inode.atime = CURRENT_TIME;
462         raw_inode.mtime = raw_inode.atime;
463         raw_inode.ctime = f->ctime;
464         raw_inode.offset = 0;
465         raw_inode.dsize = 0;
466         raw_inode.rsize = 0;
467         raw_inode.nsize = new_dentry->d_name.len;
468         raw_inode.nlink = f->nlink;
469         raw_inode.spare = 0;
470         raw_inode.rename = 0;
471         raw_inode.deleted = 0;
472
473         /* See if there already exists a file with the same name as
474            new_name.  */
475         if ((del_f = jffs_find_child(new_dir_f, new_dentry->d_name.name,
476                                      new_dentry->d_name.len))) {
477                 raw_inode.rename = 1;
478                 raw_inode.dsize = sizeof(__u32);
479                 rename_data = del_f->ino;
480         }
481
482         /* Write the new node to the flash memory.  */
483         if ((result = jffs_write_node(c, node, &raw_inode,
484                                       new_dentry->d_name.name,
485                                       (unsigned char*)&rename_data, 0, f)) < 0) {
486                 D(printk("jffs_rename(): Failed to write node to flash.\n"));
487                 kfree(node);
488                 DJM(no_jffs_node--);
489                 goto jffs_rename_end;
490         }
491         raw_inode.dsize = 0;
492
493         if (raw_inode.rename) {
494                 /* The file with the same name must be deleted.  */
495                 //FIXME deadlock                down(&c->fmc->gclock);
496                 if ((result = jffs_remove(new_dir, new_dentry,
497                                           del_f->mode)) < 0) {
498                         /* This is really bad.  */
499                         printk(KERN_ERR "JFFS: An error occurred in "
500                                "rename().\n");
501                 }
502                 //              up(&c->fmc->gclock);
503         }
504
505         if (old_dir_f != new_dir_f) {
506                 /* Remove the file from its old position in the
507                    filesystem tree.  */
508                 jffs_unlink_file_from_tree(f);
509         }
510
511         /* Insert the new node into the file system.  */
512         if ((result = jffs_insert_node(c, f, &raw_inode,
513                                        new_dentry->d_name.name, node)) < 0) {
514                 D(printk(KERN_ERR "jffs_rename(): jffs_insert_node() "
515                          "failed!\n"));
516         }
517
518         if (old_dir_f != new_dir_f) {
519                 /* Insert the file to its new position in the
520                    file system.  */
521                 jffs_insert_file_into_tree(f);
522         }
523
524         /* This is a kind of update of the inode we're about to make
525            here.  This is what they do in ext2fs.  Kind of.  */
526         if ((inode = iget(new_dir->i_sb, f->ino))) {
527                 inode->i_ctime = CURRENT_TIME;
528                 mark_inode_dirty(inode);
529                 iput(inode);
530         }
531
532 jffs_rename_end:
533         D3(printk (KERN_NOTICE "rename(): up biglock\n"));
534         up(&c->fmc->biglock);
535         return result;
536 } /* jffs_rename()  */
537
538
539 /* Read the contents of a directory.  Used by programs like `ls'
540    for instance.  */
541 static int
542 jffs_readdir(struct file *filp, void *dirent, filldir_t filldir)
543 {
544         struct jffs_file *f;
545         struct dentry *dentry = filp->f_dentry;
546         struct inode *inode = dentry->d_inode;
547         struct jffs_control *c = (struct jffs_control *)inode->i_sb->u.generic_sbp;
548         int j;
549         int ddino;
550         D3(printk (KERN_NOTICE "readdir(): down biglock\n"));
551         down(&c->fmc->biglock);
552
553         D2(printk("jffs_readdir(): inode: 0x%p, filp: 0x%p\n", inode, filp));
554         if (filp->f_pos == 0) {
555                 D3(printk("jffs_readdir(): \".\" %lu\n", inode->i_ino));
556                 if (filldir(dirent, ".", 1, filp->f_pos, inode->i_ino, DT_DIR) < 0) {
557                   D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
558                         up(&c->fmc->biglock);
559                         return 0;
560                 }
561                 filp->f_pos = 1;
562         }
563         if (filp->f_pos == 1) {
564                 if (inode->i_ino == JFFS_MIN_INO) {
565                         ddino = JFFS_MIN_INO;
566                 }
567                 else {
568                         ddino = ((struct jffs_file *)
569                                  inode->u.generic_ip)->pino;
570                 }
571                 D3(printk("jffs_readdir(): \"..\" %u\n", ddino));
572                 if (filldir(dirent, "..", 2, filp->f_pos, ddino, DT_DIR) < 0) {
573                   D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
574                         up(&c->fmc->biglock);
575                         return 0;
576                 }
577                 filp->f_pos++;
578         }
579         f = ((struct jffs_file *)inode->u.generic_ip)->children;
580         for (j = 2; (j < filp->f_pos) && f; j++) {
581                 f = f->sibling_next;
582         }
583         for (; f ; f = f->sibling_next) {
584                 D3(printk("jffs_readdir(): \"%s\" ino: %u\n",
585                           (f->name ? f->name : ""), f->ino));
586                 if (filldir(dirent, f->name, f->nsize,
587                             filp->f_pos , f->ino, DT_UNKNOWN) < 0) {
588                         D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
589                         up(&c->fmc->biglock);
590                         return 0;
591                 }
592                 filp->f_pos++;
593         }
594         D3(printk (KERN_NOTICE "readdir(): up biglock\n"));
595         up(&c->fmc->biglock);
596         return filp->f_pos;
597 } /* jffs_readdir()  */
598
599
600 /* Find a file in a directory. If the file exists, return its
601    corresponding dentry.  */
602 static struct dentry *
603 jffs_lookup(struct inode *dir, struct dentry *dentry)
604 {
605         struct jffs_file *d;
606         struct jffs_file *f;
607         struct jffs_control *c = (struct jffs_control *)dir->i_sb->u.generic_sbp;
608         int len;
609         int r = 0;
610         const char *name;
611         struct inode *inode = NULL;
612
613         len = dentry->d_name.len;
614         name = dentry->d_name.name;
615
616         D3({
617                 char *s = (char *)kmalloc(len + 1, GFP_KERNEL);
618                 memcpy(s, name, len);
619                 s[len] = '\0';
620                 printk("jffs_lookup(): dir: 0x%p, name: \"%s\"\n", dir, s);
621                 kfree(s);
622         });
623
624         D3(printk (KERN_NOTICE "lookup(): down biglock\n"));
625         down(&c->fmc->biglock);
626
627         r = -ENAMETOOLONG;
628         if (len > JFFS_MAX_NAME_LEN) {
629                 goto jffs_lookup_end;
630         }
631
632         r = -EACCES;
633         if (!(d = (struct jffs_file *)dir->u.generic_ip)) {
634                 D(printk("jffs_lookup(): No such inode! (%lu)\n",
635                          dir->i_ino));
636                 goto jffs_lookup_end;
637         }
638
639         /* Get the corresponding inode to the file.  */
640
641         /* iget calls jffs_read_inode, so we need to drop the biglock
642            before calling iget.  Unfortunately, the GC has a tendency
643            to sneak in here, because iget sometimes calls schedule (). 
644          */
645
646         if ((len == 1) && (name[0] == '.')) {
647                 D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
648                 up(&c->fmc->biglock);
649                 if (!(inode = iget(dir->i_sb, d->ino))) {
650                         D(printk("jffs_lookup(): . iget() ==> NULL\n"));
651                         goto jffs_lookup_end_no_biglock;
652                 }
653                 D3(printk (KERN_NOTICE "lookup(): down biglock\n"));
654                 down(&c->fmc->biglock);
655         } else if ((len == 2) && (name[0] == '.') && (name[1] == '.')) {
656                 D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
657                 up(&c->fmc->biglock);
658                 if (!(inode = iget(dir->i_sb, d->pino))) {
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 ((f = jffs_find_child(d, name, len))) {
665                 D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
666                 up(&c->fmc->biglock);
667                 if (!(inode = iget(dir->i_sb, f->ino))) {
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 {
674                 D3(printk("jffs_lookup(): Couldn't find the file. "
675                           "f = 0x%p, name = \"%s\", d = 0x%p, d->ino = %u\n",
676                           f, name, d, d->ino));
677                 inode = NULL;
678         }
679
680         d_add(dentry, inode);
681         D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
682         up(&c->fmc->biglock);
683         return NULL;
684
685 jffs_lookup_end:
686         D3(printk (KERN_NOTICE "lookup(): up biglock\n"));
687         up(&c->fmc->biglock);
688
689 jffs_lookup_end_no_biglock:
690         return ERR_PTR(r);
691 } /* jffs_lookup()  */
692
693
694 /* Try to read a page of data from a file.  */
695 static int
696 jffs_readpage(struct file *file, struct page *page)
697 {
698         void *buf;
699         unsigned long read_len;
700         int result = -EIO;
701         struct inode *inode = page->mapping->host;
702         struct jffs_file *f = (struct jffs_file *)inode->u.generic_ip;
703         struct jffs_control *c = (struct jffs_control *)inode->i_sb->u.generic_sbp;
704         int r;
705         loff_t offset;
706
707         D2(printk("***jffs_readpage(): file = \"%s\", page->index = %lu\n",
708                   (f->name ? f->name : ""), (long)page->index));
709
710         get_page(page);
711         /* Don't LockPage(page), should be locked already */
712         buf = page_address(page);
713         ClearPageUptodate(page);
714         ClearPageError(page);
715
716         D3(printk (KERN_NOTICE "readpage(): down biglock\n"));
717         down(&c->fmc->biglock);
718
719         offset = page->index << PAGE_CACHE_SHIFT;
720         if (offset < inode->i_size) {
721                 read_len = jffs_min(inode->i_size - offset, PAGE_SIZE);
722                 r = jffs_read_data(f, buf, offset, read_len);
723                 if (r == read_len) {
724                         if (read_len < PAGE_SIZE) {
725                                 memset(buf + read_len, 0,
726                                        PAGE_SIZE - read_len);
727                         }
728                         SetPageUptodate(page);
729                         result = 0;
730                 }
731                 D(else {
732                         printk("***jffs_readpage(): Read error! "
733                                "Wanted to read %lu bytes but only "
734                                "read %d bytes.\n", read_len, r);
735                 });
736         }
737
738         D3(printk (KERN_NOTICE "readpage(): up biglock\n"));
739         up(&c->fmc->biglock);
740         
741         if (result) {
742                 memset(buf, 0, PAGE_SIZE);
743                 SetPageError(page);
744         }
745         flush_dcache_page(page);
746
747         UnlockPage(page);
748
749         put_page(page);
750
751         D3(printk("jffs_readpage(): Leaving...\n"));
752
753         return result;
754 } /* jffs_readpage()  */
755
756
757 /* Create a new directory.  */
758 static int
759 jffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
760 {
761         struct jffs_raw_inode raw_inode;
762         struct jffs_control *c;
763         struct jffs_node *node;
764         struct jffs_file *dir_f;
765         struct inode *inode;
766         int dir_mode;
767         int result = 0;
768         int err;
769
770         D1({
771                 int len = dentry->d_name.len;
772                 char *_name = (char *) kmalloc(len + 1, GFP_KERNEL);
773                 memcpy(_name, dentry->d_name.name, len);
774                 _name[len] = '\0';
775                 printk("***jffs_mkdir(): dir = 0x%p, name = \"%s\", "
776                        "len = %d, mode = 0x%08x\n", dir, _name, len, mode);
777                 kfree(_name);
778         });
779
780         dir_f = (struct jffs_file *)dir->u.generic_ip;
781
782         ASSERT(if (!dir_f) {
783                 printk(KERN_ERR "jffs_mkdir(): No reference to a "
784                        "jffs_file struct in inode.\n");
785                 return -EIO;
786         });
787
788         c = dir_f->c;
789         D3(printk (KERN_NOTICE "mkdir(): down biglock\n"));
790         down(&c->fmc->biglock);
791
792         dir_mode = S_IFDIR | (mode & (S_IRWXUGO|S_ISVTX)
793                               & ~current->fs->umask);
794         if (dir->i_mode & S_ISGID) {
795                 dir_mode |= S_ISGID;
796         }
797
798         /* Create a node and initialize it as much as needed.  */
799         if (!(node = (struct jffs_node *) kmalloc(sizeof(struct jffs_node),
800                                                   GFP_KERNEL))) {
801                 D(printk("jffs_mkdir(): Allocation failed: node == 0\n"));
802                 result = -ENOMEM;
803                 goto jffs_mkdir_end;
804         }
805         DJM(no_jffs_node++);
806         node->data_offset = 0;
807         node->removed_size = 0;
808
809         /* Initialize the raw inode.  */
810         raw_inode.magic = JFFS_MAGIC_BITMASK;
811         raw_inode.ino = c->next_ino++;
812         raw_inode.pino = dir_f->ino;
813         raw_inode.version = 1;
814         raw_inode.mode = dir_mode;
815         raw_inode.uid = current->fsuid;
816         raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
817         /*      raw_inode.gid = current->fsgid; */
818         raw_inode.atime = CURRENT_TIME;
819         raw_inode.mtime = raw_inode.atime;
820         raw_inode.ctime = raw_inode.atime;
821         raw_inode.offset = 0;
822         raw_inode.dsize = 0;
823         raw_inode.rsize = 0;
824         raw_inode.nsize = dentry->d_name.len;
825         raw_inode.nlink = 1;
826         raw_inode.spare = 0;
827         raw_inode.rename = 0;
828         raw_inode.deleted = 0;
829
830         /* Write the new node to the flash.  */
831         if ((result = jffs_write_node(c, node, &raw_inode,
832                                       dentry->d_name.name, 0, 0, NULL)) < 0) {
833                 D(printk("jffs_mkdir(): jffs_write_node() failed.\n"));
834                 kfree(node);
835                 DJM(no_jffs_node--);
836                 goto jffs_mkdir_end;
837         }
838
839         /* Insert the new node into the file system.  */
840         if ((result = jffs_insert_node(c, 0, &raw_inode, dentry->d_name.name,
841                                        node)) < 0) {
842                 goto jffs_mkdir_end;
843         }
844
845         inode = jffs_new_inode(dir, &raw_inode, &err);
846         if (inode == NULL) {
847                 result = err;
848                 goto jffs_mkdir_end;
849         }
850
851         inode->i_op = &jffs_dir_inode_operations;
852         inode->i_fop = &jffs_dir_operations;
853
854         mark_inode_dirty(dir);
855         d_instantiate(dentry, inode);
856
857         result = 0;
858 jffs_mkdir_end:
859         D3(printk (KERN_NOTICE "mkdir(): up biglock\n"));
860         up(&c->fmc->biglock);
861         return result;
862 } /* jffs_mkdir()  */
863
864
865 /* Remove a directory.  */
866 static int
867 jffs_rmdir(struct inode *dir, struct dentry *dentry)
868 {
869         struct jffs_control *c = (struct jffs_control *)dir->i_sb->u.generic_sbp;
870         int ret;
871         D3(printk("***jffs_rmdir()\n"));
872         D3(printk (KERN_NOTICE "rmdir(): down biglock\n"));
873         down(&c->fmc->biglock);
874         ret = jffs_remove(dir, dentry, S_IFDIR);
875         D3(printk (KERN_NOTICE "rmdir(): up biglock\n"));
876         up(&c->fmc->biglock);
877         return ret;
878 }
879
880
881 /* Remove any kind of file except for directories.  */
882 static int
883 jffs_unlink(struct inode *dir, struct dentry *dentry)
884 {
885         struct jffs_control *c = (struct jffs_control *)dir->i_sb->u.generic_sbp;
886         int ret; 
887
888         D3(printk("***jffs_unlink()\n"));
889         D3(printk (KERN_NOTICE "unlink(): down biglock\n"));
890         down(&c->fmc->biglock);
891         ret = jffs_remove(dir, dentry, 0);
892         D3(printk (KERN_NOTICE "unlink(): up biglock\n"));
893         up(&c->fmc->biglock);
894         return ret;
895 }
896
897
898 /* Remove a JFFS entry, i.e. plain files, directories, etc.  Here we
899    shouldn't test for free space on the device.  */
900 static int
901 jffs_remove(struct inode *dir, struct dentry *dentry, int type)
902 {
903         struct jffs_raw_inode raw_inode;
904         struct jffs_control *c;
905         struct jffs_file *dir_f; /* The file-to-remove's parent.  */
906         struct jffs_file *del_f; /* The file to remove.  */
907         struct jffs_node *del_node;
908         struct inode *inode = 0;
909         int result = 0;
910
911         D1({
912                 int len = dentry->d_name.len;
913                 const char *name = dentry->d_name.name;
914                 char *_name = (char *) kmalloc(len + 1, GFP_KERNEL);
915                 memcpy(_name, name, len);
916                 _name[len] = '\0';
917                 printk("***jffs_remove(): file = \"%s\", ino = %ld\n", _name, dentry->d_inode->i_ino);
918                 kfree(_name);
919         });
920
921         dir_f = (struct jffs_file *) dir->u.generic_ip;
922         c = dir_f->c;
923
924         result = -ENOENT;
925         if (!(del_f = jffs_find_child(dir_f, dentry->d_name.name,
926                                       dentry->d_name.len))) {
927                 D(printk("jffs_remove(): jffs_find_child() failed.\n"));
928                 goto jffs_remove_end;
929         }
930
931         if (S_ISDIR(type)) {
932                 if (del_f->children) {
933                         result = -ENOTEMPTY;
934                         goto jffs_remove_end;
935                 }
936         }
937         else if (S_ISDIR(del_f->mode)) {
938                 D(printk("jffs_remove(): node is a directory "
939                          "but it shouldn't be.\n"));
940                 result = -EPERM;
941                 goto jffs_remove_end;
942         }
943
944         inode = dentry->d_inode;
945
946         result = -EIO;
947         if (del_f->ino != inode->i_ino)
948                 goto jffs_remove_end;
949
950         if (!inode->i_nlink) {
951                 printk("Deleting nonexistent file inode: %lu, nlink: %d\n",
952                        inode->i_ino, inode->i_nlink);
953                 inode->i_nlink=1;
954         }
955
956         /* Create a node for the deletion.  */
957         result = -ENOMEM;
958         if (!(del_node = (struct jffs_node *)
959                          kmalloc(sizeof(struct jffs_node), GFP_KERNEL))) {
960                 D(printk("jffs_remove(): Allocation failed!\n"));
961                 goto jffs_remove_end;
962         }
963         DJM(no_jffs_node++);
964         del_node->data_offset = 0;
965         del_node->removed_size = 0;
966
967         /* Initialize the raw inode.  */
968         raw_inode.magic = JFFS_MAGIC_BITMASK;
969         raw_inode.ino = del_f->ino;
970         raw_inode.pino = del_f->pino;
971 /*      raw_inode.version = del_f->highest_version + 1; */
972         raw_inode.mode = del_f->mode;
973         raw_inode.uid = current->fsuid;
974         raw_inode.gid = current->fsgid;
975         raw_inode.atime = CURRENT_TIME;
976         raw_inode.mtime = del_f->mtime;
977         raw_inode.ctime = raw_inode.atime;
978         raw_inode.offset = 0;
979         raw_inode.dsize = 0;
980         raw_inode.rsize = 0;
981         raw_inode.nsize = 0;
982         raw_inode.nlink = del_f->nlink;
983         raw_inode.spare = 0;
984         raw_inode.rename = 0;
985         raw_inode.deleted = 1;
986
987         /* Write the new node to the flash memory.  */
988         if (jffs_write_node(c, del_node, &raw_inode, 0, 0, 1, del_f) < 0) {
989                 kfree(del_node);
990                 DJM(no_jffs_node--);
991                 result = -EIO;
992                 goto jffs_remove_end;
993         }
994
995         /* Update the file.  This operation will make the file disappear
996            from the in-memory file system structures.  */
997         jffs_insert_node(c, del_f, &raw_inode, 0, del_node);
998
999         dir->i_version = ++event;
1000         dir->i_ctime = dir->i_mtime = CURRENT_TIME;
1001         mark_inode_dirty(dir);
1002         inode->i_nlink--;
1003         if (inode->i_nlink == 0) {
1004                 inode->u.generic_ip = 0;
1005         }
1006         inode->i_ctime = dir->i_ctime;
1007         mark_inode_dirty(inode);
1008
1009         d_delete(dentry);       /* This also frees the inode */
1010
1011         result = 0;
1012 jffs_remove_end:
1013         return result;
1014 } /* jffs_remove()  */
1015
1016
1017 static int
1018 jffs_mknod(struct inode *dir, struct dentry *dentry, int mode, int rdev)
1019 {
1020         struct jffs_raw_inode raw_inode;
1021         struct jffs_file *dir_f;
1022         struct jffs_node *node = 0;
1023         struct jffs_control *c;
1024         struct inode *inode;
1025         int result = 0;
1026         kdev_t dev = to_kdev_t(rdev);
1027         int err;
1028
1029         D1(printk("***jffs_mknod()\n"));
1030
1031         dir_f = (struct jffs_file *)dir->u.generic_ip;
1032         c = dir_f->c;
1033
1034         D3(printk (KERN_NOTICE "mknod(): down biglock\n"));
1035         down(&c->fmc->biglock);
1036
1037         /* Create and initialize a new node.  */
1038         if (!(node = (struct jffs_node *) kmalloc(sizeof(struct jffs_node),
1039                                                   GFP_KERNEL))) {
1040                 D(printk("jffs_mknod(): Allocation failed!\n"));
1041                 result = -ENOMEM;
1042                 goto jffs_mknod_err;
1043         }
1044         DJM(no_jffs_node++);
1045         node->data_offset = 0;
1046         node->removed_size = 0;
1047
1048         /* Initialize the raw inode.  */
1049         raw_inode.magic = JFFS_MAGIC_BITMASK;
1050         raw_inode.ino = c->next_ino++;
1051         raw_inode.pino = dir_f->ino;
1052         raw_inode.version = 1;
1053         raw_inode.mode = mode;
1054         raw_inode.uid = current->fsuid;
1055         raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
1056         /*      raw_inode.gid = current->fsgid; */
1057         raw_inode.atime = CURRENT_TIME;
1058         raw_inode.mtime = raw_inode.atime;
1059         raw_inode.ctime = raw_inode.atime;
1060         raw_inode.offset = 0;
1061         raw_inode.dsize = sizeof(kdev_t);
1062         raw_inode.rsize = 0;
1063         raw_inode.nsize = dentry->d_name.len;
1064         raw_inode.nlink = 1;
1065         raw_inode.spare = 0;
1066         raw_inode.rename = 0;
1067         raw_inode.deleted = 0;
1068
1069         /* Write the new node to the flash.  */
1070         if ((err = jffs_write_node(c, node, &raw_inode, dentry->d_name.name,
1071                                   (unsigned char *)&dev, 0, NULL)) < 0) {
1072                 D(printk("jffs_mknod(): jffs_write_node() failed.\n"));
1073                 result = err;
1074                 goto jffs_mknod_err;
1075         }
1076
1077         /* Insert the new node into the file system.  */
1078         if ((err = jffs_insert_node(c, 0, &raw_inode, dentry->d_name.name,
1079                                     node)) < 0) {
1080                 result = err;
1081                 goto jffs_mknod_end;
1082         }
1083
1084         inode = jffs_new_inode(dir, &raw_inode, &err);
1085         if (inode == NULL) {
1086                 result = err;
1087                 goto jffs_mknod_end;
1088         }
1089
1090         init_special_inode(inode, mode, rdev);
1091
1092         d_instantiate(dentry, inode);
1093
1094         goto jffs_mknod_end;
1095
1096 jffs_mknod_err:
1097         if (node) {
1098                 kfree(node);
1099                 DJM(no_jffs_node--);
1100         }
1101
1102 jffs_mknod_end:
1103         D3(printk (KERN_NOTICE "mknod(): up biglock\n"));
1104         up(&c->fmc->biglock);
1105         return result;
1106 } /* jffs_mknod()  */
1107
1108
1109 static int
1110 jffs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
1111 {
1112         struct jffs_raw_inode raw_inode;
1113         struct jffs_control *c;
1114         struct jffs_file *dir_f;
1115         struct jffs_node *node;
1116         struct inode *inode;
1117
1118         int symname_len = strlen(symname);
1119         int err;
1120
1121         D1({
1122                 int len = dentry->d_name.len;
1123                 char *_name = (char *)kmalloc(len + 1, GFP_KERNEL);
1124                 char *_symname = (char *)kmalloc(symname_len + 1, GFP_KERNEL);
1125                 memcpy(_name, dentry->d_name.name, len);
1126                 _name[len] = '\0';
1127                 memcpy(_symname, symname, symname_len);
1128                 _symname[symname_len] = '\0';
1129                 printk("***jffs_symlink(): dir = 0x%p, "
1130                        "dentry->dname.name = \"%s\", "
1131                        "symname = \"%s\"\n", dir, _name, _symname);
1132                 kfree(_name);
1133                 kfree(_symname);
1134         });
1135
1136         dir_f = (struct jffs_file *)dir->u.generic_ip;
1137         ASSERT(if (!dir_f) {
1138                 printk(KERN_ERR "jffs_symlink(): No reference to a "
1139                        "jffs_file struct in inode.\n");
1140                 return -EIO;
1141         });
1142
1143         c = dir_f->c;
1144
1145         /* Create a node and initialize it as much as needed.  */
1146         if (!(node = (struct jffs_node *) kmalloc(sizeof(struct jffs_node),
1147                                                   GFP_KERNEL))) {
1148                 D(printk("jffs_symlink(): Allocation failed: node = NULL\n"));
1149                 return -ENOMEM;
1150         }
1151         D3(printk (KERN_NOTICE "symlink(): down biglock\n"));
1152         down(&c->fmc->biglock);
1153
1154         DJM(no_jffs_node++);
1155         node->data_offset = 0;
1156         node->removed_size = 0;
1157
1158         /* Initialize the raw inode.  */
1159         raw_inode.magic = JFFS_MAGIC_BITMASK;
1160         raw_inode.ino = c->next_ino++;
1161         raw_inode.pino = dir_f->ino;
1162         raw_inode.version = 1;
1163         raw_inode.mode = S_IFLNK | S_IRWXUGO;
1164         raw_inode.uid = current->fsuid;
1165         raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
1166         raw_inode.atime = CURRENT_TIME;
1167         raw_inode.mtime = raw_inode.atime;
1168         raw_inode.ctime = raw_inode.atime;
1169         raw_inode.offset = 0;
1170         raw_inode.dsize = symname_len;
1171         raw_inode.rsize = 0;
1172         raw_inode.nsize = dentry->d_name.len;
1173         raw_inode.nlink = 1;
1174         raw_inode.spare = 0;
1175         raw_inode.rename = 0;
1176         raw_inode.deleted = 0;
1177
1178         /* Write the new node to the flash.  */
1179         if ((err = jffs_write_node(c, node, &raw_inode, dentry->d_name.name,
1180                                    (const unsigned char *)symname, 0, NULL)) < 0) {
1181                 D(printk("jffs_symlink(): jffs_write_node() failed.\n"));
1182                 kfree(node);
1183                 DJM(no_jffs_node--);
1184                 goto jffs_symlink_end;
1185         }
1186
1187         /* Insert the new node into the file system.  */
1188         if ((err = jffs_insert_node(c, 0, &raw_inode, dentry->d_name.name,
1189                                     node)) < 0) {
1190                 goto jffs_symlink_end;
1191         }
1192
1193         inode = jffs_new_inode(dir, &raw_inode, &err);
1194         if (inode == NULL) {
1195                 goto jffs_symlink_end;
1196         }
1197         err = 0;
1198         inode->i_op = &page_symlink_inode_operations;
1199         inode->i_mapping->a_ops = &jffs_address_operations;
1200
1201         d_instantiate(dentry, inode);
1202  jffs_symlink_end:
1203         D3(printk (KERN_NOTICE "symlink(): up biglock\n"));
1204         up(&c->fmc->biglock);
1205         return err;
1206 } /* jffs_symlink()  */
1207
1208
1209 /* Create an inode inside a JFFS directory (dir) and return it.
1210  *
1211  * By the time this is called, we already have created
1212  * the directory cache entry for the new file, but it
1213  * is so far negative - it has no inode.
1214  *
1215  * If the create succeeds, we fill in the inode information
1216  * with d_instantiate().
1217  */
1218 static int
1219 jffs_create(struct inode *dir, struct dentry *dentry, int mode)
1220 {
1221         struct jffs_raw_inode raw_inode;
1222         struct jffs_control *c;
1223         struct jffs_node *node;
1224         struct jffs_file *dir_f; /* JFFS representation of the directory.  */
1225         struct inode *inode;
1226         int err;
1227
1228         D1({
1229                 int len = dentry->d_name.len;
1230                 char *s = (char *)kmalloc(len + 1, GFP_KERNEL);
1231                 memcpy(s, dentry->d_name.name, len);
1232                 s[len] = '\0';
1233                 printk("jffs_create(): dir: 0x%p, name: \"%s\"\n", dir, s);
1234                 kfree(s);
1235         });
1236
1237         dir_f = (struct jffs_file *)dir->u.generic_ip;
1238         ASSERT(if (!dir_f) {
1239                 printk(KERN_ERR "jffs_create(): No reference to a "
1240                        "jffs_file struct in inode.\n");
1241                 return -EIO;
1242         });
1243
1244         c = dir_f->c;
1245
1246         /* Create a node and initialize as much as needed.  */
1247         if (!(node = (struct jffs_node *) kmalloc(sizeof(struct jffs_node),
1248                                                   GFP_KERNEL))) {
1249                 D(printk("jffs_create(): Allocation failed: node == 0\n"));
1250                 return -ENOMEM;
1251         }
1252         D3(printk (KERN_NOTICE "create(): down biglock\n"));
1253         down(&c->fmc->biglock);
1254
1255         DJM(no_jffs_node++);
1256         node->data_offset = 0;
1257         node->removed_size = 0;
1258
1259         /* Initialize the raw inode.  */
1260         raw_inode.magic = JFFS_MAGIC_BITMASK;
1261         raw_inode.ino = c->next_ino++;
1262         raw_inode.pino = dir_f->ino;
1263         raw_inode.version = 1;
1264         raw_inode.mode = mode;
1265         raw_inode.uid = current->fsuid;
1266         raw_inode.gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
1267         raw_inode.atime = CURRENT_TIME;
1268         raw_inode.mtime = raw_inode.atime;
1269         raw_inode.ctime = raw_inode.atime;
1270         raw_inode.offset = 0;
1271         raw_inode.dsize = 0;
1272         raw_inode.rsize = 0;
1273         raw_inode.nsize = dentry->d_name.len;
1274         raw_inode.nlink = 1;
1275         raw_inode.spare = 0;
1276         raw_inode.rename = 0;
1277         raw_inode.deleted = 0;
1278
1279         /* Write the new node to the flash.  */
1280         if ((err = jffs_write_node(c, node, &raw_inode,
1281                                    dentry->d_name.name, 0, 0, NULL)) < 0) {
1282                 D(printk("jffs_create(): jffs_write_node() failed.\n"));
1283                 kfree(node);
1284                 DJM(no_jffs_node--);
1285                 goto jffs_create_end;
1286         }
1287
1288         /* Insert the new node into the file system.  */
1289         if ((err = jffs_insert_node(c, 0, &raw_inode, dentry->d_name.name,
1290                                     node)) < 0) {
1291                 goto jffs_create_end;
1292         }
1293
1294         /* Initialize an inode.  */
1295         inode = jffs_new_inode(dir, &raw_inode, &err);
1296         if (inode == NULL) {
1297                 goto jffs_create_end;
1298         }
1299         err = 0;
1300         inode->i_op = &jffs_file_inode_operations;
1301         inode->i_fop = &jffs_file_operations;
1302         inode->i_mapping->a_ops = &jffs_address_operations;
1303         inode->i_mapping->nrpages = 0;
1304
1305         d_instantiate(dentry, inode);
1306  jffs_create_end:
1307         D3(printk (KERN_NOTICE "create(): up biglock\n"));
1308         up(&c->fmc->biglock);
1309         return err;
1310 } /* jffs_create()  */
1311
1312
1313 /* Write, append or rewrite data to an existing file.  */
1314 static ssize_t
1315 jffs_file_write(struct file *filp, const char *buf, size_t count,
1316                 loff_t *ppos)
1317 {
1318         struct jffs_raw_inode raw_inode;
1319         struct jffs_control *c;
1320         struct jffs_file *f;
1321         struct jffs_node *node;
1322         struct dentry *dentry = filp->f_dentry;
1323         struct inode *inode = dentry->d_inode;
1324         unsigned char *vbuf;
1325         int recoverable = 0;
1326         size_t written = 0;
1327         __u32 thiscount = count;
1328         loff_t pos;
1329         int err;
1330
1331         inode = filp->f_dentry->d_inode;
1332
1333         D2(printk("***jffs_file_write(): inode: 0x%p (ino: %lu), "
1334                   "filp: 0x%p, buf: 0x%p, count: %d\n",
1335                   inode, inode->i_ino, filp, buf, count));
1336
1337         err = filp->f_error;
1338         if (err) {
1339                 filp->f_error = 0;
1340                 return err;
1341         }
1342
1343         down(&inode->i_sem);
1344
1345         if (inode->i_sb->s_flags & MS_RDONLY) {
1346                 D(printk("jffs_file_write(): MS_RDONLY\n"));
1347                 err = -EROFS;
1348                 goto out_isem;
1349         }
1350
1351         err = -EINVAL;
1352
1353         if (!S_ISREG(inode->i_mode)) {
1354                 D(printk("jffs_file_write(): inode->i_mode == 0x%08x\n",
1355                          inode->i_mode));
1356                 goto out_isem;
1357         }
1358
1359         if (!(f = (struct jffs_file *)inode->u.generic_ip)) {
1360                 D(printk("jffs_file_write(): inode->u.generic_ip = 0x%p\n",
1361                          inode->u.generic_ip));
1362                 goto out_isem;
1363         }
1364
1365         c = f->c;
1366
1367         if (filp->f_flags & O_APPEND)
1368                 pos = inode->i_size;
1369         else
1370                 pos = *ppos;
1371         
1372         if (pos < 0) {
1373                 goto out_isem;
1374         }
1375         
1376         thiscount = jffs_min(c->fmc->max_chunk_size - sizeof(struct jffs_raw_inode), count);
1377
1378         if (!(vbuf = kmalloc(thiscount, GFP_KERNEL))) {
1379                 D(printk("jffs_file_write(): failed to allocate bounce buffer. Fix me to use page cache\n"));
1380                 err = -ENOMEM;
1381                 goto out_isem;
1382         }
1383
1384         D3(printk (KERN_NOTICE "file_write(): down biglock\n"));
1385         down(&c->fmc->biglock);
1386
1387         /* Urgh. POSIX says we can do short writes if we feel like it. 
1388          * In practice, we can't. Nothing will cope. So we loop until
1389          * we're done.
1390          *
1391          * <_Anarchy_> posix and reality are not interconnected on this issue
1392          */
1393         while (count) {
1394
1395                 /* FIXME: This is entirely gratuitous use of bounce buffers.
1396                    Get a clue and use the page cache. 
1397                    /me wanders off to get a crash course on Linux VFS
1398                    dwmw2
1399                 */
1400                 if (copy_from_user(vbuf, buf, thiscount)) {
1401                         err = -EFAULT;
1402                         goto out;
1403                 }
1404                 
1405                 /* Things are going to be written so we could allocate and
1406                    initialize the necessary data structures now.  */
1407                 if (!(node = (struct jffs_node *) kmalloc(sizeof(struct jffs_node),
1408                                                           GFP_KERNEL))) {
1409                         D(printk("jffs_file_write(): node == 0\n"));
1410                         err = -ENOMEM;
1411                         goto out;
1412                 }
1413                 DJM(no_jffs_node++);
1414                 
1415                 node->data_offset = pos;
1416                 node->removed_size = 0;
1417                 
1418                 /* Initialize the raw inode.  */
1419                 raw_inode.magic = JFFS_MAGIC_BITMASK;
1420                 raw_inode.ino = f->ino;
1421                 raw_inode.pino = f->pino;
1422
1423                 raw_inode.mode = f->mode;
1424                 
1425                 raw_inode.uid = f->uid;
1426                 raw_inode.gid = f->gid;
1427                 raw_inode.atime = CURRENT_TIME;
1428                 raw_inode.mtime = raw_inode.atime;
1429                 raw_inode.ctime = f->ctime;
1430                 raw_inode.offset = pos;
1431                 raw_inode.dsize = thiscount;
1432                 raw_inode.rsize = 0;
1433                 raw_inode.nsize = f->nsize;
1434                 raw_inode.nlink = f->nlink;
1435                 raw_inode.spare = 0;
1436                 raw_inode.rename = 0;
1437                 raw_inode.deleted = 0;
1438                 
1439                 if (pos < f->size) {
1440                         node->removed_size = raw_inode.rsize = jffs_min(thiscount, f->size - pos);
1441                         
1442                         /* If this node is going entirely over the top of old data, 
1443                            we can allow it to go into the reserved space, because 
1444                            we can that GC can reclaim the space later.
1445                         */
1446                         if (pos + thiscount < f->size) {
1447                                 /* If all the data we're overwriting are _real_,
1448                                    not just holes, then:
1449                                    recoverable = 1;
1450                                 */
1451                         }
1452                 }
1453                 
1454                 /* Write the new node to the flash.  */
1455                 /* NOTE: We would be quite happy if jffs_write_node() wrote a 
1456                    smaller node than we were expecting. There's no need for it 
1457                    to waste the space at the end of the flash just because it's 
1458                    a little smaller than what we asked for. But that's a whole
1459                    new can of worms which I'm not going to open this week. dwmw2.
1460                 */
1461                 if ((err = jffs_write_node(c, node, &raw_inode, f->name,
1462                                            (const unsigned char *)vbuf,
1463                                            recoverable, f)) < 0) {
1464                         D(printk("jffs_file_write(): jffs_write_node() failed.\n"));
1465                         kfree(node);
1466                         DJM(no_jffs_node--);
1467                         goto out;
1468                 }
1469
1470                 written += err;
1471                 buf += err;
1472                 count -= err;
1473                 pos += err;
1474
1475                 /* Insert the new node into the file system.  */
1476                 if ((err = jffs_insert_node(c, f, &raw_inode, 0, node)) < 0) {
1477                         goto out;
1478                 }
1479
1480                 D3(printk("jffs_file_write(): new f_pos %ld.\n", (long)pos));
1481
1482                 thiscount = jffs_min(c->fmc->max_chunk_size - sizeof(struct jffs_raw_inode), count);
1483         }
1484  out:
1485         D3(printk (KERN_NOTICE "file_write(): up biglock\n"));
1486         up(&c->fmc->biglock);
1487         *ppos = pos;
1488         kfree(vbuf);
1489
1490         /* Fix things in the real inode.  */
1491         if (pos > inode->i_size) {
1492                 inode->i_size = pos;
1493                 inode->i_blocks = (inode->i_size + 511) >> 9;
1494         }
1495         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
1496         mark_inode_dirty(inode);
1497         invalidate_inode_pages(inode);
1498
1499  out_isem:
1500         up(&inode->i_sem);
1501         
1502         /* What if there was an error, _and_ we've written some data. */
1503         if (written)
1504                 return written;
1505         else
1506                 return err;
1507 } /* jffs_file_write()  */
1508
1509
1510 /* This is our ioctl() routine.  */
1511 static int
1512 jffs_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
1513            unsigned long arg)
1514 {
1515         struct jffs_control *c;
1516         int ret = 0;
1517
1518         D2(printk("***jffs_ioctl(): cmd = 0x%08x, arg = 0x%08lx\n",
1519                   cmd, arg));
1520
1521         if (!(c = (struct jffs_control *)inode->i_sb->u.generic_sbp)) {
1522                 printk(KERN_ERR "JFFS: Bad inode in ioctl() call. "
1523                        "(cmd = 0x%08x)\n", cmd);
1524                 return -EIO;
1525         }
1526         D3(printk (KERN_NOTICE "ioctl(): down biglock\n"));
1527         down(&c->fmc->biglock);
1528
1529         switch (cmd) {
1530         case JFFS_PRINT_HASH:
1531                 jffs_print_hash_table(c);
1532                 break;
1533         case JFFS_PRINT_TREE:
1534                 jffs_print_tree(c->root, 0);
1535                 break;
1536         case JFFS_GET_STATUS:
1537                 {
1538                         struct jffs_flash_status fst;
1539                         struct jffs_fmcontrol *fmc = c->fmc;
1540                         printk("Flash status -- ");
1541                         if (!access_ok(VERIFY_WRITE,
1542                                        (struct jffs_flash_status *)arg,
1543                                        sizeof(struct jffs_flash_status))) {
1544                                 D(printk("jffs_ioctl(): Bad arg in "
1545                                          "JFFS_GET_STATUS ioctl!\n"));
1546                                 ret = -EFAULT;
1547                                 break;
1548                         }
1549                         fst.size = fmc->flash_size;
1550                         fst.used = fmc->used_size;
1551                         fst.dirty = fmc->dirty_size;
1552                         fst.begin = fmc->head->offset;
1553                         fst.end = fmc->tail->offset + fmc->tail->size;
1554                         printk("size: %d, used: %d, dirty: %d, "
1555                                "begin: %d, end: %d\n",
1556                                fst.size, fst.used, fst.dirty,
1557                                fst.begin, fst.end);
1558                         if (copy_to_user((struct jffs_flash_status *)arg,
1559                                          &fst,
1560                                          sizeof(struct jffs_flash_status))) {
1561                           ret = -EFAULT;
1562                         }
1563                 }
1564                 break;
1565         default:
1566                 ret = -ENOTTY;
1567         }
1568         D3(printk (KERN_NOTICE "ioctl(): up biglock\n"));
1569         up(&c->fmc->biglock);
1570         return ret;
1571 } /* jffs_ioctl()  */
1572
1573
1574 static struct address_space_operations jffs_address_operations = {
1575         readpage: jffs_readpage,
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         read:  generic_file_read,    /* read */
1590         write: jffs_file_write,      /* write */
1591         ioctl: jffs_ioctl,           /* ioctl */
1592         mmap:  generic_file_mmap,    /* mmap */
1593         fsync: jffs_fsync,
1594 };
1595
1596
1597 static struct inode_operations jffs_file_inode_operations =
1598 {
1599         lookup:  jffs_lookup,          /* lookup */
1600         setattr: jffs_setattr,
1601 };
1602
1603
1604 static struct file_operations jffs_dir_operations =
1605 {
1606         readdir:        jffs_readdir,
1607 };
1608
1609
1610 static struct inode_operations jffs_dir_inode_operations =
1611 {
1612         create:   jffs_create,
1613         lookup:   jffs_lookup,
1614         unlink:   jffs_unlink,
1615         symlink:  jffs_symlink,
1616         mkdir:    jffs_mkdir,
1617         rmdir:    jffs_rmdir,
1618         mknod:    jffs_mknod,
1619         rename:   jffs_rename,
1620         setattr:  jffs_setattr,
1621 };
1622
1623
1624 /* Initialize an inode for the VFS.  */
1625 static void
1626 jffs_read_inode(struct inode *inode)
1627 {
1628         struct jffs_file *f;
1629         struct jffs_control *c;
1630
1631         D3(printk("jffs_read_inode(): inode->i_ino == %lu\n", inode->i_ino));
1632
1633         if (!inode->i_sb) {
1634                 D(printk("jffs_read_inode(): !inode->i_sb ==> "
1635                          "No super block!\n"));
1636                 return;
1637         }
1638         c = (struct jffs_control *)inode->i_sb->u.generic_sbp;
1639         D3(printk (KERN_NOTICE "read_inode(): down biglock\n"));
1640         down(&c->fmc->biglock);
1641         if (!(f = jffs_find_file(c, inode->i_ino))) {
1642                 D(printk("jffs_read_inode(): No such inode (%lu).\n",
1643                          inode->i_ino));
1644                 D3(printk (KERN_NOTICE "read_inode(): up biglock\n"));
1645                 up(&c->fmc->biglock);
1646                 return;
1647         }
1648         inode->u.generic_ip = (void *)f;
1649         inode->i_mode = f->mode;
1650         inode->i_nlink = f->nlink;
1651         inode->i_uid = f->uid;
1652         inode->i_gid = f->gid;
1653         inode->i_size = f->size;
1654         inode->i_atime = f->atime;
1655         inode->i_mtime = f->mtime;
1656         inode->i_ctime = f->ctime;
1657         inode->i_blksize = PAGE_SIZE;
1658         inode->i_blocks = (inode->i_size + 511) >> 9;
1659         if (S_ISREG(inode->i_mode)) {
1660                 inode->i_op = &jffs_file_inode_operations;
1661                 inode->i_fop = &jffs_file_operations;
1662                 inode->i_mapping->a_ops = &jffs_address_operations;
1663         }
1664         else if (S_ISDIR(inode->i_mode)) {
1665                 inode->i_op = &jffs_dir_inode_operations;
1666                 inode->i_fop = &jffs_dir_operations;
1667         }
1668         else if (S_ISLNK(inode->i_mode)) {
1669                 inode->i_op = &page_symlink_inode_operations;
1670                 inode->i_mapping->a_ops = &jffs_address_operations;
1671         }
1672         else {
1673                 /* If the node is a device of some sort, then the number of
1674                    the device should be read from the flash memory and then
1675                    added to the inode's i_rdev member.  */
1676                 kdev_t rdev;
1677                 jffs_read_data(f, (char *)&rdev, 0, sizeof(kdev_t));
1678                 init_special_inode(inode, inode->i_mode, kdev_t_to_nr(rdev));
1679         }
1680         D3(printk (KERN_NOTICE "read_inode(): up biglock\n"));
1681         up(&c->fmc->biglock);
1682 }
1683
1684
1685 void
1686 jffs_delete_inode(struct inode *inode)
1687 {
1688         D3(printk("jffs_delete_inode(): inode->i_ino == %lu\n",
1689                   inode->i_ino));
1690
1691         lock_kernel();
1692         inode->i_size = 0;
1693         inode->i_blocks = 0;
1694         clear_inode(inode);
1695         unlock_kernel();
1696 }
1697
1698
1699 void
1700 jffs_write_super(struct super_block *sb)
1701 {
1702         struct jffs_control *c = (struct jffs_control *)sb->u.generic_sbp;
1703
1704         jffs_garbage_collect_trigger(c);
1705 }
1706
1707
1708 static struct super_operations jffs_ops =
1709 {
1710         read_inode:   jffs_read_inode,
1711         delete_inode: jffs_delete_inode,
1712         put_super:    jffs_put_super,
1713         write_super:  jffs_write_super,
1714         statfs:       jffs_statfs,
1715 };
1716
1717
1718 static DECLARE_FSTYPE_DEV(jffs_fs_type, "jffs", jffs_read_super);
1719
1720 static int __init
1721 init_jffs_fs(void)
1722 {
1723         return register_filesystem(&jffs_fs_type);
1724 }
1725
1726 static void __exit
1727 exit_jffs_fs(void)
1728 {
1729         unregister_filesystem(&jffs_fs_type);
1730 }
1731
1732 EXPORT_NO_SYMBOLS;
1733
1734 module_init(init_jffs_fs)
1735 module_exit(exit_jffs_fs)