io.h File Reference

#include <fcntl.h>

Include dependency graph for io.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	fs_open (char *path, int rw)
void	fs_read (off_t pos, int size, void *data)
int	fs_test (off_t pos, int size)
void	fs_write (off_t pos, int size, void *data)
int	fs_close (int write)
int	fs_changed (void)

Function Documentation

fs_changed()

int fs_changed

(

void

)

Definition at line 479 of file io.c.

{
    return ! !changes || did_change;
}

Referenced by VfatChkdsk().

fs_close()

int fs_close

(

int

write

)

Definition at line 459 of file io.c.

{
    CHANGE *next;
    int changed;
 
    changed = ! !changes;
    if (write)
    fs_flush();
    else
    while (changes) {
        next = changes->next;
        free(changes->data);
        free(changes);
        changes = next;
    }
    if (close(fd) < 0)
    pdie("closing filesystem");
    return changed || did_change;
}

fs_open()

void fs_open	(	char *	path,
		int	rw
	)

Definition at line 163 of file io.c.

{
    if ((fd = open(path, rw ? O_RDWR : O_RDONLY)) < 0) {
    perror("open");
    exit(6);
    }
    changes = last = NULL;
    did_change = 0;
}

fs_read()

void fs_read	(	off_t	pos,
		int	size,
		void *	data
	)

Read data from the partition, accounting for any pending updates that are queued for writing.

Parameters

[in]	pos	Byte offset, relative to the beginning of the partition, at which to read
[in]	size	Number of bytes to read
[out]	data	Where to put the data read

Definition at line 282 of file io.c.

{
    CHANGE *walk;
    int got;
 
#ifdef __REACTOS__
    const size_t readsize_aligned = (size % 512) ? (size + (512 - (size % 512))) : size;
    const off_t seekpos_aligned = pos - (pos % 512);
    const size_t seek_delta = (size_t)(pos - seekpos_aligned);
#if DBG
    const size_t readsize = (size_t)(pos - seekpos_aligned) + readsize_aligned;
#endif
    char* tmpBuf = alloc(readsize_aligned);
    if (lseek(fd, seekpos_aligned, 0) != seekpos_aligned) pdie("Seek to %lld",pos);
    if ((got = read(fd, tmpBuf, readsize_aligned)) < 0) pdie("Read %d bytes at %lld",size,pos);
    assert(got >= size);
    got = size;
    assert(seek_delta + size <= readsize);
    memcpy(data, tmpBuf+seek_delta, size);
    free(tmpBuf);
#else
    if (lseek(fd, pos, 0) != pos)
    pdie("Seek to %lld", (long long)pos);
    if ((got = read(fd, data, size)) < 0)
    pdie("Read %d bytes at %lld", size, (long long)pos);
#endif
    if (got != size)
    die("Got %d bytes instead of %d at %lld", got, size, (long long)pos);
    for (walk = changes; walk; walk = walk->next) {
    if (walk->pos < pos + size && walk->pos + walk->size > pos) {
        if (walk->pos < pos)
        memcpy(data, (char *)walk->data + pos - walk->pos,
               min(size, walk->size - pos + walk->pos));
        else
        memcpy((char *)data + walk->pos - pos, walk->data,
               min(walk->size, size + pos - walk->pos));
    }
    }
}

Referenced by add_file(), alloc_rootdir_entry(), check_backup_boot(), find_volume_de(), read_boot(), read_fat(), read_fsinfo(), and write_boot_label().

fs_test()

int fs_test	(	off_t	pos,
		int	size
	)

Definition at line 322 of file io.c.

{
    void *scratch;
    int okay;
 
#ifdef __REACTOS__
    const size_t readsize_aligned = (size % 512) ? (size + (512 - (size % 512))) : size;        // TMN:
    const off_t seekpos_aligned = pos - (pos % 512);                   // TMN:
    scratch = alloc(readsize_aligned);
    if (lseek(fd, seekpos_aligned, 0) != seekpos_aligned) pdie("Seek to %lld",pos);
    okay = read(fd, scratch, readsize_aligned) == (int)readsize_aligned;
    free(scratch);
#else
    if (lseek(fd, pos, 0) != pos)
    pdie("Seek to %lld", (long long)pos);
    scratch = alloc(size);
    okay = read(fd, scratch, size) == size;
    free(scratch);
#endif
    return okay;
}

Referenced by fix_bad(), read_boot(), and test_file().

fs_write()

void fs_write	(	off_t	pos,
		int	size,
		void *	data
	)

Definition at line 344 of file io.c.

{
    CHANGE *new;
    int did;
 
#ifdef __REACTOS__
 
    if (FsCheckFlags & FSCHECK_IMMEDIATE_WRITE) {
        void *scratch;
        const size_t readsize_aligned = (size % 512) ? (size + (512 - (size % 512))) : size;
        const off_t seekpos_aligned = pos - (pos % 512);
        const size_t seek_delta = (size_t)(pos - seekpos_aligned);
        BOOLEAN use_read = (seek_delta != 0) || ((readsize_aligned-size) != 0);
 
        assert(interactive || rw);
 
        /* Aloc temp buffer if write is not aligned */
        if (use_read)
            scratch = alloc(readsize_aligned);
        else
            scratch = data;
 
        did_change = 1;
        if (lseek(fd, seekpos_aligned, 0) != seekpos_aligned) pdie("Seek to %lld",seekpos_aligned);
 
        if (use_read)
        {
            /* Read aligned data */
            if (read(fd, scratch, readsize_aligned) < 0) pdie("Read %d bytes at %lld",size,pos);
 
            /* Patch data in memory */
            memcpy((char *)scratch + seek_delta, data, size);
 
            /* Seek back to the beginning of our read */ 
            if (lseek(fd, seekpos_aligned, 0) != seekpos_aligned) pdie("Seek to %lld",seekpos_aligned);
        }
 
        /* Write it back */
        if ((did = write(fd, scratch, readsize_aligned)) == (int)readsize_aligned)
        {
            if (use_read) free(scratch);
            return;
        }
        if (did < 0) pdie("Write %d bytes at %lld", size, pos);
        die("Wrote %d bytes instead of %d at %lld", did, size, pos);
    }
#else
    if (write_immed) {
    did_change = 1;
    if (lseek(fd, pos, 0) != pos)
        pdie("Seek to %lld", (long long)pos);
    if ((did = write(fd, data, size)) == size)
        return;
    if (did < 0)
        pdie("Write %d bytes at %lld", size, (long long)pos);
    die("Wrote %d bytes instead of %d at %lld", did, size, (long long)pos);
    }
#endif
    new = alloc(sizeof(CHANGE));
    new->pos = pos;
    memcpy(new->data = alloc(new->size = size), data, size);
    new->next = NULL;
    if (last)
    last->next = new;
    else
    changes = new;
    last = new;
}

Referenced by add_file(), alloc_rootdir_entry(), auto_rename(), check_backup_boot(), check_fat_state_bit(), clear_lfn_slots(), fs_flush(), lfn_add_slot(), lfn_fix_checksum(), lfn_get(), lfn_remove(), read_fat(), read_fsinfo(), reclaim_file(), rename_file(), set_fat(), update_free(), write_boot_label(), and write_volume_label().