240x_C_IO_Driver.zip_C ramdi_TMS320LF240x_ramdisk

/*****************************************************************************/ /* RAMDISK.C - Example user-defined device. */ /*****************************************************************************/ #include <stdlib.h> #include <string.h> #include <file.h> /*****************************************************************************/ /* This file presents a sample implementation of a user-defined device. */ /* The user must define the seven basic functions (open, close, read, */ /* write, lseek, unlink, rename). These are expected to behave just like */ /* the Unix functions of these names, but this is not strictly necessary to */ /* work properly. Also consider something like a TTY device might not be */ /* lseek-able, but can still be opened and read from. A device is added */ /* using the add_device() RTS function call (q.v.). */ /*****************************************************************************/ /* The low-level interface is based on file names and file descriptors. */ /* The file names don't need to be valid Unix file names, but must mean */ /* something to the device. File descriptors are integers which represent */ /* distinct streams open to a file; there may be more than one descriptor */ /* open to each file. The device must keep track of its own file */ /* descriptors, which will be used by the calling functions to read and */ /* write to the device. If there can only be one instance of a "file" on a */ /* device, the file descriptor doesn't matter much, so just pass a */ /* non-negative integer such as zero. */ /*****************************************************************************/ /* The RAMDISK device attempts to follow the Unix devices as closely as */ /* possible, and even supports file descriptors which point to unlinked */ /* files; however, since the RTS doesn't make extensive use of errno, quite */ /* a bit of functionality can't be reproduced. */ /*****************************************************************************/ /*****************************************************************************/ /* RAM_FILES represents the actual ramdisk. It contains files which have */ /* been created. These files might not be open. Take note of the unlinked */ /* flag; if a file is marked unlinked, it is no longer accessible by name. */ /* Attempts to open the file actually create a new entry in RAM_FILES. */ /*****************************************************************************/ /* We could have dynamically reallocated these data structures, but that */ /* would just complicate the example. */ /*****************************************************************************/ #define _NRAMFILES 10 #define _NRAMFDS 10 static struct ram_file_info { char *name; unsigned char *data; unsigned int size; unsigned int unlinked:1; } ram_files[_NRAMFILES] = { { 0 } }; /*****************************************************************************/ /* RAM_FDS contains information about open file descriptors. */ /*****************************************************************************/ static struct ram_fd_info { struct ram_file_info *file; unsigned int flags; unsigned int pos; } ram_fds[_NRAMFDS] = { { 0 } }; /*****************************************************************************/ /* */ /* RAM_SET_FILE_SIZE() - Truncate or extend current file size. */ /* */ /*****************************************************************************/ static int ram_set_file_size(struct ram_file_info *file, unsigned int newsize) { unsigned int oldsize = file->size; unsigned char *new_data = realloc(file->data, newsize); /*-----------------------------------------------------------------------*/ /* If realloc fails, there's not much we can do about it... */ /*-----------------------------------------------------------------------*/ if (newsize && !new_data) return -1; file->data = (newsize == 0 ? NULL : new_data); file->size = newsize; /*-----------------------------------------------------------------------*/ /* If we have increased the size of the file (possibly by lseeking past */ /* the end), fill the gap with zeros. */ /*-----------------------------------------------------------------------*/ if (newsize > oldsize) memset(file->data + oldsize, '\0', newsize - oldsize); return 1; } /*****************************************************************************/ /* */ /* RAM_FIND_FILE() - Find (possibly creating) a file of a given name */ /* */ /*****************************************************************************/ static struct ram_file_info *ram_find_file(const char *path, int flags) { struct ram_file_info *avail = NULL; int i; /*-----------------------------------------------------------------------*/ /* Go through all the file slots, looking for a non-unlinked file of */ /* the given name. Also look for an empty slot for creating the file */ /* if it doesn't already exist. */ /*-----------------------------------------------------------------------*/ for (i=0; i < _NRAMFILES; i++) if (ram_files[i].name == NULL) avail = &ram_files[i]; else if (!ram_files[i].unlinked && !strcmp(path, ram_files[i].name)) return &ram_files[i]; /*-----------------------------------------------------------------------*/ /* If not found, and the O_CREAT flag was set, go ahead and create an */ /* empty file. */ /*-----------------------------------------------------------------------*/ if (flags & O_CREAT) { avail->name = malloc(strlen(path) + 1); if (!avail->name) return NULL; strcpy(avail->name, path); avail->data = NULL; avail->size = 0; avail->unlinked = 0; return avail; } else return NULL; } /*****************************************************************************/ /* */ /* RAM_MAYBE_UNLINK_FILE() - Delete a file with no open file descriptors. */ /* */ /*****************************************************************************/ static void ram_maybe_unlink_file(struct ram_file_info *file) { int i; /*-----------------------------------------------------------------------*/ /* This function gets called at each attempt to unlink a file, and when */ /* an unlinked file is closed. The file is deleted from disk, but only */ /* if there are no open file descriptors to it. It is perfectly legal */ /* to unlink an open file; the actual file stays on disk until its last */ /* file descriptor is closed. */ /*-----------------------------------------------------------------------*/ for (i=0; i < _NRAMFDS; i++) if (ram_fds[i].file == file) return; if (file->size) free(file->data); free(file->name); file->name = NULL; } /*****************************************************************************/ /*****************************************************************************/ int RAM_open_called = 0; // strictly for testing... /*****************************************************************************/ /* */ /* RAM_OPEN() - Behaves just like open() */ /*