/*
       *  linux/fs/ext2/file.c
       *
       * Copyright (C) 1992, 1993, 1994, 1995
       * Remy Card (card@masi.ibp.fr)
       * Laboratoire MASI - Institut Blaise Pascal
       * Universite Pierre et Marie Curie (Paris VI)
       *
       *  from
       *
       *  linux/fs/minix/file.c
       *
       *  Copyright (C) 1991, 1992  Linus Torvalds
       *
       *  ext2 fs regular file handling primitives
       *
       *  64-bit file support on 64-bit platforms by Jakub Jelinek
       * 	(jj@sunsite.ms.mff.cuni.cz)
       */
      
      #include <linux/fs.h>
  22  #include <linux/ext2_fs.h>
      #include <linux/sched.h>
      
      static loff_t ext2_file_lseek(struct file *, loff_t, int);
      static int ext2_open_file (struct inode *, struct file *);
  27  
      #define EXT2_MAX_SIZE(bits)							\
  29  	(((EXT2_NDIR_BLOCKS + (1LL << (bits - 2)) + 				\
      	   (1LL << (bits - 2)) * (1LL << (bits - 2)) + 				\
  31  	   (1LL << (bits - 2)) * (1LL << (bits - 2)) * (1LL << (bits - 2))) * 	\
      	  (1LL << bits)) - 1)
      
  34  static long long ext2_max_sizes[] = {
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
      EXT2_MAX_SIZE(10), EXT2_MAX_SIZE(11), EXT2_MAX_SIZE(12), EXT2_MAX_SIZE(13)
      };
  38  
      /*
  40   * Make sure the offset never goes beyond the 32-bit mark..
       */
      static loff_t ext2_file_lseek(
  43  	struct file *file,
  44  	loff_t offset,
  45  	int origin)
      {
  47  	struct inode *inode = file->f_dentry->d_inode;
      
      	switch (origin) {
      		case 2:
      			offset += inode->i_size;
      			break;
      		case 1:
      			offset += file->f_pos;
      	}
  56  	if (offset<0)
      		return -EINVAL;
      	if (((unsigned long long) offset >> 32) != 0) {
      		if (offset > ext2_max_sizes[EXT2_BLOCK_SIZE_BITS(inode->i_sb)])
      			return -EINVAL;
      	} 
      	if (offset != file->f_pos) {
  63  		file->f_pos = offset;
  64  		file->f_reada = 0;
      		file->f_version = ++event;
      	}
  67  	return offset;
      }
      
      /*
       * Called when an inode is released. Note that this is different
       * from ext2_file_open: open gets called at every open, but release
       * gets called only when /all/ the files are closed.
  74   */
      static int ext2_release_file (struct inode * inode, struct file * filp)
  76  {
      	if (filp->f_mode & FMODE_WRITE)
      		ext2_discard_prealloc (inode);
      	return 0;
  80  }
      
  82  /*
       * Called when an inode is about to be open.
  84   * We use this to disallow opening RW large files on 32bit systems if
       * the caller didn't specify O_LARGEFILE.  On 64bit systems we force
       * on this flag in sys_open.
  87   */
      static int ext2_open_file (struct inode * inode, struct file * filp)
      {
      	if (!(filp->f_flags & O_LARGEFILE) &&
      	    inode->i_size > 0x7FFFFFFFLL)
  92  		return -EFBIG;
  93  	return 0;
      }
      
      /*
  97   * We have mostly NULL's here: the current defaults are ok for
       * the ext2 filesystem.
       */
      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,
 106  	open:		ext2_open_file,
      	release:	ext2_release_file,
      	fsync:		ext2_sync_file,
      };
      
      struct inode_operations ext2_file_inode_operations = {
 112  	truncate:	ext2_truncate,
      };