Add primary cache management feature to libminixfs as mfs and ext2 currently do separately, remove cache code from mfs and ext2, and make them use the libminixfs interface. This makes all fields of the buf struct private to libminixfs and FS clients aren't supposed to access them at all. Only the opaque 'void *data' field (the FS block contents, used to be called bp) is to be accessed by the FS client. The main purpose is to implement the interface to the 2ndary vm cache just once, get rid of some code duplication, and add a little abstraction to reduce the code inertia of the whole caching business. Some minor sanity checking and prohibition done by mfs in this code as removed from the generic primary cache code as a result: - checking all inodes are not in use when allocating/resizing the cache - checking readonly filesystems aren't written to - checking the superblock isn't written to on mounted filesystems The minixfslib code relies on fs_blockstats() in the client filesystem to return some FS usage information.
337 lines
9.6 KiB
C
337 lines
9.6 KiB
C
#include "inc.h"
|
|
#include <minix/com.h>
|
|
#include <minix/vfsif.h>
|
|
#include <fcntl.h>
|
|
#ifdef __NBSD_LIBC
|
|
#include <stddef.h>
|
|
#endif
|
|
#include "buf.h"
|
|
|
|
static char getdents_buf[GETDENTS_BUFSIZ];
|
|
|
|
|
|
/*===========================================================================*
|
|
* fs_read *
|
|
*===========================================================================*/
|
|
int fs_read(void) {
|
|
int r, chunk, block_size;
|
|
int nrbytes;
|
|
cp_grant_id_t gid;
|
|
off_t position, f_size, bytes_left;
|
|
unsigned int off, cum_io;
|
|
int completed;
|
|
struct dir_record *dir;
|
|
|
|
r = OK;
|
|
|
|
/* Try to get inode according to its index */
|
|
dir = get_dir_record(fs_m_in.REQ_INODE_NR);
|
|
if (dir == NULL) return(EINVAL); /* no inode found */
|
|
|
|
position = fs_m_in.REQ_SEEK_POS_LO;
|
|
nrbytes = (unsigned) fs_m_in.REQ_NBYTES; /* number of bytes to read */
|
|
block_size = v_pri.logical_block_size_l;
|
|
gid = fs_m_in.REQ_GRANT;
|
|
f_size = dir->d_file_size;
|
|
|
|
rdwt_err = OK; /* set to EIO if disk error occurs */
|
|
|
|
cum_io = 0;
|
|
/* Split the transfer into chunks that don't span two blocks. */
|
|
while (nrbytes != 0) {
|
|
off = (unsigned int) (position % block_size);
|
|
|
|
chunk = MIN(nrbytes, block_size - off);
|
|
if (chunk < 0) chunk = block_size - off;
|
|
|
|
bytes_left = f_size - position;
|
|
if (position >= f_size) break; /* we are beyond EOF */
|
|
if (chunk > bytes_left) chunk = (int) bytes_left;
|
|
|
|
/* Read or write 'chunk' bytes. */
|
|
r = read_chunk(dir, cvul64(position), off, chunk, (unsigned) nrbytes,
|
|
gid, cum_io, block_size, &completed);
|
|
|
|
if (r != OK) break; /* EOF reached */
|
|
if (rdwt_err < 0) break;
|
|
|
|
/* Update counters and pointers. */
|
|
nrbytes -= chunk; /* bytes yet to be read */
|
|
cum_io += chunk; /* bytes read so far */
|
|
position += chunk; /* position within the file */
|
|
}
|
|
|
|
fs_m_out.RES_SEEK_POS_LO = position;
|
|
|
|
if (rdwt_err != OK) r = rdwt_err; /* check for disk error */
|
|
if (rdwt_err == END_OF_FILE) r = OK;
|
|
|
|
fs_m_out.RES_NBYTES = cum_io; /*dir->d_file_size;*/
|
|
release_dir_record(dir);
|
|
|
|
return(r);
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* fs_bread *
|
|
*===========================================================================*/
|
|
int fs_bread(void)
|
|
{
|
|
int r, rw_flag, chunk, block_size;
|
|
cp_grant_id_t gid;
|
|
int nrbytes;
|
|
u64_t position;
|
|
unsigned int off, cum_io;
|
|
int completed;
|
|
struct dir_record *dir;
|
|
|
|
r = OK;
|
|
|
|
rw_flag = (fs_m_in.m_type == REQ_BREAD ? READING : WRITING);
|
|
gid = fs_m_in.REQ_GRANT;
|
|
position = make64(fs_m_in.REQ_SEEK_POS_LO, fs_m_in.REQ_SEEK_POS_HI);
|
|
nrbytes = (unsigned) fs_m_in.REQ_NBYTES;
|
|
block_size = v_pri.logical_block_size_l;
|
|
dir = v_pri.dir_rec_root;
|
|
|
|
if(rw_flag == WRITING) return (EIO); /* Not supported */
|
|
rdwt_err = OK; /* set to EIO if disk error occurs */
|
|
|
|
cum_io = 0;
|
|
/* Split the transfer into chunks that don't span two blocks. */
|
|
while (nrbytes != 0) {
|
|
off = rem64u(position, block_size); /* offset in blk*/
|
|
|
|
chunk = MIN(nrbytes, block_size - off);
|
|
if (chunk < 0) chunk = block_size - off;
|
|
|
|
/* Read 'chunk' bytes. */
|
|
r = read_chunk(dir, position, off, chunk, (unsigned) nrbytes,
|
|
gid, cum_io, block_size, &completed);
|
|
|
|
if (r != OK) break; /* EOF reached */
|
|
if (rdwt_err < 0) break;
|
|
|
|
/* Update counters and pointers. */
|
|
nrbytes -= chunk; /* bytes yet to be read */
|
|
cum_io += chunk; /* bytes read so far */
|
|
position= add64ul(position, chunk); /* position within the file */
|
|
}
|
|
|
|
fs_m_out.RES_SEEK_POS_LO = ex64lo(position);
|
|
fs_m_out.RES_SEEK_POS_HI = ex64hi(position);
|
|
|
|
if (rdwt_err != OK) r = rdwt_err; /* check for disk error */
|
|
if (rdwt_err == END_OF_FILE) r = OK;
|
|
|
|
fs_m_out.RES_NBYTES = cum_io;
|
|
|
|
return(r);
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* fs_getdents *
|
|
*===========================================================================*/
|
|
int fs_getdents(void) {
|
|
struct dir_record *dir;
|
|
ino_t ino;
|
|
cp_grant_id_t gid;
|
|
size_t block_size;
|
|
off_t pos, block_pos, block, cur_pos, tmpbuf_offset, userbuf_off;
|
|
struct buf *bp;
|
|
struct dir_record *dir_tmp;
|
|
struct dirent *dirp;
|
|
int r,done,o,len,reclen;
|
|
char *cp;
|
|
char name[NAME_MAX + 1];
|
|
char name_old[NAME_MAX + 1];
|
|
|
|
/* Initialize the tmp arrays */
|
|
memset(name,'\0',NAME_MAX);
|
|
memset(name_old,'\0',NAME_MAX);
|
|
|
|
/* Get input parameters */
|
|
ino = fs_m_in.REQ_INODE_NR;
|
|
gid = fs_m_in.REQ_GRANT;
|
|
pos = fs_m_in.REQ_SEEK_POS_LO;
|
|
|
|
block_size = v_pri.logical_block_size_l;
|
|
cur_pos = pos; /* The current position */
|
|
tmpbuf_offset = 0;
|
|
userbuf_off = 0;
|
|
memset(getdents_buf, '\0', GETDENTS_BUFSIZ); /* Avoid leaking any data */
|
|
|
|
if ((dir = get_dir_record(ino)) == NULL) return(EINVAL);
|
|
|
|
block = dir->loc_extent_l; /* First block of the directory */
|
|
block += pos / block_size; /* Shift to the block where start to read */
|
|
done = FALSE;
|
|
|
|
while (cur_pos<dir->d_file_size) {
|
|
bp = get_block(block); /* Get physical block */
|
|
|
|
if (bp == NULL) {
|
|
release_dir_record(dir);
|
|
return(EINVAL);
|
|
}
|
|
|
|
block_pos = cur_pos % block_size; /* Position where to start read */
|
|
|
|
while (block_pos < block_size) {
|
|
dir_tmp = get_free_dir_record();
|
|
create_dir_record(dir_tmp,b_data(bp) + block_pos,
|
|
block*block_size + block_pos);
|
|
if (dir_tmp->length == 0) { /* EOF. I exit and return 0s */
|
|
block_pos = block_size;
|
|
done = TRUE;
|
|
release_dir_record(dir_tmp);
|
|
} else { /* The dir record is valid. Copy data... */
|
|
if (dir_tmp->file_id[0] == 0)
|
|
strlcpy(name, ".", NAME_MAX + 1);
|
|
else if (dir_tmp->file_id[0] == 1)
|
|
strlcpy(name, "..", NAME_MAX + 1);
|
|
else {
|
|
/* Extract the name from the field file_id */
|
|
strncpy(name, dir_tmp->file_id,
|
|
dir_tmp->length_file_id);
|
|
name[dir_tmp->length_file_id] = 0;
|
|
|
|
/* Tidy up file name */
|
|
cp = memchr(name, ';', NAME_MAX);
|
|
if (cp != NULL) name[cp - name] = 0;
|
|
|
|
/*If no file extension, then remove final '.'*/
|
|
if (name[strlen(name) - 1] == '.')
|
|
name[strlen(name) - 1] = '\0';
|
|
}
|
|
|
|
if (strcmp(name_old, name) == 0) {
|
|
cur_pos += dir_tmp->length;
|
|
release_dir_record(dir_tmp);
|
|
continue;
|
|
}
|
|
|
|
strlcpy(name_old, name, NAME_MAX + 1);
|
|
|
|
/* Compute the length of the name */
|
|
cp = memchr(name, '\0', NAME_MAX);
|
|
if (cp == NULL) len = NAME_MAX;
|
|
else len= cp - name;
|
|
|
|
/* Compute record length */
|
|
reclen = offsetof(struct dirent, d_name) + len + 1;
|
|
o = (reclen % sizeof(long));
|
|
if (o != 0)
|
|
reclen += sizeof(long) - o;
|
|
|
|
/* If the new record does not fit, then copy the buffer
|
|
* and start from the beginning. */
|
|
if (tmpbuf_offset + reclen > GETDENTS_BUFSIZ) {
|
|
r = sys_safecopyto(VFS_PROC_NR, gid, userbuf_off,
|
|
(vir_bytes)getdents_buf, tmpbuf_offset);
|
|
|
|
if (r != OK)
|
|
panic("fs_getdents: sys_safecopyto failed: %d", r);
|
|
userbuf_off += tmpbuf_offset;
|
|
tmpbuf_offset= 0;
|
|
}
|
|
|
|
/* The standard data structure is created using the
|
|
* data in the buffer. */
|
|
dirp = (struct dirent *) &getdents_buf[tmpbuf_offset];
|
|
dirp->d_ino = (ino_t)(b_data(bp) + block_pos);
|
|
dirp->d_off= cur_pos;
|
|
dirp->d_reclen= reclen;
|
|
memcpy(dirp->d_name, name, len);
|
|
dirp->d_name[len]= '\0';
|
|
tmpbuf_offset += reclen;
|
|
|
|
cur_pos += dir_tmp->length;
|
|
release_dir_record(dir_tmp);
|
|
}
|
|
|
|
block_pos += dir_tmp->length;
|
|
}
|
|
|
|
put_block(bp); /* release the block */
|
|
if (done == TRUE) break;
|
|
|
|
cur_pos += block_size - cur_pos;
|
|
block++; /* read the next one */
|
|
}
|
|
|
|
if (tmpbuf_offset != 0) {
|
|
r = sys_safecopyto(VFS_PROC_NR, gid, userbuf_off,
|
|
(vir_bytes) getdents_buf, tmpbuf_offset);
|
|
if (r != OK)
|
|
panic("fs_getdents: sys_safecopyto failed: %d", r);
|
|
|
|
userbuf_off += tmpbuf_offset;
|
|
}
|
|
|
|
fs_m_out.RES_NBYTES = userbuf_off;
|
|
fs_m_out.RES_SEEK_POS_LO = cur_pos;
|
|
|
|
release_dir_record(dir); /* release the inode */
|
|
return(OK);
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* read_chunk *
|
|
*===========================================================================*/
|
|
int read_chunk(dir, position, off, chunk, left, gid, buf_off, block_size, completed)
|
|
register struct dir_record *dir;/* pointer to inode for file to be rd/wr */
|
|
u64_t position; /* position within file to read or write */
|
|
unsigned off; /* off within the current block */
|
|
int chunk; /* number of bytes to read or write */
|
|
unsigned left; /* max number of bytes wanted after position */
|
|
cp_grant_id_t gid; /* grant */
|
|
unsigned buf_off; /* offset in grant */
|
|
int block_size; /* block size of FS operating on */
|
|
int *completed; /* number of bytes copied */
|
|
{
|
|
|
|
register struct buf *bp;
|
|
register int r = OK;
|
|
block_t b;
|
|
int file_unit, rel_block, offset;
|
|
|
|
*completed = 0;
|
|
|
|
if ((ex64lo(position) <= dir->d_file_size) &&
|
|
(ex64lo(position) > dir->data_length_l)) {
|
|
while ((dir->d_next != NULL) && (ex64lo(position) > dir->data_length_l)) {
|
|
position = sub64ul(position, dir->data_length_l);
|
|
dir = dir->d_next;
|
|
}
|
|
}
|
|
|
|
if (dir->inter_gap_size != 0) {
|
|
rel_block = div64u(position, block_size);
|
|
file_unit = rel_block / dir->data_length_l;
|
|
offset = rel_block % dir->file_unit_size;
|
|
b = dir->loc_extent_l + (dir->file_unit_size +
|
|
dir->inter_gap_size) * file_unit + offset;
|
|
} else {
|
|
b = dir->loc_extent_l + div64u(position, block_size); /* Physical position
|
|
* to read. */
|
|
}
|
|
|
|
bp = get_block(b);
|
|
|
|
/* In all cases, bp now points to a valid buffer. */
|
|
if (bp == NULL) {
|
|
panic("bp not valid in rw_chunk; this can't happen");
|
|
}
|
|
|
|
r = sys_safecopyto(VFS_PROC_NR, gid, buf_off,
|
|
(vir_bytes) (b_data(bp)+off), (phys_bytes) chunk);
|
|
|
|
put_block(bp);
|
|
|
|
return(r);
|
|
}
|
|
|