- Remove unused includes.
- Add include guards to headers.
- Use unsigned variables in case they're never going to hold a negative
value. This causes GCC's complaints to disappear and should make flexelint
a lot happier, too.
- Make functions private when they're used only within a module.
- Remove unused variables.
- Add casts where appropriate.
/* Some limits. */
#define MAX_INODE_NR ((ino_t) 037777777777) /* largest inode number */
#define MAX_FILE_POS ((off_t) 0x7FFFFFFF) /* largest legal file offset */
+#define UMAX_FILE_POS ((unsigned) 0x7FFFFFF) /* largest legal file offset */
#define MAX_SYM_LOOPS 8 /* how many symbolic links are recursed */
#define NO_ZONE ((zone_t) 0) /* absence of a zone number */
#define NO_DEV ((dev_t) 0) /* absence of a device numb */
#define NO_LINK ((nlink_t) 0) /* absence of incoming links */
+#define INVAL_UID ((uid_t) -1) /* invalid uid value */
+#define INVAL_GID ((gid_t) -1) /* invalid gid value */
#define SERVARNAME "cttyline"
# define IS_KLOG_DEV 0 /* minor device for /dev/klog */
/* Full device numbers that are special to the boot monitor and FS. */
-# define DEV_RAM 0x0100 /* device number of /dev/ram */
-# define DEV_IMGRD 0x0106 /* device number of /dev/imgrd */
+# define DEV_RAM ((dev_t) 0x0100) /* device number of /dev/ram */
+# define DEV_IMGRD ((dev_t) 0x0106) /* device number of /dev/imgrd */
#endif /* _DMAP_H */
/* Get new slot to put new grant in. */
if((g = cpf_new_grantslot()) < 0)
- return -1;
+ return(GRANT_INVALID);
assert(GRANT_VALID(g));
assert(g >= 0);
if((r=cpf_setgrant_direct(g, who_to, addr, bytes, access)) < 0) {
cpf_revoke(g);
- return GRANT_INVALID;
+ return(GRANT_INVALID);
}
return g;
+#ifndef __MFS_BUF_H__
+#define __MFS_BUF_H__
+
/* Buffer (block) cache. To acquire a block, a routine calls get_block(),
* telling which block it wants. The block is then regarded as "in use"
* and has its 'b_count' field incremented. All the blocks that are not
EXTERN struct buf *front; /* points to least recently used free block */
EXTERN struct buf *rear; /* points to most recently used free block */
-EXTERN int bufs_in_use; /* # bufs currently in use (not on free list)*/
+EXTERN unsigned int bufs_in_use;/* # bufs currently in use (not on free list)*/
/* When a block is released, the type of usage is passed to put_block(). */
#define WRITE_IMMED 0100 /* block should be written to disk now */
#define FULL_DATA_BLOCK 5 /* data, fully used */
#define PARTIAL_DATA_BLOCK 6 /* data, partly used*/
+#endif
+
*/
#include "fs.h"
-#include <minix/com.h>
#include <minix/u64.h>
-#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include "buf.h"
#include "inode.h"
FORWARD _PROTOTYPE( void rm_lru, (struct buf *bp) );
-FORWARD _PROTOTYPE( int rw_block, (struct buf *, int) );
+FORWARD _PROTOTYPE( void rw_block, (struct buf *, int) );
PRIVATE int vmcache_avail = -1; /* 0 if not available, >0 if available. */
if(bp->b_bytes < fs_block_size) {
ASSERT(!bp->bp);
ASSERT(bp->b_bytes == 0);
- if(!(bp->bp = alloc_contig(fs_block_size, 0, NULL))) {
+ if(!(bp->bp = alloc_contig( (size_t) fs_block_size, 0, NULL))) {
printf("MFS: couldn't allocate a new block.\n");
for(bp = front;
bp && bp->b_bytes < fs_block_size; bp = bp->b_next)
if (z == sp->s_firstdatazone) {
bit = sp->s_zsearch;
} else {
- bit = (bit_t) z - (sp->s_firstdatazone - 1);
+ bit = (bit_t) (z - (sp->s_firstdatazone - 1));
}
b = alloc_bit(sp, ZMAP, bit);
if (b == NO_BIT) {
return(NO_ZONE);
}
if (z == sp->s_firstdatazone) sp->s_zsearch = b; /* for next time */
- return(sp->s_firstdatazone - 1 + (zone_t) b);
+ return( (zone_t) (sp->s_firstdatazone - 1) + (zone_t) b);
}
/*===========================================================================*
/* Locate the appropriate super_block and return bit. */
sp = get_super(dev);
if (numb < sp->s_firstdatazone || numb >= sp->s_zones) return;
- bit = (bit_t) (numb - (sp->s_firstdatazone - 1));
+ bit = (bit_t) (numb - (zone_t) (sp->s_firstdatazone - 1));
free_bit(sp, ZMAP, bit);
if (bit < sp->s_zsearch) sp->s_zsearch = bit;
}
/*===========================================================================*
* rw_block *
*===========================================================================*/
-PRIVATE int rw_block(bp, rw_flag)
+PRIVATE void rw_block(bp, rw_flag)
register struct buf *bp; /* buffer pointer */
int rw_flag; /* READING or WRITING */
{
* is not reported to the caller. If the error occurred while purging a block
* from the cache, it is not clear what the caller could do about it anyway.
*/
- int r, op;
+ int r, op, op_failed;
u64_t pos;
dev_t dev;
+ op_failed = 0;
+
if ( (dev = bp->b_dev) != NO_DEV) {
- pos = mul64u(bp->b_blocknr, fs_block_size);
- op = (rw_flag == READING ? MFS_DEV_READ : MFS_DEV_WRITE);
- r = block_dev_io(op, dev, SELF_E, bp->b_data, pos, fs_block_size, 0);
- if (r != fs_block_size) {
- if (r >= 0) r = END_OF_FILE;
- if (r != END_OF_FILE)
- printf("MFS(%d) I/O error on device %d/%d, block %ld\n",
- SELF_E, (dev>>MAJOR)&BYTE, (dev>>MINOR)&BYTE,
- bp->b_blocknr);
-
- bp->b_dev = NO_DEV; /* invalidate block */
-
- /* Report read errors to interested parties. */
- if (rw_flag == READING) rdwt_err = r;
- }
+ pos = mul64u(bp->b_blocknr, fs_block_size);
+ op = (rw_flag == READING ? MFS_DEV_READ : MFS_DEV_WRITE);
+ r = block_dev_io(op, dev, SELF_E, bp->b_data, pos, fs_block_size);
+ if (r < 0) {
+ printf("MFS(%d) I/O error on device %d/%d, block %lu\n",
+ SELF_E, major(dev), minor(dev), bp->b_blocknr);
+ op_failed = 1;
+ } else if( (unsigned) r != fs_block_size) {
+ r = END_OF_FILE;
+ op_failed = 1;
+ }
+
+ if (op_failed) {
+ bp->b_dev = NO_DEV; /* invalidate block */
+
+ /* Report read errors to interested parties. */
+ if (rw_flag == READING) rdwt_err = r;
+ }
}
bp->b_dirt = CLEAN;
- return OK;
}
/*===========================================================================*
register struct buf *bp;
static struct buf **dirty; /* static so it isn't on stack */
- static int dirtylistsize = 0;
+ static unsigned int dirtylistsize = 0;
int ndirty;
if(dirtylistsize != nr_bufs) {
- if(dirtylistsize > 0)
+ if(dirtylistsize > 0) {
+ assert(dirty != NULL);
free(dirty);
+ }
if(!(dirty = malloc(sizeof(dirty[0])*nr_bufs)))
panic("couldn't allocate dirty buf list");
dirtylistsize = nr_bufs;
while (bufqsize > 0) {
for (j = 0, iop = iovec; j < NR_IOREQS && j < bufqsize; j++, iop++) {
bp = bufq[j];
- if (bp->b_blocknr != bufq[0]->b_blocknr + j) break;
+ if (bp->b_blocknr != (block_t) bufq[0]->b_blocknr + j) break;
iop->iov_addr = (vir_bytes) bp->b_data;
- iop->iov_size = fs_block_size;
+ iop->iov_size = (vir_bytes) fs_block_size;
}
r = block_dev_io(rw_flag == WRITING ? MFS_DEV_SCATTER : MFS_DEV_GATHER,
dev, SELF_E, iovec,
- mul64u(bufq[0]->b_blocknr, fs_block_size), j, 0);
+ mul64u(bufq[0]->b_blocknr, fs_block_size), j);
/* Harvest the results. Dev_io reports the first error it may have
* encountered, but we only care if it's the first block that failed.
if (r != OK && i == 0) {
printf(
"fs: I/O error on device %d/%d, block %lu\n",
- (dev>>MAJOR)&BYTE, (dev>>MINOR)&BYTE,
- bp->b_blocknr);
+ major(dev), minor(dev), bp->b_blocknr);
bp->b_dev = NO_DEV; /* invalidate block */
vm_forgetblocks();
}
/*===========================================================================*
* set_blocksize *
*===========================================================================*/
-PUBLIC void set_blocksize(int blocksize)
+PUBLIC void set_blocksize(unsigned int blocksize)
{
- struct buf *bp;
- struct inode *rip;
+ struct buf *bp;
+ struct inode *rip;
- ASSERT(blocksize > 0);
+ ASSERT(blocksize > 0);
- for (bp = &buf[0]; bp < &buf[nr_bufs]; bp++)
- if(bp->b_count != 0)
- panic("change blocksize with buffer in use");
+ for (bp = &buf[0]; bp < &buf[nr_bufs]; bp++)
+ if(bp->b_count != 0) panic("change blocksize with buffer in use");
- for (rip = &inode[0]; rip < &inode[NR_INODES]; rip++)
- if (rip->i_count > 0)
- panic("change blocksize with inode in use");
+ for (rip = &inode[0]; rip < &inode[NR_INODES]; rip++)
+ if (rip->i_count > 0) panic("change blocksize with inode in use");
- buf_pool(nr_bufs);
- fs_block_size = blocksize;
+ buf_pool(nr_bufs);
+ fs_block_size = blocksize;
}
/*===========================================================================*
if(nr_bufs > 0) {
assert(buf);
- fs_sync();
+ (void) fs_sync();
for (bp = &buf[0]; bp < &buf[nr_bufs]; bp++) {
if(bp->bp) {
assert(bp->b_bytes > 0);
bp->bp = NULL;
bp->b_bytes = 0;
}
- buf[0].b_prev = NULL;
- buf[nr_bufs - 1].b_next = NULL;
+ front->b_prev = NULL;
+ rear->b_next = NULL;
for (bp = &buf[0]; bp < &buf[nr_bufs]; bp++) bp->b_hash = bp->b_next;
buf_hash[0] = front;
+#ifndef __MFS_CONST_H__
+#define __MFS_CONST_H__
+
/* Tables sizes */
#define V1_NR_DZONES 7 /* # direct zone numbers in a V1 inode */
#define V1_NR_TZONES 9 /* total # zone numbers in a V1 inode */
/* Miscellaneous constants */
#define SU_UID ((uid_t) 0) /* super_user's uid_t */
-#define SYS_UID ((uid_t) 0) /* uid_t for processes MM and INIT */
-#define SYS_GID ((gid_t) 0) /* gid_t for processes MM and INIT */
#define NORMAL 0 /* forces get_block to do disk read */
#define NO_READ 1 /* prevents get_block from doing disk read */
#define PREFETCH 2 /* tells get_block not to read or mark dev */
#define IGN_PERM 0
#define CHK_PERM 1
-#define PATH_TRANSPARENT 000 /* parse_path stops at final object */
-#define PATH_PENULTIMATE 001 /* parse_path stops at last but one name */
-#define PATH_OPAQUE 002 /* parse_path stops at final name */
-#define PATH_NONSYMBOLIC 004 /* parse_path scans final name if symbolic */
-#define PATH_STRIPDOT 010 /* parse_path strips /. from path */
-#define EAT_PATH PATH_TRANSPARENT
-#define EAT_PATH_OPAQUE PATH_OPAQUE
-#define LAST_DIR PATH_PENULTIMATE
-#define LAST_DIR_NOTDOT PATH_PENULTIMATE | PATH_STRIPDOT
-#define LAST_DIR_EATSYM PATH_NONSYMBOLIC
-
#define CLEAN 0 /* disk and memory copies identical */
#define DIRTY 1 /* disk and memory copies differ */
#define ATIME 002 /* set if atime field needs updating */
#define END_OF_FILE (-104) /* eof detected */
-#define ROOT_INODE 1 /* inode number for root directory */
+#define ROOT_INODE ((ino_t) 1) /* inode number for root directory */
#define BOOT_BLOCK ((block_t) 0) /* block number of boot block */
-#define SUPER_BLOCK_BYTES (1024) /* bytes offset */
-#define START_BLOCK 2 /* first block of FS (not counting SB) */
+#define SUPER_BLOCK_BYTES (1024) /* bytes offset */
+#define START_BLOCK ((block_t) 2) /* first block of FS (not counting SB) */
#define DIR_ENTRY_SIZE usizeof (struct direct) /* # bytes/dir entry */
#define NR_DIR_ENTRIES(b) ((b)/DIR_ENTRY_SIZE) /* # dir entries/blk */
#define V2_INDIRECTS(b) ((b)/V2_ZONE_NUM_SIZE) /* # zones/indir block */
#define V2_INODES_PER_BLOCK(b) ((b)/V2_INODE_SIZE)/* # V2 dsk inodes/blk */
-#define MFS_MIN(a,b) mfs_min_f(__FILE__,__LINE__,(a), (b))
-#define MFS_NUL(str,l,m) mfs_nul_f(__FILE__,__LINE__,(str), (l), (m))
+#define NUL(str,l,m) mfs_nul_f(__FILE__,__LINE__,(str), (l), (m))
/* Args to dev_bio/dev_io */
#define MFS_DEV_READ 10001
#define MFS_DEV_SCATTER 10003
#define MFS_DEV_GATHER 10004
+#endif
+
#include "fs.h"
-#include <fcntl.h>
-#include <assert.h>
-#include <minix/callnr.h>
#include <minix/com.h>
#include <minix/endpoint.h>
-#include <minix/ioctl.h>
#include <minix/safecopies.h>
#include <minix/u64.h>
#include <string.h>
#include <minix/vfsif.h>
-PRIVATE int dummyproc;
-
-FORWARD _PROTOTYPE( int safe_io_conversion, (endpoint_t,
- cp_grant_id_t *, int *, cp_grant_id_t *, int, endpoint_t *,
- void **, int *, vir_bytes));
+FORWARD _PROTOTYPE( int safe_io_conversion, (endpoint_t driver,
+ cp_grant_id_t *gid, int *op, cp_grant_id_t *gids, endpoint_t *io_ept,
+ void **buffer, int *vec_grants, size_t bytes));
FORWARD _PROTOTYPE( void safe_io_cleanup, (cp_grant_id_t, cp_grant_id_t *,
int));
FORWARD _PROTOTYPE( int gen_opcl, (endpoint_t driver_e, int op,
- dev_t dev, int proc_e, int flags) );
+ dev_t dev, endpoint_t proc_e, int flags) );
FORWARD _PROTOTYPE( int gen_io, (endpoint_t task_nr, message *mess_ptr) );
PUBLIC int fs_new_driver(void)
{
/* New driver endpoint for this device */
- driver_endpoints[(fs_m_in.REQ_DEV >> MAJOR) & BYTE].driver_e =
- fs_m_in.REQ_DRIVER_E;
+ dev_t dev;
+ dev = (dev_t) fs_m_in.REQ_DEV;
+ driver_endpoints[major(dev)].driver_e = (endpoint_t) fs_m_in.REQ_DRIVER_E;
return(OK);
}
/*===========================================================================*
* safe_io_conversion *
*===========================================================================*/
-PRIVATE int safe_io_conversion(driver, gid, op, gids, gids_size,
- io_ept, buf, vec_grants, bytes)
+PRIVATE int safe_io_conversion(driver, gid, op, gids, io_ept, buffer,
+ vec_grants, bytes)
endpoint_t driver;
cp_grant_id_t *gid;
int *op;
cp_grant_id_t *gids;
-int gids_size;
endpoint_t *io_ept;
-void **buf;
+void **buffer;
int *vec_grants;
-vir_bytes bytes;
+size_t bytes;
{
- int j;
+ unsigned int j;
+ int access;
iovec_t *v;
static iovec_t *new_iovec;
case MFS_DEV_WRITE:
/* Change to safe op. */
*op = *op == MFS_DEV_READ ? DEV_READ_S : DEV_WRITE_S;
-
- if((*gid=cpf_grant_direct(driver, (vir_bytes) *buf, bytes,
- *op == DEV_READ_S?CPF_WRITE:CPF_READ))<0) {
+ *gid = cpf_grant_direct(driver, (vir_bytes) *buffer, bytes,
+ *op == DEV_READ_S ? CPF_WRITE : CPF_READ);
+ if(*gid == GRANT_INVALID) {
panic("cpf_grant_magic of buffer failed");
}
*op = *op == MFS_DEV_GATHER ? DEV_GATHER_S : DEV_SCATTER_S;
/* Grant access to my new i/o vector. */
- if((*gid = cpf_grant_direct(driver, (vir_bytes) new_iovec,
- bytes * sizeof(iovec_t),
- CPF_READ | CPF_WRITE)) < 0) {
+ *gid = cpf_grant_direct(driver, (vir_bytes) new_iovec,
+ bytes * sizeof(iovec_t), CPF_READ|CPF_WRITE);
+ if(*gid == GRANT_INVALID) {
panic("cpf_grant_direct of vector failed");
}
- v = (iovec_t *) *buf;
+
+ v = (iovec_t *) *buffer;
+
/* Grant access to i/o buffers. */
for(j = 0; j < bytes; j++) {
if(j >= NR_IOREQS)
- panic("vec too big: %d", bytes);
+ panic("vec too big: %u", bytes);
+ access = (*op == DEV_GATHER_S) ? CPF_WRITE : CPF_READ;
new_iovec[j].iov_addr = gids[j] =
- cpf_grant_direct(driver, (vir_bytes) v[j].iov_addr,
- v[j].iov_size,
- *op == DEV_GATHER_S ? CPF_WRITE : CPF_READ);
+ cpf_grant_direct(driver, (vir_bytes) v[j].iov_addr,
+ (size_t) v[j].iov_size, access);
+
if(!GRANT_VALID(gids[j])) {
panic("mfs: grant to iovec buf failed");
}
}
/* Set user's vector to the new one. */
- *buf = new_iovec;
+ *buffer = new_iovec;
+ break;
+ default:
+ panic("Illegal operation %d\n", *op);
break;
}
/* Free resources (specifically, grants) allocated by safe_io_conversion(). */
int j;
- cpf_revoke(gid);
+ (void) cpf_revoke(gid);
for(j = 0; j < gids_size; j++)
- cpf_revoke(gids[j]);
+ (void) cpf_revoke(gids[j]);
return;
}
PUBLIC int block_dev_io(
int op, /* MFS_DEV_READ, MFS_DEV_WRITE, etc. */
dev_t dev, /* major-minor device number */
- int proc_e, /* in whose address space is buf? */
- void *buf, /* virtual address of the buffer */
+ endpoint_t proc_e, /* in whose address space is buf? */
+ void *buffer, /* virtual address of the buffer */
u64_t pos, /* byte position */
- int bytes, /* how many bytes to transfer */
- int flags /* special flags, like O_NONBLOCK */
+ size_t bytes /* how many bytes to transfer */
)
{
/* Read or write from a device. The parameter 'dev' tells which one. */
STATICINIT(gids, NR_IOREQS);
/* Determine driver endpoint for this device */
- driver_e = driver_endpoints[(dev >> MAJOR) & BYTE].driver_e;
+ driver_e = driver_endpoints[major(dev)].driver_e;
/* See if driver is roughly valid. */
if (driver_e == NONE) {
- printf("MFS(%d) block_dev_io: no driver for dev %x\n", SELF_E, dev);
- return(EDEADSRCDST);
+ printf("MFS(%d) block_dev_io: no driver for dev %x\n", SELF_E, dev);
+ return(EDEADSRCDST);
}
/* The io vector copying relies on this I/O being for FS itself. */
if(proc_e != SELF_E) {
- printf("MFS(%d) doing block_dev_io for non-self %d\n", SELF_E, proc_e);
- panic("doing block_dev_io for non-self: %d", proc_e);
+ printf("MFS(%d) doing block_dev_io for non-self %d\n", SELF_E, proc_e);
+ panic("doing block_dev_io for non-self: %d", proc_e);
}
/* By default, these are right. */
m.IO_ENDPT = proc_e;
- m.ADDRESS = buf;
- buf_used = buf;
+ m.ADDRESS = buffer;
+ buf_used = buffer;
/* Convert parameters to 'safe mode'. */
op_used = op;
- safe = safe_io_conversion(driver_e, &gid,
- &op_used, gids, NR_IOREQS, &m.IO_ENDPT, &buf_used,
- &vec_grants, bytes);
+ safe = safe_io_conversion(driver_e, &gid, &op_used, gids, &m.IO_ENDPT,
+ &buf_used, &vec_grants, bytes);
/* Set up rest of the message. */
if (safe) m.IO_GRANT = (char *) gid;
m.m_type = op_used;
- m.DEVICE = (dev >> MINOR) & BYTE;
+ m.DEVICE = minor(dev);
m.POSITION = ex64lo(pos);
m.COUNT = bytes;
m.HIGHPOS = ex64hi(pos);
* - VFS sends the new driver endp for the FS proc and the request again
*/
if (r != OK) {
- if (r == EDEADSRCDST) {
- printf("MFS(%d) dead driver %d\n", SELF_E, driver_e);
- driver_endpoints[(dev >> MAJOR) & BYTE].driver_e = NONE;
- return r;
- /*dmap_unmap_by_endpt(task_nr); <- in the VFS proc... */
- }
- else if (r == ELOCKED) {
- printf("MFS(%d) ELOCKED talking to %d\n", SELF_E, driver_e);
- return r;
- }
- else
- panic("call_task: can't send/receive: %d", r);
- }
- else {
- /* Did the process we did the sendrec() for get a result? */
- if (m.REP_ENDPT != proc_e) {
- printf("MFS(%d) strange device reply from %d, type = %d, proc = %d (not %d) (2) ignored\n", SELF_E, m.m_source, m.m_type, proc_e, m.REP_ENDPT);
- r = EIO;
- }
+ if (r == EDEADSRCDST) {
+ printf("MFS(%d) dead driver %d\n", SELF_E, driver_e);
+ driver_endpoints[major(dev)].driver_e = NONE;
+ return(r);
+ } else if (r == ELOCKED) {
+ printf("MFS(%d) ELOCKED talking to %d\n", SELF_E, driver_e);
+ return(r);
+ } else
+ panic("call_task: can't send/receive: %d", r);
+ } else {
+ /* Did the process we did the sendrec() for get a result? */
+ if (m.REP_ENDPT != proc_e) {
+ printf("MFS(%d) strange device reply from %d, type = %d, proc "
+ "= %d (not %d) (2) ignored\n", SELF_E, m.m_source,
+ m.m_type, proc_e, m.REP_ENDPT);
+ r = EIO;
+ }
}
/* Task has completed. See if call completed. */
if (m.REP_STATUS == SUSPEND) {
- panic("MFS block_dev_io: driver returned SUSPEND");
+ panic("MFS block_dev_io: driver returned SUSPEND");
}
- if(buf != buf_used && r == OK) {
- memcpy(buf, buf_used, bytes * sizeof(iovec_t));
+ if(buffer != buf_used && r == OK) {
+ memcpy(buffer, buf_used, bytes * sizeof(iovec_t));
}
return(m.REP_STATUS);
PUBLIC int dev_open(
endpoint_t driver_e,
dev_t dev, /* device to open */
- int proc, /* process to open for */
+ endpoint_t proc_e, /* process to open for */
int flags /* mode bits and flags */
)
{
* open/close routine. (This is the only routine that must check the
* device number for being in range. All others can trust this check.)
*/
- major = (dev >> MAJOR) & BYTE;
- if (major >= NR_DEVICES) major = 0;
- r = gen_opcl(driver_e, DEV_OPEN, dev, proc, flags);
+ major = major(dev);
+ if (major >= NR_DEVICES) {
+ printf("Major device number %d not in range\n", major(dev));
+ return(EIO);
+ }
+ r = gen_opcl(driver_e, DEV_OPEN, dev, proc_e, flags);
if (r == SUSPEND) panic("suspend on open from");
return(r);
}
endpoint_t driver_e,
int op, /* operation, DEV_OPEN or DEV_CLOSE */
dev_t dev, /* device to open or close */
- int proc_e, /* process to open/close for */
+ endpoint_t proc_e, /* process to open/close for */
int flags /* mode bits and flags */
)
{
message dev_mess;
dev_mess.m_type = op;
- dev_mess.DEVICE = (dev >> MINOR) & BYTE;
+ dev_mess.DEVICE = minor(dev);
dev_mess.IO_ENDPT = proc_e;
dev_mess.COUNT = flags;
/* Call the task. */
- gen_io(driver_e, &dev_mess);
+ (void) gen_io(driver_e, &dev_mess);
return(dev_mess.REP_STATUS);
}
proc_e = mess_ptr->IO_ENDPT;
r = sendrec(task_nr, mess_ptr);
- if(r == OK && mess_ptr->REP_STATUS == ERESTART) r = EDEADSRCDST;
- if (r != OK) {
- if (r == EDEADSRCDST) {
- printf("fs: dead driver %d\n", task_nr);
- panic("should handle crashed drivers");
- /* dmap_unmap_by_endpt(task_nr); */
- return r;
- }
- if (r == ELOCKED) {
- printf("fs: ELOCKED talking to %d\n", task_nr);
- return r;
- }
- panic("call_task: can't send/receive: %d", r);
- }
+ if(r == OK && mess_ptr->REP_STATUS == ERESTART)
+ r = EDEADSRCDST;
- /* Did the process we did the sendrec() for get a result? */
- if (mess_ptr->REP_ENDPT != proc_e) {
- printf(
- "fs: strange device reply from %d, type = %d, proc = %d (not %d) (2) ignored\n",
- mess_ptr->m_source,
- mess_ptr->m_type,
- proc_e,
- mess_ptr->REP_ENDPT);
- return(EIO);
+ if (r != OK) {
+ if (r == EDEADSRCDST) {
+ printf("fs: dead driver %d\n", task_nr);
+ panic("should handle crashed drivers");
+ return(r);
}
+ if (r == ELOCKED) {
+ printf("fs: ELOCKED talking to %d\n", task_nr);
+ return(r);
+ }
+ panic("call_task: can't send/receive: %d", r);
+ }
+
+ /* Did the process we did the sendrec() for get a result? */
+ if (mess_ptr->REP_ENDPT != proc_e) {
+ printf("fs: strange device reply from %d, type = %d, proc = %d (not "
+ "%d) (2) ignored\n", mess_ptr->m_source, mess_ptr->m_type,
+ proc_e,
+ mess_ptr->REP_ENDPT);
+ return(EIO);
+ }
return(OK);
}
+#ifndef __MFS_DRIVERS_H__
+#define __MFS_DRIVERS_H__
/* Driver endpoints for major devices. Only the block devices
* are mapped here, it's a subset of the mapping in the VFS */
endpoint_t driver_e;
} driver_endpoints[NR_DEVICES];
-
+#endif
+#ifndef __MFS_FS_H__
+#define __MFS_FS_H__
+
/* This is the master header for fs. It includes some other files
* and defines the principal constants.
*/
#include "type.h"
#include "proto.h"
#include "glo.h"
+
+#endif
+
+#ifndef __MFS_GLO_H__
+#define __MFS_GLO_H__
+
/* EXTERN should be extern except for the table file */
#ifdef _TABLE
#undef EXTERN
EXTERN message fs_m_in;
EXTERN message fs_m_out;
-EXTERN int FS_STATE;
EXTERN vfs_ucred_t credentials;
EXTERN uid_t caller_uid;
EXTERN gid_t caller_gid;
-EXTERN time_t boottime; /* time in seconds at system boot */
-EXTERN int use_getuptime2; /* Should be removed togetherwith boottime */
-
EXTERN int req_nr;
-EXTERN int SELF_E;
-
-EXTERN struct inode *chroot_dir;
+EXTERN endpoint_t SELF_E;
-EXTERN short path_processed; /* number of characters processed */
EXTERN char user_path[PATH_MAX+1]; /* pathname to be processed */
-EXTERN char *vfs_slink_storage;
-EXTERN int Xsymloop;
EXTERN dev_t fs_dev; /* The device that is handled by this FS proc.
*/
EXTERN int exitsignaled;
/* our block size. */
-EXTERN int fs_block_size;
+EXTERN unsigned int fs_block_size;
/* Buffer cache. */
EXTERN struct buf *buf;
EXTERN struct buf **buf_hash; /* the buffer hash table */
-EXTERN int nr_bufs;
+EXTERN unsigned int nr_bufs;
EXTERN int may_use_vmcache;
+
+#endif
+++ /dev/null
-
-#define _SYSTEM 1 /* get OK and negative error codes */
-#define _MINIX 1 /* tell headers to include MINIX stuff */
-
-#define VERBOSE 0 /* display diagnostics */
-
-#include <ansi.h>
-#include <sys/types.h>
-#include <limits.h>
-#include <errno.h>
-#include <signal.h>
-#include <unistd.h>
-
-#include <minix/callnr.h>
-#include <minix/config.h>
-#include <minix/type.h>
-#include <minix/const.h>
-#include <minix/com.h>
-#include <minix/syslib.h>
-#include <minix/sysutil.h>
-#include <minix/keymap.h>
-#include <minix/bitmap.h>
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <signal.h>
-
-#include "proto.h"
-
#include "super.h"
#include <minix/vfsif.h>
-FORWARD _PROTOTYPE( int addhash_inode, (struct inode *node) );
+FORWARD _PROTOTYPE( void addhash_inode, (struct inode *node) );
+
+FORWARD _PROTOTYPE( void free_inode, (dev_t dev, ino_t numb) );
FORWARD _PROTOTYPE( void new_icopy, (struct inode *rip, d2_inode *dip,
int direction, int norm));
FORWARD _PROTOTYPE( void old_icopy, (struct inode *rip, d1_inode *dip,
int direction, int norm));
-FORWARD _PROTOTYPE( int unhash_inode, (struct inode *node) );
+FORWARD _PROTOTYPE( void unhash_inode, (struct inode *node) );
+FORWARD _PROTOTYPE( void wipe_inode, (struct inode *rip) );
/*===========================================================================*
struct inode *rip;
int count;
- rip = find_inode(fs_dev, fs_m_in.REQ_INODE_NR);
+ rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR);
if(!rip) {
- printf("%s:%d put_inode: inode #%d dev: %d not found\n", __FILE__,
- __LINE__, fs_m_in.REQ_INODE_NR, fs_dev);
+ printf("%s:%d put_inode: inode #%ul dev: %d not found\n", __FILE__,
+ __LINE__, (ino_t) fs_m_in.REQ_INODE_NR, fs_dev);
panic("fs_putnode failed");
}
/* add free inodes to unused/free list */
for (rip = &inode[0]; rip < &inode[NR_INODES]; ++rip) {
- rip->i_num = 0;
+ rip->i_num = NO_ENTRY;
TAILQ_INSERT_HEAD(&unused_inodes, rip, i_unused);
}
}
/*===========================================================================*
* addhash_inode *
*===========================================================================*/
-PRIVATE int addhash_inode(struct inode *node)
+PRIVATE void addhash_inode(struct inode *node)
{
- int hashi = node->i_num & INODE_HASH_MASK;
+ int hashi = (int) (node->i_num & INODE_HASH_MASK);
/* insert into hash table */
LIST_INSERT_HEAD(&hash_inodes[hashi], node, i_hash);
- return(OK);
}
/*===========================================================================*
* unhash_inode *
*===========================================================================*/
-PRIVATE int unhash_inode(struct inode *node)
+PRIVATE void unhash_inode(struct inode *node)
{
/* remove from hash table */
LIST_REMOVE(node, i_hash);
- return(OK);
}
*===========================================================================*/
PUBLIC struct inode *get_inode(
dev_t dev, /* device on which inode resides */
- int numb /* inode number (ANSI: may not be unshort) */
+ ino_t numb /* inode number */
)
{
/* Find the inode in the hash table. If it is not there, get a free inode
register struct inode *rip;
int hashi;
- hashi = numb & INODE_HASH_MASK;
+ hashi = (int) (numb & INODE_HASH_MASK);
/* Search inode in the hash table */
LIST_FOREACH(rip, &hash_inodes[hashi], i_hash) {
rip = TAILQ_FIRST(&unused_inodes);
/* If not free unhash it */
- if (rip->i_num != 0)
+ if (rip->i_num != NO_ENTRY)
unhash_inode(rip);
/* Inode is not unused any more */
*===========================================================================*/
PUBLIC struct inode *find_inode(
dev_t dev, /* device on which inode resides */
- int numb /* inode number (ANSI: may not be unshort) */
+ ino_t numb /* inode number */
)
{
/* Find the inode specified by the inode and device number.
struct inode *rip;
int hashi;
- hashi = numb & INODE_HASH_MASK;
+ hashi = (int) (numb & INODE_HASH_MASK);
/* Search inode in the hash table */
LIST_FOREACH(rip, &hash_inodes[hashi], i_hash) {
panic("put_inode: i_count already below 1: %d", rip->i_count);
if (--rip->i_count == 0) { /* i_count == 0 means no one is using it now */
- if (rip->i_nlinks == 0) {
- /* i_nlinks == 0 means free the inode. */
- truncate_inode(rip, 0); /* return all the disk blocks */
- rip->i_mode = I_NOT_ALLOC; /* clear I_TYPE field */
+ if (rip->i_nlinks == NO_LINK) {
+ /* i_nlinks == NO_LINK means free the inode. */
+ /* return all the disk blocks */
+ if (truncate_inode(rip, (off_t) 0) != OK) return;
+ rip->i_mode = I_NOT_ALLOC; /* clear I_TYPE field */
rip->i_dirt = DIRTY;
free_inode(rip->i_dev, rip->i_num);
}
rip->i_mountpoint = FALSE;
if (rip->i_dirt == DIRTY) rw_inode(rip, WRITING);
- if (rip->i_nlinks == 0) {
+ if (rip->i_nlinks == NO_LINK) {
/* free, put at the front of the LRU list */
unhash_inode(rip);
- rip->i_num = 0;
+ rip->i_num = NO_ENTRY;
TAILQ_INSERT_HEAD(&unused_inodes, rip, i_unused);
} else {
/* unused, put at the back of the LRU (cache it) */
} else {
/* An inode slot is available. Put the inode just allocated into it. */
rip->i_mode = bits; /* set up RWX bits */
- rip->i_nlinks = 0; /* initial no links */
+ rip->i_nlinks = NO_LINK; /* initial no links */
rip->i_uid = caller_uid; /* file's uid is owner's */
rip->i_gid = caller_gid; /* ditto group id */
rip->i_dev = dev; /* mark which device it is on */
/*===========================================================================*
* wipe_inode *
*===========================================================================*/
-PUBLIC void wipe_inode(rip)
+PRIVATE void wipe_inode(rip)
register struct inode *rip; /* the inode to be erased */
{
/* Erase some fields in the inode. This function is called from alloc_inode()
/*===========================================================================*
* free_inode *
*===========================================================================*/
-PUBLIC void free_inode(
+PRIVATE void free_inode(
dev_t dev, /* on which device is the inode? */
ino_t inumb /* number of the inode to be freed */
)
/* Locate the appropriate super_block. */
sp = get_super(dev);
- if (inumb <= 0 || inumb > sp->s_ninodes) return;
- b = inumb;
+ if (inumb > sp->s_ninodes) return;
+ b = (bit_t) inumb;
free_bit(sp, IMAP, b);
if (b < sp->s_isearch) sp->s_isearch = b;
}
if (direction == READING) {
/* Copy V1.x inode to the in-core table, swapping bytes if need be. */
- rip->i_mode = conv2(norm, (int) dip->d1_mode);
- rip->i_uid = conv2(norm, (int) dip->d1_uid );
- rip->i_size = conv4(norm, dip->d1_size);
- rip->i_mtime = conv4(norm, dip->d1_mtime);
- rip->i_atime = rip->i_mtime;
- rip->i_ctime = rip->i_mtime;
- rip->i_nlinks = dip->d1_nlinks; /* 1 char */
- rip->i_gid = dip->d1_gid; /* 1 char */
+ rip->i_mode = (mode_t) conv2(norm, (int) dip->d1_mode);
+ rip->i_uid = (uid_t) conv2(norm, (int) dip->d1_uid );
+ rip->i_size = (off_t) conv4(norm, dip->d1_size);
+ rip->i_mtime = (time_t) conv4(norm, dip->d1_mtime);
+ rip->i_atime = (time_t) rip->i_mtime;
+ rip->i_ctime = (time_t) rip->i_mtime;
+ rip->i_nlinks = (nlink_t) dip->d1_nlinks; /* 1 char */
+ rip->i_gid = (gid_t) dip->d1_gid; /* 1 char */
rip->i_ndzones = V1_NR_DZONES;
rip->i_nindirs = V1_INDIRECTS;
for (i = 0; i < V1_NR_TZONES; i++)
- rip->i_zone[i] = conv2(norm, (int) dip->d1_zone[i]);
+ rip->i_zone[i] = (zone_t) conv2(norm, (int) dip->d1_zone[i]);
} else {
/* Copying V1.x inode to disk from the in-core table. */
- dip->d1_mode = conv2(norm, (int) rip->i_mode);
- dip->d1_uid = conv2(norm, (int) rip->i_uid );
- dip->d1_size = conv4(norm, rip->i_size);
- dip->d1_mtime = conv4(norm, rip->i_mtime);
- dip->d1_nlinks = rip->i_nlinks; /* 1 char */
- dip->d1_gid = rip->i_gid; /* 1 char */
+ dip->d1_mode = (u16_t) conv2(norm, (int) rip->i_mode);
+ dip->d1_uid = (i16_t) conv2(norm, (int) rip->i_uid );
+ dip->d1_size = (i32_t) conv4(norm, rip->i_size);
+ dip->d1_mtime = (i32_t) conv4(norm, rip->i_mtime);
+ dip->d1_nlinks = (u8_t) rip->i_nlinks; /* 1 char */
+ dip->d1_gid = (u8_t) rip->i_gid; /* 1 char */
for (i = 0; i < V1_NR_TZONES; i++)
- dip->d1_zone[i] = conv2(norm, (int) rip->i_zone[i]);
+ dip->d1_zone[i] = (u16_t) conv2(norm, (int) rip->i_zone[i]);
}
}
if (direction == READING) {
/* Copy V2.x inode to the in-core table, swapping bytes if need be. */
- rip->i_mode = conv2(norm,dip->d2_mode);
- rip->i_uid = conv2(norm,dip->d2_uid);
- rip->i_nlinks = conv2(norm,dip->d2_nlinks);
- rip->i_gid = conv2(norm,dip->d2_gid);
- rip->i_size = conv4(norm,dip->d2_size);
- rip->i_atime = conv4(norm,dip->d2_atime);
- rip->i_ctime = conv4(norm,dip->d2_ctime);
- rip->i_mtime = conv4(norm,dip->d2_mtime);
+ rip->i_mode = (mode_t) conv2(norm,dip->d2_mode);
+ rip->i_uid = (uid_t) conv2(norm,dip->d2_uid);
+ rip->i_nlinks = (nlink_t) conv2(norm,dip->d2_nlinks);
+ rip->i_gid = (gid_t) conv2(norm,dip->d2_gid);
+ rip->i_size = (off_t) conv4(norm,dip->d2_size);
+ rip->i_atime = (time_t) conv4(norm,dip->d2_atime);
+ rip->i_ctime = (time_t) conv4(norm,dip->d2_ctime);
+ rip->i_mtime = (time_t) conv4(norm,dip->d2_mtime);
rip->i_ndzones = V2_NR_DZONES;
rip->i_nindirs = V2_INDIRECTS(rip->i_sp->s_block_size);
for (i = 0; i < V2_NR_TZONES; i++)
- rip->i_zone[i] = conv4(norm, (long) dip->d2_zone[i]);
+ rip->i_zone[i] = (zone_t) conv4(norm, (long) dip->d2_zone[i]);
} else {
/* Copying V2.x inode to disk from the in-core table. */
- dip->d2_mode = conv2(norm,rip->i_mode);
- dip->d2_uid = conv2(norm,rip->i_uid);
- dip->d2_nlinks = conv2(norm,rip->i_nlinks);
- dip->d2_gid = conv2(norm,rip->i_gid);
- dip->d2_size = conv4(norm,rip->i_size);
- dip->d2_atime = conv4(norm,rip->i_atime);
- dip->d2_ctime = conv4(norm,rip->i_ctime);
- dip->d2_mtime = conv4(norm,rip->i_mtime);
+ dip->d2_mode = (u16_t) conv2(norm,rip->i_mode);
+ dip->d2_uid = (i16_t) conv2(norm,rip->i_uid);
+ dip->d2_nlinks = (u16_t) conv2(norm,rip->i_nlinks);
+ dip->d2_gid = (u16_t) conv2(norm,rip->i_gid);
+ dip->d2_size = (i32_t) conv4(norm,rip->i_size);
+ dip->d2_atime = (i32_t) conv4(norm,rip->i_atime);
+ dip->d2_ctime = (i32_t) conv4(norm,rip->i_ctime);
+ dip->d2_mtime = (i32_t) conv4(norm,rip->i_mtime);
for (i = 0; i < V2_NR_TZONES; i++)
- dip->d2_zone[i] = conv4(norm, (long) rip->i_zone[i]);
+ dip->d2_zone[i] = (zone_t) conv4(norm, (long) rip->i_zone[i]);
}
}
+#ifndef __MFS_INODE_H__
+#define __MFS_INODE_H__
+
/* Inode table. This table holds inodes that are currently in use. In some
* cases they have been opened by an open() or creat() system call, in other
* cases the file system itself needs the inode for one reason or another,
dev_t i_dev; /* which device is the inode on */
ino_t i_num; /* inode number on its (minor) device */
int i_count; /* # times inode used; 0 means slot is free */
- int i_ndzones; /* # direct zones (Vx_NR_DZONES) */
- int i_nindirs; /* # indirect zones per indirect block */
+ unsigned int i_ndzones; /* # direct zones (Vx_NR_DZONES) */
+ unsigned int i_nindirs; /* # indirect zones per indirect block */
struct super_block *i_sp; /* pointer to super block for inode's device */
char i_dirt; /* CLEAN or DIRTY */
- bit_t i_zsearch; /* where to start search for new zones */
+ zone_t i_zsearch; /* where to start search for new zones */
char i_mountpoint; /* true if mounted on */
/* Field values. Note that CLEAN and DIRTY are defined in "const.h" */
#define NO_SEEK 0 /* i_seek = NO_SEEK if last op was not SEEK */
#define ISEEK 1 /* i_seek = ISEEK if last op was SEEK */
+
+#endif
#include <sys/stat.h>
#include <string.h>
#include <minix/com.h>
-#include <minix/callnr.h>
#include "buf.h"
#include "inode.h"
#include "super.h"
#define SAME 1000
+
+FORWARD _PROTOTYPE( int freesp_inode, (struct inode *rip, off_t st,
+ off_t end) );
FORWARD _PROTOTYPE( int remove_dir, (struct inode *rldirp,
struct inode *rip, char dir_name[NAME_MAX]) );
FORWARD _PROTOTYPE( int unlink_file, (struct inode *dirp,
struct inode *new_ip;
phys_bytes len;
- len = MFS_MIN(fs_m_in.REQ_PATH_LEN, sizeof(string));
+ len = min( (unsigned) fs_m_in.REQ_PATH_LEN, sizeof(string));
/* Copy the link name's last component */
- r = sys_safecopyfrom(FS_PROC_NR, fs_m_in.REQ_GRANT, 0,
- (vir_bytes) string, (phys_bytes) len, D);
+ r = sys_safecopyfrom(FS_PROC_NR, (cp_grant_id_t) fs_m_in.REQ_GRANT,
+ (vir_bytes) 0, (vir_bytes) string, (size_t) len, D);
if (r != OK) return r;
- MFS_NUL(string, len, sizeof(string));
+ NUL(string, len, sizeof(string));
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* Check to see if the file has maximum number of links already. */
r = OK;
- if(rip->i_nlinks >= (rip->i_sp->s_version == V1 ? CHAR_MAX : SHRT_MAX))
+ if(rip->i_nlinks >= LINK_MAX)
r = EMLINK;
/* Only super_user may link to directories. */
}
/* Temporarily open the last dir */
- if( (ip = get_inode(fs_dev, fs_m_in.REQ_DIR_INO)) == NULL)
+ if( (ip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_DIR_INO)) == NULL)
return(EINVAL);
/* If 'name2' exists in full (even if no space) set 'r' to error. */
- if (r == OK) {
- if((new_ip = advance(ip, string, IGN_PERM)) == NULL) {
- r = err_code;
- if(r == ENOENT)
- r = OK;
- } else {
- put_inode(new_ip);
- r = EEXIST;
- }
+ if((new_ip = advance(ip, string, IGN_PERM)) == NULL) {
+ r = err_code;
+ if(r == ENOENT)
+ r = OK;
+ } else {
+ put_inode(new_ip);
+ r = EEXIST;
}
/* Try to link. */
phys_bytes len;
/* Copy the last component */
- len = MFS_MIN(fs_m_in.REQ_PATH_LEN, sizeof(string));
- r = sys_safecopyfrom(FS_PROC_NR, fs_m_in.REQ_GRANT, 0,
- (vir_bytes) string, (phys_bytes) len, D);
+ len = min( (unsigned) fs_m_in.REQ_PATH_LEN, sizeof(string));
+ r = sys_safecopyfrom(FS_PROC_NR, (cp_grant_id_t) fs_m_in.REQ_GRANT,
+ (vir_bytes) 0, (vir_bytes) string, (size_t) len, D);
if (r != OK) return r;
- MFS_NUL(string, len, sizeof(string));
+ NUL(string, len, sizeof(string));
/* Temporarily open the dir. */
- if( (rldirp = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* The last directory exists. Does the file also exist? */
- r = OK;
rip = advance(rldirp, string, IGN_PERM);
r = err_code;
struct buf *bp; /* buffer containing link text */
register struct inode *rip; /* target inode */
register int r; /* return value */
- int copylen;
+ size_t copylen;
- copylen = fs_m_in.REQ_MEM_SIZE;
- if (copylen <= 0) return(EINVAL);
+ copylen = min( (size_t) fs_m_in.REQ_MEM_SIZE, UMAX_FILE_POS);
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
if(!S_ISLNK(rip->i_mode))
r = EIO;
else {
/* Passed all checks */
- if (copylen > rip->i_size)
- copylen = rip->i_size;
- bp = get_block(rip->i_dev, b, NORMAL);
- r = sys_safecopyto(FS_PROC_NR, fs_m_in.REQ_GRANT, 0,
- (vir_bytes) bp->b_data, (vir_bytes) copylen, D);
- put_block(bp, DIRECTORY_BLOCK);
- if (r == OK)
- fs_m_out.RES_NBYTES = copylen;
+ /* We can safely cast to unsigned, because copylen is guaranteed to be
+ below max file size */
+ copylen = min( copylen, (unsigned) rip->i_size);
+ bp = get_block(rip->i_dev, b, NORMAL);
+ r = sys_safecopyto(FS_PROC_NR, (cp_grant_id_t) fs_m_in.REQ_GRANT,
+ (vir_bytes) 0, (vir_bytes) bp->b_data,
+ (size_t) copylen, D);
+ put_block(bp, DIRECTORY_BLOCK);
+ if (r == OK)
+ fs_m_out.RES_NBYTES = copylen;
}
put_inode(rip);
/* search_dir checks that rip is a directory too. */
if ((r = search_dir(rip, "", (ino_t *) 0, IS_EMPTY, IGN_PERM)) != OK)
- return r;
+ return(r);
if (strcmp(dir_name, ".") == 0 || strcmp(dir_name, "..") == 0)return(EINVAL);
if (rip->i_num == ROOT_INODE) return(EBUSY); /* can't remove 'root' */
phys_bytes len;
/* Copy the last component of the old name */
- len = MFS_MIN(fs_m_in.REQ_REN_LEN_OLD, sizeof(old_name));
- r = sys_safecopyfrom(FS_PROC_NR, fs_m_in.REQ_REN_GRANT_OLD, 0,
- (vir_bytes) old_name, (phys_bytes) len, D);
+ len = min( (unsigned) fs_m_in.REQ_REN_LEN_OLD, sizeof(old_name));
+ r = sys_safecopyfrom(FS_PROC_NR, (cp_grant_id_t) fs_m_in.REQ_REN_GRANT_OLD,
+ (vir_bytes) 0, (vir_bytes) old_name, (size_t) len, D);
if (r != OK) return r;
- MFS_NUL(old_name, len, sizeof(old_name));
+ NUL(old_name, len, sizeof(old_name));
/* Copy the last component of the new name */
- len = MFS_MIN(fs_m_in.REQ_REN_LEN_NEW, sizeof(new_name));
- r = sys_safecopyfrom(FS_PROC_NR, fs_m_in.REQ_REN_GRANT_NEW, 0,
- (vir_bytes) new_name, (phys_bytes) len, D);
+ len = min( (unsigned) fs_m_in.REQ_REN_LEN_NEW, sizeof(new_name));
+ r = sys_safecopyfrom(FS_PROC_NR, (cp_grant_id_t) fs_m_in.REQ_REN_GRANT_NEW,
+ (vir_bytes) 0, (vir_bytes) new_name, (size_t) len, D);
if (r != OK) return r;
- MFS_NUL(new_name, len, sizeof(new_name));
+ NUL(new_name, len, sizeof(new_name));
/* Get old dir inode */
- if( (old_dirp = get_inode(fs_dev, fs_m_in.REQ_REN_OLD_DIR)) == NULL)
+ if( (old_dirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_REN_OLD_DIR)) == NULL)
return(err_code);
old_ip = advance(old_dirp, old_name, IGN_PERM);
}
/* Get new dir inode */
- if( (new_dirp = get_inode(fs_dev, fs_m_in.REQ_REN_NEW_DIR)) == NULL)
+ if( (new_dirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_REN_NEW_DIR)) == NULL)
r = err_code;
new_ip = advance(new_dirp, new_name, IGN_PERM); /* not required to exist */
put_inode(new_ip);
r = EBUSY;
}
-
+
if(old_ip != NULL)
odir = ((old_ip->i_mode & I_TYPE) == I_DIRECTORY); /* TRUE iff dir */
else
- odir = FALSE; /* FIXME: is this a safe default? */
+ odir = FALSE;
/* If it is ok, check for a variety of possible errors. */
if(r == OK) {
if(new_ip == NULL) {
/* don't rename a file with a file system mounted on it.
if (old_ip->i_dev != old_dirp->i_dev) r = EXDEV;*/
- if(odir && new_dirp->i_nlinks >=
- (new_dirp->i_sp->s_version == V1 ? CHAR_MAX : SHRT_MAX) &&
- !same_pdir && r == OK) {
+ if (odir && new_dirp->i_nlinks >= LINK_MAX &&
+ !same_pdir && r == OK) {
r = EMLINK;
}
} else {
numb = old_ip->i_num; /* inode number of old file */
if(same_pdir) {
- r = search_dir(old_dirp,old_name,(ino_t *) 0,DELETE,IGN_PERM);
+ r = search_dir(old_dirp, old_name, NULL, DELETE, IGN_PERM);
/* shouldn't go wrong. */
if(r == OK)
- search_dir(old_dirp, new_name, &numb, ENTER, IGN_PERM);
+ (void) search_dir(old_dirp, new_name, &numb, ENTER,
+ IGN_PERM);
} else {
r = search_dir(new_dirp, new_name, &numb, ENTER, IGN_PERM);
if(r == OK)
- search_dir(old_dirp, old_name, (ino_t *) 0, DELETE,
- IGN_PERM);
+ (void) search_dir(old_dirp, old_name, NULL, DELETE,
+ IGN_PERM);
}
}
/* If r is OK, the ctime and mtime of old_dirp and new_dirp have been marked
off_t start, end;
int r;
- if( (rip = find_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
start = fs_m_in.REQ_TRC_START_LO;
* O_APPEND mode, as this is different per fd and is checked when
* writing is done.
*/
- int scale, file_type;
+ int r;
+ mode_t file_type;
file_type = rip->i_mode & I_TYPE; /* check to see if file is special */
if (file_type == I_CHAR_SPECIAL || file_type == I_BLOCK_SPECIAL)
if(newsize > rip->i_sp->s_max_size) /* don't let inode grow too big */
return(EFBIG);
- scale = rip->i_sp->s_log_zone_size;
-
/* Free the actual space if truncating. */
- if(newsize < rip->i_size) freesp_inode(rip, newsize, rip->i_size);
+ if(newsize < rip->i_size) {
+ if ((r = freesp_inode(rip, newsize, rip->i_size)) != OK)
+ return(r);
+ }
/* Clear the rest of the last zone if expanding. */
if(newsize > rip->i_size) clear_zone(rip, rip->i_size, 0);
/*===========================================================================*
* freesp_inode *
*===========================================================================*/
-PUBLIC int freesp_inode(rip, start, end)
+PRIVATE int freesp_inode(rip, start, end)
register struct inode *rip; /* pointer to inode to be partly freed */
off_t start, end; /* range of bytes to free (end uninclusive) */
{
* fcntl().
*/
off_t p, e;
- int zone_size;
+ int zone_size, r;
int zero_last, zero_first;
if(end > rip->i_size) /* freeing beyond end makes no sense */
*/
e = end/zone_size;
if(end == rip->i_size && (end % zone_size)) e++;
- for(p = nextblock(start, zone_size)/zone_size; p < e; p ++)
- write_map(rip, p*zone_size, NO_ZONE, WMAP_FREE);
+ for(p = nextblock(start, zone_size)/zone_size; p < e; p ++) {
+ if((r = write_map(rip, p*zone_size, NO_ZONE, WMAP_FREE)) != OK)
+ return(r);
+ }
+
}
rip->i_update |= CTIME | MTIME;
* FIRST_HALF: 0..pos-1 will be zeroed
* LAST_HALF: pos..zone_size-1 will be zeroed
*/
- int offset, len;
+ off_t offset, len;
/* Offset of zeroing boundary. */
offset = pos % zone_size;
block_t b;
struct buf *bp;
off_t offset;
- int bytes, block_size;
+ unsigned short block_size;
+ size_t bytes;
block_size = rip->i_sp->s_block_size;
panic("zerozone_range: no block");
offset = pos % block_size;
bytes = block_size - offset;
- if (bytes > len)
+ if (bytes > (size_t) len)
bytes = len;
memset(bp->b_data + offset, 0, bytes);
bp->b_dirt = DIRTY;
-#include "inc.h"
+#include "fs.h"
#include <assert.h>
+#include <minix/callnr.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
#include <minix/dmap.h>
#include <minix/endpoint.h>
#include <minix/vfsif.h>
-#include "fs.h"
#include "buf.h"
#include "inode.h"
#include "drivers.h"
/* Declare some local functions. */
FORWARD _PROTOTYPE(void get_work, (message *m_in) );
FORWARD _PROTOTYPE(void cch_check, (void) );
+FORWARD _PROTOTYPE( void reply, (endpoint_t who, message *m_out) );
/* SEF functions and variables. */
FORWARD _PROTOTYPE( void sef_local_startup, (void) );
src = fs_m_in.m_source;
error = OK;
- caller_uid = -1; /* To trap errors */
- caller_gid = -1;
+ caller_uid = INVAL_UID; /* To trap errors */
+ caller_gid = INVAL_GID;
req_nr = fs_m_in.m_type;
if (req_nr < VFS_BASE) {
if (signo != SIGTERM) return;
exitsignaled = 1;
- fs_sync();
+ (void) fs_sync();
/* If unmounting has already been performed, exit immediately.
* We might not get another message.
/*===========================================================================*
* reply *
*===========================================================================*/
-PUBLIC void reply(
+PRIVATE void reply(
endpoint_t who,
message *m_out /* report result */
)
int i;
for (i = 0; i < NR_INODES; ++i) {
- if (inode[i].i_count != cch[i] &&
- req_nr != REQ_GETNODE &&
- req_nr != REQ_PUTNODE &&
- req_nr != REQ_READSUPER &&
- req_nr != REQ_MOUNTPOINT && req_nr != REQ_UNMOUNT &&
- req_nr != REQ_SYNC && req_nr != REQ_LOOKUP)
-printf("MFS(%d) inode(%d) cc: %d req_nr: %d\n",
- SELF_E, inode[i].i_num, inode[i].i_count - cch[i], req_nr);
+ if (inode[i].i_count != cch[i] && req_nr != REQ_GETNODE &&
+ req_nr != REQ_PUTNODE && req_nr != REQ_READSUPER &&
+ req_nr != REQ_MOUNTPOINT && req_nr != REQ_UNMOUNT &&
+ req_nr != REQ_SYNC && req_nr != REQ_LOOKUP) {
+ printf("MFS(%d) inode(%ul) cc: %d req_nr: %d\n", SELF_E,
+ inode[i].i_num, inode[i].i_count - cch[i], req_nr);
+ }
- cch[i] = inode[i].i_count;
+ cch[i] = inode[i].i_count;
}
}
#include "fs.h"
-#include <fcntl.h>
#include <assert.h>
#include <minix/vfsif.h>
-#include "buf.h"
#include "inode.h"
/* Flush the blocks of a device from the cache after writing any dirty blocks
* to disk.
*/
- dev_t dev;
-
- dev = fs_m_in.REQ_DEV;
+ dev_t dev = (dev_t) fs_m_in.REQ_DEV;
if(dev == fs_dev) return(EBUSY);
flushall(dev);
#include "fs.h"
-#include <fcntl.h>
-#include <string.h>
-#include <minix/com.h>
-#include <sys/stat.h>
-#include "buf.h"
#include "inode.h"
#include "super.h"
#include "drivers.h"
struct inode *root_ip;
cp_grant_id_t label_gid;
size_t label_len;
- int r = OK;
+ int r;
endpoint_t driver_e;
int readonly, isroot;
- fs_dev = fs_m_in.REQ_DEV;
- label_gid = fs_m_in.REQ_GRANT;
- label_len = fs_m_in.REQ_PATH_LEN;
+ fs_dev = (dev_t) fs_m_in.REQ_DEV;
+ label_gid = (cp_grant_id_t) fs_m_in.REQ_GRANT;
+ label_len = (size_t) fs_m_in.REQ_PATH_LEN;
readonly = (fs_m_in.REQ_FLAGS & REQ_RDONLY) ? 1 : 0;
isroot = (fs_m_in.REQ_FLAGS & REQ_ISROOT) ? 1 : 0;
if (label_len > sizeof(fs_dev_label))
return(EINVAL);
- r = sys_safecopyfrom(fs_m_in.m_source, label_gid, 0,
- (vir_bytes)fs_dev_label, label_len, D);
+ r = sys_safecopyfrom(fs_m_in.m_source, label_gid, (vir_bytes) 0,
+ (vir_bytes) fs_dev_label, label_len, D);
if (r != OK) {
- printf("%s:%d fs_readsuper: safecopyfrom failed: %d\n",
- __FILE__, __LINE__, r);
+ printf("MFS %s:%d safecopyfrom failed: %d\n", __FILE__, __LINE__, r);
return(EINVAL);
}
- r= ds_retrieve_label_endpt(fs_dev_label, &driver_e);
- if (r != OK)
- {
- printf("mfs:fs_readsuper: ds_retrieve_label_endpt failed for '%s': %d\n",
- fs_dev_label, r);
- return EINVAL;
+ r = ds_retrieve_label_endpt(fs_dev_label, &driver_e);
+ if (r != OK) {
+ printf("MFS %s:%d ds_retrieve_label_endpt failed for '%s': %d\n",
+ __FILE__, __LINE__, fs_dev_label, r);
+ return(EINVAL);
}
/* Map the driver endpoint for this major */
- driver_endpoints[(fs_dev >> MAJOR) & BYTE].driver_e = driver_e;
- use_getuptime2 = TRUE; /* Should be removed with old getuptime call. */
- vfs_slink_storage = (char *)0xdeadbeef; /* Should be removed together
- * with old lookup code.
- */;
+ driver_endpoints[major(fs_dev)].driver_e = driver_e;
/* Open the device the file system lives on. */
- if (dev_open(driver_e, fs_dev, driver_e,
- readonly ? R_BIT : (R_BIT|W_BIT)) != OK) {
+ if (dev_open(driver_e, fs_dev, driver_e,
+ readonly ? R_BIT : (R_BIT|W_BIT) ) != OK) {
return(EINVAL);
}
return(EINVAL);
}
- if(root_ip != NULL && root_ip->i_mode == 0) {
+ if(root_ip->i_mode == 0) {
printf("%s:%d zero mode for root inode?\n", __FILE__, __LINE__);
put_inode(root_ip);
superblock.s_dev = NO_DEV;
mode_t bits;
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
if (rip->i_count > 0 && rip->i_dev == fs_dev) count += rip->i_count;
if ((root_ip = find_inode(fs_dev, ROOT_INODE)) == NULL) {
- printf("MFS: couldn't find root inode. Unmount failed.\n");
- panic("MFS: couldn't find root inode: %d", EINVAL);
+ panic("MFS: couldn't find root inode\n");
return(EINVAL);
}
(void) fs_sync();
/* Close the device the file system lives on. */
- dev_close(driver_endpoints[(fs_dev >> MAJOR) & BYTE].driver_e, fs_dev);
+ dev_close(driver_endpoints[major(fs_dev)].driver_e, fs_dev);
/* Finish off the unmount. */
superblock.s_dev = NO_DEV;
#include "fs.h"
#include <sys/stat.h>
-#include <fcntl.h>
#include <string.h>
-#include <unistd.h>
-#include <minix/callnr.h>
#include <minix/com.h>
#include "buf.h"
#include "inode.h"
#include "super.h"
#include <minix/vfsif.h>
-PRIVATE char mode_map[] = {R_BIT, W_BIT, R_BIT|W_BIT, 0};
FORWARD _PROTOTYPE( struct inode *new_node, (struct inode *ldirp,
char *string, mode_t bits, zone_t z0));
char lastc[NAME_MAX];
/* Read request message */
- omode = fs_m_in.REQ_MODE;
- caller_uid = fs_m_in.REQ_UID;
- caller_gid = fs_m_in.REQ_GID;
+ omode = (mode_t) fs_m_in.REQ_MODE;
+ caller_uid = (uid_t) fs_m_in.REQ_UID;
+ caller_gid = (gid_t) fs_m_in.REQ_GID;
/* Try to make the file. */
/* Copy the last component (i.e., file name) */
- len = MFS_MIN(fs_m_in.REQ_PATH_LEN, sizeof(lastc));
- err_code = sys_safecopyfrom(FS_PROC_NR, fs_m_in.REQ_GRANT, 0,
- (vir_bytes) lastc, (phys_bytes) len, D);
+ len = min( (unsigned) fs_m_in.REQ_PATH_LEN, sizeof(lastc));
+ err_code = sys_safecopyfrom(FS_PROC_NR, (cp_grant_id_t) fs_m_in.REQ_GRANT,
+ (vir_bytes) 0, (vir_bytes) lastc, (size_t) len, D);
if (err_code != OK) return err_code;
- MFS_NUL(lastc, len, sizeof(lastc));
+ NUL(lastc, len, sizeof(lastc));
/* Get last directory inode (i.e., directory that will hold the new inode) */
- if ((ldirp = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if ((ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(ENOENT);
/* Create a new inode by calling new_node(). */
}
/* Reply message */
- fs_m_out.m_source = rip->i_dev; /* filled with FS endpoint by the system */
fs_m_out.RES_INODE_NR = rip->i_num;
fs_m_out.RES_MODE = rip->i_mode;
fs_m_out.RES_FILE_SIZE_LO = rip->i_size;
phys_bytes len;
/* Copy the last component and set up caller's user and group id */
- len = MFS_MIN(fs_m_in.REQ_PATH_LEN, sizeof(lastc));
- err_code = sys_safecopyfrom(FS_PROC_NR, fs_m_in.REQ_GRANT, 0,
- (vir_bytes) lastc, (phys_bytes) len, D);
+ len = min( (unsigned) fs_m_in.REQ_PATH_LEN, sizeof(lastc));
+ err_code = sys_safecopyfrom(FS_PROC_NR, (cp_grant_id_t) fs_m_in.REQ_GRANT,
+ (vir_bytes) 0, (vir_bytes) lastc, (size_t) len, D);
if (err_code != OK) return err_code;
- MFS_NUL(lastc, len, sizeof(lastc));
+ NUL(lastc, len, sizeof(lastc));
- caller_uid = fs_m_in.REQ_UID;
- caller_gid = fs_m_in.REQ_GID;
+ caller_uid = (uid_t) fs_m_in.REQ_UID;
+ caller_gid = (gid_t) fs_m_in.REQ_GID;
/* Get last directory inode */
- if((ldirp = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if((ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(ENOENT);
/* Try to create the new node */
- ip = new_node(ldirp, lastc, fs_m_in.REQ_MODE, (zone_t) fs_m_in.REQ_DEV);
+ ip = new_node(ldirp, lastc, (mode_t) fs_m_in.REQ_MODE,
+ (zone_t) fs_m_in.REQ_DEV);
put_inode(ip);
put_inode(ldirp);
phys_bytes len;
/* Copy the last component and set up caller's user and group id */
- len = MFS_MIN(fs_m_in.REQ_PATH_LEN, sizeof(lastc));
- err_code = sys_safecopyfrom(FS_PROC_NR, fs_m_in.REQ_GRANT, 0,
- (vir_bytes) lastc, (phys_bytes) len, D);
+ len = min( (unsigned) fs_m_in.REQ_PATH_LEN, sizeof(lastc));
+ err_code = sys_safecopyfrom(FS_PROC_NR, (cp_grant_id_t) fs_m_in.REQ_GRANT,
+ (vir_bytes) 0, (vir_bytes) lastc, (size_t) len, D);
if(err_code != OK) return(err_code);
- MFS_NUL(lastc, len, sizeof(lastc));
+ NUL(lastc, len, sizeof(lastc));
- caller_uid = fs_m_in.REQ_UID;
- caller_gid = fs_m_in.REQ_GID;
+ caller_uid = (uid_t) fs_m_in.REQ_UID;
+ caller_gid = (gid_t) fs_m_in.REQ_GID;
/* Get last directory inode */
- if((ldirp = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if((ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(ENOENT);
/* Next make the inode. If that fails, return error code. */
- rip = new_node(ldirp, lastc, fs_m_in.REQ_MODE, (zone_t) 0);
+ rip = new_node(ldirp, lastc, (mode_t) fs_m_in.REQ_MODE, (zone_t) 0);
if(rip == NULL || err_code == EEXIST) {
put_inode(rip); /* can't make dir: it already exists */
/* Now make dir entries for . and .. unless the disk is completely full. */
/* Use dot1 and dot2, so the mode of the directory isn't important. */
- rip->i_mode = fs_m_in.REQ_MODE; /* set mode */
+ rip->i_mode = (mode_t) fs_m_in.REQ_MODE; /* set mode */
r1 = search_dir(rip, dot1, &dot, ENTER, IGN_PERM);/* enter . in the new dir*/
r2 = search_dir(rip, dot2, &dotdot, ENTER, IGN_PERM); /* enter .. in the new
dir */
/* It was not possible to enter . or .. probably disk was full -
* links counts haven't been touched. */
if(search_dir(ldirp, lastc, (ino_t *) 0, DELETE, IGN_PERM) != OK)
- panic("Dir disappeared: %d", rip->i_num);
+ panic("Dir disappeared: %ul", rip->i_num);
rip->i_nlinks--; /* undo the increment done in new_node() */
}
rip->i_dirt = DIRTY; /* either way, i_nlinks has changed */
char string[NAME_MAX]; /* last component of the new dir's path name */
struct buf *bp; /* disk buffer for link */
- caller_uid = fs_m_in.REQ_UID;
- caller_gid = fs_m_in.REQ_GID;
+ caller_uid = (uid_t) fs_m_in.REQ_UID;
+ caller_gid = (gid_t) fs_m_in.REQ_GID;
/* Copy the link name's last component */
- len = MFS_MIN(fs_m_in.REQ_PATH_LEN, sizeof(string));
- r = sys_safecopyfrom(FS_PROC_NR, fs_m_in.REQ_GRANT, 0,
- (vir_bytes) string, (phys_bytes) len, D);
+ len = min( (unsigned) fs_m_in.REQ_PATH_LEN, sizeof(string));
+ r = sys_safecopyfrom(FS_PROC_NR, (cp_grant_id_t) fs_m_in.REQ_GRANT,
+ (vir_bytes) 0, (vir_bytes) string, (size_t) len, D);
if (r != OK) return(r);
- MFS_NUL(string, len, sizeof(string));
+ NUL(string, len, sizeof(string));
/* Temporarily open the dir. */
- if( (ldirp = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (ldirp = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* Create the inode for the symlink. */
/* Allocate a disk block for the contents of the symlink.
* Copy contents of symlink (the name pointed to) into first disk block. */
if( (r = err_code) == OK) {
- r = (bp = new_block(sip, (off_t) 0)) == NULL ? err_code :
- sys_safecopyfrom(FS_PROC_NR, fs_m_in.REQ_GRANT3, 0,
- (vir_bytes) bp->b_data,
- (vir_bytes) fs_m_in.REQ_MEM_SIZE, D);
-
- if(r == OK) {
- bp->b_data[_MIN_BLOCK_SIZE-1] = '\0';
- sip->i_size = strlen(bp->b_data);
- if(sip->i_size != fs_m_in.REQ_MEM_SIZE) {
- /* This can happen if the user provides a buffer
- * with a \0 in it. This can cause a lot of trouble
- * when the symlink is used later. We could just use
- * the strlen() value, but we want to let the user
- * know he did something wrong. ENAMETOOLONG doesn't
- * exactly describe the error, but there is no
- * ENAMETOOWRONG.
- */
- r = ENAMETOOLONG;
- }
- }
+ bp = new_block(sip, (off_t) 0);
+ if (bp == NULL)
+ r = err_code;
+ else
+ r = sys_safecopyfrom(FS_PROC_NR,
+ (cp_grant_id_t) fs_m_in.REQ_GRANT3,
+ (vir_bytes) 0, (vir_bytes) bp->b_data,
+ (size_t) fs_m_in.REQ_MEM_SIZE, D);
+
+ if(bp != NULL && r == OK) {
+ bp->b_data[_MIN_BLOCK_SIZE-1] = '\0';
+ sip->i_size = (off_t) strlen(bp->b_data);
+ if(sip->i_size != fs_m_in.REQ_MEM_SIZE) {
+ /* This can happen if the user provides a buffer
+ * with a \0 in it. This can cause a lot of trouble
+ * when the symlink is used later. We could just use
+ * the strlen() value, but we want to let the user
+ * know he did something wrong. ENAMETOOLONG doesn't
+ * exactly describe the error, but there is no
+ * ENAMETOOWRONG.
+ */
+ r = ENAMETOOLONG;
+ }
+ }
- put_block(bp, DIRECTORY_BLOCK); /* put_block() accepts NULL. */
+ put_block(bp, DIRECTORY_BLOCK); /* put_block() accepts NULL. */
- if(r != OK) {
- sip->i_nlinks = 0;
- if(search_dir(ldirp, string, (ino_t *) 0, DELETE,
- IGN_PERM) != OK)
-
+ if(r != OK) {
+ sip->i_nlinks = NO_LINK;
+ if(search_dir(ldirp, string, NULL, DELETE, IGN_PERM) != OK)
panic("Symbolic link vanished");
- }
+ }
}
/* put_inode() accepts NULL as a noop, so the below are safe. */
/* Get final component of the path. */
rip = advance(ldirp, string, IGN_PERM);
- if (S_ISDIR(bits) &&
- (ldirp)->i_nlinks >= ((ldirp)->i_sp->s_version == V1 ?
- CHAR_MAX : SHRT_MAX)) {
+ if (S_ISDIR(bits) && (ldirp->i_nlinks >= LINK_MAX)) {
/* New entry is a directory, alas we can't give it a ".." */
put_inode(rip);
err_code = EMLINK;
{
struct inode *rip;
- if((rip = find_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if((rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* inhibit read ahead */
*/
#include "fs.h"
+#include "assert.h"
#include <string.h>
-#include <minix/callnr.h>
#include <minix/endpoint.h>
#include <sys/stat.h>
#include <sys/types.h>
-#include <unistd.h>
#include "buf.h"
#include "inode.h"
#include "super.h"
PUBLIC int fs_lookup()
{
cp_grant_id_t grant, grant2;
- int r, r1, len, flags, symlinks;
+ int r, r1, flags, symlinks;
+ unsigned int len;
size_t offset = 0, path_size, cred_size;
ino_t dir_ino, root_ino;
struct inode *rip;
- grant = fs_m_in.REQ_GRANT;
- path_size = fs_m_in.REQ_PATH_SIZE; /* Size of the buffer */
- len = fs_m_in.REQ_PATH_LEN; /* including terminating nul */
- dir_ino = fs_m_in.REQ_DIR_INO;
- root_ino = fs_m_in.REQ_ROOT_INO;
- flags = fs_m_in.REQ_FLAGS;
+ grant = (cp_grant_id_t) fs_m_in.REQ_GRANT;
+ path_size = (size_t) fs_m_in.REQ_PATH_SIZE; /* Size of the buffer */
+ len = (int) fs_m_in.REQ_PATH_LEN; /* including terminating nul */
+ dir_ino = (ino_t) fs_m_in.REQ_DIR_INO;
+ root_ino = (ino_t) fs_m_in.REQ_ROOT_INO;
+ flags = (int) fs_m_in.REQ_FLAGS;
/* Check length. */
if(len > sizeof(user_path)) return(E2BIG); /* too big for buffer */
- if(len < 1) return(EINVAL); /* too small */
+ if(len == 0) return(EINVAL); /* too small */
/* Copy the pathname and set up caller's user and group id */
- r = sys_safecopyfrom(FS_PROC_NR, grant, /*offset*/ 0,
- (vir_bytes) user_path, (phys_bytes) len, D);
- if(r != OK) {
- printf("MFS %s:%d sys_safecopyfrom failed: %d\n",
- __FILE__, __LINE__, r);
- return(r);
- }
+ r = sys_safecopyfrom(FS_PROC_NR, grant, /*offset*/ (vir_bytes) 0,
+ (vir_bytes) user_path, (size_t) len, D);
+ if(r != OK) return(r);
/* Verify this is a null-terminated path. */
if(user_path[len - 1] != '\0') return(EINVAL);
if(flags & PATH_GET_UCRED) { /* Do we have to copy uid/gid credentials? */
- grant2 = fs_m_in.REQ_GRANT2;
- cred_size = fs_m_in.REQ_UCRED_SIZE;
+ grant2 = (cp_grant_id_t) fs_m_in.REQ_GRANT2;
+ cred_size = (size_t) fs_m_in.REQ_UCRED_SIZE;
if (cred_size > sizeof(credentials)) return(EINVAL); /* Too big. */
- r = sys_safecopyfrom(FS_PROC_NR, grant2, 0, (vir_bytes) &credentials,
- (phys_bytes) cred_size, D);
- if (r != OK) {
- printf("MFS %s:%d sys_safecopyfrom failed: %d\n",
- __FILE__, __LINE__, r);
- return(r);
- }
+ r = sys_safecopyfrom(FS_PROC_NR, grant2, (vir_bytes) 0,
+ (vir_bytes) &credentials, cred_size, D);
+ if (r != OK) return(r);
+
caller_uid = credentials.vu_uid;
caller_gid = credentials.vu_gid;
} else {
memset(&credentials, 0, sizeof(credentials));
- caller_uid = fs_m_in.REQ_UID;
- caller_gid = fs_m_in.REQ_GID;
+ caller_uid = (uid_t) fs_m_in.REQ_UID;
+ caller_gid = (gid_t) fs_m_in.REQ_GID;
}
/* Lookup inode */
len = strlen(user_path)+1;
if(len > path_size) return(ENAMETOOLONG);
- r1 = sys_safecopyto(FS_PROC_NR, grant, 0, (vir_bytes) user_path,
- (phys_bytes) len, D);
- if(r1 != OK) {
- printf("%s:%d fs_lookup: sys_safecopyto failed: %d\n",
- __FILE__, __LINE__, r1);
- return(r1);
- }
+ r1 = sys_safecopyto(FS_PROC_NR, grant, (vir_bytes) 0,
+ (vir_bytes) user_path, (size_t) len, D);
+ if(r1 != OK) return(r1);
}
if(r == ELEAVEMOUNT || r == ESYMLINK) {
return(ENOENT);
/* If dir has been removed return ENOENT. */
- if (rip->i_nlinks == 0)
- return(ENOENT);
+ if (rip->i_nlinks == NO_LINK) return(ENOENT);
dup_inode(rip);
struct buf *bp; /* buffer containing link text */
char *sp; /* start of link text */
- bp = NULL;
-
if ((blink = read_map(rip, (off_t) 0)) == NO_BLOCK)
return(EIO);
bp = get_block(rip->i_dev, blink, NORMAL);
- llen = rip->i_size;
+ llen = (size_t) rip->i_size;
sp = bp->b_data;
slen = strlen(suffix);
* right place first, before we expand <link>. When strlen(<expandedlink>) is
* smaller than strlen(/already/processes/path), we move the suffix to the
* left. Is strlen(<expandedlink>) greater then we move it to the right. Else
- * we do nothing. */
+ * we do nothing.
+ */
if (slen > 0) { /* Do we have path after the link? */
/* For simplicity we require that suffix starts with a slash */
}
/* To be able to expand the <link>, we have to move the 'suffix'
- * to the right place. */
+ * to the right place.
+ */
if (slen + llen + 1 > sizeof(user_path))
return(ENAMETOOLONG);/* <expandedlink>+suffix+\0 does not fit*/
- if (suffix-user_path != llen) /* Move suffix left or right if needed */
+ if ((unsigned) (suffix-user_path) != llen) {
+ /* Move suffix left or right */
memmove(&user_path[llen], suffix, slen+1);
+ }
} else {
if (llen + 1 > sizeof(user_path))
return(ENAMETOOLONG); /* <expandedlink> + \0 does not fix */
* mounted file system. The super_block provides the linkage between the
* inode mounted on and the root directory of the mounted file system.
*/
- if (rip != NULL && rip->i_mountpoint) {
+ if (rip->i_mountpoint) {
/* Mountpoint encountered, report it */
err_code = EENTERMOUNT;
}
while(ep[0] != '\0' && ep[0] != '/')
ep++;
- len = ep - cp;
+ len = (size_t) (ep - cp);
/* Truncate the amount to be copied if it exceeds NAME_MAX */
- if (len > NAME_MAX)
- len = NAME_MAX;
+ if (len > NAME_MAX) len = NAME_MAX;
/* Special case of the string at cp is empty */
if (len == 0)
/* Since directories don't have holes, 'b' cannot be NO_BLOCK. */
bp = get_block(ldir_ptr->i_dev, b, NORMAL); /* get a dir block */
- if (bp == NO_BLOCK)
- panic("get_block returned NO_BLOCK");
+ assert(bp != NULL);
/* Search a directory block. */
for (dp = &bp->b_dir[0];
}
/* Match occurs if string found. */
- if (flag != ENTER && dp->d_ino != 0) {
+ if (flag != ENTER && dp->d_ino != NO_ENTRY) {
if (flag == IS_EMPTY) {
/* If this test succeeds, dir is not empty. */
if (strcmp(dp->d_name, "." ) != 0 &&
/* Save d_ino for recovery. */
t = NAME_MAX - sizeof(ino_t);
*((ino_t *) &dp->d_name[t]) = dp->d_ino;
- dp->d_ino = 0; /* erase entry */
+ dp->d_ino = NO_ENTRY; /* erase entry */
bp->b_dirt = DIRTY;
ldir_ptr->i_update |= CTIME | MTIME;
ldir_ptr->i_dirt = DIRTY;
} else {
sp = ldir_ptr->i_sp; /* 'flag' is LOOK_UP */
- *numb = conv4(sp->s_native, (int) dp->d_ino);
+ *numb = (ino_t) conv4(sp->s_native,
+ (int) dp->d_ino);
}
put_block(bp, DIRECTORY_BLOCK);
return(r);
#include "fs.h"
-#include <unistd.h>
-#include <minix/callnr.h>
-#include "buf.h"
#include "inode.h"
#include "super.h"
#include <minix/vfsif.h>
-FORWARD _PROTOTYPE( in_group, (gid_t grp) );
+FORWARD _PROTOTYPE( int in_group, (gid_t grp) );
/*===========================================================================*
/* Perform the chmod(name, mode) system call. */
register struct inode *rip;
+ mode_t mode;
+
+ mode = (mode_t) fs_m_in.REQ_MODE;
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* Now make the change. Clear setgid bit if file is not in caller's grp */
- rip->i_mode = (rip->i_mode & ~ALL_MODES) | (fs_m_in.REQ_MODE & ALL_MODES);
+ rip->i_mode = (rip->i_mode & ~ALL_MODES) | (mode & ALL_MODES);
rip->i_update |= CTIME;
rip->i_dirt = DIRTY;
register int r;
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* Not permitted to change the owner of a file on a read-only file sys. */
r = read_only(rip);
if (r == OK) {
- rip->i_uid = fs_m_in.REQ_UID;
- rip->i_gid = fs_m_in.REQ_GID;
+ rip->i_uid = (uid_t) fs_m_in.REQ_UID;
+ rip->i_gid = (gid_t) fs_m_in.REQ_GID;
rip->i_mode &= ~(I_SET_UID_BIT | I_SET_GID_BIT);
rip->i_update |= CTIME;
rip->i_dirt = DIRTY;
+#ifndef __MFS_PROTO_H__
+#define __MFS_PROTO_H__
+
/* Function prototypes. */
/* Structs used in prototypes must be declared as such first. */
_PROTOTYPE( struct buf *get_block, (dev_t dev, block_t block,int only_search));
_PROTOTYPE( void invalidate, (dev_t device) );
_PROTOTYPE( void put_block, (struct buf *bp, int block_type) );
-_PROTOTYPE( void set_blocksize, (int blocksize) );
+_PROTOTYPE( void set_blocksize, (unsigned int blocksize) );
_PROTOTYPE( void rw_scattered, (dev_t dev,
struct buf **bufq, int bufqsize, int rw_flag) );
/* device.c */
-_PROTOTYPE( int block_dev_io, (int op, dev_t dev, int proc, void *buf,
- u64_t pos, int bytes, int flags) );
-_PROTOTYPE( int dev_open, (endpoint_t driver_e, dev_t dev, int proc,
+_PROTOTYPE( int block_dev_io, (int op, dev_t dev, endpoint_t proc_e,
+ void *buf, u64_t pos, size_t bytes) );
+_PROTOTYPE( int dev_open, (endpoint_t driver_e, dev_t dev, endpoint_t proc_e,
int flags) );
_PROTOTYPE( void dev_close, (endpoint_t driver_e, dev_t dev) );
-_PROTOTYPE( int fs_clone_opcl, (void) );
_PROTOTYPE( int fs_new_driver, (void) );
/* inode.c */
_PROTOTYPE( struct inode *alloc_inode, (dev_t dev, mode_t bits) );
_PROTOTYPE( void dup_inode, (struct inode *ip) );
-_PROTOTYPE( struct inode *find_inode, (dev_t dev, int numb) );
-_PROTOTYPE( void free_inode, (dev_t dev, ino_t numb) );
-_PROTOTYPE( int fs_getnode, (void) );
+_PROTOTYPE( struct inode *find_inode, (dev_t dev, ino_t numb) );
_PROTOTYPE( int fs_putnode, (void) );
_PROTOTYPE( void init_inode_cache, (void) );
-_PROTOTYPE( struct inode *get_inode, (dev_t dev, int numb) );
+_PROTOTYPE( struct inode *get_inode, (dev_t dev, ino_t numb) );
_PROTOTYPE( void put_inode, (struct inode *rip) );
_PROTOTYPE( void update_times, (struct inode *rip) );
_PROTOTYPE( void rw_inode, (struct inode *rip, int rw_flag) );
-_PROTOTYPE( void wipe_inode, (struct inode *rip) );
/* link.c */
-_PROTOTYPE( int freesp_inode, (struct inode *rip, off_t st, off_t end) );
_PROTOTYPE( int fs_ftrunc, (void) );
_PROTOTYPE( int fs_link, (void) );
_PROTOTYPE( int fs_rdlink, (void) );
_PROTOTYPE( int fs_unlink, (void) );
_PROTOTYPE( int truncate_inode, (struct inode *rip, off_t len) );
-/* main.c */
-_PROTOTYPE( void reply, (endpoint_t who, message *m_out) );
-
/* misc.c */
_PROTOTYPE( int fs_flush, (void) );
_PROTOTYPE( int fs_sync, (void) );
/* read.c */
_PROTOTYPE( int fs_breadwrite, (void) );
_PROTOTYPE( int fs_readwrite, (void) );
-_PROTOTYPE( struct buf *rahead, (struct inode *rip, block_t baseblock,
- u64_t position, unsigned bytes_ahead) );
_PROTOTYPE( void read_ahead, (void) );
_PROTOTYPE( block_t read_map, (struct inode *rip, off_t pos) );
_PROTOTYPE( zone_t rd_indir, (struct buf *bp, int index) );
_PROTOTYPE( bit_t alloc_bit, (struct super_block *sp, int map, bit_t origin));
_PROTOTYPE( void free_bit, (struct super_block *sp, int map,
bit_t bit_returned) );
-_PROTOTYPE( int get_block_size, (dev_t dev) );
+_PROTOTYPE( unsigned int get_block_size, (dev_t dev) );
_PROTOTYPE( struct super_block *get_super, (dev_t dev) );
-_PROTOTYPE( int mounted, (struct inode *rip) );
_PROTOTYPE( int read_super, (struct super_block *sp) );
/* time.c */
_PROTOTYPE( time_t clock_time, (void) );
_PROTOTYPE( unsigned conv2, (int norm, int w) );
_PROTOTYPE( long conv4, (int norm, long x) );
-_PROTOTYPE( int fetch_name, (char *path, int len, int flag) );
-_PROTOTYPE( void mfs_nul_f, (char *file, int line, char *str, int len,
- int maxlen) );
-_PROTOTYPE( int mfs_min_f, (char *file, int line, int len1, int len2) );
+_PROTOTYPE( void mfs_nul_f, (char *file, int line, char *str, unsigned int len,
+ unsigned int maxlen) );
+_PROTOTYPE( int min, (unsigned int l, unsigned int r) );
_PROTOTYPE( int no_sys, (void) );
-_PROTOTYPE( int isokendpt_f, (char *f, int l, int e, int *p, int ft));
_PROTOTYPE( void sanitycheck, (char *file, int line) );
#define SANITYCHECK sanitycheck(__FILE__, __LINE__)
_PROTOTYPE( void zero_block, (struct buf *bp) );
_PROTOTYPE( int write_map, (struct inode *, off_t, zone_t, int) );
+#endif
+
#include "fs.h"
-#include <fcntl.h>
#include <stddef.h>
#include <string.h>
-#include <unistd.h>
#include <stdlib.h>
#include <minix/com.h>
#include <minix/u64.h>
#include "inode.h"
#include "super.h"
#include <minix/vfsif.h>
+#include <assert.h>
+
+FORWARD _PROTOTYPE( struct buf *rahead, (struct inode *rip, block_t baseblock,
+ u64_t position, unsigned bytes_ahead) );
FORWARD _PROTOTYPE( int rw_chunk, (struct inode *rip, u64_t position,
- unsigned off, int chunk, unsigned left, int rw_flag,
- cp_grant_id_t gid, unsigned buf_off, int block_size, int *completed));
+ unsigned off, size_t chunk, unsigned left, int rw_flag,
+ cp_grant_id_t gid, unsigned buf_off, unsigned int block_size,
+ int *completed) );
PRIVATE char getdents_buf[GETDENTS_BUFSIZ];
*===========================================================================*/
PUBLIC int fs_readwrite(void)
{
- int r, rw_flag, chunk, block_size, block_spec;
- int regular, nrbytes;
+ int r, rw_flag, block_spec;
+ int regular;
cp_grant_id_t gid;
off_t position, f_size, bytes_left;
- unsigned int off, cum_io;
+ unsigned int off, cum_io, block_size, chunk;
mode_t mode_word;
- int completed, r2 = OK;
+ int completed;
struct inode *rip;
+ size_t nrbytes;
r = OK;
/* Find the inode referred */
- if ((rip = find_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if ((rip = find_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
mode_word = rip->i_mode & I_TYPE;
block_spec = (mode_word == I_BLOCK_SPECIAL ? 1 : 0);
/* Determine blocksize */
- block_size = (block_spec ?
- get_block_size(rip->i_zone[0]) : rip->i_sp->s_block_size);
+ if (block_spec) {
+ block_size = get_block_size( (dev_t) rip->i_zone[0]);
+ f_size = MAX_FILE_POS;
+ } else {
+ block_size = rip->i_sp->s_block_size;
+ f_size = rip->i_size;
+ }
- f_size = (block_spec ? ULONG_MAX : rip->i_size);
-
/* Get the values from the request message */
rw_flag = (fs_m_in.m_type == REQ_READ ? READING : WRITING);
- gid = fs_m_in.REQ_GRANT;
- position = fs_m_in.REQ_SEEK_POS_LO;
- nrbytes = (unsigned) fs_m_in.REQ_NBYTES;
+ gid = (cp_grant_id_t) fs_m_in.REQ_GRANT;
+ position = (off_t) fs_m_in.REQ_SEEK_POS_LO;
+ nrbytes = (size_t) fs_m_in.REQ_NBYTES;
rdwt_err = OK; /* set to EIO if disk error occurs */
- if (rw_flag == WRITING && block_spec == 0) {
+ if (rw_flag == WRITING && !block_spec) {
/* Check in advance to see if file will grow too big. */
- if (position > rip->i_sp->s_max_size - nrbytes)
+ if (position > (off_t) (rip->i_sp->s_max_size - nrbytes))
return(EFBIG);
/* Clear the zone containing present EOF if hole about
* to be created. This is necessary because all unwritten
- * blocks prior to the EOF must read as zeros. */
+ * blocks prior to the EOF must read as zeros.
+ */
if(position > f_size) clear_zone(rip, f_size, 0);
}
cum_io = 0;
/* Split the transfer into chunks that don't span two blocks. */
- while (nrbytes != 0) {
- off = (unsigned int) (position % block_size);/* offset in blk*/
- chunk = MIN(nrbytes, block_size - off);
-
- if (chunk < 0) chunk = block_size - off;
+ while (nrbytes > 0) {
+ off = ((unsigned int) position) % block_size; /* offset in blk*/
+ chunk = min(nrbytes, block_size - off);
if (rw_flag == READING) {
bytes_left = f_size - position;
if (position >= f_size) break; /* we are beyond EOF */
- if (chunk > bytes_left) chunk = (int) bytes_left;
+ if (chunk > (unsigned int) bytes_left) chunk = bytes_left;
}
/* Read or write 'chunk' bytes. */
- r = rw_chunk(rip, cvul64(position), off, chunk, (unsigned) nrbytes,
- rw_flag, gid, cum_io, block_size, &completed);
+ r = rw_chunk(rip, cvul64((unsigned long) position), off, chunk,
+ nrbytes, rw_flag, 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 */
+ position += (off_t) chunk; /* position within the file */
}
fs_m_out.RES_SEEK_POS_LO = position; /* It might change later and the VFS
/* Check to see if read-ahead is called for, and if so, set it up. */
if(rw_flag == READING && rip->i_seek == NO_SEEK &&
- position % block_size == 0 && (regular || mode_word == I_DIRECTORY)) {
+ (unsigned int) position % block_size == 0 &&
+ (regular || mode_word == I_DIRECTORY)) {
rdahed_inode = rip;
rdahedpos = position;
}
if (rdwt_err != OK) r = rdwt_err; /* check for disk error */
if (rdwt_err == END_OF_FILE) r = OK;
- /* if user-space copying failed, read/write failed. */
- if (r == OK && r2 != OK)
- r = r2;
-
if (r == OK) {
if (rw_flag == READING) rip->i_update |= ATIME;
if (rw_flag == WRITING) rip->i_update |= CTIME | MTIME;
*===========================================================================*/
PUBLIC int fs_breadwrite(void)
{
- int r, rw_flag, chunk, block_size;
+ int r, rw_flag, completed;
cp_grant_id_t gid;
- int nrbytes;
u64_t position;
- unsigned int off, cum_io;
- int completed;
+ unsigned int off, cum_io, chunk, block_size;
+ size_t nrbytes;
/* Pseudo inode for rw_chunk */
struct inode rip;
/* Get the values from the request message */
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;
+ gid = (cp_grant_id_t) fs_m_in.REQ_GRANT;
+ position = make64((unsigned long) fs_m_in.REQ_SEEK_POS_LO,
+ (unsigned long) fs_m_in.REQ_SEEK_POS_HI);
+ nrbytes = (size_t) fs_m_in.REQ_NBYTES;
- block_size = get_block_size(fs_m_in.REQ_DEV2);
+ block_size = get_block_size( (dev_t) fs_m_in.REQ_DEV2);
- rip.i_zone[0] = fs_m_in.REQ_DEV2;
+ rip.i_zone[0] = (zone_t) fs_m_in.REQ_DEV2;
rip.i_mode = I_BLOCK_SPECIAL;
rip.i_size = 0;
cum_io = 0;
/* Split the transfer into chunks that don't span two blocks. */
- while (nrbytes != 0) {
+ while (nrbytes > 0) {
off = rem64u(position, block_size); /* offset in blk*/
-
- chunk = MIN(nrbytes, block_size - off);
- if (chunk < 0) chunk = block_size - off;
+ chunk = min(nrbytes, block_size - off);
/* Read or write 'chunk' bytes. */
- r = rw_chunk(&rip, position, off, chunk, (unsigned) nrbytes,
- rw_flag, gid, cum_io, block_size, &completed);
+ r = rw_chunk(&rip, position, off, chunk, nrbytes, rw_flag, 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 */
+ position = add64ul(position, chunk); /* position within the file */
}
fs_m_out.RES_SEEK_POS_LO = ex64lo(position);
register struct inode *rip; /* 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 int chunk; /* number of bytes to read or write */
unsigned left; /* max number of bytes wanted after position */
int rw_flag; /* READING or WRITING */
cp_grant_id_t gid; /* grant */
unsigned buf_off; /* offset in grant */
-int block_size; /* block size of FS operating on */
+unsigned int block_size; /* block size of FS operating on */
int *completed; /* number of bytes copied */
{
/* Read or write (part of) a block. */
} else {
if (ex64hi(position) != 0)
panic("rw_chunk: position too high");
- b = read_map(rip, ex64lo(position));
+ b = read_map(rip, (off_t) ex64lo(position));
dev = rip->i_dev;
}
zero_block(bp);
} else {
/* Writing to a nonexistent block. Create and enter in inode.*/
- if ((bp= new_block(rip, ex64lo(position))) == NULL)
+ if ((bp = new_block(rip, (off_t) ex64lo(position))) == NULL)
return(err_code);
}
} else if (rw_flag == READING) {
* the cache, acquire it, otherwise just acquire a free buffer.
*/
n = (chunk == block_size ? NO_READ : NORMAL);
- if (!block_spec && off == 0 && ex64lo(position) >= rip->i_size)
+ if (!block_spec && off == 0 && (off_t) ex64lo(position) >= rip->i_size)
n = NO_READ;
bp = get_block(dev, b, n);
}
panic("bp not valid in rw_chunk; this can't happen");
if (rw_flag == WRITING && chunk != block_size && !block_spec &&
- ex64lo(position) >= rip->i_size && off == 0) {
+ (off_t) ex64lo(position) >= rip->i_size && off == 0) {
zero_block(bp);
}
if (rw_flag == READING) {
/* Copy a chunk from the block buffer to user space. */
- r = sys_safecopyto(FS_PROC_NR, gid, buf_off,
- (vir_bytes) (bp->b_data+off), (phys_bytes) chunk, D);
+ r = sys_safecopyto(FS_PROC_NR, gid, (vir_bytes) buf_off,
+ (vir_bytes) (bp->b_data+off), (size_t) chunk, D);
} else {
/* Copy a chunk from user space to the block buffer. */
- r = sys_safecopyfrom(FS_PROC_NR, gid, buf_off,
- (vir_bytes) (bp->b_data+off), (phys_bytes) chunk, D);
+ r = sys_safecopyfrom(FS_PROC_NR, gid, (vir_bytes) buf_off,
+ (vir_bytes) (bp->b_data+off), (size_t) chunk, D);
bp->b_dirt = DIRTY;
}
* block (not zone) number in which that position is to be found and return it.
*/
- register struct buf *bp;
- register zone_t z;
- int scale, boff, dzones, nr_indirects, index, zind, ex;
+ struct buf *bp;
+ zone_t z;
+ int scale, boff, index, zind, ex;
+ unsigned int dzones, nr_indirects;
block_t b;
- long excess, zone, block_pos;
+ unsigned long excess, zone, block_pos;
scale = rip->i_sp->s_log_zone_size; /* for block-zone conversion */
block_pos = position/rip->i_sp->s_block_size; /* relative blk # in file */
zind = (int) zone; /* index should be an int */
z = rip->i_zone[zind];
if (z == NO_ZONE) return(NO_BLOCK);
- b = ((block_t) z << scale) + boff;
+ b = (block_t) ((z << scale) + boff);
return(b);
}
z = rd_indir(bp, ex); /* get block pointed to */
put_block(bp, INDIRECT_BLOCK); /* release single indir blk */
if (z == NO_ZONE) return(NO_BLOCK);
- b = ((block_t) z << scale) + boff;
+ b = (block_t) ((z << scale) + boff);
return(b);
}
PUBLIC void read_ahead()
{
/* Read a block into the cache before it is needed. */
- int block_size;
+ unsigned int block_size;
register struct inode *rip;
struct buf *bp;
block_t b;
block_size = get_block_size(rip->i_dev);
rdahed_inode = NULL; /* turn off read ahead */
if ( (b = read_map(rip, rdahedpos)) == NO_BLOCK) return; /* at EOF */
- bp = rahead(rip, b, cvul64(rdahedpos), block_size);
+
+ assert(rdahedpos > 0); /* So we can safely cast it to unsigned below */
+
+ bp = rahead(rip, b, cvul64( (unsigned long) rdahedpos), block_size);
put_block(bp, PARTIAL_DATA_BLOCK);
}
/*===========================================================================*
* rahead *
*===========================================================================*/
-PUBLIC struct buf *rahead(rip, baseblock, position, bytes_ahead)
+PRIVATE struct buf *rahead(rip, baseblock, position, bytes_ahead)
register struct inode *rip; /* pointer to inode for file to be read */
block_t baseblock; /* block at current position */
u64_t position; /* position within file */
* cylinder boundary (or after an error). Rw_scattered() puts an optional
* flag on all reads to allow this.
*/
- int block_size;
/* Minimum number of blocks to prefetch. */
# define BLOCKS_MINIMUM (nr_bufs < 50 ? 18 : 32)
int block_spec, scale, read_q_size;
- unsigned int blocks_ahead, fragment;
+ unsigned int blocks_ahead, fragment, block_size;
block_t block, blocks_left;
off_t ind1_pos;
dev_t dev;
struct buf *bp;
- static int readqsize = 0;
+ static unsigned int readqsize = 0;
static struct buf **read_q;
if(readqsize != nr_bufs) {
- if(readqsize > 0)
+ if(readqsize > 0) {
+ assert(read_q != NULL);
free(read_q);
+ }
if(!(read_q = malloc(sizeof(read_q[0])*nr_bufs)))
panic("couldn't allocate read_q");
readqsize = nr_bufs;
*/
fragment = rem64u(position, block_size);
- position= sub64u(position, fragment);
+ position = sub64u(position, fragment);
bytes_ahead += fragment;
blocks_ahead = (bytes_ahead + block_size - 1) / block_size;
if (block_spec && rip->i_size == 0) {
- blocks_left = NR_IOREQS;
+ blocks_left = (block_t) NR_IOREQS;
} else {
- blocks_left = (rip->i_size - ex64lo(position) + block_size - 1) /
- block_size;
+ blocks_left = (block_t) (rip->i_size-ex64lo(position)+(block_size-1)) /
+ block_size;
/* Go for the first indirect block if we are in its neighborhood. */
if (!block_spec) {
scale = rip->i_sp->s_log_zone_size;
ind1_pos = (off_t) rip->i_ndzones * (block_size << scale);
- if (ex64lo(position) <= ind1_pos && rip->i_size > ind1_pos) {
+ if ((off_t) ex64lo(position) <= ind1_pos &&
+ rip->i_size > ind1_pos) {
blocks_ahead++;
blocks_left++;
}
PUBLIC int fs_getdents(void)
{
register struct inode *rip;
- int o, r, block_size, len, reclen, done;
+ int o, r, done;
+ unsigned int block_size, len, reclen;
ino_t ino;
block_t b;
cp_grant_id_t gid;
struct dirent *dep;
char *cp;
- ino = fs_m_in.REQ_INODE_NR;
- gid = fs_m_in.REQ_GRANT;
- size = fs_m_in.REQ_MEM_SIZE;
- pos = fs_m_in.REQ_SEEK_POS_LO;
+ ino = (ino_t) fs_m_in.REQ_INODE_NR;
+ gid = (gid_t) fs_m_in.REQ_GRANT;
+ size = (size_t) fs_m_in.REQ_MEM_SIZE;
+ pos = (off_t) fs_m_in.REQ_SEEK_POS_LO;
/* Check whether the position is properly aligned */
- if(pos % DIR_ENTRY_SIZE)
+ if( (unsigned int) pos % DIR_ENTRY_SIZE)
return(ENOENT);
if( (rip = get_inode(fs_dev, ino)) == NULL)
new_pos = rip->i_size;
for(; block_pos < rip->i_size; block_pos += block_size) {
- b = read_map(rip, block_pos); /* get block number */
+ b = read_map(rip, block_pos); /* get block number */
- /* Since directories don't have holes, 'b' cannot be NO_BLOCK. */
- bp = get_block(rip->i_dev, b, NORMAL); /* get a dir block */
+ /* Since directories don't have holes, 'b' cannot be NO_BLOCK. */
+ bp = get_block(rip->i_dev, b, NORMAL); /* get a dir block */
- if(bp == NO_BLOCK)
- panic("get_block returned NO_BLOCK");
+ assert(bp != NULL);
/* Search a directory block. */
if (block_pos < pos)
if (cp == NULL)
len = NAME_MAX;
else
- len = cp-dp->d_name;
+ len = cp - (dp->d_name);
/* Compute record length */
reclen = offsetof(struct dirent, d_name) + len + 1;
reclen += sizeof(long) - o;
/* Need the position of this entry in the directory */
- ent_pos = block_pos + ((char *)dp - bp->b_data);
+ ent_pos = block_pos + ((char *) dp - (bp->b_data));
if(tmpbuf_off + reclen > GETDENTS_BUFSIZ) {
- r = sys_safecopyto(FS_PROC_NR, gid, userbuf_off,
- (vir_bytes)getdents_buf,
- tmpbuf_off, D);
- if (r != OK)
- panic("fs_getdents: sys_safecopyto failed: %d", r);
+ r = sys_safecopyto(FS_PROC_NR, gid,
+ (vir_bytes) userbuf_off,
+ (vir_bytes) getdents_buf,
+ (size_t) tmpbuf_off, D);
+ if (r != OK) {
+ put_inode(rip);
+ return(r);
+ }
userbuf_off += tmpbuf_off;
tmpbuf_off = 0;
break;
}
- dep = (struct dirent *)&getdents_buf[tmpbuf_off];
+ dep = (struct dirent *) &getdents_buf[tmpbuf_off];
dep->d_ino = dp->d_ino;
dep->d_off = ent_pos;
- dep->d_reclen = reclen;
+ dep->d_reclen = (unsigned short) reclen;
memcpy(dep->d_name, dp->d_name, len);
dep->d_name[len] = '\0';
tmpbuf_off += reclen;
}
if(tmpbuf_off != 0) {
- r = sys_safecopyto(FS_PROC_NR, gid, userbuf_off,
- (vir_bytes) getdents_buf, tmpbuf_off, D);
- if (r != OK)
- panic("fs_getdents: sys_safecopyto failed: %d", r);
+ r = sys_safecopyto(FS_PROC_NR, gid, (vir_bytes) userbuf_off,
+ (vir_bytes) getdents_buf, (size_t) tmpbuf_off, D);
+ if (r != OK) {
+ put_inode(rip);
+ return(r);
+ }
userbuf_off += tmpbuf_off;
}
#include "fs.h"
#include <sys/stat.h>
#include <sys/statfs.h>
-#include <minix/com.h>
-#include <string.h>
-#include "buf.h"
#include "inode.h"
#include "super.h"
#include <minix/vfsif.h>
statbuf.st_mode = rip->i_mode;
statbuf.st_nlink = rip->i_nlinks;
statbuf.st_uid = rip->i_uid;
- statbuf.st_gid = rip->i_gid;
- statbuf.st_rdev = (dev_t) (s ? rip->i_zone[0] : NO_DEV);
+ statbuf.st_gid = (short) rip->i_gid; /* FIXME: should become gid_t */
+ statbuf.st_rdev = (s ? (dev_t) rip->i_zone[0] : NO_DEV);
statbuf.st_size = rip->i_size;
statbuf.st_atime = rip->i_atime;
statbuf.st_mtime = rip->i_mtime;
statbuf.st_ctime = rip->i_ctime;
/* Copy the struct to user space. */
- r = sys_safecopyto(who_e, gid, 0, (vir_bytes) &statbuf,
- (phys_bytes) sizeof(statbuf), D);
+ r = sys_safecopyto(who_e, gid, (vir_bytes) 0, (vir_bytes) &statbuf,
+ (size_t) sizeof(statbuf), D);
return(r);
}
st.f_bsize = rip->i_sp->s_block_size;
/* Copy the struct to user space. */
- r = sys_safecopyto(fs_m_in.m_source, fs_m_in.REQ_GRANT, 0, (vir_bytes) &st,
- (phys_bytes) sizeof(st), D);
+ r = sys_safecopyto(fs_m_in.m_source, (cp_grant_id_t) fs_m_in.REQ_GRANT,
+ (vir_bytes) 0, (vir_bytes) &st, (size_t) sizeof(st), D);
return(r);
}
register int r; /* return value */
register struct inode *rip; /* target inode */
- if ((rip = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if ((rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
- r = stat_inode(rip, fs_m_in.m_source, fs_m_in.REQ_GRANT);
+ r = stat_inode(rip, fs_m_in.m_source, (cp_grant_id_t) fs_m_in.REQ_GRANT);
put_inode(rip); /* release the inode */
return(r);
}
/* Allocate a bit from a bit map and return its bit number. */
block_t start_block; /* first bit block */
+ block_t block;
bit_t map_bits; /* how many bits are there in the bit map? */
- unsigned bit_blocks; /* how many blocks are there in the bit map? */
- unsigned block, word, bcount;
+ short bit_blocks; /* how many blocks are there in the bit map? */
+ unsigned word, bcount;
struct buf *bp;
bitchunk_t *wptr, *wlim, k;
bit_t i, b;
if (map == IMAP) {
start_block = START_BLOCK;
- map_bits = sp->s_ninodes + 1;
+ map_bits = (bit_t) (sp->s_ninodes + 1);
bit_blocks = sp->s_imap_blocks;
} else {
start_block = START_BLOCK + sp->s_imap_blocks;
- map_bits = sp->s_zones - (sp->s_firstdatazone - 1);
+ map_bits = (bit_t) (sp->s_zones - (sp->s_firstdatazone - 1));
bit_blocks = sp->s_zmap_blocks;
}
if (origin >= map_bits) origin = 0; /* for robustness */
/* Locate the starting place. */
- block = origin / FS_BITS_PER_BLOCK(sp->s_block_size);
+ block = (block_t) (origin / FS_BITS_PER_BLOCK(sp->s_block_size));
word = (origin % FS_BITS_PER_BLOCK(sp->s_block_size)) / FS_BITCHUNK_BITS;
/* Iterate over all blocks plus one, because we start in the middle. */
if (*wptr == (bitchunk_t) ~0) continue;
/* Find and allocate the free bit. */
- k = conv2(sp->s_native, (int) *wptr);
+ k = (bitchunk_t) conv2(sp->s_native, (int) *wptr);
for (i = 0; (k & (1 << i)) != 0; ++i) {}
/* Bit number from the start of the bit map. */
/* Allocate and return bit number. */
k |= 1 << i;
- *wptr = conv2(sp->s_native, (int) k);
+ *wptr = (bitchunk_t) conv2(sp->s_native, (int) k);
bp->b_dirt = DIRTY;
put_block(bp, MAP_BLOCK);
return(b);
}
put_block(bp, MAP_BLOCK);
- if (++block >= bit_blocks) block = 0; /* last block, wrap around */
+ if (++block >= (unsigned int) bit_blocks) /* last block, wrap around */
+ block = 0;
word = 0;
} while (--bcount > 0);
return(NO_BIT); /* no bit could be allocated */
bp = get_block(sp->s_dev, start_block + block, NORMAL);
- k = conv2(sp->s_native, (int) bp->b_bitmap[word]);
+ k = (bitchunk_t) conv2(sp->s_native, (int) bp->b_bitmap[word]);
if (!(k & mask)) {
- panic(map == IMAP ? "tried to free unused inode" : "tried to free unused block: %d", bit_returned);
+ if (map == IMAP) panic("tried to free unused inode");
+ else panic("tried to free unused block: %u", bit_returned);
}
k &= ~mask;
- bp->b_bitmap[word] = conv2(sp->s_native, (int) k);
+ bp->b_bitmap[word] = (bitchunk_t) conv2(sp->s_native, (int) k);
bp->b_dirt = DIRTY;
put_block(bp, MAP_BLOCK);
/*===========================================================================*
* get_block_size *
*===========================================================================*/
-PUBLIC int get_block_size(dev_t dev)
+PUBLIC unsigned int get_block_size(dev_t dev)
{
if (dev == NO_DEV)
panic("request for block size of NO_DEV");
{
/* Read a superblock. */
dev_t dev;
- int magic;
+ unsigned int magic;
int version, native, r;
static char *sbbuf;
block_t offset;
if (dev == NO_DEV)
panic("request for super_block of NO_DEV");
- r = block_dev_io(MFS_DEV_READ, dev, SELF_E,
- sbbuf, cvu64(SUPER_BLOCK_BYTES), _MIN_BLOCK_SIZE, 0);
+ r = block_dev_io(MFS_DEV_READ, dev, SELF_E, sbbuf, cvu64(SUPER_BLOCK_BYTES),
+ _MIN_BLOCK_SIZE);
if (r != _MIN_BLOCK_SIZE)
return(EINVAL);
/* If the super block has the wrong byte order, swap the fields; the magic
* number doesn't need conversion. */
- sp->s_ninodes = conv4(native, sp->s_ninodes);
- sp->s_nzones = conv2(native, (int) sp->s_nzones);
- sp->s_imap_blocks = conv2(native, (int) sp->s_imap_blocks);
- sp->s_zmap_blocks = conv2(native, (int) sp->s_zmap_blocks);
- sp->s_firstdatazone_old = conv2(native, (int) sp->s_firstdatazone_old);
- sp->s_log_zone_size = conv2(native, (int) sp->s_log_zone_size);
- sp->s_max_size = conv4(native, sp->s_max_size);
- sp->s_zones = conv4(native, sp->s_zones);
+ sp->s_ninodes = (ino_t) conv4(native, (int) sp->s_ninodes);
+ sp->s_nzones = (zone1_t) conv2(native, (int) sp->s_nzones);
+ sp->s_imap_blocks = (short) conv2(native, (int) sp->s_imap_blocks);
+ sp->s_zmap_blocks = (short) conv2(native, (int) sp->s_zmap_blocks);
+ sp->s_firstdatazone_old =(zone1_t)conv2(native,(int)sp->s_firstdatazone_old);
+ sp->s_log_zone_size = (short) conv2(native, (int) sp->s_log_zone_size);
+ sp->s_max_size = (off_t) conv4(native, sp->s_max_size);
+ sp->s_zones = (zone_t)conv4(native, sp->s_zones);
/* In V1, the device size was kept in a short, s_nzones, which limited
* devices to 32K zones. For V2, it was decided to keep the size as a
*/
if (version == V1) {
sp->s_block_size = _STATIC_BLOCK_SIZE;
- sp->s_zones = sp->s_nzones; /* only V1 needs this copy */
+ sp->s_zones = (zone_t) sp->s_nzones; /* only V1 needs this copy */
sp->s_inodes_per_block = V1_INODES_PER_BLOCK;
sp->s_ndzones = V1_NR_DZONES;
sp->s_nindirs = V1_INDIRECTS;
sp->s_firstdatazone = (offset + (1 << sp->s_log_zone_size) - 1) >>
sp->s_log_zone_size;
} else {
- sp->s_firstdatazone = sp->s_firstdatazone_old;
+ sp->s_firstdatazone = (zone_t) sp->s_firstdatazone_old;
}
if (sp->s_block_size < _MIN_BLOCK_SIZE)
+#ifndef __MFS_SUPER_H__
+#define __MFS_SUPER_H__
+
/* Super block table. The root file system and every mounted file system
* has an entry here. The entry holds information about the sizes of the bit
* maps and inodes. The s_ninodes field gives the number of inodes available
#define IMAP 0 /* operating on the inode bit map */
#define ZMAP 1 /* operating on the zone bit map */
+
+#endif
+
#define _TABLE
#include "fs.h"
-#include <minix/callnr.h>
-#include <minix/com.h>
#include "inode.h"
#include "buf.h"
#include "super.h"
#include "fs.h"
-#include <minix/callnr.h>
-#include <minix/com.h>
#include "inode.h"
#include <minix/vfsif.h>
register int r;
/* Temporarily open the file. */
- if( (rip = get_inode(fs_dev, fs_m_in.REQ_INODE_NR)) == NULL)
+ if( (rip = get_inode(fs_dev, (ino_t) fs_m_in.REQ_INODE_NR)) == NULL)
return(EINVAL);
/* Only the owner of a file or the super_user can change its time. */
+#ifndef __MFS_TYPE_H__
+#define __MFS_TYPE_H__
+
/* Declaration of the V1 inode as it is on the disk (not in core). */
typedef struct { /* V1.x disk inode */
u16_t d1_mode; /* file type, protection, etc. */
dev_t b_dev; /* major | minor device where block resides */
char b_dirt; /* CLEAN or DIRTY */
char b_count; /* number of users of this buffer */
- int b_bytes; /* Number of bytes allocated in bp */
+ unsigned int b_bytes; /* Number of bytes allocated in bp */
};
+#endif
+
#include "fs.h"
-#include <sys/stat.h>
-#include <string.h>
-#include <minix/com.h>
-#include <minix/callnr.h>
-#include <stdlib.h>
#include "buf.h"
#include "inode.h"
#include "super.h"
-#include <minix/vfsif.h>
/*===========================================================================*
register int k;
clock_t uptime;
+ time_t boottime;
- if (use_getuptime2) {
- if ( (k=getuptime2(&uptime,&boottime)) != OK)
+ if ( (k=getuptime2(&uptime, &boottime)) != OK)
panic("clock_time: getuptme2 failed: %d", k);
- } else {
- if ( (k=getuptime(&uptime)) != OK)
- panic("clock_time err: %d", k);
- }
return( (time_t) (boottime + (uptime/sys_hz())));
}
/*===========================================================================*
* mfs_min *
*===========================================================================*/
-PUBLIC int mfs_min_f(char *file, int line, int v1, int v2)
+PUBLIC int min(unsigned int l, unsigned int r)
{
- if(v1 < 0 || v2 < 0) {
- printf("mfs:%s:%d: strange string lengths: %d, %d\n",
- file, line, v1, v2);
- panic("strange string lengths");
- }
- if(v2 >= v1) return v1;
+ if(r >= l) return(l);
- return v2;
+ return(r);
}
/*===========================================================================*
* mfs_nul *
*===========================================================================*/
-PUBLIC void mfs_nul_f(char *file, int line, char *str, int len, int maxlen)
+PUBLIC void mfs_nul_f(char *file, int line, char *str, unsigned int len,
+unsigned int maxlen)
{
- if(len < 1) {
- printf("mfs:%s:%d: %d-length string?!\n", file, line, len);
- panic("strange string length");
- }
- if(len < maxlen && str[len-1] != '\0') {
- printf("mfs:%s:%d: string (length %d, maxlen %d) "
- "not null-terminated\n",
- file, line, len, maxlen);
- }
+ if(len < maxlen && str[len-1] != '\0') {
+ printf("MFS %s:%d string (length %d, maxlen %d) not null-terminated\n",
+ file, line, len, maxlen);
+ }
}
#define MYASSERT(c) if(!(c)) { printf("MFS:%s:%d: sanity check: %s failed\n", \
/* Return nonzero if the indirect block pointed to by bp contains
* only NO_ZONE entries.
*/
- int i;
- if(sb->s_version == V1) {
- for(i = 0; i < V1_INDIRECTS; i++)
- if(bp->b_v1_ind[i] != NO_ZONE)
- return(0);
- } else {
- for(i = 0; i < V2_INDIRECTS(sb->s_block_size); i++)
- if(bp->b_v2_ind[i] != NO_ZONE)
- return(0);
- }
+ unsigned int i;
+ for(i = 0; i < V2_INDIRECTS(sb->s_block_size); i++)
+ if( bp->b_v2_ind[i] != NO_ZONE)
+ return(0);
return(1);
}
* fs_readwrite(), truncate_inode(), and new_block().
*/
- register struct buf *bp;
- register block_t b, blo, bhi;
- register off_t next;
- register int scale;
- register zone_t zone_size;
+ struct buf *bp;
+ block_t b, blo, bhi;
+ off_t next;
+ int scale, zone_size;
/* If the block size and zone size are the same, clear_zone() not needed. */
scale = rip->i_sp->s_log_zone_size;
if (scale == 0) return;
- zone_size = (zone_t) rip->i_sp->s_block_size << scale;
- if (flag == 1) pos = (pos/zone_size) * zone_size;
+ zone_size = rip->i_sp->s_block_size << scale;
+ if (flag == 1) pos = (off_t) ((pos/zone_size) * zone_size);
next = pos + rip->i_sp->s_block_size - 1;
/* If 'pos' is in the last block of a zone, do not clear the zone. */
if (next/zone_size != pos/zone_size) return;
if ( (blo = read_map(rip, next)) == NO_BLOCK) return;
- bhi = ( ((blo>>scale)+1) << scale) - 1;
+ bhi = (block_t) ( ((blo>>scale)+1) << scale) - 1;
/* Clear all the blocks between 'blo' and 'bhi'. */
for (b = blo; b <= bhi; b++) {
/* First search for this file. Start looking from
* the file's first data zone to prevent fragmentation
*/
- if ( (z = rip->i_zone[0]) == NO_ZONE) {
- /* no first zone for file either */
- z = rip->i_sp->s_firstdatazone; /* let alloc_zone decide */
+ if ( (z = rip->i_zone[0]) == NO_ZONE) {
+ /* No first zone for file either, let alloc_zone
+ * decide. */
+ z = (zone_t) rip->i_sp->s_firstdatazone;
}
} else {
/* searched before, start from last find */
/* Zero a block. */
ASSERT(bp->b_bytes > 0);
ASSERT(bp->bp);
- memset(bp->b_data, 0, bp->b_bytes);
+ memset(bp->b_data, 0, (size_t) bp->b_bytes);
bp->b_dirt = DIRTY;
}
#define SYMLOOP 16
-#define ROOT_INODE 1 /* inode number for root directory */
-
#define LABEL_MAX 16 /* maximum label size (including '\0'). Should
* not be smaller than 16 or bigger than
* M3_LONG_STRING.