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