direct/yaffsfs.c

   1 /*
   2  * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
   3  *
   4  * Copyright (C) 2002-2011 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"
  21
  22 #define YAFFSFS_MAX_SYMLINK_DEREFERENCES 5
  23
  24 #ifndef NULL
  25 #define NULL ((void *)0)
  26 #endif
  27
  28 #define ROOT_DIR(dev) (((dev) && (dev)->is_mounted) ? (dev)->root_dir : NULL)
  29
  30 /* YAFFSFS_RW_SIZE must be a power of 2 */
  31 #define YAFFSFS_RW_SHIFT (13)
  32 #define YAFFSFS_RW_SIZE  (1<<YAFFSFS_RW_SHIFT)
  33
  34 /* Some forward references */
  35 static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory,
  36                                             const YCHAR *path,
  37                                             int symDepth, int getEquiv,
  38                                             struct yaffs_obj **dirOut,
  39                                             int *notDir, int *loop);
  40
  41 static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj);
  42 static yaffs_DIR *yaffsfs_opendir_reldir_no_lock(
  43                                 struct yaffs_obj *reldir, const YCHAR *dirname);
  44 static int yaffsfs_closedir_no_lock(yaffs_DIR *dirent);
  45
  46 unsigned int yaffs_wr_attempts;
  47
  48 /*
  49  * Handle management.
  50  * There are open inodes in struct yaffsfs_Inode.
  51  * There are open file descriptors in yaffsfs_FileDes.
  52  * There are open handles in yaffsfs_FileDes.
  53  *
  54  * Things are structured this way to be like the Linux VFS model
  55  * so that interactions with the yaffs guts calls are similar.
  56  * That means more common code paths and less special code.
  57  * That means better testing etc.
  58  *
  59  * We have 3 layers because:
  60  * A handle is different than an fd because you can use dup()
  61  * to create a new handle that accesses the *same* fd. The two
  62  * handles will use the same offset (part of the fd). We only close
  63  * down the fd when there are no more handles accessing it.
  64  *
  65  * More than one fd can currently access one file, but each fd
  66  * has its own permsiions and offset.
  67  */
  68
  69 struct yaffsfs_Inode {
  70         int count;              /* Number of handles accessing this inode */
  71         struct yaffs_obj *iObj;
  72 };
  73
  74
  75 struct yaffsfs_DirSearchContext {
  76         struct yaffs_dirent de; /* directory entry */
  77         YCHAR name[NAME_MAX + 1];       /* name of directory being searched */
  78         struct yaffs_obj *dirObj;       /* ptr to directory being searched */
  79         struct yaffs_obj *nextReturn;   /* obj  returned by next readddir */
  80         struct list_head others;
  81         s32 offset:20;
  82         u8 inUse:1;
  83 };
  84
  85 struct yaffsfs_FileDes {
  86         u8 isDir:1;             /* This s a directory */
  87         u8 reading:1;
  88         u8 writing:1;
  89         u8 append:1;
  90         u8 shareRead:1;
  91         u8 shareWrite:1;
  92         s32 inodeId:12;         /* Index to corresponding yaffsfs_Inode */
  93         s32 handleCount:10;     /* Number of handles for this fd */
  94         union {
  95                 Y_LOFF_T position;      /* current position in file */
  96                 yaffs_DIR *dir;
  97         } v;
  98 };
  99
 100 struct yaffsfs_Handle {
 101         short int fdId;
 102         short int useCount;
 103 };
 104
 105
 106 static struct yaffsfs_DirSearchContext yaffsfs_dsc[YAFFSFS_N_DSC];
 107 static struct yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
 108 static struct yaffsfs_FileDes yaffsfs_fd[YAFFSFS_N_HANDLES];
 109 static struct yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
 110
 111 static int yaffsfs_handlesInitialised;
 112
 113 unsigned yaffs_set_trace(unsigned tm)
 114 {
 115         yaffs_trace_mask = tm;
 116         return yaffs_trace_mask;
 117 }
 118
 119 unsigned yaffs_get_trace(void)
 120 {
 121         return yaffs_trace_mask;
 122 }
 123
 124 /*
 125  * yaffsfs_InitHandle
 126  * Inilitalise handle management on start-up.
 127  */
 128
 129 static void yaffsfs_InitHandles(void)
 130 {
 131         int i;
 132
 133         if (yaffsfs_handlesInitialised)
 134                 return;
 135
 136         yaffsfs_handlesInitialised = 1;
 137
 138         memset(yaffsfs_inode, 0, sizeof(yaffsfs_inode));
 139         memset(yaffsfs_fd, 0, sizeof(yaffsfs_fd));
 140         memset(yaffsfs_handle, 0, sizeof(yaffsfs_handle));
 141         memset(yaffsfs_dsc, 0, sizeof(yaffsfs_dsc));
 142
 143         for (i = 0; i < YAFFSFS_N_HANDLES; i++)
 144                 yaffsfs_fd[i].inodeId = -1;
 145         for (i = 0; i < YAFFSFS_N_HANDLES; i++)
 146                 yaffsfs_handle[i].fdId = -1;
 147 }
 148
 149 static struct yaffsfs_Handle *yaffsfs_HandleToPointer(int h)
 150 {
 151         if (h >= 0 && h < YAFFSFS_N_HANDLES)
 152                 return &yaffsfs_handle[h];
 153         return NULL;
 154 }
 155
 156 static struct yaffsfs_FileDes *yaffsfs_HandleToFileDes(int handle)
 157 {
 158         struct yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
 159
 160         if (h && h->useCount > 0 && h->fdId >= 0 && h->fdId < YAFFSFS_N_HANDLES)
 161                 return &yaffsfs_fd[h->fdId];
 162
 163         return NULL;
 164 }
 165
 166 static struct yaffsfs_Inode *yaffsfs_HandleToInode(int handle)
 167 {
 168         struct yaffsfs_FileDes *fd = yaffsfs_HandleToFileDes(handle);
 169
 170         if (fd && fd->handleCount > 0 &&
 171             fd->inodeId >= 0 && fd->inodeId < YAFFSFS_N_HANDLES)
 172                 return &yaffsfs_inode[fd->inodeId];
 173
 174         return NULL;
 175 }
 176
 177 static struct yaffs_obj *yaffsfs_HandleToObject(int handle)
 178 {
 179         struct yaffsfs_Inode *in = yaffsfs_HandleToInode(handle);
 180
 181         if (in)
 182                 return in->iObj;
 183
 184         return NULL;
 185 }
 186
 187 /*
 188  * yaffsfs_FindInodeIdForObject
 189  * Find the inode entry for an object, if it exists.
 190  */
 191
 192 static int yaffsfs_FindInodeIdForObject(struct yaffs_obj *obj)
 193 {
 194         int i;
 195         int ret = -1;
 196
 197         if (obj)
 198                 obj = yaffs_get_equivalent_obj(obj);
 199
 200         /* Look for it in open inode table */
 201         for (i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++) {
 202                 if (yaffsfs_inode[i].iObj == obj)
 203                         ret = i;
 204         }
 205         return ret;
 206 }
 207
 208 /*
 209  * yaffsfs_GetInodeIdForObject
 210  * Grab an inode entry when opening a new inode.
 211  */
 212 static int yaffsfs_GetInodeIdForObject(struct yaffs_obj *obj)
 213 {
 214         int i;
 215         int ret;
 216         struct yaffsfs_Inode *in = NULL;
 217
 218         if (obj)
 219                 obj = yaffs_get_equivalent_obj(obj);
 220
 221         ret = yaffsfs_FindInodeIdForObject(obj);
 222
 223         for (i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++) {
 224                 if (!yaffsfs_inode[i].iObj)
 225                         ret = i;
 226         }
 227
 228         if (ret >= 0) {
 229                 in = &yaffsfs_inode[ret];
 230                 if (!in->iObj)
 231                         in->count = 0;
 232                 in->iObj = obj;
 233                 in->count++;
 234         }
 235
 236         return ret;
 237 }
 238
 239 static int yaffsfs_CountHandles(struct yaffs_obj *obj)
 240 {
 241         int i = yaffsfs_FindInodeIdForObject(obj);
 242
 243         if (i >= 0)
 244                 return yaffsfs_inode[i].count;
 245         else
 246                 return 0;
 247 }
 248
 249 static void yaffsfs_ReleaseInode(struct yaffsfs_Inode *in)
 250 {
 251         struct yaffs_obj *obj;
 252
 253         obj = in->iObj;
 254         obj->my_inode = NULL;
 255         in->iObj = NULL;
 256
 257         if (obj->unlinked)
 258                 yaffs_del_obj(obj);
 259 }
 260
 261 static void yaffsfs_PutInode(int inodeId)
 262 {
 263         if (inodeId >= 0 && inodeId < YAFFSFS_N_HANDLES) {
 264                 struct yaffsfs_Inode *in = &yaffsfs_inode[inodeId];
 265                 in->count--;
 266                 if (in->count <= 0) {
 267                         yaffsfs_ReleaseInode(in);
 268                         in->count = 0;
 269                 }
 270         }
 271 }
 272
 273 static int yaffsfs_NewHandle(struct yaffsfs_Handle **hptr)
 274 {
 275         int i;
 276         struct yaffsfs_Handle *h;
 277
 278         for (i = 0; i < YAFFSFS_N_HANDLES; i++) {
 279                 h = &yaffsfs_handle[i];
 280                 if (h->useCount < 1) {
 281                         memset(h, 0, sizeof(struct yaffsfs_Handle));
 282                         h->fdId = -1;
 283                         h->useCount = 1;
 284                         if (hptr)
 285                                 *hptr = h;
 286                         return i;
 287                 }
 288         }
 289         return -1;
 290 }
 291
 292 static int yaffsfs_NewHandleAndFileDes(void)
 293 {
 294         int i;
 295         struct yaffsfs_FileDes *fd;
 296         struct yaffsfs_Handle *h = NULL;
 297         int handle = yaffsfs_NewHandle(&h);
 298
 299         if (handle < 0)
 300                 return -1;
 301
 302         for (i = 0; i < YAFFSFS_N_HANDLES; i++) {
 303                 fd = &yaffsfs_fd[i];
 304                 if (fd->handleCount < 1) {
 305                         memset(fd, 0, sizeof(struct yaffsfs_FileDes));
 306                         fd->inodeId = -1;
 307                         fd->handleCount = 1;
 308                         h->fdId = i;
 309                         return handle;
 310                 }
 311         }
 312
 313         /* Dump the handle because we could not get a fd */
 314         h->useCount = 0;
 315         return -1;
 316 }
 317
 318 /*
 319  * yaffs_get_handle
 320  * Increase use of handle when reading/writing a file
 321  * Also gets the file descriptor.
 322  */
 323
 324 static int yaffsfs_GetHandle(int handle)
 325 {
 326         struct yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
 327
 328         if (h && h->useCount > 0) {
 329                 h->useCount++;
 330                 return 0;
 331         }
 332         return -1;
 333 }
 334
 335 /*
 336  * yaffs_put_handle
 337  * Let go of a handle when closing a file or aborting an open or
 338  * ending a read or write.
 339  */
 340
 341 static int yaffsfs_PutFileDes(int fdId)
 342 {
 343         struct yaffsfs_FileDes *fd;
 344
 345         if (fdId >= 0 && fdId < YAFFSFS_N_HANDLES) {
 346                 fd = &yaffsfs_fd[fdId];
 347                 fd->handleCount--;
 348                 if (fd->handleCount < 1) {
 349                         if (fd->isDir)
 350                                 yaffsfs_closedir_no_lock(fd->v.dir);
 351                         if (fd->inodeId >= 0) {
 352                                 yaffsfs_PutInode(fd->inodeId);
 353                                 fd->inodeId = -1;
 354                         }
 355                 }
 356         }
 357         return 0;
 358 }
 359
 360 static int yaffsfs_PutHandle(int handle)
 361 {
 362         struct yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle);
 363
 364         if (h && h->useCount > 0) {
 365                 h->useCount--;
 366                 if (h->useCount < 1) {
 367                         yaffsfs_PutFileDes(h->fdId);
 368                         h->fdId = -1;
 369                 }
 370         }
 371
 372         return 0;
 373 }
 374
 375 static void yaffsfs_BreakDeviceHandles(struct yaffs_dev *dev)
 376 {
 377         struct yaffsfs_FileDes *fd;
 378         struct yaffsfs_Handle *h;
 379         struct yaffs_obj *obj;
 380         int i;
 381         for (i = 0; i < YAFFSFS_N_HANDLES; i++) {
 382                 h = yaffsfs_HandleToPointer(i);
 383                 fd = yaffsfs_HandleToFileDes(i);
 384                 obj = yaffsfs_HandleToObject(i);
 385                 if (h && h->useCount > 0) {
 386                         h->useCount = 0;
 387                         h->fdId = 0;
 388                 }
 389                 if (fd && fd->handleCount > 0 && obj && obj->my_dev == dev) {
 390                         fd->handleCount = 0;
 391                         yaffsfs_PutInode(fd->inodeId);
 392                         fd->inodeId = -1;
 393                 }
 394         }
 395 }
 396
 397 /*
 398  *  Stuff to handle names.
 399  */
 400 #ifdef CONFIG_YAFFS_CASE_INSENSITIVE
 401 #ifndef CONFIG_YAFFS_WINCE
 402 static int yaffs_toupper(YCHAR a)
 403 {
 404         if (a >= 'a' && a <= 'z')
 405                 return (a - 'a') + 'A';
 406         else
 407                 return a;
 408 }
 409 #endif
 410
 411 static int yaffsfs_Match(YCHAR a, YCHAR b)
 412 {
 413         return (yaffs_toupper(a) == yaffs_toupper(b));
 414 }
 415 #else
 416 static int yaffsfs_Match(YCHAR a, YCHAR b)
 417 {
 418         /* case sensitive */
 419         return (a == b);
 420 }
 421 #endif
 422
 423 static int yaffsfs_IsPathDivider(YCHAR ch)
 424 {
 425         const YCHAR *str = YAFFS_PATH_DIVIDERS;
 426
 427         while (*str) {
 428                 if (*str == ch)
 429                         return 1;
 430                 str++;
 431         }
 432
 433         return 0;
 434 }
 435
 436 static int yaffsfs_CheckNameLength(const YCHAR *name)
 437 {
 438         int retVal = 0;
 439
 440         int nameLength = yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH + 1);
 441
 442         if (nameLength == 0) {
 443                 yaffsfs_SetError(-ENOENT);
 444                 retVal = -1;
 445         } else if (nameLength > YAFFS_MAX_NAME_LENGTH) {
 446                 yaffsfs_SetError(-ENAMETOOLONG);
 447                 retVal = -1;
 448         }
 449
 450         return retVal;
 451 }
 452
 453 static int yaffsfs_alt_dir_path(const YCHAR *path, YCHAR **ret_path)
 454 {
 455         YCHAR *alt_path = NULL;
 456         int path_length;
 457         int i;
 458
 459         /*
 460          * We don't have a definition for max path length.
 461          * We will use 3 * max name length instead.
 462          */
 463         *ret_path = NULL;
 464         path_length = yaffs_strnlen(path, (YAFFS_MAX_NAME_LENGTH + 1) * 3 + 1);
 465
 466         /* If the last character is a path divider, then we need to
 467          * trim it back so that the name look-up works properly.
 468          * eg. /foo/new_dir/ -> /foo/newdir
 469          * Curveball: Need to handle multiple path dividers:
 470          * eg. /foof/sdfse///// -> /foo/sdfse
 471          */
 472         if (path_length > 0 && yaffsfs_IsPathDivider(path[path_length - 1])) {
 473                 alt_path = kmalloc(path_length + 1, 0);
 474                 if (!alt_path)
 475                         return -1;
 476                 yaffs_strcpy(alt_path, path);
 477                 for (i = path_length - 1;
 478                      i >= 0 && yaffsfs_IsPathDivider(alt_path[i]); i--)
 479                         alt_path[i] = (YCHAR) 0;
 480         }
 481         *ret_path = alt_path;
 482         return 0;
 483 }
 484
 485 LIST_HEAD(yaffsfs_deviceList);
 486
 487 /*
 488  * yaffsfs_FindDevice
 489  * yaffsfs_FindRoot
 490  * Scan the configuration list to find the device
 491  * Curveballs: Should match paths that end in '/' too
 492  * Curveball2 Might have "/x/ and "/x/y". Need to return the longest match
 493  */
 494 static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path,
 495                                             YCHAR **restOfPath)
 496 {
 497         struct list_head *cfg;
 498         const YCHAR *leftOver;
 499         const YCHAR *p;
 500         struct yaffs_dev *retval = NULL;
 501         struct yaffs_dev *dev = NULL;
 502         int thisMatchLength;
 503         int longestMatch = -1;
 504         int matching;
 505
 506         /*
 507          * Check all configs, choose the one that:
 508          * 1) Actually matches a prefix (ie /a amd /abc will not match
 509          * 2) Matches the longest.
 510          */
 511         list_for_each(cfg, &yaffsfs_deviceList) {
 512                 dev = list_entry(cfg, struct yaffs_dev, dev_list);
 513                 leftOver = path;
 514                 p = dev->param.name;
 515                 thisMatchLength = 0;
 516                 matching = 1;
 517
 518                 if(!p)
 519                         continue;
 520
 521                 while (matching && *p && *leftOver) {
 522                         /* Skip over any /s */
 523                         while (yaffsfs_IsPathDivider(*p))
 524                                 p++;
 525
 526                         /* Skip over any /s */
 527                         while (yaffsfs_IsPathDivider(*leftOver))
 528                                 leftOver++;
 529
 530                         /* Now match the text part */
 531                         while (matching &&
 532                                *p && !yaffsfs_IsPathDivider(*p) &&
 533                                *leftOver && !yaffsfs_IsPathDivider(*leftOver)) {
 534                                 if (yaffsfs_Match(*p, *leftOver)) {
 535                                         p++;
 536                                         leftOver++;
 537                                         thisMatchLength++;
 538                                 } else {
 539                                         matching = 0;
 540                                 }
 541                         }
 542                 }
 543
 544                 /* Skip over any /s in leftOver */
 545                 while (yaffsfs_IsPathDivider(*leftOver))
 546                         leftOver++;
 547
 548                 /*Skip over any /s in p */
 549                 while (yaffsfs_IsPathDivider(*p))
 550                         p++;
 551
 552                 /* p should now be at the end of the string if fully matched */
 553                 if (*p)
 554                         matching = 0;
 555
 556                 if (matching && (thisMatchLength > longestMatch)) {
 557                         /* Matched prefix */
 558                         *restOfPath = (YCHAR *) leftOver;
 559                         retval = dev;
 560                         longestMatch = thisMatchLength;
 561                 }
 562
 563         }
 564         return retval;
 565 }
 566
 567 static int yaffsfs_CheckPath(const YCHAR *path)
 568 {
 569         int n = 0;
 570         int divs = 0;
 571
 572         while (*path && n < YAFFS_MAX_NAME_LENGTH && divs < 100) {
 573                 if (yaffsfs_IsPathDivider(*path)) {
 574                         n = 0;
 575                         divs++;
 576                 } else
 577                         n++;
 578                 path++;
 579         }
 580
 581         return (*path) ? -1 : 0;
 582 }
 583
 584 /* FindMountPoint only returns a dev entry if the path is a mount point */
 585 static struct yaffs_dev *yaffsfs_FindMountPoint(const YCHAR *path)
 586 {
 587         struct yaffs_dev *dev;
 588         YCHAR *restOfPath = NULL;
 589
 590         dev = yaffsfs_FindDevice(path, &restOfPath);
 591         if (dev && restOfPath && *restOfPath)
 592                 dev = NULL;
 593         return dev;
 594 }
 595
 596 static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path,
 597                                           YCHAR **restOfPath)
 598 {
 599         struct yaffs_dev *dev;
 600
 601         dev = yaffsfs_FindDevice(path, restOfPath);
 602         if (dev && dev->is_mounted)
 603                 return dev->root_dir;
 604
 605         return NULL;
 606 }
 607
 608 static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,
 609                                             int symDepth, int *loop)
 610 {
 611
 612         if (obj)
 613                 obj = yaffs_get_equivalent_obj(obj);
 614
 615         while (obj && obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) {
 616                 YCHAR *alias = obj->variant.symlink_variant.alias;
 617
 618                 if (yaffsfs_IsPathDivider(*alias))
 619                         /*
 620                          * Starts with a /, need to scan from root up */
 621                         /* NB Might not work if this is called with root != NULL
 622                         */
 623                         obj = yaffsfs_FindObject(NULL, alias, symDepth++,
 624                                                  1, NULL, NULL, loop);
 625                 else
 626                         /*
 627                          * Relative to here so use the parent of the
 628                          * symlink as a start
 629                          */
 630                         obj = yaffsfs_FindObject(obj->parent, alias, symDepth++,
 631                                                  1, NULL, NULL, loop);
 632         }
 633         return obj;
 634 }
 635
 636 /*
 637  * yaffsfs_FindDirectory
 638  * Parse a path to determine the directory and the name within the directory.
 639  *
 640  * eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx"
 641  */
 642 static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir,
 643                                                  const YCHAR *path,
 644                                                  YCHAR **name, int symDepth,
 645                                                  int *notDir, int *loop)
 646 {
 647         struct yaffs_obj *dir;
 648         YCHAR *restOfPath;
 649         YCHAR str[YAFFS_MAX_NAME_LENGTH + 1];
 650         int i;
 651
 652         if (symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES) {
 653                 if (loop)
 654                         *loop = 1;
 655                 return NULL;
 656         }
 657
 658         if (startDir) {
 659                 dir = startDir;
 660                 restOfPath = (YCHAR *) path;
 661         } else
 662                 dir = yaffsfs_FindRoot(path, &restOfPath);
 663
 664         while (dir) {
 665                 /*
 666                  * parse off /.
 667                  * curve ball: also throw away surplus '/'
 668                  * eg. "/ram/x////ff" gets treated the same as "/ram/x/ff"
 669                  */
 670                 while (yaffsfs_IsPathDivider(*restOfPath))
 671                         restOfPath++;   /* get rid of '/' */
 672
 673                 *name = restOfPath;
 674                 i = 0;
 675
 676                 while (*restOfPath && !yaffsfs_IsPathDivider(*restOfPath)) {
 677                         if (i < YAFFS_MAX_NAME_LENGTH) {
 678                                 str[i] = *restOfPath;
 679                                 str[i + 1] = '\0';
 680                                 i++;
 681                         }
 682                         restOfPath++;
 683                 }
 684
 685                 if (!*restOfPath)
 686                         /* got to the end of the string */
 687                         return dir;
 688                 else {
 689                         if (yaffs_strcmp(str, _Y(".")) == 0) {
 690                                 /* Do nothing */
 691                         } else if (yaffs_strcmp(str, _Y("..")) == 0) {
 692                                 dir = dir->parent;
 693                         } else {
 694                                 dir = yaffs_find_by_name(dir, str);
 695
 696                                 dir = yaffsfs_FollowLink(dir, symDepth, loop);
 697
 698                                 if (dir && dir->variant_type !=
 699                                     YAFFS_OBJECT_TYPE_DIRECTORY) {
 700                                         if (notDir)
 701                                                 *notDir = 1;
 702                                         dir = NULL;
 703                                 }
 704
 705                         }
 706                 }
 707         }
 708         /* directory did not exist. */
 709         return NULL;
 710 }
 711
 712 static struct yaffs_obj *yaffsfs_FindDirectory(struct yaffs_obj *relDir,
 713                                                const YCHAR *path,
 714                                                YCHAR **name,
 715                                                int symDepth,
 716                                                int *notDir, int *loop)
 717 {
 718         return yaffsfs_DoFindDirectory(relDir, path, name, symDepth, notDir,
 719                                                 loop);
 720 }
 721
 722 /*
 723  * yaffsfs_FindObject turns a path for an existing object into the object
 724  */
 725 static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relDir,
 726                                             const YCHAR *path, int symDepth,
 727                                             int getEquiv,
 728                                             struct yaffs_obj **dirOut,
 729                                             int *notDir, int *loop)
 730 {
 731         struct yaffs_obj *dir;
 732         struct yaffs_obj *obj;
 733         YCHAR *name;
 734
 735         dir =
 736             yaffsfs_FindDirectory(relDir, path, &name, symDepth, notDir, loop);
 737
 738         if (dirOut)
 739                 *dirOut = dir;
 740
 741         if (dir && *name)
 742                 obj = yaffs_find_by_name(dir, name);
 743         else
 744                 obj = dir;
 745
 746         if (getEquiv)
 747                 obj = yaffs_get_equivalent_obj(obj);
 748
 749         return obj;
 750 }
 751
 752 /*************************************************************************
 753  *      Start of yaffsfs visible functions.
 754  *************************************************************************/
 755
 756 int yaffs_dup(int handle)
 757 {
 758         int newHandleNumber = -1;
 759         struct yaffsfs_FileDes *existingFD = NULL;
 760         struct yaffsfs_Handle *existingHandle = NULL;
 761         struct yaffsfs_Handle *newHandle = NULL;
 762
 763         yaffsfs_Lock();
 764         existingHandle = yaffsfs_HandleToPointer(handle);
 765         existingFD = yaffsfs_HandleToFileDes(handle);
 766         if (existingFD)
 767                 newHandleNumber = yaffsfs_NewHandle(&newHandle);
 768         if (newHandle) {
 769                 newHandle->fdId = existingHandle->fdId;
 770                 existingFD->handleCount++;
 771         }
 772
 773         yaffsfs_Unlock();
 774
 775         if (!existingFD)
 776                 yaffsfs_SetError(-EBADF);
 777         else if (!newHandle)
 778                 yaffsfs_SetError(-ENOMEM);
 779
 780         return newHandleNumber;
 781
 782 }
 783
 784 static int yaffsfs_TooManyObjects(struct yaffs_dev *dev)
 785 {
 786         int current_objects = dev->n_obj - dev->n_deleted_files;
 787
 788         if (dev->param.max_objects && current_objects > dev->param.max_objects)
 789                 return 1;
 790         else
 791                 return 0;
 792 }
 793
 794 int yaffs_open_sharing_reldir(struct yaffs_obj *reldir, const YCHAR *path,
 795                         int oflag, int mode, int sharing)
 796 {
 797         struct yaffs_obj *obj = NULL;
 798         struct yaffs_obj *dir = NULL;
 799         YCHAR *name;
 800         int handle = -1;
 801         struct yaffsfs_FileDes *fd = NULL;
 802         int openDenied = 0;
 803         int symDepth = 0;
 804         int errorReported = 0;
 805         int rwflags = oflag & (O_RDWR | O_RDONLY | O_WRONLY);
 806         u8 shareRead = (sharing & YAFFS_SHARE_READ) ? 1 : 0;
 807         u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0;
 808         u8 sharedReadAllowed;
 809         u8 sharedWriteAllowed;
 810         u8 alreadyReading;
 811         u8 alreadyWriting;
 812         u8 readRequested;
 813         u8 writeRequested;
 814         int notDir = 0;
 815         int loop = 0;
 816         int is_dir = 0;
 817         yaffs_DIR *dsc;
 818
 819         if (yaffsfs_CheckMemRegion(path, 0, 0)< 0) {
 820                 yaffsfs_SetError(-EFAULT);
 821                 return -1;
 822         }
 823
 824         if (yaffsfs_CheckPath(path) < 0) {
 825                 yaffsfs_SetError(-ENAMETOOLONG);
 826                 return -1;
 827         }
 828
 829         /* O_EXCL only has meaning if O_CREAT is specified */
 830         if (!(oflag & O_CREAT))
 831                 oflag &= ~(O_EXCL);
 832
 833         /* O_TRUNC has no meaning if (O_CREAT | O_EXCL) is specified */
 834         if ((oflag & O_CREAT) & (oflag & O_EXCL))
 835                 oflag &= ~(O_TRUNC);
 836
 837         /* Todo: Are there any more flag combos to sanitise ? */
 838
 839         /* Figure out if reading or writing is requested */
 840
 841         readRequested = (rwflags == O_RDWR || rwflags == O_RDONLY) ? 1 : 0;
 842         writeRequested = (rwflags == O_RDWR || rwflags == O_WRONLY) ? 1 : 0;
 843
 844         yaffsfs_Lock();
 845
 846         handle = yaffsfs_NewHandleAndFileDes();
 847
 848         if (handle < 0) {
 849                 yaffsfs_SetError(-ENFILE);
 850                 errorReported = 1;
 851         } else {
 852
 853                 fd = yaffsfs_HandleToFileDes(handle);
 854
 855                 /* try to find the exisiting object */
 856                 obj = yaffsfs_FindObject(reldir, path, 0, 1, NULL, NULL, NULL);
 857
 858                 obj = yaffsfs_FollowLink(obj, symDepth++, &loop);
 859
 860                 if (obj &&
 861                     obj->variant_type != YAFFS_OBJECT_TYPE_FILE &&
 862                     obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
 863                         obj = NULL;
 864
 865                 if (obj) {
 866
 867                         /* The file already exists or it might be a directory */
 868                         is_dir = (obj->variant_type ==
 869                                         YAFFS_OBJECT_TYPE_DIRECTORY);
 870
 871                         /* A directory can't be opened except for read */
 872                         if ( is_dir &&
 873                             (writeRequested || !readRequested ||
 874                                 (oflag & ~O_RDONLY))) {
 875                                 openDenied = 1;
 876                                 yaffsfs_SetError(-EISDIR);
 877                                 errorReported = 1;
 878                         }
 879
 880                         if(is_dir) {
 881                                 dsc = yaffsfs_opendir_reldir_no_lock(reldir, path);
 882                                 if (!dsc) {
 883                                         openDenied = 1;
 884                                         yaffsfs_SetError(-ENFILE);
 885                                         errorReported = 1;
 886                                 }
 887                         }
 888
 889                         /* Open should fail if O_CREAT and O_EXCL are specified
 890                          * for a file that exists.
 891                          */
 892                         if (!errorReported &&
 893                             (oflag & O_EXCL) && (oflag & O_CREAT)) {
 894                                 openDenied = 1;
 895                                 yaffsfs_SetError(-EEXIST);
 896                                 errorReported = 1;
 897                         }
 898
 899                         /* Check file permissions */
 900                         if (readRequested && !(obj->yst_mode & S_IREAD))
 901                                 openDenied = 1;
 902
 903                         if (writeRequested && !(obj->yst_mode & S_IWRITE))
 904                                 openDenied = 1;
 905
 906                         if (!errorReported && writeRequested &&
 907                             obj->my_dev->read_only) {
 908                                 openDenied = 1;
 909                                 yaffsfs_SetError(-EROFS);
 910                                 errorReported = 1;
 911                         }
 912
 913                         if (openDenied && !errorReported) {
 914                                 yaffsfs_SetError(-EACCES);
 915                                 errorReported = 1;
 916                         }
 917
 918                         /* Check sharing of an existing object. */
 919                         if (!openDenied) {
 920                                 struct yaffsfs_FileDes *fdx;
 921                                 int i;
 922
 923                                 sharedReadAllowed = 1;
 924                                 sharedWriteAllowed = 1;
 925                                 alreadyReading = 0;
 926                                 alreadyWriting = 0;
 927                                 for (i = 0; i < YAFFSFS_N_HANDLES; i++) {
 928                                         fdx = &yaffsfs_fd[i];
 929                                         if (fdx->handleCount > 0 &&
 930                                             fdx->inodeId >= 0 &&
 931                                             yaffsfs_inode[fdx->inodeId].iObj
 932                                             == obj) {
 933                                                 if (!fdx->shareRead)
 934                                                         sharedReadAllowed = 0;
 935                                                 if (!fdx->shareWrite)
 936                                                         sharedWriteAllowed = 0;
 937                                                 if (fdx->reading)
 938                                                         alreadyReading = 1;
 939                                                 if (fdx->writing)
 940                                                         alreadyWriting = 1;
 941                                         }
 942                                 }
 943
 944                                 if ((!sharedReadAllowed && readRequested) ||
 945                                     (!shareRead && alreadyReading) ||
 946                                     (!sharedWriteAllowed && writeRequested) ||
 947                                     (!shareWrite && alreadyWriting)) {
 948                                         openDenied = 1;
 949                                         yaffsfs_SetError(-EBUSY);
 950                                         errorReported = 1;
 951                                 }
 952                         }
 953
 954                 }
 955
 956                 /* If we could not open an existing object, then let's see if
 957                  * the directory exists. If not, error.
 958                  */
 959                 if (!obj && !errorReported) {
 960                         dir = yaffsfs_FindDirectory(reldir, path, &name, 0,
 961                                                     &notDir, &loop);
 962                         if (!dir && notDir) {
 963                                 yaffsfs_SetError(-ENOTDIR);
 964                                 errorReported = 1;
 965                         } else if (loop) {
 966                                 yaffsfs_SetError(-ELOOP);
 967                                 errorReported = 1;
 968                         } else if (!dir) {
 969                                 yaffsfs_SetError(-ENOENT);
 970                                 errorReported = 1;
 971                         }
 972                 }
 973
 974                 if (!obj && dir && !errorReported && (oflag & O_CREAT)) {
 975                         /* Let's see if we can create this file */
 976                         if (dir->my_dev->read_only) {
 977                                 yaffsfs_SetError(-EROFS);
 978                                 errorReported = 1;
 979                         } else if (yaffsfs_TooManyObjects(dir->my_dev)) {
 980                                 yaffsfs_SetError(-ENFILE);
 981                                 errorReported = 1;
 982                         } else
 983                                 obj = yaffs_create_file(dir, name, mode, 0, 0);
 984
 985                         if (!obj && !errorReported) {
 986                                 yaffsfs_SetError(-ENOSPC);
 987                                 errorReported = 1;
 988                         }
 989                 }
 990
 991                 if (!obj && dir && !errorReported && !(oflag & O_CREAT)) {
 992                         yaffsfs_SetError(-ENOENT);
 993                         errorReported = 1;
 994                 }
 995
 996                 if (obj && !openDenied) {
 997                         int inodeId = yaffsfs_GetInodeIdForObject(obj);
 998
 999                         if (inodeId < 0) {
1000                                 /*
1001                                  * Todo: Fix any problem if inodes run out,
1002                                  * That can't happen if the number of inode
1003                                  * items >= number of handles.
1004                                  */
1005                         }
1006
1007                         fd->inodeId = inodeId;
1008                         fd->reading = readRequested;
1009                         fd->writing = writeRequested;
1010                         fd->append = (oflag & O_APPEND) ? 1 : 0;
1011                         fd->shareRead = shareRead;
1012                         fd->shareWrite = shareWrite;
1013                         fd->isDir = is_dir;
1014
1015                         if(is_dir)
1016                                 fd->v.dir = dsc;
1017                         else
1018                                 fd->v.position = 0;
1019
1020                         /* Hook inode to object */
1021                         obj->my_inode = (void *)&yaffsfs_inode[inodeId];
1022
1023                         if (!is_dir && (oflag & O_TRUNC) && fd->writing)
1024                                 yaffs_resize_file(obj, 0);
1025                 } else {
1026                         yaffsfs_PutHandle(handle);
1027                         if (!errorReported)
1028                                 yaffsfs_SetError(0);    /* Problem */
1029                         handle = -1;
1030                 }
1031         }
1032
1033         yaffsfs_Unlock();
1034
1035         return handle;
1036 }
1037
1038 int yaffs_open_sharing_reldev(struct yaffs_dev *dev, const YCHAR *path, int oflag,
1039                                 int mode, int sharing)
1040 {
1041         return yaffs_open_sharing_reldir(ROOT_DIR(dev), path,
1042                                         oflag, mode, sharing);
1043 }
1044
1045 int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
1046 {
1047         return yaffs_open_sharing_reldir(NULL, path, oflag, mode, sharing);
1048 }
1049
1050 int yaffs_open_reldir(struct yaffs_obj *reldir,const YCHAR *path, int oflag, int mode)
1051 {
1052         return yaffs_open_sharing_reldir(reldir, path, oflag, mode,
1053                                   YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
1054 }
1055
1056 int yaffs_open_reldev(struct yaffs_dev *dev,const YCHAR *path, int oflag, int mode)
1057 {
1058         return yaffs_open_sharing_reldir(ROOT_DIR(dev), path, oflag, mode,
1059                                   YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
1060 }
1061
1062 int yaffs_open(const YCHAR *path, int oflag, int mode)
1063 {
1064         return yaffs_open_reldir(NULL, path, oflag, mode);
1065 }
1066
1067 static int yaffs_Dofsync(int handle, int datasync)
1068 {
1069         int retVal = -1;
1070         struct yaffs_obj *obj;
1071
1072         yaffsfs_Lock();
1073
1074         obj = yaffsfs_HandleToObject(handle);
1075
1076         if (!obj)
1077                 yaffsfs_SetError(-EBADF);
1078         else if (obj->my_dev->read_only)
1079                 yaffsfs_SetError(-EROFS);
1080         else {
1081                 yaffs_flush_file(obj, 1, datasync, 0);
1082                 retVal = 0;
1083         }
1084
1085         yaffsfs_Unlock();
1086
1087         return retVal;
1088 }
1089
1090 int yaffs_fsync(int handle)
1091 {
1092         return yaffs_Dofsync(handle, 0);
1093 }
1094
1095 int yaffs_flush(int handle)
1096 {
1097         return yaffs_fsync(handle);
1098 }
1099
1100 int yaffs_fdatasync(int handle)
1101 {
1102         return yaffs_Dofsync(handle, 1);
1103 }
1104
1105 int yaffs_close(int handle)
1106 {
1107         struct yaffsfs_Handle *h = NULL;
1108         struct yaffsfs_FileDes *f;
1109         struct yaffs_obj *obj = NULL;
1110         int retVal = -1;
1111
1112         yaffsfs_Lock();
1113
1114         h = yaffsfs_HandleToPointer(handle);
1115         f = yaffsfs_HandleToFileDes(handle);
1116         obj = yaffsfs_HandleToObject(handle);
1117
1118         if (!h || !obj || !f)
1119                 yaffsfs_SetError(-EBADF);
1120         else {
1121                 /* clean up */
1122                 if(!f->isDir)
1123                         yaffs_flush_file(obj, 1, 0, 1);
1124                 yaffsfs_PutHandle(handle);
1125                 retVal = 0;
1126         }
1127
1128         yaffsfs_Unlock();
1129
1130         return retVal;
1131 }
1132
1133 static int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte,
1134                     int isPread, Y_LOFF_T offset)
1135 {
1136         struct yaffsfs_FileDes *fd = NULL;
1137         struct yaffs_obj *obj = NULL;
1138         Y_LOFF_T pos = 0;
1139         Y_LOFF_T startPos = 0;
1140         Y_LOFF_T endPos = 0;
1141         int nRead = 0;
1142         int nToRead = 0;
1143         int totalRead = 0;
1144         Y_LOFF_T maxRead;
1145         u8 *buf = (u8 *) vbuf;
1146
1147         if (yaffsfs_CheckMemRegion(vbuf, nbyte, 1) < 0) {
1148                 yaffsfs_SetError(-EFAULT);
1149                 return -1;
1150         }
1151
1152         yaffsfs_Lock();
1153         fd = yaffsfs_HandleToFileDes(handle);
1154         obj = yaffsfs_HandleToObject(handle);
1155
1156         if (!fd || !obj) {
1157                 /* bad handle */
1158                 yaffsfs_SetError(-EBADF);
1159                 totalRead = -1;
1160         } else if (!fd->reading) {
1161                 /* Not a reading handle */
1162                 yaffsfs_SetError(-EINVAL);
1163                 totalRead = -1;
1164         } else if (nbyte > YAFFS_MAX_FILE_SIZE) {
1165                 yaffsfs_SetError(-EINVAL);
1166                 totalRead = -1;
1167         } else {
1168                 if (isPread)
1169                         startPos = offset;
1170                 else
1171                         startPos = fd->v.position;
1172
1173                 pos = startPos;
1174
1175                 if (yaffs_get_obj_length(obj) > pos)
1176                         maxRead = yaffs_get_obj_length(obj) - pos;
1177                 else
1178                         maxRead = 0;
1179
1180                 if (nbyte > maxRead)
1181                         nbyte = maxRead;
1182
1183                 yaffsfs_GetHandle(handle);
1184
1185                 endPos = pos + nbyte;
1186
1187                 if (pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
1188                     nbyte > YAFFS_MAX_FILE_SIZE ||
1189                     endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE) {
1190                         totalRead = -1;
1191                         nbyte = 0;
1192                 }
1193
1194                 while (nbyte > 0) {
1195                         nToRead = YAFFSFS_RW_SIZE -
1196                             (pos & (YAFFSFS_RW_SIZE - 1));
1197                         if (nToRead > nbyte)
1198                                 nToRead = nbyte;
1199
1200                         /* Tricky bit...
1201                          * Need to reverify object in case the device was
1202                          * unmounted in another thread.
1203                          */
1204                         obj = yaffsfs_HandleToObject(handle);
1205                         if (!obj)
1206                                 nRead = 0;
1207                         else
1208                                 nRead = yaffs_file_rd(obj, buf, pos, nToRead);
1209
1210                         if (nRead > 0) {
1211                                 totalRead += nRead;
1212                                 pos += nRead;
1213                                 buf += nRead;
1214                         }
1215
1216                         if (nRead == nToRead)
1217                                 nbyte -= nRead;
1218                         else
1219                                 nbyte = 0;      /* no more to read */
1220
1221                         if (nbyte > 0) {
1222                                 yaffsfs_Unlock();
1223                                 yaffsfs_Lock();
1224                         }
1225
1226                 }
1227
1228                 yaffsfs_PutHandle(handle);
1229
1230                 if (!isPread) {
1231                         if (totalRead >= 0)
1232                                 fd->v.position = startPos + totalRead;
1233                         else
1234                                 yaffsfs_SetError(-EINVAL);
1235                 }
1236
1237         }
1238
1239         yaffsfs_Unlock();
1240
1241         return (totalRead >= 0) ? totalRead : -1;
1242
1243 }
1244
1245 int yaffs_read(int handle, void *buf, unsigned int nbyte)
1246 {
1247         return yaffsfs_do_read(handle, buf, nbyte, 0, 0);
1248 }
1249
1250 int yaffs_pread(int handle, void *buf, unsigned int nbyte, Y_LOFF_T offset)
1251 {
1252         return yaffsfs_do_read(handle, buf, nbyte, 1, offset);
1253 }
1254
1255 static int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte,
1256                      int isPwrite, Y_LOFF_T offset)
1257 {
1258         struct yaffsfs_FileDes *fd = NULL;
1259         struct yaffs_obj *obj = NULL;
1260         Y_LOFF_T pos = 0;
1261         Y_LOFF_T startPos = 0;
1262         Y_LOFF_T endPos;
1263         int nWritten = 0;
1264         int totalWritten = 0;
1265         int write_trhrough = 0;
1266         int nToWrite = 0;
1267         const u8 *buf = (const u8 *)vbuf;
1268
1269         if (yaffsfs_CheckMemRegion(vbuf, nbyte, 0) < 0) {
1270                 yaffsfs_SetError(-EFAULT);
1271                 return -1;
1272         }
1273
1274         yaffsfs_Lock();
1275         fd = yaffsfs_HandleToFileDes(handle);
1276         obj = yaffsfs_HandleToObject(handle);
1277
1278         if (!fd || !obj) {
1279                 /* bad handle */
1280                 yaffsfs_SetError(-EBADF);
1281                 totalWritten = -1;
1282         } else if (!fd->writing) {
1283                 yaffsfs_SetError(-EINVAL);
1284                 totalWritten = -1;
1285         } else if (obj->my_dev->read_only) {
1286                 yaffsfs_SetError(-EROFS);
1287                 totalWritten = -1;
1288         } else {
1289                 if (fd->append)
1290                         startPos = yaffs_get_obj_length(obj);
1291                 else if (isPwrite)
1292                         startPos = offset;
1293                 else
1294                         startPos = fd->v.position;
1295
1296                 yaffsfs_GetHandle(handle);
1297                 pos = startPos;
1298                 endPos = pos + nbyte;
1299
1300                 if (pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
1301                     nbyte > YAFFS_MAX_FILE_SIZE ||
1302                     endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE) {
1303                         totalWritten = -1;
1304                         nbyte = 0;
1305                 }
1306
1307                 while (nbyte > 0) {
1308
1309                         nToWrite = YAFFSFS_RW_SIZE -
1310                             (pos & (YAFFSFS_RW_SIZE - 1));
1311                         if (nToWrite > nbyte)
1312                                 nToWrite = nbyte;
1313
1314                         /* Tricky bit...
1315                          * Need to reverify object in case the device was
1316                          * remounted or unmounted in another thread.
1317                          */
1318                         obj = yaffsfs_HandleToObject(handle);
1319                         if (!obj || obj->my_dev->read_only)
1320                                 nWritten = 0;
1321                         else
1322                                 nWritten =
1323                                     yaffs_wr_file(obj, buf, pos, nToWrite,
1324                                                   write_trhrough);
1325                         if (nWritten > 0) {
1326                                 totalWritten += nWritten;
1327                                 pos += nWritten;
1328                                 buf += nWritten;
1329                         }
1330
1331                         if (nWritten == nToWrite)
1332                                 nbyte -= nToWrite;
1333                         else
1334                                 nbyte = 0;
1335
1336                         if (nWritten < 1 && totalWritten < 1) {
1337                                 yaffsfs_SetError(-ENOSPC);
1338                                 totalWritten = -1;
1339                         }
1340
1341                         if (nbyte > 0) {
1342                                 yaffsfs_Unlock();
1343                                 yaffsfs_Lock();
1344                         }
1345                 }
1346
1347                 yaffsfs_PutHandle(handle);
1348
1349                 if (!isPwrite) {
1350                         if (totalWritten > 0)
1351                                 fd->v.position = startPos + totalWritten;
1352                         else
1353                                 yaffsfs_SetError(-EINVAL);
1354                 }
1355         }
1356
1357         yaffsfs_Unlock();
1358
1359         return (totalWritten >= 0) ? totalWritten : -1;
1360 }
1361
1362 int yaffs_write(int fd, const void *buf, unsigned int nbyte)
1363 {
1364         return yaffsfs_do_write(fd, buf, nbyte, 0, 0);
1365 }
1366
1367 int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, Y_LOFF_T offset)
1368 {
1369         return yaffsfs_do_write(fd, buf, nbyte, 1, offset);
1370 }
1371
1372 int yaffs_truncate_reldir(struct yaffs_obj *reldir, const YCHAR *path,
1373                                 Y_LOFF_T new_size)
1374 {
1375         struct yaffs_obj *obj = NULL;
1376         struct yaffs_obj *dir = NULL;
1377         int result = YAFFS_FAIL;
1378         int notDir = 0;
1379         int loop = 0;
1380
1381         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
1382                 yaffsfs_SetError(-EFAULT);
1383                 return -1;
1384         }
1385
1386         if (yaffsfs_CheckPath(path) < 0) {
1387                 yaffsfs_SetError(-ENAMETOOLONG);
1388                 return -1;
1389         }
1390
1391         yaffsfs_Lock();
1392
1393         obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
1394         obj = yaffsfs_FollowLink(obj, 0, &loop);
1395
1396         if (!dir && notDir)
1397                 yaffsfs_SetError(-ENOTDIR);
1398         else if (loop)
1399                 yaffsfs_SetError(-ELOOP);
1400         else if (!dir || !obj)
1401                 yaffsfs_SetError(-ENOENT);
1402         else if (obj->my_dev->read_only)
1403                 yaffsfs_SetError(-EROFS);
1404         else if (obj->variant_type != YAFFS_OBJECT_TYPE_FILE)
1405                 yaffsfs_SetError(-EISDIR);
1406         else if (obj->my_dev->read_only)
1407                 yaffsfs_SetError(-EROFS);
1408         else if (new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
1409                 yaffsfs_SetError(-EINVAL);
1410         else
1411                 result = yaffs_resize_file(obj, new_size);
1412
1413         yaffsfs_Unlock();
1414
1415         return (result) ? 0 : -1;
1416 }
1417
1418 int yaffs_truncate_reldev(struct yaffs_dev *dev, const YCHAR *path,
1419                         Y_LOFF_T new_size)
1420 {
1421         return yaffs_truncate_reldir(ROOT_DIR(dev), path, new_size);
1422 }
1423
1424 int yaffs_truncate(const YCHAR *path, Y_LOFF_T new_size)
1425 {
1426         return yaffs_truncate_reldir(NULL, path, new_size);
1427 }
1428
1429 int yaffs_ftruncate(int handle, Y_LOFF_T new_size)
1430 {
1431         struct yaffsfs_FileDes *fd = NULL;
1432         struct yaffs_obj *obj = NULL;
1433         int result = 0;
1434
1435         yaffsfs_Lock();
1436         fd = yaffsfs_HandleToFileDes(handle);
1437         obj = yaffsfs_HandleToObject(handle);
1438
1439         if (!fd || !obj)
1440                 /* bad handle */
1441                 yaffsfs_SetError(-EBADF);
1442         else if (!fd->writing)
1443                 yaffsfs_SetError(-EINVAL);
1444         else if (obj->my_dev->read_only)
1445                 yaffsfs_SetError(-EROFS);
1446         else if (new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE)
1447                 yaffsfs_SetError(-EINVAL);
1448         else
1449                 /* resize the file */
1450                 result = yaffs_resize_file(obj, new_size);
1451         yaffsfs_Unlock();
1452
1453         return (result) ? 0 : -1;
1454
1455 }
1456
1457 Y_LOFF_T yaffs_lseek(int handle, Y_LOFF_T offset, int whence)
1458 {
1459         struct yaffsfs_FileDes *fd = NULL;
1460         struct yaffs_obj *obj = NULL;
1461         Y_LOFF_T pos = -1;
1462         Y_LOFF_T fSize = -1;
1463
1464         yaffsfs_Lock();
1465         fd = yaffsfs_HandleToFileDes(handle);
1466         obj = yaffsfs_HandleToObject(handle);
1467
1468         if (!fd || !obj)
1469                 yaffsfs_SetError(-EBADF);
1470         else if (offset > YAFFS_MAX_FILE_SIZE)
1471                 yaffsfs_SetError(-EINVAL);
1472         else {
1473                 if (whence == SEEK_SET) {
1474                         if (offset >= 0)
1475                                 pos = offset;
1476                 } else if (whence == SEEK_CUR) {
1477                         if ((fd->v.position + offset) >= 0)
1478                                 pos = (fd->v.position + offset);
1479                 } else if (whence == SEEK_END) {
1480                         fSize = yaffs_get_obj_length(obj);
1481                         if (fSize >= 0 && (fSize + offset) >= 0)
1482                                 pos = fSize + offset;
1483                 }
1484
1485                 if (pos >= 0 && pos <= YAFFS_MAX_FILE_SIZE)
1486                         fd->v.position = pos;
1487                 else {
1488                         yaffsfs_SetError(-EINVAL);
1489                         pos = -1;
1490                 }
1491         }
1492
1493         yaffsfs_Unlock();
1494
1495         return pos;
1496 }
1497
1498 static int yaffsfs_DoUnlink_reldir(struct yaffs_obj *reldir,
1499                                 const YCHAR *path, int isDirectory)
1500 {
1501         struct yaffs_obj *dir = NULL;
1502         struct yaffs_obj *obj = NULL;
1503         YCHAR *name;
1504         int result = YAFFS_FAIL;
1505         int notDir = 0;
1506         int loop = 0;
1507
1508         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
1509                 yaffsfs_SetError(-EFAULT);
1510                 return -1;
1511         }
1512
1513         if (yaffsfs_CheckPath(path) < 0) {
1514                 yaffsfs_SetError(-ENAMETOOLONG);
1515                 return -1;
1516         }
1517
1518         yaffsfs_Lock();
1519
1520         obj = yaffsfs_FindObject(reldir, path, 0, 0, NULL, NULL, NULL);
1521         dir = yaffsfs_FindDirectory(reldir, path, &name, 0, &notDir, &loop);
1522
1523         if (!dir && notDir)
1524                 yaffsfs_SetError(-ENOTDIR);
1525         else if (loop)
1526                 yaffsfs_SetError(-ELOOP);
1527         else if (!dir)
1528                 yaffsfs_SetError(-ENOENT);
1529         else if (yaffs_strncmp(name, _Y("."), 2) == 0)
1530                 yaffsfs_SetError(-EINVAL);
1531         else if (!obj)
1532                 yaffsfs_SetError(-ENOENT);
1533         else if (obj->my_dev->read_only)
1534                 yaffsfs_SetError(-EROFS);
1535         else if (!isDirectory &&
1536                  obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
1537                 yaffsfs_SetError(-EISDIR);
1538         else if (isDirectory &&
1539                  obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
1540                 yaffsfs_SetError(-ENOTDIR);
1541         else if (isDirectory && obj == obj->my_dev->root_dir)
1542                 yaffsfs_SetError(-EBUSY);       /* Can't rmdir a root */
1543         else {
1544                 result = yaffs_unlinker(dir, name);
1545
1546                 if (result == YAFFS_FAIL && isDirectory)
1547                         yaffsfs_SetError(-ENOTEMPTY);
1548         }
1549
1550         yaffsfs_Unlock();
1551
1552         return (result == YAFFS_FAIL) ? -1 : 0;
1553 }
1554
1555 int yaffs_unlink_reldir(struct yaffs_obj *reldir, const YCHAR *path)
1556 {
1557         return yaffsfs_DoUnlink_reldir(reldir, path, 0);
1558 }
1559
1560 int yaffs_unlink_reldev(struct yaffs_dev *dev, const YCHAR *path)
1561 {
1562         return yaffsfs_DoUnlink_reldir(ROOT_DIR(dev), path, 0);
1563 }
1564
1565 int yaffs_unlink(const YCHAR *path)
1566 {
1567         return yaffs_unlink_reldir(NULL, path);
1568 }
1569
1570 static int rename_file_over_dir(struct yaffs_obj *obj, struct yaffs_obj *newobj)
1571 {
1572         if (obj && obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY &&
1573             newobj && newobj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
1574                 return 1;
1575         else
1576                 return 0;
1577 }
1578
1579 static int rename_dir_over_file(struct yaffs_obj *obj, struct yaffs_obj *newobj)
1580 {
1581         if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
1582             newobj && newobj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
1583                 return 1;
1584         else
1585                 return 0;
1586 }
1587
1588 int yaffs_rename_reldir(struct yaffs_obj *reldir,
1589                         const YCHAR *oldPath, const YCHAR *newPath)
1590 {
1591         struct yaffs_obj *olddir = NULL;
1592         struct yaffs_obj *newdir = NULL;
1593         struct yaffs_obj *obj = NULL;
1594         struct yaffs_obj *newobj = NULL;
1595         YCHAR *oldname;
1596         YCHAR *newname;
1597         int result = YAFFS_FAIL;
1598         int rename_allowed = 1;
1599         int notOldDir = 0;
1600         int notNewDir = 0;
1601         int oldLoop = 0;
1602         int newLoop = 0;
1603
1604         YCHAR *alt_newpath = NULL;
1605
1606         if (yaffsfs_CheckMemRegion(oldPath, 0, 0) < 0 ||
1607             yaffsfs_CheckMemRegion(newPath, 0, 0) < 0) {
1608                 yaffsfs_SetError(-EFAULT);
1609                 return -1;
1610         }
1611
1612         if (yaffsfs_CheckPath(oldPath) < 0 || yaffsfs_CheckPath(newPath) < 0) {
1613                 yaffsfs_SetError(-ENAMETOOLONG);
1614                 return -1;
1615         }
1616
1617         if (yaffsfs_alt_dir_path(newPath, &alt_newpath) < 0) {
1618                 yaffsfs_SetError(-ENOMEM);
1619                 return -1;
1620         }
1621         if (alt_newpath)
1622                 newPath = alt_newpath;
1623
1624         yaffsfs_Lock();
1625
1626         olddir = yaffsfs_FindDirectory(reldir, oldPath, &oldname, 0,
1627                                        &notOldDir, &oldLoop);
1628         newdir = yaffsfs_FindDirectory(reldir, newPath, &newname, 0,
1629                                        &notNewDir, &newLoop);
1630         obj = yaffsfs_FindObject(reldir, oldPath, 0, 0, NULL, NULL, NULL);
1631         newobj = yaffsfs_FindObject(reldir, newPath, 0, 0, NULL, NULL, NULL);
1632
1633         /* If the object being renamed is a directory and the
1634          * path ended with a "/" then the olddir == obj.
1635          * We pass through NULL for the old name to tell the lower layers
1636          * to use olddir as the object.
1637          */
1638
1639         if (olddir == obj)
1640                 oldname = NULL;
1641
1642         if ((!olddir && notOldDir) || (!newdir && notNewDir)) {
1643                 yaffsfs_SetError(-ENOTDIR);
1644                 rename_allowed = 0;
1645         } else if (oldLoop || newLoop) {
1646                 yaffsfs_SetError(-ELOOP);
1647                 rename_allowed = 0;
1648         } else if (olddir && oldname &&
1649                         yaffs_strncmp(oldname, _Y("."), 2) == 0) {
1650                 yaffsfs_SetError(-EINVAL);
1651                 rename_allowed = 0;
1652         } else if (!olddir || !newdir || !obj) {
1653                 yaffsfs_SetError(-ENOENT);
1654                 rename_allowed = 0;
1655         } else if (obj->my_dev->read_only) {
1656                 yaffsfs_SetError(-EROFS);
1657                 rename_allowed = 0;
1658         } else if (rename_file_over_dir(obj, newobj)) {
1659                 yaffsfs_SetError(-EISDIR);
1660                 rename_allowed = 0;
1661         } else if (rename_dir_over_file(obj, newobj)) {
1662                 yaffsfs_SetError(-ENOTDIR);
1663                 rename_allowed = 0;
1664         } else if (yaffs_is_non_empty_dir(newobj)) {
1665                 yaffsfs_SetError(-ENOTEMPTY);
1666                 rename_allowed = 0;
1667         } else if (olddir->my_dev != newdir->my_dev) {
1668                 /* Rename must be on same device */
1669                 yaffsfs_SetError(-EXDEV);
1670                 rename_allowed = 0;
1671         } else if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
1672                 /*
1673                  * It is a directory, check that it is not being renamed to
1674                  * being its own decendent.
1675                  * Do this by tracing from the new directory back to the root,
1676                  * checking for obj
1677                  */
1678
1679                 struct yaffs_obj *xx = newdir;
1680
1681                 while (rename_allowed && xx) {
1682                         if (xx == obj)
1683                                 rename_allowed = 0;
1684                         xx = xx->parent;
1685                 }
1686                 if (!rename_allowed)
1687                         yaffsfs_SetError(-EINVAL);
1688         }
1689
1690         if (rename_allowed)
1691                 result = yaffs_rename_obj(olddir, oldname, newdir, newname);
1692
1693         yaffsfs_Unlock();
1694
1695         kfree(alt_newpath);
1696
1697         return (result == YAFFS_FAIL) ? -1 : 0;
1698 }
1699
1700 int yaffs_rename_reldev(struct yaffs_dev *dev, const YCHAR *oldPath,
1701                         const YCHAR *newPath)
1702 {
1703         return yaffs_rename_reldir(ROOT_DIR(dev), oldPath, newPath);
1704 }
1705 int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
1706 {
1707         return yaffs_rename_reldir(NULL, oldPath, newPath);
1708 }
1709
1710 static int yaffsfs_DoStat(struct yaffs_obj *obj, struct yaffs_stat *buf)
1711 {
1712         int retVal = -1;
1713
1714         obj = yaffs_get_equivalent_obj(obj);
1715
1716         if (obj && buf) {
1717                 buf->st_dev = (int)obj->my_dev->os_context;
1718                 buf->st_ino = obj->obj_id;
1719                 buf->st_mode = obj->yst_mode & ~S_IFMT;
1720
1721                 if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
1722                         buf->st_mode |= S_IFDIR;
1723                 else if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK)
1724                         buf->st_mode |= S_IFLNK;
1725                 else if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE)
1726                         buf->st_mode |= S_IFREG;
1727
1728                 buf->st_nlink = yaffs_get_obj_link_count(obj);
1729                 buf->st_uid = 0;
1730                 buf->st_gid = 0;
1731                 buf->st_rdev = obj->yst_rdev;
1732                 buf->st_size = yaffs_get_obj_length(obj);
1733                 buf->st_blksize = obj->my_dev->data_bytes_per_chunk;
1734                 buf->st_blocks = (buf->st_size + buf->st_blksize - 1) /
1735                     buf->st_blksize;
1736 #if CONFIG_YAFFS_WINCE
1737                 buf->yst_wince_atime[0] = obj->win_atime[0];
1738                 buf->yst_wince_atime[1] = obj->win_atime[1];
1739                 buf->yst_wince_ctime[0] = obj->win_ctime[0];
1740                 buf->yst_wince_ctime[1] = obj->win_ctime[1];
1741                 buf->yst_wince_mtime[0] = obj->win_mtime[0];
1742                 buf->yst_wince_mtime[1] = obj->win_mtime[1];
1743 #else
1744                 buf->yst_atime = obj->yst_atime;
1745                 buf->yst_ctime = obj->yst_ctime;
1746                 buf->yst_mtime = obj->yst_mtime;
1747 #endif
1748                 retVal = 0;
1749         }
1750         return retVal;
1751 }
1752
1753 static int yaffsfs_DoStatOrLStat_reldir(struct yaffs_obj *reldir, const YCHAR *path,
1754                                  struct yaffs_stat *buf, int doLStat)
1755 {
1756         struct yaffs_obj *obj = NULL;
1757         struct yaffs_obj *dir = NULL;
1758         int retVal = -1;
1759         int notDir = 0;
1760         int loop = 0;
1761
1762         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0 ||
1763             yaffsfs_CheckMemRegion(buf, sizeof(*buf), 1) < 0) {
1764                 yaffsfs_SetError(-EFAULT);
1765                 return -1;
1766         }
1767
1768         if (yaffsfs_CheckPath(path) < 0) {
1769                 yaffsfs_SetError(-ENAMETOOLONG);
1770                 return -1;
1771         }
1772
1773         yaffsfs_Lock();
1774
1775         obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
1776
1777         if (!doLStat && obj)
1778                 obj = yaffsfs_FollowLink(obj, 0, &loop);
1779
1780         if (!dir && notDir)
1781                 yaffsfs_SetError(-ENOTDIR);
1782         else if (loop)
1783                 yaffsfs_SetError(-ELOOP);
1784         else if (!dir || !obj)
1785                 yaffsfs_SetError(-ENOENT);
1786         else
1787                 retVal = yaffsfs_DoStat(obj, buf);
1788
1789         yaffsfs_Unlock();
1790
1791         return retVal;
1792
1793 }
1794
1795 int yaffs_stat_reldir(struct yaffs_obj *reldir, const YCHAR *path,
1796                     struct yaffs_stat *buf)
1797 {
1798         return yaffsfs_DoStatOrLStat_reldir(reldir, path, buf, 0);
1799 }
1800
1801 int yaffs_lstat_reldir(struct yaffs_obj *reldir, const YCHAR *path,
1802                     struct yaffs_stat *buf)
1803 {
1804         return yaffsfs_DoStatOrLStat_reldir(reldir, path, buf, 1);
1805 }
1806
1807 int yaffs_stat_reldev(struct yaffs_dev *dev, const YCHAR *path,
1808                     struct yaffs_stat *buf)
1809 {
1810         return yaffsfs_DoStatOrLStat_reldir(ROOT_DIR(dev), path, buf, 0);
1811 }
1812
1813 int yaffs_lstat_reldev(struct yaffs_dev *dev, const YCHAR *path,
1814                     struct yaffs_stat *buf)
1815 {
1816         return yaffsfs_DoStatOrLStat_reldir(ROOT_DIR(dev), path, buf, 1);
1817 }
1818
1819 int yaffs_stat(const YCHAR *path, struct yaffs_stat *buf)
1820 {
1821         return yaffs_stat_reldir(NULL, path, buf);
1822 }
1823
1824 int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf)
1825 {
1826         return yaffs_lstat_reldir(NULL, path, buf);
1827 }
1828
1829 int yaffs_fstat(int fd, struct yaffs_stat *buf)
1830 {
1831         struct yaffs_obj *obj;
1832
1833         int retVal = -1;
1834
1835         if (yaffsfs_CheckMemRegion(buf, sizeof(*buf), 1) < 0) {
1836                 yaffsfs_SetError(-EFAULT);
1837                 return -1;
1838         }
1839
1840         yaffsfs_Lock();
1841         obj = yaffsfs_HandleToObject(fd);
1842
1843         if (obj)
1844                 retVal = yaffsfs_DoStat(obj, buf);
1845         else
1846                 /* bad handle */
1847                 yaffsfs_SetError(-EBADF);
1848
1849         yaffsfs_Unlock();
1850
1851         return retVal;
1852 }
1853
1854 static int yaffsfs_DoUtime(struct yaffs_obj *obj,
1855                            const struct yaffs_utimbuf *buf)
1856 {
1857         int retVal = -1;
1858         struct yaffs_utimbuf local;
1859
1860         obj = yaffs_get_equivalent_obj(obj);
1861
1862         if (obj && obj->my_dev->read_only) {
1863                 yaffsfs_SetError(-EROFS);
1864                 return -1;
1865         }
1866
1867 #if !CONFIG_YAFFS_WINCE
1868         if (!buf) {
1869                 local.actime = Y_CURRENT_TIME;
1870                 local.modtime = local.actime;
1871                 buf = &local;
1872         }
1873
1874         if (obj) {
1875                 int result;
1876
1877                 obj->yst_atime = buf->actime;
1878                 obj->yst_mtime = buf->modtime;
1879                 obj->dirty = 1;
1880                 result = yaffs_flush_file(obj, 0, 0, 0);
1881                 retVal = result == YAFFS_OK ? 0 : -1;
1882         }
1883 #endif
1884
1885         return retVal;
1886 }
1887
1888 int yaffs_utime_reldir(struct yaffs_obj *reldir, const YCHAR *path,
1889                      const struct yaffs_utimbuf *buf)
1890 {
1891         struct yaffs_obj *obj = NULL;
1892         struct yaffs_obj *dir = NULL;
1893         int retVal = -1;
1894         int notDir = 0;
1895         int loop = 0;
1896
1897         if (!path) {
1898                 yaffsfs_SetError(-EFAULT);
1899                 return -1;
1900         }
1901
1902         if (yaffsfs_CheckPath(path) < 0) {
1903                 yaffsfs_SetError(-ENAMETOOLONG);
1904                 return -1;
1905         }
1906
1907         yaffsfs_Lock();
1908
1909         obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
1910
1911         if (!dir && notDir)
1912                 yaffsfs_SetError(-ENOTDIR);
1913         else if (loop)
1914                 yaffsfs_SetError(-ELOOP);
1915         else if (!dir || !obj)
1916                 yaffsfs_SetError(-ENOENT);
1917         else
1918                 retVal = yaffsfs_DoUtime(obj, buf);
1919
1920         yaffsfs_Unlock();
1921
1922         return retVal;
1923
1924 }
1925
1926 int yaffs_utime_reldev(struct yaffs_dev *dev, const YCHAR *path,
1927                         const struct yaffs_utimbuf *buf)
1928 {
1929         return yaffs_utime_reldir(ROOT_DIR(dev), path, buf);
1930 }
1931
1932 int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf)
1933 {
1934         return yaffs_utime_reldir(NULL, path, buf);
1935 }
1936
1937 int yaffs_futime(int fd, const struct yaffs_utimbuf *buf)
1938 {
1939         struct yaffs_obj *obj;
1940
1941         int retVal = -1;
1942
1943         yaffsfs_Lock();
1944         obj = yaffsfs_HandleToObject(fd);
1945
1946         if (obj)
1947                 retVal = yaffsfs_DoUtime(obj, buf);
1948         else
1949                 /* bad handle */
1950                 yaffsfs_SetError(-EBADF);
1951
1952         yaffsfs_Unlock();
1953
1954         return retVal;
1955 }
1956
1957 #ifndef CONFIG_YAFFS_WINCE
1958 /* xattrib functions */
1959
1960 static int yaffs_do_setxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
1961                                   const char *name, const void *data, int size,
1962                                   int flags, int follow)
1963 {
1964         struct yaffs_obj *obj;
1965         struct yaffs_obj *dir;
1966         int notDir = 0;
1967         int loop = 0;
1968
1969         int retVal = -1;
1970
1971         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0 ||
1972             yaffsfs_CheckMemRegion(name, 0, 0) < 0 ||
1973             yaffsfs_CheckMemRegion(data, size, 0) < 0) {
1974                 yaffsfs_SetError(-EFAULT);
1975                 return -1;
1976         }
1977
1978         if (yaffsfs_CheckPath(path) < 0) {
1979                 yaffsfs_SetError(-ENAMETOOLONG);
1980                 return -1;
1981         }
1982
1983         yaffsfs_Lock();
1984
1985         obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
1986
1987         if (follow)
1988                 obj = yaffsfs_FollowLink(obj, 0, &loop);
1989
1990         if (!dir && notDir)
1991                 yaffsfs_SetError(-ENOTDIR);
1992         else if (loop)
1993                 yaffsfs_SetError(-ELOOP);
1994         else if (!dir || !obj)
1995                 yaffsfs_SetError(-ENOENT);
1996         else {
1997                 retVal = yaffs_set_xattrib(obj, name, data, size, flags);
1998                 if (retVal < 0) {
1999                         yaffsfs_SetError(retVal);
2000                         retVal = -1;
2001                 }
2002         }
2003
2004         yaffsfs_Unlock();
2005
2006         return retVal;
2007
2008 }
2009
2010 int yaffs_setxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
2011                         const char *name, const void *data, int size, int flags)
2012 {
2013         return yaffs_do_setxattr_reldir(reldir, path, name, data, size, flags, 1);
2014 }
2015
2016 int yaffs_setxattr_reldev(struct yaffs_dev *dev, const YCHAR *path,
2017                 const char *name, const void *data, int size, int flags)
2018 {
2019         return yaffs_setxattr_reldir(ROOT_DIR(dev), path, name, data, size, flags);
2020 }
2021
2022 int yaffs_setxattr(const YCHAR *path, const char *name,
2023                    const void *data, int size, int flags)
2024 {
2025         return yaffs_setxattr_reldir(NULL, path, name, data, size, flags);
2026 }
2027
2028 int yaffs_lsetxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path, const char *name,
2029                     const void *data, int size, int flags)
2030 {
2031         return yaffs_do_setxattr_reldir(reldir, path, name, data, size, flags, 0);
2032 }
2033
2034 int yaffs_lsetxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name,
2035                    const void *data, int size, int flags)
2036 {
2037         return yaffs_lsetxattr_reldir(ROOT_DIR(dev), path, name, data, size, flags);
2038 }
2039
2040 int yaffs_lsetxattr(const YCHAR *path, const char *name,
2041                    const void *data, int size, int flags)
2042 {
2043         return yaffs_lsetxattr_reldir(NULL, path, name, data, size, flags);
2044 }
2045
2046 int yaffs_fsetxattr(int fd, const char *name,
2047                     const void *data, int size, int flags)
2048 {
2049         struct yaffs_obj *obj;
2050
2051         int retVal = -1;
2052
2053         if (yaffsfs_CheckMemRegion(name, 0, 0) < 0 ||
2054             yaffsfs_CheckMemRegion(data, size, 0) < 0) {
2055                 yaffsfs_SetError(-EFAULT);
2056                 return -1;
2057         }
2058
2059         yaffsfs_Lock();
2060         obj = yaffsfs_HandleToObject(fd);
2061
2062         if (!obj)
2063                 yaffsfs_SetError(-EBADF);
2064         else {
2065                 retVal = yaffs_set_xattrib(obj, name, data, size, flags);
2066                 if (retVal < 0) {
2067                         yaffsfs_SetError(retVal);
2068                         retVal = -1;
2069                 }
2070         }
2071
2072         yaffsfs_Unlock();
2073
2074         return retVal;
2075 }
2076
2077 static int yaffs_do_getxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
2078                         const char *name, void *data, int size, int follow)
2079 {
2080         struct yaffs_obj *obj;
2081         struct yaffs_obj *dir;
2082         int retVal = -1;
2083         int notDir = 0;
2084         int loop = 0;
2085
2086         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0 ||
2087             yaffsfs_CheckMemRegion(name, 0, 0) < 0 ||
2088             yaffsfs_CheckMemRegion(data, size, 1) < 0) {
2089                 yaffsfs_SetError(-EFAULT);
2090                 return -1;
2091         }
2092
2093         if (yaffsfs_CheckPath(path) < 0) {
2094                 yaffsfs_SetError(-ENAMETOOLONG);
2095                 return -1;
2096         }
2097
2098         yaffsfs_Lock();
2099
2100         obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
2101
2102         if (follow)
2103                 obj = yaffsfs_FollowLink(obj, 0, &loop);
2104
2105         if (!dir && notDir)
2106                 yaffsfs_SetError(-ENOTDIR);
2107         else if (loop)
2108                 yaffsfs_SetError(-ELOOP);
2109         else if (!dir || !obj)
2110                 yaffsfs_SetError(-ENOENT);
2111         else {
2112                 retVal = yaffs_get_xattrib(obj, name, data, size);
2113                 if (retVal < 0) {
2114                         yaffsfs_SetError(retVal);
2115                         retVal = -1;
2116                 }
2117         }
2118         yaffsfs_Unlock();
2119
2120         return retVal;
2121
2122 }
2123
2124 int yaffs_getxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
2125                         const char *name, void *data, int size)
2126 {
2127         return yaffs_do_getxattr_reldir(reldir, path, name, data, size, 1);
2128 }
2129
2130 int yaffs_getxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name, void *data, int size)
2131 {
2132         return yaffs_getxattr_reldir(ROOT_DIR(dev), path, name, data, size);
2133 }
2134
2135 int yaffs_getxattr(const YCHAR *path, const char *name, void *data, int size)
2136 {
2137         return yaffs_getxattr_reldir(NULL, path, name, data, size);
2138 }
2139
2140 int yaffs_lgetxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
2141                         const char *name, void *data, int size)
2142 {
2143         return yaffs_do_getxattr_reldir(reldir, path, name, data, size, 0);
2144 }
2145
2146 int yaffs_lgetxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name, void *data, int size)
2147 {
2148         return yaffs_lgetxattr_reldir(ROOT_DIR(dev), path, name, data, size);
2149 }
2150
2151 int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size)
2152 {
2153         return yaffs_lgetxattr_reldir(NULL, path, name, data, size);
2154 }
2155
2156 int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
2157 {
2158         struct yaffs_obj *obj;
2159
2160         int retVal = -1;
2161
2162         if (yaffsfs_CheckMemRegion(name, 0, 0) < 0 ||
2163             yaffsfs_CheckMemRegion(data, size, 1) < 0) {
2164                 yaffsfs_SetError(-EFAULT);
2165                 return -1;
2166         }
2167
2168         yaffsfs_Lock();
2169         obj = yaffsfs_HandleToObject(fd);
2170
2171         if (obj) {
2172                 retVal = yaffs_get_xattrib(obj, name, data, size);
2173                 if (retVal < 0) {
2174                         yaffsfs_SetError(retVal);
2175                         retVal = -1;
2176                 }
2177         } else
2178                 /* bad handle */
2179                 yaffsfs_SetError(-EBADF);
2180
2181         yaffsfs_Unlock();
2182
2183         return retVal;
2184 }
2185
2186 static int yaffs_do_listxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
2187                                 char *data, int size, int follow)
2188 {
2189         struct yaffs_obj *obj = NULL;
2190         struct yaffs_obj *dir = NULL;
2191         int retVal = -1;
2192         int notDir = 0;
2193         int loop = 0;
2194
2195         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0 ||
2196             yaffsfs_CheckMemRegion(data, size, 1) < 0) {
2197                 yaffsfs_SetError(-EFAULT);
2198                 return -1;
2199         }
2200
2201         if (yaffsfs_CheckPath(path) < 0) {
2202                 yaffsfs_SetError(-ENAMETOOLONG);
2203                 return -1;
2204         }
2205
2206         yaffsfs_Lock();
2207
2208         obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
2209
2210         if (follow)
2211                 obj = yaffsfs_FollowLink(obj, 0, &loop);
2212
2213         if (!dir && notDir)
2214                 yaffsfs_SetError(-ENOTDIR);
2215         else if (loop)
2216                 yaffsfs_SetError(-ELOOP);
2217         else if (!dir || !obj)
2218                 yaffsfs_SetError(-ENOENT);
2219         else {
2220                 retVal = yaffs_list_xattrib(obj, data, size);
2221                 if (retVal < 0) {
2222                         yaffsfs_SetError(retVal);
2223                         retVal = -1;
2224                 }
2225         }
2226
2227         yaffsfs_Unlock();
2228
2229         return retVal;
2230
2231 }
2232
2233 int yaffs_listxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
2234                         char *data, int size)
2235 {
2236         return yaffs_do_listxattr_reldir(reldir, path, data, size, 1);
2237 }
2238
2239 int yaffs_listxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, char *data, int size)
2240 {
2241         return yaffs_listxattr_reldir(ROOT_DIR(dev), path, data, size);
2242 }
2243
2244 int yaffs_listxattr(const YCHAR *path, char *data, int size)
2245 {
2246         return yaffs_listxattr_reldir(NULL, path, data, size);
2247 }
2248
2249 int yaffs_llistxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
2250                         char *data, int size)
2251 {
2252         return yaffs_do_listxattr_reldir(reldir, path, data, size, 0);
2253 }
2254
2255 int yaffs_llistxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, char *data, int size)
2256 {
2257         return yaffs_llistxattr_reldir(ROOT_DIR(dev), path, data, size);
2258 }
2259
2260 int yaffs_llistxattr(const YCHAR *path, char *data, int size)
2261 {
2262         return yaffs_llistxattr_reldir(NULL, path, data, size);
2263 }
2264
2265 int yaffs_flistxattr(int fd, char *data, int size)
2266 {
2267         struct yaffs_obj *obj;
2268
2269         int retVal = -1;
2270
2271         if (yaffsfs_CheckMemRegion(data, size, 1) < 0) {
2272                 yaffsfs_SetError(-EFAULT);
2273                 return -1;
2274         }
2275
2276         yaffsfs_Lock();
2277         obj = yaffsfs_HandleToObject(fd);
2278
2279         if (obj) {
2280                 retVal = yaffs_list_xattrib(obj, data, size);
2281                 if (retVal < 0) {
2282                         yaffsfs_SetError(retVal);
2283                         retVal = -1;
2284                 }
2285         } else
2286                 /* bad handle */
2287                 yaffsfs_SetError(-EBADF);
2288
2289         yaffsfs_Unlock();
2290
2291         return retVal;
2292 }
2293
2294 static int yaffs_do_removexattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
2295                                 const char *name, int follow)
2296 {
2297         struct yaffs_obj *obj = NULL;
2298         struct yaffs_obj *dir = NULL;
2299         int notDir = 0;
2300         int loop = 0;
2301         int retVal = -1;
2302
2303         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0 ||
2304             yaffsfs_CheckMemRegion(name, 0, 0) < 0) {
2305                 yaffsfs_SetError(-EFAULT);
2306                 return -1;
2307         }
2308
2309         if (yaffsfs_CheckPath(path) < 0) {
2310                 yaffsfs_SetError(-ENAMETOOLONG);
2311                 return -1;
2312         }
2313
2314         yaffsfs_Lock();
2315
2316         obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
2317
2318         if (follow)
2319                 obj = yaffsfs_FollowLink(obj, 0, &loop);
2320
2321         if (!dir && notDir)
2322                 yaffsfs_SetError(-ENOTDIR);
2323         else if (loop)
2324                 yaffsfs_SetError(-ELOOP);
2325         else if (!dir || !obj)
2326                 yaffsfs_SetError(-ENOENT);
2327         else {
2328                 retVal = yaffs_remove_xattrib(obj, name);
2329                 if (retVal < 0) {
2330                         yaffsfs_SetError(retVal);
2331                         retVal = -1;
2332                 }
2333         }
2334
2335         yaffsfs_Unlock();
2336
2337         return retVal;
2338
2339 }
2340
2341 int yaffs_removexattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
2342                         const char *name)
2343 {
2344         return yaffs_do_removexattr_reldir(reldir, path, name, 1);
2345 }
2346
2347 int yaffs_removexattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name)
2348 {
2349         return yaffs_removexattr_reldir(ROOT_DIR(dev), path, name);
2350 }
2351
2352 int yaffs_removexattr(const YCHAR *path, const char *name)
2353 {
2354         return yaffs_removexattr_reldir(NULL, path, name);
2355 }
2356
2357 int yaffs_lremovexattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
2358                         const char *name)
2359 {
2360         return yaffs_do_removexattr_reldir(reldir, path, name, 0);
2361 }
2362
2363 int yaffs_lremovexattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name)
2364 {
2365         return yaffs_lremovexattr_reldir(ROOT_DIR(dev), path, name);
2366 }
2367
2368 int yaffs_lremovexattr(const YCHAR *path, const char *name)
2369 {
2370         return yaffs_lremovexattr_reldir(NULL, path, name);
2371 }
2372
2373 int yaffs_fremovexattr(int fd, const char *name)
2374 {
2375         struct yaffs_obj *obj;
2376
2377         int retVal = -1;
2378
2379         if (yaffsfs_CheckMemRegion(name, 0, 0) < 0) {
2380                 yaffsfs_SetError(-EFAULT);
2381                 return -1;
2382         }
2383
2384         yaffsfs_Lock();
2385         obj = yaffsfs_HandleToObject(fd);
2386
2387         if (obj) {
2388                 retVal = yaffs_remove_xattrib(obj, name);
2389                 if (retVal < 0) {
2390                         yaffsfs_SetError(retVal);
2391                         retVal = -1;
2392                 }
2393         } else
2394                 /* bad handle */
2395                 yaffsfs_SetError(-EBADF);
2396
2397         yaffsfs_Unlock();
2398
2399         return retVal;
2400 }
2401 #endif
2402
2403 #ifdef CONFIG_YAFFS_WINCE
2404 int yaffs_get_wince_times(int fd, unsigned *wctime,
2405                           unsigned *watime, unsigned *wmtime)
2406 {
2407         struct yaffs_obj *obj;
2408
2409         int retVal = -1;
2410
2411         yaffsfs_Lock();
2412         obj = yaffsfs_HandleToObject(fd);
2413
2414         if (obj) {
2415
2416                 if (wctime) {
2417                         wctime[0] = obj->win_ctime[0];
2418                         wctime[1] = obj->win_ctime[1];
2419                 }
2420                 if (watime) {
2421                         watime[0] = obj->win_atime[0];
2422                         watime[1] = obj->win_atime[1];
2423                 }
2424                 if (wmtime) {
2425                         wmtime[0] = obj->win_mtime[0];
2426                         wmtime[1] = obj->win_mtime[1];
2427                 }
2428
2429                 retVal = 0;
2430         } else
2431                 /*  bad handle */
2432                 yaffsfs_SetError(-EBADF);
2433
2434         yaffsfs_Unlock();
2435
2436         return retVal;
2437 }
2438
2439 int yaffs_set_wince_times(int fd,
2440                           const unsigned *wctime,
2441                           const unsigned *watime, const unsigned *wmtime)
2442 {
2443         struct yaffs_obj *obj;
2444         int result;
2445         int retVal = -1;
2446
2447         yaffsfs_Lock();
2448         obj = yaffsfs_HandleToObject(fd);
2449
2450         if (obj) {
2451
2452                 if (wctime) {
2453                         obj->win_ctime[0] = wctime[0];
2454                         obj->win_ctime[1] = wctime[1];
2455                 }
2456                 if (watime) {
2457                         obj->win_atime[0] = watime[0];
2458                         obj->win_atime[1] = watime[1];
2459                 }
2460                 if (wmtime) {
2461                         obj->win_mtime[0] = wmtime[0];
2462                         obj->win_mtime[1] = wmtime[1];
2463                 }
2464
2465                 obj->dirty = 1;
2466                 result = yaffs_flush_file(obj, 0, 0, 0);
2467                 retVal = 0;
2468         } else
2469                 /* bad handle */
2470                 yaffsfs_SetError(-EBADF);
2471
2472         yaffsfs_Unlock();
2473
2474         return retVal;
2475 }
2476
2477 #endif
2478
2479 static int yaffsfs_DoChMod(struct yaffs_obj *obj, mode_t mode)
2480 {
2481         int result = -1;
2482
2483         if (obj)
2484                 obj = yaffs_get_equivalent_obj(obj);
2485
2486         if (obj) {
2487                 obj->yst_mode = mode;
2488                 obj->dirty = 1;
2489                 result = yaffs_flush_file(obj, 0, 0, 0);
2490         }
2491
2492         return result == YAFFS_OK ? 0 : -1;
2493 }
2494
2495 int yaffs_access_reldir(struct yaffs_obj *reldir, const YCHAR *path, int amode)
2496 {
2497         struct yaffs_obj *obj = NULL;
2498         struct yaffs_obj *dir = NULL;
2499         int notDir = 0;
2500         int loop = 0;
2501         int retval = -1;
2502
2503         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
2504                 yaffsfs_SetError(-EFAULT);
2505                 return -1;
2506         }
2507
2508         if (yaffsfs_CheckPath(path) < 0) {
2509                 yaffsfs_SetError(-ENAMETOOLONG);
2510                 return -1;
2511         }
2512
2513         if (amode & ~(R_OK | W_OK | X_OK)) {
2514                 yaffsfs_SetError(-EINVAL);
2515                 return -1;
2516         }
2517
2518         yaffsfs_Lock();
2519
2520         obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
2521         obj = yaffsfs_FollowLink(obj, 0, &loop);
2522
2523         if (!dir && notDir)
2524                 yaffsfs_SetError(-ENOTDIR);
2525         else if (loop)
2526                 yaffsfs_SetError(-ELOOP);
2527         else if (!dir || !obj)
2528                 yaffsfs_SetError(-ENOENT);
2529         else if ((amode & W_OK) && obj->my_dev->read_only)
2530                 yaffsfs_SetError(-EROFS);
2531         else {
2532                 int access_ok = 1;
2533
2534                 if ((amode & R_OK) && !(obj->yst_mode & S_IREAD))
2535                         access_ok = 0;
2536                 if ((amode & W_OK) && !(obj->yst_mode & S_IWRITE))
2537                         access_ok = 0;
2538                 if ((amode & X_OK) && !(obj->yst_mode & S_IEXEC))
2539                         access_ok = 0;
2540
2541                 if (!access_ok)
2542                         yaffsfs_SetError(-EACCES);
2543                 else
2544                         retval = 0;
2545         }
2546
2547         yaffsfs_Unlock();
2548
2549         return retval;
2550
2551 }
2552
2553 int yaffs_access_reldev(struct yaffs_dev *dev, const YCHAR *path, int amode)
2554 {
2555         return yaffs_access_reldir(ROOT_DIR(dev), path, amode);
2556 }
2557
2558 int yaffs_access(const YCHAR *path, int amode)
2559 {
2560         return yaffs_access_reldir(NULL, path, amode);
2561 }
2562
2563 int yaffs_chmod_reldir(struct yaffs_obj *reldir, const YCHAR *path, mode_t mode)
2564 {
2565         struct yaffs_obj *obj = NULL;
2566         struct yaffs_obj *dir = NULL;
2567         int retVal = -1;
2568         int notDir = 0;
2569         int loop = 0;
2570
2571         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
2572                 yaffsfs_SetError(-EFAULT);
2573                 return -1;
2574         }
2575
2576         if (yaffsfs_CheckPath(path) < 0) {
2577                 yaffsfs_SetError(-ENAMETOOLONG);
2578                 return -1;
2579         }
2580
2581         if (mode & ~(0777)) {
2582                 yaffsfs_SetError(-EINVAL);
2583                 return -1;
2584         }
2585
2586         yaffsfs_Lock();
2587
2588         obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
2589         obj = yaffsfs_FollowLink(obj, 0, &loop);
2590
2591         if (!dir && notDir)
2592                 yaffsfs_SetError(-ENOTDIR);
2593         else if (loop)
2594                 yaffsfs_SetError(-ELOOP);
2595         else if (!dir || !obj)
2596                 yaffsfs_SetError(-ENOENT);
2597         else if (obj->my_dev->read_only)
2598                 yaffsfs_SetError(-EROFS);
2599         else
2600                 retVal = yaffsfs_DoChMod(obj, mode);
2601
2602         yaffsfs_Unlock();
2603
2604         return retVal;
2605
2606 }
2607
2608 int yaffs_chmod_reldev(struct yaffs_dev *dev, const YCHAR *path, mode_t mode)
2609 {
2610         return yaffs_chmod_reldir(ROOT_DIR(dev), path, mode);
2611 }
2612
2613 int yaffs_chmod(const YCHAR *path, mode_t mode)
2614 {
2615         return yaffs_chmod_reldir(NULL, path, mode);
2616 }
2617
2618 int yaffs_fchmod(int fd, mode_t mode)
2619 {
2620         struct yaffs_obj *obj;
2621         int retVal = -1;
2622
2623         if (mode & ~(0777)) {
2624                 yaffsfs_SetError(-EINVAL);
2625                 return -1;
2626         }
2627
2628         yaffsfs_Lock();
2629         obj = yaffsfs_HandleToObject(fd);
2630
2631         if (!obj)
2632                 yaffsfs_SetError(-EBADF);
2633         else if (obj->my_dev->read_only)
2634                 yaffsfs_SetError(-EROFS);
2635         else
2636                 retVal = yaffsfs_DoChMod(obj, mode);
2637
2638         yaffsfs_Unlock();
2639
2640         return retVal;
2641 }
2642
2643 int yaffs_mkdir_reldir(struct yaffs_obj *reldir, const YCHAR *path, mode_t mode)
2644 {
2645         struct yaffs_obj *parent = NULL;
2646         struct yaffs_obj *dir = NULL;
2647         YCHAR *name;
2648         YCHAR *alt_path = NULL;
2649         int retVal = -1;
2650         int notDir = 0;
2651         int loop = 0;
2652
2653         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
2654                 yaffsfs_SetError(-EFAULT);
2655                 return -1;
2656         }
2657
2658         if (yaffsfs_CheckPath(path) < 0) {
2659                 yaffsfs_SetError(-ENAMETOOLONG);
2660                 return -1;
2661         }
2662
2663         if (yaffsfs_alt_dir_path(path, &alt_path) < 0) {
2664                 yaffsfs_SetError(-ENOMEM);
2665                 return -1;
2666         }
2667         if (alt_path)
2668                 path = alt_path;
2669
2670         yaffsfs_Lock();
2671         parent = yaffsfs_FindDirectory(reldir, path, &name, 0, &notDir, &loop);
2672         if (!parent && notDir)
2673                 yaffsfs_SetError(-ENOTDIR);
2674         else if (loop)
2675                 yaffsfs_SetError(-ELOOP);
2676         else if (!parent)
2677                 yaffsfs_SetError(-ENOENT);
2678         else if (yaffsfs_TooManyObjects(parent->my_dev))
2679                 yaffsfs_SetError(-ENFILE);
2680         else if (yaffs_strnlen(name, 5) == 0) {
2681                 /* Trying to make the root itself */
2682                 yaffsfs_SetError(-EEXIST);
2683         } else if (parent->my_dev->read_only)
2684                 yaffsfs_SetError(-EROFS);
2685         else {
2686                 dir = yaffs_create_dir(parent, name, mode, 0, 0);
2687                 if (dir)
2688                         retVal = 0;
2689                 else if (yaffs_find_by_name(parent, name))
2690                         yaffsfs_SetError(-EEXIST);      /* name exists */
2691                 else
2692                         yaffsfs_SetError(-ENOSPC);      /* assume no space */
2693         }
2694
2695         yaffsfs_Unlock();
2696
2697         kfree(alt_path);
2698
2699         return retVal;
2700 }
2701
2702 int yaffs_mkdir_reldev(struct yaffs_dev *dev, const YCHAR *path, mode_t mode)
2703 {
2704         return yaffs_mkdir_reldir(ROOT_DIR(dev), path, mode);
2705 }
2706
2707 int yaffs_mkdir(const YCHAR *path, mode_t mode)
2708 {
2709         return yaffs_mkdir_reldir(NULL, path, mode);
2710 }
2711
2712 int yaffs_rmdir_reldir(struct yaffs_obj *reldir, const YCHAR *path)
2713 {
2714         int result;
2715         YCHAR *alt_path;
2716
2717         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
2718                 yaffsfs_SetError(-EFAULT);
2719                 return -1;
2720         }
2721
2722         if (yaffsfs_CheckPath(path) < 0) {
2723                 yaffsfs_SetError(-ENAMETOOLONG);
2724                 return -1;
2725         }
2726
2727         if (yaffsfs_alt_dir_path(path, &alt_path) < 0) {
2728                 yaffsfs_SetError(-ENOMEM);
2729                 return -1;
2730         }
2731         if (alt_path)
2732                 path = alt_path;
2733         result = yaffsfs_DoUnlink_reldir(reldir, path, 1);
2734
2735         kfree(alt_path);
2736
2737         return result;
2738 }
2739
2740 int yaffs_rmdir_reldev(struct yaffs_dev *dev, const YCHAR *path)
2741 {
2742         return yaffs_rmdir_reldir(ROOT_DIR(dev), path);
2743 }
2744
2745 int yaffs_rmdir(const YCHAR *path)
2746 {
2747         return yaffs_rmdir_reldir(NULL, path);
2748 }
2749
2750 /*
2751  * The mount/unmount/sync functions act on devices rather than reldirs.
2752  */
2753 void *yaffs_getdev(const YCHAR *path)
2754 {
2755         struct yaffs_dev *dev = NULL;
2756         YCHAR *dummy;
2757         dev = yaffsfs_FindDevice(path, &dummy);
2758         return (void *)dev;
2759 }
2760
2761 int yaffs_mount_common(struct yaffs_dev *dev, const YCHAR *path,
2762                                 int read_only, int skip_checkpt)
2763 {
2764         int retVal = -1;
2765         int result = YAFFS_FAIL;
2766
2767         if (!dev) {
2768                 if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
2769                         yaffsfs_SetError(-EFAULT);
2770                         return -1;
2771                 }
2772
2773                 yaffs_trace(YAFFS_TRACE_MOUNT, "yaffs: Mounting %s", path);
2774
2775                 if (yaffsfs_CheckPath(path) < 0) {
2776                         yaffsfs_SetError(-ENAMETOOLONG);
2777                         return -1;
2778                 }
2779         }
2780
2781         yaffsfs_Lock();
2782
2783         yaffsfs_InitHandles();
2784
2785         if (!dev)
2786                 dev = yaffsfs_FindMountPoint(path);
2787
2788         if (dev) {
2789                 if (!dev->is_mounted) {
2790                         dev->read_only = read_only ? 1 : 0;
2791                         if (skip_checkpt) {
2792                                 u8 skip = dev->param.skip_checkpt_rd;
2793                                 dev->param.skip_checkpt_rd = 1;
2794                                 result = yaffs_guts_initialise(dev);
2795                                 dev->param.skip_checkpt_rd = skip;
2796                         } else {
2797                                 result = yaffs_guts_initialise(dev);
2798                         }
2799
2800                         if (result == YAFFS_FAIL)
2801                                 yaffsfs_SetError(-ENOMEM);
2802                         retVal = result ? 0 : -1;
2803
2804                 } else
2805                         yaffsfs_SetError(-EBUSY);
2806         } else
2807                 yaffsfs_SetError(-ENODEV);
2808
2809         yaffsfs_Unlock();
2810         return retVal;
2811
2812 }
2813
2814 int yaffs_mount3_reldev(struct yaffs_dev *dev, int read_only, int skip_checkpt)
2815 {
2816         return yaffs_mount_common(dev, NULL, read_only, skip_checkpt);
2817 }
2818
2819 int yaffs_mount3(const YCHAR *path, int read_only, int skip_checkpt)
2820 {
2821         return yaffs_mount_common(NULL, path, read_only, skip_checkpt);
2822 }
2823
2824 int yaffs_mount2_reldev(struct yaffs_dev *dev, int readonly)
2825 {
2826         return yaffs_mount_common(dev, NULL, readonly, 0);
2827 }
2828
2829 int yaffs_mount2(const YCHAR *path, int readonly)
2830 {
2831         return yaffs_mount_common(NULL, path, readonly, 0);
2832 }
2833
2834 int yaffs_mount_reldev(struct yaffs_dev *dev)
2835 {
2836         return yaffs_mount_common(dev, NULL, 0, 0);
2837 }
2838
2839 int yaffs_mount(const YCHAR *path)
2840 {
2841         return yaffs_mount_common(NULL, path, 0, 0);
2842 }
2843
2844 int yaffs_sync_common(struct yaffs_dev *dev, const YCHAR *path)
2845 {
2846         int retVal = -1;
2847         YCHAR *dummy;
2848
2849         if (!dev) {
2850                 if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
2851                         yaffsfs_SetError(-EFAULT);
2852                         return -1;
2853                 }
2854
2855                 if (yaffsfs_CheckPath(path) < 0) {
2856                         yaffsfs_SetError(-ENAMETOOLONG);
2857                         return -1;
2858                 }
2859         }
2860
2861         yaffsfs_Lock();
2862         if (!dev)
2863                 dev = yaffsfs_FindDevice(path, &dummy);
2864
2865         if (dev) {
2866                 if (!dev->is_mounted)
2867                         yaffsfs_SetError(-EINVAL);
2868                 else if (dev->read_only)
2869                         yaffsfs_SetError(-EROFS);
2870                 else {
2871
2872                         yaffs_flush_whole_cache(dev, 0);
2873                         yaffs_checkpoint_save(dev);
2874                         retVal = 0;
2875
2876                 }
2877         } else
2878                 yaffsfs_SetError(-ENODEV);
2879
2880         yaffsfs_Unlock();
2881         return retVal;
2882 }
2883
2884 int yaffs_sync_reldev(struct yaffs_dev *dev)
2885 {
2886         return yaffs_sync_common(dev, NULL);
2887 }
2888
2889 int yaffs_sync(const YCHAR *path)
2890 {
2891         return yaffs_sync_common(NULL, path);
2892 }
2893
2894
2895 static int yaffsfs_bg_gc_common(struct yaffs_dev *dev,
2896                                 const YCHAR *path,
2897                                 int urgency)
2898 {
2899         int retVal = -1;
2900         YCHAR *dummy;
2901
2902         if (!dev) {
2903                 if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
2904                         yaffsfs_SetError(-EFAULT);
2905                         return -1;
2906                 }
2907
2908                 if (yaffsfs_CheckPath(path) < 0) {
2909                         yaffsfs_SetError(-ENAMETOOLONG);
2910                         return -1;
2911                 }
2912         }
2913
2914         yaffsfs_Lock();
2915         if (!dev)
2916                 dev = yaffsfs_FindDevice(path, &dummy);
2917
2918         if (dev) {
2919                 if (!dev->is_mounted)
2920                         yaffsfs_SetError(-EINVAL);
2921                 else
2922                         retVal = yaffs_bg_gc(dev, urgency);
2923         } else
2924                 yaffsfs_SetError(-ENODEV);
2925
2926         yaffsfs_Unlock();
2927         return retVal;
2928 }
2929
2930 /* Background gc functions.
2931  * These return 0 when bg done or greater than 0 when gc has been
2932  * done and there is still a lot of garbage to be cleaned up.
2933  */
2934
2935 int yaffs_do_background_gc(const YCHAR *path, int urgency)
2936 {
2937         return yaffsfs_bg_gc_common(NULL, path, urgency);
2938 }
2939
2940 int yaffs_do_background_gc_reldev(struct yaffs_dev *dev, int urgency)
2941 {
2942         return yaffsfs_bg_gc_common(dev, NULL, urgency);
2943 }
2944
2945 static int yaffsfs_IsDevBusy(struct yaffs_dev *dev)
2946 {
2947         int i;
2948         struct yaffs_obj *obj;
2949
2950         for (i = 0; i < YAFFSFS_N_HANDLES; i++) {
2951                 obj = yaffsfs_HandleToObject(i);
2952                 if (obj && obj->my_dev == dev)
2953                         return 1;
2954         }
2955         return 0;
2956 }
2957
2958 int yaffs_remount_common(struct yaffs_dev *dev, const YCHAR *path,
2959                        int force, int read_only)
2960 {
2961         int retVal = -1;
2962
2963         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
2964                 yaffsfs_SetError(-EFAULT);
2965                 return -1;
2966         }
2967
2968         if (yaffsfs_CheckPath(path) < 0) {
2969                 yaffsfs_SetError(-ENAMETOOLONG);
2970                 return -1;
2971         }
2972
2973         yaffsfs_Lock();
2974         if (!dev)
2975                 dev = yaffsfs_FindMountPoint(path);
2976
2977         if (dev) {
2978                 if (dev->is_mounted) {
2979                         yaffs_flush_whole_cache(dev, 0);
2980
2981                         if (force || !yaffsfs_IsDevBusy(dev)) {
2982                                 if (read_only)
2983                                         yaffs_checkpoint_save(dev);
2984                                 dev->read_only = read_only ? 1 : 0;
2985                                 retVal = 0;
2986                         } else
2987                                 yaffsfs_SetError(-EBUSY);
2988
2989                 } else
2990                         yaffsfs_SetError(-EINVAL);
2991
2992         } else
2993                 yaffsfs_SetError(-ENODEV);
2994
2995         yaffsfs_Unlock();
2996         return retVal;
2997
2998 }
2999
3000 int yaffs_remount_reldev(struct yaffs_dev *dev, int force, int read_only)
3001 {
3002         return yaffs_remount_common(dev, NULL, force, read_only);
3003 }
3004 int yaffs_remount(const YCHAR *path, int force, int read_only)
3005 {
3006         return yaffs_remount_common(NULL, path, force, read_only);
3007 }
3008
3009 int yaffs_unmount2_common(struct yaffs_dev *dev, const YCHAR *path, int force)
3010 {
3011         int retVal = -1;
3012
3013         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
3014                 yaffsfs_SetError(-EFAULT);
3015                 return -1;
3016         }
3017
3018         if (yaffsfs_CheckPath(path) < 0) {
3019                 yaffsfs_SetError(-ENAMETOOLONG);
3020                 return -1;
3021         }
3022
3023         yaffsfs_Lock();
3024         if (!dev)
3025                 dev = yaffsfs_FindMountPoint(path);
3026
3027         if (dev) {
3028                 if (dev->is_mounted) {
3029                         int inUse;
3030                         yaffs_flush_whole_cache(dev, 0);
3031                         yaffs_checkpoint_save(dev);
3032                         inUse = yaffsfs_IsDevBusy(dev);
3033                         if (!inUse || force) {
3034                                 if (inUse)
3035                                         yaffsfs_BreakDeviceHandles(dev);
3036                                 yaffs_deinitialise(dev);
3037
3038                                 retVal = 0;
3039                         } else
3040                                 yaffsfs_SetError(-EBUSY);
3041
3042                 } else
3043                         yaffsfs_SetError(-EINVAL);
3044
3045         } else
3046                 yaffsfs_SetError(-ENODEV);
3047
3048         yaffsfs_Unlock();
3049         return retVal;
3050
3051 }
3052
3053 int yaffs_unmount2_reldev(struct yaffs_dev *dev, int force)
3054 {
3055         return yaffs_unmount2_common(dev, NULL, force);
3056 }
3057
3058 int yaffs_unmount2(const YCHAR *path, int force)
3059 {
3060         return yaffs_unmount2_common(NULL, path, force);
3061 }
3062
3063 int yaffs_unmount_reldev(struct yaffs_dev *dev)
3064 {
3065         return yaffs_unmount2_reldev(dev, 0);
3066 }
3067
3068 int yaffs_unmount(const YCHAR *path)
3069 {
3070         return yaffs_unmount2(path, 0);
3071 }
3072
3073 int yaffs_format_common(struct yaffs_dev *dev,
3074                 const YCHAR *path,
3075                 int unmount_flag,
3076                 int force_unmount_flag,
3077                 int remount_flag)
3078 {
3079         int retVal = 0;
3080         int result;
3081
3082         if (!dev) {
3083                 if (!path) {
3084                         yaffsfs_SetError(-EFAULT);
3085                         return -1;
3086                 }
3087
3088                 if (yaffsfs_CheckPath(path) < 0) {
3089                         yaffsfs_SetError(-ENAMETOOLONG);
3090                         return -1;
3091                 }
3092         }
3093
3094         yaffsfs_Lock();
3095         if (!dev)
3096                 dev = yaffsfs_FindMountPoint(path);
3097
3098         if (dev) {
3099                 int was_mounted = dev->is_mounted;
3100
3101                 if (dev->is_mounted && unmount_flag) {
3102                         int inUse;
3103                         yaffs_flush_whole_cache(dev, 0);
3104                         yaffs_checkpoint_save(dev);
3105                         inUse = yaffsfs_IsDevBusy(dev);
3106                         if (!inUse || force_unmount_flag) {
3107                                 if (inUse)
3108                                         yaffsfs_BreakDeviceHandles(dev);
3109                                 yaffs_deinitialise(dev);
3110                         }
3111                 }
3112
3113                 if(dev->is_mounted) {
3114                                 yaffsfs_SetError(-EBUSY);
3115                                 retVal = -1;
3116                 } else {
3117                         yaffs_guts_format_dev(dev);
3118                         if(was_mounted && remount_flag) {
3119                                 result = yaffs_guts_initialise(dev);
3120                                 if (result == YAFFS_FAIL) {
3121                                         yaffsfs_SetError(-ENOMEM);
3122                                         retVal = -1;
3123                                 }
3124                         }
3125                 }
3126         } else {
3127                 yaffsfs_SetError(-ENODEV);
3128                 retVal = -1;
3129         }
3130
3131         yaffsfs_Unlock();
3132         return retVal;
3133
3134 }
3135
3136 int yaffs_format_reldev(struct yaffs_dev *dev,
3137                 int unmount_flag,
3138                 int force_unmount_flag,
3139                 int remount_flag)
3140 {
3141         return yaffs_format_common(dev, NULL, unmount_flag,
3142                         force_unmount_flag, remount_flag);
3143 }
3144
3145 int yaffs_format(const YCHAR *path,
3146                 int unmount_flag,
3147                 int force_unmount_flag,
3148                 int remount_flag)
3149 {
3150         return yaffs_format_common(NULL, path, unmount_flag,
3151                         force_unmount_flag, remount_flag);
3152 }
3153
3154 Y_LOFF_T yaffs_freespace_common(struct yaffs_dev *dev, const YCHAR *path)
3155 {
3156         Y_LOFF_T retVal = -1;
3157         YCHAR *dummy;
3158
3159         if (!dev) {
3160                 if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
3161                         yaffsfs_SetError(-EFAULT);
3162                         return -1;
3163                 }
3164
3165                 if (yaffsfs_CheckPath(path) < 0) {
3166                         yaffsfs_SetError(-ENAMETOOLONG);
3167                         return -1;
3168                 }
3169         }
3170
3171         yaffsfs_Lock();
3172         if (!dev)
3173                 dev = yaffsfs_FindDevice(path, &dummy);
3174         if (dev && dev->is_mounted) {
3175                 retVal = yaffs_get_n_free_chunks(dev);
3176                 retVal *= dev->data_bytes_per_chunk;
3177
3178         } else
3179                 yaffsfs_SetError(-EINVAL);
3180
3181         yaffsfs_Unlock();
3182         return retVal;
3183 }
3184
3185 Y_LOFF_T yaffs_freespace_reldev(struct yaffs_dev *dev)
3186 {
3187         return yaffs_freespace_common(dev, NULL);
3188 }
3189
3190 Y_LOFF_T yaffs_freespace(const YCHAR *path)
3191 {
3192         return yaffs_freespace_common(NULL, path);
3193 }
3194
3195 Y_LOFF_T yaffs_totalspace_common(struct yaffs_dev *dev, const YCHAR *path)
3196 {
3197         Y_LOFF_T retVal = -1;
3198         YCHAR *dummy;
3199
3200         if (!dev) {
3201                 if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
3202                         yaffsfs_SetError(-EFAULT);
3203                         return -1;
3204                 }
3205
3206                 if (yaffsfs_CheckPath(path) < 0) {
3207                         yaffsfs_SetError(-ENAMETOOLONG);
3208                         return -1;
3209                 }
3210         }
3211
3212         yaffsfs_Lock();
3213         if (!dev)
3214                 dev = yaffsfs_FindDevice(path, &dummy);
3215         if (dev && dev->is_mounted) {
3216                 retVal = (dev->param.end_block - dev->param.start_block + 1) -
3217                     dev->param.n_reserved_blocks;
3218                 retVal *= dev->param.chunks_per_block;
3219                 retVal *= dev->data_bytes_per_chunk;
3220
3221         } else
3222                 yaffsfs_SetError(-EINVAL);
3223
3224         yaffsfs_Unlock();
3225         return retVal;
3226 }
3227
3228 Y_LOFF_T yaffs_totalspace_reldev(struct yaffs_dev *dev)
3229 {
3230         return yaffs_totalspace_common(dev, NULL);
3231 }
3232
3233 Y_LOFF_T yaffs_totalspace(const YCHAR *path)
3234 {
3235         return yaffs_totalspace_common(NULL, path);
3236 }
3237
3238 int yaffs_inodecount_common(struct yaffs_dev *dev, const YCHAR *path)
3239 {
3240         Y_LOFF_T retVal = -1;
3241         YCHAR *dummy;
3242
3243         if (!dev) {
3244                 if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
3245                         yaffsfs_SetError(-EFAULT);
3246                         return -1;
3247                 }
3248
3249                 if (yaffsfs_CheckPath(path) < 0) {
3250                         yaffsfs_SetError(-ENAMETOOLONG);
3251                         return -1;
3252                 }
3253         }
3254
3255         yaffsfs_Lock();
3256         if (!dev)
3257                 dev = yaffsfs_FindDevice(path, &dummy);
3258         if (dev && dev->is_mounted) {
3259                 int n_obj = dev->n_obj;
3260                 if (n_obj > dev->n_hardlinks)
3261                         retVal = n_obj - dev->n_hardlinks;
3262         }
3263
3264         if (retVal < 0)
3265                 yaffsfs_SetError(-EINVAL);
3266
3267         yaffsfs_Unlock();
3268         return retVal;
3269 }
3270
3271 int yaffs_inodecount_reldev(struct yaffs_dev *dev)
3272 {
3273         return yaffs_inodecount_common(dev, NULL);
3274 }
3275
3276 int yaffs_inodecount(const YCHAR *path)
3277 {
3278         return yaffs_inodecount_common(NULL, path);
3279 }
3280
3281 void yaffs_add_device(struct yaffs_dev *dev)
3282 {
3283         struct list_head *cfg;
3284         /* First check that the device is not in the list. */
3285
3286         list_for_each(cfg, &yaffsfs_deviceList) {
3287                 if (dev == list_entry(cfg, struct yaffs_dev, dev_list))
3288                         return;
3289         }
3290
3291         dev->is_mounted = 0;
3292         dev->param.remove_obj_fn = yaffsfs_RemoveObjectCallback;
3293
3294         if (!dev->dev_list.next)
3295                 INIT_LIST_HEAD(&dev->dev_list);
3296
3297         list_add(&dev->dev_list, &yaffsfs_deviceList);
3298
3299
3300 }
3301
3302 void yaffs_remove_device(struct yaffs_dev *dev)
3303 {
3304         list_del_init(&dev->dev_list);
3305 }
3306
3307 /* Functions to iterate through devices. NB Use with extreme care! */
3308
3309 static struct list_head *dev_iterator;
3310 void yaffs_dev_rewind(void)
3311 {
3312         dev_iterator = yaffsfs_deviceList.next;
3313 }
3314
3315 struct yaffs_dev *yaffs_next_dev(void)
3316 {
3317         struct yaffs_dev *retval;
3318
3319         if (!dev_iterator)
3320                 return NULL;
3321         if (dev_iterator == &yaffsfs_deviceList)
3322                 return NULL;
3323
3324         retval = list_entry(dev_iterator, struct yaffs_dev, dev_list);
3325         dev_iterator = dev_iterator->next;
3326         return retval;
3327 }
3328
3329 /* Directory search stuff. */
3330
3331 static struct list_head search_contexts;
3332
3333 static void yaffsfs_SetDirRewound(struct yaffsfs_DirSearchContext *dsc)
3334 {
3335         if (dsc &&
3336             dsc->dirObj &&
3337             dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
3338
3339                 dsc->offset = 0;
3340
3341                 if (list_empty(&dsc->dirObj->variant.dir_variant.children))
3342                         dsc->nextReturn = NULL;
3343                 else
3344                         dsc->nextReturn =
3345                             list_entry(dsc->dirObj->variant.dir_variant.
3346                                        children.next, struct yaffs_obj,
3347                                        siblings);
3348         } else {
3349                 /* Hey someone isn't playing nice! */
3350         }
3351 }
3352
3353 static void yaffsfs_DirAdvance(struct yaffsfs_DirSearchContext *dsc)
3354 {
3355         if (dsc &&
3356             dsc->dirObj &&
3357             dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
3358
3359                 if (dsc->nextReturn == NULL ||
3360                     list_empty(&dsc->dirObj->variant.dir_variant.children))
3361                         dsc->nextReturn = NULL;
3362                 else {
3363                         struct list_head *next = dsc->nextReturn->siblings.next;
3364
3365                         if (next == &dsc->dirObj->variant.dir_variant.children)
3366                                 dsc->nextReturn = NULL; /* end of list */
3367                         else
3368                                 dsc->nextReturn = list_entry(next,
3369                                                              struct yaffs_obj,
3370                                                              siblings);
3371                 }
3372         } else {
3373                 /* Hey someone isn't playing nice! */
3374         }
3375 }
3376
3377 static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj)
3378 {
3379
3380         struct list_head *i;
3381         struct yaffsfs_DirSearchContext *dsc;
3382
3383         /* if search contexts not initilised then skip */
3384         if (!search_contexts.next)
3385                 return;
3386
3387         /* Iterate through the directory search contexts.
3388          * If any are the one being removed, then advance the dsc to
3389          * the next one to prevent a hanging ptr.
3390          */
3391         list_for_each(i, &search_contexts) {
3392                 if (i) {
3393                         dsc = list_entry(i, struct yaffsfs_DirSearchContext,
3394                                          others);
3395                         if (dsc->nextReturn == obj)
3396                                 yaffsfs_DirAdvance(dsc);
3397                 }
3398         }
3399
3400 }
3401
3402 static yaffs_DIR *yaffsfs_opendir_reldir_no_lock(struct yaffs_obj *reldir,
3403                                         const YCHAR *dirname)
3404 {
3405         yaffs_DIR *dir = NULL;
3406         struct yaffs_obj *obj = NULL;
3407         struct yaffsfs_DirSearchContext *dsc = NULL;
3408         int notDir = 0;
3409         int loop = 0;
3410
3411         if (yaffsfs_CheckMemRegion(dirname, 0, 0) < 0) {
3412                 yaffsfs_SetError(-EFAULT);
3413                 return NULL;
3414         }
3415
3416         if (yaffsfs_CheckPath(dirname) < 0) {
3417                 yaffsfs_SetError(-ENAMETOOLONG);
3418                 return NULL;
3419         }
3420
3421         obj = yaffsfs_FindObject(reldir, dirname, 0, 1, NULL, &notDir, &loop);
3422
3423         if (!obj && notDir)
3424                 yaffsfs_SetError(-ENOTDIR);
3425         else if (loop)
3426                 yaffsfs_SetError(-ELOOP);
3427         else if (!obj)
3428                 yaffsfs_SetError(-ENOENT);
3429         else if (obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
3430                 yaffsfs_SetError(-ENOTDIR);
3431         else {
3432                 int i;
3433
3434                 for (i = 0, dsc = NULL; i < YAFFSFS_N_DSC && !dsc; i++) {
3435                         if (!yaffsfs_dsc[i].inUse)
3436                                 dsc = &yaffsfs_dsc[i];
3437                 }
3438
3439                 dir = (yaffs_DIR *) dsc;
3440
3441                 if (dsc) {
3442                         memset(dsc, 0, sizeof(struct yaffsfs_DirSearchContext));
3443                         dsc->inUse = 1;
3444                         dsc->dirObj = obj;
3445                         yaffs_strncpy(dsc->name, dirname, NAME_MAX);
3446                         INIT_LIST_HEAD(&dsc->others);
3447
3448                         if (!search_contexts.next)
3449                                 INIT_LIST_HEAD(&search_contexts);
3450
3451                         list_add(&dsc->others, &search_contexts);
3452                         yaffsfs_SetDirRewound(dsc);
3453                 }
3454         }
3455         return dir;
3456 }
3457
3458 yaffs_DIR *yaffs_opendir_reldir(struct yaffs_obj *reldir, const YCHAR *dirname)
3459 {
3460         yaffs_DIR *ret;
3461
3462         yaffsfs_Lock();
3463         ret = yaffsfs_opendir_reldir_no_lock(reldir, dirname);
3464         yaffsfs_Unlock();
3465         return ret;
3466 }
3467
3468 yaffs_DIR *yaffs_opendir_reldev(struct yaffs_dev *dev, const YCHAR *dirname)
3469 {
3470         return yaffs_opendir_reldir(ROOT_DIR(dev), dirname);
3471 }
3472
3473 yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
3474 {
3475         return yaffs_opendir_reldir(NULL, dirname);
3476 }
3477
3478 struct yaffs_dirent *yaffsfs_readdir_no_lock(yaffs_DIR * dirp)
3479 {
3480         struct yaffsfs_DirSearchContext *dsc;
3481         struct yaffs_dirent *retVal = NULL;
3482
3483         dsc = (struct yaffsfs_DirSearchContext *) dirp;
3484
3485
3486         if (dsc && dsc->inUse) {
3487                 yaffsfs_SetError(0);
3488                 if (dsc->nextReturn) {
3489                         dsc->de.d_ino =
3490                             yaffs_get_equivalent_obj(dsc->nextReturn)->obj_id;
3491                         dsc->de.d_dont_use = (unsigned)dsc->nextReturn;
3492                         dsc->de.d_off = dsc->offset++;
3493                         yaffs_get_obj_name(dsc->nextReturn,
3494                                            dsc->de.d_name, NAME_MAX);
3495                         if (yaffs_strnlen(dsc->de.d_name, NAME_MAX + 1) == 0) {
3496                                 /* this should not happen! */
3497                                 yaffs_strcpy(dsc->de.d_name, _Y("zz"));
3498                         }
3499                         dsc->de.d_reclen = sizeof(struct yaffs_dirent);
3500                         retVal = &dsc->de;
3501                         yaffsfs_DirAdvance(dsc);
3502                 } else
3503                         retVal = NULL;
3504         } else
3505                 yaffsfs_SetError(-EBADF);
3506
3507         return retVal;
3508
3509 }
3510 struct yaffs_dirent *yaffs_readdir(yaffs_DIR * dirp)
3511 {
3512         struct yaffs_dirent *ret;
3513
3514         yaffsfs_Lock();
3515         ret = yaffsfs_readdir_no_lock(dirp);
3516         yaffsfs_Unlock();
3517         return ret;
3518 }
3519
3520 static void yaffsfs_rewinddir_no_lock(yaffs_DIR *dirp)
3521 {
3522         struct yaffsfs_DirSearchContext *dsc;
3523
3524         dsc = (struct yaffsfs_DirSearchContext *) dirp;
3525
3526         if (yaffsfs_CheckMemRegion(dirp, sizeof(*dsc), 0) < 0)
3527                 return;
3528
3529         yaffsfs_SetDirRewound(dsc);
3530
3531 }
3532
3533 void yaffs_rewinddir(yaffs_DIR *dirp)
3534 {
3535         yaffsfs_Lock();
3536         yaffsfs_rewinddir_no_lock(dirp);
3537         yaffsfs_Unlock();
3538 }
3539
3540 struct yaffs_dirent *yaffs_readdir_fd(int fd)
3541 {
3542         struct yaffs_dirent *ret = NULL;
3543         struct yaffsfs_FileDes *f;
3544
3545         yaffsfs_Lock();
3546         f = yaffsfs_HandleToFileDes(fd);
3547         if(f && f->isDir)
3548                 ret = yaffsfs_readdir_no_lock(f->v.dir);
3549         yaffsfs_Unlock();
3550         return ret;
3551 }
3552
3553 void yaffs_rewinddir_fd(int fd)
3554 {
3555         struct yaffsfs_FileDes *f;
3556
3557         yaffsfs_Lock();
3558         f = yaffsfs_HandleToFileDes(fd);
3559         if(f && f->isDir)
3560                 yaffsfs_rewinddir_no_lock(f->v.dir);
3561         yaffsfs_Unlock();
3562 }
3563
3564
3565 static int yaffsfs_closedir_no_lock(yaffs_DIR *dirp)
3566 {
3567         struct yaffsfs_DirSearchContext *dsc;
3568
3569         dsc = (struct yaffsfs_DirSearchContext *) dirp;
3570
3571         if (yaffsfs_CheckMemRegion(dirp, sizeof(*dsc), 0) < 0) {
3572                 yaffsfs_SetError(-EFAULT);
3573                 return -1;
3574         }
3575
3576         dsc->inUse = 0;
3577         list_del(&dsc->others); /* unhook from list */
3578
3579         return 0;
3580 }
3581 int yaffs_closedir(yaffs_DIR *dirp)
3582 {
3583         int ret;
3584
3585         yaffsfs_Lock();
3586         ret = yaffsfs_closedir_no_lock(dirp);
3587         yaffsfs_Unlock();
3588         return ret;
3589 }
3590
3591 /* End of directory stuff */
3592
3593 int yaffs_symlink_reldir(struct yaffs_obj *reldir,
3594                        const YCHAR *oldpath, const YCHAR *newpath)
3595 {
3596         struct yaffs_obj *parent = NULL;
3597         struct yaffs_obj *obj;
3598         YCHAR *name;
3599         int retVal = -1;
3600         int mode = 0;           /* ignore for now */
3601         int notDir = 0;
3602         int loop = 0;
3603
3604         if (yaffsfs_CheckMemRegion(oldpath, 0, 0) < 0 ||
3605             yaffsfs_CheckMemRegion(newpath, 0, 0) < 0) {
3606                 yaffsfs_SetError(-EFAULT);
3607                 return -1;
3608         }
3609
3610         if (yaffsfs_CheckPath(newpath) < 0 || yaffsfs_CheckPath(oldpath) < 0) {
3611                 yaffsfs_SetError(-ENAMETOOLONG);
3612                 return -1;
3613         }
3614
3615         yaffsfs_Lock();
3616         parent = yaffsfs_FindDirectory(reldir, newpath, &name, 0, &notDir, &loop);
3617         if (!parent && notDir)
3618                 yaffsfs_SetError(-ENOTDIR);
3619         else if (loop)
3620                 yaffsfs_SetError(-ELOOP);
3621         else if (!parent || yaffs_strnlen(name, 5) < 1)
3622                 yaffsfs_SetError(-ENOENT);
3623         else if (yaffsfs_TooManyObjects(parent->my_dev))
3624                 yaffsfs_SetError(-ENFILE);
3625         else if (parent->my_dev->read_only)
3626                 yaffsfs_SetError(-EROFS);
3627         else if (parent) {
3628                 obj = yaffs_create_symlink(parent, name, mode, 0, 0, oldpath);
3629                 if (obj)
3630                         retVal = 0;
3631                 else if (yaffsfs_FindObject(reldir, newpath, 0, 0,
3632                                                 NULL, NULL, NULL))
3633                         yaffsfs_SetError(-EEXIST);
3634                 else
3635                         yaffsfs_SetError(-ENOSPC);
3636         }
3637
3638         yaffsfs_Unlock();
3639
3640         return retVal;
3641
3642 }
3643 int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
3644 {
3645         return yaffs_symlink_reldir(NULL, oldpath, newpath);
3646 }
3647
3648 int yaffs_readlink_reldir(struct yaffs_obj *reldir,const YCHAR *path,
3649                         YCHAR *buf, int bufsiz)
3650 {
3651         struct yaffs_obj *obj = NULL;
3652         struct yaffs_obj *dir = NULL;
3653         int retVal = -1;
3654         int notDir = 0;
3655         int loop = 0;
3656
3657         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0 ||
3658             yaffsfs_CheckMemRegion(buf, bufsiz, 1) < 0) {
3659                 yaffsfs_SetError(-EFAULT);
3660                 return -1;
3661         }
3662
3663         yaffsfs_Lock();
3664
3665         obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, &notDir, &loop);
3666
3667         if (!dir && notDir)
3668                 yaffsfs_SetError(-ENOTDIR);
3669         else if (loop)
3670                 yaffsfs_SetError(-ELOOP);
3671         else if (!dir || !obj)
3672                 yaffsfs_SetError(-ENOENT);
3673         else if (obj->variant_type != YAFFS_OBJECT_TYPE_SYMLINK)
3674                 yaffsfs_SetError(-EINVAL);
3675         else {
3676                 YCHAR *alias = obj->variant.symlink_variant.alias;
3677                 memset(buf, 0, bufsiz);
3678                 yaffs_strncpy(buf, alias, bufsiz - 1);
3679                 retVal = 0;
3680         }
3681         yaffsfs_Unlock();
3682         return retVal;
3683 }
3684 int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
3685 {
3686         return yaffs_readlink_reldir(NULL, path, buf, bufsiz);
3687 }
3688
3689 int yaffs_link_reldir(struct yaffs_obj *reldir,
3690                         const YCHAR *oldpath, const YCHAR *linkpath)
3691 {
3692         /* Creates a link called newpath to existing oldpath */
3693         struct yaffs_obj *obj = NULL;
3694         struct yaffs_obj *lnk = NULL;
3695         struct yaffs_obj *obj_dir = NULL;
3696         struct yaffs_obj *lnk_dir = NULL;
3697         int retVal = -1;
3698         int notDirObj = 0;
3699         int notDirLnk = 0;
3700         int objLoop = 0;
3701         int lnkLoop = 0;
3702         YCHAR *newname;
3703
3704         if (yaffsfs_CheckMemRegion(oldpath, 0, 0) < 0 ||
3705             yaffsfs_CheckMemRegion(linkpath, 0, 0) < 0) {
3706                 yaffsfs_SetError(-EFAULT);
3707                 return -1;
3708         }
3709
3710         if (yaffsfs_CheckPath(linkpath) < 0 || yaffsfs_CheckPath(oldpath) < 0) {
3711                 yaffsfs_SetError(-ENAMETOOLONG);
3712                 return -1;
3713         }
3714
3715         yaffsfs_Lock();
3716
3717         obj = yaffsfs_FindObject(reldir, oldpath, 0, 1,
3718                                  &obj_dir, &notDirObj, &objLoop);
3719         lnk = yaffsfs_FindObject(reldir, linkpath, 0, 0, NULL, NULL, NULL);
3720         lnk_dir = yaffsfs_FindDirectory(reldir, linkpath, &newname,
3721                                         0, &notDirLnk, &lnkLoop);
3722
3723         if ((!obj_dir && notDirObj) || (!lnk_dir && notDirLnk))
3724                 yaffsfs_SetError(-ENOTDIR);
3725         else if (objLoop || lnkLoop)
3726                 yaffsfs_SetError(-ELOOP);
3727         else if (!obj_dir || !lnk_dir || !obj)
3728                 yaffsfs_SetError(-ENOENT);
3729         else if (obj->my_dev->read_only)
3730                 yaffsfs_SetError(-EROFS);
3731         else if (yaffsfs_TooManyObjects(obj->my_dev))
3732                 yaffsfs_SetError(-ENFILE);
3733         else if (lnk)
3734                 yaffsfs_SetError(-EEXIST);
3735         else if (lnk_dir->my_dev != obj->my_dev)
3736                 yaffsfs_SetError(-EXDEV);
3737         else {
3738                 retVal = yaffsfs_CheckNameLength(newname);
3739
3740                 if (retVal == 0) {
3741                         lnk = yaffs_link_obj(lnk_dir, newname, obj);
3742                         if (lnk)
3743                                 retVal = 0;
3744                         else {
3745                                 yaffsfs_SetError(-ENOSPC);
3746                                 retVal = -1;
3747                         }
3748                 }
3749         }
3750         yaffsfs_Unlock();
3751
3752         return retVal;
3753 }
3754 int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
3755 {
3756         return yaffs_link_reldir(NULL, oldpath, linkpath);
3757 }
3758
3759 int yaffs_mknod_reldir(struct yaffs_obj *reldir, const YCHAR *pathname,
3760                      mode_t mode, dev_t dev_val)
3761 {
3762         (void) pathname;
3763         (void) mode;
3764         (void) dev_val;
3765         (void) reldir;
3766
3767         yaffsfs_SetError(-EINVAL);
3768         return -1;
3769 }
3770
3771 int yaffs_mknod_reldev(struct yaffs_dev *dev, const YCHAR *pathname, mode_t mode, dev_t dev_val)
3772 {
3773         return yaffs_mknod_reldir(ROOT_DIR(dev), pathname, mode, dev_val);
3774 }
3775
3776 int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev_val)
3777 {
3778         return yaffs_mknod_reldir(NULL, pathname, mode, dev_val);
3779 }
3780
3781 /*
3782  * D E B U G   F U N C T I O N S
3783  */
3784
3785 /*
3786  * yaffs_n_handles()
3787  * Returns number of handles attached to the object
3788  */
3789 int yaffs_n_handles_reldir(struct yaffs_obj *reldir, const YCHAR *path)
3790 {
3791         struct yaffs_obj *obj;
3792
3793         if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
3794                 yaffsfs_SetError(-EFAULT);
3795                 return -1;
3796         }
3797
3798         if (yaffsfs_CheckPath(path) < 0) {
3799                 yaffsfs_SetError(-ENAMETOOLONG);
3800                 return -1;
3801         }
3802
3803         obj = yaffsfs_FindObject(reldir, path, 0, 1, NULL, NULL, NULL);
3804
3805         if (obj)
3806                 return yaffsfs_CountHandles(obj);
3807         else
3808                 return -1;
3809 }
3810
3811 int yaffs_n_handles(const YCHAR *path)
3812 {
3813         return yaffs_n_handles_reldir(NULL, path);
3814 }
3815
3816 int yaffs_get_error(void)
3817 {
3818         return yaffsfs_GetLastError();
3819 }
3820
3821 int yaffs_set_error(int error)
3822 {
3823         yaffsfs_SetError(error);
3824         return 0;
3825 }
3826
3827 int yaffs_dump_dev_reldir(struct yaffs_obj *reldir, const YCHAR *path)
3828 {
3829 #if 1
3830         (void) path;
3831         (void) reldir;
3832 #else
3833         YCHAR *rest;
3834
3835
3836         if (!reldir)
3837                 reldir = yaffsfs_FindRoot(path, &rest);
3838
3839         if (reldir) {
3840                 struct yaffs_dev *dev = reldir->my_dev;
3841
3842                 printf("\n"
3843                        "n_page_writes.......... %d\n"
3844                        "n_page_reads........... %d\n"
3845                        "n_erasures....... %d\n"
3846                        "n_gc_copies............ %d\n"
3847                        "garbageCollections... %d\n"
3848                        "passiveGarbageColl'ns %d\n"
3849                        "\n",
3850                        dev->n_page_writes,
3851                        dev->n_page_reads,
3852                        dev->n_erasures,
3853                        dev->n_gc_copies,
3854                        dev->garbageCollections, dev->passiveGarbageCollections);
3855
3856         }
3857 #endif
3858         return 0;
3859 }
3860
3861 int yaffs_dump_dev(const YCHAR *path)
3862 {
3863         return yaffs_dump_dev_reldir(NULL, path);
3864 }