file.c

Solaris操作系统下的过滤驱动程序, C源码程序.

	fist_dprint(6, "IOCTL SET: got arg %d\n", val);
	if (val < 0 || val > 20) {
	    err = -EINVAL;
	    break;
	}
	fist_set_debug_value(val);
	break;
#endif /* FIST_DEBUG */
#ifdef FIST_FILTER_SCA
    case FIST_IOCTL_GET_FAST_TAIL_VALUE:
	val = (stopd(inode->i_sb)->sca_flags != 0);
	printk("IOCTL GET: send arg %d\n", val);
	err = put_user(val, (int *) arg);
	break;

#ifdef FIST_FAST_TAILS
    case FIST_IOCTL_SET_FAST_TAIL_VALUE:
	err = get_user(val, (int *) arg);
	if (err)
	    break;
	fist_dprint(6, "IOCTL SET: got arg %d\n", val);
	if (val == 1) {
	    stopd(inode->i_sb)->sca_flags |= SCA_FLAG_FASTTAIL;
	} else if (val == 0) {
	    stopd(inode->i_sb)->sca_flags &= ~SCA_FLAG_FASTTAIL;
	} else {
	    err = -EINVAL;
	}
	break;
#endif /* FIST_FAST_TAILS */
#endif /* FIST_FILTER_SCA */

    /* add non-debugging fist ioctl's here */
FIST_IOCTL_ECLS

    default:
	hidden_file = ftohf(file);
	/* pass operation to hidden filesystem, and return status */
	if (hidden_file->f_op && hidden_file->f_op->ioctl)
	    err = hidden_file->f_op->ioctl(itohi(inode), hidden_file, cmd, arg);
    } /* end of outer switch statement */

    print_exit_status(err);
    return err;
}


#ifdef not_needed
STATIC int
wrapfs_mmap(file_t *file, vm_area_t *vma)
{
    int err = 0;
    file_t *hidden_file = ftohf(file);
    inode_t *inode = file->f_dentry->d_inode;
    inode_t *hidden_inode = itohi(inode);
    vm_area_t *hidden_vma = (vm_area_t *) 0xdeadc0de;

    print_entry_location();

    fist_dprint(6, "MMAP1: inode 0x%x, hidden_inode 0x%x, inode->i_count %d, hidden_inode->i_count %d\n",
		(int) inode, (int) hidden_inode, (int) inode->i_count, (int) hidden_inode->i_count);

    if (!hidden_file->f_op || !hidden_file->f_op->mmap) {
	err = -ENODEV;
	goto out;
    }

    /*
     * Most of this code comes straight from generic_file_mmap
     * in mm/filemap.c.
     */
    if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE)) {
	vma->vm_ops = &wrapfs_shared_vmops;
    } else {
	vma->vm_ops = &wrapfs_private_vmops;
    }
    if (!inode->i_sb || !S_ISREG(inode->i_mode)) {
	err = -EACCES;
	goto out;
    }
    if (!hidden_inode->i_op || !hidden_inode->i_mapping->a_ops->readpage) {
	err = -ENOEXEC;
	goto out;
    }
    UPDATE_ATIME(inode);

    /*
     * Now we do the hidden stuff, but only for shared maps.
     */
    if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE)) {
	hidden_vma = kmalloc(sizeof(vm_area_t), GFP_KERNEL);
	if (!hidden_vma) {
	    printk("MMAP: Out of memory\n");
	    err = -ENOMEM;
	    goto out;
	}
	// ION, is this right?
	memcpy(hidden_vma, vma, sizeof(vm_area_t));
	vmatohvma(vma) = hidden_vma;
	err = hidden_file->f_op->mmap(hidden_file, hidden_vma);
	hidden_vma->vm_file = hidden_file;
	atomic_inc(&hidden_file->f_count);
    }

    /*
     * XXX: do we need to insert_vm_struct and merge_segments as is
     * done in do_mmap()?
     */
 out:
    fist_dprint(6, "MMAP2: inode 0x%x, hidden_inode 0x%x, inode->i_count %d, hidden_inode->i_count %d\n",
		(int) inode, (int) hidden_inode, (int) inode->i_count, (int) hidden_inode->i_count);
#if 0
    if (!err) {
	inode->i_mmap = vma;
	hidden_inode->i_mmap = hidden_vma;
    }
#endif
    print_exit_status(err);
    return err;
}
#endif /* not_needed */


STATIC int
wrapfs_open(inode_t *inode, file_t *file)
{
    int err = 0;
    int hidden_mode, hidden_flags;
    file_t *hidden_file;
    dentry_t *hidden_dentry = wrapfs_hidden_dentry(file->f_dentry);

    print_entry_location();
    fist_print_dentry(__FUNCTION__ " IN hidden_dentry", hidden_dentry);

    dget(hidden_dentry);

    hidden_flags = file->f_flags;
#ifdef FIST_FILTER_DATA
    hidden_mode = file->f_mode | FMODE_READ;
    if (file->f_flags & O_APPEND) {
	fist_dprint(5, "file is opened in append-only mode\n");
	hidden_flags &= ~O_APPEND; /* turn off O_APPEND flag */
    }
#else /* not FIST_FILTER_DATA */
    hidden_mode = file->f_mode;
#endif /* not FIST_FILTER_DATA */

    /*
     * dentry_open will decrement mnt refcnt if err.
     * otherwise fput() will do an mntput() for us upon file close.
     */
    mntget(stopd(inode->i_sb)->hidden_mnt);
    hidden_file = dentry_open(hidden_dentry, stopd(inode->i_sb)->hidden_mnt, hidden_mode, hidden_flags);
    if (IS_ERR(hidden_file)) {
	err = PTR_ERR(hidden_file);
	goto out;
    }

    ftohf(file) = hidden_file;	/* link two files */

 out:
    fist_print_dentry(__FUNCTION__ " OUT hidden_dentry", hidden_dentry);
    print_exit_status(err);
    return err;
}


STATIC int
wrapfs_flush(file_t *file)
{
    int err = 0;		/* assume ok (see open.c:close_fp) */
    file_t *hidden_file = ftohf(file);

    print_entry_location();

    if (!hidden_file->f_op || !hidden_file->f_op->flush)
	goto out;

    err = hidden_file->f_op->flush(hidden_file);

out:
    print_exit_status(err);
    return err;
}


STATIC int
wrapfs_release(inode_t *inode, file_t *file)
{
    int err = 0;
    file_t *hidden_file = ftohf(file);
    dentry_t *hidden_dentry;

    print_entry_location();
    ASSERT(hidden_file != NULL);

    fist_print_dentry("wrapfs_release IN hidden_dentry", hidden_file->f_dentry);
    fist_checkinode(inode, "wrapfs_release");
    fist_dprint(6, "wrapfs_release IN, file->f_count=%d\n", file->f_count);
    /*
     * will decrement file refcount, and if 0, destroy the file,
     * which will call the lower file system's file release function.
     */
    hidden_dentry = hidden_file->f_dentry;
    fput(hidden_file);

    fist_dprint(6, "wrapfs_release done\n");
    fist_checkinode(inode, "post wrapfs_release");

    fist_print_dentry("wrapfs_release OUT hidden_dentry", hidden_dentry);
    print_exit_status(err);
    return err;
}


STATIC int
wrapfs_fsync(file_t *file, dentry_t *dentry)
{
    int err = -EINVAL;
    file_t *hidden_file = ftohf(file);
    dentry_t *hidden_dentry = wrapfs_hidden_dentry(dentry);

    print_entry_location();

    if (hidden_file->f_op && hidden_file->f_op->fsync) {
	down(&hidden_dentry->d_inode->i_sem);
	err = hidden_file->f_op->fsync(hidden_file, hidden_dentry);
	up(&hidden_dentry->d_inode->i_sem);
    }

    print_exit_status(err);
    return err;
}


STATIC int
wrapfs_fasync(int fd, file_t *file, int flag)
{
    int err = 0;
    file_t *hidden_file = ftohf(file);

    print_entry_location();

    if (hidden_file->f_op && hidden_file->f_op->fasync)
	err = hidden_file->f_op->fasync(fd, hidden_file, flag);

    print_exit_status(err);
    return err;
}


STATIC int
wrapfs_lock(file_t *file, int cmd, struct file_lock *fl)
{
    int err = 0;
    file_t *hidden_file = ftohf(file);

    print_entry_location();

    if (hidden_file->f_op->lock) {
	err = hidden_file->f_op->lock(hidden_file, F_GETLK, fl);
    } else {
	posix_test_lock(hidden_file, fl);
    }

    print_exit_status(err);
    return err;
}


struct file_operations wrapfs_fops =
{
    llseek:	wrapfs_llseek,
#ifdef FIST_FILTER_DATA
    read:	generic_file_read,
    write:	generic_file_write,
#else /* not FIST_FILTER_DATA */
    read:	wrapfs_read,
    write:	wrapfs_write,
#endif /* not FIST_FILTER_DATA */
    readdir:	wrapfs_readdir,
    poll:	wrapfs_poll,
    ioctl:	wrapfs_ioctl,
#ifdef NOT_NEEDED
    mmap:	wrapfs_mmap,
#else /* NOT_NEEDED */
    mmap:	generic_file_mmap,
#endif /* NOT_NEEDED */
    open:	wrapfs_open,
    flush:	wrapfs_flush,
    release:	wrapfs_release,
    fsync:	wrapfs_fsync,
    fasync:	wrapfs_fasync,
    lock:	wrapfs_lock,
    /* not needed: readv */
    /* not needed: writev */
};

/*
 * Local variables:
 * c-basic-offset: 4
 * End:
 */