/*
* YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
*
- * Copyright (C) 2002-2011 Aleph One Ltd.
- * for Toby Churchill Ltd and Brightstar Engineering
+ * Copyright (C) 2002-2018 Aleph One Ltd.
*
* Created by Charles Manning <charles@aleph1.co.uk>
*
#include "string.h"
+#define YAFFS_MAX_RW_SIZE 0x70000000
#define YAFFSFS_MAX_SYMLINK_DEREFERENCES 5
#ifndef NULL
#define NULL ((void *)0)
#endif
+#define ROOT_DIR(dev) (((dev) && (dev)->is_mounted) ? (dev)->root_dir : NULL)
+
/* YAFFSFS_RW_SIZE must be a power of 2 */
#define YAFFSFS_RW_SHIFT (13)
#define YAFFSFS_RW_SIZE (1<<YAFFSFS_RW_SHIFT)
int *notDir, int *loop);
static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj);
+static yaffs_DIR *yaffsfs_opendir_reldir_no_lock(
+ struct yaffs_obj *reldir, const YCHAR *dirname);
+static int yaffsfs_closedir_no_lock(yaffs_DIR *dirent);
unsigned int yaffs_wr_attempts;
struct yaffs_obj *iObj;
};
+
+struct yaffsfs_DirSearchContext {
+ struct yaffs_dirent de; /* directory entry */
+ YCHAR name[NAME_MAX + 1]; /* name of directory being searched */
+ struct yaffs_obj *dirObj; /* ptr to directory being searched */
+ struct yaffs_obj *nextReturn; /* obj returned by next readddir */
+ struct list_head others;
+ s32 offset:20;
+ u8 inUse:1;
+};
+
struct yaffsfs_FileDes {
+ u8 isDir:1; /* This s a directory */
u8 reading:1;
u8 writing:1;
u8 append:1;
u8 shareRead:1;
u8 shareWrite:1;
- int inodeId:12; /* Index to corresponding yaffsfs_Inode */
- int handleCount:10; /* Number of handles for this fd */
- Y_LOFF_T position; /* current position in file */
+ s32 inodeId:12; /* Index to corresponding yaffsfs_Inode */
+ s32 handleCount:10; /* Number of handles for this fd */
+ union {
+ Y_LOFF_T position; /* current position in file */
+ yaffs_DIR *dir;
+ } v;
};
struct yaffsfs_Handle {
};
-struct yaffsfs_DirSearchContxt {
- struct yaffs_dirent de; /* directory entry */
- YCHAR name[NAME_MAX + 1]; /* name of directory being searched */
- struct yaffs_obj *dirObj; /* ptr to directory being searched */
- struct yaffs_obj *nextReturn; /* obj returned by next readddir */
- struct list_head others;
- int offset:20;
- unsigned inUse:1;
-};
-
-static struct yaffsfs_DirSearchContxt yaffsfs_dsc[YAFFSFS_N_DSC];
+static struct yaffsfs_DirSearchContext yaffsfs_dsc[YAFFSFS_N_DSC];
static struct yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES];
static struct yaffsfs_FileDes yaffsfs_fd[YAFFSFS_N_HANDLES];
static struct yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
static void yaffsfs_InitHandles(void)
{
int i;
+
if (yaffsfs_handlesInitialised)
return;
+ yaffsfs_handlesInitialised = 1;
+
memset(yaffsfs_inode, 0, sizeof(yaffsfs_inode));
memset(yaffsfs_fd, 0, sizeof(yaffsfs_fd));
memset(yaffsfs_handle, 0, sizeof(yaffsfs_handle));
struct yaffs_obj *obj;
obj = in->iObj;
-
- if (obj->unlinked)
- yaffs_del_obj(obj);
-
obj->my_inode = NULL;
in->iObj = NULL;
+ if (obj->unlinked)
+ yaffs_del_obj(obj);
}
static void yaffsfs_PutInode(int inodeId)
fd = &yaffsfs_fd[fdId];
fd->handleCount--;
if (fd->handleCount < 1) {
+ if (fd->isDir) {
+ yaffsfs_closedir_no_lock(fd->v.dir);
+ fd->v.dir = NULL;
+ }
if (fd->inodeId >= 0) {
yaffsfs_PutInode(fd->inodeId);
fd->inodeId = -1;
* Stuff to handle names.
*/
#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
-
+#ifndef CONFIG_YAFFS_WINCE
static int yaffs_toupper(YCHAR a)
{
if (a >= 'a' && a <= 'z')
else
return a;
}
+#endif
static int yaffsfs_Match(YCHAR a, YCHAR b)
{
return 0;
}
-static int yaffsfs_CheckNameLength(const char *name)
+static int yaffsfs_CheckNameLength(const YCHAR *name)
{
int retVal = 0;
thisMatchLength = 0;
matching = 1;
+
if(!p)
continue;
- while (matching && *p && *leftOver) {
- /* Skip over any /s */
- while (yaffsfs_IsPathDivider(*p))
- p++;
+ /* Skip over any leading /s */
+ while (yaffsfs_IsPathDivider(*p))
+ p++;
+ while (yaffsfs_IsPathDivider(*leftOver))
+ leftOver++;
- /* Skip over any /s */
- while (yaffsfs_IsPathDivider(*leftOver))
- leftOver++;
+ while (matching && *p && *leftOver) {
/* Now match the text part */
while (matching &&
matching = 0;
}
}
+
+ if ((*p && !yaffsfs_IsPathDivider(*p)) ||
+ (*leftOver && !yaffsfs_IsPathDivider(*leftOver)))
+ matching = 0;
+ else {
+ while (yaffsfs_IsPathDivider(*p))
+ p++;
+ while (yaffsfs_IsPathDivider(*leftOver))
+ leftOver++;
+ }
}
/* Skip over any /s in leftOver */
retval = dev;
longestMatch = thisMatchLength;
}
-
}
return retval;
}
YCHAR *alias = obj->variant.symlink_variant.alias;
if (yaffsfs_IsPathDivider(*alias))
- /* Starts with a /, need to scan from root up */
+ /*
+ * Starts with a /, need to scan from root up */
+ /* NB Might not work if this is called with root != NULL
+ */
obj = yaffsfs_FindObject(NULL, alias, symDepth++,
1, NULL, NULL, loop);
else
if (dirOut)
*dirOut = dir;
- if (dir && *name)
+ /* At this stage we have looked up directory part and have the name part
+ * in name if there is one.
+ *
+ * eg /nand/x/ will give us a name of ""
+ * /nand/x will give us a name of "x"
+ *
+ * Since the name part might be "." or ".." which need to be fixed.
+ */
+ if (dir && (yaffs_strcmp(name, _Y("..")) == 0)) {
+ dir = dir->parent;
+ obj = dir;
+ } else if (dir && (yaffs_strcmp(name, _Y(".")) == 0))
+ obj = dir;
+ else if (dir && *name)
obj = yaffs_find_by_name(dir, name);
else
obj = dir;
return 0;
}
-int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
+int yaffs_open_sharing_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ int oflag, int mode, int sharing)
{
struct yaffs_obj *obj = NULL;
struct yaffs_obj *dir = NULL;
u8 writeRequested;
int notDir = 0;
int loop = 0;
+ int is_dir = 0;
+ yaffs_DIR *dsc = NULL;
if (yaffsfs_CheckMemRegion(path, 0, 0)< 0) {
yaffsfs_SetError(-EFAULT);
oflag &= ~(O_EXCL);
/* O_TRUNC has no meaning if (O_CREAT | O_EXCL) is specified */
- if ((oflag & O_CREAT) & (oflag & O_EXCL))
+ if ((oflag & O_CREAT) && (oflag & O_EXCL))
oflag &= ~(O_TRUNC);
/* Todo: Are there any more flag combos to sanitise ? */
if (handle < 0) {
yaffsfs_SetError(-ENFILE);
- errorReported = 1;
+ errorReported = __LINE__;
} else {
fd = yaffsfs_HandleToFileDes(handle);
/* try to find the exisiting object */
- obj = yaffsfs_FindObject(NULL, path, 0, 1, NULL, NULL, NULL);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, NULL, NULL, NULL);
obj = yaffsfs_FollowLink(obj, symDepth++, &loop);
if (obj) {
/* The file already exists or it might be a directory */
+ is_dir = (obj->variant_type ==
+ YAFFS_OBJECT_TYPE_DIRECTORY);
+
+ /*
+ * A directory can't be opened except for read, so we
+ * ignore other flags
+ */
+ if (is_dir) {
+ writeRequested = 0;
+ readRequested = 1;
+ rwflags = O_RDONLY;
+ }
- /* A directory can't be opened as a file */
- if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) {
- openDenied = 1;
- yaffsfs_SetError(-EISDIR);
- errorReported = 1;
+ if(is_dir) {
+ dsc = yaffsfs_opendir_reldir_no_lock(reldir, path);
+ if (!dsc) {
+ openDenied = __LINE__;
+ yaffsfs_SetError(-ENFILE);
+ errorReported = __LINE__;
+ }
}
/* Open should fail if O_CREAT and O_EXCL are specified
*/
if (!errorReported &&
(oflag & O_EXCL) && (oflag & O_CREAT)) {
- openDenied = 1;
+ openDenied = __LINE__;
yaffsfs_SetError(-EEXIST);
- errorReported = 1;
+ errorReported = __LINE__;
}
/* Check file permissions */
- if (readRequested && !(obj->yst_mode & S_IREAD))
- openDenied = 1;
+ if (readRequested && !(obj->yst_mode & S_IRUSR))
+ openDenied = __LINE__;
- if (writeRequested && !(obj->yst_mode & S_IWRITE))
- openDenied = 1;
+ if (writeRequested && !(obj->yst_mode & S_IWUSR))
+ openDenied = __LINE__;
if (!errorReported && writeRequested &&
obj->my_dev->read_only) {
- openDenied = 1;
+ openDenied = __LINE__;
yaffsfs_SetError(-EROFS);
- errorReported = 1;
+ errorReported = __LINE__;
}
if (openDenied && !errorReported) {
yaffsfs_SetError(-EACCES);
- errorReported = 1;
+ errorReported = __LINE__;
}
/* Check sharing of an existing object. */
(!shareRead && alreadyReading) ||
(!sharedWriteAllowed && writeRequested) ||
(!shareWrite && alreadyWriting)) {
- openDenied = 1;
+ openDenied = __LINE__;
yaffsfs_SetError(-EBUSY);
- errorReported = 1;
+ errorReported = __LINE__;
}
}
* the directory exists. If not, error.
*/
if (!obj && !errorReported) {
- dir = yaffsfs_FindDirectory(NULL, path, &name, 0,
+ dir = yaffsfs_FindDirectory(reldir, path, &name, 0,
¬Dir, &loop);
if (!dir && notDir) {
yaffsfs_SetError(-ENOTDIR);
- errorReported = 1;
+ errorReported = __LINE__;
} else if (loop) {
yaffsfs_SetError(-ELOOP);
- errorReported = 1;
+ errorReported = __LINE__;
} else if (!dir) {
yaffsfs_SetError(-ENOENT);
- errorReported = 1;
+ errorReported = __LINE__;
}
}
/* Let's see if we can create this file */
if (dir->my_dev->read_only) {
yaffsfs_SetError(-EROFS);
- errorReported = 1;
+ errorReported = __LINE__;
} else if (yaffsfs_TooManyObjects(dir->my_dev)) {
yaffsfs_SetError(-ENFILE);
- errorReported = 1;
+ errorReported = __LINE__;
} else
obj = yaffs_create_file(dir, name, mode, 0, 0);
if (!obj && !errorReported) {
yaffsfs_SetError(-ENOSPC);
- errorReported = 1;
+ errorReported = __LINE__;
}
}
if (!obj && dir && !errorReported && !(oflag & O_CREAT)) {
yaffsfs_SetError(-ENOENT);
- errorReported = 1;
+ errorReported = __LINE__;
}
if (obj && !openDenied) {
fd->reading = readRequested;
fd->writing = writeRequested;
fd->append = (oflag & O_APPEND) ? 1 : 0;
- fd->position = 0;
fd->shareRead = shareRead;
fd->shareWrite = shareWrite;
+ fd->isDir = is_dir;
+
+ if(is_dir)
+ fd->v.dir = dsc;
+ else
+ fd->v.position = 0;
/* Hook inode to object */
obj->my_inode = (void *)&yaffsfs_inode[inodeId];
- if ((oflag & O_TRUNC) && fd->writing)
+ if (!is_dir && (oflag & O_TRUNC) && fd->writing)
yaffs_resize_file(obj, 0);
} else {
+ if (dsc)
+ yaffsfs_closedir_no_lock(dsc);
+ dsc = NULL;
yaffsfs_PutHandle(handle);
if (!errorReported)
yaffsfs_SetError(0); /* Problem */
return handle;
}
-int yaffs_open(const YCHAR *path, int oflag, int mode)
+int yaffs_open_sharing_reldev(struct yaffs_dev *dev, const YCHAR *path, int oflag,
+ int mode, int sharing)
+{
+ return yaffs_open_sharing_reldir(ROOT_DIR(dev), path,
+ oflag, mode, sharing);
+}
+
+int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing)
+{
+ return yaffs_open_sharing_reldir(NULL, path, oflag, mode, sharing);
+}
+
+int yaffs_open_reldir(struct yaffs_obj *reldir,const YCHAR *path, int oflag, int mode)
+{
+ return yaffs_open_sharing_reldir(reldir, path, oflag, mode,
+ YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
+}
+
+int yaffs_open_reldev(struct yaffs_dev *dev,const YCHAR *path, int oflag, int mode)
{
- return yaffs_open_sharing(path, oflag, mode,
+ return yaffs_open_sharing_reldir(ROOT_DIR(dev), path, oflag, mode,
YAFFS_SHARE_READ | YAFFS_SHARE_WRITE);
}
+int yaffs_open(const YCHAR *path, int oflag, int mode)
+{
+ return yaffs_open_reldir(NULL, path, oflag, mode);
+}
+
static int yaffs_Dofsync(int handle, int datasync)
{
int retVal = -1;
else if (obj->my_dev->read_only)
yaffsfs_SetError(-EROFS);
else {
- yaffs_flush_file(obj, 1, datasync);
+ yaffs_flush_file(obj, 1, datasync, 0);
retVal = 0;
}
int yaffs_close(int handle)
{
struct yaffsfs_Handle *h = NULL;
+ struct yaffsfs_FileDes *f;
struct yaffs_obj *obj = NULL;
int retVal = -1;
yaffsfs_Lock();
h = yaffsfs_HandleToPointer(handle);
+ f = yaffsfs_HandleToFileDes(handle);
obj = yaffsfs_HandleToObject(handle);
- if (!h || !obj)
+ if (!h || !obj || !f)
yaffsfs_SetError(-EBADF);
else {
/* clean up */
- yaffs_flush_file(obj, 1, 0);
+ if(!f->isDir)
+ yaffs_flush_file(obj, 1, 0, 1);
yaffsfs_PutHandle(handle);
retVal = 0;
}
/* Not a reading handle */
yaffsfs_SetError(-EINVAL);
totalRead = -1;
- } else if (nbyte > YAFFS_MAX_FILE_SIZE) {
+ } else if (nbyte > YAFFS_MAX_RW_SIZE) {
yaffsfs_SetError(-EINVAL);
totalRead = -1;
} else {
if (isPread)
startPos = offset;
else
- startPos = fd->position;
+ startPos = fd->v.position;
pos = startPos;
endPos = pos + nbyte;
if (pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
- nbyte > YAFFS_MAX_FILE_SIZE ||
+ nbyte > YAFFS_MAX_RW_SIZE ||
endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE) {
totalRead = -1;
nbyte = 0;
while (nbyte > 0) {
nToRead = YAFFSFS_RW_SIZE -
(pos & (YAFFSFS_RW_SIZE - 1));
- if (nToRead > nbyte)
+ if (nToRead > (int)nbyte)
nToRead = nbyte;
/* Tricky bit...
if (!isPread) {
if (totalRead >= 0)
- fd->position = startPos + totalRead;
+ fd->v.position = startPos + totalRead;
else
yaffsfs_SetError(-EINVAL);
}
else if (isPwrite)
startPos = offset;
else
- startPos = fd->position;
+ startPos = fd->v.position;
yaffsfs_GetHandle(handle);
pos = startPos;
endPos = pos + nbyte;
if (pos < 0 || pos > YAFFS_MAX_FILE_SIZE ||
- nbyte > YAFFS_MAX_FILE_SIZE ||
+ nbyte > YAFFS_MAX_RW_SIZE ||
endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE) {
totalWritten = -1;
nbyte = 0;
nToWrite = YAFFSFS_RW_SIZE -
(pos & (YAFFSFS_RW_SIZE - 1));
- if (nToWrite > nbyte)
+ if (nToWrite > (int)nbyte)
nToWrite = nbyte;
/* Tricky bit...
if (!isPwrite) {
if (totalWritten > 0)
- fd->position = startPos + totalWritten;
+ fd->v.position = startPos + totalWritten;
else
yaffsfs_SetError(-EINVAL);
}
return yaffsfs_do_write(fd, buf, nbyte, 1, offset);
}
-int yaffs_truncate(const YCHAR *path, Y_LOFF_T new_size)
+int yaffs_truncate_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ Y_LOFF_T new_size)
{
struct yaffs_obj *obj = NULL;
struct yaffs_obj *dir = NULL;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, ¬Dir, &loop);
obj = yaffsfs_FollowLink(obj, 0, &loop);
if (!dir && notDir)
return (result) ? 0 : -1;
}
+int yaffs_truncate_reldev(struct yaffs_dev *dev, const YCHAR *path,
+ Y_LOFF_T new_size)
+{
+ return yaffs_truncate_reldir(ROOT_DIR(dev), path, new_size);
+}
+
+int yaffs_truncate(const YCHAR *path, Y_LOFF_T new_size)
+{
+ return yaffs_truncate_reldir(NULL, path, new_size);
+}
+
int yaffs_ftruncate(int handle, Y_LOFF_T new_size)
{
struct yaffsfs_FileDes *fd = NULL;
if (offset >= 0)
pos = offset;
} else if (whence == SEEK_CUR) {
- if ((fd->position + offset) >= 0)
- pos = (fd->position + offset);
+ if ((fd->v.position + offset) >= 0)
+ pos = (fd->v.position + offset);
} else if (whence == SEEK_END) {
fSize = yaffs_get_obj_length(obj);
if (fSize >= 0 && (fSize + offset) >= 0)
}
if (pos >= 0 && pos <= YAFFS_MAX_FILE_SIZE)
- fd->position = pos;
+ fd->v.position = pos;
else {
yaffsfs_SetError(-EINVAL);
pos = -1;
return pos;
}
-static int yaffsfs_DoUnlink(const YCHAR *path, int isDirectory)
+static int yaffsfs_DoUnlink_reldir(struct yaffs_obj *reldir,
+ const YCHAR *path, int isDirectory)
{
struct yaffs_obj *dir = NULL;
struct yaffs_obj *obj = NULL;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, path, 0, 0, NULL, NULL, NULL);
- dir = yaffsfs_FindDirectory(NULL, path, &name, 0, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, path, 0, 0, NULL, NULL, NULL);
+ dir = yaffsfs_FindDirectory(reldir, path, &name, 0, ¬Dir, &loop);
if (!dir && notDir)
yaffsfs_SetError(-ENOTDIR);
return (result == YAFFS_FAIL) ? -1 : 0;
}
+int yaffs_unlink_reldir(struct yaffs_obj *reldir, const YCHAR *path)
+{
+ return yaffsfs_DoUnlink_reldir(reldir, path, 0);
+}
+
+int yaffs_unlink_reldev(struct yaffs_dev *dev, const YCHAR *path)
+{
+ return yaffsfs_DoUnlink_reldir(ROOT_DIR(dev), path, 0);
+}
+
int yaffs_unlink(const YCHAR *path)
{
- return yaffsfs_DoUnlink(path, 0);
+ return yaffs_unlink_reldir(NULL, path);
}
-int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
+int yaffs_funlink(int fd)
+{
+ struct yaffs_obj *obj;
+ int retVal = -1;
+
+ yaffsfs_Lock();
+ obj = yaffsfs_HandleToObject(fd);
+
+ if (!obj)
+ yaffsfs_SetError(-EBADF);
+ else if (obj->my_dev->read_only)
+ yaffsfs_SetError(-EROFS);
+ else if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
+ !(list_empty(&obj->variant.dir_variant.children)))
+ yaffsfs_SetError(-ENOTEMPTY);
+ else if (obj == obj->my_dev->root_dir)
+ yaffsfs_SetError(-EBUSY); /* Can't rmdir a root */
+ else if (yaffs_unlink_obj(obj) == YAFFS_OK)
+ retVal = 0;
+
+ yaffsfs_Unlock();
+
+ return retVal;
+}
+
+int yaffs_fgetfl(int fd, int *flags)
+{
+ struct yaffsfs_FileDes *fdp = yaffsfs_HandleToFileDes(fd);
+ int retVal;
+
+ yaffsfs_Lock();
+
+ if(!flags || !fdp) {
+ yaffsfs_SetError(-EINVAL);
+ retVal = -1;
+ } else {
+ if (fdp->reading && fdp->writing)
+ *flags = O_RDWR;
+ else if (fdp->writing)
+ *flags = O_WRONLY;
+ else
+ *flags = O_RDONLY;
+ retVal = 0;
+ }
+
+ yaffsfs_Unlock();
+ return retVal;
+}
+
+
+static int rename_file_over_dir(struct yaffs_obj *obj, struct yaffs_obj *newobj)
+{
+ if (obj && obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY &&
+ newobj && newobj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY)
+ return 1;
+ else
+ return 0;
+}
+
+static int rename_dir_over_file(struct yaffs_obj *obj, struct yaffs_obj *newobj)
+{
+ if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY &&
+ newobj && newobj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY)
+ return 1;
+ else
+ return 0;
+}
+
+int yaffs_rename_reldir(struct yaffs_obj *reldir,
+ const YCHAR *oldPath, const YCHAR *newPath)
{
struct yaffs_obj *olddir = NULL;
struct yaffs_obj *newdir = NULL;
yaffsfs_Lock();
- olddir = yaffsfs_FindDirectory(NULL, oldPath, &oldname, 0,
+ olddir = yaffsfs_FindDirectory(reldir, oldPath, &oldname, 0,
¬OldDir, &oldLoop);
- newdir = yaffsfs_FindDirectory(NULL, newPath, &newname, 0,
+ newdir = yaffsfs_FindDirectory(reldir, newPath, &newname, 0,
¬NewDir, &newLoop);
- obj = yaffsfs_FindObject(NULL, oldPath, 0, 0, NULL, NULL, NULL);
- newobj = yaffsfs_FindObject(NULL, newPath, 0, 0, NULL, NULL, NULL);
+ obj = yaffsfs_FindObject(reldir, oldPath, 0, 0, NULL, NULL, NULL);
+ newobj = yaffsfs_FindObject(reldir, newPath, 0, 0, NULL, NULL, NULL);
/* If the object being renamed is a directory and the
* path ended with a "/" then the olddir == obj.
} else if (obj->my_dev->read_only) {
yaffsfs_SetError(-EROFS);
rename_allowed = 0;
+ } else if (rename_file_over_dir(obj, newobj)) {
+ yaffsfs_SetError(-EISDIR);
+ rename_allowed = 0;
+ } else if (rename_dir_over_file(obj, newobj)) {
+ yaffsfs_SetError(-ENOTDIR);
+ rename_allowed = 0;
} else if (yaffs_is_non_empty_dir(newobj)) {
yaffsfs_SetError(-ENOTEMPTY);
rename_allowed = 0;
return (result == YAFFS_FAIL) ? -1 : 0;
}
+int yaffs_rename_reldev(struct yaffs_dev *dev, const YCHAR *oldPath,
+ const YCHAR *newPath)
+{
+ return yaffs_rename_reldir(ROOT_DIR(dev), oldPath, newPath);
+}
+int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
+{
+ return yaffs_rename_reldir(NULL, oldPath, newPath);
+}
+
static int yaffsfs_DoStat(struct yaffs_obj *obj, struct yaffs_stat *buf)
{
int retVal = -1;
obj = yaffs_get_equivalent_obj(obj);
if (obj && buf) {
- buf->st_dev = (int)obj->my_dev->os_context;
+ buf->st_dev = 0;
buf->st_ino = obj->obj_id;
buf->st_mode = obj->yst_mode & ~S_IFMT;
return retVal;
}
-static int yaffsfs_DoStatOrLStat(const YCHAR *path,
+static int yaffsfs_DoStatOrLStat_reldir(struct yaffs_obj *reldir, const YCHAR *path,
struct yaffs_stat *buf, int doLStat)
{
struct yaffs_obj *obj = NULL;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, ¬Dir, &loop);
if (!doLStat && obj)
obj = yaffsfs_FollowLink(obj, 0, &loop);
}
+int yaffs_stat_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ struct yaffs_stat *buf)
+{
+ return yaffsfs_DoStatOrLStat_reldir(reldir, path, buf, 0);
+}
+
+int yaffs_lstat_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ struct yaffs_stat *buf)
+{
+ return yaffsfs_DoStatOrLStat_reldir(reldir, path, buf, 1);
+}
+
+int yaffs_stat_reldev(struct yaffs_dev *dev, const YCHAR *path,
+ struct yaffs_stat *buf)
+{
+ return yaffsfs_DoStatOrLStat_reldir(ROOT_DIR(dev), path, buf, 0);
+}
+
+int yaffs_lstat_reldev(struct yaffs_dev *dev, const YCHAR *path,
+ struct yaffs_stat *buf)
+{
+ return yaffsfs_DoStatOrLStat_reldir(ROOT_DIR(dev), path, buf, 1);
+}
+
int yaffs_stat(const YCHAR *path, struct yaffs_stat *buf)
{
- return yaffsfs_DoStatOrLStat(path, buf, 0);
+ return yaffs_stat_reldir(NULL, path, buf);
}
int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf)
{
- return yaffsfs_DoStatOrLStat(path, buf, 1);
+ return yaffs_lstat_reldir(NULL, path, buf);
}
int yaffs_fstat(int fd, struct yaffs_stat *buf)
const struct yaffs_utimbuf *buf)
{
int retVal = -1;
- int result;
-
struct yaffs_utimbuf local;
obj = yaffs_get_equivalent_obj(obj);
return -1;
}
+#if !CONFIG_YAFFS_WINCE
+ // if the the buffer is null then create one with the fields set to the current time.
if (!buf) {
local.actime = Y_CURRENT_TIME;
local.modtime = local.actime;
buf = &local;
}
+ // copy the buffer's time into the obj.
if (obj) {
+ int result;
+
obj->yst_atime = buf->actime;
obj->yst_mtime = buf->modtime;
+
+ // set the obj to dirty to cause it to be written to flash during the next flush operation.
obj->dirty = 1;
- result = yaffs_flush_file(obj, 0, 0);
+ result = yaffs_flush_file(obj, 0, 0, 0);
retVal = result == YAFFS_OK ? 0 : -1;
}
+#endif
return retVal;
}
-int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf)
+int yaffs_utime_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ const struct yaffs_utimbuf *buf)
{
struct yaffs_obj *obj = NULL;
struct yaffs_obj *dir = NULL;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, ¬Dir, &loop);
if (!dir && notDir)
yaffsfs_SetError(-ENOTDIR);
}
+int yaffs_utime_reldev(struct yaffs_dev *dev, const YCHAR *path,
+ const struct yaffs_utimbuf *buf)
+{
+ return yaffs_utime_reldir(ROOT_DIR(dev), path, buf);
+}
+
+int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf)
+{
+ return yaffs_utime_reldir(NULL, path, buf);
+}
+
int yaffs_futime(int fd, const struct yaffs_utimbuf *buf)
{
struct yaffs_obj *obj;
#ifndef CONFIG_YAFFS_WINCE
/* xattrib functions */
-static int yaffs_do_setxattr(const YCHAR *path, const char *name,
- const void *data, int size, int flags, int follow)
+static int yaffs_do_setxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ const char *name, const void *data, int size,
+ int flags, int follow)
{
struct yaffs_obj *obj;
struct yaffs_obj *dir;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, ¬Dir, &loop);
if (follow)
obj = yaffsfs_FollowLink(obj, 0, &loop);
}
+int yaffs_setxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ const char *name, const void *data, int size, int flags)
+{
+ return yaffs_do_setxattr_reldir(reldir, path, name, data, size, flags, 1);
+}
+
+int yaffs_setxattr_reldev(struct yaffs_dev *dev, const YCHAR *path,
+ const char *name, const void *data, int size, int flags)
+{
+ return yaffs_setxattr_reldir(ROOT_DIR(dev), path, name, data, size, flags);
+}
+
int yaffs_setxattr(const YCHAR *path, const char *name,
const void *data, int size, int flags)
{
- return yaffs_do_setxattr(path, name, data, size, flags, 1);
+ return yaffs_setxattr_reldir(NULL, path, name, data, size, flags);
}
-int yaffs_lsetxattr(const YCHAR *path, const char *name,
+int yaffs_lsetxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path, const char *name,
const void *data, int size, int flags)
{
- return yaffs_do_setxattr(path, name, data, size, flags, 0);
+ return yaffs_do_setxattr_reldir(reldir, path, name, data, size, flags, 0);
+}
+
+int yaffs_lsetxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name,
+ const void *data, int size, int flags)
+{
+ return yaffs_lsetxattr_reldir(ROOT_DIR(dev), path, name, data, size, flags);
+}
+
+int yaffs_lsetxattr(const YCHAR *path, const char *name,
+ const void *data, int size, int flags)
+{
+ return yaffs_lsetxattr_reldir(NULL, path, name, data, size, flags);
}
int yaffs_fsetxattr(int fd, const char *name,
return retVal;
}
-static int yaffs_do_getxattr(const YCHAR *path, const char *name,
- void *data, int size, int follow)
+static int yaffs_do_getxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ const char *name, void *data, int size, int follow)
{
struct yaffs_obj *obj;
struct yaffs_obj *dir;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, ¬Dir, &loop);
if (follow)
obj = yaffsfs_FollowLink(obj, 0, &loop);
}
+int yaffs_getxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ const char *name, void *data, int size)
+{
+ return yaffs_do_getxattr_reldir(reldir, path, name, data, size, 1);
+}
+
+int yaffs_getxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name, void *data, int size)
+{
+ return yaffs_getxattr_reldir(ROOT_DIR(dev), path, name, data, size);
+}
+
int yaffs_getxattr(const YCHAR *path, const char *name, void *data, int size)
{
- return yaffs_do_getxattr(path, name, data, size, 1);
+ return yaffs_getxattr_reldir(NULL, path, name, data, size);
+}
+
+int yaffs_lgetxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ const char *name, void *data, int size)
+{
+ return yaffs_do_getxattr_reldir(reldir, path, name, data, size, 0);
+}
+
+int yaffs_lgetxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name, void *data, int size)
+{
+ return yaffs_lgetxattr_reldir(ROOT_DIR(dev), path, name, data, size);
}
int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size)
{
- return yaffs_do_getxattr(path, name, data, size, 0);
+ return yaffs_lgetxattr_reldir(NULL, path, name, data, size);
}
int yaffs_fgetxattr(int fd, const char *name, void *data, int size)
return retVal;
}
-static int yaffs_do_listxattr(const YCHAR *path, char *data,
- int size, int follow)
+static int yaffs_do_listxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ char *data, int size, int follow)
{
struct yaffs_obj *obj = NULL;
struct yaffs_obj *dir = NULL;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, ¬Dir, &loop);
if (follow)
obj = yaffsfs_FollowLink(obj, 0, &loop);
}
+int yaffs_listxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ char *data, int size)
+{
+ return yaffs_do_listxattr_reldir(reldir, path, data, size, 1);
+}
+
+int yaffs_listxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, char *data, int size)
+{
+ return yaffs_listxattr_reldir(ROOT_DIR(dev), path, data, size);
+}
+
int yaffs_listxattr(const YCHAR *path, char *data, int size)
{
- return yaffs_do_listxattr(path, data, size, 1);
+ return yaffs_listxattr_reldir(NULL, path, data, size);
+}
+
+int yaffs_llistxattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ char *data, int size)
+{
+ return yaffs_do_listxattr_reldir(reldir, path, data, size, 0);
+}
+
+int yaffs_llistxattr_reldev(struct yaffs_dev *dev, const YCHAR *path, char *data, int size)
+{
+ return yaffs_llistxattr_reldir(ROOT_DIR(dev), path, data, size);
}
int yaffs_llistxattr(const YCHAR *path, char *data, int size)
{
- return yaffs_do_listxattr(path, data, size, 0);
+ return yaffs_llistxattr_reldir(NULL, path, data, size);
}
int yaffs_flistxattr(int fd, char *data, int size)
return retVal;
}
-static int yaffs_do_removexattr(const YCHAR *path, const char *name,
- int follow)
+static int yaffs_do_removexattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ const char *name, int follow)
{
struct yaffs_obj *obj = NULL;
struct yaffs_obj *dir = NULL;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, ¬Dir, &loop);
if (follow)
obj = yaffsfs_FollowLink(obj, 0, &loop);
}
+int yaffs_removexattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ const char *name)
+{
+ return yaffs_do_removexattr_reldir(reldir, path, name, 1);
+}
+
+int yaffs_removexattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name)
+{
+ return yaffs_removexattr_reldir(ROOT_DIR(dev), path, name);
+}
+
int yaffs_removexattr(const YCHAR *path, const char *name)
{
- return yaffs_do_removexattr(path, name, 1);
+ return yaffs_removexattr_reldir(NULL, path, name);
+}
+
+int yaffs_lremovexattr_reldir(struct yaffs_obj *reldir, const YCHAR *path,
+ const char *name)
+{
+ return yaffs_do_removexattr_reldir(reldir, path, name, 0);
+}
+
+int yaffs_lremovexattr_reldev(struct yaffs_dev *dev, const YCHAR *path, const char *name)
+{
+ return yaffs_lremovexattr_reldir(ROOT_DIR(dev), path, name);
}
int yaffs_lremovexattr(const YCHAR *path, const char *name)
{
- return yaffs_do_removexattr(path, name, 0);
+ return yaffs_lremovexattr_reldir(NULL, path, name);
}
int yaffs_fremovexattr(int fd, const char *name)
}
obj->dirty = 1;
- result = yaffs_flush_file(obj, 0, 0);
+ result = yaffs_flush_file(obj, 0, 0, 0);
retVal = 0;
} else
/* bad handle */
if (obj) {
obj->yst_mode = mode;
obj->dirty = 1;
- result = yaffs_flush_file(obj, 0, 0);
+ result = yaffs_flush_file(obj, 0, 0, 0);
}
return result == YAFFS_OK ? 0 : -1;
}
-int yaffs_access(const YCHAR *path, int amode)
+int yaffs_access_reldir(struct yaffs_obj *reldir, const YCHAR *path, int amode)
{
struct yaffs_obj *obj = NULL;
struct yaffs_obj *dir = NULL;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, ¬Dir, &loop);
obj = yaffsfs_FollowLink(obj, 0, &loop);
if (!dir && notDir)
else {
int access_ok = 1;
- if ((amode & R_OK) && !(obj->yst_mode & S_IREAD))
+ if ((amode & R_OK) && !(obj->yst_mode & S_IRUSR))
access_ok = 0;
- if ((amode & W_OK) && !(obj->yst_mode & S_IWRITE))
+ if ((amode & W_OK) && !(obj->yst_mode & S_IWUSR))
access_ok = 0;
- if ((amode & X_OK) && !(obj->yst_mode & S_IEXEC))
+ if ((amode & X_OK) && !(obj->yst_mode & S_IXUSR))
access_ok = 0;
if (!access_ok)
}
-int yaffs_chmod(const YCHAR *path, mode_t mode)
+int yaffs_access_reldev(struct yaffs_dev *dev, const YCHAR *path, int amode)
+{
+ return yaffs_access_reldir(ROOT_DIR(dev), path, amode);
+}
+
+int yaffs_access(const YCHAR *path, int amode)
+{
+ return yaffs_access_reldir(NULL, path, amode);
+}
+
+int yaffs_chmod_reldir(struct yaffs_obj *reldir, const YCHAR *path, mode_t mode)
{
struct yaffs_obj *obj = NULL;
struct yaffs_obj *dir = NULL;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, ¬Dir, &loop);
obj = yaffsfs_FollowLink(obj, 0, &loop);
if (!dir && notDir)
}
+int yaffs_chmod_reldev(struct yaffs_dev *dev, const YCHAR *path, mode_t mode)
+{
+ return yaffs_chmod_reldir(ROOT_DIR(dev), path, mode);
+}
+
+int yaffs_chmod(const YCHAR *path, mode_t mode)
+{
+ return yaffs_chmod_reldir(NULL, path, mode);
+}
+
int yaffs_fchmod(int fd, mode_t mode)
{
struct yaffs_obj *obj;
return retVal;
}
-int yaffs_mkdir(const YCHAR *path, mode_t mode)
+int yaffs_mkdir_reldir(struct yaffs_obj *reldir, const YCHAR *path, mode_t mode)
{
struct yaffs_obj *parent = NULL;
struct yaffs_obj *dir = NULL;
path = alt_path;
yaffsfs_Lock();
- parent = yaffsfs_FindDirectory(NULL, path, &name, 0, ¬Dir, &loop);
+ parent = yaffsfs_FindDirectory(reldir, path, &name, 0, ¬Dir, &loop);
if (!parent && notDir)
yaffsfs_SetError(-ENOTDIR);
else if (loop)
return retVal;
}
-int yaffs_rmdir(const YCHAR *path)
+int yaffs_mkdir_reldev(struct yaffs_dev *dev, const YCHAR *path, mode_t mode)
+{
+ return yaffs_mkdir_reldir(ROOT_DIR(dev), path, mode);
+}
+
+int yaffs_mkdir(const YCHAR *path, mode_t mode)
+{
+ return yaffs_mkdir_reldir(NULL, path, mode);
+}
+
+int yaffs_rmdir_reldir(struct yaffs_obj *reldir, const YCHAR *path)
{
int result;
YCHAR *alt_path;
}
if (alt_path)
path = alt_path;
- result = yaffsfs_DoUnlink(path, 1);
+ result = yaffsfs_DoUnlink_reldir(reldir, path, 1);
kfree(alt_path);
return result;
}
+int yaffs_rmdir_reldev(struct yaffs_dev *dev, const YCHAR *path)
+{
+ return yaffs_rmdir_reldir(ROOT_DIR(dev), path);
+}
+
+int yaffs_rmdir(const YCHAR *path)
+{
+ return yaffs_rmdir_reldir(NULL, path);
+}
+
+/*
+ * The mount/unmount/sync functions act on devices rather than reldirs.
+ */
void *yaffs_getdev(const YCHAR *path)
{
struct yaffs_dev *dev = NULL;
return (void *)dev;
}
-int yaffs_mount_common(const YCHAR *path, int read_only, int skip_checkpt)
+int yaffs_mount_common(struct yaffs_dev *dev, const YCHAR *path,
+ int read_only, int skip_checkpt)
{
int retVal = -1;
int result = YAFFS_FAIL;
- struct yaffs_dev *dev = NULL;
- if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
- yaffsfs_SetError(-EFAULT);
- return -1;
- }
+ if (!dev) {
+ if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+ yaffsfs_SetError(-EFAULT);
+ return -1;
+ }
- yaffs_trace(YAFFS_TRACE_MOUNT, "yaffs: Mounting %s", path);
+ yaffs_trace(YAFFS_TRACE_MOUNT, "yaffs: Mounting %s", path);
- if (yaffsfs_CheckPath(path) < 0) {
- yaffsfs_SetError(-ENAMETOOLONG);
- return -1;
+ if (yaffsfs_CheckPath(path) < 0) {
+ yaffsfs_SetError(-ENAMETOOLONG);
+ return -1;
+ }
}
yaffsfs_Lock();
yaffsfs_InitHandles();
- dev = yaffsfs_FindMountPoint(path);
+ if (!dev)
+ dev = yaffsfs_FindMountPoint(path);
+
if (dev) {
if (!dev->is_mounted) {
dev->read_only = read_only ? 1 : 0;
}
+int yaffs_mount3_reldev(struct yaffs_dev *dev, int read_only, int skip_checkpt)
+{
+ return yaffs_mount_common(dev, NULL, read_only, skip_checkpt);
+}
+
+int yaffs_mount3(const YCHAR *path, int read_only, int skip_checkpt)
+{
+ return yaffs_mount_common(NULL, path, read_only, skip_checkpt);
+}
+
+int yaffs_mount2_reldev(struct yaffs_dev *dev, int readonly)
+{
+ return yaffs_mount_common(dev, NULL, readonly, 0);
+}
+
int yaffs_mount2(const YCHAR *path, int readonly)
{
- return yaffs_mount_common(path, readonly, 0);
+ return yaffs_mount_common(NULL, path, readonly, 0);
+}
+
+int yaffs_mount_reldev(struct yaffs_dev *dev)
+{
+ return yaffs_mount_common(dev, NULL, 0, 0);
}
int yaffs_mount(const YCHAR *path)
{
- return yaffs_mount_common(path, 0, 0);
+ return yaffs_mount_common(NULL, path, 0, 0);
}
-int yaffs_sync(const YCHAR *path)
+static int yaffs_sync_common(struct yaffs_dev *dev,
+ const YCHAR *path,
+ int do_checkpt)
{
int retVal = -1;
- struct yaffs_dev *dev = NULL;
YCHAR *dummy;
- if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
- yaffsfs_SetError(-EFAULT);
- return -1;
- }
+ if (!dev) {
+ if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+ yaffsfs_SetError(-EFAULT);
+ return -1;
+ }
- if (yaffsfs_CheckPath(path) < 0) {
- yaffsfs_SetError(-ENAMETOOLONG);
- return -1;
+ if (yaffsfs_CheckPath(path) < 0) {
+ yaffsfs_SetError(-ENAMETOOLONG);
+ return -1;
+ }
}
yaffsfs_Lock();
- dev = yaffsfs_FindDevice(path, &dummy);
+ if (!dev)
+ dev = yaffsfs_FindDevice(path, &dummy);
+
if (dev) {
if (!dev->is_mounted)
yaffsfs_SetError(-EINVAL);
yaffsfs_SetError(-EROFS);
else {
- yaffs_flush_whole_cache(dev);
- yaffs_checkpoint_save(dev);
+ yaffs_flush_whole_cache(dev, 0);
+ if (do_checkpt)
+ yaffs_checkpoint_save(dev);
retVal = 0;
}
return retVal;
}
+int yaffs_sync_files_reldev(struct yaffs_dev *dev)
+{
+ return yaffs_sync_common(dev, NULL, 0);
+}
+
+int yaffs_sync_files(const YCHAR *path)
+{
+ return yaffs_sync_common(NULL, path, 0);
+}
+
+int yaffs_sync_reldev(struct yaffs_dev *dev)
+{
+ return yaffs_sync_common(dev, NULL, 1);
+}
+
+int yaffs_sync(const YCHAR *path)
+{
+ return yaffs_sync_common(NULL, path, 1);
+}
+
+
+static int yaffsfs_bg_gc_common(struct yaffs_dev *dev,
+ const YCHAR *path,
+ int urgency)
+{
+ int retVal = -1;
+ YCHAR *dummy;
+
+ if (!dev) {
+ if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+ yaffsfs_SetError(-EFAULT);
+ return -1;
+ }
+
+ if (yaffsfs_CheckPath(path) < 0) {
+ yaffsfs_SetError(-ENAMETOOLONG);
+ return -1;
+ }
+ }
+
+ yaffsfs_Lock();
+ if (!dev)
+ dev = yaffsfs_FindDevice(path, &dummy);
+
+ if (dev) {
+ if (!dev->is_mounted)
+ yaffsfs_SetError(-EINVAL);
+ else
+ retVal = yaffs_bg_gc(dev, urgency);
+ } else
+ yaffsfs_SetError(-ENODEV);
+
+ yaffsfs_Unlock();
+ return retVal;
+}
+
+/* Background gc functions.
+ * These return 0 when bg done or greater than 0 when gc has been
+ * done and there is still a lot of garbage to be cleaned up.
+ */
+
+int yaffs_do_background_gc(const YCHAR *path, int urgency)
+{
+ return yaffsfs_bg_gc_common(NULL, path, urgency);
+}
+
+int yaffs_do_background_gc_reldev(struct yaffs_dev *dev, int urgency)
+{
+ return yaffsfs_bg_gc_common(dev, NULL, urgency);
+}
+
static int yaffsfs_IsDevBusy(struct yaffs_dev *dev)
{
int i;
return 0;
}
-int yaffs_remount(const YCHAR *path, int force, int read_only)
+int yaffs_remount_common(struct yaffs_dev *dev, const YCHAR *path,
+ int force, int read_only)
{
int retVal = -1;
- struct yaffs_dev *dev = NULL;
+ int was_read_only;
if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
yaffsfs_SetError(-EFAULT);
}
yaffsfs_Lock();
- dev = yaffsfs_FindMountPoint(path);
+ if (!dev)
+ dev = yaffsfs_FindMountPoint(path);
+
if (dev) {
if (dev->is_mounted) {
- yaffs_flush_whole_cache(dev);
+ yaffs_flush_whole_cache(dev, 0);
if (force || !yaffsfs_IsDevBusy(dev)) {
if (read_only)
yaffs_checkpoint_save(dev);
+ was_read_only = dev->read_only;
dev->read_only = read_only ? 1 : 0;
+ if (was_read_only && !read_only) {
+ yaffs_guts_cleanup(dev);
+ }
retVal = 0;
} else
yaffsfs_SetError(-EBUSY);
}
-int yaffs_unmount2(const YCHAR *path, int force)
+int yaffs_remount_reldev(struct yaffs_dev *dev, int force, int read_only)
+{
+ return yaffs_remount_common(dev, NULL, force, read_only);
+}
+int yaffs_remount(const YCHAR *path, int force, int read_only)
+{
+ return yaffs_remount_common(NULL, path, force, read_only);
+}
+
+int yaffs_unmount2_common(struct yaffs_dev *dev, const YCHAR *path, int force)
{
int retVal = -1;
- struct yaffs_dev *dev = NULL;
- if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
- yaffsfs_SetError(-EFAULT);
- return -1;
- }
- if (yaffsfs_CheckPath(path) < 0) {
- yaffsfs_SetError(-ENAMETOOLONG);
- return -1;
+ if (!dev) {
+ if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+ yaffsfs_SetError(-EFAULT);
+ return -1;
+ }
+
+ if (yaffsfs_CheckPath(path) < 0) {
+ yaffsfs_SetError(-ENAMETOOLONG);
+ return -1;
+ }
}
yaffsfs_Lock();
- dev = yaffsfs_FindMountPoint(path);
+ if (!dev)
+ dev = yaffsfs_FindMountPoint(path);
+
if (dev) {
if (dev->is_mounted) {
int inUse;
- yaffs_flush_whole_cache(dev);
+ yaffs_flush_whole_cache(dev, 0);
yaffs_checkpoint_save(dev);
inUse = yaffsfs_IsDevBusy(dev);
if (!inUse || force) {
}
+int yaffs_unmount2_reldev(struct yaffs_dev *dev, int force)
+{
+ return yaffs_unmount2_common(dev, NULL, force);
+}
+
+int yaffs_unmount2(const YCHAR *path, int force)
+{
+ return yaffs_unmount2_common(NULL, path, force);
+}
+
+int yaffs_unmount_reldev(struct yaffs_dev *dev)
+{
+ return yaffs_unmount2_reldev(dev, 0);
+}
+
int yaffs_unmount(const YCHAR *path)
{
return yaffs_unmount2(path, 0);
}
-int yaffs_format(const YCHAR *path,
+int yaffs_format_common(struct yaffs_dev *dev,
+ const YCHAR *path,
int unmount_flag,
int force_unmount_flag,
int remount_flag)
{
int retVal = 0;
- struct yaffs_dev *dev = NULL;
int result;
- if (!path) {
- yaffsfs_SetError(-EFAULT);
- return -1;
- }
+ if (!dev) {
+ if (!path) {
+ yaffsfs_SetError(-EFAULT);
+ return -1;
+ }
- if (yaffsfs_CheckPath(path) < 0) {
- yaffsfs_SetError(-ENAMETOOLONG);
- return -1;
+ if (yaffsfs_CheckPath(path) < 0) {
+ yaffsfs_SetError(-ENAMETOOLONG);
+ return -1;
+ }
}
yaffsfs_Lock();
- dev = yaffsfs_FindMountPoint(path);
+ if (!dev)
+ dev = yaffsfs_FindMountPoint(path);
if (dev) {
int was_mounted = dev->is_mounted;
if (dev->is_mounted && unmount_flag) {
int inUse;
- yaffs_flush_whole_cache(dev);
+ yaffs_flush_whole_cache(dev, 0);
yaffs_checkpoint_save(dev);
inUse = yaffsfs_IsDevBusy(dev);
if (!inUse || force_unmount_flag) {
yaffsfs_SetError(-EBUSY);
retVal = -1;
} else {
- yaffs_format_dev(dev);
+ yaffs_guts_format_dev(dev);
if(was_mounted && remount_flag) {
result = yaffs_guts_initialise(dev);
if (result == YAFFS_FAIL) {
}
+int yaffs_format_reldev(struct yaffs_dev *dev,
+ int unmount_flag,
+ int force_unmount_flag,
+ int remount_flag)
+{
+ return yaffs_format_common(dev, NULL, unmount_flag,
+ force_unmount_flag, remount_flag);
+}
+
+int yaffs_format(const YCHAR *path,
+ int unmount_flag,
+ int force_unmount_flag,
+ int remount_flag)
+{
+ return yaffs_format_common(NULL, path, unmount_flag,
+ force_unmount_flag, remount_flag);
+}
-Y_LOFF_T yaffs_freespace(const YCHAR *path)
+Y_LOFF_T yaffs_freespace_common(struct yaffs_dev *dev, const YCHAR *path)
{
Y_LOFF_T retVal = -1;
- struct yaffs_dev *dev = NULL;
YCHAR *dummy;
- if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
- yaffsfs_SetError(-EFAULT);
- return -1;
- }
+ if (!dev) {
+ if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+ yaffsfs_SetError(-EFAULT);
+ return -1;
+ }
- if (yaffsfs_CheckPath(path) < 0) {
- yaffsfs_SetError(-ENAMETOOLONG);
- return -1;
+ if (yaffsfs_CheckPath(path) < 0) {
+ yaffsfs_SetError(-ENAMETOOLONG);
+ return -1;
+ }
}
yaffsfs_Lock();
- dev = yaffsfs_FindDevice(path, &dummy);
+ if (!dev)
+ dev = yaffsfs_FindDevice(path, &dummy);
if (dev && dev->is_mounted) {
retVal = yaffs_get_n_free_chunks(dev);
retVal *= dev->data_bytes_per_chunk;
return retVal;
}
-Y_LOFF_T yaffs_totalspace(const YCHAR *path)
+Y_LOFF_T yaffs_freespace_reldev(struct yaffs_dev *dev)
+{
+ return yaffs_freespace_common(dev, NULL);
+}
+
+Y_LOFF_T yaffs_freespace(const YCHAR *path)
+{
+ return yaffs_freespace_common(NULL, path);
+}
+
+Y_LOFF_T yaffs_totalspace_common(struct yaffs_dev *dev, const YCHAR *path)
{
Y_LOFF_T retVal = -1;
- struct yaffs_dev *dev = NULL;
YCHAR *dummy;
- if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
- yaffsfs_SetError(-EFAULT);
- return -1;
- }
+ if (!dev) {
+ if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+ yaffsfs_SetError(-EFAULT);
+ return -1;
+ }
- if (yaffsfs_CheckPath(path) < 0) {
- yaffsfs_SetError(-ENAMETOOLONG);
- return -1;
+ if (yaffsfs_CheckPath(path) < 0) {
+ yaffsfs_SetError(-ENAMETOOLONG);
+ return -1;
+ }
}
yaffsfs_Lock();
- dev = yaffsfs_FindDevice(path, &dummy);
+ if (!dev)
+ dev = yaffsfs_FindDevice(path, &dummy);
if (dev && dev->is_mounted) {
retVal = (dev->param.end_block - dev->param.start_block + 1) -
dev->param.n_reserved_blocks;
return retVal;
}
-int yaffs_inodecount(const YCHAR *path)
+Y_LOFF_T yaffs_totalspace_reldev(struct yaffs_dev *dev)
+{
+ return yaffs_totalspace_common(dev, NULL);
+}
+
+Y_LOFF_T yaffs_totalspace(const YCHAR *path)
+{
+ return yaffs_totalspace_common(NULL, path);
+}
+
+int yaffs_inodecount_common(struct yaffs_dev *dev, const YCHAR *path)
{
Y_LOFF_T retVal = -1;
- struct yaffs_dev *dev = NULL;
YCHAR *dummy;
- if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
- yaffsfs_SetError(-EFAULT);
- return -1;
- }
+ if (!dev) {
+ if (yaffsfs_CheckMemRegion(path, 0, 0) < 0) {
+ yaffsfs_SetError(-EFAULT);
+ return -1;
+ }
- if (yaffsfs_CheckPath(path) < 0) {
- yaffsfs_SetError(-ENAMETOOLONG);
- return -1;
+ if (yaffsfs_CheckPath(path) < 0) {
+ yaffsfs_SetError(-ENAMETOOLONG);
+ return -1;
+ }
}
yaffsfs_Lock();
- dev = yaffsfs_FindDevice(path, &dummy);
+ if (!dev)
+ dev = yaffsfs_FindDevice(path, &dummy);
if (dev && dev->is_mounted) {
int n_obj = dev->n_obj;
if (n_obj > dev->n_hardlinks)
return retVal;
}
+int yaffs_inodecount_reldev(struct yaffs_dev *dev)
+{
+ return yaffs_inodecount_common(dev, NULL);
+}
+
+int yaffs_inodecount(const YCHAR *path)
+{
+ return yaffs_inodecount_common(NULL, path);
+}
+
void yaffs_add_device(struct yaffs_dev *dev)
{
struct list_head *cfg;
INIT_LIST_HEAD(&dev->dev_list);
list_add(&dev->dev_list, &yaffsfs_deviceList);
+
+
}
void yaffs_remove_device(struct yaffs_dev *dev)
static struct list_head search_contexts;
-static void yaffsfs_SetDirRewound(struct yaffsfs_DirSearchContxt *dsc)
+static void yaffsfs_SetDirRewound(struct yaffsfs_DirSearchContext *dsc)
{
if (dsc &&
dsc->dirObj &&
}
}
-static void yaffsfs_DirAdvance(struct yaffsfs_DirSearchContxt *dsc)
+static void yaffsfs_DirAdvance(struct yaffsfs_DirSearchContext *dsc)
{
if (dsc &&
dsc->dirObj &&
{
struct list_head *i;
- struct yaffsfs_DirSearchContxt *dsc;
+ struct yaffsfs_DirSearchContext *dsc;
/* if search contexts not initilised then skip */
if (!search_contexts.next)
*/
list_for_each(i, &search_contexts) {
if (i) {
- dsc = list_entry(i, struct yaffsfs_DirSearchContxt,
+ dsc = list_entry(i, struct yaffsfs_DirSearchContext,
others);
if (dsc->nextReturn == obj)
yaffsfs_DirAdvance(dsc);
}
-yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
+static yaffs_DIR *yaffsfs_opendir_reldir_no_lock(struct yaffs_obj *reldir,
+ const YCHAR *dirname)
{
yaffs_DIR *dir = NULL;
struct yaffs_obj *obj = NULL;
- struct yaffsfs_DirSearchContxt *dsc = NULL;
+ struct yaffsfs_DirSearchContext *dsc = NULL;
int notDir = 0;
int loop = 0;
return NULL;
}
- yaffsfs_Lock();
-
- obj = yaffsfs_FindObject(NULL, dirname, 0, 1, NULL, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, dirname, 0, 1, NULL, ¬Dir, &loop);
+ obj = yaffsfs_FollowLink(obj, 0, &loop);
if (!obj && notDir)
yaffsfs_SetError(-ENOTDIR);
dir = (yaffs_DIR *) dsc;
if (dsc) {
- memset(dsc, 0, sizeof(struct yaffsfs_DirSearchContxt));
+ memset(dsc, 0, sizeof(struct yaffsfs_DirSearchContext));
dsc->inUse = 1;
dsc->dirObj = obj;
yaffs_strncpy(dsc->name, dirname, NAME_MAX);
list_add(&dsc->others, &search_contexts);
yaffsfs_SetDirRewound(dsc);
}
-
}
+ return dir;
+}
+
+yaffs_DIR *yaffs_opendir_reldir(struct yaffs_obj *reldir, const YCHAR *dirname)
+{
+ yaffs_DIR *ret;
+ yaffsfs_Lock();
+ ret = yaffsfs_opendir_reldir_no_lock(reldir, dirname);
yaffsfs_Unlock();
+ return ret;
+}
- return dir;
+yaffs_DIR *yaffs_opendir_reldev(struct yaffs_dev *dev, const YCHAR *dirname)
+{
+ return yaffs_opendir_reldir(ROOT_DIR(dev), dirname);
}
-struct yaffs_dirent *yaffs_readdir(yaffs_DIR * dirp)
+yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
{
- struct yaffsfs_DirSearchContxt *dsc;
+ return yaffs_opendir_reldir(NULL, dirname);
+}
+
+struct yaffs_dirent *yaffsfs_readdir_no_lock(yaffs_DIR * dirp)
+{
+ struct yaffsfs_DirSearchContext *dsc;
struct yaffs_dirent *retVal = NULL;
- dsc = (struct yaffsfs_DirSearchContxt *) dirp;
- yaffsfs_Lock();
+ dsc = (struct yaffsfs_DirSearchContext *) dirp;
+
if (dsc && dsc->inUse) {
yaffsfs_SetError(0);
if (dsc->nextReturn) {
dsc->de.d_ino =
yaffs_get_equivalent_obj(dsc->nextReturn)->obj_id;
- dsc->de.d_dont_use = (unsigned)dsc->nextReturn;
+ dsc->de.d_dont_use = 0;
dsc->de.d_off = dsc->offset++;
yaffs_get_obj_name(dsc->nextReturn,
dsc->de.d_name, NAME_MAX);
} else
yaffsfs_SetError(-EBADF);
- yaffsfs_Unlock();
-
return retVal;
}
+struct yaffs_dirent *yaffs_readdir(yaffs_DIR * dirp)
+{
+ struct yaffs_dirent *ret;
-void yaffs_rewinddir(yaffs_DIR *dirp)
+ yaffsfs_Lock();
+ ret = yaffsfs_readdir_no_lock(dirp);
+ yaffsfs_Unlock();
+ return ret;
+}
+
+static void yaffsfs_rewinddir_no_lock(yaffs_DIR *dirp)
{
- struct yaffsfs_DirSearchContxt *dsc;
+ struct yaffsfs_DirSearchContext *dsc;
- dsc = (struct yaffsfs_DirSearchContxt *) dirp;
+ dsc = (struct yaffsfs_DirSearchContext *) dirp;
if (yaffsfs_CheckMemRegion(dirp, sizeof(*dsc), 0) < 0)
return;
+ yaffsfs_SetDirRewound(dsc);
+
+}
+
+void yaffs_rewinddir(yaffs_DIR *dirp)
+{
+ yaffsfs_Lock();
+ yaffsfs_rewinddir_no_lock(dirp);
+ yaffsfs_Unlock();
+}
+
+struct yaffs_dirent *yaffs_readdir_fd(int fd)
+{
+ struct yaffs_dirent *ret = NULL;
+ struct yaffsfs_FileDes *f;
+
yaffsfs_Lock();
+ f = yaffsfs_HandleToFileDes(fd);
+ if(f && f->isDir && f->v.dir)
+ ret = yaffsfs_readdir_no_lock(f->v.dir);
+ yaffsfs_Unlock();
+ return ret;
+}
- yaffsfs_SetDirRewound(dsc);
+void yaffs_rewinddir_fd(int fd)
+{
+ struct yaffsfs_FileDes *f;
+ yaffsfs_Lock();
+ f = yaffsfs_HandleToFileDes(fd);
+ if(f && f->isDir)
+ yaffsfs_rewinddir_no_lock(f->v.dir);
yaffsfs_Unlock();
}
-int yaffs_closedir(yaffs_DIR *dirp)
+
+static int yaffsfs_closedir_no_lock(yaffs_DIR *dirp)
{
- struct yaffsfs_DirSearchContxt *dsc;
+ struct yaffsfs_DirSearchContext *dsc;
- dsc = (struct yaffsfs_DirSearchContxt *) dirp;
+ dsc = (struct yaffsfs_DirSearchContext *) dirp;
if (yaffsfs_CheckMemRegion(dirp, sizeof(*dsc), 0) < 0) {
yaffsfs_SetError(-EFAULT);
return -1;
}
- yaffsfs_Lock();
dsc->inUse = 0;
list_del(&dsc->others); /* unhook from list */
- yaffsfs_Unlock();
+
return 0;
}
+int yaffs_closedir(yaffs_DIR *dirp)
+{
+ int ret;
+
+ yaffsfs_Lock();
+ ret = yaffsfs_closedir_no_lock(dirp);
+ yaffsfs_Unlock();
+ return ret;
+}
+
/* End of directory stuff */
-int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
+int yaffs_symlink_reldir(struct yaffs_obj *reldir,
+ const YCHAR *oldpath, const YCHAR *newpath)
{
struct yaffs_obj *parent = NULL;
struct yaffs_obj *obj;
}
yaffsfs_Lock();
- parent = yaffsfs_FindDirectory(NULL, newpath, &name, 0, ¬Dir, &loop);
+ parent = yaffsfs_FindDirectory(reldir, newpath, &name, 0, ¬Dir, &loop);
if (!parent && notDir)
yaffsfs_SetError(-ENOTDIR);
else if (loop)
obj = yaffs_create_symlink(parent, name, mode, 0, 0, oldpath);
if (obj)
retVal = 0;
- else if (yaffsfs_FindObject
- (NULL, newpath, 0, 0, NULL, NULL, NULL))
+ else if (yaffsfs_FindObject(reldir, newpath, 0, 0,
+ NULL, NULL, NULL))
yaffsfs_SetError(-EEXIST);
else
yaffsfs_SetError(-ENOSPC);
return retVal;
}
+int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
+{
+ return yaffs_symlink_reldir(NULL, oldpath, newpath);
+}
-int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
+int yaffs_readlink_reldir(struct yaffs_obj *reldir,const YCHAR *path,
+ YCHAR *buf, int bufsiz)
{
struct yaffs_obj *obj = NULL;
struct yaffs_obj *dir = NULL;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, ¬Dir, &loop);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, &dir, ¬Dir, &loop);
if (!dir && notDir)
yaffsfs_SetError(-ENOTDIR);
yaffsfs_Unlock();
return retVal;
}
+int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
+{
+ return yaffs_readlink_reldir(NULL, path, buf, bufsiz);
+}
-int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
+int yaffs_link_reldir(struct yaffs_obj *reldir,
+ const YCHAR *oldpath, const YCHAR *linkpath)
{
/* Creates a link called newpath to existing oldpath */
struct yaffs_obj *obj = NULL;
yaffsfs_Lock();
- obj = yaffsfs_FindObject(NULL, oldpath, 0, 1,
+ obj = yaffsfs_FindObject(reldir, oldpath, 0, 1,
&obj_dir, ¬DirObj, &objLoop);
- lnk = yaffsfs_FindObject(NULL, linkpath, 0, 0, NULL, NULL, NULL);
- lnk_dir = yaffsfs_FindDirectory(NULL, linkpath, &newname,
+ lnk = yaffsfs_FindObject(reldir, linkpath, 0, 0, NULL, NULL, NULL);
+ lnk_dir = yaffsfs_FindDirectory(reldir, linkpath, &newname,
0, ¬DirLnk, &lnkLoop);
if ((!obj_dir && notDirObj) || (!lnk_dir && notDirLnk))
return retVal;
}
+int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath)
+{
+ return yaffs_link_reldir(NULL, oldpath, linkpath);
+}
-int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev)
+int yaffs_mknod_reldir(struct yaffs_obj *reldir, const YCHAR *pathname,
+ mode_t mode, dev_t dev_val)
{
(void) pathname;
(void) mode;
- (void) dev;
+ (void) dev_val;
+ (void) reldir;
yaffsfs_SetError(-EINVAL);
return -1;
}
+int yaffs_mknod_reldev(struct yaffs_dev *dev, const YCHAR *pathname, mode_t mode, dev_t dev_val)
+{
+ return yaffs_mknod_reldir(ROOT_DIR(dev), pathname, mode, dev_val);
+}
+
+int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev_val)
+{
+ return yaffs_mknod_reldir(NULL, pathname, mode, dev_val);
+}
+
/*
* D E B U G F U N C T I O N S
*/
* yaffs_n_handles()
* Returns number of handles attached to the object
*/
-int yaffs_n_handles(const YCHAR *path)
+int yaffs_n_handles_reldir(struct yaffs_obj *reldir, const YCHAR *path)
{
struct yaffs_obj *obj;
return -1;
}
- obj = yaffsfs_FindObject(NULL, path, 0, 1, NULL, NULL, NULL);
+ obj = yaffsfs_FindObject(reldir, path, 0, 1, NULL, NULL, NULL);
if (obj)
return yaffsfs_CountHandles(obj);
return -1;
}
+int yaffs_n_handles(const YCHAR *path)
+{
+ return yaffs_n_handles_reldir(NULL, path);
+}
+
int yaffs_get_error(void)
{
return yaffsfs_GetLastError();
return 0;
}
-int yaffs_dump_dev(const YCHAR *path)
+struct yaffs_obj * yaffs_get_obj_from_fd(int handle)
+{
+ return yaffsfs_HandleToObject(handle);
+}
+
+int yaffs_dump_dev_reldir(struct yaffs_obj *reldir, const YCHAR *path)
{
#if 1
(void) path;
+ (void) reldir;
#else
YCHAR *rest;
- struct yaffs_obj *obj = yaffsfs_FindRoot(path, &rest);
- if (obj) {
- struct yaffs_dev *dev = obj->my_dev;
+ if (!reldir)
+ reldir = yaffsfs_FindRoot(path, &rest);
+
+ if (reldir) {
+ struct yaffs_dev *dev = reldir->my_dev;
printf("\n"
"n_page_writes.......... %d\n"
#endif
return 0;
}
+
+int yaffs_dump_dev(const YCHAR *path)
+{
+ return yaffs_dump_dev_reldir(NULL, path);
+}
projects / yaffs2.git / blobdiff