ssize_t
ext2lib_pread(fsi_file_t *file, void *buf, size_t nbytes, uint64_t off)
{
ext2_file_t *f = fsip_file_data(file);
__u64 tmpoff;
unsigned int n;
int err;
if ((err = ext2fs_file_llseek(*f, 0, EXT2_SEEK_CUR, &tmpoff)) != 0) {
errno = EINVAL;
return (-1);
}
if ((err = ext2fs_file_llseek(*f, off, EXT2_SEEK_SET, NULL)) != 0) {
errno = EINVAL;
return (-1);
}
err = ext2fs_file_read(*f, buf, nbytes, &n);
ext2fs_file_llseek(*f, tmpoff, EXT2_SEEK_SET, NULL);
if (err != 0) {
errno = EINVAL;
return (-1);
}
return (n);
}
int op_read (const char *path, char *buf, size_t size, off_t offset, struct fuse_file_info *fi)
{
__u64 pos;
errcode_t rc;
unsigned int bytes;
ext2_file_t efile = EXT2FS_FILE(fi->fh);
ext2_filsys e2fs = current_ext2fs();
debugf("enter");
debugf("path = %s", path);
efile = do_open(e2fs, path, O_RDONLY);
rc = ext2fs_file_llseek(efile, offset, SEEK_SET, &pos);
if (rc) {
do_release(efile);
return -EINVAL;
}
rc = ext2fs_file_read(efile, buf, size, &bytes);
if (rc) {
do_release(efile);
return -EIO;
}
do_release(efile);
debugf("leave");
return bytes;
}
size_t do_write (ext2_file_t efile, const char *buf, size_t size, off_t offset)
{
int rt;
const char *tmp;
unsigned int wr;
unsigned long long npos;
unsigned long long fsize;
debugf("enter");
rt = ext2fs_file_get_lsize(efile, &fsize);
if (rt != 0) {
debugf("ext2fs_file_get_lsize(efile, &fsize); failed");
return rt;
}
if (offset + size > fsize) {
rt = ext2fs_file_set_size2(efile, offset + size);
if (rt) {
debugf("extfs_file_set_size(efile, %lld); failed", offset + size);
return rt;
}
}
rt = ext2fs_file_llseek(efile, offset, SEEK_SET, &npos);
if (rt) {
debugf("ext2fs_file_lseek(efile, %lld, SEEK_SET, &npos); failed", offset);
return rt;
}
for (rt = 0, wr = 0, tmp = buf; size > 0 && rt == 0; size -= wr, tmp += wr) {
rt = ext2fs_file_write(efile, tmp, size, &wr);
debugf("rt: %d, size: %u, written: %u", rt, size, wr);
}
if (rt) {
debugf("ext2fs_file_write(edile, tmp, size, &wr); failed");
return rt;
}
rt = ext2fs_file_flush(efile);
if (rt) {
debugf("ext2_file_flush(efile); failed");
return rt;
}
debugf("leave");
return wr;
}
s64 ext2_seek64_r (struct _reent *r, int fd, s64 pos, int dir)
{
ext2_log_trace("fd %p, pos %lli, dir %i\n", (void *) fd, pos, dir);
ext2_file_state* file = STATE(fd);
// Sanity check
if (!file || !file->fd) {
r->_errno = EINVAL;
return -1;
}
__u64 pos_loaded = 0;
ext2fs_file_llseek(file->fd, pos, dir, &pos_loaded);
return (s64) pos_loaded;
}
static int read_journal_block(const char *cmd, struct journal_source *source,
ext2_loff_t offset, char *buf, unsigned int size)
{
int retval;
unsigned int got;
if (source->where == JOURNAL_IS_EXTERNAL) {
if (lseek(source->fd, offset, SEEK_SET) < 0) {
retval = errno;
goto seek_err;
}
retval = read(source->fd, buf, size);
if (retval < 0) {
retval = errno;
goto read_err;
}
got = retval;
retval = 0;
} else {
retval = ext2fs_file_llseek(source->file, offset,
EXT2_SEEK_SET, NULL);
if (retval) {
seek_err:
com_err(cmd, retval, "while seeking in reading journal");
return retval;
}
retval = ext2fs_file_read(source->file, buf, size, &got);
if (retval) {
read_err:
com_err(cmd, retval, "while reading journal");
return retval;
}
}
if (got != size) {
com_err(cmd, 0, "short read (read %u, expected %u) "
"while reading journal", got, size);
retval = -1;
}
return retval;
}
int ext2_open_r (struct _reent *r, void *fileStruct, const char *path, int flags, int mode)
{
//ext2_log_trace("fileStruct %p, path %s, flags %i, mode %i\n", fileStruct, path, flags, mode);
ext2_file_state* file = STATE(fileStruct);
// Get the volume descriptor for this path
file->vd = ext2GetVolume(path);
if (!file->vd) {
r->_errno = ENODEV;
return -1;
}
// Lock
ext2Lock(file->vd);
// Determine which mode the file is opened for
file->flags = flags;
if ((flags & 0x03) == O_RDONLY) {
file->read = true;
file->write = false;
file->append = false;
} else if ((flags & 0x03) == O_WRONLY) {
file->read = false;
file->write = true;
file->append = (flags & O_APPEND);
} else if ((flags & 0x03) == O_RDWR) {
file->read = true;
file->write = true;
file->append = (flags & O_APPEND);
} else {
r->_errno = EACCES;
ext2Unlock(file->vd);
return -1;
}
// Try and find the file and (if found) ensure that it is not a directory
file->ni = ext2OpenEntry(file->vd, path);
if (file->ni && LINUX_S_ISDIR(file->ni->ni.i_mode))
{
ext2CloseEntry(file->vd, file->ni);
ext2Unlock(file->vd);
r->_errno = EISDIR;
return -1;
}
// Are we creating this file?
if ((flags & O_CREAT) && !file->ni)
// Create the file
file->ni = ext2Create(file->vd, path, S_IFREG, NULL);
// exit(0);
// Sanity check, the file should be open by now
if (!file->ni) {
ext2Unlock(file->vd);
r->_errno = ENOENT;
return -1;
}
// Make sure we aren't trying to write to a read-only file
if (!(file->vd->fs->flags & EXT2_FLAG_RW) && file->write)
{
ext2CloseEntry(file->vd, file->ni);
ext2Unlock(file->vd);
r->_errno = EROFS;
return -1;
}
errcode_t err = ext2fs_file_open2(file->vd->fs, file->ni->ino, &file->ni->ni,
file->write ? EXT2_FLAG_RW : 0, &file->fd);
if(err != 0)
{
ext2CloseEntry(file->vd, file->ni);
ext2Unlock(file->vd);
r->_errno = ENOENT;
return -1;
}
// Truncate the file if requested
if ((flags & O_TRUNC) && file->write) {
if (ext2fs_file_set_size2(file->fd, 0) != 0) {
ext2CloseEntry(file->vd, file->ni);
ext2Unlock(file->vd);
r->_errno = errno;
return -1;
}
file->ni->ni.i_size = file->ni->ni.i_size_high = 0;
}
// Set the files current position
ext2fs_file_llseek(file->fd, file->append ? EXT2_I_SIZE(&file->ni->ni) : 0, SEEK_SET, 0);
//ext2_log_trace("file->len %lld\n", EXT2_I_SIZE(&file->ni->ni));
// Update file times
ext2UpdateTimes(file->vd, file->ni, EXT2_UPDATE_ATIME);
// Insert the file into the double-linked FILO list of open files
if (file->vd->firstOpenFile) {
file->nextOpenFile = file->vd->firstOpenFile;
file->vd->firstOpenFile->prevOpenFile = file;
} else {
file->nextOpenFile = NULL;
}
file->prevOpenFile = NULL;
file->vd->firstOpenFile = file;
file->vd->openFileCount++;
// Sync access time
ext2Sync(file->vd, file->ni);
file->is_ntfs = 0;
// Unlock
ext2Unlock(file->vd);
return (int)(s64)fileStruct;
}
int ext2_file_to_sectors (struct _reent *r,const char *path,uint32_t *sec_out,uint32_t *size_out,int max,int phys)
{
ntfs_file_state fileStruct;
ext2_file_state* file = STATE(&fileStruct);
// Get the volume descriptor for this path
file->vd = ext2GetVolume(path);
if (!file->vd) {
r->_errno = ENODEV;
return -1;
}
// Lock
ext2Lock(file->vd);
file->flags = 0;
file->read = true;
file->write = false;
file->append = false;
// Try and find the file and (if found) ensure that it is not a directory
file->ni = ext2OpenEntry(file->vd, path);
if (file->ni && LINUX_S_ISDIR(file->ni->ni.i_mode))
{
ext2CloseEntry(file->vd, file->ni);
ext2Unlock(file->vd);
r->_errno = EISDIR;
return -1;
}
// Sanity check, the file should be open by now
if (!file->ni) {
ext2Unlock(file->vd);
r->_errno = ENOENT;
return -1;
}
errcode_t err = ext2fs_file_open2(file->vd->fs, file->ni->ino, &file->ni->ni,
0, &file->fd);
if(err != 0)
{
ext2CloseEntry(file->vd, file->ni);
ext2Unlock(file->vd);
r->_errno = ENOENT;
return -1;
}
//ext2_log_trace("file->len %lld\n", EXT2_I_SIZE(&file->ni->ni));
// Update file times
ext2UpdateTimes(file->vd, file->ni, EXT2_UPDATE_ATIME);
// Insert the file into the double-linked FILO list of open files
if (file->vd->firstOpenFile) {
file->nextOpenFile = file->vd->firstOpenFile;
file->vd->firstOpenFile->prevOpenFile = file;
} else {
file->nextOpenFile = NULL;
}
file->prevOpenFile = NULL;
file->vd->firstOpenFile = file;
file->vd->openFileCount++;
// Sync access time
ext2Sync(file->vd, file->ni);
file->is_ntfs = 0;
u64 read = 0;
err = 0;
// Read from the files data attribute
//err = ext2fs_file_read(file->fd, ptr, len, &read);
u64 len = 0;
ext2fs_file_llseek(file->fd, 0, SEEK_END, (__u64 *) &len);
// Set the files current position
ext2fs_file_llseek(file->fd, 0, SEEK_SET, 0);
u32 current_block = 0;
err = ext2fs_file_read_sectors(file->fd, len, &read, sec_out, size_out, ¤t_block, max);
if (err || read <= 0 || read > len) {
ext2Unlock(file->vd);
r->_errno = errno;
current_block = err ? err : -1;
goto end;
}
end:
// Close the file
ext2CloseFile(file);
// Remove the file from the double-linked FILO list of open files
file->vd->openFileCount--;
if (file->nextOpenFile)
file->nextOpenFile->prevOpenFile = file->prevOpenFile;
if (file->prevOpenFile)
file->prevOpenFile->nextOpenFile = file->nextOpenFile;
else
file->vd->firstOpenFile = file->nextOpenFile;
ext2Unlock(file->vd);
return current_block;
}
