Пример #1
0
Файл: vfs.c Проект: Rotte/osm-k
int vfs_getfree(char *filesystem)
{
    fs_t *fs = NULL;
    int ret;

    if (vfs_start_op() != VFS_OK)
        return VFS_UNUSABLE;

    semaphore_P(vfs_table.sem);

    fs = vfs_get_filesystem(filesystem);

    if(fs == NULL) {
        semaphore_V(vfs_table.sem);
        vfs_end_op();
        return VFS_NO_SUCH_FS;
    }

    ret = fs->getfree(fs);

    semaphore_V(vfs_table.sem);

    vfs_end_op();
    return ret;
}
Пример #2
0
Файл: vfs.c Проект: Rotte/osm-k
int vfs_file(char *pathname, int idx, char *buffer)
{
    char volumename[VFS_NAME_LENGTH];
    char dirname[VFS_NAME_LENGTH];
    fs_t *fs = NULL;
    int ret;

    if (vfs_start_op() != VFS_OK)
        return VFS_UNUSABLE;

    if (vfs_parse_pathname(pathname, volumename, dirname) != VFS_OK) {
        vfs_end_op();
        return VFS_ERROR;
    }

    semaphore_P(vfs_table.sem);

    fs = vfs_get_filesystem(volumename);

    if(fs == NULL) {
        semaphore_V(vfs_table.sem);
        vfs_end_op();
        return VFS_NO_SUCH_FS;
    }

    ret = fs->file(fs, dirname, idx, buffer);

    semaphore_V(vfs_table.sem);

    vfs_end_op();
    return ret;
}
Пример #3
0
Файл: vfs.c Проект: mrb852/osm
/**
 * Removes given file from filesystem.
 *
 * @param pathname Full name of the file, including mountpoint.
 *
 * @return VFS_OK on success, negative (VFS_*) on failure.
 *
 */
int vfs_remove(const char *pathname)
{
  char volumename[VFS_NAME_LENGTH];
  char filename[VFS_NAME_LENGTH];
  fs_t *fs = NULL;
  int ret;

  if (vfs_start_op() != VFS_OK)
    return VFS_UNUSABLE;

  if (vfs_parse_pathname(pathname, volumename, filename) != VFS_OK) {
    vfs_end_op();
    return VFS_INVALID_PARAMS;
  }

  semaphore_P(vfs_table.sem);

  fs = vfs_get_filesystem(volumename);

  if(fs == NULL) {
    semaphore_V(vfs_table.sem);
    vfs_end_op();
    return VFS_NO_SUCH_FS;
  }

  ret = fs->remove(fs, filename);

  semaphore_V(vfs_table.sem);

  vfs_end_op();
  return ret;
}
Пример #4
0
Файл: vfs.c Проект: Rotte/osm-k
int vfs_create(char *pathname, int size)
{
    char volumename[VFS_NAME_LENGTH];
    char filename[VFS_NAME_LENGTH];
    fs_t *fs = NULL;
    int ret;

    KERNEL_ASSERT(size >= 0);

    if (vfs_start_op() != VFS_OK)
        return VFS_UNUSABLE;

    if(vfs_parse_pathname(pathname, volumename, filename) != VFS_OK) {
        vfs_end_op();
        return VFS_ERROR;
    }

    semaphore_P(vfs_table.sem);

    fs = vfs_get_filesystem(volumename);

    if(fs == NULL) {
        semaphore_V(vfs_table.sem);
        vfs_end_op();
        return VFS_NO_SUCH_FS;
    }

    ret = fs->create(fs, filename, size);

    semaphore_V(vfs_table.sem);

    vfs_end_op();
    return ret;
}
Пример #5
0
int vfs_file(char *pathname, int idx, char *buffer)
{
    char volumename[VFS_NAME_LENGTH];
    char dirname[VFS_NAME_LENGTH];
    fs_t *fs = NULL;
    int ret;

    if (vfs_start_op() != VFS_OK)
        return VFS_UNUSABLE;

    if (pathname == NULL) {
        semaphore_P(vfs_table.sem);
        for (ret = 0; ret < CONFIG_MAX_FILESYSTEMS && idx != 0; ret++) {
            if (vfs_table.filesystems[ret].filesystem != NULL)
                idx--;
        }
        /* Error can be caused if idx was <= 0 or idx was higher than the
         * number of mounted volumes
         */
        if (idx != 0) {
            semaphore_V(vfs_table.sem);
            vfs_end_op();
            return VFS_ERROR;
        }
        stringcopy(buffer, vfs_table.filesystems[ret].mountpoint, VFS_NAME_LENGTH);
        semaphore_V(vfs_table.sem);
        vfs_end_op();
        return VFS_OK;
    }

    if (vfs_parse_pathname(pathname, volumename, dirname) != VFS_OK) {
        vfs_end_op();
        return VFS_ERROR;
    }

    semaphore_P(vfs_table.sem);

    fs = vfs_get_filesystem(volumename);

    if(fs == NULL) {
        semaphore_V(vfs_table.sem);
        vfs_end_op();
        return VFS_NO_SUCH_FS;
    }

    ret = fs->file(fs, dirname, idx, buffer);

    semaphore_V(vfs_table.sem);

    vfs_end_op();
    return ret;
}
Пример #6
0
Файл: vfs.c Проект: Rotte/osm-k
int vfs_write(openfile_t file, void *buffer, int datasize)
{
    openfile_entry_t *openfile;
    fs_t *fs;
    int ret;

    if (vfs_start_op() != VFS_OK)
        return VFS_UNUSABLE;

    openfile = vfs_verify_open(file);
    fs = openfile->filesystem;

    KERNEL_ASSERT(datasize >= 0 && buffer != NULL);

    ret = fs->write(fs, openfile->fileid, buffer, datasize,
                    openfile->seek_position);

    if(ret > 0) {
        semaphore_P(openfile_table.sem);
        openfile->seek_position += ret;
        semaphore_V(openfile_table.sem);
    }

    vfs_end_op();
    return ret;
}
Пример #7
0
Файл: vfs.c Проект: mrb852/osm
/**
 * Seek given file to given position. The position is not verified
 * to be within the file's size.
 *
 * @param file Open file
 *
 * @param seek_position New positive seek position.
 *
 * @return VFS_OK, panics on invalid arguments.
 *
 */
int vfs_seek(openfile_t file, int seek_position)
{
  openfile_entry_t *openfile;

  if (vfs_start_op() != VFS_OK)
    return VFS_UNUSABLE;

  if(seek_position < 0) {
    return VFS_INVALID_PARAMS;
  }

  semaphore_P(openfile_table.sem);

  openfile = vfs_verify_open(file);
  if (openfile == NULL) {
    semaphore_V(openfile_table.sem);
    return VFS_NOT_OPEN;
  }

  openfile->seek_position = seek_position;

  semaphore_V(openfile_table.sem);

  vfs_end_op();
  return VFS_OK;
}
Пример #8
0
Файл: vfs.c Проект: mrb852/osm
/**
 * Close open file.
 *
 * @param file Openfile id
 *
 * @return VFS_OK on success, negative (VFS_*) on error.
 *
 */
int vfs_close(openfile_t file)
{
  openfile_entry_t *openfile;
  fs_t *fs;
  int ret;

  if (vfs_start_op() != VFS_OK)
    return VFS_UNUSABLE;

  semaphore_P(openfile_table.sem);

  openfile = vfs_verify_open(file);
  if (openfile == NULL) {
    semaphore_V(openfile_table.sem);
    return VFS_NOT_OPEN;
  }

  fs = openfile->filesystem;

  ret = fs->close(fs, openfile->fileid);
  openfile->filesystem = NULL;

  semaphore_V(openfile_table.sem);

  vfs_end_op();
  return ret;
}
Пример #9
0
Файл: vfs.c Проект: Rotte/osm-k
int vfs_mount(fs_t *fs, char *name)
{
    int i;
    int row;

    KERNEL_ASSERT(name != NULL && name[0] != '\0');

    if (vfs_start_op() != VFS_OK)
        return VFS_UNUSABLE;

    semaphore_P(vfs_table.sem);

    for (i = 0; i < CONFIG_MAX_FILESYSTEMS; i++) {
        if (vfs_table.filesystems[i].filesystem == NULL)
            break;
    }

    row = i;

    if(row >= CONFIG_MAX_FILESYSTEMS) {
        semaphore_V(vfs_table.sem);
        kprintf("VFS: Warning, maximum mount count exceeded, mount failed.\n");
        vfs_end_op();
        return VFS_LIMIT;
    }

    for (i = 0; i < CONFIG_MAX_FILESYSTEMS; i++) {
        if(stringcmp(vfs_table.filesystems[i].mountpoint, name) == 0) {
            semaphore_V(vfs_table.sem);
            kprintf("VFS: Warning, attempt to mount 2 filesystems "
                    "with same name\n");
            vfs_end_op();
            return VFS_ERROR;
        }
    }

    stringcopy(vfs_table.filesystems[row].mountpoint, name, VFS_NAME_LENGTH);
    vfs_table.filesystems[row].filesystem = fs;

    semaphore_V(vfs_table.sem);
    vfs_end_op();
    return VFS_OK;
}
Пример #10
0
int vfs_filecount(char *pathname)
{
    char volumename[VFS_NAME_LENGTH];
    char dirname[VFS_NAME_LENGTH];
    fs_t *fs = NULL;
    int ret;

    if (vfs_start_op() != VFS_OK)
        return VFS_UNUSABLE;

     if (pathname == NULL) {
         semaphore_P(vfs_table.sem);
         for (ret = 0; ret < CONFIG_MAX_FILESYSTEMS; ret++) {
             if (vfs_table.filesystems[ret].filesystem == NULL)
                 break;
         }
         semaphore_V(vfs_table.sem);
         vfs_end_op();
         return ret;
     }

    if (vfs_parse_pathname(pathname, volumename, dirname) != VFS_OK) {
        vfs_end_op();
        return VFS_ERROR;
    }

    semaphore_P(vfs_table.sem);

    fs = vfs_get_filesystem(volumename);

    if(fs == NULL) {
        semaphore_V(vfs_table.sem);
        vfs_end_op();
        return VFS_NO_SUCH_FS;
    }

    ret = fs->filecount(fs, dirname);

    semaphore_V(vfs_table.sem);

    vfs_end_op();
    return ret;
}
Пример #11
0
Файл: vfs.c Проект: Rotte/osm-k
int vfs_unmount(char *name)
{
    int i, row;
    fs_t *fs = NULL;

    if (vfs_start_op() != VFS_OK)
        return VFS_UNUSABLE;

    semaphore_P(vfs_table.sem);

    for (row = 0; row < CONFIG_MAX_FILESYSTEMS; row++) {
        if(!stringcmp(vfs_table.filesystems[row].mountpoint, name)) {
            fs = vfs_table.filesystems[row].filesystem;
            break;
        }
    }

    if(fs == NULL) {
        semaphore_V(vfs_table.sem);
        vfs_end_op();
        return VFS_NOT_FOUND;
    }

    semaphore_P(openfile_table.sem);
    for(i = 0; i < CONFIG_MAX_OPEN_FILES; i++) {
        if(openfile_table.files[i].filesystem == fs) {
            semaphore_V(openfile_table.sem);
            semaphore_V(vfs_table.sem);
            vfs_end_op();
            return VFS_IN_USE;
        }
    }

    fs->unmount(fs);
    vfs_table.filesystems[row].filesystem = NULL;

    semaphore_V(openfile_table.sem);
    semaphore_V(vfs_table.sem);
    vfs_end_op();
    return VFS_OK;
}
Пример #12
0
Файл: vfs.c Проект: Rotte/osm-k
int vfs_seek(openfile_t file, int seek_position)
{
    openfile_entry_t *openfile;

    if (vfs_start_op() != VFS_OK)
        return VFS_UNUSABLE;

    KERNEL_ASSERT(seek_position >= 0);
    semaphore_P(openfile_table.sem);

    openfile = vfs_verify_open(file);
    openfile->seek_position = seek_position;

    semaphore_V(openfile_table.sem);

    vfs_end_op();
    return VFS_OK;
}
Пример #13
0
Файл: vfs.c Проект: mrb852/osm
/**
 * Tells the given file's position.
 *
 * @param file Open file
 *
 * @return the file's seek position. Negative values on error
 *
 */
int vfs_tell(openfile_t file)
{
  openfile_entry_t *openfile;

  if (vfs_start_op() != VFS_OK)
    return VFS_UNUSABLE;

  semaphore_P(openfile_table.sem);

  openfile = vfs_verify_open(file);
  if (openfile == NULL) {
    semaphore_V(openfile_table.sem);
    return VFS_NOT_OPEN;
  }

  int seek_position = openfile->seek_position;

  semaphore_V(openfile_table.sem);

  vfs_end_op();
  return seek_position;
}
Пример #14
0
Файл: vfs.c Проект: mrb852/osm
/**
 * Writes datasize bytes from given buffer to given open file.
 * The write is started from current seek position and after writing, the
 * position is updated.
 *
 * @param file Open file
 *
 * @param buffer Buffer to be written to file.
 *
 * @param datasize Number of bytes to write.
 *
 * @return Number of bytes written. All bytes are written unless error
 * prevented to do that. Negative values are specific error conditions.
 *
 */
int vfs_write(openfile_t file, void *buffer, int datasize)
{
  openfile_entry_t *openfile;
  fs_t *fs;
  int fileid, seek_position, ret;

  if (datasize < 0 || buffer == NULL) {
    return VFS_INVALID_PARAMS;
  }

  if (vfs_start_op() != VFS_OK)
    return VFS_UNUSABLE;

  semaphore_P(openfile_table.sem);

  openfile = vfs_verify_open(file);
  if (openfile == NULL) {
    semaphore_V(openfile_table.sem);
    return VFS_NOT_OPEN;
  }

  fs = openfile->filesystem;
  fileid = openfile->fileid;
  seek_position = openfile->seek_position;

  semaphore_V(openfile_table.sem);

  ret = fs->write(fs, fileid, buffer, datasize, seek_position);

  if(ret > 0) {
    semaphore_P(openfile_table.sem);
    openfile->seek_position += ret;
    semaphore_V(openfile_table.sem);
  }

  vfs_end_op();
  return ret;
}
Пример #15
0
Файл: vfs.c Проект: Rotte/osm-k
openfile_t vfs_open(char *pathname)
{
    openfile_t file;
    int fileid;
    char volumename[VFS_NAME_LENGTH];
    char filename[VFS_NAME_LENGTH];
    fs_t *fs = NULL;

    if (vfs_start_op() != VFS_OK)
        return VFS_UNUSABLE;

    if (vfs_parse_pathname(pathname, volumename, filename) != VFS_OK) {
        vfs_end_op();
        return VFS_ERROR;
    }

    semaphore_P(vfs_table.sem);
    semaphore_P(openfile_table.sem);

    for(file=0; file<CONFIG_MAX_OPEN_FILES; file++) {
        if(openfile_table.files[file].filesystem == NULL) {
            break;
        }
    }

    if(file >= CONFIG_MAX_OPEN_FILES) {
        semaphore_V(openfile_table.sem);
        semaphore_V(vfs_table.sem);
        kprintf("VFS: Warning, maximum number of open files exceeded.");
        vfs_end_op();
        return VFS_LIMIT;
    }

    fs = vfs_get_filesystem(volumename);

    if(fs == NULL) {
        semaphore_V(openfile_table.sem);
        semaphore_V(vfs_table.sem);
        vfs_end_op();
        return VFS_NO_SUCH_FS;
    }

    openfile_table.files[file].filesystem = fs;

    semaphore_V(openfile_table.sem);
    semaphore_V(vfs_table.sem);

    fileid = fs->open(fs, filename);

    if(fileid < 0) {
        semaphore_P(openfile_table.sem);
        openfile_table.files[file].filesystem = NULL;
        semaphore_V(openfile_table.sem);
        vfs_end_op();
        return fileid; /* negative -> error*/
    }

    openfile_table.files[file].fileid = fileid;
    openfile_table.files[file].seek_position = 0;

    vfs_end_op();
    return file;
}