Minix1.5/fs/write.c

Compare this file to the similar file:
Show the results in this format: 

/* This file is the counterpart of "read.c".  It contains the code for writing
 * insofar as this is not contained in read_write().
 *
 * The entry points into this file are
 *   do_write:     call read_write to perform the WRITE system call
 *   write_map:    add a new zone to an inode
 *   clear_zone:   erase a zone in the middle of a file
 *   new_block:    acquire a new block
 */

#include "fs.h"
#include "buf.h"
#include "file.h"
#include "fproc.h"
#include "inode.h"
#include "super.h"

FORWARD int write_map();

/*===========================================================================*
 *				do_write				     *
 *===========================================================================*/
PUBLIC int do_write()
{
/* Perform the write(fd, buffer, nbytes) system call. */
  return(read_write(WRITING));
}


/*===========================================================================*
 *				write_map				     *
 *===========================================================================*/
PRIVATE int write_map(rip, position, new_zone)
register struct inode *rip;	/* pointer to inode to be changed */
off_t position;			/* file address to be mapped */
zone_nr new_zone;		/* zone # to be inserted */
{
/* Write a new zone into an inode. */
  int scale;
  zone_nr z, *zp;
  register block_nr b;
  long excess, zone;
  int index;
  struct buf *bp;
  int new_ind, new_dbl;

  rip->i_dirt = DIRTY;		/* inode will be changed */
  bp = NIL_BUF;
  scale = scale_factor(rip);	/* for zone-block conversion */
  zone = (position/BLOCK_SIZE) >> scale;	/* relative zone # to insert */

  /* Is 'position' to be found in the inode itself? */
  if (zone < NR_DZONE_NUM) {
	rip->i_zone[(int) zone] = new_zone;
	rip->i_update = MTIME;	/* mark mtime for update later */
	return(OK);
  }

  /* It is not in the inode, so it must be single or double indirect. */
  excess = zone - NR_DZONE_NUM;	/* first NR_DZONE_NUM don't count */
  new_ind = FALSE;
  new_dbl = FALSE;

  if (excess < NR_INDIRECTS) {
	/* 'position' can be located via the single indirect block. */
	zp = &rip->i_zone[NR_DZONE_NUM];
  } else {
	/* 'position' can be located via the double indirect block. */
	if ( (z = rip->i_zone[NR_DZONE_NUM+1]) == NO_ZONE) {
		/* Create the double indirect block. */
		if ( (z = alloc_zone(rip->i_dev, rip->i_zone[0])) == NO_ZONE)
			return(err_code);
		rip->i_zone[NR_DZONE_NUM+1] = z;
		new_dbl = TRUE;	/* set flag for later */
	}

	/* Either way, 'z' is zone number for double indirect block. */
	excess -= NR_INDIRECTS;	/* single indirect doesn't count */
	index = excess / NR_INDIRECTS;
	excess = excess % NR_INDIRECTS;
	if (index >= NR_INDIRECTS) return(EFBIG);
	b = (block_nr) z << scale;
	bp = get_block(rip->i_dev, b, (new_dbl ? NO_READ : NORMAL));
	if (new_dbl) zero_block(bp);
	zp= &bp->b_ind[index];
  }

  /* 'zp' now points to place where indirect zone # goes; 'excess' is index. */
  if (*zp == NO_ZONE) {
	/* Create indirect block. */
	*zp = alloc_zone(rip->i_dev, rip->i_zone[0]);
	new_ind = TRUE;
	if (bp != NIL_BUF) bp->b_dirt = DIRTY;	/* if double ind, it is dirty */
	if (*zp == NO_ZONE) {
		put_block(bp, INDIRECT_BLOCK);	/* release dbl indirect blk */
		return(err_code);	/* couldn't create single ind */
	}
  }
  put_block(bp, INDIRECT_BLOCK);	/* release double indirect blk */

  /* 'zp' now points to indirect block's zone number. */
  b = (block_nr) *zp << scale;
  bp = get_block(rip->i_dev, b, (new_ind ? NO_READ : NORMAL) );
  if (new_ind) zero_block(bp);
  bp->b_ind[(int) excess] = new_zone;
  rip->i_update = MTIME;		/* mark mtime for update later */
  bp->b_dirt = DIRTY;
  put_block(bp, INDIRECT_BLOCK);

  return(OK);
}

/*===========================================================================*
 *				clear_zone				     *
 *===========================================================================*/
PUBLIC void clear_zone(rip, pos, flag)
register struct inode *rip;	/* inode to clear */
off_t pos;			/* points to block to clear */
int flag;			/* 0 if called by read_write, 1 by new_block */
{
/* Zero a zone, possibly starting in the middle.  The parameter 'pos' gives
 * a byte in the first block to be zeroed.  Clearzone() is called from 
 * read_write and new_block().
 */

  register struct buf *bp;
  register block_nr b, blo, bhi;
  register off_t next;
  register int scale;
  register zone_type zone_size;

  /* If the block size and zone size are the same, clear_zone() not needed. */
  if ( (scale = scale_factor(rip)) == 0) return;


  zone_size = (zone_type) BLOCK_SIZE << scale;
  if (flag == 1) pos = (pos/zone_size) * zone_size;
  next = pos + 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;

  /* Clear all the blocks between 'blo' and 'bhi'. */
  for (b = blo; b <= bhi; b++) {
	bp = get_block(rip->i_dev, b, NO_READ);
	zero_block(bp);
	put_block(bp, FULL_DATA_BLOCK);
  }
}


/*===========================================================================*
 *				new_block				     *
 *===========================================================================*/
PUBLIC struct buf *new_block(rip, position)
register struct inode *rip;	/* pointer to inode */
off_t position;			/* file pointer */
{
/* Acquire a new block and return a pointer to it.  Doing so may require
 * allocating a complete zone, and then returning the initial block.
 * On the other hand, the current zone may still have some unused blocks.
 */

  register struct buf *bp;
  block_nr b, base_block;
  zone_nr z;
  zone_type zone_size;
  int scale, r;
  struct super_block *sp;

  /* Is another block available in the current zone? */
  if ( (b = read_map(rip, position)) == NO_BLOCK) {
	/* Choose first zone if need be. */
	if (rip->i_size == 0) {
		sp = get_super(rip->i_dev);
		z = sp->s_firstdatazone;
	} else {
		z = rip->i_zone[0];
	}
	if ( (z = alloc_zone(rip->i_dev, z)) == NO_ZONE) return(NIL_BUF);
	if ( (r = write_map(rip, position, z)) != OK) {
		free_zone(rip->i_dev, z);
		err_code = r;
		return(NIL_BUF);
	}

	/* If we are not writing at EOF, clear the zone, just to be safe. */
	if ( position != rip->i_size) clear_zone(rip, position, 1);
	scale = scale_factor(rip);
	base_block = (block_nr) z << scale;
	zone_size = (zone_type) BLOCK_SIZE << scale;
	b = base_block + (block_nr)((position % zone_size)/BLOCK_SIZE);
  }

  bp = get_block(rip->i_dev, b, NO_READ);
  zero_block(bp);
  return(bp);
}


/*===========================================================================*
 *				zero_block				     *
 *===========================================================================*/
PUBLIC void zero_block(bp)
register struct buf *bp;	/* pointer to buffer to zero */
{
/* Zero a block. */

  register int n;
  register int *zip;

  n = INTS_PER_BLOCK;		/* number of integers in a block */
  zip = bp->b_int;		/* where to start clearing */

  do { *zip++ = 0;}  while (--n);
  bp->b_dirt = DIRTY;
}