Linux 内核源代码情景分析（四）（下）

// fs/ext2/file.c
struct file_operations ext2_file_operations = {
  llseek:   ext2_file_lseek,
  read:   generic_file_read,
  write:    generic_file_write,
  ioctl:    ext2_ioctl,
  mmap:   generic_file_mmap,
  open:   ext2_open_file,
  release:  ext2_release_file,
  fsync:    ext2_sync_file,
};

// =================================================================================
// mm/filemap.c
/*
 * Write to a file through the page cache. 
 *
 * We currently put everything into the page cache prior to writing it.
 * This is not a problem when writing full pages. With partial pages,
 * however, we first have to read the data into the cache, then
 * dirty the page, and finally schedule it for writing. Alternatively, we
 * could write-through just the portion of data that would go into that
 * page, but that would kill performance for applications that write data
 * line by line, and it's prone to race conditions.
 *
 * Note that this routine doesn't try to keep track of dirty pages. Each
 * file system has to do this all by itself, unfortunately.
 *              okir@monad.swb.de
 */
ssize_t
generic_file_write(struct file *file,const char *buf,size_t count,loff_t *ppos)
{
  struct inode  *inode = file->f_dentry->d_inode; 
  struct address_space *mapping = inode->i_mapping;
  unsigned long limit = current->rlim[RLIMIT_FSIZE].rlim_cur;
  loff_t    pos;
  struct page *page, *cached_page;
  unsigned long written;
  long    status;
  int   err;

  cached_page = NULL;

  down(&inode->i_sem);

  pos = *ppos;
  err = -EINVAL;
  if (pos < 0)
    goto out;

  err = file->f_error;
  if (err) {
    file->f_error = 0;
    goto out;
  }

  written = 0;

  if (file->f_flags & O_APPEND)
    pos = inode->i_size;

  /*
   * Check whether we've reached the file size limit.
   */
  err = -EFBIG;
  if (limit != RLIM_INFINITY) {
    if (pos >= limit) {
      send_sig(SIGXFSZ, current, 0);
      goto out;
    }
    if (count > limit - pos) {
      send_sig(SIGXFSZ, current, 0);
      count = limit - pos;
    }
  }

  status  = 0;
  if (count) {
    remove_suid(inode);
    inode->i_ctime = inode->i_mtime = CURRENT_TIME;
    mark_inode_dirty_sync(inode);
  }

  while (count) {
    unsigned long bytes, index, offset;
    char *kaddr;
    int deactivate = 1;

    /*
     * Try to find the page in the cache. If it isn't there,
     * allocate a free page.
     */
    offset = (pos & (PAGE_CACHE_SIZE -1)); /* Within page */
    index = pos >> PAGE_CACHE_SHIFT;
    bytes = PAGE_CACHE_SIZE - offset;
    if (bytes > count) {
      bytes = count;
      deactivate = 0;
    }

    /*
     * Bring in the user page that we will copy from _first_.
     * Otherwise there's a nasty deadlock on copying from the
     * same page as we're writing to, without it being marked
     * up-to-date.
     */
    { volatile unsigned char dummy;
      __get_user(dummy, buf);
      __get_user(dummy, buf+bytes-1);
    }

    status = -ENOMEM; /* we'll assign it later anyway */
    page = __grab_cache_page(mapping, index, &cached_page);
    if (!page)
      break;

    /* We have exclusive IO access to the page.. */
    if (!PageLocked(page)) {
      PAGE_BUG(page);
    }

    status = mapping->a_ops->prepare_write(file, page, offset, offset+bytes);
    if (status)
      goto unlock;
    kaddr = page_address(page);
    status = copy_from_user(kaddr+offset, buf, bytes);
    flush_dcache_page(page);
    if (status)
      goto fail_write;
    status = mapping->a_ops->commit_write(file, page, offset, offset+bytes);
    if (!status)
      status = bytes;

    if (status >= 0) {
      written += status;
      count -= status;
      pos += status;
      buf += status;
    }
unlock:
    /* Mark it unlocked again and drop the page.. */
    UnlockPage(page);
    if (deactivate)
      deactivate_page(page);
    page_cache_release(page);

    if (status < 0)
      break;
  }
  *ppos = pos;

  if (cached_page)
    page_cache_free(cached_page);

  /* For now, when the user asks for O_SYNC, we'll actually
   * provide O_DSYNC. */
  if ((status >= 0) && (file->f_flags & O_SYNC))
    status = generic_osync_inode(inode, 1); /* 1 means datasync */
  
  err = written ? written : status;
out:

  up(&inode->i_sem);
  return err;
fail_write:
  status = -EFAULT;
  ClearPageUptodate(page);
  kunmap(page);
  goto unlock;
}

// include/linux/fs.h
struct address_space {
  struct list_head  clean_pages;  /* list of clean pages */
  struct list_head  dirty_pages;  /* list of dirty pages */
  struct list_head  locked_pages; /* list of locked pages */
  unsigned long   nrpages;  /* number of total pages */
  struct address_space_operations *a_ops; /* methods */
  struct inode    *host;    /* owner: inode, block_device */
  struct vm_area_struct *i_mmap;  /* list of private mappings */
  struct vm_area_struct *i_mmap_shared; /* list of shared mappings */
  spinlock_t    i_shared_lock;  /* and spinlock protecting it */
};

struct address_space_operations {
  int (*writepage)(struct page *);
  int (*readpage)(struct file *, struct page *);
  int (*sync_page)(struct page *);
  int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);
  int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
  /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
  int (*bmap)(struct address_space *, long);
};

// fs/ext2/inode.c
static int ext2_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
{
  return block_prepare_write(page,from,to,ext2_get_block);
}

// =================================================================================
// fs/buffer.c
int block_prepare_write(struct page *page, unsigned from, unsigned to,
      get_block_t *get_block)
{
  struct inode *inode = page->mapping->host;
  int err = __block_prepare_write(inode, page, from, to, get_block);
  if (err) {
    ClearPageUptodate(page);
    kunmap(page);
  }
  return err;
}

static int __block_prepare_write(struct inode *inode, struct page *page,
    unsigned from, unsigned to, get_block_t *get_block)
{
  unsigned block_start, block_end;
  unsigned long block;
  int err = 0;
  unsigned blocksize, bbits;
  struct buffer_head *bh, *head, *wait[2], **wait_bh=wait;
  char *kaddr = kmap(page);

  blocksize = inode->i_sb->s_blocksize;
  if (!page->buffers)
    create_empty_buffers(page, inode->i_dev, blocksize);
  head = page->buffers;

  bbits = inode->i_sb->s_blocksize_bits;
  block = page->index << (PAGE_CACHE_SHIFT - bbits);

  for(bh = head, block_start = 0; bh != head || !block_start;
      block++, block_start=block_end, bh = bh->b_this_page) {
    if (!bh)
      BUG();
    block_end = block_start+blocksize;
    if (block_end <= from)
      continue;
    if (block_start >= to)
      break;
    if (!buffer_mapped(bh)) {
      err = get_block(inode, block, bh, 1);
      if (err)
        goto out;
      if (buffer_new(bh)) {
        unmap_underlying_metadata(bh);
        if (Page_Uptodate(page)) {
          set_bit(BH_Uptodate, &bh->b_state);
          continue;
        }
        if (block_end > to)
          memset(kaddr+to, 0, block_end-to);
        if (block_start < from)
          memset(kaddr+block_start, 0, from-block_start);
        if (block_end > to || block_start < from)
          flush_dcache_page(page);
        continue;
      }
    }
    if (Page_Uptodate(page)) {
      set_bit(BH_Uptodate, &bh->b_state);
      continue; 
    }
    if (!buffer_uptodate(bh) &&
         (block_start < from || block_end > to)) {
      ll_rw_block(READ, 1, &bh);
      *wait_bh++=bh;
    }
  }
  /*
   * If we issued read requests - let them complete.
   */
  while(wait_bh > wait) {
    wait_on_buffer(*--wait_bh);
    err = -EIO;
    if (!buffer_uptodate(*wait_bh))
      goto out;
  }
  return 0;
out:
  return err;
}

// fs/ext2/inode.c
/*
 * Allocation strategy is simple: if we have to allocate something, we will
 * have to go the whole way to leaf. So let's do it before attaching anything
 * to tree, set linkage between the newborn blocks, write them if sync is
 * required, recheck the path, free and repeat if check fails, otherwise
 * set the last missing link (that will protect us from any truncate-generated
 * removals - all blocks on the path are immune now) and possibly force the
 * write on the parent block.
 * That has a nice additional property: no special recovery from the failed
 * allocations is needed - we simply release blocks and do not touch anything
 * reachable from inode.
 */

static int ext2_get_block(struct inode *inode, long iblock, struct buffer_head *bh_result, int create)
{
  int err = -EIO;
  int offsets[4];
  Indirect chain[4];
  Indirect *partial;
  unsigned long goal;
  int left;
  int depth = ext2_block_to_path(inode, iblock, offsets);

  if (depth == 0)
    goto out;

  lock_kernel();
reread:
  partial = ext2_get_branch(inode, depth, offsets, chain, &err);

  /* Simplest case - block found, no allocation needed */
  if (!partial) {
got_it:
    bh_result->b_dev = inode->i_dev;
    bh_result->b_blocknr = le32_to_cpu(chain[depth-1].key);
    bh_result->b_state |= (1UL << BH_Mapped);
    /* Clean up and exit */
    partial = chain+depth-1; /* the whole chain */
    goto cleanup;
  }

  /* Next simple case - plain lookup or failed read of indirect block */
  if (!create || err == -EIO) {
cleanup:
    while (partial > chain) {
      brelse(partial->bh);
      partial--;
    }
    unlock_kernel();
out:
    return err;
  }

  /*
   * Indirect block might be removed by truncate while we were
   * reading it. Handling of that case (forget what we've got and
   * reread) is taken out of the main path.
   */
  if (err == -EAGAIN)
    goto changed;

  if (ext2_find_goal(inode, iblock, chain, partial, &goal) < 0)
    goto changed;

  left = (chain + depth) - partial;
  err = ext2_alloc_branch(inode, left, goal,
          offsets+(partial-chain), partial);
  if (err)
    goto cleanup;

  if (ext2_splice_branch(inode, iblock, chain, partial, left) < 0)
    goto changed;

  bh_result->b_state |= (1UL << BH_New);
  goto got_it;

changed:
  while (partial > chain) {
    bforget(partial->bh);
    partial--;
  }
  goto reread;
}

// fs/ext2/inode.c
static int ext2_block_to_path(struct inode *inode, long i_block, int offsets[4])
{
  int ptrs = EXT2_ADDR_PER_BLOCK(inode->i_sb);
  int ptrs_bits = EXT2_ADDR_PER_BLOCK_BITS(inode->i_sb);
  const long direct_blocks = EXT2_NDIR_BLOCKS,
    indirect_blocks = ptrs,
    double_blocks = (1 << (ptrs_bits * 2));
  int n = 0;

  if (i_block < 0) {
    ext2_warning (inode->i_sb, "ext2_block_to_path", "block < 0");
  } else if (i_block < direct_blocks) {
    offsets[n++] = i_block;
  } else if ( (i_block -= direct_blocks) < indirect_blocks) {
    offsets[n++] = EXT2_IND_BLOCK;
    offsets[n++] = i_block;
  } else if ((i_block -= indirect_blocks) < double_blocks) {
    offsets[n++] = EXT2_DIND_BLOCK;
    offsets[n++] = i_block >> ptrs_bits;
    offsets[n++] = i_block & (ptrs - 1);
  } else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
    offsets[n++] = EXT2_TIND_BLOCK;
    offsets[n++] = i_block >> (ptrs_bits * 2);
    offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
    offsets[n++] = i_block & (ptrs - 1);
  } else {
    ext2_warning (inode->i_sb, "ext2_block_to_path", "block > big");
  }
  return n;
}

// fs/ext2/inode.c
/**
 *  ext2_get_branch - read the chain of indirect blocks leading to data
 *  @inode: inode in question
 *  @depth: depth of the chain (1 - direct pointer, etc.)
 *  @offsets: offsets of pointers in inode/indirect blocks
 *  @chain: place to store the result
 *  @err: here we store the error value
 *
 *  Function fills the array of triples <key, p, bh> and returns %NULL
 *  if everything went OK or the pointer to the last filled triple
 *  (incomplete one) otherwise. Upon the return chain[i].key contains
 *  the number of (i+1)-th block in the chain (as it is stored in memory,
 *  i.e. little-endian 32-bit), chain[i].p contains the address of that
 *  number (it points into struct inode for i==0 and into the bh->b_data
 *  for i>0) and chain[i].bh points to the buffer_head of i-th indirect
 *  block for i>0 and NULL for i==0. In other words, it holds the block
 *  numbers of the chain, addresses they were taken from (and where we can
 *  verify that chain did not change) and buffer_heads hosting these
 *  numbers.
 *
 *  Function stops when it stumbles upon zero pointer (absent block)
 *    (pointer to last triple returned, *@err == 0)
 *  or when it gets an IO error reading an indirect block
 *    (ditto, *@err == -EIO)
 *  or when it notices that chain had been changed while it was reading
 *    (ditto, *@err == -EAGAIN)
 *  or when it reads all @depth-1 indirect blocks successfully and finds
 *  the whole chain, all way to the data (returns %NULL, *err == 0).
 */
static inline Indirect *ext2_get_branch(struct inode *inode,
          int depth,
          int *offsets,
          Indirect chain[4],
          int *err)
{
  kdev_t dev = inode->i_dev;
  int size = inode->i_sb->s_blocksize;
  Indirect *p = chain;
  struct buffer_head *bh;

  *err = 0;
  /* i_data is not going away, no lock needed */
  add_chain (chain, NULL, inode->u.ext2_i.i_data + *offsets);
  if (!p->key)
    goto no_block;
  while (--depth) {
    bh = bread(dev, le32_to_cpu(p->key), size);
    if (!bh)
      goto failure;
    /* Reader: pointers */
    if (!verify_chain(chain, p))
      goto changed;
    add_chain(++p, bh, (u32*)bh->b_data + *++offsets);
    /* Reader: end */
    if (!p->key)
      goto no_block;
  }
  return NULL;

changed:
  *err = -EAGAIN;
  goto no_block;
failure:
  *err = -EIO;
no_block:
  return p;
}

// // fs/ext2/file.c
ssize_t
generic_file_write(struct file *file,const char *buf,size_t count,loff_t *ppos)
{
  // ...
    status = mapping->a_ops->prepare_write(file, page, offset, offset+bytes);
    if (status)
      goto unlock;
    kaddr = page_address(page);
    status = copy_from_user(kaddr+offset, buf, bytes);
    flush_dcache_page(page);
    if (status)
      goto fail_write;
    status = mapping->a_ops->commit_write(file, page, offset, offset+bytes);
  // ...
}