yaffs_fs.c

   1 /*
   2  * YAFFS: Yet another FFS. A NAND-flash specific file system.
   3  * yaffs_fs.c
   4  *
   5  * Copyright (C) 2002 Aleph One Ltd.
   6  *   for Toby Churchill Ltd and Brightstar Engineering
   7  *
   8  * Created by Charles Manning <charles@aleph1.co.uk>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  *
  14  * This is the file system front-end to YAFFS that hooks it up to
  15  * the VFS.
  16  *
  17  * Special notes:
  18  * >> 2.4: sb->u.generic_sbp points to the yaffs_Device associated with
  19  *         this superblock
  20  * >> 2.6: sb->s_fs_info  points to the yaffs_Device associated with this
  21  *         superblock
  22  * >> inode->u.generic_ip points to the associated yaffs_Object.
  23  *
  24  * Acknowledgements:
  25  * * Luc van OostenRyck for numerous patches.
  26  * * Nick Bane for numerous patches.
  27  * * Nick Bane for 2.5/2.6 integration.
  28  * * Andras Toth for mknod rdev issue.
  29  * * Michael Fischer for finding the problem with inode inconsistency.
  30  * * Some code bodily lifted from JFFS2.
  31  */
  32
  33 const char *yaffs_fs_c_version =
  34     "$Id: yaffs_fs.c,v 1.45 2006-04-25 00:41:43 wookey Exp $";
  35 extern const char *yaffs_guts_c_version;
  36
  37 #include <linux/config.h>
  38 #include <linux/kernel.h>
  39 #include <linux/module.h>
  40 #include <linux/version.h>
  41 #include <linux/slab.h>
  42 #include <linux/init.h>
  43 #include <linux/list.h>
  44 #include <linux/fs.h>
  45 #include <linux/proc_fs.h>
  46 #include <linux/smp_lock.h>
  47 #include <linux/pagemap.h>
  48 #include <linux/mtd/mtd.h>
  49 #include <linux/interrupt.h>
  50 #include <linux/string.h>
  51 #include <linux/ctype.h>
  52
  53 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
  54
  55 #include <linux/statfs.h>       /* Added NCB 15-8-2003 */
  56 #include <asm/statfs.h>
  57 #define UnlockPage(p) unlock_page(p)
  58 #define Page_Uptodate(page)     test_bit(PG_uptodate, &(page)->flags)
  59
  60 /* FIXME: use sb->s_id instead ? */
  61 #define yaffs_devname(sb, buf)  bdevname(sb->s_bdev, buf)
  62
  63 #else
  64
  65 #include <linux/locks.h>
  66 #define BDEVNAME_SIZE           0
  67 #define yaffs_devname(sb, buf)  kdevname(sb->s_dev)
  68
  69 #endif
  70
  71 #include <asm/uaccess.h>
  72
  73 #include "yportenv.h"
  74 #include "yaffs_guts.h"
  75
  76 unsigned yaffs_traceMask = YAFFS_TRACE_ALWAYS | YAFFS_TRACE_BAD_BLOCKS /* | 0xFFFFFFFF */;
  77
  78 #include <linux/mtd/mtd.h>
  79 #include "yaffs_mtdif.h"
  80 #include "yaffs_mtdif2.h"
  81
  82 /*#define T(x) printk x */
  83
  84 #define yaffs_InodeToObject(iptr) ((yaffs_Object *)((iptr)->u.generic_ip))
  85 #define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode)
  86
  87 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
  88 #define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->s_fs_info)
  89 #else
  90 #define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->u.generic_sbp)
  91 #endif
  92
  93 static void yaffs_put_super(struct super_block *sb);
  94
  95 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
  96                                 loff_t * pos);
  97
  98 static int yaffs_file_flush(struct file *file);
  99
 100 static int yaffs_sync_object(struct file *file, struct dentry *dentry,
 101                              int datasync);
 102
 103 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);
 104
 105 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 106 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
 107                         struct nameidata *n);
 108 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
 109                                    struct nameidata *n);
 110 #else
 111 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode);
 112 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry);
 113 #endif
 114 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
 115                       struct dentry *dentry);
 116 static int yaffs_unlink(struct inode *dir, struct dentry *dentry);
 117 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
 118                          const char *symname);
 119 static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
 120
 121 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 122 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 123                        dev_t dev);
 124 #else
 125 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 126                        int dev);
 127 #endif
 128 static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
 129                         struct inode *new_dir, struct dentry *new_dentry);
 130 static int yaffs_setattr(struct dentry *dentry, struct iattr *attr);
 131
 132 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 133 static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf);
 134 #else
 135 static int yaffs_statfs(struct super_block *sb, struct statfs *buf);
 136 #endif
 137 static void yaffs_read_inode(struct inode *inode);
 138
 139 static void yaffs_put_inode(struct inode *inode);
 140 static void yaffs_delete_inode(struct inode *);
 141 static void yaffs_clear_inode(struct inode *);
 142
 143 static int yaffs_readpage(struct file *file, struct page *page);
 144 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 145 static int yaffs_writepage(struct page *page, struct writeback_control *wbc);
 146 #else
 147 static int yaffs_writepage(struct page *page);
 148 #endif
 149 static int yaffs_prepare_write(struct file *f, struct page *pg,
 150                                unsigned offset, unsigned to);
 151 static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
 152                               unsigned to);
 153
 154 static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
 155                           int buflen);
 156 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
 157 static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
 158 #else
 159 static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
 160 #endif
 161
 162 static struct address_space_operations yaffs_file_address_operations = {
 163         .readpage = yaffs_readpage,
 164         .writepage = yaffs_writepage,
 165         .prepare_write = yaffs_prepare_write,
 166         .commit_write = yaffs_commit_write,
 167 };
 168
 169 static struct file_operations yaffs_file_operations = {
 170         .read = generic_file_read,
 171         .write = generic_file_write,
 172         .mmap = generic_file_mmap,
 173         .flush = yaffs_file_flush,
 174         .fsync = yaffs_sync_object,
 175 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 176         .sendfile = generic_file_sendfile,
 177 #endif
 178
 179 };
 180
 181 static struct inode_operations yaffs_file_inode_operations = {
 182         .setattr = yaffs_setattr,
 183 };
 184
 185 static struct inode_operations yaffs_symlink_inode_operations = {
 186         .readlink = yaffs_readlink,
 187         .follow_link = yaffs_follow_link,
 188         .setattr = yaffs_setattr,
 189 };
 190
 191 static struct inode_operations yaffs_dir_inode_operations = {
 192         .create = yaffs_create,
 193         .lookup = yaffs_lookup,
 194         .link = yaffs_link,
 195         .unlink = yaffs_unlink,
 196         .symlink = yaffs_symlink,
 197         .mkdir = yaffs_mkdir,
 198         .rmdir = yaffs_unlink,
 199         .mknod = yaffs_mknod,
 200         .rename = yaffs_rename,
 201         .setattr = yaffs_setattr,
 202 };
 203
 204 static struct file_operations yaffs_dir_operations = {
 205         .read = generic_read_dir,
 206         .readdir = yaffs_readdir,
 207         .fsync = yaffs_sync_object,
 208 };
 209
 210 static struct super_operations yaffs_super_ops = {
 211         .statfs = yaffs_statfs,
 212         .read_inode = yaffs_read_inode,
 213         .put_inode = yaffs_put_inode,
 214         .put_super = yaffs_put_super,
 215         .delete_inode = yaffs_delete_inode,
 216         .clear_inode = yaffs_clear_inode,
 217 };
 218
 219 static void yaffs_GrossLock(yaffs_Device * dev)
 220 {
 221         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs locking\n"));
 222
 223         down(&dev->grossLock);
 224 }
 225
 226 static void yaffs_GrossUnlock(yaffs_Device * dev)
 227 {
 228         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs unlocking\n"));
 229         up(&dev->grossLock);
 230
 231 }
 232
 233 static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
 234                           int buflen)
 235 {
 236         unsigned char *alias;
 237         int ret;
 238
 239         yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
 240
 241         yaffs_GrossLock(dev);
 242
 243         alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry));
 244
 245         yaffs_GrossUnlock(dev);
 246
 247         if (!alias)
 248                 return -ENOMEM;
 249
 250         ret = vfs_readlink(dentry, buffer, buflen, alias);
 251         kfree(alias);
 252         return ret;
 253 }
 254
 255 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
 256 static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
 257 #else
 258 static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
 259 #endif
 260 {
 261         unsigned char *alias;
 262         int ret;
 263         yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
 264
 265         yaffs_GrossLock(dev);
 266
 267         alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry));
 268
 269         yaffs_GrossUnlock(dev);
 270
 271         if (!alias)
 272         {
 273                 ret = -ENOMEM;
 274                 goto out;
 275         }
 276
 277         ret = vfs_follow_link(nd, alias);
 278         kfree(alias);
 279 out:
 280 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
 281         return ERR_PTR (ret);
 282 #else
 283         return ret;
 284 #endif
 285 }
 286
 287 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
 288                               yaffs_Object * obj);
 289
 290 /*
 291  * Lookup is used to find objects in the fs
 292  */
 293 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 294
 295 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
 296                                    struct nameidata *n)
 297 #else
 298 static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
 299 #endif
 300 {
 301         yaffs_Object *obj;
 302         struct inode *inode = NULL;     /* NCB 2.5/2.6 needs NULL here */
 303
 304         yaffs_Device *dev = yaffs_InodeToObject(dir)->myDev;
 305
 306         yaffs_GrossLock(dev);
 307
 308         T(YAFFS_TRACE_OS,
 309           (KERN_DEBUG "yaffs_lookup for %d:%s\n",
 310            yaffs_InodeToObject(dir)->objectId, dentry->d_name.name));
 311
 312         obj =
 313             yaffs_FindObjectByName(yaffs_InodeToObject(dir),
 314                                    dentry->d_name.name);
 315
 316         obj = yaffs_GetEquivalentObject(obj);   /* in case it was a hardlink */
 317
 318         /* Can't hold gross lock when calling yaffs_get_inode() */
 319         yaffs_GrossUnlock(dev);
 320
 321         if (obj) {
 322                 T(YAFFS_TRACE_OS,
 323                   (KERN_DEBUG "yaffs_lookup found %d\n", obj->objectId));
 324
 325                 inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
 326
 327                 if (inode) {
 328                         T(YAFFS_TRACE_OS,
 329                           (KERN_DEBUG "yaffs_loookup dentry \n"));
 330 /* #if 0 asserted by NCB for 2.5/6 compatability - falls through to
 331  * d_add even if NULL inode */
 332 #if 0
 333                         /*dget(dentry); // try to solve directory bug */
 334                         d_add(dentry, inode);
 335
 336                         /* return dentry; */
 337                         return NULL;
 338 #endif
 339                 }
 340
 341         } else {
 342                 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_lookup not found\n"));
 343
 344         }
 345
 346 /* added NCB for 2.5/6 compatability - forces add even if inode is
 347  * NULL which creates dentry hash */
 348         d_add(dentry, inode);
 349
 350         return NULL;
 351         /*      return (ERR_PTR(-EIO)); */
 352
 353 }
 354
 355 /* For now put inode is just for debugging
 356  * Put inode is called when the inode **structure** is put.
 357  */
 358 static void yaffs_put_inode(struct inode *inode)
 359 {
 360         T(YAFFS_TRACE_OS,
 361           ("yaffs_put_inode: ino %d, count %d\n", (int)inode->i_ino,
 362            atomic_read(&inode->i_count)));
 363
 364 }
 365
 366 /* clear is called to tell the fs to release any per-inode data it holds */
 367 static void yaffs_clear_inode(struct inode *inode)
 368 {
 369         yaffs_Object *obj;
 370         yaffs_Device *dev;
 371
 372         obj = yaffs_InodeToObject(inode);
 373
 374         T(YAFFS_TRACE_OS,
 375           ("yaffs_clear_inode: ino %d, count %d %s\n", (int)inode->i_ino,
 376            atomic_read(&inode->i_count),
 377            obj ? "object exists" : "null object"));
 378
 379         if (obj) {
 380                 dev = obj->myDev;
 381                 yaffs_GrossLock(dev);
 382
 383                 /* Clear the association between the inode and
 384                  * the yaffs_Object.
 385                  */
 386                 obj->myInode = NULL;
 387                 inode->u.generic_ip = NULL;
 388
 389                 /* If the object freeing was deferred, then the real
 390                  * free happens now.
 391                  * This should fix the inode inconsistency problem.
 392                  */
 393
 394                 yaffs_HandleDeferedFree(obj);
 395
 396                 yaffs_GrossUnlock(dev);
 397         }
 398
 399 }
 400
 401 /* delete is called when the link count is zero and the inode
 402  * is put (ie. nobody wants to know about it anymore, time to
 403  * delete the file).
 404  * NB Must call clear_inode()
 405  */
 406 static void yaffs_delete_inode(struct inode *inode)
 407 {
 408         yaffs_Object *obj = yaffs_InodeToObject(inode);
 409         yaffs_Device *dev;
 410
 411         T(YAFFS_TRACE_OS,
 412           ("yaffs_delete_inode: ino %d, count %d %s\n", (int)inode->i_ino,
 413            atomic_read(&inode->i_count),
 414            obj ? "object exists" : "null object"));
 415
 416         if (obj) {
 417                 dev = obj->myDev;
 418                 yaffs_GrossLock(dev);
 419                 yaffs_DeleteFile(obj);
 420                 yaffs_GrossUnlock(dev);
 421         }
 422 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
 423         truncate_inode_pages (&inode->i_data, 0);
 424 #endif
 425         clear_inode(inode);
 426 }
 427
 428 static int yaffs_file_flush(struct file *file)
 429 {
 430         yaffs_Object *obj = yaffs_DentryToObject(file->f_dentry);
 431
 432         yaffs_Device *dev = obj->myDev;
 433
 434         T(YAFFS_TRACE_OS,
 435           (KERN_DEBUG "yaffs_file_flush object %d (%s)\n", obj->objectId,
 436            obj->dirty ? "dirty" : "clean"));
 437
 438         yaffs_GrossLock(dev);
 439
 440         yaffs_FlushFile(obj, 1);
 441
 442         yaffs_GrossUnlock(dev);
 443
 444         return 0;
 445 }
 446
 447 static int yaffs_readpage_nolock(struct file *f, struct page *pg)
 448 {
 449         /* Lifted from jffs2 */
 450
 451         yaffs_Object *obj;
 452         unsigned char *pg_buf;
 453         int ret;
 454
 455         yaffs_Device *dev;
 456
 457         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage at %08x, size %08x\n",
 458                            (unsigned)(pg->index << PAGE_CACHE_SHIFT),
 459                            (unsigned)PAGE_CACHE_SIZE));
 460
 461         obj = yaffs_DentryToObject(f->f_dentry);
 462
 463         dev = obj->myDev;
 464
 465 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 466         BUG_ON(!PageLocked(pg));
 467 #else
 468         if (!PageLocked(pg))
 469                 PAGE_BUG(pg);
 470 #endif
 471
 472         pg_buf = kmap(pg);
 473         /* FIXME: Can kmap fail? */
 474
 475         yaffs_GrossLock(dev);
 476
 477         ret =
 478             yaffs_ReadDataFromFile(obj, pg_buf, pg->index << PAGE_CACHE_SHIFT,
 479                                    PAGE_CACHE_SIZE);
 480
 481         yaffs_GrossUnlock(dev);
 482
 483         if (ret >= 0)
 484                 ret = 0;
 485
 486         if (ret) {
 487                 ClearPageUptodate(pg);
 488                 SetPageError(pg);
 489         } else {
 490                 SetPageUptodate(pg);
 491                 ClearPageError(pg);
 492         }
 493
 494         flush_dcache_page(pg);
 495         kunmap(pg);
 496
 497         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage done\n"));
 498         return ret;
 499 }
 500
 501 static int yaffs_readpage_unlock(struct file *f, struct page *pg)
 502 {
 503         int ret = yaffs_readpage_nolock(f, pg);
 504         UnlockPage(pg);
 505         return ret;
 506 }
 507
 508 static int yaffs_readpage(struct file *f, struct page *pg)
 509 {
 510         return yaffs_readpage_unlock(f, pg);
 511 }
 512
 513 /* writepage inspired by/stolen from smbfs */
 514
 515 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 516 static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
 517 #else
 518 static int yaffs_writepage(struct page *page)
 519 #endif
 520 {
 521         struct address_space *mapping = page->mapping;
 522         loff_t offset = (loff_t) page->index << PAGE_CACHE_SHIFT;
 523         struct inode *inode;
 524         unsigned long end_index;
 525         char *buffer;
 526         yaffs_Object *obj;
 527         int nWritten = 0;
 528         unsigned nBytes;
 529
 530         if (!mapping)
 531                 BUG();
 532         inode = mapping->host;
 533         if (!inode)
 534                 BUG();
 535
 536         if (offset > inode->i_size) {
 537                 T(YAFFS_TRACE_OS,
 538                   (KERN_DEBUG
 539                    "yaffs_writepage at %08x, inode size = %08x!!!\n",
 540                    (unsigned)(page->index << PAGE_CACHE_SHIFT),
 541                    (unsigned)inode->i_size));
 542                 T(YAFFS_TRACE_OS,
 543                   (KERN_DEBUG "                -> don't care!!\n"));
 544                 unlock_page(page);
 545                 return 0;
 546         }
 547
 548         end_index = inode->i_size >> PAGE_CACHE_SHIFT;
 549
 550         /* easy case */
 551         if (page->index < end_index) {
 552                 nBytes = PAGE_CACHE_SIZE;
 553         } else {
 554                 nBytes = inode->i_size & (PAGE_CACHE_SIZE - 1);
 555         }
 556
 557         get_page(page);
 558
 559         buffer = kmap(page);
 560
 561         obj = yaffs_InodeToObject(inode);
 562         yaffs_GrossLock(obj->myDev);
 563
 564         T(YAFFS_TRACE_OS,
 565           (KERN_DEBUG "yaffs_writepage at %08x, size %08x\n",
 566            (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes));
 567         T(YAFFS_TRACE_OS,
 568           (KERN_DEBUG "writepag0: obj = %05x, ino = %05x\n",
 569            (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
 570
 571         nWritten =
 572             yaffs_WriteDataToFile(obj, buffer, page->index << PAGE_CACHE_SHIFT,
 573                                   nBytes, 0);
 574
 575         T(YAFFS_TRACE_OS,
 576           (KERN_DEBUG "writepag1: obj = %05x, ino = %05x\n",
 577            (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
 578
 579         yaffs_GrossUnlock(obj->myDev);
 580
 581         kunmap(page);
 582         SetPageUptodate(page);
 583         UnlockPage(page);
 584         put_page(page);
 585
 586         return (nWritten == nBytes) ? 0 : -ENOSPC;
 587 }
 588
 589 static int yaffs_prepare_write(struct file *f, struct page *pg,
 590                                unsigned offset, unsigned to)
 591 {
 592
 593         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_prepair_write\n"));
 594         if (!Page_Uptodate(pg) && (offset || to < PAGE_CACHE_SIZE))
 595                 return yaffs_readpage_nolock(f, pg);
 596
 597         return 0;
 598
 599 }
 600
 601 static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
 602                               unsigned to)
 603 {
 604
 605         void *addr = page_address(pg) + offset;
 606         loff_t pos = (((loff_t) pg->index) << PAGE_CACHE_SHIFT) + offset;
 607         int nBytes = to - offset;
 608         int nWritten;
 609
 610         unsigned spos = pos;
 611         unsigned saddr = (unsigned)addr;
 612
 613         T(YAFFS_TRACE_OS,
 614           (KERN_DEBUG "yaffs_commit_write addr %x pos %x nBytes %d\n", saddr,
 615            spos, nBytes));
 616
 617         nWritten = yaffs_file_write(f, addr, nBytes, &pos);
 618
 619         if (nWritten != nBytes) {
 620                 T(YAFFS_TRACE_OS,
 621                   (KERN_DEBUG
 622                    "yaffs_commit_write not same size nWritten %d  nBytes %d\n",
 623                    nWritten, nBytes));
 624                 SetPageError(pg);
 625                 ClearPageUptodate(pg);
 626         } else {
 627                 SetPageUptodate(pg);
 628         }
 629
 630         T(YAFFS_TRACE_OS,
 631           (KERN_DEBUG "yaffs_commit_write returning %d\n",
 632            nWritten == nBytes ? 0 : nWritten));
 633
 634         return nWritten == nBytes ? 0 : nWritten;
 635
 636 }
 637
 638 static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object * obj)
 639 {
 640         if (inode && obj) {
 641                 inode->i_ino = obj->objectId;
 642                 inode->i_mode = obj->yst_mode;
 643                 inode->i_uid = obj->yst_uid;
 644                 inode->i_gid = obj->yst_gid;
 645                 inode->i_blksize = inode->i_sb->s_blocksize;
 646 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 647
 648                 inode->i_rdev = old_decode_dev(obj->yst_rdev);
 649                 inode->i_atime.tv_sec = (time_t) (obj->yst_atime);
 650                 inode->i_atime.tv_nsec = 0;
 651                 inode->i_mtime.tv_sec = (time_t) obj->yst_mtime;
 652                 inode->i_mtime.tv_nsec = 0;
 653                 inode->i_ctime.tv_sec = (time_t) obj->yst_ctime;
 654                 inode->i_ctime.tv_nsec = 0;
 655 #else
 656                 inode->i_rdev = obj->yst_rdev;
 657                 inode->i_atime = obj->yst_atime;
 658                 inode->i_mtime = obj->yst_mtime;
 659                 inode->i_ctime = obj->yst_ctime;
 660 #endif
 661                 inode->i_size = yaffs_GetObjectFileLength(obj);
 662                 inode->i_blocks = (inode->i_size + 511) >> 9;
 663
 664                 inode->i_nlink = yaffs_GetObjectLinkCount(obj);
 665
 666                 T(YAFFS_TRACE_OS,
 667                   (KERN_DEBUG
 668                    "yaffs_FillInode mode %x uid %d gid %d size %d count %d\n",
 669                    inode->i_mode, inode->i_uid, inode->i_gid,
 670                    (int)inode->i_size, atomic_read(&inode->i_count)));
 671
 672                 switch (obj->yst_mode & S_IFMT) {
 673                 default:        /* fifo, device or socket */
 674 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 675                         init_special_inode(inode, obj->yst_mode,
 676                                            old_decode_dev(obj->yst_rdev));
 677 #else
 678                         init_special_inode(inode, obj->yst_mode,
 679                                            (dev_t) (obj->yst_rdev));
 680 #endif
 681                         break;
 682                 case S_IFREG:   /* file */
 683                         inode->i_op = &yaffs_file_inode_operations;
 684                         inode->i_fop = &yaffs_file_operations;
 685                         inode->i_mapping->a_ops =
 686                             &yaffs_file_address_operations;
 687                         break;
 688                 case S_IFDIR:   /* directory */
 689                         inode->i_op = &yaffs_dir_inode_operations;
 690                         inode->i_fop = &yaffs_dir_operations;
 691                         break;
 692                 case S_IFLNK:   /* symlink */
 693                         inode->i_op = &yaffs_symlink_inode_operations;
 694                         break;
 695                 }
 696
 697                 inode->u.generic_ip = obj;
 698                 obj->myInode = inode;
 699
 700         } else {
 701                 T(YAFFS_TRACE_OS,
 702                   (KERN_DEBUG "yaffs_FileInode invalid parameters\n"));
 703         }
 704
 705 }
 706
 707 struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
 708                               yaffs_Object * obj)
 709 {
 710         struct inode *inode;
 711
 712         if (!sb) {
 713                 T(YAFFS_TRACE_OS,
 714                   (KERN_DEBUG "yaffs_get_inode for NULL super_block!!\n"));
 715                 return NULL;
 716
 717         }
 718
 719         if (!obj) {
 720                 T(YAFFS_TRACE_OS,
 721                   (KERN_DEBUG "yaffs_get_inode for NULL object!!\n"));
 722                 return NULL;
 723
 724         }
 725
 726         T(YAFFS_TRACE_OS,
 727           (KERN_DEBUG "yaffs_get_inode for object %d\n", obj->objectId));
 728
 729         inode = iget(sb, obj->objectId);
 730
 731         /* NB Side effect: iget calls back to yaffs_read_inode(). */
 732         /* iget also increments the inode's i_count */
 733         /* NB You can't be holding grossLock or deadlock will happen! */
 734
 735         return inode;
 736 }
 737
 738 static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
 739                                 loff_t * pos)
 740 {
 741         yaffs_Object *obj;
 742         int nWritten, ipos;
 743         struct inode *inode;
 744         yaffs_Device *dev;
 745
 746         obj = yaffs_DentryToObject(f->f_dentry);
 747
 748         dev = obj->myDev;
 749
 750         yaffs_GrossLock(dev);
 751
 752         inode = f->f_dentry->d_inode;
 753
 754         if (!S_ISBLK(inode->i_mode) && f->f_flags & O_APPEND) {
 755                 ipos = inode->i_size;
 756         } else {
 757                 ipos = *pos;
 758         }
 759
 760         if (!obj) {
 761                 T(YAFFS_TRACE_OS,
 762                   (KERN_DEBUG "yaffs_file_write: hey obj is null!\n"));
 763         } else {
 764                 T(YAFFS_TRACE_OS,
 765                   (KERN_DEBUG
 766                    "yaffs_file_write about to write writing %d bytes"
 767                    "to object %d at %d\n",
 768                    n, obj->objectId, ipos));
 769         }
 770
 771         nWritten = yaffs_WriteDataToFile(obj, buf, ipos, n, 0);
 772
 773         T(YAFFS_TRACE_OS,
 774           (KERN_DEBUG "yaffs_file_write writing %d bytes, %d written at %d\n",
 775            n, nWritten, ipos));
 776         if (nWritten > 0) {
 777                 ipos += nWritten;
 778                 *pos = ipos;
 779                 if (ipos > inode->i_size) {
 780                         inode->i_size = ipos;
 781                         inode->i_blocks = (ipos + 511) >> 9;
 782
 783                         T(YAFFS_TRACE_OS,
 784                           (KERN_DEBUG
 785                            "yaffs_file_write size updated to %d bytes, "
 786                            "%d blocks\n",
 787                            ipos, (int)(inode->i_blocks)));
 788                 }
 789
 790         }
 791         yaffs_GrossUnlock(dev);
 792         return nWritten == 0 ? -ENOSPC : nWritten;
 793 }
 794
 795 static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
 796 {
 797         yaffs_Object *obj;
 798         yaffs_Device *dev;
 799         struct inode *inode = f->f_dentry->d_inode;
 800         unsigned long offset, curoffs;
 801         struct list_head *i;
 802         yaffs_Object *l;
 803
 804         char name[YAFFS_MAX_NAME_LENGTH + 1];
 805
 806         obj = yaffs_DentryToObject(f->f_dentry);
 807         dev = obj->myDev;
 808
 809         yaffs_GrossLock(dev);
 810
 811         offset = f->f_pos;
 812
 813         T(YAFFS_TRACE_OS, ("yaffs_readdir: starting at %d\n", (int)offset));
 814
 815         if (offset == 0) {
 816                 T(YAFFS_TRACE_OS,
 817                   (KERN_DEBUG "yaffs_readdir: entry . ino %d \n",
 818                    (int)inode->i_ino));
 819                 if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR)
 820                     < 0) {
 821                         goto out;
 822                 }
 823                 offset++;
 824                 f->f_pos++;
 825         }
 826         if (offset == 1) {
 827                 T(YAFFS_TRACE_OS,
 828                   (KERN_DEBUG "yaffs_readdir: entry .. ino %d \n",
 829                    (int)f->f_dentry->d_parent->d_inode->i_ino));
 830                 if (filldir
 831                     (dirent, "..", 2, offset,
 832                      f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
 833                         goto out;
 834                 }
 835                 offset++;
 836                 f->f_pos++;
 837         }
 838
 839         curoffs = 1;
 840
 841         /* If the directory has changed since the open or last call to
 842            readdir, rewind to after the 2 canned entries. */
 843
 844         if (f->f_version != inode->i_version) {
 845                 offset = 2;
 846                 f->f_pos = offset;
 847                 f->f_version = inode->i_version;
 848         }
 849
 850         list_for_each(i, &obj->variant.directoryVariant.children) {
 851                 curoffs++;
 852                 if (curoffs >= offset) {
 853                         l = list_entry(i, yaffs_Object, siblings);
 854
 855                         yaffs_GetObjectName(l, name,
 856                                             YAFFS_MAX_NAME_LENGTH + 1);
 857                         T(YAFFS_TRACE_OS,
 858                           (KERN_DEBUG "yaffs_readdir: %s inode %d\n", name,
 859                            yaffs_GetObjectInode(l)));
 860
 861                         if (filldir(dirent,
 862                                     name,
 863                                     strlen(name),
 864                                     offset,
 865                                     yaffs_GetObjectInode(l),
 866                                     yaffs_GetObjectType(l))
 867                             < 0) {
 868                                 goto up_and_out;
 869                         }
 870
 871                         offset++;
 872                         f->f_pos++;
 873                 }
 874         }
 875
 876       up_and_out:
 877       out:
 878
 879         yaffs_GrossUnlock(dev);
 880
 881         return 0;
 882 }
 883
 884 /*
 885  * File creation. Allocate an inode, and we're done..
 886  */
 887 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 888 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 889                        dev_t rdev)
 890 #else
 891 static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
 892                        int rdev)
 893 #endif
 894 {
 895         struct inode *inode;
 896
 897         yaffs_Object *obj = NULL;
 898         yaffs_Device *dev;
 899
 900         yaffs_Object *parent = yaffs_InodeToObject(dir);
 901
 902         int error = -ENOSPC;
 903         uid_t uid = current->fsuid;
 904         gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
 905
 906         if (parent) {
 907                 T(YAFFS_TRACE_OS,
 908                   (KERN_DEBUG "yaffs_mknod: parent object %d type %d\n",
 909                    parent->objectId, parent->variantType));
 910         } else {
 911                 T(YAFFS_TRACE_OS,
 912                   (KERN_DEBUG "yaffs_mknod: could not get parent object\n"));
 913                 return -EPERM;
 914         }
 915
 916         T(YAFFS_TRACE_OS, ("yaffs_mknod: making oject for %s, "
 917                            "mode %x dev %x\n",
 918                            dentry->d_name.name, mode, rdev));
 919
 920         dev = parent->myDev;
 921
 922         yaffs_GrossLock(dev);
 923
 924         switch (mode & S_IFMT) {
 925         default:
 926                 /* Special (socket, fifo, device...) */
 927                 T(YAFFS_TRACE_OS, (KERN_DEBUG
 928                                    "yaffs_mknod: making special\n"));
 929 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 930                 obj =
 931                     yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
 932                                        gid, old_encode_dev(rdev));
 933 #else
 934                 obj =
 935                     yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
 936                                        gid, rdev);
 937 #endif
 938                 break;
 939         case S_IFREG:           /* file          */
 940                 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
 941                 obj =
 942                     yaffs_MknodFile(parent, dentry->d_name.name, mode, uid,
 943                                     gid);
 944                 break;
 945         case S_IFDIR:           /* directory */
 946                 T(YAFFS_TRACE_OS,
 947                   (KERN_DEBUG "yaffs_mknod: making directory\n"));
 948                 obj =
 949                     yaffs_MknodDirectory(parent, dentry->d_name.name, mode,
 950                                          uid, gid);
 951                 break;
 952         case S_IFLNK:           /* symlink */
 953                 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
 954                 obj = NULL;     /* Do we ever get here? */
 955                 break;
 956         }
 957
 958         /* Can not call yaffs_get_inode() with gross lock held */
 959         yaffs_GrossUnlock(dev);
 960
 961         if (obj) {
 962                 inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj);
 963                 d_instantiate(dentry, inode);
 964                 T(YAFFS_TRACE_OS,
 965                   (KERN_DEBUG "yaffs_mknod created object %d count = %d\n",
 966                    obj->objectId, atomic_read(&inode->i_count)));
 967                 error = 0;
 968         } else {
 969                 T(YAFFS_TRACE_OS,
 970                   (KERN_DEBUG "yaffs_mknod failed making object\n"));
 971                 error = -ENOMEM;
 972         }
 973
 974         return error;
 975 }
 976
 977 static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 978 {
 979         int retVal;
 980         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mkdir\n"));
 981         retVal = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
 982 #if 0
 983         /* attempt to fix dir bug - didn't work */
 984         if (!retVal) {
 985                 dget(dentry);
 986         }
 987 #endif
 988         return retVal;
 989 }
 990
 991 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 992 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
 993                         struct nameidata *n)
 994 #else
 995 static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode)
 996 #endif
 997 {
 998         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_create\n"));
 999         return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
1000 }
1001
1002 static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
1003 {
1004         int retVal;
1005
1006         yaffs_Device *dev;
1007
1008         T(YAFFS_TRACE_OS,
1009           (KERN_DEBUG "yaffs_unlink %d:%s\n", (int)(dir->i_ino),
1010            dentry->d_name.name));
1011
1012         dev = yaffs_InodeToObject(dir)->myDev;
1013
1014         yaffs_GrossLock(dev);
1015
1016         retVal = yaffs_Unlink(yaffs_InodeToObject(dir), dentry->d_name.name);
1017
1018         if (retVal == YAFFS_OK) {
1019                 dentry->d_inode->i_nlink--;
1020                 dir->i_version++;
1021                 yaffs_GrossUnlock(dev);
1022                 mark_inode_dirty(dentry->d_inode);
1023                 return 0;
1024         }
1025         yaffs_GrossUnlock(dev);
1026         return -ENOTEMPTY;
1027 }
1028
1029 /*
1030  * Create a link...
1031  */
1032 static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
1033                       struct dentry *dentry)
1034 {
1035         struct inode *inode = old_dentry->d_inode;
1036         yaffs_Object *obj = NULL;
1037         yaffs_Object *link = NULL;
1038         yaffs_Device *dev;
1039
1040         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_link\n"));
1041
1042         obj = yaffs_InodeToObject(inode);
1043         dev = obj->myDev;
1044
1045         yaffs_GrossLock(dev);
1046
1047         if (!S_ISDIR(inode->i_mode))    /* Don't link directories */
1048         {
1049                 link =
1050                     yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name,
1051                                obj);
1052         }
1053
1054         if (link) {
1055                 old_dentry->d_inode->i_nlink = yaffs_GetObjectLinkCount(obj);
1056                 d_instantiate(dentry, old_dentry->d_inode);
1057                 atomic_inc(&old_dentry->d_inode->i_count);
1058                 T(YAFFS_TRACE_OS,
1059                   (KERN_DEBUG "yaffs_link link count %d i_count %d\n",
1060                    old_dentry->d_inode->i_nlink,
1061                    atomic_read(&old_dentry->d_inode->i_count)));
1062
1063         }
1064
1065         yaffs_GrossUnlock(dev);
1066
1067         if (link) {
1068
1069                 return 0;
1070         }
1071
1072         return -EPERM;
1073 }
1074
1075 static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
1076                          const char *symname)
1077 {
1078         yaffs_Object *obj;
1079         yaffs_Device *dev;
1080         uid_t uid = current->fsuid;
1081         gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
1082
1083         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_symlink\n"));
1084
1085         dev = yaffs_InodeToObject(dir)->myDev;
1086         yaffs_GrossLock(dev);
1087         obj = yaffs_MknodSymLink(yaffs_InodeToObject(dir), dentry->d_name.name,
1088                                  S_IFLNK | S_IRWXUGO, uid, gid, symname);
1089         yaffs_GrossUnlock(dev);
1090
1091         if (obj) {
1092
1093                 struct inode *inode;
1094
1095                 inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
1096                 d_instantiate(dentry, inode);
1097                 T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink created OK\n"));
1098                 return 0;
1099         } else {
1100                 T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink not created\n"));
1101
1102         }
1103
1104         return -ENOMEM;
1105 }
1106
1107 static int yaffs_sync_object(struct file *file, struct dentry *dentry,
1108                              int datasync)
1109 {
1110
1111         yaffs_Object *obj;
1112         yaffs_Device *dev;
1113
1114         obj = yaffs_DentryToObject(dentry);
1115
1116         dev = obj->myDev;
1117
1118         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_object\n"));
1119         yaffs_GrossLock(dev);
1120         yaffs_FlushFile(obj, 1);
1121         yaffs_GrossUnlock(dev);
1122         return 0;
1123 }
1124
1125 /*
1126  * The VFS layer already does all the dentry stuff for rename.
1127  *
1128  * NB: POSIX says you can rename an object over an old object of the same name
1129  */
1130 static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
1131                         struct inode *new_dir, struct dentry *new_dentry)
1132 {
1133         yaffs_Device *dev;
1134         int retVal = YAFFS_FAIL;
1135         yaffs_Object *target;
1136
1137         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_rename\n"));
1138         dev = yaffs_InodeToObject(old_dir)->myDev;
1139
1140         yaffs_GrossLock(dev);
1141
1142         /* Check if the target is an existing directory that is not empty. */
1143         target =
1144             yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),
1145                                    new_dentry->d_name.name);
1146
1147
1148
1149         if (target &&
1150             target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
1151             !list_empty(&target->variant.directoryVariant.children)) {
1152
1153                 T(YAFFS_TRACE_OS, (KERN_DEBUG "target is non-empty dir\n"));
1154
1155                 retVal = YAFFS_FAIL;
1156         } else {
1157
1158                 /* Now does unlinking internally using shadowing mechanism */
1159                 T(YAFFS_TRACE_OS, (KERN_DEBUG "calling yaffs_RenameObject\n"));
1160
1161                 retVal =
1162                     yaffs_RenameObject(yaffs_InodeToObject(old_dir),
1163                                        old_dentry->d_name.name,
1164                                        yaffs_InodeToObject(new_dir),
1165                                        new_dentry->d_name.name);
1166
1167         }
1168         yaffs_GrossUnlock(dev);
1169
1170         if (retVal == YAFFS_OK) {
1171                 if(target) {
1172                         new_dentry->d_inode->i_nlink--;
1173                         mark_inode_dirty(new_dentry->d_inode);
1174                 }
1175
1176                 return 0;
1177         } else {
1178                 return -ENOTEMPTY;
1179         }
1180
1181 }
1182
1183 static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
1184 {
1185         struct inode *inode = dentry->d_inode;
1186         int error;
1187         yaffs_Device *dev;
1188
1189         T(YAFFS_TRACE_OS,
1190           (KERN_DEBUG "yaffs_setattr of object %d\n",
1191            yaffs_InodeToObject(inode)->objectId));
1192
1193         if ((error = inode_change_ok(inode, attr)) == 0) {
1194
1195                 dev = yaffs_InodeToObject(inode)->myDev;
1196                 yaffs_GrossLock(dev);
1197                 if (yaffs_SetAttributes(yaffs_InodeToObject(inode), attr) ==
1198                     YAFFS_OK) {
1199                         error = 0;
1200                 } else {
1201                         error = -EPERM;
1202                 }
1203                 yaffs_GrossUnlock(dev);
1204                 if (!error)
1205                         error = inode_setattr(inode, attr);
1206         }
1207         return error;
1208 }
1209
1210 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1211 static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf)
1212 #else
1213 static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
1214 #endif
1215 {
1216
1217         yaffs_Device *dev = yaffs_SuperToDevice(sb);
1218         T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_statfs\n"));
1219
1220         yaffs_GrossLock(dev);
1221
1222         buf->f_type = YAFFS_MAGIC;
1223         buf->f_bsize = sb->s_blocksize;
1224         buf->f_namelen = 255;
1225         if (sb->s_blocksize > dev->nBytesPerChunk) {
1226
1227                 buf->f_blocks =
1228                     (dev->endBlock - dev->startBlock +
1229                      1) * dev->nChunksPerBlock / (sb->s_blocksize /
1230                                                   dev->nBytesPerChunk);
1231                 buf->f_bfree =
1232                     yaffs_GetNumberOfFreeChunks(dev) / (sb->s_blocksize /
1233                                                         dev->nBytesPerChunk);
1234         } else {
1235
1236                 buf->f_blocks =
1237                     (dev->endBlock - dev->startBlock +
1238                      1) * dev->nChunksPerBlock * (dev->nBytesPerChunk /
1239                                                   sb->s_blocksize);
1240                 buf->f_bfree =
1241                     yaffs_GetNumberOfFreeChunks(dev) * (dev->nBytesPerChunk /
1242                                                         sb->s_blocksize);
1243         }
1244         buf->f_files = 0;
1245         buf->f_ffree = 0;
1246         buf->f_bavail = buf->f_bfree;
1247
1248         yaffs_GrossUnlock(dev);
1249         return 0;
1250 }
1251
1252 static void yaffs_read_inode(struct inode *inode)
1253 {
1254         /* NB This is called as a side effect of other functions, but
1255          * we had to release the lock to prevent deadlocks, so
1256          * need to lock again.
1257          */
1258
1259         yaffs_Object *obj;
1260         yaffs_Device *dev = yaffs_SuperToDevice(inode->i_sb);
1261
1262         T(YAFFS_TRACE_OS,
1263           (KERN_DEBUG "yaffs_read_inode for %d\n", (int)inode->i_ino));
1264
1265         yaffs_GrossLock(dev);
1266
1267         obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
1268
1269         yaffs_FillInodeFromObject(inode, obj);
1270
1271         yaffs_GrossUnlock(dev);
1272 }
1273
1274 static LIST_HEAD(yaffs_dev_list);
1275
1276 static void yaffs_put_super(struct super_block *sb)
1277 {
1278         yaffs_Device *dev = yaffs_SuperToDevice(sb);
1279
1280         yaffs_GrossLock(dev);
1281
1282         yaffs_FlushEntireDeviceCache(dev);
1283
1284         if (dev->putSuperFunc) {
1285                 dev->putSuperFunc(sb);
1286         }
1287         yaffs_Deinitialise(dev);
1288         yaffs_GrossUnlock(dev);
1289
1290         /* we assume this is protected by lock_kernel() in mount/umount */
1291         list_del(&dev->devList);
1292
1293         if(dev->spareBuffer){
1294                 YFREE(dev->spareBuffer);
1295                 dev->spareBuffer = NULL;
1296         }
1297
1298         kfree(dev);
1299 }
1300
1301
1302 static void yaffs_MTDPutSuper(struct super_block *sb)
1303 {
1304
1305         struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
1306
1307         if (mtd->sync) {
1308                 mtd->sync(mtd);
1309         }
1310
1311         put_mtd_device(mtd);
1312 }
1313
1314
1315 static struct super_block *yaffs_internal_read_super(int yaffsVersion,
1316                                                      struct super_block *sb,
1317                                                      void *data, int silent)
1318 {
1319         int nBlocks;
1320         struct inode *inode = NULL;
1321         struct dentry *root;
1322         yaffs_Device *dev = 0;
1323         char devname_buf[BDEVNAME_SIZE + 1];
1324         struct mtd_info *mtd;
1325         int err;
1326
1327         sb->s_magic = YAFFS_MAGIC;
1328         sb->s_op = &yaffs_super_ops;
1329
1330         if (!sb)
1331                 printk(KERN_INFO "yaffs: sb is NULL\n");
1332         else if (!sb->s_dev)
1333                 printk(KERN_INFO "yaffs: sb->s_dev is NULL\n");
1334         else if (!yaffs_devname(sb, devname_buf))
1335                 printk(KERN_INFO "yaffs: devname is NULL\n");
1336         else
1337                 printk(KERN_INFO "yaffs: dev is %d name is \"%s\"\n",
1338                        sb->s_dev,
1339                        yaffs_devname(sb, devname_buf));
1340
1341         sb->s_blocksize = PAGE_CACHE_SIZE;
1342         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
1343         T(YAFFS_TRACE_OS, ("yaffs_read_super: Using yaffs%d\n", yaffsVersion));
1344         T(YAFFS_TRACE_OS,
1345           ("yaffs_read_super: block size %d\n", (int)(sb->s_blocksize)));
1346
1347 #ifdef CONFIG_YAFFS_DISABLE_WRITE_VERIFY
1348         T(YAFFS_TRACE_OS,
1349           ("yaffs: Write verification disabled. All guarantees "
1350            "null and void\n"));
1351 #endif
1352
1353         T(YAFFS_TRACE_ALWAYS, ("yaffs: Attempting MTD mount on %u.%u, "
1354                                "\"%s\"\n",
1355                                MAJOR(sb->s_dev), MINOR(sb->s_dev),
1356                                yaffs_devname(sb, devname_buf)));
1357
1358         /* Check it's an mtd device..... */
1359         if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) {
1360                 return NULL;    /* This isn't an mtd device */
1361         }
1362         /* Get the device */
1363         mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
1364         if (!mtd) {
1365                 T(YAFFS_TRACE_ALWAYS,
1366                   ("yaffs: MTD device #%u doesn't appear to exist\n",
1367                    MINOR(sb->s_dev)));
1368                 return NULL;
1369         }
1370         /* Check it's NAND */
1371         if (mtd->type != MTD_NANDFLASH) {
1372                 T(YAFFS_TRACE_ALWAYS,
1373                   ("yaffs: MTD device is not NAND it's type %d\n", mtd->type));
1374                 return NULL;
1375         }
1376
1377         T(YAFFS_TRACE_OS, (" erase %p\n", mtd->erase));
1378         T(YAFFS_TRACE_OS, (" read %p\n", mtd->read));
1379         T(YAFFS_TRACE_OS, (" write %p\n", mtd->write));
1380         T(YAFFS_TRACE_OS, (" readoob %p\n", mtd->read_oob));
1381         T(YAFFS_TRACE_OS, (" writeoob %p\n", mtd->write_oob));
1382         T(YAFFS_TRACE_OS, (" block_isbad %p\n", mtd->block_isbad));
1383         T(YAFFS_TRACE_OS, (" block_markbad %p\n", mtd->block_markbad));
1384         T(YAFFS_TRACE_OS, (" oobblock %d\n", mtd->oobblock));
1385         T(YAFFS_TRACE_OS, (" oobsize %d\n", mtd->oobsize));
1386         T(YAFFS_TRACE_OS, (" erasesize %d\n", mtd->erasesize));
1387         T(YAFFS_TRACE_OS, (" size %d\n", mtd->size));
1388
1389 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
1390
1391         if (yaffsVersion == 1 &&
1392             mtd->oobblock >= 2048) {
1393             T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs2\n"));
1394             yaffsVersion = 2;
1395         }
1396 #endif
1397
1398         if (yaffsVersion == 2) {
1399                 /* Check for version 2 style functions */
1400                 if (!mtd->erase ||
1401                     !mtd->block_isbad ||
1402                     !mtd->block_markbad ||
1403                     !mtd->read ||
1404                     !mtd->write ||
1405                     !mtd->write_ecc ||
1406                     !mtd->read_ecc || !mtd->read_oob || !mtd->write_oob) {
1407                         T(YAFFS_TRACE_ALWAYS,
1408                           ("yaffs: MTD device does not support required "
1409                            "functions\n"));;
1410                         return NULL;
1411                 }
1412
1413                 if (mtd->oobblock < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
1414                     mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) {
1415                         T(YAFFS_TRACE_ALWAYS,
1416                           ("yaffs: MTD device does not have the "
1417                            "right page sizes\n"));
1418                         return NULL;
1419                 }
1420         } else {
1421                 /* Check for V1 style functions */
1422                 if (!mtd->erase ||
1423                     !mtd->read ||
1424                     !mtd->write ||
1425                     !mtd->write_ecc ||
1426                     !mtd->read_ecc || !mtd->read_oob || !mtd->write_oob) {
1427                         T(YAFFS_TRACE_ALWAYS,
1428                           ("yaffs: MTD device does not support required "
1429                            "functions\n"));;
1430                         return NULL;
1431                 }
1432
1433                 if (mtd->oobblock != YAFFS_BYTES_PER_CHUNK ||
1434                     mtd->oobsize != YAFFS_BYTES_PER_SPARE) {
1435                         T(YAFFS_TRACE_ALWAYS,
1436                           ("yaffs: MTD device does not support have the "
1437                            "right page sizes\n"));
1438                         return NULL;
1439                 }
1440         }
1441
1442         /* OK, so if we got here, we have an MTD that's NAND and looks
1443          * like it has the right capabilities
1444          * Set the yaffs_Device up for mtd
1445          */
1446
1447 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1448         sb->s_fs_info = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
1449 #else
1450         sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
1451 #endif
1452         if (!dev) {
1453                 /* Deep shit could not allocate device structure */
1454                 T(YAFFS_TRACE_ALWAYS,
1455                   ("yaffs_read_super: Failed trying to allocate "
1456                    "yaffs_Device. \n"));
1457                 return NULL;
1458         }
1459
1460         memset(dev, 0, sizeof(yaffs_Device));
1461         dev->genericDevice = mtd;
1462         dev->name = mtd->name;
1463
1464         /* Set up the memory size parameters.... */
1465
1466         nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
1467         dev->startBlock = 0;
1468         dev->endBlock = nBlocks - 1;
1469         dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
1470         dev->nBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
1471         dev->nReservedBlocks = 5;
1472         dev->nShortOpCaches = 10;       /* Enable short op caching */
1473
1474         /* ... and the functions. */
1475         if (yaffsVersion == 2) {
1476                 dev->writeChunkWithTagsToNAND =
1477                     nandmtd2_WriteChunkWithTagsToNAND;
1478                 dev->readChunkWithTagsFromNAND =
1479                     nandmtd2_ReadChunkWithTagsFromNAND;
1480                 dev->markNANDBlockBad = nandmtd2_MarkNANDBlockBad;
1481                 dev->queryNANDBlock = nandmtd2_QueryNANDBlock;
1482                 dev->spareBuffer = YMALLOC(mtd->oobsize);
1483                 dev->isYaffs2 = 1;
1484                 dev->nBytesPerChunk = mtd->oobblock;
1485                 dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
1486                 nBlocks = mtd->size / mtd->erasesize;
1487                 dev->startBlock = 0;
1488                 dev->endBlock = nBlocks - 1;
1489         } else {
1490                 dev->writeChunkToNAND = nandmtd_WriteChunkToNAND;
1491                 dev->readChunkFromNAND = nandmtd_ReadChunkFromNAND;
1492                 dev->isYaffs2 = 0;
1493         }
1494         /* ... and common functions */
1495         dev->eraseBlockInNAND = nandmtd_EraseBlockInNAND;
1496         dev->initialiseNAND = nandmtd_InitialiseNAND;
1497
1498         dev->putSuperFunc = yaffs_MTDPutSuper;
1499
1500 #ifndef CONFIG_YAFFS_DOES_ECC
1501         dev->useNANDECC = 1;
1502 #endif
1503
1504 #ifdef CONFIG_YAFFS_DISABLE_WIDE_TNODES
1505         dev->wideTnodesDisabled = 1;
1506 #endif
1507
1508         /* we assume this is protected by lock_kernel() in mount/umount */
1509         list_add_tail(&dev->devList, &yaffs_dev_list);
1510
1511         init_MUTEX(&dev->grossLock);
1512
1513         yaffs_GrossLock(dev);
1514
1515         err = yaffs_GutsInitialise(dev);
1516
1517         T(YAFFS_TRACE_OS,
1518           ("yaffs_read_super: guts initialised %s\n",
1519            (err == YAFFS_OK) ? "OK" : "FAILED"));
1520
1521         /* Release lock before yaffs_get_inode() */
1522         yaffs_GrossUnlock(dev);
1523
1524         /* Create root inode */
1525         if (err == YAFFS_OK)
1526                 inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0,
1527                                         yaffs_Root(dev));
1528
1529         if (!inode)
1530                 return NULL;
1531
1532         inode->i_op = &yaffs_dir_inode_operations;
1533         inode->i_fop = &yaffs_dir_operations;
1534
1535         T(YAFFS_TRACE_OS, ("yaffs_read_super: got root inode\n"));
1536
1537         root = d_alloc_root(inode);
1538
1539         T(YAFFS_TRACE_OS, ("yaffs_read_super: d_alloc_root done\n"));
1540
1541         if (!root) {
1542                 iput(inode);
1543                 return NULL;
1544         }
1545         sb->s_root = root;
1546
1547         T(YAFFS_TRACE_OS, ("yaffs_read_super: done\n"));
1548         return sb;
1549 }
1550
1551
1552 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1553 static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data,
1554                                          int silent)
1555 {
1556         return yaffs_internal_read_super(1, sb, data, silent) ? 0 : -EINVAL;
1557 }
1558
1559 static struct super_block *yaffs_read_super(struct file_system_type *fs,
1560                                             int flags, const char *dev_name,
1561                                             void *data)
1562 {
1563
1564         return get_sb_bdev(fs, flags, dev_name, data,
1565                            yaffs_internal_read_super_mtd);
1566 }
1567
1568 static struct file_system_type yaffs_fs_type = {
1569         .owner = THIS_MODULE,
1570         .name = "yaffs",
1571         .get_sb = yaffs_read_super,
1572         .kill_sb = kill_block_super,
1573         .fs_flags = FS_REQUIRES_DEV,
1574 };
1575 #else
1576 static struct super_block *yaffs_read_super(struct super_block *sb, void *data,
1577                                             int silent)
1578 {
1579         return yaffs_internal_read_super(1, sb, data, silent);
1580 }
1581
1582 static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super,
1583                       FS_REQUIRES_DEV);
1584 #endif
1585
1586
1587 #ifdef CONFIG_YAFFS_YAFFS2
1588
1589 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1590 static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data,
1591                                           int silent)
1592 {
1593         return yaffs_internal_read_super(2, sb, data, silent) ? 0 : -EINVAL;
1594 }
1595
1596 static struct super_block *yaffs2_read_super(struct file_system_type *fs,
1597                                              int flags, const char *dev_name,
1598                                              void *data)
1599 {
1600
1601         return get_sb_bdev(fs, flags, dev_name, data,
1602                            yaffs2_internal_read_super_mtd);
1603 }
1604
1605 static struct file_system_type yaffs2_fs_type = {
1606         .owner = THIS_MODULE,
1607         .name = "yaffs2",
1608         .get_sb = yaffs2_read_super,
1609         .kill_sb = kill_block_super,
1610         .fs_flags = FS_REQUIRES_DEV,
1611 };
1612 #else
1613 static struct super_block *yaffs2_read_super(struct super_block *sb,
1614                                              void *data, int silent)
1615 {
1616         return yaffs_internal_read_super(2, sb, data, silent);
1617 }
1618
1619 static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super,
1620                       FS_REQUIRES_DEV);
1621 #endif
1622
1623 #endif                          /* CONFIG_YAFFS_YAFFS2 */
1624
1625 static struct proc_dir_entry *my_proc_entry;
1626
1627 static char *yaffs_dump_dev(char *buf, yaffs_Device * dev)
1628 {
1629         buf += sprintf(buf, "startBlock......... %d\n", dev->startBlock);
1630         buf += sprintf(buf, "endBlock........... %d\n", dev->endBlock);
1631         buf += sprintf(buf, "chunkGroupBits..... %d\n", dev->chunkGroupBits);
1632         buf += sprintf(buf, "chunkGroupSize..... %d\n", dev->chunkGroupSize);
1633         buf += sprintf(buf, "nErasedBlocks...... %d\n", dev->nErasedBlocks);
1634         buf += sprintf(buf, "nTnodesCreated..... %d\n", dev->nTnodesCreated);
1635         buf += sprintf(buf, "nFreeTnodes........ %d\n", dev->nFreeTnodes);
1636         buf += sprintf(buf, "nObjectsCreated.... %d\n", dev->nObjectsCreated);
1637         buf += sprintf(buf, "nFreeObjects....... %d\n", dev->nFreeObjects);
1638         buf += sprintf(buf, "nFreeChunks........ %d\n", dev->nFreeChunks);
1639         buf += sprintf(buf, "nPageWrites........ %d\n", dev->nPageWrites);
1640         buf += sprintf(buf, "nPageReads......... %d\n", dev->nPageReads);
1641         buf += sprintf(buf, "nBlockErasures..... %d\n", dev->nBlockErasures);
1642         buf += sprintf(buf, "nGCCopies.......... %d\n", dev->nGCCopies);
1643         buf +=
1644             sprintf(buf, "garbageCollections. %d\n", dev->garbageCollections);
1645         buf +=
1646             sprintf(buf, "passiveGCs......... %d\n",
1647                     dev->passiveGarbageCollections);
1648         buf += sprintf(buf, "nRetriedWrites..... %d\n", dev->nRetriedWrites);
1649         buf += sprintf(buf, "nRetireBlocks...... %d\n", dev->nRetiredBlocks);
1650         buf += sprintf(buf, "eccFixed........... %d\n", dev->eccFixed);
1651         buf += sprintf(buf, "eccUnfixed......... %d\n", dev->eccUnfixed);
1652         buf += sprintf(buf, "tagsEccFixed....... %d\n", dev->tagsEccFixed);
1653         buf += sprintf(buf, "tagsEccUnfixed..... %d\n", dev->tagsEccUnfixed);
1654         buf += sprintf(buf, "cacheHits.......... %d\n", dev->cacheHits);
1655         buf += sprintf(buf, "nDeletedFiles...... %d\n", dev->nDeletedFiles);
1656         buf += sprintf(buf, "nUnlinkedFiles..... %d\n", dev->nUnlinkedFiles);
1657         buf +=
1658             sprintf(buf, "nBackgroudDeletions %d\n", dev->nBackgroundDeletions);
1659         buf += sprintf(buf, "useNANDECC......... %d\n", dev->useNANDECC);
1660         buf += sprintf(buf, "isYaffs2........... %d\n", dev->isYaffs2);
1661
1662         return buf;
1663 }
1664
1665 static int yaffs_proc_read(char *page,
1666                            char **start,
1667                            off_t offset, int count, int *eof, void *data)
1668 {
1669         struct list_head *item;
1670         char *buf = page;
1671         int step = offset;
1672         int n = 0;
1673
1674         /* Get proc_file_read() to step 'offset' by one on each sucessive call.
1675          * We use 'offset' (*ppos) to indicate where we are in devList.
1676          * This also assumes the user has posted a read buffer large
1677          * enough to hold the complete output; but that's life in /proc.
1678          */
1679
1680         *(int *)start = 1;
1681
1682         /* Print header first */
1683         if (step == 0) {
1684                 buf += sprintf(buf, "YAFFS built:" __DATE__ " " __TIME__
1685                                "\n%s\n%s\n", yaffs_fs_c_version,
1686                                yaffs_guts_c_version);
1687         }
1688
1689         /* hold lock_kernel while traversing yaffs_dev_list */
1690         lock_kernel();
1691
1692         /* Locate and print the Nth entry.  Order N-squared but N is small. */
1693         list_for_each(item, &yaffs_dev_list) {
1694                 yaffs_Device *dev = list_entry(item, yaffs_Device, devList);
1695                 if (n < step) {
1696                         n++;
1697                         continue;
1698                 }
1699                 buf += sprintf(buf, "\nDevice %d \"%s\"\n", n, dev->name);
1700                 buf = yaffs_dump_dev(buf, dev);
1701                 break;
1702         }
1703         unlock_kernel();
1704
1705         return buf - page < count ? buf - page : count;
1706 }
1707
1708 /**
1709  * Set the verbosity of the warnings and error messages.
1710  *
1711  */
1712
1713 static struct {
1714         char *mask_name;
1715         unsigned mask_bitfield;
1716 } mask_flags[] = {
1717         {"allocate", YAFFS_TRACE_ALLOCATE},
1718         {"always", YAFFS_TRACE_ALWAYS},
1719         {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS},
1720         {"buffers", YAFFS_TRACE_BUFFERS},
1721         {"bug", YAFFS_TRACE_BUG},
1722         {"deletion", YAFFS_TRACE_DELETION},
1723         {"erase", YAFFS_TRACE_ERASE},
1724         {"error", YAFFS_TRACE_ERROR},
1725         {"gc_detail", YAFFS_TRACE_GC_DETAIL},
1726         {"gc", YAFFS_TRACE_GC},
1727         {"mtd", YAFFS_TRACE_MTD},
1728         {"nandaccess", YAFFS_TRACE_NANDACCESS},
1729         {"os", YAFFS_TRACE_OS},
1730         {"scan_debug", YAFFS_TRACE_SCAN_DEBUG},
1731         {"scan", YAFFS_TRACE_SCAN},
1732         {"tracing", YAFFS_TRACE_TRACING},
1733         {"write", YAFFS_TRACE_WRITE},
1734         {"all", 0xffffffff},
1735         {"none", 0},
1736         {NULL, 0},
1737 };
1738
1739 static int yaffs_proc_write(struct file *file, const char *buf,
1740                                          unsigned long count, void *data)
1741 {
1742         unsigned rg = 0, mask_bitfield;
1743         char *end, *mask_name;
1744         int i;
1745         int done = 0;
1746         int add, len;
1747         int pos = 0;
1748
1749         rg = yaffs_traceMask;
1750
1751         while (!done && (pos < count)) {
1752                 done = 1;
1753                 while ((pos < count) && isspace(buf[pos])) {
1754                         pos++;
1755                 }
1756
1757                 switch (buf[pos]) {
1758                 case '+':
1759                 case '-':
1760                 case '=':
1761                         add = buf[pos];
1762                         pos++;
1763                         break;
1764
1765                 default:
1766                         add = ' ';
1767                         break;
1768                 }
1769                 mask_name = NULL;
1770                 mask_bitfield = simple_strtoul(buf + pos, &end, 0);
1771                 if (end > buf + pos) {
1772                         mask_name = "numeral";
1773                         len = end - (buf + pos);
1774                         done = 0;
1775                 } else {
1776
1777                         for (i = 0; mask_flags[i].mask_name != NULL; i++) {
1778                                 len = strlen(mask_flags[i].mask_name);
1779                                 if (strncmp(buf + pos, mask_flags[i].mask_name, len) == 0) {
1780                                         mask_name = mask_flags[i].mask_name;
1781                                         mask_bitfield = mask_flags[i].mask_bitfield;
1782                                         done = 0;
1783                                         break;
1784                                 }
1785                         }
1786                 }
1787
1788                 if (mask_name != NULL) {
1789                         pos += len;
1790                         done = 0;
1791                         switch(add) {
1792                         case '-':
1793                                 rg &= ~mask_bitfield;
1794                                 break;
1795                         case '+':
1796                                 rg |= mask_bitfield;
1797                                 break;
1798                         case '=':
1799                                 rg = mask_bitfield;
1800                                 break;
1801                         default:
1802                                 rg |= mask_bitfield;
1803                                 break;
1804                         }
1805                 }
1806         }
1807
1808         yaffs_traceMask = rg;
1809         if (rg & YAFFS_TRACE_ALWAYS) {
1810                 for (i = 0; mask_flags[i].mask_name != NULL; i++) {
1811                         char flag;
1812                         flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-';
1813                         printk("%c%s\n", flag, mask_flags[i].mask_name);
1814                 }
1815         }
1816
1817         return count;
1818 }
1819
1820 /* Stuff to handle installation of file systems */
1821 struct file_system_to_install {
1822         struct file_system_type *fst;
1823         int installed;
1824 };
1825
1826 static struct file_system_to_install fs_to_install[] = {
1827 //#ifdef CONFIG_YAFFS_YAFFS1
1828         {&yaffs_fs_type, 0},
1829 //#endif
1830 //#ifdef CONFIG_YAFFS_YAFFS2
1831         {&yaffs2_fs_type, 0},
1832 //#endif
1833         {NULL, 0}
1834 };
1835
1836 static int __init init_yaffs_fs(void)
1837 {
1838         int error = 0;
1839         struct file_system_to_install *fsinst;
1840
1841         T(YAFFS_TRACE_ALWAYS,
1842           ("yaffs " __DATE__ " " __TIME__ " Installing. \n"));
1843
1844         /* Install the proc_fs entry */
1845         my_proc_entry = create_proc_entry("yaffs",
1846                                                S_IRUGO | S_IFREG,
1847                                                &proc_root);
1848
1849         if (my_proc_entry) {
1850                 my_proc_entry->write_proc = yaffs_proc_write;
1851                 my_proc_entry->read_proc = yaffs_proc_read;
1852                 my_proc_entry->data = NULL;
1853         } else {
1854                 return -ENOMEM;
1855         }
1856
1857         /* Now add the file system entries */
1858
1859         fsinst = fs_to_install;
1860
1861         while (fsinst->fst && !error) {
1862                 error = register_filesystem(fsinst->fst);
1863                 if (!error) {
1864                         fsinst->installed = 1;
1865                 }
1866                 fsinst++;
1867         }
1868
1869         /* Any errors? uninstall  */
1870         if (error) {
1871                 fsinst = fs_to_install;
1872
1873                 while (fsinst->fst) {
1874                         if (fsinst->installed) {
1875                                 unregister_filesystem(fsinst->fst);
1876                                 fsinst->installed = 0;
1877                         }
1878                         fsinst++;
1879                 }
1880         }
1881
1882         return error;
1883 }
1884
1885 static void __exit exit_yaffs_fs(void)
1886 {
1887
1888         struct file_system_to_install *fsinst;
1889
1890         T(YAFFS_TRACE_ALWAYS, ("yaffs " __DATE__ " " __TIME__
1891                                " removing. \n"));
1892
1893         remove_proc_entry("yaffs", &proc_root);
1894
1895         fsinst = fs_to_install;
1896
1897         while (fsinst->fst) {
1898                 if (fsinst->installed) {
1899                         unregister_filesystem(fsinst->fst);
1900                         fsinst->installed = 0;
1901                 }
1902                 fsinst++;
1903         }
1904
1905 }
1906
1907 module_init(init_yaffs_fs)
1908 module_exit(exit_yaffs_fs)
1909
1910 MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system");
1911 MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2006");
1912 MODULE_LICENSE("GPL");