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