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