direct/yaffsfs.c

   1 /*
   2  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
   3  *
   4  * Copyright (C) 2002-2010 Aleph One Ltd.
   5  *   for Toby Churchill Ltd and Brightstar Engineering
   6  *
   7  * Created by Charles Manning <charles@aleph1.co.uk>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include "yaffsfs.h"
  15 #include "yaffs_guts.h"
  16 #include "yaffscfg.h"
  17 #include "yportenv.h"
  18 #include "yaffs_trace.h"
  19
  20 #include <string.h> /* for memset */
  21
  22 #define YAFFSFS_MAX_SYMLINK_DEREFERENCES 5
  23
  24 #ifndef NULL
  25 #define NULL ((void *)0)
  26 #endif
  27
  28
  29 /* YAFFSFS_RW_SIZE must be a power of 2 */
  30 #define YAFFSFS_RW_SHIFT (13)
  31 #define YAFFSFS_RW_SIZE  (1<<YAFFSFS_RW_SHIFT)
  32
  33 /* Some forward references */
  34 static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory,
  35                         const YCHAR *path,
  36                         int symDepth, int getEquiv,
  37                         struct yaffs_obj **dirOut,
  38                         int *notDir, int *loop);
  39
  40 static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj);
  41
  42 unsigned int yaffs_wr_attempts;
  43
  44 /*
  45  * Handle management.
  46  * There are open inodes in yaffsfs_Inode.
  47  * There are open handles in yaffsfs_Handle.
  48  *
  49  * Things are structured this way to be like the Linux VFS model
  50  * so that interactions with the yaffs guts calls are similar.
  51  * That means more common code paths and less special code.
  52  * That means better testing etc.
  53  */
  54
  55 typedef struct {
  56         int count;      /* Number of handles accessing this inode */
  57         struct yaffs_obj *iObj;
  58 } yaffsfs_Inode;
  59
  60 typedef struct{
  61         u8      reading:1;
  62         u8      writing:1;
  63         u8      append:1;
  64         u8      shareRead:1;
  65         u8      shareWrite:1;
  66         int     inodeId:12;     /* Index to corresponding yaffsfs_Inode */
  67         int     useCount:10;    /* Use count for this handle */
  68         u32 position;           /* current position in file */
  69 }yaffsfs_Handle;
  70
  71 static yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
  72 static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
  73 static int yaffsfs_handlesInitialised;
  74
  75
  76 unsigned yaffs_set_trace(unsigned  tm)
  77 {
  78         yaffs_trace_mask = tm;
  79         return yaffs_trace_mask;
  80 }
  81
  82 unsigned yaffs_get_trace(void)
  83 {
  84         return yaffs_trace_mask;
  85 }
  86
  87 /*
  88  * yaffsfs_InitHandle
  89  * Inilitalise handle management on start-up.
  90  */
  91
  92 static void yaffsfs_InitHandles(void)
  93 {
  94         int i;
  95         if(yaffsfs_handlesInitialised)
  96                 return;
  97
  98         memset(yaffsfs_inode,0,sizeof(yaffsfs_inode));
  99         memset(yaffsfs_handle,0,sizeof(yaffsfs_handle));
 100         for(i = 0; i < YAFFSFS_N_HANDLES; i++)
 101                 yaffsfs_handle[i].inodeId = -1;
 102 }
 103
 104 yaffsfs_Handle *yaffsfs_GetHandlePointer(int h)
 105 {
 106         if(h < 0 || h >= YAFFSFS_N_HANDLES)
 107                 return NULL;
 108
 109         return &yaffsfs_handle[h];
 110 }
 111
 112 yaffsfs_Inode *yaffsfs_GetInodePointer(int handle)
 113 {
 114         yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
 115
 116         if(h && h->useCount > 0 && h->inodeId >= 0 && h->inodeId < YAFFSFS_N_HANDLES)
 117                 return  &yaffsfs_inode[h->inodeId];
 118
 119         return NULL;
 120 }
 121
 122 struct yaffs_obj *yaffsfs_GetHandleObject(int handle)
 123 {
 124         yaffsfs_Inode *in = yaffsfs_GetInodePointer(handle);
 125
 126         if(in)
 127                 return in->iObj;
 128
 129         return NULL;
 130 }
 131
 132 /*
 133  * yaffsfs_FindInodeIdForObject
 134  * Find the inode entry for an object, if it exists.
 135  */
 136
 137 static int yaffsfs_FindInodeIdForObject(struct yaffs_obj *obj)
 138 {
 139         int i;
 140         int ret = -1;
 141
 142         if(obj)
 143                 obj = yaffs_get_equivalent_obj(obj);
 144
 145         /* Look for it in open inode table*/
 146         for(i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++){
 147                 if(yaffsfs_inode[i].iObj == obj)
 148                         ret = i;
 149         }
 150         return ret;
 151 }
 152
 153 /*
 154  * yaffsfs_GetInodeIdForObject
 155  * Grab an inode entry when opening a new inode.
 156  */
 157 static int yaffsfs_GetInodeIdForObject(struct yaffs_obj *obj)
 158 {
 159         int i;
 160         int ret;
 161         yaffsfs_Inode *in = NULL;
 162
 163         if(obj)
 164                 obj = yaffs_get_equivalent_obj(obj);
 165
 166         ret = yaffsfs_FindInodeIdForObject(obj);
 167
 168         for(i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++){
 169                 if(!yaffsfs_inode[i].iObj)
 170                         ret = i;
 171         }
 172
 173         if(ret>=0){
 174                 in = &yaffsfs_inode[ret];
 175                 if(!in->iObj)
 176                         in->count = 0;
 177                 in->iObj = obj;
 178                 in->count++;
 179         }
 180
 181
 182         return ret;
 183 }
 184
 185
 186 static int yaffsfs_CountHandles(struct yaffs_obj *obj)
 187 {
 188         int i = yaffsfs_FindInodeIdForObject(obj);
 189
 190         if(i >= 0)
 191                 return yaffsfs_inode[i].count;
 192         else
 193                 return 0;
 194 }
 195
 196 static void yaffsfs_ReleaseInode(yaffsfs_Inode *in)
 197 {
 198         struct yaffs_obj *obj;
 199
 200         obj = in->iObj;
 201
 202         if(obj->unlinked)
 203                 yaffs_del_obj(obj);
 204
 205         obj->my_inode = NULL;
 206         in->iObj = NULL;
 207
 208 }
 209
 210 static void yaffsfs_PutInode(int inodeId)
 211 {
 212         if(inodeId >= 0 && inodeId < YAFFSFS_N_HANDLES){
 213                 yaffsfs_Inode *in = & yaffsfs_inode[inodeId];
 214                 in->count--;
 215                 if(in->count <= 0){
 216                         yaffsfs_ReleaseInode(in);
 217                         in->count = 0;
 218                 }
 219         }
 220 }
 221
 222
 223 /*
 224  * yaffsfs_GetHandle
 225  * Grab a handle (when opening a file)
 226  */
 227
 228 static int yaffsfs_GetNewHandle(void)
 229 {
 230         int i;
 231         yaffsfs_Handle *h;
 232
 233         for(i = 0; i < YAFFSFS_N_HANDLES; i++){
 234                 h = yaffsfs_GetHandlePointer(i);
 235                 if(!h){
 236                         /* todo bug: should never happen */
 237                 }
 238                 if(h->useCount < 1){
 239                         memset(h,0,sizeof(yaffsfs_Handle));
 240                         h->inodeId=-1;
 241                         h->useCount=1;
 242                         return i;
 243                 }
 244         }
 245         return -1;
 246 }
 247
 248 /*
 249  * yaffs_get_handle
 250  * Increase use of handle when reading/writing a file
 251  */
 252 static int yaffsfs_GetHandle(int handle)
 253 {
 254         yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
 255
 256         if(h && h->useCount > 0){
 257                 h->useCount++;
 258         }
 259         return 0;
 260 }
 261
 262 /*
 263  * yaffs_put_handle
 264  * Let go of a handle when closing a file or aborting an open or
 265  * ending a read or write.
 266  */
 267 static int yaffsfs_PutHandle(int handle)
 268 {
 269         yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
 270
 271         if(h && h->useCount > 0){
 272                 h->useCount--;
 273                 if(h->useCount < 1){
 274                         if(h->inodeId >= 0){
 275                                 yaffsfs_PutInode(h->inodeId);
 276                                 h->inodeId = -1;
 277                         }
 278                 }
 279         }
 280         return 0;
 281 }
 282
 283 static void yaffsfs_BreakDeviceHandles(struct yaffs_dev *dev)
 284 {
 285         yaffsfs_Handle *h;
 286         struct yaffs_obj *obj;
 287         int i;
 288         for(i = 0; i < YAFFSFS_N_HANDLES; i++){
 289                 h = yaffsfs_GetHandlePointer(i);
 290                 obj = yaffsfs_GetHandleObject(i);
 291                 if(h && h->useCount>0 && obj && obj->my_dev == dev){
 292                         h->useCount = 0;
 293                         yaffsfs_PutInode(h->inodeId);
 294                         h->inodeId = -1;
 295                 }
 296         }
 297 }
 298
 299
 300
 301
 302 /*
 303  *  Stuff to handle names.
 304  */
 305
 306
 307 int yaffsfs_Match(YCHAR a, YCHAR b)
 308 {
 309         /* case sensitive */
 310         return (a == b);
 311 }
 312
 313 int yaffsfs_IsPathDivider(YCHAR ch)
 314 {
 315         const YCHAR *str = YAFFS_PATH_DIVIDERS;
 316
 317         while(*str){
 318                 if(*str == ch)
 319                         return 1;
 320                 str++;
 321         }
 322
 323         return 0;
 324 }
 325
 326 int yaffsfs_CheckNameLength(const char *name)
 327 {
 328         int retVal = 0;
 329
 330         int nameLength = yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH+1);
 331
 332         if(nameLength == 0){
 333                 yaffsfs_SetError(-ENOENT);
 334                 retVal = -1;
 335         } else if (nameLength > YAFFS_MAX_NAME_LENGTH){
 336                 yaffsfs_SetError(-ENAMETOOLONG);
 337                 retVal = -1;
 338         }
 339
 340         return retVal;
 341 }
 342
 343
 344 static int yaffsfs_alt_dir_path(const YCHAR *path, YCHAR **ret_path)
 345 {
 346         YCHAR *alt_path = NULL;
 347         int path_length;
 348         int i;
 349
 350         /*
 351          * We don't have a definition for max path length.
 352          * We will use 3 * max name length instead.
 353          */
 354         *ret_path = NULL;
 355         path_length = strnlen(path,(YAFFS_MAX_NAME_LENGTH+1)*3 +1);
 356
 357         /* If the last character is a path divider, then we need to
 358          * trim it back so that the name look-up works properly.
 359          * eg. /foo/new_dir/ -> /foo/newdir
 360          * Curveball: Need to handle multiple path dividers:
 361          * eg. /foof/sdfse///// -> /foo/sdfse
 362          */
 363         if(path_length > 0 &&
 364                 yaffsfs_IsPathDivider(path[path_length-1])){
 365                 alt_path = YMALLOC(path_length + 1);
 366                 if(!alt_path)
 367                         return -1;
 368                 strcpy(alt_path, path);
 369                 for(i = path_length-1;
 370                         i >= 0 && yaffsfs_IsPathDivider(alt_path[i]);
 371                         i--)
 372                         alt_path[i] = (YCHAR) 0;
 373         }
 374         *ret_path = alt_path;
 375         return 0;
 376 }
 377
 378
 379 LIST_HEAD(yaffsfs_deviceList);
 380
 381 /*
 382  * yaffsfs_FindDevice
 383  * yaffsfs_FindRoot
 384  * Scan the configuration list to find the device
 385  * Curveballs: Should match paths that end in '/' too
 386  * Curveball2 Might have "/x/ and "/x/y". Need to return the longest match
 387  */
 388 static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
 389 {
 390         struct list_head *cfg;
 391         const YCHAR *leftOver;
 392         const YCHAR *p;
 393         struct yaffs_dev *retval = NULL;
 394         struct yaffs_dev *dev = NULL;
 395         int thisMatchLength;
 396         int longestMatch = -1;
 397         int matching;
 398
 399         /*
 400          * Check all configs, choose the one that:
 401          * 1) Actually matches a prefix (ie /a amd /abc will not match
 402          * 2) Matches the longest.
 403          */
 404         list_for_each(cfg, &yaffsfs_deviceList){
 405                 dev = list_entry(cfg, struct yaffs_dev, dev_list);
 406                 leftOver = path;
 407                 p = dev->param.name;
 408                 thisMatchLength = 0;
 409                 matching = 1;
 410
 411
 412                 while(matching && *p && *leftOver){
 413                         /* Skip over any /s */
 414                         while(yaffsfs_IsPathDivider(*p))
 415                               p++;
 416
 417                         /* Skip over any /s */
 418                         while(yaffsfs_IsPathDivider(*leftOver))
 419                               leftOver++;
 420
 421                         /* Now match the text part */
 422                         while(matching &&
 423                               *p && !yaffsfs_IsPathDivider(*p) &&
 424                               *leftOver && !yaffsfs_IsPathDivider(*leftOver)){
 425                                 if(yaffsfs_Match(*p,*leftOver)){
 426                                         p++;
 427                                         leftOver++;
 428                                         thisMatchLength++;
 429                                 } else {
 430                                         matching = 0;
 431                                 }
 432                         }
 433                 }
 434
 435                 /* Skip over any /s in leftOver */
 436                 while(yaffsfs_IsPathDivider(*leftOver))
 437                       leftOver++;
 438
 439                 // Skip over any /s in p
 440                 while(yaffsfs_IsPathDivider(*p))
 441                       p++;
 442
 443                 // p should now be at the end of the string (ie. fully matched)
 444                 if(*p)
 445                         matching = 0;
 446
 447                 if( matching && (thisMatchLength > longestMatch))
 448                 {
 449                         // Matched prefix
 450                         *restOfPath = (YCHAR *)leftOver;
 451                         retval = dev;
 452                         longestMatch = thisMatchLength;
 453                 }
 454
 455         }
 456         return retval;
 457 }
 458
 459 static int yaffsfs_CheckPath(const YCHAR *path)
 460 {
 461         int n=0;
 462         int divs=0;
 463         while(*path && n < YAFFS_MAX_NAME_LENGTH && divs < 100){
 464                 if(yaffsfs_IsPathDivider(*path)){
 465                         n=0;
 466                         divs++;
 467                 } else
 468                         n++;
 469                 path++;
 470         }
 471
 472         return (*path) ? -1 : 0;
 473 }
 474
 475 /* FindMountPoint only returns a dev entry if the path is a mount point */
 476 static struct yaffs_dev *yaffsfs_FindMountPoint(const YCHAR *path)
 477 {
 478         struct yaffs_dev *dev;
 479         YCHAR *restOfPath=NULL;
 480         dev = yaffsfs_FindDevice(path,&restOfPath);
 481         if(dev && restOfPath && *restOfPath)
 482                 dev = NULL;
 483         return dev;
 484 }
 485
 486 static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
 487 {
 488
 489         struct yaffs_dev *dev;
 490
 491         dev= yaffsfs_FindDevice(path,restOfPath);
 492         if(dev && dev->is_mounted){
 493                 return dev->root_dir;
 494         }
 495         return NULL;
 496 }
 497
 498 static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,
 499                                         int symDepth, int *loop)
 500 {
 501
 502         if(obj)
 503                 obj = yaffs_get_equivalent_obj(obj);
 504
 505         while(obj && obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK){
 506                 YCHAR *alias = obj->variant.symlink_variant.alias;
 507
 508                 if(yaffsfs_IsPathDivider(*alias))
 509                         /* Starts with a /, need to scan from root up */
 510                         obj = yaffsfs_FindObject(NULL,alias,symDepth++,
 511                                                 1,NULL,NULL,loop);
 512                 else
 513                         /* Relative to here, so use the parent of the symlink as a start */
 514                         obj = yaffsfs_FindObject(obj->parent,alias,symDepth++,
 515                                                 1,NULL,NULL,loop);
 516         }
 517         return obj;
 518 }
 519
 520
 521 /*
 522  * yaffsfs_FindDirectory
 523  * Parse a path to determine the directory and the name within the directory.
 524  *
 525  * eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx"
 526  */
 527 static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
 528                                 const YCHAR *path, YCHAR **name, int symDepth,
 529                                 int *notDir,int *loop)
 530 {
 531         struct yaffs_obj *dir;
 532         YCHAR *restOfPath;
 533         YCHAR str[YAFFS_MAX_NAME_LENGTH+1];
 534         int i;
 535
 536         if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES){
 537                 if(loop)
 538                         *loop = 1;
 539                 return NULL;
 540         }
 541
 542         if(startDir){
 543                 dir = startDir;
 544                 restOfPath = (YCHAR *)path;
 545         }
 546         else
 547                 dir = yaffsfs_FindRoot(path,&restOfPath);
 548
 549
 550         while(dir){
 551                 /*
 552                  * parse off /.
 553                  * curve ball: also throw away surplus '/'
 554                  * eg. "/ram/x////ff" gets treated the same as "/ram/x/ff"
 555                  */
 556                 while(yaffsfs_IsPathDivider(*restOfPath))
 557                         restOfPath++; /* get rid of '/' */
 558
 559                 *name = restOfPath;
 560                 i = 0;
 561
 562                 while(*restOfPath && !yaffsfs_IsPathDivider(*restOfPath)){
 563                         if (i < YAFFS_MAX_NAME_LENGTH){
 564                                 str[i] = *restOfPath;
 565                                 str[i+1] = '\0';
 566                                 i++;
 567                         }
 568                         restOfPath++;
 569                 }
 570
 571                 if(!*restOfPath)
 572                         /* got to the end of the string */
 573                         return dir;
 574                 else{
 575                         if(yaffs_strcmp(str,_Y(".")) == 0)
 576                         {
 577                                 /* Do nothing */
 578                         }
 579                         else if(yaffs_strcmp(str,_Y("..")) == 0)
 580                                 dir = dir->parent;
 581                         else{
 582                                 dir = yaffs_find_by_name(dir,str);
 583
 584                                 dir = yaffsfs_FollowLink(dir,symDepth,loop);
 585
 586                                 if(dir && dir->variant_type !=
 587                                         YAFFS_OBJECT_TYPE_DIRECTORY){
 588                                         if(notDir)
 589                                                 *notDir = 1;
 590                                         dir = NULL;
 591                                 }
 592
 593                         }
 594                 }
 595         }
 596         /* directory did not exist. */
 597         return NULL;
 598 }
 599
 600 static struct yaffs_obj *yaffsfs_FindDirectory(struct yaffs_obj *relDir,
 601                                         const YCHAR *path,
 602                                         YCHAR **name,
 603                                         int symDepth,
 604                                         int *notDir,
 605                                         int *loop)
 606 {
 607         return yaffsfs_DoFindDirectory(relDir,path,name,symDepth,notDir,loop);
 608 }
 609
 610 /*
 611  * yaffsfs_FindObject turns a path for an existing object into the object
 612  */
 613 static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relDir,
 614                         const YCHAR *path,int symDepth, int getEquiv,
 615                         struct yaffs_obj **dirOut, int *notDir,int *loop)
 616 {
 617         struct yaffs_obj *dir;
 618         struct yaffs_obj *obj;
 619         YCHAR *name;
 620
 621         dir = yaffsfs_FindDirectory(relDir,path,&name,symDepth,notDir,loop);
 622
 623         if(dirOut)
 624                 *dirOut =  dir;
 625
 626         if(dir && *name)
 627                 obj = yaffs_find_by_name(dir,name);
 628         else
 629                 obj = dir;
 630
 631         if(getEquiv)
 632                 obj = yaffs_get_equivalent_obj(obj);
 633
 634         return obj;
 635 }
 636
 637
 638 int yaffs_dup(int fd)
 639 {
 640         int newHandle = -1;
 641         yaffsfs_Handle *oldPtr = NULL;
 642         yaffsfs_Handle *newPtr = NULL;
 643
 644         yaffsfs_Lock();
 645
 646         oldPtr = yaffsfs_GetHandlePointer(fd);
 647         if(oldPtr && oldPtr->useCount > 0)
 648                 newHandle = yaffsfs_GetNewHandle();
 649         if(newHandle >= 0)
 650                 newPtr = yaffsfs_GetHandlePointer(newHandle);
 651
 652         if(newPtr){
 653                 *newPtr = *oldPtr;
 654                 return newHandle;
 655         }
 656
 657         if(!oldPtr)
 658                 yaffsfs_SetError(-EBADF);
 659         else
 660                 yaffsfs_SetError(-ENOMEM);
 661
 662         return -1;
 663
 664 }
 665
 666
 667
 668 int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
 669 {
 670         struct yaffs_obj *obj = NULL;
 671         struct yaffs_obj *dir = NULL;
 672         YCHAR *name;
 673         int handle = -1;
 674         yaffsfs_Handle *yh = NULL;
 675         int openDenied = 0;
 676         int symDepth = 0;
 677         int errorReported = 0;
 678         int rwflags = oflag & ( O_RDWR | O_RDONLY | O_WRONLY);
 679         u8 shareRead = (sharing & YAFFS_SHARE_READ) ?  1 : 0;
 680         u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0;
 681         u8 sharedReadAllowed;
 682         u8 sharedWriteAllowed;
 683         u8 alreadyReading;
 684         u8 alreadyWriting;
 685         u8 readRequested;
 686         u8 writeRequested;
 687         int notDir = 0;
 688         int loop = 0;
 689
 690         if(yaffsfs_CheckPath(path) < 0){
 691                 yaffsfs_SetError(-ENAMETOOLONG);
 692                 return -1;
 693         }
 694
 695         /* O_EXCL only has meaning if O_CREAT is specified */
 696         if(!(oflag & O_CREAT))
 697                 oflag &= ~(O_EXCL);
 698
 699         /* O_TRUNC has no meaning if (O_CREAT | O_EXCL) is specified */
 700         if( (oflag & O_CREAT) & (oflag & O_EXCL))
 701                 oflag &= ~(O_TRUNC);
 702
 703         /* Todo: Are there any more flag combos to sanitise ? */
 704
 705         /* Figure out if reading or writing is requested */
 706
 707         readRequested = (rwflags == O_RDWR || rwflags == O_RDONLY) ? 1 : 0;
 708         writeRequested = (rwflags == O_RDWR || rwflags == O_WRONLY) ? 1 : 0;
 709
 710         yaffsfs_Lock();
 711
 712         handle = yaffsfs_GetNewHandle();
 713
 714         if(handle < 0){
 715                 yaffsfs_SetError(-ENFILE);
 716                 errorReported = 1;
 717         } else {
 718
 719                 yh = yaffsfs_GetHandlePointer(handle);
 720
 721                 /* try to find the exisiting object */
 722                 obj = yaffsfs_FindObject(NULL,path,0,1,NULL,NULL,NULL);
 723
 724                 obj = yaffsfs_FollowLink(obj,symDepth++,&loop);
 725
 726                 if(obj &&
 727                         obj->variant_type != YAFFS_OBJECT_TYPE_FILE &&
 728                         obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
 729                         obj = NULL;
 730
 731
 732                 if(obj){
 733
 734                         /* The file already exists or it might be a directory */
 735
 736                         /* If it is a directory then we can't open it as a file */
 737                         if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
 738                                 openDenied = 1;
 739                                 yaffsfs_SetError(-EISDIR);
 740                                 errorReported = 1;
 741                         }
 742
 743                         /* Open should fail if O_CREAT and O_EXCL are specified since
 744                          * the file exists
 745                          */
 746                         if(!errorReported && (oflag & O_EXCL) && (oflag & O_CREAT)){
 747                                 openDenied = 1;
 748                                 yaffsfs_SetError(-EEXIST);
 749                                 errorReported = 1;
 750                         }
 751
 752                         /* Check file permissions */
 753                         if( readRequested && !(obj->yst_mode & S_IREAD))
 754                                 openDenied = 1;
 755
 756                         if( writeRequested && !(obj->yst_mode & S_IWRITE))
 757                                 openDenied = 1;
 758
 759                         if( !errorReported && writeRequested &&
 760                                 obj->my_dev->read_only){
 761                                 openDenied = 1;
 762                                 yaffsfs_SetError(-EROFS);
 763                                 errorReported = 1;
 764                         }
 765
 766                         if(openDenied && !errorReported ) {
 767                                 /* Error if the file exists but permissions are refused. */
 768                                 yaffsfs_SetError(-EACCES);
 769                                 errorReported = 1;
 770                         }
 771
 772                         /* Check sharing of an existing object. */
 773                         if(!openDenied){
 774                                 yaffsfs_Handle *hx;
 775                                 int i;
 776                                 sharedReadAllowed = 1;
 777                                 sharedWriteAllowed = 1;
 778                                 alreadyReading = 0;
 779                                 alreadyWriting = 0;
 780                                 for( i = 0; i < YAFFSFS_N_HANDLES; i++){
 781                                         hx = &yaffsfs_handle[i];
 782                                         if(hx->useCount > 0 &&
 783                                                 hx->inodeId >= 0 &&
 784                                                 yaffsfs_inode[hx->inodeId].iObj == obj){
 785                                                 if(!hx->shareRead)
 786                                                         sharedReadAllowed = 0;
 787                                                 if(!hx->shareWrite)
 788                                                         sharedWriteAllowed = 0;
 789                                                 if(hx->reading)
 790                                                         alreadyReading = 1;
 791                                                 if(hx->writing)
 792                                                         alreadyWriting = 1;
 793                                         }
 794                                 }
 795
 796
 797
 798                                 if((!sharedReadAllowed && readRequested)||
 799                                         (!shareRead  && alreadyReading) ||
 800                                         (!sharedWriteAllowed && writeRequested) ||
 801                                         (!shareWrite && alreadyWriting)){
 802                                         openDenied = 1;
 803                                         yaffsfs_SetError(-EBUSY);
 804                                         errorReported=1;
 805                                 }
 806                         }
 807
 808                 }
 809
 810                 /* If we could not open an existing object, then let's see if
 811                  * the directory exists. If not, error.
 812                  */
 813                 if(!obj && !errorReported){
 814                         dir = yaffsfs_FindDirectory(NULL,path,&name,0,&notDir,&loop);
 815                         if(!dir && notDir){
 816                                 yaffsfs_SetError(-ENOTDIR);
 817                                 errorReported = 1;
 818                         } else if(loop){
 819                                 yaffsfs_SetError(-ELOOP);
 820                                 errorReported = 1;
 821                         } else  if(!dir){
 822                                 yaffsfs_SetError(-ENOENT);
 823                                 errorReported = 1;
 824                         }
 825                 }
 826
 827                 if(!obj && dir && !errorReported && (oflag & O_CREAT)) {
 828                         /* Let's see if we can create this file if it does not exist. */
 829                         if(dir->my_dev->read_only){
 830                                 yaffsfs_SetError(-EROFS);
 831                                 errorReported = 1;
 832                         } else
 833                                 obj = yaffs_create_file(dir,name,mode,0,0);
 834
 835                         if(!obj && !errorReported){
 836                                 yaffsfs_SetError(-ENOSPC);
 837                                 errorReported = 1;
 838                         }
 839                 }
 840
 841                 if(!obj && dir && !errorReported && !(oflag & O_CREAT)) {
 842                         /* Error if the file does not exist and CREAT is not set. */
 843                         yaffsfs_SetError(-ENOENT);
 844                         errorReported = 1;
 845                 }
 846
 847                 if(obj && !openDenied) {
 848                         int inodeId = yaffsfs_GetInodeIdForObject(obj);
 849
 850                         if(inodeId<0) {
 851                                 /*
 852                                  * Todo: Fix any problem if inodes run out, though that
 853                                  * can't happen if the number of inode items >= number of handles.
 854                                  */
 855                         }
 856
 857                         yh->inodeId = inodeId;
 858                         yh->reading = readRequested;
 859                         yh->writing = writeRequested;
 860                         yh->append =  (oflag & O_APPEND) ? 1 : 0;
 861                         yh->position = 0;
 862                         yh->shareRead = shareRead;
 863                         yh->shareWrite = shareWrite;
 864
 865                         /* Hook inode to object */
 866                         obj->my_inode = (void*) &yaffsfs_inode[inodeId];
 867
 868                         if((oflag & O_TRUNC) && yh->writing)
 869                                 yaffs_resize_file(obj,0);
 870                 } else {
 871                         yaffsfs_PutHandle(handle);
 872                         if(!errorReported)
 873                                 yaffsfs_SetError(0); /* Problem */
 874                         handle = -1;
 875                 }
 876         }
 877
 878         yaffsfs_Unlock();
 879
 880         return handle;
 881 }
 882
 883 int yaffs_open(const YCHAR *path, int oflag, int mode)
 884 {
 885         return yaffs_open_sharing(path, oflag, mode, YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
 886 }
 887
 888 int yaffs_Dofsync(int fd,int datasync)
 889 {
 890         yaffsfs_Handle *h = NULL;
 891         int retVal = -1;
 892
 893         yaffsfs_Lock();
 894
 895         h = yaffsfs_GetHandlePointer(fd);
 896
 897         if(!h || h->useCount < 1)
 898                 yaffsfs_SetError(-EBADF);
 899         else {
 900                 struct yaffs_obj * obj;
 901                 obj = yaffsfs_inode[h->inodeId].iObj;
 902                 if(obj->my_dev->read_only)
 903                         yaffsfs_SetError(-EROFS);
 904                 else {
 905                         yaffs_flush_file(yaffsfs_inode[h->inodeId].iObj,1,datasync);
 906                         retVal = 0;
 907                 }
 908         }
 909
 910         yaffsfs_Unlock();
 911
 912         return retVal;
 913 }
 914
 915 int yaffs_fsync(int fd)
 916 {
 917         return yaffs_Dofsync(fd,0);
 918 }
 919
 920 int yaffs_flush(int fd)
 921 {
 922         return yaffs_fsync(fd);
 923 }
 924
 925 int yaffs_fdatasync(int fd)
 926 {
 927         return yaffs_Dofsync(fd,1);
 928 }
 929
 930 int yaffs_close(int fd)
 931 {
 932         yaffsfs_Handle *h = NULL;
 933         int retVal = 0;
 934
 935         yaffsfs_Lock();
 936
 937         h = yaffsfs_GetHandlePointer(fd);
 938
 939         if(h && h->useCount > 0) {
 940                 /* clean up */
 941                 yaffs_flush_file(yaffsfs_inode[h->inodeId].iObj,1,0);
 942                 yaffsfs_PutHandle(fd);
 943                 retVal = 0;
 944         } else {
 945                 /* bad handle */
 946                 yaffsfs_SetError(-EBADF);
 947                 retVal = -1;
 948         }
 949
 950         yaffsfs_Unlock();
 951
 952         return retVal;
 953 }
 954
 955
 956
 957 int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int offset)
 958 {
 959         yaffsfs_Handle *h = NULL;
 960         struct yaffs_obj *obj = NULL;
 961         int pos = 0;
 962         int startPos = 0;
 963         int endPos = 0;
 964         int nRead = 0;
 965         int nToRead = 0;
 966         int totalRead = 0;
 967         unsigned int maxRead;
 968         u8 *buf = (u8 *)vbuf;
 969
 970         yaffsfs_Lock();
 971         h = yaffsfs_GetHandlePointer(fd);
 972         obj = yaffsfs_GetHandleObject(fd);
 973
 974         if(!h || !obj){
 975                 /* bad handle */
 976                 yaffsfs_SetError(-EBADF);
 977                 totalRead = -1;
 978         } else if(!h->reading){
 979                 /* Not a reading handle */
 980                 yaffsfs_SetError(-EINVAL);
 981                 totalRead = -1;
 982         } else if(nbyte > YAFFS_MAX_FILE_SIZE){
 983                 yaffsfs_SetError(-EINVAL);
 984                 totalRead = -1;
 985         } else {
 986                 if(isPread)
 987                         startPos = offset;
 988                 else
 989                         startPos = h->position;
 990
 991                 pos = startPos;
 992
 993                 if(yaffs_get_obj_length(obj) > pos)
 994                         maxRead = yaffs_get_obj_length(obj) - pos;
 995                 else
 996                         maxRead = 0;
 997
 998                 if(nbyte > maxRead)
 999                         nbyte = maxRead;
1000
1001
1002                 yaffsfs_GetHandle(fd);
1003
1004                 endPos = pos + nbyte;
1005
1006                 if(pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
1007                         nbyte > YAFFS_MAX_FILE_SIZE ||
1008                         endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE){
1009                         totalRead = -1;
1010                         nbyte = 0;
1011                 }
1012
1013                 while(nbyte > 0) {
1014                         nToRead = YAFFSFS_RW_SIZE - (pos & (YAFFSFS_RW_SIZE -1));
1015                         if(nToRead > nbyte)
1016                                 nToRead = nbyte;
1017
1018                         /* Tricky bit...
1019                          * Need to reverify object in case the device was
1020                          * unmounted in another thread.
1021                          */
1022                         obj = yaffsfs_GetHandleObject(fd);
1023                         if(!obj)
1024                                 nRead = 0;
1025                         else
1026                                 nRead = yaffs_file_rd(obj,buf,pos,nToRead);
1027
1028                         if(nRead > 0){
1029                                 totalRead += nRead;
1030                                 pos += nRead;
1031                                 buf += nRead;
1032                         }
1033
1034                         if(nRead == nToRead)
1035                                 nbyte-=nRead;
1036                         else
1037                                 nbyte = 0; /* no more to read */
1038
1039
1040                         if(nbyte > 0){
1041                                 yaffsfs_Unlock();
1042                                 yaffsfs_Lock();
1043                         }
1044
1045                 }
1046
1047                 yaffsfs_PutHandle(fd);
1048
1049                 if(!isPread) {
1050                         if(totalRead >= 0)
1051                                 h->position = startPos + totalRead;
1052                         else
1053                                 yaffsfs_SetError(-EINVAL);
1054                 }
1055
1056         }
1057
1058         yaffsfs_Unlock();
1059
1060         return (totalRead >= 0) ? totalRead : -1;
1061
1062 }
1063
1064 int yaffs_read(int fd, void *buf, unsigned int nbyte)
1065 {
1066         return yaffsfs_do_read(fd, buf, nbyte, 0, 0);
1067 }
1068
1069 int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset)
1070 {
1071         return yaffsfs_do_read(fd, buf, nbyte, 1, offset);
1072 }
1073
1074 int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite, int offset)
1075 {
1076         yaffsfs_Handle *h = NULL;
1077         struct yaffs_obj *obj = NULL;
1078         int pos = 0;
1079         int startPos = 0;
1080         int endPos;
1081         int nWritten = 0;
1082         int totalWritten = 0;
1083         int write_trhrough = 0;
1084         int nToWrite = 0;
1085         const u8 *buf = (const u8 *)vbuf;
1086
1087         yaffsfs_Lock();
1088         h = yaffsfs_GetHandlePointer(fd);
1089         obj = yaffsfs_GetHandleObject(fd);
1090
1091         if(!h || !obj){
1092                 /* bad handle */
1093                 yaffsfs_SetError(-EBADF);
1094                 totalWritten = -1;
1095         } else if(!h->writing){
1096                 yaffsfs_SetError(-EINVAL);
1097                 totalWritten=-1;
1098         } else if(obj->my_dev->read_only){
1099                 yaffsfs_SetError(-EROFS);
1100                 totalWritten=-1;
1101         } else {
1102                 if(h->append)
1103                         startPos = yaffs_get_obj_length(obj);
1104                 else if(isPwrite)
1105                         startPos = offset;
1106                 else
1107                         startPos = h->position;
1108
1109                 yaffsfs_GetHandle(fd);
1110                 pos = startPos;
1111                 endPos = pos + nbyte;
1112
1113                 if(pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
1114                         nbyte > YAFFS_MAX_FILE_SIZE ||
1115                         endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE){
1116                         totalWritten = -1;
1117                         nbyte = 0;
1118                 }
1119
1120                 while(nbyte > 0) {
1121
1122                         nToWrite = YAFFSFS_RW_SIZE - (pos & (YAFFSFS_RW_SIZE -1));
1123                         if(nToWrite > nbyte)
1124                                 nToWrite = nbyte;
1125
1126                         /* Tricky bit...
1127                          * Need to reverify object in case the device was
1128                          * remounted or unmounted in another thread.
1129                          */
1130                         obj = yaffsfs_GetHandleObject(fd);
1131                         if(!obj || obj->my_dev->read_only)
1132                                 nWritten = 0;
1133                         else
1134                                 nWritten = yaffs_wr_file(obj,buf,pos,nToWrite,
1135                                                         write_trhrough);
1136                         if(nWritten > 0){
1137                                 totalWritten += nWritten;
1138                                 pos += nWritten;
1139                                 buf += nWritten;
1140                         }
1141
1142                         if(nWritten == nToWrite)
1143                                 nbyte -= nToWrite;
1144                         else
1145                                 nbyte = 0;
1146
1147                         if(nWritten < 1 && totalWritten < 1){
1148                                 yaffsfs_SetError(-ENOSPC);
1149                                 totalWritten = -1;
1150                         }
1151
1152                         if(nbyte > 0){
1153                                 yaffsfs_Unlock();
1154                                 yaffsfs_Lock();
1155                         }
1156                 }
1157
1158                 yaffsfs_PutHandle(fd);
1159
1160                 if(!isPwrite){
1161                         if(totalWritten > 0)
1162                                 h->position = startPos + totalWritten;
1163                         else
1164                                 yaffsfs_SetError(-EINVAL);
1165                 }
1166         }
1167
1168         yaffsfs_Unlock();
1169
1170         return (totalWritten >= 0) ? totalWritten : -1;
1171 }
1172
1173 int yaffs_write(int fd, const void *buf, unsigned int nbyte)
1174 {
1175         return yaffsfs_do_write(fd, buf, nbyte, 0, 0);
1176 }
1177
1178 int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offset)
1179 {
1180         return yaffsfs_do_write(fd, buf, nbyte, 1, offset);
1181 }
1182
1183
1184 int yaffs_truncate(const YCHAR *path,off_t new_size)
1185 {
1186         struct yaffs_obj *obj = NULL;
1187         struct yaffs_obj *dir = NULL;
1188         int result = YAFFS_FAIL;
1189         int notDir = 0;
1190         int loop = 0;
1191
1192         if(yaffsfs_CheckPath(path) < 0){
1193                 yaffsfs_SetError(-ENAMETOOLONG);
1194                 return -1;
1195         }
1196
1197         yaffsfs_Lock();
1198
1199         obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
1200         obj = yaffsfs_FollowLink(obj,0,&loop);
1201
1202         if(!dir && notDir)
1203                 yaffsfs_SetError(-ENOTDIR);
1204         else if(loop)
1205                 yaffsfs_SetError(-ELOOP);
1206         else if(!dir || !obj)
1207                 yaffsfs_SetError(-ENOENT);
1208         else if(obj->my_dev->read_only)
1209                 yaffsfs_SetError(-EROFS);
1210         else if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
1211                 yaffsfs_SetError(-EISDIR);
1212         else if(obj->my_dev->read_only)
1213                 yaffsfs_SetError(-EROFS);
1214         else if(new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
1215                 yaffsfs_SetError(-EINVAL);
1216         else
1217                 result = yaffs_resize_file(obj,new_size);
1218
1219         yaffsfs_Unlock();
1220
1221         return (result) ? 0 : -1;
1222 }
1223
1224 int yaffs_ftruncate(int fd, off_t new_size)
1225 {
1226         yaffsfs_Handle *h = NULL;
1227         struct yaffs_obj *obj = NULL;
1228         int result = 0;
1229
1230         yaffsfs_Lock();
1231         h = yaffsfs_GetHandlePointer(fd);
1232         obj = yaffsfs_GetHandleObject(fd);
1233
1234         if(!h || !obj)
1235                 /* bad handle */
1236                 yaffsfs_SetError(-EBADF);
1237         else if(!h->writing)
1238                 yaffsfs_SetError(-EINVAL);
1239         else if(obj->my_dev->read_only)
1240                 yaffsfs_SetError(-EROFS);
1241         else if( new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
1242                 yaffsfs_SetError(-EINVAL);
1243         else
1244                 /* resize the file */
1245                 result = yaffs_resize_file(obj,new_size);
1246         yaffsfs_Unlock();
1247
1248         return (result) ? 0 : -1;
1249
1250 }
1251
1252 off_t yaffs_lseek(int fd, off_t offset, int whence)
1253 {
1254         yaffsfs_Handle *h = NULL;
1255         struct yaffs_obj *obj = NULL;
1256         int pos = -1;
1257         int fSize = -1;
1258
1259         yaffsfs_Lock();
1260         h = yaffsfs_GetHandlePointer(fd);
1261         obj = yaffsfs_GetHandleObject(fd);
1262
1263         if(!h || !obj)
1264                 yaffsfs_SetError(-EBADF);
1265         else if(offset > YAFFS_MAX_FILE_SIZE)
1266                 yaffsfs_SetError(-EINVAL);
1267         else {
1268                 if(whence == SEEK_SET){
1269                         if(offset >= 0)
1270                                 pos = offset;
1271                 } else if(whence == SEEK_CUR) {
1272                         if( (h->position + offset) >= 0)
1273                                 pos = (h->position + offset);
1274                 } else if(whence == SEEK_END) {
1275                         fSize = yaffs_get_obj_length(obj);
1276                         if(fSize >= 0 && (fSize + offset) >= 0)
1277                                 pos = fSize + offset;
1278                 }
1279
1280                 if(pos >= 0 && pos <= YAFFS_MAX_FILE_SIZE)
1281                         h->position = pos;
1282                 else{
1283                         yaffsfs_SetError(-EINVAL);
1284                         pos = -1;
1285                 }
1286         }
1287
1288         yaffsfs_Unlock();
1289
1290         return pos;
1291 }
1292
1293
1294 int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
1295 {
1296         struct yaffs_obj *dir = NULL;
1297         struct yaffs_obj *obj = NULL;
1298         YCHAR *name;
1299         int result = YAFFS_FAIL;
1300         int notDir = 0;
1301         int loop = 0;
1302
1303         if(yaffsfs_CheckPath(path) < 0){
1304                 yaffsfs_SetError(-ENAMETOOLONG);
1305                 return -1;
1306         }
1307
1308         yaffsfs_Lock();
1309
1310         obj = yaffsfs_FindObject(NULL,path,0,0,NULL,NULL,NULL);
1311         dir = yaffsfs_FindDirectory(NULL,path,&name,0,&notDir,&loop);
1312
1313         if(!dir && notDir)
1314                 yaffsfs_SetError(-ENOTDIR);
1315         else if(loop)
1316                 yaffsfs_SetError(-ELOOP);
1317         else if(!dir)
1318                 yaffsfs_SetError(-ENOENT);
1319         else if(yaffs_strncmp(name,_Y("."),2) == 0)
1320                 yaffsfs_SetError(-EINVAL);
1321         else if(!obj)
1322                 yaffsfs_SetError(-ENOENT);
1323         else if(obj->my_dev->read_only)
1324                 yaffsfs_SetError(-EROFS);
1325         else if(!isDirectory && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
1326                 yaffsfs_SetError(-EISDIR);
1327         else if(isDirectory && obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
1328                 yaffsfs_SetError(-ENOTDIR);
1329         else if(isDirectory && obj == obj->my_dev->root_dir)
1330                 yaffsfs_SetError(-EBUSY); /* Can't rmdir a root */
1331         else {
1332                 result = yaffs_unlinker(dir,name);
1333
1334                 if(result == YAFFS_FAIL && isDirectory)
1335                         yaffsfs_SetError(-ENOTEMPTY);
1336         }
1337
1338         yaffsfs_Unlock();
1339
1340         return (result == YAFFS_FAIL) ? -1 : 0;
1341 }
1342
1343
1344 int yaffs_unlink(const YCHAR *path)
1345 {
1346         return yaffsfs_DoUnlink(path,0);
1347 }
1348
1349 int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
1350 {
1351         struct yaffs_obj *olddir = NULL;
1352         struct yaffs_obj *newdir = NULL;
1353         struct yaffs_obj *obj = NULL;
1354         struct yaffs_obj *newobj = NULL;
1355         YCHAR *oldname;
1356         YCHAR *newname;
1357         int result= YAFFS_FAIL;
1358         int rename_allowed = 1;
1359         int notOldDir = 0;
1360         int notNewDir = 0;
1361         int oldLoop = 0;
1362         int newLoop = 0;
1363
1364         YCHAR *alt_newpath=NULL;
1365
1366         if(yaffsfs_CheckPath(newPath) < 0){
1367                 yaffsfs_SetError(-ENAMETOOLONG);
1368                 return -1;
1369         }
1370
1371         if(yaffsfs_alt_dir_path(newPath, &alt_newpath) < 0){
1372                 yaffsfs_SetError(-ENOMEM);
1373                 return -1;
1374         }
1375         if(alt_newpath)
1376                 newPath = alt_newpath;
1377
1378         yaffsfs_Lock();
1379
1380
1381         olddir = yaffsfs_FindDirectory(NULL,oldPath,&oldname,0,&notOldDir,&oldLoop);
1382         newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0,&notNewDir,&newLoop);
1383         obj = yaffsfs_FindObject(NULL,oldPath,0,0,NULL,NULL,NULL);
1384         newobj = yaffsfs_FindObject(NULL,newPath,0,0,NULL,NULL,NULL);
1385
1386         /* If the object being renamed is a directory and the
1387          * path ended with a "/" then the olddir == obj.
1388          * We pass through NULL for the old name to tell the lower layers
1389          * to use olddir as the object.
1390          */
1391
1392         if(olddir == obj)
1393                 oldname = NULL;
1394
1395         if((!olddir && notOldDir) || (!newdir && notNewDir)) {
1396                 yaffsfs_SetError(-ENOTDIR);
1397                 rename_allowed = 0;
1398         } else if(oldLoop || newLoop) {
1399                 yaffsfs_SetError(-ELOOP);
1400                 rename_allowed = 0;
1401         } else if (olddir && oldname && yaffs_strncmp(oldname, _Y("."),2) == 0){
1402                 yaffsfs_SetError(-EINVAL);
1403                 rename_allowed = 0;
1404         }else if(!olddir || !newdir || !obj) {
1405                 yaffsfs_SetError(-ENOENT);
1406                 rename_allowed = 0;
1407         } else if(obj->my_dev->read_only){
1408                 yaffsfs_SetError(-EROFS);
1409                 rename_allowed = 0;
1410         } else if(yaffs_is_non_empty_dir(newobj)){
1411                 yaffsfs_SetError(-ENOTEMPTY);
1412                 rename_allowed = 0;
1413         } else if(olddir->my_dev != newdir->my_dev) {
1414                 /* Rename must be on same device */
1415                 yaffsfs_SetError(-EXDEV);
1416                 rename_allowed = 0;
1417         } else if(obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
1418                 /*
1419                  * It is a directory, check that it is not being renamed to
1420                  * being its own decendent.
1421                  * Do this by tracing from the new directory back to the root,
1422                  * checking for obj
1423                  */
1424
1425                 struct yaffs_obj *xx = newdir;
1426
1427                 while( rename_allowed && xx){
1428                         if(xx == obj)
1429                                 rename_allowed = 0;
1430                         xx = xx->parent;
1431                 }
1432                 if(!rename_allowed)
1433                         yaffsfs_SetError(-EINVAL);
1434         }
1435
1436         if(rename_allowed)
1437                 result = yaffs_rename_obj(olddir,oldname,newdir,newname);
1438
1439         yaffsfs_Unlock();
1440
1441         if(alt_newpath)
1442                 YFREE(alt_newpath);
1443
1444         return (result == YAFFS_FAIL) ? -1 : 0;
1445 }
1446
1447
1448 static int yaffsfs_DoStat(struct yaffs_obj *obj,struct yaffs_stat *buf)
1449 {
1450         int retVal = -1;
1451
1452         obj = yaffs_get_equivalent_obj(obj);
1453
1454         if(obj && buf){
1455                 buf->st_dev = (int)obj->my_dev->os_context;
1456                 buf->st_ino = obj->obj_id;
1457                 buf->st_mode = obj->yst_mode & ~S_IFMT; /* clear out file type bits */
1458
1459                 if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
1460                         buf->st_mode |= S_IFDIR;
1461                 else if(obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK)
1462                         buf->st_mode |= S_IFLNK;
1463                 else if(obj->variant_type == YAFFS_OBJECT_TYPE_FILE)
1464                         buf->st_mode |= S_IFREG;
1465
1466                 buf->st_nlink = yaffs_get_obj_link_count(obj);
1467                 buf->st_uid = 0;
1468                 buf->st_gid = 0;;
1469                 buf->st_rdev = obj->yst_rdev;
1470                 buf->st_size = yaffs_get_obj_length(obj);
1471                 buf->st_blksize = obj->my_dev->data_bytes_per_chunk;
1472                 buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize;
1473 #if CONFIG_YAFFS_WINCE
1474                 buf->yst_wince_atime[0] = obj->win_atime[0];
1475                 buf->yst_wince_atime[1] = obj->win_atime[1];
1476                 buf->yst_wince_ctime[0] = obj->win_ctime[0];
1477                 buf->yst_wince_ctime[1] = obj->win_ctime[1];
1478                 buf->yst_wince_mtime[0] = obj->win_mtime[0];
1479                 buf->yst_wince_mtime[1] = obj->win_mtime[1];
1480 #else
1481                 buf->yst_atime = obj->yst_atime;
1482                 buf->yst_ctime = obj->yst_ctime;
1483                 buf->yst_mtime = obj->yst_mtime;
1484 #endif
1485                 retVal = 0;
1486         }
1487         return retVal;
1488 }
1489
1490 static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat)
1491 {
1492         struct yaffs_obj *obj=NULL;
1493         struct yaffs_obj *dir=NULL;
1494         int retVal = -1;
1495         int notDir = 0;
1496         int loop = 0;
1497
1498         if(yaffsfs_CheckPath(path) < 0){
1499                 yaffsfs_SetError(-ENAMETOOLONG);
1500                 return -1;
1501         }
1502
1503         yaffsfs_Lock();
1504
1505         obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
1506
1507         if(!doLStat && obj)
1508                 obj = yaffsfs_FollowLink(obj,0,&loop);
1509
1510         if(!dir && notDir)
1511                 yaffsfs_SetError(-ENOTDIR);
1512         else if(loop)
1513                 yaffsfs_SetError(-ELOOP);
1514         else if(!dir || !obj)
1515                 yaffsfs_SetError(-ENOENT);
1516         else
1517                 retVal = yaffsfs_DoStat(obj,buf);
1518
1519         yaffsfs_Unlock();
1520
1521         return retVal;
1522
1523 }
1524
1525 int yaffs_stat(const YCHAR *path, struct yaffs_stat *buf)
1526 {
1527         return yaffsfs_DoStatOrLStat(path,buf,0);
1528 }
1529
1530 int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf)
1531 {
1532         return yaffsfs_DoStatOrLStat(path,buf,1);
1533 }
1534
1535 int yaffs_fstat(int fd, struct yaffs_stat *buf)
1536 {
1537         struct yaffs_obj *obj;
1538
1539         int retVal = -1;
1540
1541         yaffsfs_Lock();
1542         obj = yaffsfs_GetHandleObject(fd);
1543
1544         if(obj)
1545                 retVal = yaffsfs_DoStat(obj,buf);
1546         else
1547                 /* bad handle */
1548                 yaffsfs_SetError(-EBADF);
1549
1550         yaffsfs_Unlock();
1551
1552         return retVal;
1553 }
1554
1555 #ifndef CONFIG_YAFFS_WINCE
1556 /* xattrib functions */
1557
1558
1559 static int yaffs_do_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags, int follow)
1560 {
1561         struct yaffs_obj *obj;
1562         struct yaffs_obj *dir;
1563         int notDir = 0;
1564         int loop = 0;
1565
1566         int retVal = -1;
1567
1568         if(yaffsfs_CheckPath(path) < 0){
1569                 yaffsfs_SetError(-ENAMETOOLONG);
1570                 return -1;
1571         }
1572
1573         yaffsfs_Lock();
1574
1575         obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
1576
1577         if(follow)
1578                 obj = yaffsfs_FollowLink(obj,0,&loop);
1579
1580         if(!dir && notDir)
1581                 yaffsfs_SetError(-ENOTDIR);
1582         else if(loop)
1583                 yaffsfs_SetError(-ELOOP);
1584         else if(!dir || !obj)
1585                 yaffsfs_SetError(-ENOENT);
1586         else {
1587                 retVal = yaffs_set_xattrib(obj,name,data,size,flags);
1588                 if(retVal< 0){
1589                         yaffsfs_SetError(retVal);
1590                         retVal = -1;
1591                 }
1592         }
1593
1594         yaffsfs_Unlock();
1595
1596         return retVal;
1597
1598 }
1599
1600 int yaffs_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags)
1601 {
1602         return yaffs_do_setxattr(path, name, data, size, flags, 1);
1603 }
1604
1605 int yaffs_lsetxattr(const YCHAR *path, const char *name, const void *data, int size, int flags)
1606 {
1607         return yaffs_do_setxattr(path, name, data, size, flags, 0);
1608 }
1609
1610
1611
1612 int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int flags)
1613 {
1614         struct yaffs_obj *obj;
1615
1616         int retVal = -1;
1617
1618         yaffsfs_Lock();
1619         obj = yaffsfs_GetHandleObject(fd);
1620
1621         if(!obj)
1622                 yaffsfs_SetError(-EBADF);
1623         else {
1624                 retVal = yaffs_set_xattrib(obj,name,data,size,flags);
1625                 if(retVal< 0){
1626                         yaffsfs_SetError(retVal);
1627                         retVal = -1;
1628                 }
1629         }
1630
1631         yaffsfs_Unlock();
1632
1633         return retVal;
1634 }
1635
1636 static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, int size, int follow)
1637 {
1638         struct yaffs_obj *obj;
1639         struct yaffs_obj *dir;
1640         int retVal = -1;
1641         int notDir = 0;
1642         int loop = 0;
1643
1644         if(yaffsfs_CheckPath(path) < 0){
1645                 yaffsfs_SetError(-ENAMETOOLONG);
1646                 return -1;
1647         }
1648
1649         yaffsfs_Lock();
1650
1651         obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
1652
1653         if(follow)
1654                 obj = yaffsfs_FollowLink(obj,0,&loop);
1655
1656         if(!dir && notDir)
1657                 yaffsfs_SetError(-ENOTDIR);
1658         else if(loop)
1659                 yaffsfs_SetError(-ELOOP);
1660         else if(!dir || !obj)
1661                 yaffsfs_SetError(-ENOENT);
1662         else {
1663                 retVal = yaffs_get_xattrib(obj,name,data,size);
1664                 if(retVal< 0){
1665                         yaffsfs_SetError(retVal);
1666                         retVal = -1;
1667                 }
1668         }
1669         yaffsfs_Unlock();
1670
1671         return retVal;
1672
1673 }
1674
1675 int yaffs_getxattr(const YCHAR *path, const char *name, void *data, int size)
1676 {
1677         return yaffs_do_getxattr( path, name, data, size, 1);
1678 }
1679 int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size)
1680 {
1681         return yaffs_do_getxattr( path, name, data, size, 0);
1682 }
1683
1684
1685
1686 int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
1687 {
1688         struct yaffs_obj *obj;
1689
1690         int retVal = -1;
1691
1692         yaffsfs_Lock();
1693         obj = yaffsfs_GetHandleObject(fd);
1694
1695         if(obj) {
1696                 retVal = yaffs_get_xattrib(obj,name,data,size);
1697                 if(retVal< 0){
1698                         yaffsfs_SetError(retVal);
1699                         retVal = -1;
1700                 }
1701         } else
1702                 /* bad handle */
1703                 yaffsfs_SetError(-EBADF);
1704
1705         yaffsfs_Unlock();
1706
1707         return retVal;
1708 }
1709
1710 static int yaffs_do_listxattr(const YCHAR *path, char *data, int size, int follow)
1711 {
1712         struct yaffs_obj *obj=NULL;
1713         struct yaffs_obj *dir=NULL;
1714         int retVal = -1;
1715         int notDir = 0;
1716         int loop = 0;
1717
1718         if(yaffsfs_CheckPath(path) < 0){
1719                 yaffsfs_SetError(-ENAMETOOLONG);
1720                 return -1;
1721         }
1722
1723         yaffsfs_Lock();
1724
1725         obj = yaffsfs_FindObject(NULL,path,0,1,&dir,&notDir,&loop);
1726
1727         if(follow)
1728                 obj = yaffsfs_FollowLink(obj,0,&loop);
1729
1730         if(!dir && notDir)
1731                 yaffsfs_SetError(-ENOTDIR);
1732         else if(loop)
1733                 yaffsfs_SetError(-ELOOP);
1734         else if(!dir || !obj)
1735                 yaffsfs_SetError(-ENOENT);
1736         else {
1737                 retVal = yaffs_list_xattrib(obj, data,size);
1738                 if(retVal< 0){
1739                         yaffsfs_SetError(retVal);
1740                         retVal = -1;
1741                 }
1742         }
1743
1744         yaffsfs_Unlock();
1745
1746         return retVal;
1747
1748 }
1749
1750 int yaffs_listxattr(const YCHAR *path, char *data, int size)
1751 {
1752         return yaffs_do_listxattr(path, data, size, 1);
1753 }
1754
1755 int yaffs_llistxattr(const YCHAR *path, char *data, int size)
1756 {
1757         return yaffs_do_listxattr(path, data, size, 0);
1758 }
1759
1760 int yaffs_flistxattr(int fd, char *data, int size)
1761 {
1762         struct yaffs_obj *obj;
1763
1764         int retVal = -1;
1765
1766         yaffsfs_Lock();
1767         obj = yaffsfs_GetHandleObject(fd);
1768
1769         if(obj) {
1770                 retVal = yaffs_list_xattrib(obj,data,size);
1771                 if(retVal< 0){
1772                         yaffsfs_SetError(retVal);
1773                         retVal = -1;
1774                 }
1775         } else
1776                 /* bad handle */
1777                 yaffsfs_SetError(-EBADF);
1778
1779         yaffsfs_Unlock();
1780
1781         return retVal;
1782 }
1783
1784 static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow)
1785 {
1786         struct yaffs_obj *obj=NULL;
1787         struct yaffs_obj *dir=NULL;
1788         int notDir = 0;
1789         int loop = 0;
1790         int retVal = -1;
1791
1792         if(yaffsfs_CheckPath(path) < 0){
1793                 yaffsfs_SetError(-ENAMETOOLONG);
1794                 return -1;
1795         }
1796
1797         yaffsfs_Lock();
1798
1799         obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
1800
1801         if(follow)
1802                 obj = yaffsfs_FollowLink(obj,0,&loop);
1803
1804         if(!dir && notDir)
1805                 yaffsfs_SetError(-ENOTDIR);
1806         else if(loop)
1807                 yaffsfs_SetError(-ELOOP);
1808         else if(!dir || !obj)
1809                 yaffsfs_SetError(-ENOENT);
1810         else {
1811                 retVal = yaffs_remove_xattrib(obj,name);
1812                 if(retVal< 0){
1813                         yaffsfs_SetError(retVal);
1814                         retVal = -1;
1815                 }
1816         }
1817
1818         yaffsfs_Unlock();
1819
1820         return retVal;
1821
1822 }
1823
1824 int yaffs_removexattr(const YCHAR *path, const char *name)
1825 {
1826         return yaffs_do_removexattr(path, name, 1);
1827 }
1828
1829 int yaffs_lremovexattr(const YCHAR *path, const char *name)
1830 {
1831         return yaffs_do_removexattr(path, name, 0);
1832 }
1833
1834 int yaffs_fremovexattr(int fd, const char *name)
1835 {
1836         struct yaffs_obj *obj;
1837
1838         int retVal = -1;
1839
1840         yaffsfs_Lock();
1841         obj = yaffsfs_GetHandleObject(fd);
1842
1843         if(obj){
1844                 retVal = yaffs_remove_xattrib(obj,name);
1845                 if(retVal< 0){
1846                         yaffsfs_SetError(retVal);
1847                         retVal = -1;
1848                 }
1849         }else
1850                 /* bad handle */
1851                 yaffsfs_SetError(-EBADF);
1852
1853         yaffsfs_Unlock();
1854
1855         return retVal;
1856 }
1857 #endif
1858
1859 #ifdef CONFIG_YAFFS_WINCE
1860 int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *wmtime)
1861 {
1862         struct yaffs_obj *obj;
1863
1864         int retVal = -1;
1865
1866         yaffsfs_Lock();
1867         obj = yaffsfs_GetHandleObject(fd);
1868
1869         if(obj){
1870
1871                 if(wctime){
1872                         wctime[0] = obj->win_ctime[0];
1873                         wctime[1] = obj->win_ctime[1];
1874                 }
1875                 if(watime){
1876                         watime[0] = obj->win_atime[0];
1877                         watime[1] = obj->win_atime[1];
1878                 }
1879                 if(wmtime){
1880                         wmtime[0] = obj->win_mtime[0];
1881                         wmtime[1] = obj->win_mtime[1];
1882                 }
1883
1884
1885                 retVal = 0;
1886         } else
1887                 /*  bad handle */
1888                 yaffsfs_SetError(-EBADF);
1889
1890         yaffsfs_Unlock();
1891
1892         return retVal;
1893 }
1894
1895
1896 int yaffs_set_wince_times(int fd,
1897                                                   const unsigned *wctime,
1898                                                   const unsigned *watime,
1899                                                   const unsigned *wmtime)
1900 {
1901         struct yaffs_obj *obj;
1902         int result;
1903         int retVal = -1;
1904
1905         yaffsfs_Lock();
1906         obj = yaffsfs_GetHandleObject(fd);
1907
1908         if(obj){
1909
1910                 if(wctime){
1911                         obj->win_ctime[0] = wctime[0];
1912                         obj->win_ctime[1] = wctime[1];
1913                 }
1914                 if(watime){
1915                         obj->win_atime[0] = watime[0];
1916                         obj->win_atime[1] = watime[1];
1917                 }
1918                 if(wmtime){
1919                         obj->win_mtime[0] = wmtime[0];
1920                         obj->win_mtime[1] = wmtime[1];
1921                 }
1922
1923                 obj->dirty = 1;
1924                 result = yaffs_flush_file(obj,0,0);
1925                 retVal = 0;
1926         } else
1927                 /* bad handle */
1928                 yaffsfs_SetError(-EBADF);
1929
1930         yaffsfs_Unlock();
1931
1932         return retVal;
1933 }
1934
1935 #endif
1936
1937
1938 static int yaffsfs_DoChMod(struct yaffs_obj *obj,mode_t mode)
1939 {
1940         int result = -1;
1941
1942         if(obj)
1943                 obj = yaffs_get_equivalent_obj(obj);
1944
1945         if(obj) {
1946                 obj->yst_mode = mode;
1947                 obj->dirty = 1;
1948                 result = yaffs_flush_file(obj,0,0);
1949         }
1950
1951         return result == YAFFS_OK ? 0 : -1;
1952 }
1953
1954
1955 int yaffs_access(const YCHAR *path, int amode)
1956 {
1957         struct yaffs_obj *obj=NULL;
1958         struct yaffs_obj *dir=NULL;
1959         int notDir = 0;
1960         int loop = 0;
1961         int retval = -1;
1962
1963         if(yaffsfs_CheckPath(path) < 0){
1964                 yaffsfs_SetError(-ENAMETOOLONG);
1965                 return -1;
1966         }
1967
1968         if(amode & ~(R_OK | W_OK | X_OK)){
1969                 yaffsfs_SetError(-EINVAL);
1970                 return -1;
1971         }
1972
1973         yaffsfs_Lock();
1974
1975         obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
1976         obj = yaffsfs_FollowLink(obj,0,&loop);
1977
1978         if(!dir && notDir)
1979                 yaffsfs_SetError(-ENOTDIR);
1980         else if(loop)
1981                 yaffsfs_SetError(-ELOOP);
1982         else if(!dir || !obj)
1983                 yaffsfs_SetError(-ENOENT);
1984         else if((amode & W_OK) && obj->my_dev->read_only)
1985                 yaffsfs_SetError(-EROFS);
1986         else{
1987                 int access_ok = 1;
1988
1989                 if((amode & R_OK) && !(obj->yst_mode & S_IREAD))
1990                         access_ok = 0;
1991                 if((amode & W_OK) && !(obj->yst_mode & S_IWRITE))
1992                         access_ok = 0;
1993                 if((amode & X_OK) && !(obj->yst_mode & S_IEXEC))
1994                         access_ok = 0;
1995
1996                 if(!access_ok)
1997                         yaffsfs_SetError(-EACCES);
1998                 else
1999                         retval = 0;
2000         }
2001
2002         yaffsfs_Unlock();
2003
2004         return retval;
2005
2006 }
2007
2008
2009 int yaffs_chmod(const YCHAR *path, mode_t mode)
2010 {
2011         struct yaffs_obj *obj=NULL;
2012         struct yaffs_obj *dir=NULL;
2013         int retVal = -1;
2014         int notDir = 0;
2015         int loop = 0;
2016
2017         if(yaffsfs_CheckPath(path) < 0){
2018                 yaffsfs_SetError(-ENAMETOOLONG);
2019                 return -1;
2020         }
2021
2022         if(mode & ~(0777)){
2023                 yaffsfs_SetError(-EINVAL);
2024                 return -1;
2025         }
2026
2027         yaffsfs_Lock();
2028
2029         obj = yaffsfs_FindObject(NULL,path,0,1, &dir, &notDir,&loop);
2030         obj = yaffsfs_FollowLink(obj,0,&loop);
2031
2032         if(!dir && notDir)
2033                 yaffsfs_SetError(-ENOTDIR);
2034         else if(loop)
2035                 yaffsfs_SetError(-ELOOP);
2036         else if(!dir || !obj)
2037                 yaffsfs_SetError(-ENOENT);
2038         else if(obj->my_dev->read_only)
2039                 yaffsfs_SetError(-EROFS);
2040         else
2041                 retVal = yaffsfs_DoChMod(obj,mode);
2042
2043         yaffsfs_Unlock();
2044
2045         return retVal;
2046
2047 }
2048
2049
2050 int yaffs_fchmod(int fd, mode_t mode)
2051 {
2052         struct yaffs_obj *obj;
2053         int retVal = -1;
2054
2055         if(mode & ~(0777)){
2056                 yaffsfs_SetError(-EINVAL);
2057                 return -1;
2058         }
2059
2060         yaffsfs_Lock();
2061         obj = yaffsfs_GetHandleObject(fd);
2062
2063         if(!obj)
2064                 yaffsfs_SetError(-EBADF);
2065         else if(obj->my_dev->read_only)
2066                 yaffsfs_SetError(-EROFS);
2067         else
2068                 retVal = yaffsfs_DoChMod(obj,mode);
2069
2070         yaffsfs_Unlock();
2071
2072         return retVal;
2073 }
2074
2075 int yaffs_mkdir(const YCHAR *path, mode_t mode)
2076 {
2077         struct yaffs_obj *parent = NULL;
2078         struct yaffs_obj *dir = NULL;
2079         YCHAR *name;
2080         YCHAR *alt_path = NULL;
2081         int retVal= -1;
2082         int notDir = 0;
2083         int loop = 0;
2084
2085         if(yaffsfs_CheckPath(path) < 0){
2086                 yaffsfs_SetError(-ENAMETOOLONG);
2087                 return -1;
2088         }
2089
2090         if(yaffsfs_alt_dir_path(path, &alt_path) < 0){
2091                 yaffsfs_SetError(-ENOMEM);
2092                 return -1;
2093         }
2094         if(alt_path)
2095                 path = alt_path;
2096
2097         yaffsfs_Lock();
2098         parent = yaffsfs_FindDirectory(NULL,path,&name,0,&notDir,&loop);
2099         if(!parent && notDir)
2100                 yaffsfs_SetError(-ENOTDIR);
2101         else if(loop)
2102                 yaffsfs_SetError(-ELOOP);
2103         else if(!parent)
2104                 yaffsfs_SetError(-ENOENT);
2105         else if(yaffs_strnlen(name,5) == 0){
2106                 /* Trying to make the root itself */
2107                 yaffsfs_SetError(-EEXIST);
2108         } else if(parent->my_dev->read_only)
2109                 yaffsfs_SetError(-EROFS);
2110         else {
2111                 dir = yaffs_create_dir(parent,name,mode,0,0);
2112                 if(dir)
2113                         retVal = 0;
2114                 else if (yaffs_find_by_name(parent,name))
2115                         yaffsfs_SetError(-EEXIST); /* the name already exists */
2116                 else
2117                         yaffsfs_SetError(-ENOSPC); /* just assume no space */
2118         }
2119
2120         yaffsfs_Unlock();
2121
2122         if(alt_path)
2123                 YFREE(alt_path);
2124
2125         return retVal;
2126 }
2127
2128 int yaffs_rmdir(const YCHAR *path)
2129 {
2130         int result;
2131         YCHAR *alt_path;
2132
2133         if(yaffsfs_CheckPath(path) < 0){
2134                 yaffsfs_SetError(-ENAMETOOLONG);
2135                 return -1;
2136         }
2137
2138         if(yaffsfs_alt_dir_path(path, &alt_path) < 0){
2139                 yaffsfs_SetError(-ENOMEM);
2140                 return -1;
2141         }
2142         if(alt_path)
2143                 path = alt_path;
2144         result =  yaffsfs_DoUnlink(path,1);
2145         if(alt_path)
2146                 YFREE(alt_path);
2147         return result;
2148 }
2149
2150
2151 void * yaffs_getdev(const YCHAR *path)
2152 {
2153         struct yaffs_dev *dev=NULL;
2154         YCHAR *dummy;
2155         dev = yaffsfs_FindDevice(path,&dummy);
2156         return (void *)dev;
2157 }
2158
2159 int yaffs_mount2(const YCHAR *path,int read_only)
2160 {
2161         int retVal=-1;
2162         int result=YAFFS_FAIL;
2163         struct yaffs_dev *dev=NULL;
2164
2165         T(YAFFS_TRACE_MOUNT,(TSTR("yaffs: Mounting %s" TENDSTR),path));
2166
2167         if(yaffsfs_CheckPath(path) < 0){
2168                 yaffsfs_SetError(-ENAMETOOLONG);
2169                 return -1;
2170         }
2171
2172         yaffsfs_Lock();
2173
2174         yaffsfs_InitHandles();
2175
2176         dev = yaffsfs_FindMountPoint(path);
2177         if(dev){
2178                 if(!dev->is_mounted){
2179                         dev->read_only = read_only ? 1 : 0;
2180                         result = yaffs_guts_initialise(dev);
2181                         if(result == YAFFS_FAIL)
2182                                 yaffsfs_SetError(-ENOMEM);
2183                         retVal = result ? 0 : -1;
2184
2185                 }
2186                 else
2187                         yaffsfs_SetError(-EBUSY);
2188         } else
2189                 yaffsfs_SetError(-ENODEV);
2190
2191         yaffsfs_Unlock();
2192         return retVal;
2193
2194 }
2195
2196 int yaffs_mount(const YCHAR *path)
2197 {
2198         return yaffs_mount2(path,0);
2199 }
2200
2201 int yaffs_sync(const YCHAR *path)
2202 {
2203         int retVal=-1;
2204         struct yaffs_dev *dev=NULL;
2205         YCHAR *dummy;
2206
2207         if(yaffsfs_CheckPath(path) < 0){
2208                 yaffsfs_SetError(-ENAMETOOLONG);
2209                 return -1;
2210         }
2211
2212         yaffsfs_Lock();
2213         dev = yaffsfs_FindDevice(path,&dummy);
2214         if(dev){
2215                 if(!dev->is_mounted)
2216                         yaffsfs_SetError(-EINVAL);
2217                 else if(dev->read_only)
2218                         yaffsfs_SetError(-EROFS);
2219                 else {
2220
2221                         yaffs_flush_whole_cache(dev);
2222                         yaffs_checkpoint_save(dev);
2223                         retVal = 0;
2224
2225                 }
2226         }else
2227                 yaffsfs_SetError(-ENODEV);
2228
2229         yaffsfs_Unlock();
2230         return retVal;
2231 }
2232
2233
2234 int yaffs_remount(const YCHAR *path, int force, int read_only)
2235 {
2236         int retVal=-1;
2237         struct yaffs_dev *dev=NULL;
2238         yaffsfs_Handle *yh;
2239
2240         if(yaffsfs_CheckPath(path) < 0){
2241                 yaffsfs_SetError(-ENAMETOOLONG);
2242                 return -1;
2243         }
2244
2245         yaffsfs_Lock();
2246         dev = yaffsfs_FindMountPoint(path);
2247         if(dev){
2248                 if(dev->is_mounted){
2249                         int i;
2250                         int inUse;
2251
2252                         yaffs_flush_whole_cache(dev);
2253
2254                         for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse && !force; i++){
2255                                 yh = & yaffsfs_handle[i];
2256                                 if(yh->useCount>0 &&
2257                                         yaffsfs_inode[yh->inodeId].iObj->my_dev == dev)
2258                                         inUse = 1; /* the device is in use, can't unmount */
2259                         }
2260
2261                         if(!inUse || force){
2262                                 if(read_only)
2263                                         yaffs_checkpoint_save(dev);
2264                                 dev->read_only =  read_only ? 1 : 0;
2265                                 retVal = 0;
2266                         } else
2267                                 yaffsfs_SetError(-EBUSY);
2268
2269                 } else
2270                         yaffsfs_SetError(-EINVAL);
2271
2272         }
2273         else
2274                 yaffsfs_SetError(-ENODEV);
2275
2276         yaffsfs_Unlock();
2277         return retVal;
2278
2279 }
2280
2281 int yaffs_unmount2(const YCHAR *path, int force)
2282 {
2283         int retVal=-1;
2284         struct yaffs_dev *dev=NULL;
2285
2286         if(yaffsfs_CheckPath(path) < 0){
2287                 yaffsfs_SetError(-ENAMETOOLONG);
2288                 return -1;
2289         }
2290
2291         yaffsfs_Lock();
2292         dev = yaffsfs_FindMountPoint(path);
2293         if(dev){
2294                 if(dev->is_mounted){
2295                         int i;
2296                         int inUse;
2297
2298                         yaffs_flush_whole_cache(dev);
2299                         yaffs_checkpoint_save(dev);
2300
2301                         for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse; i++){
2302                                 if(yaffsfs_handle[i].useCount > 0 &&
2303                                 yaffsfs_inode[yaffsfs_handle[i].inodeId].iObj->my_dev == dev)
2304                                         inUse = 1; /* the device is in use, can't unmount */
2305                         }
2306
2307                         if(!inUse || force){
2308                                 if(inUse)
2309                                         yaffsfs_BreakDeviceHandles(dev);
2310                                 yaffs_deinitialise(dev);
2311
2312                                 retVal = 0;
2313                         } else
2314                                 yaffsfs_SetError(-EBUSY);
2315
2316                 } else
2317                         yaffsfs_SetError(-EINVAL);
2318
2319         } else
2320                 yaffsfs_SetError(-ENODEV);
2321
2322         yaffsfs_Unlock();
2323         return retVal;
2324
2325 }
2326
2327 int yaffs_unmount(const YCHAR *path)
2328 {
2329         return yaffs_unmount2(path,0);
2330 }
2331
2332 loff_t yaffs_freespace(const YCHAR *path)
2333 {
2334         loff_t retVal=-1;
2335         struct yaffs_dev *dev=NULL;
2336         YCHAR *dummy;
2337
2338         if(yaffsfs_CheckPath(path) < 0){
2339                 yaffsfs_SetError(-ENAMETOOLONG);
2340                 return -1;
2341         }
2342
2343         yaffsfs_Lock();
2344         dev = yaffsfs_FindDevice(path,&dummy);
2345         if(dev  && dev->is_mounted){
2346                 retVal = yaffs_get_n_free_chunks(dev);
2347                 retVal *= dev->data_bytes_per_chunk;
2348
2349         } else
2350                 yaffsfs_SetError(-EINVAL);
2351
2352         yaffsfs_Unlock();
2353         return retVal;
2354 }
2355
2356 loff_t yaffs_totalspace(const YCHAR *path)
2357 {
2358         loff_t retVal=-1;
2359         struct yaffs_dev *dev=NULL;
2360         YCHAR *dummy;
2361
2362         if(yaffsfs_CheckPath(path) < 0){
2363                 yaffsfs_SetError(-ENAMETOOLONG);
2364                 return -1;
2365         }
2366
2367         yaffsfs_Lock();
2368         dev = yaffsfs_FindDevice(path,&dummy);
2369         if(dev  && dev->is_mounted){
2370                 retVal = (dev->param.end_block - dev->param.start_block + 1) -
2371                         dev->param.n_reserved_blocks;
2372                 retVal *= dev->param.chunks_per_block;
2373                 retVal *= dev->data_bytes_per_chunk;
2374
2375         } else
2376                 yaffsfs_SetError(-EINVAL);
2377
2378         yaffsfs_Unlock();
2379         return retVal;
2380 }
2381
2382 int yaffs_inodecount(const YCHAR *path)
2383 {
2384         loff_t retVal= -1;
2385         struct yaffs_dev *dev=NULL;
2386         YCHAR *dummy;
2387
2388         if(yaffsfs_CheckPath(path) < 0){
2389                 yaffsfs_SetError(-ENAMETOOLONG);
2390                 return -1;
2391         }
2392
2393         yaffsfs_Lock();
2394         dev = yaffsfs_FindDevice(path,&dummy);
2395         if(dev  && dev->is_mounted) {
2396            int n_obj = dev->n_obj;
2397            if(n_obj > dev->n_hardlinks)
2398                 retVal = n_obj - dev->n_hardlinks;
2399         }
2400
2401         if(retVal < 0)
2402                 yaffsfs_SetError(-EINVAL);
2403
2404         yaffsfs_Unlock();
2405         return retVal;
2406 }
2407
2408
2409 void yaffs_add_device(struct yaffs_dev *dev)
2410 {
2411         dev->is_mounted = 0;
2412         dev->param.remove_obj_fn = yaffsfs_RemoveObjectCallback;
2413
2414         if(!dev->dev_list.next)
2415                 INIT_LIST_HEAD(&dev->dev_list);
2416
2417         list_add(&dev->dev_list,&yaffsfs_deviceList);
2418 }
2419
2420 void yaffs_remove_device(struct yaffs_dev *dev)
2421 {
2422         list_del_init(&dev->dev_list);
2423 }
2424
2425
2426
2427
2428 /* Directory search stuff. */
2429
2430 /*
2431  * Directory search context
2432  *
2433  * NB this is an opaque structure.
2434  */
2435
2436
2437 typedef struct
2438 {
2439         u32 magic;
2440         yaffs_dirent de;                /* directory entry being used by this dsc */
2441         YCHAR name[NAME_MAX+1];         /* name of directory being searched */
2442         struct yaffs_obj *dirObj;           /* ptr to directory being searched */
2443         struct yaffs_obj *nextReturn;       /* obj to be returned by next readddir */
2444         int offset;
2445         struct list_head others;
2446 } yaffsfs_DirectorySearchContext;
2447
2448
2449
2450 static struct list_head search_contexts;
2451
2452
2453 static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)
2454 {
2455         if(dsc &&
2456            dsc->dirObj &&
2457            dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
2458
2459            dsc->offset = 0;
2460
2461            if( list_empty(&dsc->dirObj->variant.dir_variant.children))
2462                 dsc->nextReturn = NULL;
2463            else
2464                 dsc->nextReturn = list_entry(dsc->dirObj->variant.dir_variant.children.next,
2465                                                 struct yaffs_obj,siblings);
2466         } else {
2467                 /* Hey someone isn't playing nice! */
2468         }
2469 }
2470
2471 static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc)
2472 {
2473         if(dsc &&
2474            dsc->dirObj &&
2475            dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){
2476
2477            if( dsc->nextReturn == NULL ||
2478                list_empty(&dsc->dirObj->variant.dir_variant.children))
2479                 dsc->nextReturn = NULL;
2480            else {
2481                    struct list_head *next = dsc->nextReturn->siblings.next;
2482
2483                    if( next == &dsc->dirObj->variant.dir_variant.children)
2484                         dsc->nextReturn = NULL; /* end of list */
2485                    else
2486                         dsc->nextReturn = list_entry(next,struct yaffs_obj,siblings);
2487            }
2488         } else {
2489                 /* Hey someone isn't playing nice! */
2490         }
2491 }
2492
2493 static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj)
2494 {
2495
2496         struct list_head *i;
2497         yaffsfs_DirectorySearchContext *dsc;
2498
2499         /* if search contexts not initilised then skip */
2500         if(!search_contexts.next)
2501                 return;
2502
2503         /* Iterate through the directory search contexts.
2504          * If any are the one being removed, then advance the dsc to
2505          * the next one to prevent a hanging ptr.
2506          */
2507          list_for_each(i, &search_contexts) {
2508                 if (i) {
2509                         dsc = list_entry(i, yaffsfs_DirectorySearchContext,others);
2510                         if(dsc->nextReturn == obj)
2511                                 yaffsfs_DirAdvance(dsc);
2512                 }
2513         }
2514
2515 }
2516
2517 yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
2518 {
2519         yaffs_DIR *dir = NULL;
2520         struct yaffs_obj *obj = NULL;
2521         yaffsfs_DirectorySearchContext *dsc = NULL;
2522         int notDir = 0;
2523         int loop = 0;
2524
2525         if(yaffsfs_CheckPath(dirname) < 0){
2526                 yaffsfs_SetError(-ENAMETOOLONG);
2527                 return NULL;
2528         }
2529
2530         yaffsfs_Lock();
2531
2532         obj = yaffsfs_FindObject(NULL,dirname,0,1,NULL,&notDir,&loop);
2533
2534         if(!obj && notDir)
2535                 yaffsfs_SetError(-ENOTDIR);
2536         else if(loop)
2537                 yaffsfs_SetError(-ELOOP);
2538         else if(!obj)
2539                 yaffsfs_SetError(-ENOENT);
2540         else if(obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
2541                 yaffsfs_SetError(-ENOTDIR);
2542         else {
2543
2544                 dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext));
2545                 dir = (yaffs_DIR *)dsc;
2546
2547                 if(dsc){
2548                         memset(dsc,0,sizeof(yaffsfs_DirectorySearchContext));
2549                         dsc->magic = YAFFS_MAGIC;
2550                         dsc->dirObj = obj;
2551                         yaffs_strncpy(dsc->name,dirname,NAME_MAX);
2552                         INIT_LIST_HEAD(&dsc->others);
2553
2554                         if(!search_contexts.next)
2555                                 INIT_LIST_HEAD(&search_contexts);
2556
2557                         list_add(&dsc->others,&search_contexts);
2558                         yaffsfs_SetDirRewound(dsc);
2559                 }
2560
2561         }
2562
2563         yaffsfs_Unlock();
2564
2565         return dir;
2566 }
2567
2568 struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
2569 {
2570         yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
2571         struct yaffs_dirent *retVal = NULL;
2572
2573         yaffsfs_Lock();
2574
2575         if(dsc && dsc->magic == YAFFS_MAGIC){
2576                 yaffsfs_SetError(0);
2577                 if(dsc->nextReturn){
2578                         dsc->de.d_ino = yaffs_get_equivalent_obj(dsc->nextReturn)->obj_id;
2579                         dsc->de.d_dont_use = (unsigned)dsc->nextReturn;
2580                         dsc->de.d_off = dsc->offset++;
2581                         yaffs_get_obj_name(dsc->nextReturn,dsc->de.d_name,NAME_MAX);
2582                         if(yaffs_strnlen(dsc->de.d_name,NAME_MAX+1) == 0)
2583                         {
2584                                 /* this should not happen! */
2585                                 yaffs_strcpy(dsc->de.d_name,_Y("zz"));
2586                         }
2587                         dsc->de.d_reclen = sizeof(struct yaffs_dirent);
2588                         retVal = &dsc->de;
2589                         yaffsfs_DirAdvance(dsc);
2590                 } else
2591                         retVal = NULL;
2592         } else
2593                 yaffsfs_SetError(-EBADF);
2594
2595         yaffsfs_Unlock();
2596
2597         return retVal;
2598
2599 }
2600
2601
2602 void yaffs_rewinddir(yaffs_DIR *dirp)
2603 {
2604         yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
2605
2606         yaffsfs_Lock();
2607
2608         yaffsfs_SetDirRewound(dsc);
2609
2610         yaffsfs_Unlock();
2611 }
2612
2613
2614 int yaffs_closedir(yaffs_DIR *dirp)
2615 {
2616         yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp;
2617
2618         yaffsfs_Lock();
2619         dsc->magic = 0;
2620         list_del(&dsc->others); /* unhook from list */
2621         YFREE(dsc);
2622         yaffsfs_Unlock();
2623         return 0;
2624 }
2625
2626 /* End of directory stuff */
2627
2628
2629 int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
2630 {
2631         struct yaffs_obj *parent = NULL;
2632         struct yaffs_obj *obj;
2633         YCHAR *name;
2634         int retVal= -1;
2635         int mode = 0; /* ignore for now */
2636         int notDir = 0;
2637         int loop = 0;
2638
2639         if(yaffsfs_CheckPath(newpath) < 0){
2640                 yaffsfs_SetError(-ENAMETOOLONG);
2641                 return -1;
2642         }
2643         yaffsfs_Lock();
2644         parent = yaffsfs_FindDirectory(NULL,newpath,&name,0,&notDir,&loop);
2645         if(!parent && notDir)
2646                 yaffsfs_SetError(-ENOTDIR);
2647         else if(loop)
2648                 yaffsfs_SetError(-ELOOP);
2649         else if( !parent || yaffs_strnlen(name,5) < 1)
2650                 yaffsfs_SetError(-ENOENT);
2651         else if(parent->my_dev->read_only)
2652                 yaffsfs_SetError(-EROFS);
2653         else if(parent){
2654                 obj = yaffs_create_symlink(parent,name,mode,0,0,oldpath);
2655                 if(obj)
2656                         retVal = 0;
2657                 else if (yaffsfs_FindObject(NULL,newpath,0,0, NULL,NULL,NULL))
2658                         yaffsfs_SetError(-EEXIST);
2659                 else
2660                         yaffsfs_SetError(-ENOSPC);
2661         }
2662
2663         yaffsfs_Unlock();
2664
2665         return retVal;
2666
2667 }
2668
2669 int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
2670 {
2671         struct yaffs_obj *obj = NULL;
2672         struct yaffs_obj *dir = NULL;
2673         int retVal= -1;
2674         int notDir = 0;
2675         int loop = 0;
2676
2677         yaffsfs_Lock();
2678
2679         obj = yaffsfs_FindObject(NULL,path,0,1, &dir,&notDir,&loop);
2680
2681         if(!dir && notDir)
2682                 yaffsfs_SetError(-ENOTDIR);
2683         else if(loop)
2684                 yaffsfs_SetError(-ELOOP);
2685         else if(!dir || !obj)
2686                 yaffsfs_SetError(-ENOENT);
2687         else if(obj->variant_type != YAFFS_OBJECT_TYPE_SYMLINK)
2688                 yaffsfs_SetError(-EINVAL);
2689         else {
2690                 YCHAR *alias = obj->variant.symlink_variant.alias;
2691                 memset(buf,0,bufsiz);
2692                 yaffs_strncpy(buf,alias,bufsiz - 1);
2693                 retVal = 0;
2694         }
2695         yaffsfs_Unlock();
2696         return retVal;
2697 }
2698
2699 int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
2700 {
2701         /* Creates a link called newpath to existing oldpath */
2702         struct yaffs_obj *obj = NULL;
2703         struct yaffs_obj *lnk = NULL;
2704         struct yaffs_obj *obj_dir = NULL;
2705         struct yaffs_obj *lnk_dir = NULL;
2706         int retVal = -1;
2707         int notDirObj = 0;
2708         int notDirLnk = 0;
2709         int objLoop = 0;
2710         int lnkLoop = 0;
2711         YCHAR *newname;
2712
2713         if(yaffsfs_CheckPath(linkpath) < 0){
2714                 yaffsfs_SetError(-ENAMETOOLONG);
2715                 return -1;
2716         }
2717
2718         yaffsfs_Lock();
2719
2720         obj = yaffsfs_FindObject(NULL,oldpath,0,1,&obj_dir,&notDirObj,&objLoop);
2721         lnk = yaffsfs_FindObject(NULL,linkpath,0,0,NULL,NULL,NULL);
2722         lnk_dir = yaffsfs_FindDirectory(NULL,linkpath,&newname,0,&notDirLnk,&lnkLoop);
2723
2724         if((!obj_dir && notDirObj) || (!lnk_dir && notDirLnk))
2725                 yaffsfs_SetError(-ENOTDIR);
2726         else if(objLoop || lnkLoop)
2727                 yaffsfs_SetError(-ELOOP);
2728         else if(!obj_dir || !lnk_dir || !obj)
2729                 yaffsfs_SetError(-ENOENT);
2730         else if(obj->my_dev->read_only)
2731                 yaffsfs_SetError(-EROFS);
2732         else if(lnk)
2733                 yaffsfs_SetError(-EEXIST);
2734         else if(lnk_dir->my_dev != obj->my_dev)
2735                 yaffsfs_SetError(-EXDEV);
2736         else {
2737                 retVal = yaffsfs_CheckNameLength(newname);
2738
2739                 if(retVal == 0) {
2740                         lnk = yaffs_link_obj(lnk_dir,newname,obj);
2741                         if(lnk)
2742                                 retVal = 0;
2743                         else{
2744                                 yaffsfs_SetError(-ENOSPC);
2745                                 retVal = -1;
2746                         }
2747                 }
2748         }
2749         yaffsfs_Unlock();
2750
2751         return retVal;
2752 }
2753
2754 int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
2755 {
2756         pathname=pathname;
2757         mode=mode;
2758         dev=dev;
2759
2760         yaffsfs_SetError(-EINVAL);
2761         return -1;
2762 }
2763
2764
2765 /*
2766  * D E B U G   F U N C T I O N S
2767  */
2768
2769 /*
2770  * yaffs_n_handles()
2771  * Returns number of handles attached to the object
2772  */
2773 int yaffs_n_handles(const YCHAR *path)
2774 {
2775         struct yaffs_obj *obj;
2776
2777         if(yaffsfs_CheckPath(path) < 0){
2778                 yaffsfs_SetError(-ENAMETOOLONG);
2779                 return -1;
2780         }
2781
2782         obj = yaffsfs_FindObject(NULL,path,0,1,NULL,NULL,NULL);
2783
2784         if(obj)
2785                 return yaffsfs_CountHandles(obj);
2786         else
2787                 return -1;
2788 }
2789
2790 int yaffs_get_error(void)
2791 {
2792         return yaffsfs_GetLastError();
2793 }
2794
2795 int yaffs_set_error(int error)
2796 {
2797         yaffsfs_SetError(error);
2798         return 0;
2799 }
2800
2801 int yaffs_dump_dev(const YCHAR *path)
2802 {
2803 #if 1
2804         path=path;
2805 #else
2806         YCHAR *rest;
2807
2808         struct yaffs_obj *obj = yaffsfs_FindRoot(path,&rest);
2809
2810         if(obj){
2811                 struct yaffs_dev *dev = obj->my_dev;
2812
2813                 printf("\n"
2814                            "n_page_writes.......... %d\n"
2815                            "n_page_reads........... %d\n"
2816                            "n_erasures....... %d\n"
2817                            "n_gc_copies............ %d\n"
2818                            "garbageCollections... %d\n"
2819                            "passiveGarbageColl'ns %d\n"
2820                            "\n",
2821                                 dev->n_page_writes,
2822                                 dev->n_page_reads,
2823                                 dev->n_erasures,
2824                                 dev->n_gc_copies,
2825                                 dev->garbageCollections,
2826                                 dev->passiveGarbageCollections
2827                 );
2828
2829         }
2830
2831 #endif
2832         return 0;
2833 }
2834