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