mfs: use macros to mark blocks and inodes dirty
. No functional change . Only serves to get hooks to do checks in . e.g. should things be marked dirty when we are mounted readonly Signed-off-by: Ben Gras <ben@minix3.org>
This commit is contained in:
parent
34a8901eb8
commit
9b7d357ca1
|
@ -1,6 +1,8 @@
|
|||
#ifndef __MFS_BUF_H__
|
||||
#define __MFS_BUF_H__
|
||||
|
||||
#include "clean.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
|
||||
|
|
|
@ -136,7 +136,7 @@ PUBLIC struct buf *get_block(
|
|||
* Avoid hysteresis by flushing all other dirty blocks for the same device.
|
||||
*/
|
||||
if (bp->b_dev != NO_DEV) {
|
||||
if (bp->b_dirt == DIRTY) flushall(bp->b_dev);
|
||||
if (ISDIRTY(bp)) flushall(bp->b_dev);
|
||||
|
||||
/* Are we throwing out a block that contained something?
|
||||
* Give it to VM for the second-layer cache.
|
||||
|
@ -360,8 +360,7 @@ int rw_flag; /* READING or WRITING */
|
|||
}
|
||||
}
|
||||
|
||||
bp->b_dirt = CLEAN;
|
||||
|
||||
MARKCLEAN(bp);
|
||||
}
|
||||
|
||||
/*===========================================================================*
|
||||
|
@ -406,7 +405,7 @@ PUBLIC void flushall(
|
|||
}
|
||||
|
||||
for (bp = &buf[0], ndirty = 0; bp < &buf[nr_bufs]; bp++)
|
||||
if (bp->b_dirt == DIRTY && bp->b_dev == dev) dirty[ndirty++] = bp;
|
||||
if (ISDIRTY(bp) && bp->b_dev == dev) dirty[ndirty++] = bp;
|
||||
rw_scattered(dev, dirty, ndirty, WRITING);
|
||||
}
|
||||
|
||||
|
@ -487,7 +486,7 @@ PUBLIC void rw_scattered(
|
|||
bp->b_dev = dev; /* validate block */
|
||||
put_block(bp, PARTIAL_DATA_BLOCK);
|
||||
} else {
|
||||
bp->b_dirt = CLEAN;
|
||||
MARKCLEAN(bp);
|
||||
}
|
||||
r -= fs_block_size;
|
||||
}
|
||||
|
|
11
servers/mfs/clean.h
Normal file
11
servers/mfs/clean.h
Normal file
|
@ -0,0 +1,11 @@
|
|||
|
||||
#ifndef _MFS_CLEAN_H
|
||||
#define _MFS_CLEAN_H 1
|
||||
|
||||
#define MARKDIRTY(b) ((b)->b_dirt = BP_DIRTY)
|
||||
#define MARKCLEAN(b) ((b)->b_dirt = BP_CLEAN)
|
||||
|
||||
#define ISDIRTY(b) ((b)->b_dirt == BP_DIRTY)
|
||||
#define ISCLEAN(b) ((b)->b_dirt == BP_CLEAN)
|
||||
|
||||
#endif
|
|
@ -57,8 +57,10 @@
|
|||
#define IGN_PERM 0
|
||||
#define CHK_PERM 1
|
||||
|
||||
#define CLEAN 0 /* disk and memory copies identical */
|
||||
#define DIRTY 1 /* disk and memory copies differ */
|
||||
#define BP_CLEAN 0 /* on-disk block and memory copies identical */
|
||||
#define BP_DIRTY 1 /* on-disk block and memory copies differ */
|
||||
#define IN_CLEAN 0 /* in-block inode and memory copies identical */
|
||||
#define IN_DIRTY 1 /* in-block inode and memory copies differ */
|
||||
#define ATIME 002 /* set if atime field needs updating */
|
||||
#define CTIME 004 /* set if ctime field needs updating */
|
||||
#define MTIME 010 /* set if mtime field needs updating */
|
||||
|
|
|
@ -233,12 +233,12 @@ register struct inode *rip; /* pointer to inode to be released */
|
|||
*/
|
||||
(void) truncate_inode(rip, (off_t) 0);
|
||||
rip->i_mode = I_NOT_ALLOC; /* clear I_TYPE field */
|
||||
rip->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(rip);
|
||||
free_inode(rip->i_dev, rip->i_num);
|
||||
}
|
||||
|
||||
rip->i_mountpoint = FALSE;
|
||||
if (rip->i_dirt == DIRTY) rw_inode(rip, WRITING);
|
||||
if (IN_ISDIRTY(rip)) rw_inode(rip, WRITING);
|
||||
|
||||
if (rip->i_nlinks == NO_LINK) {
|
||||
/* free, put at the front of the LRU list */
|
||||
|
@ -325,7 +325,7 @@ register struct inode *rip; /* the inode to be erased */
|
|||
|
||||
rip->i_size = 0;
|
||||
rip->i_update = ATIME | CTIME | MTIME; /* update all times later */
|
||||
rip->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(rip);
|
||||
for (i = 0; i < V2_NR_TZONES; i++) rip->i_zone[i] = NO_ZONE;
|
||||
}
|
||||
|
||||
|
@ -405,7 +405,7 @@ int rw_flag; /* READING or WRITING */
|
|||
/* Do the read or write. */
|
||||
if (rw_flag == WRITING) {
|
||||
if (rip->i_update) update_times(rip); /* times need updating */
|
||||
if (sp->s_rd_only == FALSE) bp->b_dirt = DIRTY;
|
||||
if (sp->s_rd_only == FALSE) MARKDIRTY(bp);
|
||||
}
|
||||
|
||||
/* Copy the inode from the disk block to the in-core table or vice versa.
|
||||
|
@ -417,7 +417,7 @@ int rw_flag; /* READING or WRITING */
|
|||
new_icopy(rip, dip2, rw_flag, sp->s_native);
|
||||
|
||||
put_block(bp, INODE_BLOCK);
|
||||
rip->i_dirt = CLEAN;
|
||||
IN_MARKCLEAN(rip);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -62,4 +62,10 @@ EXTERN unsigned int inode_cache_miss;
|
|||
#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 */
|
||||
|
||||
#define IN_MARKCLEAN(i) i->i_dirt = IN_CLEAN
|
||||
#define IN_MARKDIRTY(i) i->i_dirt = IN_DIRTY
|
||||
|
||||
#define IN_ISCLEAN(i) i->i_dirt == IN_CLEAN
|
||||
#define IN_ISDIRTY(i) i->i_dirt == IN_DIRTY
|
||||
|
||||
#endif
|
||||
|
|
|
@ -97,7 +97,7 @@ PUBLIC int fs_link()
|
|||
if(r == OK) {
|
||||
rip->i_nlinks++;
|
||||
rip->i_update |= CTIME;
|
||||
rip->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(rip);
|
||||
}
|
||||
|
||||
/* Done. Release both inodes. */
|
||||
|
@ -271,7 +271,7 @@ char file_name[MFS_NAME_MAX]; /* name of file to be removed */
|
|||
if (r == OK) {
|
||||
rip->i_nlinks--; /* entry deleted from parent's dir */
|
||||
rip->i_update |= CTIME;
|
||||
rip->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(rip);
|
||||
}
|
||||
|
||||
put_inode(rip);
|
||||
|
@ -471,7 +471,7 @@ PUBLIC int fs_rename()
|
|||
if(search_dir(old_ip, dot2, &numb, ENTER, IGN_PERM) == OK) {
|
||||
/* New link created. */
|
||||
new_dirp->i_nlinks++;
|
||||
new_dirp->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(new_dirp);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -546,7 +546,7 @@ off_t newsize; /* inode must become this size */
|
|||
/* Next correct the inode size. */
|
||||
rip->i_size = newsize;
|
||||
rip->i_update |= CTIME | MTIME;
|
||||
rip->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(rip);
|
||||
|
||||
return(OK);
|
||||
}
|
||||
|
@ -610,7 +610,7 @@ off_t start, end; /* range of bytes to free (end uninclusive) */
|
|||
}
|
||||
|
||||
rip->i_update |= CTIME | MTIME;
|
||||
rip->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(rip);
|
||||
|
||||
return(OK);
|
||||
}
|
||||
|
@ -693,7 +693,7 @@ off_t len;
|
|||
if (bytes > (size_t) len)
|
||||
bytes = len;
|
||||
memset(bp->b_data + offset, 0, bytes);
|
||||
bp->b_dirt = DIRTY;
|
||||
MARKDIRTY(bp);
|
||||
put_block(bp, FULL_DATA_BLOCK);
|
||||
|
||||
pos += bytes;
|
||||
|
|
|
@ -3,7 +3,7 @@
|
|||
#include <minix/vfsif.h>
|
||||
#include <minix/bdev.h>
|
||||
#include "inode.h"
|
||||
|
||||
#include "clean.h"
|
||||
|
||||
/*===========================================================================*
|
||||
* fs_sync *
|
||||
|
@ -23,11 +23,11 @@ PUBLIC int fs_sync()
|
|||
|
||||
/* Write all the dirty inodes to the disk. */
|
||||
for(rip = &inode[0]; rip < &inode[NR_INODES]; rip++)
|
||||
if(rip->i_count > 0 && rip->i_dirt == DIRTY) rw_inode(rip, WRITING);
|
||||
if(rip->i_count > 0 && IN_ISDIRTY(rip)) rw_inode(rip, WRITING);
|
||||
|
||||
/* Write all the dirty blocks to the disk, one drive at a time. */
|
||||
for(bp = &buf[0]; bp < &buf[nr_bufs]; bp++)
|
||||
if(bp->b_dev != NO_DEV && bp->b_dirt == DIRTY)
|
||||
if(bp->b_dev != NO_DEV && ISDIRTY(bp))
|
||||
flushall(bp->b_dev);
|
||||
|
||||
return(OK); /* sync() can't fail */
|
||||
|
|
|
@ -150,7 +150,7 @@ PUBLIC int fs_mkdir()
|
|||
/* Normal case. It was possible to enter . and .. in the new dir. */
|
||||
rip->i_nlinks++; /* this accounts for . */
|
||||
ldirp->i_nlinks++; /* this accounts for .. */
|
||||
ldirp->i_dirt = DIRTY; /* mark parent's inode as dirty */
|
||||
IN_MARKDIRTY(ldirp); /* mark parent's inode as dirty */
|
||||
} else {
|
||||
/* It was not possible to enter . or .. probably disk was full -
|
||||
* links counts haven't been touched. */
|
||||
|
@ -158,7 +158,7 @@ PUBLIC int fs_mkdir()
|
|||
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 */
|
||||
IN_MARKDIRTY(rip); /* either way, i_nlinks has changed */
|
||||
|
||||
put_inode(ldirp); /* return the inode of the parent dir */
|
||||
put_inode(rip); /* return the inode of the newly made dir */
|
||||
|
@ -293,7 +293,7 @@ PRIVATE struct inode *new_node(struct inode *ldirp,
|
|||
/* New inode acquired. Try to make directory entry. */
|
||||
if((r=search_dir(ldirp, string, &rip->i_num, ENTER, IGN_PERM)) != OK) {
|
||||
rip->i_nlinks--; /* pity, have to free disk inode */
|
||||
rip->i_dirt = DIRTY; /* dirty inodes are written out */
|
||||
IN_MARKDIRTY(rip); /* dirty inodes are written out */
|
||||
put_inode(rip); /* this call frees the inode */
|
||||
err_code = r;
|
||||
return(NULL);
|
||||
|
|
|
@ -561,9 +561,9 @@ int check_permissions; /* check permissions when flag is !IS_EMPTY */
|
|||
t = MFS_NAME_MAX - sizeof(ino_t);
|
||||
*((ino_t *) &dp->mfs_d_name[t]) = dp->mfs_d_ino;
|
||||
dp->mfs_d_ino = NO_ENTRY; /* erase entry */
|
||||
bp->b_dirt = DIRTY;
|
||||
MARKDIRTY(bp);
|
||||
ldir_ptr->i_update |= CTIME | MTIME;
|
||||
ldir_ptr->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(ldir_ptr);
|
||||
if (pos < ldir_ptr->i_last_dpos)
|
||||
ldir_ptr->i_last_dpos = pos;
|
||||
} else {
|
||||
|
@ -614,10 +614,10 @@ int check_permissions; /* check permissions when flag is !IS_EMPTY */
|
|||
for (i = 0; i < MFS_NAME_MAX && string[i]; i++) dp->mfs_d_name[i] = string[i];
|
||||
sp = ldir_ptr->i_sp;
|
||||
dp->mfs_d_ino = conv4(sp->s_native, (int) *numb);
|
||||
bp->b_dirt = DIRTY;
|
||||
MARKDIRTY(bp);
|
||||
put_block(bp, DIRECTORY_BLOCK);
|
||||
ldir_ptr->i_update |= CTIME | MTIME; /* mark mtime for update later */
|
||||
ldir_ptr->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(ldir_ptr);
|
||||
if (new_slots > old_slots) {
|
||||
ldir_ptr->i_size = (off_t) new_slots * DIR_ENTRY_SIZE;
|
||||
/* Send the change to disk if the directory is extended. */
|
||||
|
|
|
@ -25,7 +25,7 @@ PUBLIC int fs_chmod()
|
|||
/* Now make the change. Clear setgid bit if file is not in caller's grp */
|
||||
rip->i_mode = (rip->i_mode & ~ALL_MODES) | (mode & ALL_MODES);
|
||||
rip->i_update |= CTIME;
|
||||
rip->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(rip);
|
||||
|
||||
/* Return full new mode to caller. */
|
||||
fs_m_out.RES_MODE = rip->i_mode;
|
||||
|
@ -54,7 +54,7 @@ PUBLIC int fs_chown()
|
|||
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;
|
||||
IN_MARKDIRTY(rip);
|
||||
}
|
||||
|
||||
/* Update caller on current mode, as it may have changed. */
|
||||
|
|
|
@ -117,7 +117,7 @@ PUBLIC int fs_readwrite(void)
|
|||
if (r == OK) {
|
||||
if (rw_flag == READING) rip->i_update |= ATIME;
|
||||
if (rw_flag == WRITING) rip->i_update |= CTIME | MTIME;
|
||||
rip->i_dirt = DIRTY; /* inode is thus now dirty */
|
||||
IN_MARKDIRTY(rip); /* inode is thus now dirty */
|
||||
}
|
||||
|
||||
fs_m_out.RES_NBYTES = cum_io;
|
||||
|
@ -267,7 +267,7 @@ int *completed; /* number of bytes copied */
|
|||
/* Copy a chunk from user space to the block buffer. */
|
||||
r = sys_safecopyfrom(VFS_PROC_NR, gid, (vir_bytes) buf_off,
|
||||
(vir_bytes) (bp->b_data+off), (size_t) chunk, D);
|
||||
bp->b_dirt = DIRTY;
|
||||
MARKDIRTY(bp);
|
||||
}
|
||||
|
||||
n = (off + chunk == block_size ? FULL_DATA_BLOCK : PARTIAL_DATA_BLOCK);
|
||||
|
@ -643,7 +643,7 @@ PUBLIC int fs_getdents(void)
|
|||
fs_m_out.RES_NBYTES = userbuf_off;
|
||||
fs_m_out.RES_SEEK_POS_LO = new_pos;
|
||||
rip->i_update |= ATIME;
|
||||
rip->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(rip);
|
||||
r = OK;
|
||||
}
|
||||
|
||||
|
|
|
@ -88,7 +88,7 @@ bit_t origin; /* number of bit to start searching at */
|
|||
/* Allocate and return bit number. */
|
||||
k |= 1 << i;
|
||||
*wptr = (bitchunk_t) conv4(sp->s_native, (int) k);
|
||||
bp->b_dirt = DIRTY;
|
||||
MARKDIRTY(bp);
|
||||
put_block(bp, MAP_BLOCK);
|
||||
return(b);
|
||||
}
|
||||
|
@ -140,7 +140,7 @@ bit_t bit_returned; /* number of bit to insert into the map */
|
|||
|
||||
k &= ~mask;
|
||||
bp->b_bitmap[word] = (bitchunk_t) conv4(sp->s_native, (int) k);
|
||||
bp->b_dirt = DIRTY;
|
||||
MARKDIRTY(bp);
|
||||
|
||||
put_block(bp, MAP_BLOCK);
|
||||
}
|
||||
|
|
|
@ -22,7 +22,7 @@ PUBLIC int fs_utime()
|
|||
rip->i_atime = fs_m_in.REQ_ACTIME;
|
||||
rip->i_mtime = fs_m_in.REQ_MODTIME;
|
||||
rip->i_update = CTIME; /* discard any stale ATIME and MTIME flags */
|
||||
rip->i_dirt = DIRTY;
|
||||
IN_MARKDIRTY(rip);
|
||||
}
|
||||
|
||||
put_inode(rip);
|
||||
|
|
|
@ -35,7 +35,7 @@ struct buf {
|
|||
struct buf *b_hash; /* used to link bufs on hash chains */
|
||||
block_t b_blocknr; /* block number of its (minor) device */
|
||||
dev_t b_dev; /* major | minor device where block resides */
|
||||
char b_dirt; /* CLEAN or DIRTY */
|
||||
char b_dirt; /* BP_CLEAN or BP_DIRTY */
|
||||
char b_count; /* number of users of this buffer */
|
||||
unsigned int b_bytes; /* Number of bytes allocated in bp */
|
||||
};
|
||||
|
|
|
@ -44,7 +44,7 @@ int op; /* special actions */
|
|||
long excess, zone;
|
||||
struct buf *bp_dindir = NULL, *bp = NULL;
|
||||
|
||||
rip->i_dirt = DIRTY; /* inode will be changed */
|
||||
IN_MARKDIRTY(rip);
|
||||
scale = rip->i_sp->s_log_zone_size; /* for zone-block conversion */
|
||||
/* relative zone # to insert */
|
||||
zone = (position/rip->i_sp->s_block_size) >> scale;
|
||||
|
@ -119,7 +119,7 @@ int op; /* special actions */
|
|||
|
||||
new_ind = TRUE;
|
||||
/* If double ind, it is dirty. */
|
||||
if (bp_dindir != NULL) bp_dindir->b_dirt = DIRTY;
|
||||
if (bp_dindir != NULL) MARKDIRTY(bp_dindir);
|
||||
if (z1 == NO_ZONE) {
|
||||
/* Release dbl indirect blk. */
|
||||
put_block(bp_dindir, INDIRECT_BLOCK);
|
||||
|
@ -155,14 +155,14 @@ int op; /* special actions */
|
|||
rip->i_zone[zones] = z1;
|
||||
} else {
|
||||
wr_indir(bp_dindir, ind_ex, z1);
|
||||
bp_dindir->b_dirt = DIRTY;
|
||||
MARKDIRTY(bp_dindir);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
wr_indir(bp, ex, new_zone);
|
||||
}
|
||||
/* z1 equals NO_ZONE only when we are freeing up the indirect block. */
|
||||
bp->b_dirt = (z1 == NO_ZONE) ? CLEAN : DIRTY;
|
||||
if(z1 == NO_ZONE) { MARKCLEAN(bp); } else { MARKDIRTY(bp); }
|
||||
put_block(bp, INDIRECT_BLOCK);
|
||||
}
|
||||
|
||||
|
@ -172,7 +172,7 @@ int op; /* special actions */
|
|||
*/
|
||||
if(z1 == NO_ZONE && !single && z2 != NO_ZONE &&
|
||||
empty_indir(bp_dindir, rip->i_sp)) {
|
||||
bp_dindir->b_dirt = CLEAN;
|
||||
MARKCLEAN(bp_dindir);
|
||||
free_zone(rip->i_dev, z2);
|
||||
rip->i_zone[zones+1] = NO_ZONE;
|
||||
}
|
||||
|
@ -332,6 +332,6 @@ register struct buf *bp; /* pointer to buffer to zero */
|
|||
ASSERT(bp->b_bytes > 0);
|
||||
ASSERT(bp->bp);
|
||||
memset(bp->b_data, 0, (size_t) bp->b_bytes);
|
||||
bp->b_dirt = DIRTY;
|
||||
MARKDIRTY(bp);
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in a new issue