Subversion Repositories shark

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include <fs/types.h>
#include <fs/errno.h>
#include <fs/task.h>
#include <fs/maccess.h>
#include <fs/stat.h>
#include <fs/fcntl.h>
#include <fs/mount.h>

#include "fsconst.h"
#include "file.h"
#include "dentry.h"
#include "inode.h"
#include "fileop.h"
#include "inodeop.h"
#include "super.h"
#include "fs.h"

#include "debug.h"


/*
  Example of how the code is expanded in system with/without
  memory protection.
 
  If DUMMY_MACCESS is defined:
 
  char *pathname;
  int len;

  len=1;
  if ((!len)||len>MAXSIZE) return -EVERIFY;
  pathname=userpathname;
  ...


  if DUMMY_MACCESS is NOT defined:
 
  char pathname[MAXSIZE];
  int len;

  len=verifyreadnolen(userpathanme);
  if ((!len)||len>MAXSIZE) return -EVERIFY;
  memcpyfromuser(pathname,userpathname);
  ...

*/

/* PS: open() e opendir() potrebbero condividere codice! */

int k_open(char *upathname, int oflag, int mode)
{
  declare_buffer(char,pathname,MAXPATHNAME);
  int len;
  struct file   *f;
  struct dentry *d;
  int           ret,res,createflag;
  __pid_t       pid;

  call_to_fs();
 
  printk0("k_open: START");
  pid=__get_pid();
 
  len=__verify_read_nolen((char*)upathname);
  if ((!len)||(len>MAXPATHNAMELEN)) return_from_fs(-EVERIFY);
  __copy_from_user(pathname,upathname,len+1);

  printk0("k_open: verifing memory... done");
 
  /* flags not supported */
  /* O_NOCTTY is ignored */
  if (oflag&O_DSYNC||
      oflag&O_NOCTTY||
      oflag&O_NONBLOCK||
      oflag&O_RSYNC||
      oflag&O_SYNC) {
    return_from_fs(-EACCES);
  }

  /* O_TRUNC wiht O_RDONLY not permitted! */
  if ((oflag&O_RDONLY)&&(oflag&O_TRUNC)) return_from_fs(-EACCES);
 
  printk0("k_open: checking flags... done");
 
  if (oflag&O_CREAT) {
    if (oflag&O_EXCL) createflag=DENTRY_MUSTCREATE;
    else createflag=DENTRY_CANCREATE;
  } else createflag=DENTRY_NOCREATE;

 
  d=find_dentry_from_ext(cwden_ptr(pid),(char *)pathname,&createflag);
  if (d==NULL) {
    printk0("k_open: can't find/create directory entry");
    if (createflag&DENTRY_EXIST) return_from_fs(-EEXIST);
    return_from_fs(-ENOENT);
  }
 
  if (__S_ISDIR(d->d_inode->i_st.st_mode)) {
    if (oflag&O_WRONLY||oflag&O_RDWR)
      /* can't write on a directory */
      return_from_fs(-EISDIR);
  }
 
  /* check for read-only filesystem */
  if (!(d->d_sb->sb_mopts.flags&MOUNT_FLAG_RW)) {
    if (oflag&O_WRONLY||oflag&O_RDWR||oflag&O_TRUNC) {
      /* NB: O_CREAT va testata prima della find_dentry() */
      unlock_dentry(d);      
      return_from_fs(-EROFS);
    }
  }
 
  printk0("k_open: find dir entry... done");

  f=get_file(d->d_inode);
  if (f==NULL) {
    unlock_dentry(d);
    return_from_fs(-ENFILE);
  }

  printk0("k_open: getting system file entry... done");

  if (createflag&DENTRY_CREATED)
    d->d_inode->i_st.st_mode=(mode&__ALLPERMS)|__S_IFREG;
 
  f->f_dentry=d;
  f->f_op=d->d_inode->i_op->default_file_ops;
  f->f_pos=0;
  f->f_flag_isdir=__S_ISDIR(d->d_inode->i_st.st_mode);
 
  ret=get_fd(pid,f);
  if (ret==-1) {
    free_file(f);
    unlock_dentry(d);
    return_from_fs(-EMFILE);
  }
  *fildesfflags_ptr(pid,ret)=oflag;

  printk0("k_open: getting file descriptor... done");

  if (oflag&O_TRUNC&&!(createflag&DENTRY_CREATED)) {
    struct inode *in=file_ptr(pid,ret)->f_dentry->d_inode;
    /* acquire write lock on inode's file */
    __rwlock_wrlock(&in->i_lock);
    /* truncate the file */
    in->i_op->truncate(in,0);      
    /* release write lock on inode's file */
    __rwlock_wrunlock(&in->i_lock);
    printk0("k_open: file truncation... done");
  }
 
  res=f->f_op->open(f->f_dentry->d_inode,f);
  if (res!=0) {
    free_fd(pid,ret);
    free_file(f);
    unlock_dentry(d);
    return_from_fs(res);
  }

  printk0("k_open: called proper filesystem open... done");

  printk0("k_open: END");
  return_from_fs(ret);
}