--- /dev/null
+Date: Thu, 09 Oct 2008 17:11:31 +1100
+From: Donald Douwsma <donaldd@sgi.com>
+Subject: DMAPI Source
+Patch-mainline: ?
+References: bnc#450658
+
+Acked-by: Jan Kara <jack@suse.cz>
+
+---
+ fs/dmapi/Makefile | 53 +
+ fs/dmapi/Status | 128 +++
+ fs/dmapi/dmapi.h | 1086 ++++++++++++++++++++++++++
+ fs/dmapi/dmapi_attr.c | 93 ++
+ fs/dmapi/dmapi_bulkattr.c | 170 ++++
+ fs/dmapi/dmapi_config.c | 117 ++
+ fs/dmapi/dmapi_dmattr.c | 228 +++++
+ fs/dmapi/dmapi_event.c | 860 +++++++++++++++++++++
+ fs/dmapi/dmapi_handle.c | 119 ++
+ fs/dmapi/dmapi_hole.c | 119 ++
+ fs/dmapi/dmapi_io.c | 142 +++
+ fs/dmapi/dmapi_kern.h | 599 ++++++++++++++
+ fs/dmapi/dmapi_mountinfo.c | 527 ++++++++++++
+ fs/dmapi/dmapi_port.h | 138 +++
+ fs/dmapi/dmapi_private.h | 619 +++++++++++++++
+ fs/dmapi/dmapi_region.c | 91 ++
+ fs/dmapi/dmapi_register.c | 1644 ++++++++++++++++++++++++++++++++++++++++
+ fs/dmapi/dmapi_right.c | 1256 ++++++++++++++++++++++++++++++
+ fs/dmapi/dmapi_session.c | 1825 +++++++++++++++++++++++++++++++++++++++++++++
+ fs/dmapi/dmapi_sysent.c | 805 +++++++++++++++++++
+ fs/dmapi/sv.h | 89 ++
+ 21 files changed, 10708 insertions(+)
+
+Index: linux-2.6.26/fs/dmapi/dmapi_attr.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_attr.c
+@@ -0,0 +1,93 @@
++/*
++ * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++
++/* Retrieve attributes for a single file, directory or symlink. */
++
++int
++dm_get_fileattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int mask,
++ dm_stat_t __user *statp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VNO,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->get_fileattr(tdp->td_ip, tdp->td_right,
++ mask, statp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++/* Set one or more file attributes of a file, directory, or symlink. */
++
++int
++dm_set_fileattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int mask,
++ dm_fileattr_t __user *attrp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VNO,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->set_fileattr(tdp->td_ip, tdp->td_right,
++ mask, attrp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
+Index: linux-2.6.26/fs/dmapi/dmapi_bulkattr.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_bulkattr.c
+@@ -0,0 +1,170 @@
++/*
++ * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++
++int
++dm_init_attrloc(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrloc_t __user *locp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VFS|DM_TDT_DIR,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->init_attrloc(tdp->td_ip, tdp->td_right, locp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++/*
++ * Retrieves both standard and DM specific file attributes for the file
++ * system indicated by the handle. (The FS has to be mounted).
++ * Syscall returns 1 to indicate SUCCESS and more information is available.
++ * -1 is returned on error, and errno will be set appropriately.
++ * 0 is returned upon successful completion.
++ */
++
++int
++dm_get_bulkattr_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int mask,
++ dm_attrloc_t __user *locp,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp,
++ int *rvp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VFS,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->get_bulkattr_rvp(tdp->td_ip, tdp->td_right,
++ mask, locp, buflen, bufp, rlenp, rvp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++/*
++ * Retrieves attributes of directory entries given a handle to that
++ * directory. Iterative.
++ * Syscall returns 1 to indicate SUCCESS and more information is available.
++ * -1 is returned on error, and errno will be set appropriately.
++ * 0 is returned upon successful completion.
++ */
++
++int
++dm_get_dirattrs_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int mask,
++ dm_attrloc_t __user *locp,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp,
++ int *rvp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_DIR,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->get_dirattrs_rvp(tdp->td_ip, tdp->td_right,
++ mask, locp, buflen, bufp, rlenp, rvp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_get_bulkall_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int mask,
++ dm_attrname_t __user *attrnamep,
++ dm_attrloc_t __user *locp,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp,
++ int *rvp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VFS,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->get_bulkall_rvp(tdp->td_ip, tdp->td_right,
++ mask, attrnamep, locp, buflen, bufp, rlenp, rvp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
+Index: linux-2.6.26/fs/dmapi/dmapi_config.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_config.c
+@@ -0,0 +1,117 @@
++/*
++ * Copyright (c) 2000-2004 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++
++#include <asm/uaccess.h>
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++int
++dm_get_config(
++ void __user *hanp,
++ size_t hlen,
++ dm_config_t flagname,
++ dm_size_t __user *retvalp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ dm_size_t retval;
++ int system = 1;
++ int error;
++
++ /* Trap and process configuration parameters which are system-wide. */
++
++ switch (flagname) {
++ case DM_CONFIG_LEGACY:
++ case DM_CONFIG_PENDING:
++ case DM_CONFIG_OBJ_REF:
++ retval = DM_TRUE;
++ break;
++ case DM_CONFIG_MAX_MESSAGE_DATA:
++ retval = DM_MAX_MSG_DATA;
++ break;
++ default:
++ system = 0;
++ break;
++ }
++ if (system) {
++ if (copy_to_user(retvalp, &retval, sizeof(retval)))
++ return(-EFAULT);
++ return(0);
++ }
++
++ /* Must be filesystem-specific. Convert the handle into an inode. */
++
++ if ((error = dm_get_config_tdp(hanp, hlen, &tdp)) != 0)
++ return(error);
++
++ /* Now call the filesystem-specific routine to determine the
++ value of the configuration option for that filesystem.
++ */
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->get_config(tdp->td_ip, tdp->td_right,
++ flagname, retvalp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_get_config_events(
++ void __user *hanp,
++ size_t hlen,
++ u_int nelem,
++ dm_eventset_t __user *eventsetp,
++ u_int __user *nelemp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ /* Convert the handle into an inode. */
++
++ if ((error = dm_get_config_tdp(hanp, hlen, &tdp)) != 0)
++ return(error);
++
++ /* Now call the filesystem-specific routine to determine the
++ events supported by that filesystem.
++ */
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->get_config_events(tdp->td_ip, tdp->td_right,
++ nelem, eventsetp, nelemp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
+Index: linux-2.6.26/fs/dmapi/dmapi_dmattr.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_dmattr.c
+@@ -0,0 +1,228 @@
++/*
++ * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++
++int
++dm_clear_inherit(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrname_t __user *attrnamep)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VFS,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->clear_inherit(tdp->td_ip, tdp->td_right,
++ attrnamep);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_get_dmattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrname_t __user *attrnamep,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VNO,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->get_dmattr(tdp->td_ip, tdp->td_right,
++ attrnamep, buflen, bufp, rlenp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_getall_dmattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VNO,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->getall_dmattr(tdp->td_ip, tdp->td_right,
++ buflen, bufp, rlenp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_getall_inherit(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int nelem,
++ dm_inherit_t __user *inheritbufp,
++ u_int __user *nelemp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VFS,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->getall_inherit(tdp->td_ip, tdp->td_right,
++ nelem, inheritbufp, nelemp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_remove_dmattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ int setdtime,
++ dm_attrname_t __user *attrnamep)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VNO,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->remove_dmattr(tdp->td_ip, tdp->td_right,
++ setdtime, attrnamep);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_set_dmattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrname_t __user *attrnamep,
++ int setdtime,
++ size_t buflen,
++ void __user *bufp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VNO,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->set_dmattr(tdp->td_ip, tdp->td_right,
++ attrnamep, setdtime, buflen, bufp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_set_inherit(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrname_t __user *attrnamep,
++ mode_t mode)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VFS,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->set_inherit(tdp->td_ip, tdp->td_right,
++ attrnamep, mode);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
+Index: linux-2.6.26/fs/dmapi/dmapi_event.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_event.c
+@@ -0,0 +1,860 @@
++/*
++ * Copyright (c) 2000-2005 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++#include <asm/uaccess.h>
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++/* The "rights" portion of the DMAPI spec is not currently implemented. A
++ framework for rights is provided in the code, but turns out to be a noop
++ in practice. The following comments are a brain dump to serve as input to
++ the poor soul that eventually has to get DMAPI rights working in IRIX.
++
++ A DMAPI right is similar but not identical to the mrlock_t mechanism
++ already used within the kernel. The similarities are that it is a
++ sleeping lock, and that a multiple-reader, single-writer protocol is used.
++ How locks are obtained and dropped are different however. With a mrlock_t,
++ a thread grabs the lock, does some stuff, then drops the lock, and all other
++ threads block in the meantime (assuming a write lock). There is a one-to-
++ one relationship between the lock and the thread which obtained the lock.
++ Not so with DMAPI right locks. A DMAPI lock is associated with a particular
++ session/token/hanp/hlen quad; since there is a dm_tokdata_t structure for
++ each such quad, you can think of it as a one-to-one relationship between the
++ lock and a dm_tokdata_t. Any application thread which presents the correct
++ quad is entitled to grab or release the lock, or to use the rights
++ associated with that lock. The thread that grabs the lock does not have to
++ be the one to use the lock, nor does it have to be the thread which drops
++ the lock. The lock can be held for very long periods of time, even across
++ multiple systems calls by multiple application threads. The idea is that a
++ coordinated group of DMAPI application threads can grab the lock, issue a
++ series of inode accesses and/or updates, then drop the lock, and be assured
++ that no other thread in the system could be modifying the inode at the same
++ time. The kernel is expected to blindly trust that the application will
++ not forget to unlock inodes it has locked, and will not deadlock itself
++ against the kernel.
++
++ There are two types of DMAPI rights, file object (inode) and filesystem
++ object (superblock?). An inode right is the equivalent of the combination
++ of both the XFS ilock and iolock; if held exclusively, no data or metadata
++ within the file can be changed by non-lock-holding threads. The filesystem
++ object lock is a little fuzzier; I think that if it is held, things like
++ unmounts can be blocked, plus there is an event mask associated with the
++ filesystem which can't be updated without the lock. (By the way, that
++ event mask is supposed to be persistent in the superblock; add that to
++ your worklist :-)
++
++ All events generated by XFS currently arrive with no rights, i.e.
++ DM_RIGHT_NULL, and return to the filesystem with no rights. It would be
++ smart to leave it this way if possible, because it otherwise becomes more
++ likely that an application thread will deadlock against the kernel if the
++ one responsible for calling dm_get_events() happens to touch a file which
++ was locked at the time the event was queued. Since the thread is blocked,
++ it can't read the event in order to find and drop the lock. Catch-22. If
++ you do have events that arrive with non-null rights, then dm_enqueue() needs
++ to have code added for synchronous events which atomically switches the
++ right from being a thread-based right to a dm_tokdata_t-based right without
++ allowing the lock to drop in between. You will probably have to add a new
++ dm_fsys_vector entry point to do this. The lock can't be lost during the
++ switch, or other threads might change the inode or superblock in between.
++ Likewise, if you need to return to the filesystem holding a right, then
++ you need a DMAPI-to-thread atomic switch to occur, most likely in
++ dm_change_right(). Again, the lock must not be lost during the switch; the
++ DMAPI spec spends a couple of pages stressing this. Another dm_fsys_vector
++ entry point is probably the answer.
++
++ There are several assumptions implied in the current layout of the code.
++ First of all, if an event returns to the filesystem with a return value of
++ zero, then the filesystem can assume that any locks (rights) held at the
++ start of the event are still in effect at the end of the event. (Note that
++ the application could have temporarily dropped and reaquired the right
++ while the event was outstanding, however). If the event returns to the
++ filesystem with an errno, then the filesystem must assume that it has lost
++ any and all rights associated with any of the objects in the event. This
++ was done for a couple of reasons. First of all, since an errno is being
++ returned, most likely the filesystem is going to immediately drop all the
++ locks anyway. If the DMAPI code was required to unconditionally reobtain
++ all locks before returning to the filesystem, then dm_pending() wouldn't
++ work for NFS server threads because the process would block indefinitely
++ trying to get its thread-based rights back, because the DMAPI-rights
++ associated with the dm_tokdata_t in the outstanding event would prevent
++ the rights from being obtained. That would be a bad thing. We wouldn't
++ be able to let users Cntl-C out of read/write/truncate events either.
++
++ If a case should ever surface where the thread has lost its rights even
++ though it has a zero return status, or where the thread has rights even
++ though it is returning with an errno, then this logic will have to be
++ reworked. This could be done by changing the 'right' parameters on all
++ the event calls to (dm_right_t *), so that they could serve both as IN
++ and OUT parameters.
++
++ Some events such as DM_EVENT_DESTROY arrive without holding an inode
++ reference; if you don't have an inode reference, you can't have a right
++ on the file.
++
++ One more quirk. The DM_EVENT_UNMOUNT event is defined to be synchronous
++ when it's behavior is asynchronous. If an unmount event arrives with
++ rights, the event should return with the same rights and should NOT leave
++ any rights in the dm_tokdata_t where the application could use them.
++*/
++
++
++#define GETNEXTOFF(vdat) ((vdat).vd_offset + (vdat).vd_length)
++#define HANDLE_SIZE(tdp) \
++ ((tdp)->td_type & DM_TDT_VFS ? DM_FSHSIZE : DM_HSIZE((tdp)->td_handle))
++
++
++/* Given an inode pointer in a filesystem known to support DMAPI,
++ build a tdp structure for the corresponding inode.
++*/
++
++static dm_tokdata_t *
++dm_ip_data(
++ struct inode *ip,
++ dm_right_t right,
++ int referenced) /* != 0, caller holds inode reference */
++{
++ int error;
++ dm_tokdata_t *tdp;
++ int filetype;
++
++ tdp = kmem_cache_alloc(dm_tokdata_cachep, GFP_KERNEL);
++ if (tdp == NULL) {
++ printk("%s/%d: kmem_cache_alloc(dm_tokdata_cachep) returned NULL\n", __FUNCTION__, __LINE__);
++ return NULL;
++ }
++
++ tdp->td_next = NULL;
++ tdp->td_tevp = NULL;
++ tdp->td_app_ref = 0;
++ tdp->td_orig_right = right;
++ tdp->td_right = right;
++ tdp->td_flags = DM_TDF_ORIG;
++ if (referenced) {
++ tdp->td_flags |= DM_TDF_EVTREF;
++ }
++
++ filetype = ip->i_mode & S_IFMT;
++ if (filetype == S_IFREG) {
++ tdp->td_type = DM_TDT_REG;
++ } else if (filetype == S_IFDIR) {
++ tdp->td_type = DM_TDT_DIR;
++ } else if (filetype == S_IFLNK) {
++ tdp->td_type = DM_TDT_LNK;
++ } else {
++ tdp->td_type = DM_TDT_OTH;
++ }
++
++ if (referenced) {
++ tdp->td_ip = ip;
++ } else {
++ tdp->td_ip = NULL;
++ }
++ tdp->td_vcount = 0;
++
++ if ((error = dm_ip_to_handle(ip, &tdp->td_handle)) != 0) {
++ panic("dm_ip_data: dm_ip_to_handle failed for ip %p in "
++ "a DMAPI filesystem, errno %d\n", ip, error);
++ }
++
++ return(tdp);
++}
++
++
++/* Given a sb pointer to a filesystem known to support DMAPI, build a tdp
++ structure for that sb.
++*/
++static dm_tokdata_t *
++dm_sb_data(
++ struct super_block *sb,
++ struct inode *ip, /* will be NULL for DM_EVENT_UNMOUNT */
++ dm_right_t right)
++{
++ dm_tokdata_t *tdp;
++ struct filesystem_dmapi_operations *dops;
++ dm_fsid_t fsid;
++
++ dops = dm_fsys_ops(sb);
++ ASSERT(dops);
++ dops->get_fsid(sb, &fsid);
++
++ tdp = kmem_cache_alloc(dm_tokdata_cachep, GFP_KERNEL);
++ if (tdp == NULL) {
++ printk("%s/%d: kmem_cache_alloc(dm_tokdata_cachep) returned NULL\n", __FUNCTION__, __LINE__);
++ return NULL;
++ }
++
++ tdp->td_next = NULL;
++ tdp->td_tevp = NULL;
++ tdp->td_app_ref = 0;
++ tdp->td_orig_right = right;
++ tdp->td_right = right;
++ tdp->td_flags = DM_TDF_ORIG;
++ if (ip) {
++ tdp->td_flags |= DM_TDF_EVTREF;
++ }
++ tdp->td_type = DM_TDT_VFS;
++ tdp->td_ip = ip;
++ tdp->td_vcount = 0;
++
++ memcpy(&tdp->td_handle.ha_fsid, &fsid, sizeof(fsid));
++ memset((char *)&tdp->td_handle.ha_fsid + sizeof(fsid), 0,
++ sizeof(tdp->td_handle) - sizeof(fsid));
++
++ return(tdp);
++}
++
++
++/* Link a tdp structure into the tevp. */
++
++static void
++dm_add_handle_to_event(
++ dm_tokevent_t *tevp,
++ dm_tokdata_t *tdp)
++{
++ tdp->td_next = tevp->te_tdp;
++ tevp->te_tdp = tdp;
++ tdp->td_tevp = tevp;
++}
++
++
++/* Generate the given data event for the inode, and wait for a reply. The
++ caller must guarantee that the inode's reference count is greater than zero
++ so that the filesystem can't disappear while the request is outstanding.
++*/
++
++int
++dm_send_data_event(
++ dm_eventtype_t event,
++ struct inode *ip,
++ dm_right_t vp_right, /* current right for ip */
++ dm_off_t offset,
++ size_t length,
++ int flags) /* 0 or DM_FLAGS_NDELAY */
++{
++ dm_data_event_t *datap;
++ dm_tokevent_t *tevp;
++ dm_tokdata_t *tdp;
++ int error;
++
++ tdp = dm_ip_data(ip, vp_right, /* reference held */ 1);
++ if (tdp == NULL)
++ return -ENOMEM;
++
++ /* Calculate the size of the event in bytes, create an event structure
++ for it, and insert the file's handle into the event.
++ */
++
++ tevp = dm_evt_create_tevp(event, HANDLE_SIZE(tdp), (void **)&datap);
++ if (tevp == NULL) {
++ kmem_cache_free(dm_tokdata_cachep, tdp);
++ return(-ENOMEM);
++ }
++ dm_add_handle_to_event(tevp, tdp);
++
++ /* Now fill in all the dm_data_event_t fields. */
++
++ datap->de_handle.vd_offset = sizeof(*datap);
++ datap->de_handle.vd_length = HANDLE_SIZE(tdp);
++ memcpy((char *)datap + datap->de_handle.vd_offset, &tdp->td_handle,
++ datap->de_handle.vd_length);
++ datap->de_offset = offset;
++ datap->de_length = length;
++
++ /* Queue the message and wait for the reply. */
++
++ error = dm_enqueue_normal_event(ip->i_sb, &tevp, flags);
++
++ /* If no errors occurred, we must leave with the same rights we had
++ upon entry. If errors occurred, we must leave with no rights.
++ */
++
++ dm_evt_rele_tevp(tevp, error);
++
++ return(error);
++}
++
++
++/* Generate the destroy event for the inode and wait until the request has been
++ queued. The caller does not hold an inode reference or a right on the inode,
++ but it must otherwise lock down the inode such that the filesystem can't
++ disappear while the request is waiting to be queued. While waiting to be
++ queued, the inode must not be referenceable either by path or by a call
++ to dm_handle_to_ip().
++*/
++
++int
++dm_send_destroy_event(
++ struct inode *ip,
++ dm_right_t vp_right) /* always DM_RIGHT_NULL */
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokevent_t *tevp;
++ dm_tokdata_t *tdp;
++ dm_destroy_event_t *destp;
++ dm_attrname_t attrname;
++ char *value;
++ int value_len;
++ int error;
++
++ tdp = dm_ip_data(ip, vp_right, /* no reference held */ 0);
++ if (tdp == NULL)
++ return -ENOMEM;
++
++ if ((error = dm_waitfor_destroy_attrname(ip->i_sb, &attrname)) != 0)
++ return(error);
++
++ /* If a return-on-destroy attribute name exists for this filesystem,
++ see if the object being deleted has this attribute. If the object
++ doesn't have the attribute or if we encounter an error, then send
++ the event without the attribute.
++ */
++
++ value_len = -1; /* because zero is a valid attribute length */
++ if (attrname.an_chars[0] != '\0') {
++ fsys_vector = dm_fsys_vector(ip);
++ error = fsys_vector->get_destroy_dmattr(ip, vp_right, &attrname,
++ &value, &value_len);
++ if (error && error != -ENODATA)
++ return error;
++ }
++
++ /* Now that we know the size of the attribute value, if any, calculate
++ the size of the event in bytes, create an event structure for it,
++ and insert the handle into the event.
++ */
++
++ tevp = dm_evt_create_tevp(DM_EVENT_DESTROY,
++ HANDLE_SIZE(tdp) + (value_len >= 0 ? value_len : 0),
++ (void **)&destp);
++ if (tevp == NULL) {
++ kmem_cache_free(dm_tokdata_cachep, tdp);
++ if (value_len > 0)
++ kfree(value);
++ return(-ENOMEM);
++ }
++ dm_add_handle_to_event(tevp, tdp);
++
++ /* Now fill in all the dm_destroy_event_t fields. */
++
++ destp->ds_handle.vd_offset = sizeof(*destp);
++ destp->ds_handle.vd_length = HANDLE_SIZE(tdp);
++ memcpy((char *)destp + destp->ds_handle.vd_offset, &tdp->td_handle,
++ destp->ds_handle.vd_length);
++ if (value_len >= 0) {
++ destp->ds_attrname = attrname;
++ destp->ds_attrcopy.vd_length = value_len;
++ if (value_len == 0) {
++ destp->ds_attrcopy.vd_offset = 0;
++ } else {
++ destp->ds_attrcopy.vd_offset = GETNEXTOFF(destp->ds_handle);
++ memcpy((char *)destp + destp->ds_attrcopy.vd_offset, value,
++ value_len);
++ kfree(value);
++ }
++ }
++
++ /* Queue the message asynchronously. */
++
++ error = dm_enqueue_normal_event(ip->i_sb, &tevp, 0);
++
++ /* Since we had no rights upon entry, we have none to reobtain before
++ leaving.
++ */
++
++ dm_evt_rele_tevp(tevp, 1);
++
++ return(error);
++}
++
++
++/* The dm_mount_event_t event is sent in turn to all sessions that have asked
++ for it until one either rejects it or accepts it. The filesystem is not
++ going anywhere because the mount is blocked until the event is answered.
++*/
++
++int
++dm_send_mount_event(
++ struct super_block *sb, /* filesystem being mounted */
++ dm_right_t vfsp_right,
++ struct inode *ip, /* mounted on directory */
++ dm_right_t vp_right,
++ struct inode *rootip,
++ dm_right_t rootvp_right,
++ char *name1, /* mount path */
++ char *name2) /* filesystem device name */
++{
++ int error;
++ dm_tokevent_t *tevp = NULL;
++ dm_tokdata_t *tdp1 = NULL; /* filesystem handle for event */
++ dm_tokdata_t *tdp2 = NULL; /* file handle for mounted-on dir. */
++ dm_tokdata_t *tdp3 = NULL; /* file handle for root inode */
++ dm_mount_event_t *mp;
++ size_t nextoff;
++
++ /* Convert the sb to a filesystem handle, and ip and rootip into
++ file handles. ip (the mounted-on directory) may not have a handle
++ if it is a different filesystem type which does not support DMAPI.
++ */
++
++ tdp1 = dm_sb_data(sb, rootip, vfsp_right);
++ if (tdp1 == NULL)
++ goto out_nomem;
++
++ if ((ip == NULL) || dm_check_dmapi_ip(ip)) {
++ ip = NULL; /* we are mounting on non-DMAPI FS */
++ } else {
++ tdp2 = dm_ip_data(ip, vp_right, /* reference held */ 1);
++ if (tdp2 == NULL)
++ goto out_nomem;
++ }
++
++ tdp3 = dm_ip_data(rootip, rootvp_right, /* reference held */ 1);
++ if (tdp3 == NULL)
++ goto out_nomem;
++
++ /* Calculate the size of the event in bytes, create an event structure
++ for it, and insert the handles into the event.
++ */
++
++ tevp = dm_evt_create_tevp(DM_EVENT_MOUNT,
++ HANDLE_SIZE(tdp1) + (ip ? HANDLE_SIZE(tdp2) : 0) +
++ HANDLE_SIZE(tdp3) + strlen(name1) + 1 +
++ strlen(name2) + 1, (void **)&mp);
++ if (tevp == NULL)
++ goto out_nomem;
++
++ dm_add_handle_to_event(tevp, tdp1);
++ if (ip)
++ dm_add_handle_to_event(tevp, tdp2);
++ dm_add_handle_to_event(tevp, tdp3);
++
++ /* Now fill in all the dm_mount_event_t fields. */
++
++ mp->me_handle1.vd_offset = sizeof(*mp);
++ mp->me_handle1.vd_length = HANDLE_SIZE(tdp1);
++ memcpy((char *) mp + mp->me_handle1.vd_offset, &tdp1->td_handle,
++ mp->me_handle1.vd_length);
++ nextoff = GETNEXTOFF(mp->me_handle1);
++
++ if (ip) {
++ mp->me_handle2.vd_offset = nextoff;
++ mp->me_handle2.vd_length = HANDLE_SIZE(tdp2);
++ memcpy((char *)mp + mp->me_handle2.vd_offset, &tdp2->td_handle,
++ mp->me_handle2.vd_length);
++ nextoff = GETNEXTOFF(mp->me_handle2);
++ }
++
++ mp->me_name1.vd_offset = nextoff;
++ mp->me_name1.vd_length = strlen(name1) + 1;
++ memcpy((char *)mp + mp->me_name1.vd_offset, name1, mp->me_name1.vd_length);
++ nextoff = GETNEXTOFF(mp->me_name1);
++
++ mp->me_name2.vd_offset = nextoff;
++ mp->me_name2.vd_length = strlen(name2) + 1;
++ memcpy((char *)mp + mp->me_name2.vd_offset, name2, mp->me_name2.vd_length);
++ nextoff = GETNEXTOFF(mp->me_name2);
++
++ mp->me_roothandle.vd_offset = nextoff;
++ mp->me_roothandle.vd_length = HANDLE_SIZE(tdp3);
++ memcpy((char *)mp + mp->me_roothandle.vd_offset, &tdp3->td_handle,
++ mp->me_roothandle.vd_length);
++
++ mp->me_mode = (sb->s_flags & MS_RDONLY ? DM_MOUNT_RDONLY : 0);
++
++ /* Queue the message and wait for the reply. */
++
++ error = dm_enqueue_mount_event(sb, tevp);
++
++ /* If no errors occurred, we must leave with the same rights we had
++ upon entry. If errors occurred, we must leave with no rights.
++ */
++
++ dm_evt_rele_tevp(tevp, error);
++
++ return(error);
++
++out_nomem:
++ if (tevp)
++ kfree(tevp);
++ if (tdp1)
++ kmem_cache_free(dm_tokdata_cachep, tdp1);
++ if (tdp2)
++ kmem_cache_free(dm_tokdata_cachep, tdp2);
++ if (tdp3)
++ kmem_cache_free(dm_tokdata_cachep, tdp3);
++ return -ENOMEM;
++}
++
++
++/* Generate an DM_EVENT_UNMOUNT event and wait for a reply. The 'retcode'
++ field indicates whether this is a successful or unsuccessful unmount.
++ If successful, the filesystem is already unmounted, and any pending handle
++ reference to the filesystem will be failed. If the unmount was
++ unsuccessful, then the filesystem will be placed back into full service.
++
++ The DM_EVENT_UNMOUNT event should really be asynchronous, because the
++ application has no control over whether or not the unmount succeeds. (The
++ DMAPI spec defined it that way because asynchronous events aren't always
++ guaranteed to be delivered.)
++
++ Since the filesystem is already unmounted in the successful case, the
++ DM_EVENT_UNMOUNT event can't make available any inode to be used in
++ subsequent sid/hanp/hlen/token calls by the application. The event will
++ hang around until the application does a DM_RESP_CONTINUE, but the handle
++ within the event is unusable by the application.
++*/
++
++void
++dm_send_unmount_event(
++ struct super_block *sb,
++ struct inode *ip, /* NULL if unmount successful */
++ dm_right_t vfsp_right,
++ mode_t mode,
++ int retcode, /* errno, if unmount failed */
++ int flags)
++{
++ dm_namesp_event_t *np;
++ dm_tokevent_t *tevp;
++ dm_tokdata_t *tdp1;
++
++ /* If the unmount failed, put the filesystem back into full service,
++ allowing blocked handle references to finish. If it succeeded, put
++ the filesystem into the DM_STATE_UNMOUNTED state and fail all
++ blocked DM_NO_TOKEN handle accesses.
++ */
++
++ if (retcode != 0) { /* unmount was unsuccessful */
++ dm_change_fsys_entry(sb, DM_STATE_MOUNTED);
++ } else {
++ dm_change_fsys_entry(sb, DM_STATE_UNMOUNTED);
++ }
++
++ /* If the event wasn't in the filesystem dm_eventset_t, just remove
++ the filesystem from the list of DMAPI filesystems and return.
++ */
++
++ if (flags & DM_FLAGS_UNWANTED) {
++ if (retcode == 0)
++ dm_remove_fsys_entry(sb);
++ return;
++ }
++
++ /* Calculate the size of the event in bytes and allocate zeroed memory
++ for it.
++ */
++
++ tdp1 = dm_sb_data(sb, ip, vfsp_right);
++ if (tdp1 == NULL)
++ return;
++
++ tevp = dm_evt_create_tevp(DM_EVENT_UNMOUNT, HANDLE_SIZE(tdp1),
++ (void **)&np);
++ if (tevp == NULL) {
++ kmem_cache_free(dm_tokdata_cachep, tdp1);
++ return;
++ }
++
++ dm_add_handle_to_event(tevp, tdp1);
++
++ /* Now copy in all the dm_namesp_event_t specific fields. */
++
++ np->ne_handle1.vd_offset = sizeof(*np);
++ np->ne_handle1.vd_length = HANDLE_SIZE(tdp1);
++ memcpy((char *) np + np->ne_handle1.vd_offset, &tdp1->td_handle,
++ np->ne_handle1.vd_length);
++ np->ne_mode = mode;
++ np->ne_retcode = retcode;
++
++ /* Since DM_EVENT_UNMOUNT is effectively asynchronous, queue the
++ message and ignore any error return for DM_EVENT_UNMOUNT.
++ */
++
++ (void)dm_enqueue_normal_event(sb, &tevp, flags);
++
++ if (retcode == 0)
++ dm_remove_fsys_entry(sb);
++
++ dm_evt_rele_tevp(tevp, 0);
++}
++
++
++/* Generate the given namespace event and wait for a reply (if synchronous) or
++ until the event has been queued (asynchronous). The caller must guarantee
++ that at least one inode within the filesystem has had its reference count
++ bumped so that the filesystem can't disappear while the event is
++ outstanding.
++*/
++
++int
++dm_send_namesp_event(
++ dm_eventtype_t event,
++ struct super_block *sb, /* used by PREUNMOUNT */
++ struct inode *ip1,
++ dm_right_t vp1_right,
++ struct inode *ip2,
++ dm_right_t vp2_right,
++ const char *name1,
++ const char *name2,
++ mode_t mode,
++ int retcode,
++ int flags)
++{
++ dm_namesp_event_t *np;
++ dm_tokevent_t *tevp;
++ dm_tokdata_t *tdp1 = NULL; /* primary handle for event */
++ dm_tokdata_t *tdp2 = NULL; /* additional handle for event */
++ size_t nextoff;
++ int error;
++
++ if (sb == NULL)
++ sb = ip1->i_sb;
++
++ switch (event) {
++ case DM_EVENT_PREUNMOUNT:
++ /*
++ * PREUNMOUNT - Send the file system handle in handle1,
++ * and the handle for the root dir in the second. Otherwise
++ * it's a normal sync message; i.e. succeeds or fails
++ * depending on the app's return code.
++ * ip1 and ip2 are both the root dir of mounted FS
++ * vp1_right is the filesystem right.
++ * vp2_right is the root inode right.
++ */
++
++ if (flags & DM_FLAGS_UNWANTED) {
++ dm_change_fsys_entry(sb, DM_STATE_UNMOUNTING);
++ return(0);
++ }
++ if (ip1 == NULL) {
++ /* If preunmount happens after kill_super then
++ * it's too late; there's nothing left with which
++ * to construct an event.
++ */
++ return(0);
++ }
++ tdp1 = dm_sb_data(sb, ip1, vp1_right);
++ if (tdp1 == NULL)
++ return -ENOMEM;
++ tdp2 = dm_ip_data(ip2, vp2_right, /* reference held */ 1);
++ if (tdp2 == NULL) {
++ kmem_cache_free(dm_tokdata_cachep, tdp1);
++ return -ENOMEM;
++ }
++ break;
++
++ case DM_EVENT_NOSPACE:
++ /* vp1_right is the filesystem right. */
++
++ tdp1 = dm_sb_data(sb, ip1, vp1_right);
++ if (tdp1 == NULL)
++ return -ENOMEM;
++ tdp2 = dm_ip_data(ip2, vp2_right, /* reference held */ 1); /* additional info - not in the spec */
++ if (tdp2 == NULL) {
++ kmem_cache_free(dm_tokdata_cachep, tdp1);
++ return -ENOMEM;
++ }
++ break;
++
++ default:
++ /* All other events only pass in inodes and don't require any
++ special cases.
++ */
++
++ tdp1 = dm_ip_data(ip1, vp1_right, /* reference held */ 1);
++ if (tdp1 == NULL)
++ return -ENOMEM;
++ if (ip2) {
++ tdp2 = dm_ip_data(ip2, vp2_right, /* reference held */ 1);
++ if (tdp2 == NULL) {
++ kmem_cache_free(dm_tokdata_cachep, tdp1);
++ return -ENOMEM;
++ }
++ }
++ }
++
++ /* Calculate the size of the event in bytes and allocate zeroed memory
++ for it.
++ */
++
++ tevp = dm_evt_create_tevp(event,
++ HANDLE_SIZE(tdp1) + (ip2 ? HANDLE_SIZE(tdp2) : 0) +
++ (name1 ? strlen(name1) + 1 : 0) +
++ (name2 ? strlen(name2) + 1 : 0), (void **)&np);
++ if (tevp == NULL) {
++ if (tdp1)
++ kmem_cache_free(dm_tokdata_cachep, tdp1);
++ if (tdp2)
++ kmem_cache_free(dm_tokdata_cachep, tdp2);
++ return(-ENOMEM);
++ }
++
++ dm_add_handle_to_event(tevp, tdp1);
++ if (ip2)
++ dm_add_handle_to_event(tevp, tdp2);
++
++ /* Now copy in all the dm_namesp_event_t specific fields. */
++
++ np->ne_handle1.vd_offset = sizeof(*np);
++ np->ne_handle1.vd_length = HANDLE_SIZE(tdp1);
++ memcpy((char *) np + np->ne_handle1.vd_offset, &tdp1->td_handle,
++ np->ne_handle1.vd_length);
++ nextoff = GETNEXTOFF(np->ne_handle1);
++ if (ip2) {
++ np->ne_handle2.vd_offset = nextoff;
++ np->ne_handle2.vd_length = HANDLE_SIZE(tdp2);
++ memcpy((char *)np + np->ne_handle2.vd_offset, &tdp2->td_handle,
++ np->ne_handle2.vd_length);
++ nextoff = GETNEXTOFF(np->ne_handle2);
++ }
++ if (name1) {
++ np->ne_name1.vd_offset = nextoff;
++ np->ne_name1.vd_length = strlen(name1) + 1;
++ memcpy((char *)np + np->ne_name1.vd_offset, name1,
++ np->ne_name1.vd_length);
++ nextoff = GETNEXTOFF(np->ne_name1);
++ }
++ if (name2) {
++ np->ne_name2.vd_offset = nextoff;
++ np->ne_name2.vd_length = strlen(name2) + 1;
++ memcpy((char *)np + np->ne_name2.vd_offset, name2,
++ np->ne_name2.vd_length);
++ }
++ np->ne_mode = mode;
++ np->ne_retcode = retcode;
++
++ /* Queue the message and wait for the reply. */
++
++ error = dm_enqueue_normal_event(sb, &tevp, flags);
++
++ /* If no errors occurred, we must leave with the same rights we had
++ upon entry. If errors occurred, we must leave with no rights.
++ */
++
++ dm_evt_rele_tevp(tevp, error);
++
++ if (!error && event == DM_EVENT_PREUNMOUNT) {
++ dm_change_fsys_entry(sb, DM_STATE_UNMOUNTING);
++ }
++
++ return(error);
++}
++
++
++/*
++ * Send a message of type "DM_EVENT_USER". Since no inode is involved, we
++ * don't have to worry about rights here.
++ */
++
++int
++dm_send_msg(
++ dm_sessid_t targetsid,
++ dm_msgtype_t msgtype, /* SYNC or ASYNC */
++ size_t buflen,
++ void __user *bufp)
++{
++ dm_tokevent_t *tevp;
++ int sync;
++ void *msgp;
++ int error;
++
++ if (buflen > DM_MAX_MSG_DATA)
++ return(-E2BIG);
++ if (msgtype == DM_MSGTYPE_ASYNC) {
++ sync = 0;
++ } else if (msgtype == DM_MSGTYPE_SYNC) {
++ sync = 1;
++ } else {
++ return(-EINVAL);
++ }
++
++ tevp = dm_evt_create_tevp(DM_EVENT_USER, buflen, (void **)&msgp);
++ if (tevp == NULL)
++ return -ENOMEM;
++
++ if (buflen && copy_from_user(msgp, bufp, buflen)) {
++ dm_evt_rele_tevp(tevp, 0);
++ return(-EFAULT);
++ }
++
++ /* Enqueue the request and wait for the reply. */
++
++ error = dm_enqueue_sendmsg_event(targetsid, tevp, sync);
++
++ /* Destroy the tevp and return the reply. (dm_pending is not
++ supported here.)
++ */
++
++ dm_evt_rele_tevp(tevp, error);
++
++ return(error);
++}
++
++
++/*
++ * Send a message of type "DM_EVENT_USER". Since no inode is involved, we
++ * don't have to worry about rights here.
++ */
++
++int
++dm_create_userevent(
++ dm_sessid_t sid,
++ size_t msglen,
++ void __user *msgdatap,
++ dm_token_t __user *tokenp) /* return token created */
++{
++ dm_tokevent_t *tevp;
++ dm_token_t token;
++ int error;
++ void *msgp;
++
++ if (msglen > DM_MAX_MSG_DATA)
++ return(-E2BIG);
++
++ tevp = dm_evt_create_tevp(DM_EVENT_USER, msglen, (void **)&msgp);
++ if (tevp == NULL)
++ return(-ENOMEM);
++
++ if (msglen && copy_from_user(msgp, msgdatap, msglen)) {
++ dm_evt_rele_tevp(tevp, 0);
++ return(-EFAULT);
++ }
++
++ /* Queue the message. If that didn't work, free the tevp structure. */
++
++ if ((error = dm_enqueue_user_event(sid, tevp, &token)) != 0)
++ dm_evt_rele_tevp(tevp, 0);
++
++ if (!error && copy_to_user(tokenp, &token, sizeof(token)))
++ error = -EFAULT;
++
++ return(error);
++}
+Index: linux-2.6.26/fs/dmapi/dmapi.h
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi.h
+@@ -0,0 +1,1086 @@
++/*
++ * Copyright (c) 1995-2003 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2.1 of the GNU Lesser General Public License
++ * as published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU Lesser General Public
++ * License along with this program; if not, write the Free Software
++ * Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307,
++ * USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++
++#ifndef __DMAPI_H__
++#define __DMAPI_H__
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#ifndef __KERNEL__
++#include <sys/types.h>
++#endif
++#include <linux/types.h>
++
++#ifndef __user
++#define __user
++#endif
++
++/**************************************************************************
++ * *
++ * The SGI implementation of DMAPI is based upon the X/Open document *
++ * Systems Management: Data Storage Managment (XDSM) API *
++ * dated February 1997. Not all DMAPI functions and structure fields *
++ * have been implemented. Most importantly, the DMAPI functions *
++ * dm_request_right, dm_release_right, dm_query_right, dm_upgrade_right *
++ * and dm_downgrade_right do not work as described in the specification. *
++ * *
++ * The XFS filesystem currently does not allow its locking mechanisms to *
++ * be externally accessed from user space. While the above-mentioned *
++ * dm_xxx_right functions exist and can be called by applications, they *
++ * always return successfully without actually obtaining any locks *
++ * within the filesystem. *
++ * *
++ * Applications which do not need full rights support and which only *
++ * make dm_xxx_right calls in order to satisfy the input requirements of *
++ * other DMAPI calls should be able to use these routines to avoid *
++ * having to implement special-case code for SGI platforms. Applications *
++ * which truely need the capabilities of a full implementation of rights *
++ * will unfortunately have to come up with alternate software solutions *
++ * until such time as rights can be completely implemented. *
++ * *
++ * Functions and structure fields defined within this file which are not *
++ * supported in the SGI implementation of DMAPI are indicated by comments *
++ * following their definitions such as "not supported", or "not *
++ * completely supported". Any function or field not so marked may be *
++ * assumed to work exactly according to the spec. *
++ * *
++ **************************************************************************/
++
++
++
++/* The first portion of this file contains defines and typedefs that are
++ DMAPI implementation-dependent, and could be different on other platforms.
++*/
++
++typedef __s64 dm_attrloc_t;
++typedef unsigned int dm_boolean_t;
++typedef __u64 dm_eventset_t;
++typedef __u64 dm_fsid_t;
++typedef __u64 dm_ino_t;
++typedef __u32 dm_igen_t;
++typedef __s64 dm_off_t;
++typedef unsigned int dm_sequence_t;
++typedef int dm_sessid_t;
++typedef __u64 dm_size_t;
++typedef __s64 dm_ssize_t;
++typedef int dm_token_t;
++
++/* XXX dev_t, mode_t, and nlink_t are not the same size in kernel space
++ and user space. This affects the field offsets for dm_stat_t.
++ The following solution is temporary.
++
++ user space sizes: dev_t=8 mode_t=4 nlink_t=4
++ kernel space : dev_t=2 mode_t=2 nlink_t=2
++
++*/
++typedef __s64 dm_dev_t;
++typedef int dm_mode_t;
++typedef int dm_nlink_t;
++
++
++#define DM_REGION_NOEVENT 0x0
++#define DM_REGION_READ 0x1
++#define DM_REGION_WRITE 0x2
++#define DM_REGION_TRUNCATE 0x4
++
++/* Values for the mask argument used with dm_get_fileattr, dm_get_bulkattr,
++ dm_get_dirattrs, and dm_set_fileattr.
++*/
++
++#define DM_AT_MODE 0x0001
++#define DM_AT_UID 0x0002
++#define DM_AT_GID 0x0004
++#define DM_AT_ATIME 0x0008
++#define DM_AT_MTIME 0x0010
++#define DM_AT_CTIME 0x0020
++#define DM_AT_SIZE 0x0040
++#define DM_AT_DTIME 0x0080
++#define DM_AT_HANDLE 0x0100
++#define DM_AT_EMASK 0x0200
++#define DM_AT_PMANR 0x0400
++#define DM_AT_PATTR 0x0800
++#define DM_AT_STAT 0x1000
++#define DM_AT_CFLAG 0x2000
++
++#define DM_EV_WAIT 0x1 /* used in dm_get_events() */
++
++#define DM_MOUNT_RDONLY 0x1 /* me_mode field in dm_mount_event_t */
++
++#define DM_RR_WAIT 0x1
++
++#define DM_UNMOUNT_FORCE 0x1 /* ne_mode field in dm_namesp_event_t */
++
++#define DM_WRITE_SYNC 0x1 /* used in dm_write_invis() */
++
++#define DM_SESSION_INFO_LEN 256
++#define DM_NO_SESSION 0
++#define DM_TRUE 1
++#define DM_FALSE 0
++#define DM_INVALID_TOKEN 0
++#define DM_NO_TOKEN (-1)
++#define DM_INVALID_HANP NULL
++#define DM_INVALID_HLEN 0
++#define DM_GLOBAL_HANP ((void *)(1LL))
++#define DM_GLOBAL_HLEN ((size_t)(1))
++#define DM_VER_STR_CONTENTS "SGI DMAPI (XDSM) API, Release 1.1."
++
++
++#define DMEV_SET(event_type, event_list) \
++ ((event_list) |= (1 << (event_type)))
++#define DMEV_CLR(event_type, event_list) \
++ ((event_list) &= ~(1 << (event_type)))
++#define DMEV_ISSET(event_type, event_list) \
++ (int)(((event_list) & (1 << (event_type))) != 0)
++#define DMEV_ZERO(event_list) \
++ (event_list) = 0
++
++
++typedef struct {
++ int vd_offset; /* offset from start of containing struct */
++ unsigned int vd_length; /* length of data starting at vd_offset */
++} dm_vardata_t;
++
++#define DM_GET_VALUE(p, field, type) \
++ ((type) ((char *)(p) + (p)->field.vd_offset))
++
++#define DM_GET_LEN(p, field) \
++ ((p)->field.vd_length)
++
++#define DM_STEP_TO_NEXT(p, type) \
++ ((type) ((p)->_link ? (char *)(p) + (p)->_link : NULL))
++
++
++
++
++/* The remainder of this include file contains defines, typedefs, and
++ structures which are strictly defined by the DMAPI 2.3 specification.
++
++ (The _link field which appears in several structures is an
++ implementation-specific way to implement DM_STEP_TO_NEXT, and
++ should not be referenced directly by application code.)
++*/
++
++
++#define DM_ATTR_NAME_SIZE 8
++
++
++struct dm_attrname {
++ unsigned char an_chars[DM_ATTR_NAME_SIZE];
++};
++typedef struct dm_attrname dm_attrname_t;
++
++
++struct dm_attrlist {
++ int _link;
++ dm_attrname_t al_name;
++ dm_vardata_t al_data;
++};
++typedef struct dm_attrlist dm_attrlist_t;
++
++
++typedef enum {
++ DM_CONFIG_INVALID,
++ DM_CONFIG_BULKALL,
++ DM_CONFIG_CREATE_BY_HANDLE,
++ DM_CONFIG_DTIME_OVERLOAD,
++ DM_CONFIG_LEGACY,
++ DM_CONFIG_LOCK_UPGRADE,
++ DM_CONFIG_MAX_ATTR_ON_DESTROY,
++ DM_CONFIG_MAX_ATTRIBUTE_SIZE,
++ DM_CONFIG_MAX_HANDLE_SIZE,
++ DM_CONFIG_MAX_MANAGED_REGIONS,
++ DM_CONFIG_MAX_MESSAGE_DATA,
++ DM_CONFIG_OBJ_REF,
++ DM_CONFIG_PENDING,
++ DM_CONFIG_PERS_ATTRIBUTES,
++ DM_CONFIG_PERS_EVENTS,
++ DM_CONFIG_PERS_INHERIT_ATTRIBS,
++ DM_CONFIG_PERS_MANAGED_REGIONS,
++ DM_CONFIG_PUNCH_HOLE,
++ DM_CONFIG_TOTAL_ATTRIBUTE_SPACE,
++ DM_CONFIG_WILL_RETRY
++} dm_config_t;
++
++
++struct dm_dioinfo { /* non-standard SGI addition */
++ unsigned int d_mem;
++ unsigned int d_miniosz;
++ unsigned int d_maxiosz;
++ dm_boolean_t d_dio_only;
++};
++typedef struct dm_dioinfo dm_dioinfo_t;
++
++
++struct dm_dispinfo {
++ int _link;
++ unsigned int di_pad1; /* reserved; do not reference */
++ dm_vardata_t di_fshandle;
++ dm_eventset_t di_eventset;
++};
++typedef struct dm_dispinfo dm_dispinfo_t;
++
++
++#ifndef HAVE_DM_EVENTTYPE_T
++#define HAVE_DM_EVENTTYPE_T
++typedef enum {
++ DM_EVENT_INVALID = -1,
++ DM_EVENT_CANCEL = 0, /* not supported */
++ DM_EVENT_MOUNT = 1,
++ DM_EVENT_PREUNMOUNT = 2,
++ DM_EVENT_UNMOUNT = 3,
++ DM_EVENT_DEBUT = 4, /* not supported */
++ DM_EVENT_CREATE = 5,
++ DM_EVENT_CLOSE = 6, /* not supported */
++ DM_EVENT_POSTCREATE = 7,
++ DM_EVENT_REMOVE = 8,
++ DM_EVENT_POSTREMOVE = 9,
++ DM_EVENT_RENAME = 10,
++ DM_EVENT_POSTRENAME = 11,
++ DM_EVENT_LINK = 12,
++ DM_EVENT_POSTLINK = 13,
++ DM_EVENT_SYMLINK = 14,
++ DM_EVENT_POSTSYMLINK = 15,
++ DM_EVENT_READ = 16,
++ DM_EVENT_WRITE = 17,
++ DM_EVENT_TRUNCATE = 18,
++ DM_EVENT_ATTRIBUTE = 19,
++ DM_EVENT_DESTROY = 20,
++ DM_EVENT_NOSPACE = 21,
++ DM_EVENT_USER = 22,
++ DM_EVENT_MAX = 23
++} dm_eventtype_t;
++#endif
++
++
++struct dm_eventmsg {
++ int _link;
++ dm_eventtype_t ev_type;
++ dm_token_t ev_token;
++ dm_sequence_t ev_sequence;
++ dm_vardata_t ev_data;
++};
++typedef struct dm_eventmsg dm_eventmsg_t;
++
++
++struct dm_cancel_event { /* not supported */
++ dm_sequence_t ce_sequence;
++ dm_token_t ce_token;
++};
++typedef struct dm_cancel_event dm_cancel_event_t;
++
++
++struct dm_data_event {
++ dm_vardata_t de_handle;
++ dm_off_t de_offset;
++ dm_size_t de_length;
++};
++typedef struct dm_data_event dm_data_event_t;
++
++struct dm_destroy_event {
++ dm_vardata_t ds_handle;
++ dm_attrname_t ds_attrname;
++ dm_vardata_t ds_attrcopy;
++};
++typedef struct dm_destroy_event dm_destroy_event_t;
++
++struct dm_mount_event {
++ dm_mode_t me_mode;
++ dm_vardata_t me_handle1;
++ dm_vardata_t me_handle2;
++ dm_vardata_t me_name1;
++ dm_vardata_t me_name2;
++ dm_vardata_t me_roothandle;
++};
++typedef struct dm_mount_event dm_mount_event_t;
++
++struct dm_namesp_event {
++ dm_mode_t ne_mode;
++ dm_vardata_t ne_handle1;
++ dm_vardata_t ne_handle2;
++ dm_vardata_t ne_name1;
++ dm_vardata_t ne_name2;
++ int ne_retcode;
++};
++typedef struct dm_namesp_event dm_namesp_event_t;
++
++
++typedef enum {
++ DM_EXTENT_INVALID,
++ DM_EXTENT_RES,
++ DM_EXTENT_HOLE
++} dm_extenttype_t;
++
++
++struct dm_extent {
++ dm_extenttype_t ex_type;
++ unsigned int ex_pad1; /* reserved; do not reference */
++ dm_off_t ex_offset;
++ dm_size_t ex_length;
++};
++typedef struct dm_extent dm_extent_t;
++
++struct dm_fileattr {
++ dm_mode_t fa_mode;
++ uid_t fa_uid;
++ gid_t fa_gid;
++ time_t fa_atime;
++ time_t fa_mtime;
++ time_t fa_ctime;
++ time_t fa_dtime;
++ unsigned int fa_pad1; /* reserved; do not reference */
++ dm_off_t fa_size;
++};
++typedef struct dm_fileattr dm_fileattr_t;
++
++
++struct dm_inherit { /* not supported */
++ dm_attrname_t ih_name;
++ dm_mode_t ih_filetype;
++};
++typedef struct dm_inherit dm_inherit_t;
++
++
++typedef enum {
++ DM_MSGTYPE_INVALID,
++ DM_MSGTYPE_SYNC,
++ DM_MSGTYPE_ASYNC
++} dm_msgtype_t;
++
++
++struct dm_region {
++ dm_off_t rg_offset;
++ dm_size_t rg_size;
++ unsigned int rg_flags;
++ unsigned int rg_pad1; /* reserved; do not reference */
++};
++typedef struct dm_region dm_region_t;
++
++
++typedef enum {
++ DM_RESP_INVALID,
++ DM_RESP_CONTINUE,
++ DM_RESP_ABORT,
++ DM_RESP_DONTCARE
++} dm_response_t;
++
++
++#ifndef HAVE_DM_RIGHT_T
++#define HAVE_DM_RIGHT_T
++typedef enum {
++ DM_RIGHT_NULL,
++ DM_RIGHT_SHARED,
++ DM_RIGHT_EXCL
++} dm_right_t;
++#endif
++
++
++struct dm_stat {
++ int _link;
++ dm_vardata_t dt_handle;
++ dm_vardata_t dt_compname;
++ int dt_nevents;
++ dm_eventset_t dt_emask;
++ int dt_pers; /* field not supported */
++ int dt_pmanreg;
++ time_t dt_dtime;
++ unsigned int dt_change; /* field not supported */
++ unsigned int dt_pad1; /* reserved; do not reference */
++ dm_dev_t dt_dev;
++ dm_ino_t dt_ino;
++ dm_mode_t dt_mode;
++ dm_nlink_t dt_nlink;
++ uid_t dt_uid;
++ gid_t dt_gid;
++ dm_dev_t dt_rdev;
++ unsigned int dt_pad2; /* reserved; do not reference */
++ dm_off_t dt_size;
++ time_t dt_atime;
++ time_t dt_mtime;
++ time_t dt_ctime;
++ unsigned int dt_blksize;
++ dm_size_t dt_blocks;
++
++ /* Non-standard filesystem-specific fields. Currently XFS is the only
++ supported filesystem type.
++ */
++
++ __u64 dt_pad3; /* reserved; do not reference */
++ int dt_fstype; /* filesystem index; see sysfs(2) */
++ union {
++ struct {
++ dm_igen_t igen;
++ unsigned int xflags;
++ unsigned int extsize;
++ unsigned int extents;
++ unsigned short aextents;
++ unsigned short dmstate;
++ } sgi_xfs;
++ } fsys_dep;
++};
++typedef struct dm_stat dm_stat_t;
++
++#define dt_xfs_igen fsys_dep.sgi_xfs.igen
++#define dt_xfs_xflags fsys_dep.sgi_xfs.xflags
++#define dt_xfs_extsize fsys_dep.sgi_xfs.extsize
++#define dt_xfs_extents fsys_dep.sgi_xfs.extents
++#define dt_xfs_aextents fsys_dep.sgi_xfs.aextents
++#define dt_xfs_dmstate fsys_dep.sgi_xfs.dmstate
++
++/* Flags for the non-standard dt_xfs_xflags field. */
++
++#define DM_XFLAG_REALTIME 0x00000001
++#define DM_XFLAG_PREALLOC 0x00000002
++#define DM_XFLAG_IMMUTABLE 0x00000008
++#define DM_XFLAG_APPEND 0x00000010
++#define DM_XFLAG_SYNC 0x00000020
++#define DM_XFLAG_NOATIME 0x00000040
++#define DM_XFLAG_NODUMP 0x00000080
++#define DM_XFLAG_HASATTR 0x80000000
++
++
++struct dm_timestruct {
++ time_t dm_tv_sec;
++ int dm_tv_nsec;
++};
++typedef struct dm_timestruct dm_timestruct_t;
++
++
++struct dm_xstat { /* not supported */
++ dm_stat_t dx_statinfo;
++ dm_vardata_t dx_attrdata;
++};
++typedef struct dm_xstat dm_xstat_t;
++
++
++#define MAXDMFSFIDSZ 46
++
++struct dm_fid {
++ __u16 dm_fid_len; /* length of remainder */
++ __u16 dm_fid_pad;
++ __u32 dm_fid_gen; /* generation number */
++ __u64 dm_fid_ino; /* 64 bits inode number */
++};
++typedef struct dm_fid dm_fid_t;
++
++
++struct dm_handle {
++ union {
++ __s64 align; /* force alignment of ha_fid */
++ dm_fsid_t _ha_fsid; /* unique file system identifier */
++ } ha_u;
++ dm_fid_t ha_fid; /* file system specific file ID */
++};
++typedef struct dm_handle dm_handle_t;
++#define ha_fsid ha_u._ha_fsid
++
++#define DM_HSIZE(handle) (((char *) &(handle).ha_fid.dm_fid_pad \
++ - (char *) &(handle)) \
++ + (handle).ha_fid.dm_fid_len)
++
++#define DM_HANDLE_CMP(h1, h2) memcmp(h1, h2, sizeof(dm_handle_t))
++
++#define DM_FSHSIZE sizeof(dm_fsid_t)
++
++
++/* The following list provides the prototypes for all functions defined in
++ the DMAPI interface.
++*/
++
++extern int
++dm_clear_inherit( /* not supported */
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrname_t __user *attrnamep);
++
++extern int
++dm_create_by_handle( /* not supported */
++ dm_sessid_t sid,
++ void __user *dirhanp,
++ size_t dirhlen,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen,
++ char __user *cname);
++
++extern int
++dm_create_session(
++ dm_sessid_t oldsid,
++ char __user *sessinfop,
++ dm_sessid_t __user *newsidp);
++
++extern int
++dm_create_userevent(
++ dm_sessid_t sid,
++ size_t msglen,
++ void __user *msgdatap,
++ dm_token_t __user *tokenp);
++
++extern int
++dm_destroy_session(
++ dm_sessid_t sid);
++
++extern int
++dm_downgrade_right( /* not completely supported; see caveat above */
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token);
++
++extern int
++dm_fd_to_handle(
++ int fd,
++ void **hanpp,
++ size_t *hlenp);
++
++extern int
++dm_find_eventmsg(
++ dm_sessid_t sid,
++ dm_token_t token,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp);
++
++extern int
++dm_get_allocinfo(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_off_t *offp,
++ unsigned int nelem,
++ dm_extent_t *extentp,
++ unsigned int *nelemp);
++
++extern int
++dm_get_bulkall( /* not supported */
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ unsigned int mask,
++ dm_attrname_t *attrnamep,
++ dm_attrloc_t *locp,
++ size_t buflen,
++ void *bufp,
++ size_t *rlenp);
++
++extern int
++dm_get_bulkattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ unsigned int mask,
++ dm_attrloc_t *locp,
++ size_t buflen,
++ void *bufp,
++ size_t *rlenp);
++
++extern int
++dm_get_config(
++ void __user *hanp,
++ size_t hlen,
++ dm_config_t flagname,
++ dm_size_t __user *retvalp);
++
++extern int
++dm_get_config_events(
++ void __user *hanp,
++ size_t hlen,
++ unsigned int nelem,
++ dm_eventset_t __user *eventsetp,
++ unsigned int __user *nelemp);
++
++extern int
++dm_get_dirattrs(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ unsigned int mask,
++ dm_attrloc_t *locp,
++ size_t buflen,
++ void *bufp,
++ size_t *rlenp);
++
++extern int
++dm_get_dmattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrname_t __user *attrnamep,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp);
++
++extern int
++dm_get_eventlist(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ unsigned int nelem,
++ dm_eventset_t __user *eventsetp,
++ unsigned int __user *nelemp);
++
++extern int
++dm_get_events(
++ dm_sessid_t sid,
++ unsigned int maxmsgs,
++ unsigned int flags,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp);
++
++extern int
++dm_get_fileattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ unsigned int mask,
++ dm_stat_t __user *statp);
++
++extern int
++dm_get_mountinfo(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp);
++
++extern int
++dm_get_region(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ unsigned int nelem,
++ dm_region_t __user *regbufp,
++ unsigned int __user *nelemp);
++
++extern int
++dm_getall_disp(
++ dm_sessid_t sid,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp);
++
++extern int
++dm_getall_dmattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp);
++
++extern int
++dm_getall_inherit( /* not supported */
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ unsigned int nelem,
++ dm_inherit_t __user *inheritbufp,
++ unsigned int __user *nelemp);
++
++extern int
++dm_getall_sessions(
++ unsigned int nelem,
++ dm_sessid_t __user *sidbufp,
++ unsigned int __user *nelemp);
++
++extern int
++dm_getall_tokens(
++ dm_sessid_t sid,
++ unsigned int nelem,
++ dm_token_t __user *tokenbufp,
++ unsigned int __user *nelemp);
++
++extern int
++dm_handle_cmp(
++ void *hanp1,
++ size_t hlen1,
++ void *hanp2,
++ size_t hlen2);
++
++extern void
++dm_handle_free(
++ void *hanp,
++ size_t hlen);
++
++extern u_int
++dm_handle_hash(
++ void *hanp,
++ size_t hlen);
++
++extern dm_boolean_t
++dm_handle_is_valid(
++ void *hanp,
++ size_t hlen);
++
++extern int
++dm_handle_to_fshandle(
++ void *hanp,
++ size_t hlen,
++ void **fshanpp,
++ size_t *fshlenp);
++
++extern int
++dm_handle_to_fsid(
++ void *hanp,
++ size_t hlen,
++ dm_fsid_t *fsidp);
++
++extern int
++dm_handle_to_igen(
++ void *hanp,
++ size_t hlen,
++ dm_igen_t *igenp);
++
++extern int
++dm_handle_to_ino(
++ void *hanp,
++ size_t hlen,
++ dm_ino_t *inop);
++
++extern int
++dm_handle_to_path(
++ void *dirhanp,
++ size_t dirhlen,
++ void *targhanp,
++ size_t targhlen,
++ size_t buflen,
++ char *pathbufp,
++ size_t *rlenp);
++
++extern int
++dm_init_attrloc(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrloc_t __user *locp);
++
++extern int
++dm_init_service(
++ char **versionstrpp);
++
++extern int
++dm_make_handle(
++ dm_fsid_t *fsidp,
++ dm_ino_t *inop,
++ dm_igen_t *igenp,
++ void **hanpp,
++ size_t *hlenp);
++
++extern int
++dm_make_fshandle(
++ dm_fsid_t *fsidp,
++ void **hanpp,
++ size_t *hlenp);
++
++extern int
++dm_mkdir_by_handle( /* not supported */
++ dm_sessid_t sid,
++ void __user *dirhanp,
++ size_t dirhlen,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen,
++ char __user *cname);
++
++extern int
++dm_move_event(
++ dm_sessid_t srcsid,
++ dm_token_t token,
++ dm_sessid_t targetsid,
++ dm_token_t __user *rtokenp);
++
++extern int
++dm_obj_ref_hold(
++ dm_sessid_t sid,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen);
++
++extern int
++dm_obj_ref_query(
++ dm_sessid_t sid,
++ dm_token_t token,
++ void *hanp,
++ size_t hlen);
++
++extern int
++dm_obj_ref_rele(
++ dm_sessid_t sid,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen);
++
++extern int
++dm_path_to_fshandle(
++ char *path,
++ void **hanpp,
++ size_t *hlenp);
++
++extern int
++dm_path_to_handle(
++ char *path,
++ void **hanpp,
++ size_t *hlenp);
++
++extern int
++dm_pending(
++ dm_sessid_t sid,
++ dm_token_t token,
++ dm_timestruct_t __user *delay);
++
++extern int
++dm_probe_hole(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_off_t off,
++ dm_size_t len,
++ dm_off_t __user *roffp,
++ dm_size_t __user *rlenp);
++
++extern int
++dm_punch_hole(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_off_t off,
++ dm_size_t len);
++
++extern int
++dm_query_right( /* not completely supported; see caveat above */
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_right_t __user *rightp);
++
++extern int
++dm_query_session(
++ dm_sessid_t sid,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp);
++
++extern dm_ssize_t
++dm_read_invis(
++ dm_sessid_t sid,
++ void *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_off_t off,
++ dm_size_t len,
++ void *bufp);
++
++extern int
++dm_release_right( /* not completely supported; see caveat above */
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token);
++
++extern int
++dm_remove_dmattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ int setdtime,
++ dm_attrname_t __user *attrnamep);
++
++extern int
++dm_request_right( /* not completely supported; see caveat above */
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ unsigned int flags,
++ dm_right_t right);
++
++extern int
++dm_respond_event(
++ dm_sessid_t sid,
++ dm_token_t token,
++ dm_response_t response,
++ int reterror,
++ size_t buflen,
++ void __user *respbufp);
++
++extern int
++dm_send_msg(
++ dm_sessid_t targetsid,
++ dm_msgtype_t msgtype,
++ size_t buflen,
++ void __user *bufp);
++
++extern int
++dm_set_disp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_eventset_t __user *eventsetp,
++ unsigned int maxevent);
++
++extern int
++dm_set_dmattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrname_t __user *attrnamep,
++ int setdtime,
++ size_t buflen,
++ void __user *bufp);
++
++extern int
++dm_set_eventlist(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_eventset_t __user *eventsetp,
++ unsigned int maxevent);
++
++extern int
++dm_set_fileattr(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ unsigned int mask,
++ dm_fileattr_t __user *attrp);
++
++extern int
++dm_set_inherit( /* not supported */
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrname_t __user *attrnamep,
++ mode_t mode);
++
++extern int
++dm_set_region(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ unsigned int nelem,
++ dm_region_t __user *regbufp,
++ dm_boolean_t __user *exactflagp);
++
++extern int
++dm_set_return_on_destroy(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrname_t __user *attrnamep,
++ dm_boolean_t enable);
++
++extern int
++dm_symlink_by_handle( /* not supported */
++ dm_sessid_t sid,
++ void __user *dirhanp,
++ size_t dirhlen,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen,
++ char __user *cname,
++ char __user *path);
++
++extern int
++dm_sync_by_handle(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token);
++
++extern int
++dm_upgrade_right( /* not completely supported; see caveat above */
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token);
++
++extern dm_ssize_t
++dm_write_invis(
++ dm_sessid_t sid,
++ void *hanp,
++ size_t hlen,
++ dm_token_t token,
++ int flags,
++ dm_off_t off,
++ dm_size_t len,
++ void *bufp);
++
++/* Non-standard SGI additions to the DMAPI interface. */
++
++int
++dm_open_by_handle(
++ void __user *hanp,
++ size_t hlen,
++ int mode);
++
++extern int
++dm_get_dioinfo(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_dioinfo_t __user *diop);
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* __DMAPI_H__ */
+Index: linux-2.6.26/fs/dmapi/dmapi_handle.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_handle.c
+@@ -0,0 +1,119 @@
++/*
++ * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++
++int
++dm_create_by_handle(
++ dm_sessid_t sid,
++ void __user *dirhanp,
++ size_t dirhlen,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen,
++ char __user *cname)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, dirhanp, dirhlen, token, DM_TDT_DIR,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->create_by_handle(tdp->td_ip, tdp->td_right,
++ hanp, hlen, cname);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_mkdir_by_handle(
++ dm_sessid_t sid,
++ void __user *dirhanp,
++ size_t dirhlen,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen,
++ char __user *cname)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, dirhanp, dirhlen, token, DM_TDT_DIR,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->mkdir_by_handle(tdp->td_ip, tdp->td_right,
++ hanp, hlen, cname);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_symlink_by_handle(
++ dm_sessid_t sid,
++ void __user *dirhanp,
++ size_t dirhlen,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen,
++ char __user *cname,
++ char __user *path)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, dirhanp, dirhlen, token, DM_TDT_DIR,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->symlink_by_handle(tdp->td_ip, tdp->td_right,
++ hanp, hlen, cname, path);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
+Index: linux-2.6.26/fs/dmapi/dmapi_hole.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_hole.c
+@@ -0,0 +1,119 @@
++/*
++ * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++
++int
++dm_get_allocinfo_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_off_t __user *offp,
++ u_int nelem,
++ dm_extent_t __user *extentp,
++ u_int __user *nelemp,
++ int *rvp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_REG,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->get_allocinfo_rvp(tdp->td_ip, tdp->td_right,
++ offp, nelem, extentp, nelemp, rvp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_probe_hole(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_off_t off,
++ dm_size_t len,
++ dm_off_t __user *roffp,
++ dm_size_t __user *rlenp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_REG,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->probe_hole(tdp->td_ip, tdp->td_right,
++ off, len, roffp, rlenp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_punch_hole(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_off_t off,
++ dm_size_t len)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_REG,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->punch_hole(tdp->td_ip, tdp->td_right, off, len);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
+Index: linux-2.6.26/fs/dmapi/dmapi_io.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_io.c
+@@ -0,0 +1,142 @@
++/*
++ * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++
++int
++dm_read_invis_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_off_t off,
++ dm_size_t len,
++ void __user *bufp,
++ int *rvp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_REG,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->read_invis_rvp(tdp->td_ip, tdp->td_right,
++ off, len, bufp, rvp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_write_invis_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ int flags,
++ dm_off_t off,
++ dm_size_t len,
++ void __user *bufp,
++ int *rvp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_REG,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->write_invis_rvp(tdp->td_ip, tdp->td_right,
++ flags, off, len, bufp, rvp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_sync_by_handle (
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_REG,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->sync_by_handle(tdp->td_ip, tdp->td_right);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_get_dioinfo (
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_dioinfo_t __user *diop)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_REG,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->get_dioinfo(tdp->td_ip, tdp->td_right, diop);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
+Index: linux-2.6.26/fs/dmapi/dmapi_kern.h
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_kern.h
+@@ -0,0 +1,599 @@
++/*
++ * Copyright (c) 2000-2005 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++
++#ifndef __DMAPI_KERN_H__
++#define __DMAPI_KERN_H__
++
++#include <linux/fs.h>
++
++union sys_dmapi_uarg {
++ void *p;
++ __u64 u;
++};
++typedef union sys_dmapi_uarg sys_dmapi_u;
++
++struct sys_dmapi_args {
++ sys_dmapi_u uarg1, uarg2, uarg3, uarg4, uarg5, uarg6, uarg7, uarg8,
++ uarg9, uarg10, uarg11;
++};
++typedef struct sys_dmapi_args sys_dmapi_args_t;
++
++#define DM_Uarg(uap,i) uap->uarg##i.u
++#define DM_Parg(uap,i) uap->uarg##i.p
++
++#ifdef __KERNEL__
++
++struct dm_handle_t;
++
++/* The first group of definitions and prototypes define the filesystem's
++ interface into the DMAPI code.
++*/
++
++
++/* Definitions used for the flags field on dm_send_data_event(),
++ dm_send_unmount_event(), and dm_send_namesp_event() calls.
++*/
++
++#define DM_FLAGS_NDELAY 0x001 /* return EAGAIN after dm_pending() */
++#define DM_FLAGS_UNWANTED 0x002 /* event not in fsys dm_eventset_t */
++
++/* Possible code levels reported by dm_code_level(). */
++
++#define DM_CLVL_INIT 0 /* DMAPI prior to X/Open compliance */
++#define DM_CLVL_XOPEN 1 /* X/Open compliant DMAPI */
++
++
++/*
++ * Filesystem operations accessed by the DMAPI core.
++ */
++struct filesystem_dmapi_operations {
++ int (*get_fsys_vector)(struct super_block *sb, void *addr);
++ int (*fh_to_inode)(struct super_block *sb, struct inode **ip,
++ dm_fid_t *fid);
++ const struct file_operations * (*get_invis_ops)(struct inode *ip);
++ int (*inode_to_fh)(struct inode *ip, dm_fid_t *fid,
++ dm_fsid_t *fsid );
++ void (*get_fsid)(struct super_block *sb, dm_fsid_t *fsid);
++#define HAVE_DM_QUEUE_FLUSH
++ int (*flushing)(struct inode *ip);
++};
++
++
++/* Prototypes used outside of the DMI module/directory. */
++
++int dm_send_data_event(
++ dm_eventtype_t event,
++ struct inode *ip,
++ dm_right_t vp_right,
++ dm_off_t off,
++ size_t len,
++ int flags);
++
++int dm_send_destroy_event(
++ struct inode *ip,
++ dm_right_t vp_right);
++
++int dm_send_mount_event(
++ struct super_block *sb,
++ dm_right_t vfsp_right,
++ struct inode *ip,
++ dm_right_t vp_right,
++ struct inode *rootip,
++ dm_right_t rootvp_right,
++ char *name1,
++ char *name2);
++
++int dm_send_namesp_event(
++ dm_eventtype_t event,
++ struct super_block *sb,
++ struct inode *ip1,
++ dm_right_t vp1_right,
++ struct inode *ip2,
++ dm_right_t vp2_right,
++ const char *name1,
++ const char *name2,
++ mode_t mode,
++ int retcode,
++ int flags);
++
++void dm_send_unmount_event(
++ struct super_block *sbp,
++ struct inode *ip,
++ dm_right_t sbp_right,
++ mode_t mode,
++ int retcode,
++ int flags);
++
++int dm_code_level(void);
++
++int dm_ip_to_handle (
++ struct inode *ip,
++ dm_handle_t *handlep);
++
++#define HAVE_DM_RELEASE_THREADS_ERRNO
++int dm_release_threads(
++ struct super_block *sb,
++ struct inode *inode,
++ int errno);
++
++void dmapi_register(
++ struct file_system_type *fstype,
++ struct filesystem_dmapi_operations *dmapiops);
++
++void dmapi_unregister(
++ struct file_system_type *fstype);
++
++int dmapi_registered(
++ struct file_system_type *fstype,
++ struct filesystem_dmapi_operations **dmapiops);
++
++
++/* The following prototypes and definitions are used by DMAPI as its
++ interface into the filesystem code. Communication between DMAPI and the
++ filesystem are established as follows:
++ 1. DMAPI uses the VFS_DMAPI_FSYS_VECTOR to ask for the addresses
++ of all the functions within the filesystem that it may need to call.
++ 2. The filesystem returns an array of function name/address pairs which
++ DMAPI builds into a function vector.
++ The VFS_DMAPI_FSYS_VECTOR call is only made one time for a particular
++ filesystem type. From then on, DMAPI uses its function vector to call the
++ filesystem functions directly. Functions in the array which DMAPI doesn't
++ recognize are ignored. A dummy function which returns ENOSYS is used for
++ any function that DMAPI needs but which was not provided by the filesystem.
++ If XFS doesn't recognize the VFS_DMAPI_FSYS_VECTOR, DMAPI assumes that it
++ doesn't have the X/Open support code; in this case DMAPI uses the XFS-code
++ originally bundled within DMAPI.
++
++ The goal of this interface is allow incremental changes to be made to
++ both the filesystem and to DMAPI while minimizing inter-patch dependencies,
++ and to eventually allow DMAPI to support multiple filesystem types at the
++ same time should that become necessary.
++*/
++
++typedef enum {
++ DM_FSYS_CLEAR_INHERIT = 0,
++ DM_FSYS_CREATE_BY_HANDLE = 1,
++ DM_FSYS_DOWNGRADE_RIGHT = 2,
++ DM_FSYS_GET_ALLOCINFO_RVP = 3,
++ DM_FSYS_GET_BULKALL_RVP = 4,
++ DM_FSYS_GET_BULKATTR_RVP = 5,
++ DM_FSYS_GET_CONFIG = 6,
++ DM_FSYS_GET_CONFIG_EVENTS = 7,
++ DM_FSYS_GET_DESTROY_DMATTR = 8,
++ DM_FSYS_GET_DIOINFO = 9,
++ DM_FSYS_GET_DIRATTRS_RVP = 10,
++ DM_FSYS_GET_DMATTR = 11,
++ DM_FSYS_GET_EVENTLIST = 12,
++ DM_FSYS_GET_FILEATTR = 13,
++ DM_FSYS_GET_REGION = 14,
++ DM_FSYS_GETALL_DMATTR = 15,
++ DM_FSYS_GETALL_INHERIT = 16,
++ DM_FSYS_INIT_ATTRLOC = 17,
++ DM_FSYS_MKDIR_BY_HANDLE = 18,
++ DM_FSYS_PROBE_HOLE = 19,
++ DM_FSYS_PUNCH_HOLE = 20,
++ DM_FSYS_READ_INVIS_RVP = 21,
++ DM_FSYS_RELEASE_RIGHT = 22,
++ DM_FSYS_REMOVE_DMATTR = 23,
++ DM_FSYS_REQUEST_RIGHT = 24,
++ DM_FSYS_SET_DMATTR = 25,
++ DM_FSYS_SET_EVENTLIST = 26,
++ DM_FSYS_SET_FILEATTR = 27,
++ DM_FSYS_SET_INHERIT = 28,
++ DM_FSYS_SET_REGION = 29,
++ DM_FSYS_SYMLINK_BY_HANDLE = 30,
++ DM_FSYS_SYNC_BY_HANDLE = 31,
++ DM_FSYS_UPGRADE_RIGHT = 32,
++ DM_FSYS_WRITE_INVIS_RVP = 33,
++ DM_FSYS_OBJ_REF_HOLD = 34,
++ DM_FSYS_MAX = 35
++} dm_fsys_switch_t;
++
++
++#define DM_FSYS_OBJ 0x1 /* object refers to a fsys handle */
++
++
++/*
++ * Prototypes for filesystem-specific functions.
++ */
++
++typedef int (*dm_fsys_clear_inherit_t)(
++ struct inode *ip,
++ dm_right_t right,
++ dm_attrname_t __user *attrnamep);
++
++typedef int (*dm_fsys_create_by_handle_t)(
++ struct inode *ip,
++ dm_right_t right,
++ void __user *hanp,
++ size_t hlen,
++ char __user *cname);
++
++typedef int (*dm_fsys_downgrade_right_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int type); /* DM_FSYS_OBJ or zero */
++
++typedef int (*dm_fsys_get_allocinfo_rvp_t)(
++ struct inode *ip,
++ dm_right_t right,
++ dm_off_t __user *offp,
++ u_int nelem,
++ dm_extent_t __user *extentp,
++ u_int __user *nelemp,
++ int *rvalp);
++
++typedef int (*dm_fsys_get_bulkall_rvp_t)(
++ struct inode *ip, /* root inode */
++ dm_right_t right,
++ u_int mask,
++ dm_attrname_t __user *attrnamep,
++ dm_attrloc_t __user *locp,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp,
++ int *rvalp);
++
++typedef int (*dm_fsys_get_bulkattr_rvp_t)(
++ struct inode *ip, /* root inode */
++ dm_right_t right,
++ u_int mask,
++ dm_attrloc_t __user *locp,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp,
++ int *rvalp);
++
++typedef int (*dm_fsys_get_config_t)(
++ struct inode *ip,
++ dm_right_t right,
++ dm_config_t flagname,
++ dm_size_t __user *retvalp);
++
++typedef int (*dm_fsys_get_config_events_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int nelem,
++ dm_eventset_t __user *eventsetp,
++ u_int __user *nelemp);
++
++typedef int (*dm_fsys_get_destroy_dmattr_t)(
++ struct inode *ip,
++ dm_right_t right,
++ dm_attrname_t *attrnamep,
++ char **valuepp,
++ int *vlenp);
++
++typedef int (*dm_fsys_get_dioinfo_t)(
++ struct inode *ip,
++ dm_right_t right,
++ dm_dioinfo_t __user *diop);
++
++typedef int (*dm_fsys_get_dirattrs_rvp_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int mask,
++ dm_attrloc_t __user *locp,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp,
++ int *rvalp);
++
++typedef int (*dm_fsys_get_dmattr_t)(
++ struct inode *ip,
++ dm_right_t right,
++ dm_attrname_t __user *attrnamep,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp);
++
++typedef int (*dm_fsys_get_eventlist_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int type,
++ u_int nelem,
++ dm_eventset_t *eventsetp, /* in kernel space! */
++ u_int *nelemp); /* in kernel space! */
++
++typedef int (*dm_fsys_get_fileattr_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int mask,
++ dm_stat_t __user *statp);
++
++typedef int (*dm_fsys_get_region_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int nelem,
++ dm_region_t __user *regbufp,
++ u_int __user *nelemp);
++
++typedef int (*dm_fsys_getall_dmattr_t)(
++ struct inode *ip,
++ dm_right_t right,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp);
++
++typedef int (*dm_fsys_getall_inherit_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int nelem,
++ dm_inherit_t __user *inheritbufp,
++ u_int __user *nelemp);
++
++typedef int (*dm_fsys_init_attrloc_t)(
++ struct inode *ip, /* sometimes root inode */
++ dm_right_t right,
++ dm_attrloc_t __user *locp);
++
++typedef int (*dm_fsys_mkdir_by_handle_t)(
++ struct inode *ip,
++ dm_right_t right,
++ void __user *hanp,
++ size_t hlen,
++ char __user *cname);
++
++typedef int (*dm_fsys_probe_hole_t)(
++ struct inode *ip,
++ dm_right_t right,
++ dm_off_t off,
++ dm_size_t len,
++ dm_off_t __user *roffp,
++ dm_size_t __user *rlenp);
++
++typedef int (*dm_fsys_punch_hole_t)(
++ struct inode *ip,
++ dm_right_t right,
++ dm_off_t off,
++ dm_size_t len);
++
++typedef int (*dm_fsys_read_invis_rvp_t)(
++ struct inode *ip,
++ dm_right_t right,
++ dm_off_t off,
++ dm_size_t len,
++ void __user *bufp,
++ int *rvp);
++
++typedef int (*dm_fsys_release_right_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int type);
++
++typedef int (*dm_fsys_remove_dmattr_t)(
++ struct inode *ip,
++ dm_right_t right,
++ int setdtime,
++ dm_attrname_t __user *attrnamep);
++
++typedef int (*dm_fsys_request_right_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int type, /* DM_FSYS_OBJ or zero */
++ u_int flags,
++ dm_right_t newright);
++
++typedef int (*dm_fsys_set_dmattr_t)(
++ struct inode *ip,
++ dm_right_t right,
++ dm_attrname_t __user *attrnamep,
++ int setdtime,
++ size_t buflen,
++ void __user *bufp);
++
++typedef int (*dm_fsys_set_eventlist_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int type,
++ dm_eventset_t *eventsetp, /* in kernel space! */
++ u_int maxevent);
++
++typedef int (*dm_fsys_set_fileattr_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int mask,
++ dm_fileattr_t __user *attrp);
++
++typedef int (*dm_fsys_set_inherit_t)(
++ struct inode *ip,
++ dm_right_t right,
++ dm_attrname_t __user *attrnamep,
++ mode_t mode);
++
++typedef int (*dm_fsys_set_region_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int nelem,
++ dm_region_t __user *regbufp,
++ dm_boolean_t __user *exactflagp);
++
++typedef int (*dm_fsys_symlink_by_handle_t)(
++ struct inode *ip,
++ dm_right_t right,
++ void __user *hanp,
++ size_t hlen,
++ char __user *cname,
++ char __user *path);
++
++typedef int (*dm_fsys_sync_by_handle_t)(
++ struct inode *ip,
++ dm_right_t right);
++
++typedef int (*dm_fsys_upgrade_right_t)(
++ struct inode *ip,
++ dm_right_t right,
++ u_int type); /* DM_FSYS_OBJ or zero */
++
++typedef int (*dm_fsys_write_invis_rvp_t)(
++ struct inode *ip,
++ dm_right_t right,
++ int flags,
++ dm_off_t off,
++ dm_size_t len,
++ void __user *bufp,
++ int *rvp);
++
++typedef void (*dm_fsys_obj_ref_hold_t)(
++ struct inode *ip);
++
++
++/* Structure definitions used by the VFS_DMAPI_FSYS_VECTOR call. */
++
++typedef struct {
++ dm_fsys_switch_t func_no; /* function number */
++ union {
++ dm_fsys_clear_inherit_t clear_inherit;
++ dm_fsys_create_by_handle_t create_by_handle;
++ dm_fsys_downgrade_right_t downgrade_right;
++ dm_fsys_get_allocinfo_rvp_t get_allocinfo_rvp;
++ dm_fsys_get_bulkall_rvp_t get_bulkall_rvp;
++ dm_fsys_get_bulkattr_rvp_t get_bulkattr_rvp;
++ dm_fsys_get_config_t get_config;
++ dm_fsys_get_config_events_t get_config_events;
++ dm_fsys_get_destroy_dmattr_t get_destroy_dmattr;
++ dm_fsys_get_dioinfo_t get_dioinfo;
++ dm_fsys_get_dirattrs_rvp_t get_dirattrs_rvp;
++ dm_fsys_get_dmattr_t get_dmattr;
++ dm_fsys_get_eventlist_t get_eventlist;
++ dm_fsys_get_fileattr_t get_fileattr;
++ dm_fsys_get_region_t get_region;
++ dm_fsys_getall_dmattr_t getall_dmattr;
++ dm_fsys_getall_inherit_t getall_inherit;
++ dm_fsys_init_attrloc_t init_attrloc;
++ dm_fsys_mkdir_by_handle_t mkdir_by_handle;
++ dm_fsys_probe_hole_t probe_hole;
++ dm_fsys_punch_hole_t punch_hole;
++ dm_fsys_read_invis_rvp_t read_invis_rvp;
++ dm_fsys_release_right_t release_right;
++ dm_fsys_remove_dmattr_t remove_dmattr;
++ dm_fsys_request_right_t request_right;
++ dm_fsys_set_dmattr_t set_dmattr;
++ dm_fsys_set_eventlist_t set_eventlist;
++ dm_fsys_set_fileattr_t set_fileattr;
++ dm_fsys_set_inherit_t set_inherit;
++ dm_fsys_set_region_t set_region;
++ dm_fsys_symlink_by_handle_t symlink_by_handle;
++ dm_fsys_sync_by_handle_t sync_by_handle;
++ dm_fsys_upgrade_right_t upgrade_right;
++ dm_fsys_write_invis_rvp_t write_invis_rvp;
++ dm_fsys_obj_ref_hold_t obj_ref_hold;
++ } u_fc;
++} fsys_function_vector_t;
++
++struct dm_fcntl_vector {
++ int code_level;
++ int count; /* Number of functions in the vector */
++ fsys_function_vector_t *vecp;
++};
++typedef struct dm_fcntl_vector dm_fcntl_vector_t;
++
++struct dm_fcntl_mapevent {
++ size_t length; /* length of transfer */
++ dm_eventtype_t max_event; /* Maximum (WRITE or READ) event */
++ int error; /* returned error code */
++};
++typedef struct dm_fcntl_mapevent dm_fcntl_mapevent_t;
++
++#endif /* __KERNEL__ */
++
++
++/* The following definitions are needed both by the kernel and by the
++ library routines.
++*/
++
++#define DM_MAX_HANDLE_SIZE 56 /* maximum size for a file handle */
++
++
++/*
++ * Opcodes for dmapi ioctl.
++ */
++
++#define DM_CLEAR_INHERIT 1
++#define DM_CREATE_BY_HANDLE 2
++#define DM_CREATE_SESSION 3
++#define DM_CREATE_USEREVENT 4
++#define DM_DESTROY_SESSION 5
++#define DM_DOWNGRADE_RIGHT 6
++#define DM_FD_TO_HANDLE 7
++#define DM_FIND_EVENTMSG 8
++#define DM_GET_ALLOCINFO 9
++#define DM_GET_BULKALL 10
++#define DM_GET_BULKATTR 11
++#define DM_GET_CONFIG 12
++#define DM_GET_CONFIG_EVENTS 13
++#define DM_GET_DIOINFO 14
++#define DM_GET_DIRATTRS 15
++#define DM_GET_DMATTR 16
++#define DM_GET_EVENTLIST 17
++#define DM_GET_EVENTS 18
++#define DM_GET_FILEATTR 19
++#define DM_GET_MOUNTINFO 20
++#define DM_GET_REGION 21
++#define DM_GETALL_DISP 22
++#define DM_GETALL_DMATTR 23
++#define DM_GETALL_INHERIT 24
++#define DM_GETALL_SESSIONS 25
++#define DM_GETALL_TOKENS 26
++#define DM_INIT_ATTRLOC 27
++#define DM_MKDIR_BY_HANDLE 28
++#define DM_MOVE_EVENT 29
++#define DM_OBJ_REF_HOLD 30
++#define DM_OBJ_REF_QUERY 31
++#define DM_OBJ_REF_RELE 32
++#define DM_PATH_TO_FSHANDLE 33
++#define DM_PATH_TO_HANDLE 34
++#define DM_PENDING 35
++#define DM_PROBE_HOLE 36
++#define DM_PUNCH_HOLE 37
++#define DM_QUERY_RIGHT 38
++#define DM_QUERY_SESSION 39
++#define DM_READ_INVIS 40
++#define DM_RELEASE_RIGHT 41
++#define DM_REMOVE_DMATTR 42
++#define DM_REQUEST_RIGHT 43
++#define DM_RESPOND_EVENT 44
++#define DM_SEND_MSG 45
++#define DM_SET_DISP 46
++#define DM_SET_DMATTR 47
++#define DM_SET_EVENTLIST 48
++#define DM_SET_FILEATTR 49
++#define DM_SET_INHERIT 50
++#define DM_SET_REGION 51
++#define DM_SET_RETURN_ON_DESTROY 52
++#define DM_SYMLINK_BY_HANDLE 53
++#define DM_SYNC_BY_HANDLE 54
++#define DM_UPGRADE_RIGHT 55
++#define DM_WRITE_INVIS 56
++#define DM_OPEN_BY_HANDLE 57
++
++#endif /* __DMAPI_KERN_H__ */
+Index: linux-2.6.26/fs/dmapi/dmapi_mountinfo.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_mountinfo.c
+@@ -0,0 +1,527 @@
++/*
++ * Copyright (c) 2000-2005 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++static LIST_HEAD(dm_fsys_map);
++static spinlock_t dm_fsys_lock = SPIN_LOCK_UNLOCKED;
++
++int
++dm_code_level(void)
++{
++ return DM_CLVL_XOPEN; /* initial X/Open compliant release */
++}
++
++
++/* Dummy routine which is stored in each function vector slot for which the
++ filesystem provides no function of its own. If an application calls the
++ function, he will just get ENOSYS.
++*/
++
++static int
++dm_enosys(void)
++{
++ return -ENOSYS; /* function not supported by filesystem */
++}
++
++
++/* dm_query_fsys_for_vector() asks a filesystem for its list of supported
++ DMAPI functions, and builds a dm_vector_map_t structure based upon the
++ reply. We ignore functions supported by the filesystem which we do not
++ know about, and we substitute the subroutine 'dm_enosys' for each function
++ we know about but the filesystem does not support.
++*/
++
++static void
++dm_query_fsys_for_vector(
++ dm_vector_map_t *map)
++{
++ struct super_block *sb = map->sb;
++ fsys_function_vector_t *vecp;
++ dm_fcntl_vector_t vecrq;
++ dm_fsys_vector_t *vptr;
++ struct filesystem_dmapi_operations *dmapiops = map->dmapiops;
++ int error;
++ int i;
++
++
++ /* Allocate a function vector and initialize all fields with a
++ dummy function that returns ENOSYS.
++ */
++
++ vptr = map->vptr = kmem_cache_alloc(dm_fsys_vptr_cachep, GFP_KERNEL);
++ if (vptr == NULL) {
++ printk("%s/%d: kmem_cache_alloc(dm_fsys_vptr_cachep) returned NULL\n", __FUNCTION__, __LINE__);
++ return;
++ }
++
++ vptr->code_level = 0;
++ vptr->clear_inherit = (dm_fsys_clear_inherit_t)dm_enosys;
++ vptr->create_by_handle = (dm_fsys_create_by_handle_t)dm_enosys;
++ vptr->downgrade_right = (dm_fsys_downgrade_right_t)dm_enosys;
++ vptr->get_allocinfo_rvp = (dm_fsys_get_allocinfo_rvp_t)dm_enosys;
++ vptr->get_bulkall_rvp = (dm_fsys_get_bulkall_rvp_t)dm_enosys;
++ vptr->get_bulkattr_rvp = (dm_fsys_get_bulkattr_rvp_t)dm_enosys;
++ vptr->get_config = (dm_fsys_get_config_t)dm_enosys;
++ vptr->get_config_events = (dm_fsys_get_config_events_t)dm_enosys;
++ vptr->get_destroy_dmattr = (dm_fsys_get_destroy_dmattr_t)dm_enosys;
++ vptr->get_dioinfo = (dm_fsys_get_dioinfo_t)dm_enosys;
++ vptr->get_dirattrs_rvp = (dm_fsys_get_dirattrs_rvp_t)dm_enosys;
++ vptr->get_dmattr = (dm_fsys_get_dmattr_t)dm_enosys;
++ vptr->get_eventlist = (dm_fsys_get_eventlist_t)dm_enosys;
++ vptr->get_fileattr = (dm_fsys_get_fileattr_t)dm_enosys;
++ vptr->get_region = (dm_fsys_get_region_t)dm_enosys;
++ vptr->getall_dmattr = (dm_fsys_getall_dmattr_t)dm_enosys;
++ vptr->getall_inherit = (dm_fsys_getall_inherit_t)dm_enosys;
++ vptr->init_attrloc = (dm_fsys_init_attrloc_t)dm_enosys;
++ vptr->mkdir_by_handle = (dm_fsys_mkdir_by_handle_t)dm_enosys;
++ vptr->probe_hole = (dm_fsys_probe_hole_t)dm_enosys;
++ vptr->punch_hole = (dm_fsys_punch_hole_t)dm_enosys;
++ vptr->read_invis_rvp = (dm_fsys_read_invis_rvp_t)dm_enosys;
++ vptr->release_right = (dm_fsys_release_right_t)dm_enosys;
++ vptr->request_right = (dm_fsys_request_right_t)dm_enosys;
++ vptr->remove_dmattr = (dm_fsys_remove_dmattr_t)dm_enosys;
++ vptr->set_dmattr = (dm_fsys_set_dmattr_t)dm_enosys;
++ vptr->set_eventlist = (dm_fsys_set_eventlist_t)dm_enosys;
++ vptr->set_fileattr = (dm_fsys_set_fileattr_t)dm_enosys;
++ vptr->set_inherit = (dm_fsys_set_inherit_t)dm_enosys;
++ vptr->set_region = (dm_fsys_set_region_t)dm_enosys;
++ vptr->symlink_by_handle = (dm_fsys_symlink_by_handle_t)dm_enosys;
++ vptr->sync_by_handle = (dm_fsys_sync_by_handle_t)dm_enosys;
++ vptr->upgrade_right = (dm_fsys_upgrade_right_t)dm_enosys;
++ vptr->write_invis_rvp = (dm_fsys_write_invis_rvp_t)dm_enosys;
++ vptr->obj_ref_hold = (dm_fsys_obj_ref_hold_t)dm_enosys;
++
++ /* Issue a call to the filesystem in order to obtain
++ its vector of filesystem-specific DMAPI routines.
++ */
++
++ vecrq.count = 0;
++ vecrq.vecp = NULL;
++
++ error = -ENOSYS;
++ ASSERT(dmapiops);
++ if (dmapiops->get_fsys_vector)
++ error = dmapiops->get_fsys_vector(sb, (caddr_t)&vecrq);
++
++ /* If we still have an error at this point, then the filesystem simply
++ does not support DMAPI, so we give up with all functions set to
++ ENOSYS.
++ */
++
++ if (error || vecrq.count == 0) {
++ kmem_cache_free(dm_fsys_vptr_cachep, vptr);
++ map->vptr = NULL;
++ return;
++ }
++
++ /* The request succeeded and we were given a vector which we need to
++ map to our current level. Overlay the dummy function with every
++ filesystem function we understand.
++ */
++
++ vptr->code_level = vecrq.code_level;
++ vecp = vecrq.vecp;
++ for (i = 0; i < vecrq.count; i++) {
++ switch (vecp[i].func_no) {
++ case DM_FSYS_CLEAR_INHERIT:
++ vptr->clear_inherit = vecp[i].u_fc.clear_inherit;
++ break;
++ case DM_FSYS_CREATE_BY_HANDLE:
++ vptr->create_by_handle = vecp[i].u_fc.create_by_handle;
++ break;
++ case DM_FSYS_DOWNGRADE_RIGHT:
++ vptr->downgrade_right = vecp[i].u_fc.downgrade_right;
++ break;
++ case DM_FSYS_GET_ALLOCINFO_RVP:
++ vptr->get_allocinfo_rvp = vecp[i].u_fc.get_allocinfo_rvp;
++ break;
++ case DM_FSYS_GET_BULKALL_RVP:
++ vptr->get_bulkall_rvp = vecp[i].u_fc.get_bulkall_rvp;
++ break;
++ case DM_FSYS_GET_BULKATTR_RVP:
++ vptr->get_bulkattr_rvp = vecp[i].u_fc.get_bulkattr_rvp;
++ break;
++ case DM_FSYS_GET_CONFIG:
++ vptr->get_config = vecp[i].u_fc.get_config;
++ break;
++ case DM_FSYS_GET_CONFIG_EVENTS:
++ vptr->get_config_events = vecp[i].u_fc.get_config_events;
++ break;
++ case DM_FSYS_GET_DESTROY_DMATTR:
++ vptr->get_destroy_dmattr = vecp[i].u_fc.get_destroy_dmattr;
++ break;
++ case DM_FSYS_GET_DIOINFO:
++ vptr->get_dioinfo = vecp[i].u_fc.get_dioinfo;
++ break;
++ case DM_FSYS_GET_DIRATTRS_RVP:
++ vptr->get_dirattrs_rvp = vecp[i].u_fc.get_dirattrs_rvp;
++ break;
++ case DM_FSYS_GET_DMATTR:
++ vptr->get_dmattr = vecp[i].u_fc.get_dmattr;
++ break;
++ case DM_FSYS_GET_EVENTLIST:
++ vptr->get_eventlist = vecp[i].u_fc.get_eventlist;
++ break;
++ case DM_FSYS_GET_FILEATTR:
++ vptr->get_fileattr = vecp[i].u_fc.get_fileattr;
++ break;
++ case DM_FSYS_GET_REGION:
++ vptr->get_region = vecp[i].u_fc.get_region;
++ break;
++ case DM_FSYS_GETALL_DMATTR:
++ vptr->getall_dmattr = vecp[i].u_fc.getall_dmattr;
++ break;
++ case DM_FSYS_GETALL_INHERIT:
++ vptr->getall_inherit = vecp[i].u_fc.getall_inherit;
++ break;
++ case DM_FSYS_INIT_ATTRLOC:
++ vptr->init_attrloc = vecp[i].u_fc.init_attrloc;
++ break;
++ case DM_FSYS_MKDIR_BY_HANDLE:
++ vptr->mkdir_by_handle = vecp[i].u_fc.mkdir_by_handle;
++ break;
++ case DM_FSYS_PROBE_HOLE:
++ vptr->probe_hole = vecp[i].u_fc.probe_hole;
++ break;
++ case DM_FSYS_PUNCH_HOLE:
++ vptr->punch_hole = vecp[i].u_fc.punch_hole;
++ break;
++ case DM_FSYS_READ_INVIS_RVP:
++ vptr->read_invis_rvp = vecp[i].u_fc.read_invis_rvp;
++ break;
++ case DM_FSYS_RELEASE_RIGHT:
++ vptr->release_right = vecp[i].u_fc.release_right;
++ break;
++ case DM_FSYS_REMOVE_DMATTR:
++ vptr->remove_dmattr = vecp[i].u_fc.remove_dmattr;
++ break;
++ case DM_FSYS_REQUEST_RIGHT:
++ vptr->request_right = vecp[i].u_fc.request_right;
++ break;
++ case DM_FSYS_SET_DMATTR:
++ vptr->set_dmattr = vecp[i].u_fc.set_dmattr;
++ break;
++ case DM_FSYS_SET_EVENTLIST:
++ vptr->set_eventlist = vecp[i].u_fc.set_eventlist;
++ break;
++ case DM_FSYS_SET_FILEATTR:
++ vptr->set_fileattr = vecp[i].u_fc.set_fileattr;
++ break;
++ case DM_FSYS_SET_INHERIT:
++ vptr->set_inherit = vecp[i].u_fc.set_inherit;
++ break;
++ case DM_FSYS_SET_REGION:
++ vptr->set_region = vecp[i].u_fc.set_region;
++ break;
++ case DM_FSYS_SYMLINK_BY_HANDLE:
++ vptr->symlink_by_handle = vecp[i].u_fc.symlink_by_handle;
++ break;
++ case DM_FSYS_SYNC_BY_HANDLE:
++ vptr->sync_by_handle = vecp[i].u_fc.sync_by_handle;
++ break;
++ case DM_FSYS_UPGRADE_RIGHT:
++ vptr->upgrade_right = vecp[i].u_fc.upgrade_right;
++ break;
++ case DM_FSYS_WRITE_INVIS_RVP:
++ vptr->write_invis_rvp = vecp[i].u_fc.write_invis_rvp;
++ break;
++ case DM_FSYS_OBJ_REF_HOLD:
++ vptr->obj_ref_hold = vecp[i].u_fc.obj_ref_hold;
++ break;
++ default: /* ignore ones we don't understand */
++ break;
++ }
++ }
++}
++
++
++/* Must hold dm_fsys_lock.
++ * This returns the prototype for all instances of the fstype.
++ */
++static dm_vector_map_t *
++dm_fsys_map_by_fstype(
++ struct file_system_type *fstype)
++{
++ struct list_head *p;
++ dm_vector_map_t *proto = NULL;
++ dm_vector_map_t *m;
++
++ ASSERT_ALWAYS(fstype);
++ list_for_each(p, &dm_fsys_map) {
++ m = list_entry(p, dm_vector_map_t, ftype_list);
++ if (m->f_type == fstype) {
++ proto = m;
++ break;
++ }
++ }
++ return proto;
++}
++
++
++/* Must hold dm_fsys_lock */
++static dm_vector_map_t *
++dm_fsys_map_by_sb(
++ struct super_block *sb)
++{
++ struct list_head *p;
++ dm_vector_map_t *proto;
++ dm_vector_map_t *m;
++ dm_vector_map_t *foundmap = NULL;
++
++ proto = dm_fsys_map_by_fstype(sb->s_type);
++ if(proto == NULL) {
++ return NULL;
++ }
++
++ list_for_each(p, &proto->sb_list) {
++ m = list_entry(p, dm_vector_map_t, sb_list);
++ if (m->sb == sb) {
++ foundmap = m;
++ break;
++ }
++ }
++ return foundmap;
++}
++
++
++#ifdef CONFIG_DMAPI_DEBUG
++static void
++sb_list(
++ struct super_block *sb)
++{
++ struct list_head *p;
++ dm_vector_map_t *proto;
++ dm_vector_map_t *m;
++
++ proto = dm_fsys_map_by_fstype(sb->s_type);
++ ASSERT(proto);
++
++printk("%s/%d: Current sb_list\n", __FUNCTION__, __LINE__);
++ list_for_each(p, &proto->sb_list) {
++ m = list_entry(p, dm_vector_map_t, sb_list);
++printk("%s/%d: map 0x%p, sb 0x%p, vptr 0x%p, dmapiops 0x%p\n", __FUNCTION__, __LINE__, m, m->sb, m->vptr, m->dmapiops);
++ }
++printk("%s/%d: Done sb_list\n", __FUNCTION__, __LINE__);
++}
++#else
++#define sb_list(x)
++#endif
++
++#ifdef CONFIG_DMAPI_DEBUG
++static void
++ftype_list(void)
++{
++ struct list_head *p;
++ dm_vector_map_t *m;
++
++printk("%s/%d: Current ftype_list\n", __FUNCTION__, __LINE__);
++ list_for_each(p, &dm_fsys_map) {
++ m = list_entry(p, dm_vector_map_t, ftype_list);
++ printk("%s/%d: FS 0x%p, ftype 0x%p %s\n", __FUNCTION__, __LINE__, m, m->f_type, m->f_type->name);
++ }
++printk("%s/%d: Done ftype_list\n", __FUNCTION__, __LINE__);
++}
++#else
++#define ftype_list()
++#endif
++
++/* Ask for vptr for this filesystem instance.
++ * The caller knows this inode is on a dmapi-managed filesystem.
++ */
++dm_fsys_vector_t *
++dm_fsys_vector(
++ struct inode *ip)
++{
++ dm_vector_map_t *map;
++
++ spin_lock(&dm_fsys_lock);
++ ftype_list();
++ map = dm_fsys_map_by_sb(ip->i_sb);
++ spin_unlock(&dm_fsys_lock);
++ ASSERT(map);
++ ASSERT(map->vptr);
++ return map->vptr;
++}
++
++
++/* Ask for the dmapiops for this filesystem instance. The caller is
++ * also asking if this is a dmapi-managed filesystem.
++ */
++struct filesystem_dmapi_operations *
++dm_fsys_ops(
++ struct super_block *sb)
++{
++ dm_vector_map_t *proto = NULL;
++ dm_vector_map_t *map;
++
++ spin_lock(&dm_fsys_lock);
++ ftype_list();
++ sb_list(sb);
++ map = dm_fsys_map_by_sb(sb);
++ if (map == NULL)
++ proto = dm_fsys_map_by_fstype(sb->s_type);
++ spin_unlock(&dm_fsys_lock);
++
++ if ((map == NULL) && (proto == NULL))
++ return NULL;
++
++ if (map == NULL) {
++ /* Find out if it's dmapi-managed */
++ dm_vector_map_t *m;
++
++ ASSERT(proto);
++ m = kmem_cache_alloc(dm_fsys_map_cachep, GFP_KERNEL);
++ if (m == NULL) {
++ printk("%s/%d: kmem_cache_alloc(dm_fsys_map_cachep) returned NULL\n", __FUNCTION__, __LINE__);
++ return NULL;
++ }
++ memset(m, 0, sizeof(*m));
++ m->dmapiops = proto->dmapiops;
++ m->f_type = sb->s_type;
++ m->sb = sb;
++ INIT_LIST_HEAD(&m->sb_list);
++ INIT_LIST_HEAD(&m->ftype_list);
++
++ dm_query_fsys_for_vector(m);
++ if (m->vptr == NULL) {
++ /* This isn't dmapi-managed */
++ kmem_cache_free(dm_fsys_map_cachep, m);
++ return NULL;
++ }
++
++ spin_lock(&dm_fsys_lock);
++ if ((map = dm_fsys_map_by_sb(sb)) == NULL)
++ list_add(&m->sb_list, &proto->sb_list);
++ spin_unlock(&dm_fsys_lock);
++
++ if (map) {
++ kmem_cache_free(dm_fsys_vptr_cachep, m->vptr);
++ kmem_cache_free(dm_fsys_map_cachep, m);
++ }
++ else {
++ map = m;
++ }
++ }
++
++ return map->dmapiops;
++}
++
++
++
++/* Called when a filesystem instance is unregistered from dmapi */
++void
++dm_fsys_ops_release(
++ struct super_block *sb)
++{
++ dm_vector_map_t *map;
++
++ spin_lock(&dm_fsys_lock);
++ ASSERT(!list_empty(&dm_fsys_map));
++ map = dm_fsys_map_by_sb(sb);
++ ASSERT(map);
++ list_del(&map->sb_list);
++ spin_unlock(&dm_fsys_lock);
++
++ ASSERT(map->vptr);
++ kmem_cache_free(dm_fsys_vptr_cachep, map->vptr);
++ kmem_cache_free(dm_fsys_map_cachep, map);
++}
++
++
++/* Called by a filesystem module that is loading into the kernel.
++ * This creates a new dm_vector_map_t which serves as the prototype
++ * for instances of this fstype and also provides the list_head
++ * for instances of this fstype. The prototypes are the only ones
++ * on the fstype_list, and will never be on the sb_list.
++ */
++void
++dmapi_register(
++ struct file_system_type *fstype,
++ struct filesystem_dmapi_operations *dmapiops)
++{
++ dm_vector_map_t *proto;
++
++ proto = kmem_cache_alloc(dm_fsys_map_cachep, GFP_KERNEL);
++ if (proto == NULL) {
++ printk("%s/%d: kmem_cache_alloc(dm_fsys_map_cachep) returned NULL\n", __FUNCTION__, __LINE__);
++ return;
++ }
++ memset(proto, 0, sizeof(*proto));
++ proto->dmapiops = dmapiops;
++ proto->f_type = fstype;
++ INIT_LIST_HEAD(&proto->sb_list);
++ INIT_LIST_HEAD(&proto->ftype_list);
++
++ spin_lock(&dm_fsys_lock);
++ ASSERT(dm_fsys_map_by_fstype(fstype) == NULL);
++ list_add(&proto->ftype_list, &dm_fsys_map);
++ ftype_list();
++ spin_unlock(&dm_fsys_lock);
++}
++
++/* Called by a filesystem module that is unloading from the kernel */
++void
++dmapi_unregister(
++ struct file_system_type *fstype)
++{
++ struct list_head *p;
++ dm_vector_map_t *proto;
++ dm_vector_map_t *m;
++
++ spin_lock(&dm_fsys_lock);
++ ASSERT(!list_empty(&dm_fsys_map));
++ proto = dm_fsys_map_by_fstype(fstype);
++ ASSERT(proto);
++ list_del(&proto->ftype_list);
++ spin_unlock(&dm_fsys_lock);
++
++ p = &proto->sb_list;
++ while (!list_empty(p)) {
++ m = list_entry(p->next, dm_vector_map_t, sb_list);
++ list_del(&m->sb_list);
++ ASSERT(m->vptr);
++ kmem_cache_free(dm_fsys_vptr_cachep, m->vptr);
++ kmem_cache_free(dm_fsys_map_cachep, m);
++ }
++ kmem_cache_free(dm_fsys_map_cachep, proto);
++}
++
++
++int
++dmapi_registered(
++ struct file_system_type *fstype,
++ struct filesystem_dmapi_operations **dmapiops)
++{
++ return 0;
++}
+Index: linux-2.6.26/fs/dmapi/dmapi_port.h
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_port.h
+@@ -0,0 +1,138 @@
++/*
++ * Copyright (c) 2000-2004 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++#ifndef _DMAPI_PORT_H
++#define _DMAPI_PORT_H
++
++#include <asm/div64.h>
++#include "sv.h"
++
++#include <linux/sched.h> /* preempt needs this */
++#include <linux/spinlock.h>
++
++typedef spinlock_t lock_t;
++
++#define spinlock_init(lock, name) spin_lock_init(lock)
++#define spinlock_destroy(lock)
++
++#define mutex_spinlock(lock) ({ spin_lock(lock); 0; })
++#define mutex_spinunlock(lock, s) spin_unlock(lock)
++#define nested_spinlock(lock) spin_lock(lock)
++#define nested_spinunlock(lock) spin_unlock(lock)
++
++typedef signed int __int32_t;
++typedef unsigned int __uint32_t;
++typedef signed long long int __int64_t;
++typedef unsigned long long int __uint64_t;
++
++
++/* __psint_t is the same size as a pointer */
++#if (BITS_PER_LONG == 32)
++typedef __int32_t __psint_t;
++typedef __uint32_t __psunsigned_t;
++#elif (BITS_PER_LONG == 64)
++typedef __int64_t __psint_t;
++typedef __uint64_t __psunsigned_t;
++#else
++#error BITS_PER_LONG must be 32 or 64
++#endif
++
++static inline void
++assfail(char *a, char *f, int l)
++{
++ printk("DMAPI assertion failed: %s, file: %s, line: %d\n", a, f, l);
++ BUG();
++}
++
++#ifdef DEBUG
++#define doass 1
++# ifdef lint
++# define ASSERT(EX) ((void)0) /* avoid "constant in conditional" babble */
++# else
++# define ASSERT(EX) ((!doass||(EX))?((void)0):assfail(#EX, __FILE__, __LINE__))
++# endif /* lint */
++#else
++# define ASSERT(x) ((void)0)
++#endif /* DEBUG */
++
++#define ASSERT_ALWAYS(EX) ((EX)?((void)0):assfail(#EX, __FILE__, __LINE__))
++
++
++#if defined __i386__
++
++/* Side effect free 64 bit mod operation */
++static inline __u32 dmapi_do_mod(void *a, __u32 b, int n)
++{
++ switch (n) {
++ case 4:
++ return *(__u32 *)a % b;
++ case 8:
++ {
++ unsigned long __upper, __low, __high, __mod;
++ __u64 c = *(__u64 *)a;
++ __upper = __high = c >> 32;
++ __low = c;
++ if (__high) {
++ __upper = __high % (b);
++ __high = __high / (b);
++ }
++ asm("divl %2":"=a" (__low), "=d" (__mod):"rm" (b), "0" (__low), "1" (__upper));
++ asm("":"=A" (c):"a" (__low),"d" (__high));
++ return __mod;
++ }
++ }
++
++ /* NOTREACHED */
++ return 0;
++}
++#else
++
++/* Side effect free 64 bit mod operation */
++static inline __u32 dmapi_do_mod(void *a, __u32 b, int n)
++{
++ switch (n) {
++ case 4:
++ return *(__u32 *)a % b;
++ case 8:
++ {
++ __u64 c = *(__u64 *)a;
++ return do_div(c, b);
++ }
++ }
++
++ /* NOTREACHED */
++ return 0;
++}
++#endif
++
++#define do_mod(a, b) dmapi_do_mod(&(a), (b), sizeof(a))
++
++#endif /* _DMAPI_PORT_H */
+Index: linux-2.6.26/fs/dmapi/dmapi_private.h
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_private.h
+@@ -0,0 +1,619 @@
++/*
++ * Copyright (c) 2000-2005 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++#ifndef _DMAPI_PRIVATE_H
++#define _DMAPI_PRIVATE_H
++
++#include <linux/slab.h>
++#include "dmapi_port.h"
++#include "sv.h"
++
++#ifdef CONFIG_PROC_FS
++#define DMAPI_PROCFS "orig/fs/dmapi_v2" /* DMAPI device in /proc. */
++#define DMAPI_DBG_PROCFS "orig/fs/dmapi_d" /* DMAPI debugging dir */
++#endif
++
++extern struct kmem_cache *dm_fsreg_cachep;
++extern struct kmem_cache *dm_tokdata_cachep;
++extern struct kmem_cache *dm_session_cachep;
++extern struct kmem_cache *dm_fsys_map_cachep;
++extern struct kmem_cache *dm_fsys_vptr_cachep;
++
++typedef struct dm_tokdata {
++ struct dm_tokdata *td_next;
++ struct dm_tokevent *td_tevp; /* pointer to owning tevp */
++ int td_app_ref; /* # app threads currently active */
++ dm_right_t td_orig_right; /* original right held when created */
++ dm_right_t td_right; /* current right held for this handle */
++ short td_flags;
++ short td_type; /* object type */
++ int td_vcount; /* # of current application VN_HOLDs */
++ struct inode *td_ip; /* inode pointer */
++ dm_handle_t td_handle; /* handle for ip or sb */
++} dm_tokdata_t;
++
++/* values for td_type */
++
++#define DM_TDT_NONE 0x00 /* td_handle is empty */
++#define DM_TDT_VFS 0x01 /* td_handle points to a sb */
++#define DM_TDT_REG 0x02 /* td_handle points to a file */
++#define DM_TDT_DIR 0x04 /* td_handle points to a directory */
++#define DM_TDT_LNK 0x08 /* td_handle points to a symlink */
++#define DM_TDT_OTH 0x10 /* some other object eg. pipe, socket */
++
++#define DM_TDT_VNO (DM_TDT_REG|DM_TDT_DIR|DM_TDT_LNK|DM_TDT_OTH)
++#define DM_TDT_ANY (DM_TDT_VFS|DM_TDT_REG|DM_TDT_DIR|DM_TDT_LNK|DM_TDT_OTH)
++
++/* values for td_flags */
++
++#define DM_TDF_ORIG 0x0001 /* part of the original event */
++#define DM_TDF_EVTREF 0x0002 /* event thread holds inode reference */
++#define DM_TDF_STHREAD 0x0004 /* only one app can use this handle */
++#define DM_TDF_RIGHT 0x0008 /* vcount bumped for dm_request_right */
++#define DM_TDF_HOLD 0x0010 /* vcount bumped for dm_obj_ref_hold */
++
++
++/* Because some events contain __u64 fields, we force te_msg and te_event
++ to always be 8-byte aligned. In order to send more than one message in
++ a single dm_get_events() call, we also ensure that each message is an
++ 8-byte multiple.
++*/
++
++typedef struct dm_tokevent {
++ struct dm_tokevent *te_next;
++ struct dm_tokevent *te_hashnext; /* hash chain */
++ lock_t te_lock; /* lock for all fields but te_*next.
++ * te_next and te_hashnext are
++ * protected by the session lock.
++ */
++ short te_flags;
++ short te_allocsize; /* alloc'ed size of this structure */
++ sv_t te_evt_queue; /* queue waiting for dm_respond_event */
++ sv_t te_app_queue; /* queue waiting for handle access */
++ int te_evt_ref; /* number of event procs using token */
++ int te_app_ref; /* number of app procs using token */
++ int te_app_slp; /* number of app procs sleeping */
++ int te_reply; /* return errno for sync messages */
++ dm_tokdata_t *te_tdp; /* list of handle/right pairs */
++ union {
++ __u64 align; /* force alignment of te_msg */
++ dm_eventmsg_t te_msg; /* user visible part */
++ } te_u;
++ __u64 te_event; /* start of dm_xxx_event_t message */
++} dm_tokevent_t;
++
++#define te_msg te_u.te_msg
++
++/* values for te_flags */
++
++#define DM_TEF_LOCKED 0x0001 /* event "locked" by dm_get_events() */
++#define DM_TEF_INTERMED 0x0002 /* a dm_pending reply was received */
++#define DM_TEF_FINAL 0x0004 /* dm_respond_event has been received */
++#define DM_TEF_HASHED 0x0010 /* event is on hash chain */
++#define DM_TEF_FLUSH 0x0020 /* flushing threads from queues */
++
++
++#ifdef CONFIG_DMAPI_DEBUG
++#define DM_SHASH_DEBUG
++#endif
++
++typedef struct dm_sesshash {
++ dm_tokevent_t *h_next; /* ptr to chain of tokevents */
++#ifdef DM_SHASH_DEBUG
++ int maxlength;
++ int curlength;
++ int num_adds;
++ int num_dels;
++ int dup_hits;
++#endif
++} dm_sesshash_t;
++
++
++typedef struct dm_eventq {
++ dm_tokevent_t *eq_head;
++ dm_tokevent_t *eq_tail;
++ int eq_count; /* size of queue */
++} dm_eventq_t;
++
++
++typedef struct dm_session {
++ struct dm_session *sn_next; /* sessions linkage */
++ dm_sessid_t sn_sessid; /* user-visible session number */
++ u_int sn_flags;
++ lock_t sn_qlock; /* lock for newq/delq related fields */
++ sv_t sn_readerq; /* waiting for message on sn_newq */
++ sv_t sn_writerq; /* waiting for room on sn_newq */
++ u_int sn_readercnt; /* count of waiting readers */
++ u_int sn_writercnt; /* count of waiting readers */
++ dm_eventq_t sn_newq; /* undelivered event queue */
++ dm_eventq_t sn_delq; /* delivered event queue */
++ dm_eventq_t sn_evt_writerq; /* events of thrds in sn_writerq */
++ dm_sesshash_t *sn_sesshash; /* buckets for tokevent hash chains */
++#ifdef DM_SHASH_DEBUG
++ int sn_buckets_in_use;
++ int sn_max_buckets_in_use;
++#endif
++ char sn_info[DM_SESSION_INFO_LEN]; /* user-supplied info */
++} dm_session_t;
++
++/* values for sn_flags */
++
++#define DM_SN_WANTMOUNT 0x0001 /* session wants to get mount events */
++
++
++typedef enum {
++ DM_STATE_MOUNTING,
++ DM_STATE_MOUNTED,
++ DM_STATE_UNMOUNTING,
++ DM_STATE_UNMOUNTED
++} dm_fsstate_t;
++
++
++typedef struct dm_fsreg {
++ struct dm_fsreg *fr_next;
++ struct super_block *fr_sb; /* filesystem pointer */
++ dm_tokevent_t *fr_tevp;
++ dm_fsid_t fr_fsid; /* filesystem ID */
++ void *fr_msg; /* dm_mount_event_t for filesystem */
++ int fr_msgsize; /* size of dm_mount_event_t */
++ dm_fsstate_t fr_state;
++ sv_t fr_dispq;
++ int fr_dispcnt;
++ dm_eventq_t fr_evt_dispq; /* events of thrds in fr_dispq */
++ sv_t fr_queue; /* queue for hdlcnt/sbcnt/unmount */
++ lock_t fr_lock;
++ int fr_hdlcnt; /* threads blocked during unmount */
++ int fr_vfscnt; /* threads in VFS_VGET or VFS_ROOT */
++ int fr_unmount; /* if non-zero, umount is sleeping */
++ dm_attrname_t fr_rattr; /* dm_set_return_on_destroy attribute */
++ dm_session_t *fr_sessp [DM_EVENT_MAX];
++} dm_fsreg_t;
++
++
++
++
++/* events valid in dm_set_disp() when called with a filesystem handle. */
++
++#define DM_VALID_DISP_EVENTS ( \
++ (1 << DM_EVENT_PREUNMOUNT) | \
++ (1 << DM_EVENT_UNMOUNT) | \
++ (1 << DM_EVENT_NOSPACE) | \
++ (1 << DM_EVENT_DEBUT) | \
++ (1 << DM_EVENT_CREATE) | \
++ (1 << DM_EVENT_POSTCREATE) | \
++ (1 << DM_EVENT_REMOVE) | \
++ (1 << DM_EVENT_POSTREMOVE) | \
++ (1 << DM_EVENT_RENAME) | \
++ (1 << DM_EVENT_POSTRENAME) | \
++ (1 << DM_EVENT_LINK) | \
++ (1 << DM_EVENT_POSTLINK) | \
++ (1 << DM_EVENT_SYMLINK) | \
++ (1 << DM_EVENT_POSTSYMLINK) | \
++ (1 << DM_EVENT_READ) | \
++ (1 << DM_EVENT_WRITE) | \
++ (1 << DM_EVENT_TRUNCATE) | \
++ (1 << DM_EVENT_ATTRIBUTE) | \
++ (1 << DM_EVENT_DESTROY) )
++
++
++/* isolate the read/write/trunc events of a dm_tokevent_t */
++
++#define DM_EVENT_RDWRTRUNC(tevp) ( \
++ ((tevp)->te_msg.ev_type == DM_EVENT_READ) || \
++ ((tevp)->te_msg.ev_type == DM_EVENT_WRITE) || \
++ ((tevp)->te_msg.ev_type == DM_EVENT_TRUNCATE) )
++
++
++/*
++ * Global handle hack isolation.
++ */
++
++#define DM_GLOBALHAN(hanp, hlen) (((hanp) == DM_GLOBAL_HANP) && \
++ ((hlen) == DM_GLOBAL_HLEN))
++
++
++#define DM_MAX_MSG_DATA 3960
++
++
++
++/* Supported filesystem function vector functions. */
++
++
++typedef struct {
++ int code_level;
++ dm_fsys_clear_inherit_t clear_inherit;
++ dm_fsys_create_by_handle_t create_by_handle;
++ dm_fsys_downgrade_right_t downgrade_right;
++ dm_fsys_get_allocinfo_rvp_t get_allocinfo_rvp;
++ dm_fsys_get_bulkall_rvp_t get_bulkall_rvp;
++ dm_fsys_get_bulkattr_rvp_t get_bulkattr_rvp;
++ dm_fsys_get_config_t get_config;
++ dm_fsys_get_config_events_t get_config_events;
++ dm_fsys_get_destroy_dmattr_t get_destroy_dmattr;
++ dm_fsys_get_dioinfo_t get_dioinfo;
++ dm_fsys_get_dirattrs_rvp_t get_dirattrs_rvp;
++ dm_fsys_get_dmattr_t get_dmattr;
++ dm_fsys_get_eventlist_t get_eventlist;
++ dm_fsys_get_fileattr_t get_fileattr;
++ dm_fsys_get_region_t get_region;
++ dm_fsys_getall_dmattr_t getall_dmattr;
++ dm_fsys_getall_inherit_t getall_inherit;
++ dm_fsys_init_attrloc_t init_attrloc;
++ dm_fsys_mkdir_by_handle_t mkdir_by_handle;
++ dm_fsys_probe_hole_t probe_hole;
++ dm_fsys_punch_hole_t punch_hole;
++ dm_fsys_read_invis_rvp_t read_invis_rvp;
++ dm_fsys_release_right_t release_right;
++ dm_fsys_remove_dmattr_t remove_dmattr;
++ dm_fsys_request_right_t request_right;
++ dm_fsys_set_dmattr_t set_dmattr;
++ dm_fsys_set_eventlist_t set_eventlist;
++ dm_fsys_set_fileattr_t set_fileattr;
++ dm_fsys_set_inherit_t set_inherit;
++ dm_fsys_set_region_t set_region;
++ dm_fsys_symlink_by_handle_t symlink_by_handle;
++ dm_fsys_sync_by_handle_t sync_by_handle;
++ dm_fsys_upgrade_right_t upgrade_right;
++ dm_fsys_write_invis_rvp_t write_invis_rvp;
++ dm_fsys_obj_ref_hold_t obj_ref_hold;
++} dm_fsys_vector_t;
++
++
++typedef struct {
++ struct list_head ftype_list; /* list of fstypes */
++ struct list_head sb_list; /* list of sb's per fstype */
++ struct file_system_type *f_type;
++ struct filesystem_dmapi_operations *dmapiops;
++ dm_fsys_vector_t *vptr;
++ struct super_block *sb;
++} dm_vector_map_t;
++
++
++extern dm_session_t *dm_sessions; /* head of session list */
++extern dm_fsreg_t *dm_registers;
++extern lock_t dm_reg_lock; /* lock for registration list */
++
++/*
++ * Kernel only prototypes.
++ */
++
++int dm_find_session_and_lock(
++ dm_sessid_t sid,
++ dm_session_t **sessionpp,
++ unsigned long *lcp);
++
++int dm_find_msg_and_lock(
++ dm_sessid_t sid,
++ dm_token_t token,
++ dm_tokevent_t **tevpp,
++ unsigned long *lcp);
++
++dm_tokevent_t * dm_evt_create_tevp(
++ dm_eventtype_t event,
++ int variable_size,
++ void **msgpp);
++
++int dm_app_get_tdp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ short types,
++ dm_right_t right,
++ dm_tokdata_t **tdpp);
++
++int dm_get_config_tdp(
++ void __user *hanp,
++ size_t hlen,
++ dm_tokdata_t **tdpp);
++
++void dm_app_put_tdp(
++ dm_tokdata_t *tdp);
++
++void dm_put_tevp(
++ dm_tokevent_t *tevp,
++ dm_tokdata_t *tdp);
++
++void dm_evt_rele_tevp(
++ dm_tokevent_t *tevp,
++ int droprights);
++
++int dm_enqueue_normal_event(
++ struct super_block *sbp,
++ dm_tokevent_t **tevpp,
++ int flags);
++
++int dm_enqueue_mount_event(
++ struct super_block *sbp,
++ dm_tokevent_t *tevp);
++
++int dm_enqueue_sendmsg_event(
++ dm_sessid_t targetsid,
++ dm_tokevent_t *tevp,
++ int synch);
++
++int dm_enqueue_user_event(
++ dm_sessid_t sid,
++ dm_tokevent_t *tevp,
++ dm_token_t *tokenp);
++
++int dm_obj_ref_query_rvp(
++ dm_sessid_t sid,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen,
++ int *rvp);
++
++int dm_read_invis_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_off_t off,
++ dm_size_t len,
++ void __user *bufp,
++ int *rvp);
++
++int dm_write_invis_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ int flags,
++ dm_off_t off,
++ dm_size_t len,
++ void __user *bufp,
++ int *rvp);
++
++int dm_get_bulkattr_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int mask,
++ dm_attrloc_t __user *locp,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp,
++ int *rvp);
++
++int dm_get_bulkall_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int mask,
++ dm_attrname_t __user *attrnamep,
++ dm_attrloc_t __user *locp,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp,
++ int *rvp);
++
++int dm_get_dirattrs_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int mask,
++ dm_attrloc_t __user *locp,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp,
++ int *rvp);
++
++int dm_get_allocinfo_rvp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_off_t __user *offp,
++ u_int nelem,
++ dm_extent_t __user *extentp,
++ u_int __user *nelemp,
++ int *rvp);
++
++int dm_waitfor_destroy_attrname(
++ struct super_block *sb,
++ dm_attrname_t *attrnamep);
++
++void dm_clear_fsreg(
++ dm_session_t *s);
++
++int dm_add_fsys_entry(
++ struct super_block *sb,
++ dm_tokevent_t *tevp);
++
++void dm_change_fsys_entry(
++ struct super_block *sb,
++ dm_fsstate_t newstate);
++
++void dm_remove_fsys_entry(
++ struct super_block *sb);
++
++dm_fsys_vector_t *dm_fsys_vector(
++ struct inode *ip);
++
++struct filesystem_dmapi_operations *dm_fsys_ops(
++ struct super_block *sb);
++
++void dm_fsys_ops_release(
++ struct super_block *sb);
++
++int dm_waitfor_disp_session(
++ struct super_block *sb,
++ dm_tokevent_t *tevp,
++ dm_session_t **sessionpp,
++ unsigned long *lcp);
++
++struct inode * dm_handle_to_ip (
++ dm_handle_t *handlep,
++ short *typep);
++
++int dm_check_dmapi_ip(
++ struct inode *ip);
++
++dm_tokevent_t * dm_find_mount_tevp_and_lock(
++ dm_fsid_t *fsidp,
++ unsigned long *lcp);
++
++int dm_path_to_hdl(
++ char __user *path,
++ void __user *hanp,
++ size_t __user *hlenp);
++
++int dm_path_to_fshdl(
++ char __user *path,
++ void __user *hanp,
++ size_t __user *hlenp);
++
++int dm_fd_to_hdl(
++ int fd,
++ void __user *hanp,
++ size_t __user *hlenp);
++
++int dm_upgrade_right(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token);
++
++int dm_downgrade_right(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token);
++
++int dm_request_right(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int flags,
++ dm_right_t right);
++
++int dm_release_right(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token);
++
++int dm_query_right(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_right_t __user *rightp);
++
++
++int dm_set_eventlist(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_eventset_t __user *eventsetp,
++ u_int maxevent);
++
++int dm_obj_ref_hold(
++ dm_sessid_t sid,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen);
++
++int dm_obj_ref_rele(
++ dm_sessid_t sid,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen);
++
++int dm_get_eventlist(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int nelem,
++ dm_eventset_t __user *eventsetp,
++ u_int __user *nelemp);
++
++
++int dm_set_disp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_eventset_t __user *eventsetp,
++ u_int maxevent);
++
++
++int dm_set_return_on_destroy(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrname_t __user *attrnamep,
++ dm_boolean_t enable);
++
++
++int dm_get_mountinfo(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp);
++
++void dm_link_event(
++ dm_tokevent_t *tevp,
++ dm_eventq_t *queue);
++
++void dm_unlink_event(
++ dm_tokevent_t *tevp,
++ dm_eventq_t *queue);
++
++int dm_open_by_handle_rvp(
++ unsigned int fd,
++ void __user *hanp,
++ size_t hlen,
++ int mode,
++ int *rvp);
++
++int dm_copyin_handle(
++ void __user *hanp,
++ size_t hlen,
++ dm_handle_t *handlep);
++
++int dm_release_disp_threads(
++ dm_fsid_t *fsid,
++ struct inode *inode,
++ int errno);
++
++#endif /* _DMAPI_PRIVATE_H */
+Index: linux-2.6.26/fs/dmapi/dmapi_region.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_region.c
+@@ -0,0 +1,91 @@
++/*
++ * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++
++int
++dm_get_region(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int nelem,
++ dm_region_t __user *regbufp,
++ u_int __user *nelemp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_REG,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->get_region(tdp->td_ip, tdp->td_right,
++ nelem, regbufp, nelemp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++
++int
++dm_set_region(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int nelem,
++ dm_region_t __user *regbufp,
++ dm_boolean_t __user *exactflagp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_REG,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->set_region(tdp->td_ip, tdp->td_right,
++ nelem, regbufp, exactflagp);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
+Index: linux-2.6.26/fs/dmapi/dmapi_register.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_register.c
+@@ -0,0 +1,1644 @@
++/*
++ * Copyright (c) 2000-2005 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++
++#include <linux/version.h>
++#include <linux/mm.h>
++#include <linux/proc_fs.h>
++#include <linux/module.h>
++#include <linux/mount.h>
++#include <linux/namei.h>
++#include <asm/uaccess.h>
++#include <linux/fs.h>
++#include <linux/file.h>
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++/* LOOKUP_POSTIVE was removed in Linux 2.6 */
++#ifndef LOOKUP_POSITIVE
++#define LOOKUP_POSITIVE 0
++#endif
++
++dm_fsreg_t *dm_registers; /* head of filesystem registration list */
++int dm_fsys_cnt; /* number of filesystems on dm_registers list */
++lock_t dm_reg_lock = SPIN_LOCK_UNLOCKED;/* lock for dm_registers */
++
++
++
++#ifdef CONFIG_PROC_FS
++static int
++fsreg_read_pfs(char *buffer, char **start, off_t offset,
++ int count, int *eof, void *data)
++{
++ int len;
++ int i;
++ dm_fsreg_t *fsrp = (dm_fsreg_t*)data;
++ char statebuf[30];
++
++#define CHKFULL if(len >= count) break;
++#define ADDBUF(a,b) len += sprintf(buffer + len, a, b); CHKFULL;
++
++ switch (fsrp->fr_state) {
++ case DM_STATE_MOUNTING: sprintf(statebuf, "mounting"); break;
++ case DM_STATE_MOUNTED: sprintf(statebuf, "mounted"); break;
++ case DM_STATE_UNMOUNTING: sprintf(statebuf, "unmounting"); break;
++ case DM_STATE_UNMOUNTED: sprintf(statebuf, "unmounted"); break;
++ default:
++ sprintf(statebuf, "unknown:%d", (int)fsrp->fr_state);
++ break;
++ }
++
++ len=0;
++ while(1){
++ ADDBUF("fsrp=0x%p\n", fsrp);
++ ADDBUF("fr_next=0x%p\n", fsrp->fr_next);
++ ADDBUF("fr_sb=0x%p\n", fsrp->fr_sb);
++ ADDBUF("fr_tevp=0x%p\n", fsrp->fr_tevp);
++ ADDBUF("fr_fsid=%c\n", '?');
++ ADDBUF("fr_msg=0x%p\n", fsrp->fr_msg);
++ ADDBUF("fr_msgsize=%d\n", fsrp->fr_msgsize);
++ ADDBUF("fr_state=%s\n", statebuf);
++ ADDBUF("fr_dispq=%c\n", '?');
++ ADDBUF("fr_dispcnt=%d\n", fsrp->fr_dispcnt);
++
++ ADDBUF("fr_evt_dispq.eq_head=0x%p\n", fsrp->fr_evt_dispq.eq_head);
++ ADDBUF("fr_evt_dispq.eq_tail=0x%p\n", fsrp->fr_evt_dispq.eq_tail);
++ ADDBUF("fr_evt_dispq.eq_count=%d\n", fsrp->fr_evt_dispq.eq_count);
++
++ ADDBUF("fr_queue=%c\n", '?');
++ ADDBUF("fr_lock=%c\n", '?');
++ ADDBUF("fr_hdlcnt=%d\n", fsrp->fr_hdlcnt);
++ ADDBUF("fr_vfscnt=%d\n", fsrp->fr_vfscnt);
++ ADDBUF("fr_unmount=%d\n", fsrp->fr_unmount);
++
++ len += sprintf(buffer + len, "fr_rattr=");
++ CHKFULL;
++ for(i = 0; i <= DM_ATTR_NAME_SIZE; ++i){
++ ADDBUF("%c", fsrp->fr_rattr.an_chars[i]);
++ }
++ CHKFULL;
++ len += sprintf(buffer + len, "\n");
++ CHKFULL;
++
++ for(i = 0; i < DM_EVENT_MAX; i++){
++ if( fsrp->fr_sessp[i] != NULL ){
++ ADDBUF("fr_sessp[%d]=", i);
++ ADDBUF("0x%p\n", fsrp->fr_sessp[i]);
++ }
++ }
++ CHKFULL;
++
++ break;
++ }
++
++ if (offset >= len) {
++ *start = buffer;
++ *eof = 1;
++ return 0;
++ }
++ *start = buffer + offset;
++ if ((len -= offset) > count)
++ return count;
++ *eof = 1;
++
++ return len;
++}
++#endif
++
++
++/* Returns a pointer to the filesystem structure for the filesystem
++ referenced by fsidp. The caller is responsible for obtaining dm_reg_lock
++ before calling this routine.
++*/
++
++static dm_fsreg_t *
++dm_find_fsreg(
++ dm_fsid_t *fsidp)
++{
++ dm_fsreg_t *fsrp;
++
++ for (fsrp = dm_registers; fsrp; fsrp = fsrp->fr_next) {
++ if (!memcmp(&fsrp->fr_fsid, fsidp, sizeof(*fsidp)))
++ break;
++ }
++ return(fsrp);
++}
++
++
++/* Given a fsid_t, dm_find_fsreg_and_lock() finds the dm_fsreg_t structure
++ for that filesytem if one exists, and returns a pointer to the structure
++ after obtaining its 'fr_lock' so that the caller can safely modify the
++ dm_fsreg_t. The caller is responsible for releasing 'fr_lock'.
++*/
++
++static dm_fsreg_t *
++dm_find_fsreg_and_lock(
++ dm_fsid_t *fsidp,
++ unsigned long *lcp) /* address of returned lock cookie */
++{
++ dm_fsreg_t *fsrp;
++
++ for (;;) {
++ *lcp = mutex_spinlock(&dm_reg_lock);
++
++ if ((fsrp = dm_find_fsreg(fsidp)) == NULL) {
++ mutex_spinunlock(&dm_reg_lock, *lcp);
++ return(NULL);
++ }
++ if (spin_trylock(&fsrp->fr_lock)) {
++ nested_spinunlock(&dm_reg_lock);
++ return(fsrp); /* success */
++ }
++
++ /* If the second lock is not available, drop the first and
++ start over. This gives the CPU a chance to process any
++ interrupts, and also allows processes which want a fr_lock
++ for a different filesystem to proceed.
++ */
++
++ mutex_spinunlock(&dm_reg_lock, *lcp);
++ }
++}
++
++
++/* dm_add_fsys_entry() is called when a DM_EVENT_MOUNT event is about to be
++ sent. It creates a dm_fsreg_t structure for the filesystem and stores a
++ pointer to a copy of the mount event within that structure so that it is
++ available for subsequent dm_get_mountinfo() calls.
++*/
++
++int
++dm_add_fsys_entry(
++ struct super_block *sb,
++ dm_tokevent_t *tevp)
++{
++ dm_fsreg_t *fsrp;
++ int msgsize;
++ void *msg;
++ unsigned long lc; /* lock cookie */
++ dm_fsid_t fsid;
++ struct filesystem_dmapi_operations *dops;
++
++ dops = dm_fsys_ops(sb);
++ ASSERT(dops);
++ dops->get_fsid(sb, &fsid);
++
++ /* Allocate and initialize a dm_fsreg_t structure for the filesystem. */
++
++ msgsize = tevp->te_allocsize - offsetof(dm_tokevent_t, te_event);
++ msg = kmalloc(msgsize, GFP_KERNEL);
++ if (msg == NULL) {
++ printk("%s/%d: kmalloc returned NULL\n", __FUNCTION__, __LINE__);
++ return -ENOMEM;
++ }
++ memcpy(msg, &tevp->te_event, msgsize);
++
++ fsrp = kmem_cache_alloc(dm_fsreg_cachep, GFP_KERNEL);
++ if (fsrp == NULL) {
++ kfree(msg);
++ printk("%s/%d: kmem_cache_alloc(dm_fsreg_cachep) returned NULL\n", __FUNCTION__, __LINE__);
++ return -ENOMEM;
++ }
++ memset(fsrp, 0, sizeof(*fsrp));
++
++ fsrp->fr_sb = sb;
++ fsrp->fr_tevp = tevp;
++ memcpy(&fsrp->fr_fsid, &fsid, sizeof(fsid));
++ fsrp->fr_msg = msg;
++ fsrp->fr_msgsize = msgsize;
++ fsrp->fr_state = DM_STATE_MOUNTING;
++ sv_init(&fsrp->fr_dispq, SV_DEFAULT, "fr_dispq");
++ sv_init(&fsrp->fr_queue, SV_DEFAULT, "fr_queue");
++ spinlock_init(&fsrp->fr_lock, "fr_lock");
++
++ /* If no other mounted DMAPI filesystem already has this same
++ fsid_t, then add this filesystem to the list.
++ */
++
++ lc = mutex_spinlock(&dm_reg_lock);
++
++ if (!dm_find_fsreg(&fsid)) {
++ fsrp->fr_next = dm_registers;
++ dm_registers = fsrp;
++ dm_fsys_cnt++;
++ mutex_spinunlock(&dm_reg_lock, lc);
++#ifdef CONFIG_PROC_FS
++ {
++ char buf[100];
++ struct proc_dir_entry *entry;
++
++ sprintf(buf, DMAPI_DBG_PROCFS "/fsreg/0x%p", fsrp);
++ entry = create_proc_read_entry(buf, 0, NULL, fsreg_read_pfs, fsrp);
++ entry->owner = THIS_MODULE;
++ }
++#endif
++ return(0);
++ }
++
++ /* A fsid_t collision occurred, so prevent this new filesystem from
++ mounting.
++ */
++
++ mutex_spinunlock(&dm_reg_lock, lc);
++
++ sv_destroy(&fsrp->fr_dispq);
++ sv_destroy(&fsrp->fr_queue);
++ spinlock_destroy(&fsrp->fr_lock);
++ kfree(msg);
++ kmem_cache_free(dm_fsreg_cachep, fsrp);
++ return(-EBUSY);
++}
++
++
++/* dm_change_fsys_entry() is called whenever a filesystem's mount state is
++ about to change. The state is changed to DM_STATE_MOUNTED after a
++ successful DM_EVENT_MOUNT event or after a failed unmount. It is changed
++ to DM_STATE_UNMOUNTING after a successful DM_EVENT_PREUNMOUNT event.
++ Finally, the state is changed to DM_STATE_UNMOUNTED after a successful
++ unmount. It stays in this state until the DM_EVENT_UNMOUNT event is
++ queued, at which point the filesystem entry is removed.
++*/
++
++void
++dm_change_fsys_entry(
++ struct super_block *sb,
++ dm_fsstate_t newstate)
++{
++ dm_fsreg_t *fsrp;
++ int seq_error;
++ unsigned long lc; /* lock cookie */
++ dm_fsid_t fsid;
++ struct filesystem_dmapi_operations *dops;
++
++ /* Find the filesystem referenced by the sb's fsid_t. This should
++ always succeed.
++ */
++
++ dops = dm_fsys_ops(sb);
++ ASSERT(dops);
++ dops->get_fsid(sb, &fsid);
++
++ if ((fsrp = dm_find_fsreg_and_lock(&fsid, &lc)) == NULL) {
++ panic("dm_change_fsys_entry: can't find DMAPI fsrp for "
++ "sb %p\n", sb);
++ }
++
++ /* Make sure that the new state is acceptable given the current state
++ of the filesystem. Any error here is a major DMAPI/filesystem
++ screwup.
++ */
++
++ seq_error = 0;
++ switch (newstate) {
++ case DM_STATE_MOUNTED:
++ if (fsrp->fr_state != DM_STATE_MOUNTING &&
++ fsrp->fr_state != DM_STATE_UNMOUNTING) {
++ seq_error++;
++ }
++ break;
++ case DM_STATE_UNMOUNTING:
++ if (fsrp->fr_state != DM_STATE_MOUNTED)
++ seq_error++;
++ break;
++ case DM_STATE_UNMOUNTED:
++ if (fsrp->fr_state != DM_STATE_UNMOUNTING)
++ seq_error++;
++ break;
++ default:
++ seq_error++;
++ break;
++ }
++ if (seq_error) {
++ panic("dm_change_fsys_entry: DMAPI sequence error: old state "
++ "%d, new state %d, fsrp %p\n", fsrp->fr_state,
++ newstate, fsrp);
++ }
++
++ /* If the old state was DM_STATE_UNMOUNTING, then processes could be
++ sleeping in dm_handle_to_ip() waiting for their DM_NO_TOKEN handles
++ to be translated to inodes. Wake them up so that they either
++ continue (new state is DM_STATE_MOUNTED) or fail (new state is
++ DM_STATE_UNMOUNTED).
++ */
++
++ if (fsrp->fr_state == DM_STATE_UNMOUNTING) {
++ if (fsrp->fr_hdlcnt)
++ sv_broadcast(&fsrp->fr_queue);
++ }
++
++ /* Change the filesystem's mount state to its new value. */
++
++ fsrp->fr_state = newstate;
++ fsrp->fr_tevp = NULL; /* not valid after DM_STATE_MOUNTING */
++
++ /* If the new state is DM_STATE_UNMOUNTING, wait until any application
++ threads currently in the process of making VFS_VGET and VFS_ROOT
++ calls are done before we let this unmount thread continue the
++ unmount. (We want to make sure that the unmount will see these
++ inode references during its scan.)
++ */
++
++ if (newstate == DM_STATE_UNMOUNTING) {
++ while (fsrp->fr_vfscnt) {
++ fsrp->fr_unmount++;
++ sv_wait(&fsrp->fr_queue, 1, &fsrp->fr_lock, lc);
++ lc = mutex_spinlock(&fsrp->fr_lock);
++ fsrp->fr_unmount--;
++ }
++ }
++
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++}
++
++
++/* dm_remove_fsys_entry() gets called after a failed mount or after an
++ DM_EVENT_UNMOUNT event has been queued. (The filesystem entry must stay
++ until the DM_EVENT_UNMOUNT reply is queued so that the event can use the
++ 'fr_sessp' list to see which session to send the event to.)
++*/
++
++void
++dm_remove_fsys_entry(
++ struct super_block *sb)
++{
++ dm_fsreg_t **fsrpp;
++ dm_fsreg_t *fsrp;
++ unsigned long lc; /* lock cookie */
++ struct filesystem_dmapi_operations *dops;
++ dm_fsid_t fsid;
++
++ dops = dm_fsys_ops(sb);
++ ASSERT(dops);
++ dops->get_fsid(sb, &fsid);
++
++ /* Find the filesystem referenced by the sb's fsid_t and dequeue
++ it after verifying that the fr_state shows a filesystem that is
++ either mounting or unmounted.
++ */
++
++ lc = mutex_spinlock(&dm_reg_lock);
++
++ fsrpp = &dm_registers;
++ while ((fsrp = *fsrpp) != NULL) {
++ if (!memcmp(&fsrp->fr_fsid, &fsid, sizeof(fsrp->fr_fsid)))
++ break;
++ fsrpp = &fsrp->fr_next;
++ }
++ if (fsrp == NULL) {
++ mutex_spinunlock(&dm_reg_lock, lc);
++ panic("dm_remove_fsys_entry: can't find DMAPI fsrp for "
++ "sb %p\n", sb);
++ }
++
++ nested_spinlock(&fsrp->fr_lock);
++
++ /* Verify that it makes sense to remove this entry. */
++
++ if (fsrp->fr_state != DM_STATE_MOUNTING &&
++ fsrp->fr_state != DM_STATE_UNMOUNTED) {
++ nested_spinunlock(&fsrp->fr_lock);
++ mutex_spinunlock(&dm_reg_lock, lc);
++ panic("dm_remove_fsys_entry: DMAPI sequence error: old state "
++ "%d, fsrp %p\n", fsrp->fr_state, fsrp);
++ }
++
++ *fsrpp = fsrp->fr_next;
++ dm_fsys_cnt--;
++
++ nested_spinunlock(&dm_reg_lock);
++
++ /* Since the filesystem is about to finish unmounting, we must be sure
++ that no inodes are being referenced within the filesystem before we
++ let this event thread continue. If the filesystem is currently in
++ state DM_STATE_MOUNTING, then we know by definition that there can't
++ be any references. If the filesystem is DM_STATE_UNMOUNTED, then
++ any application threads referencing handles with DM_NO_TOKEN should
++ have already been awakened by dm_change_fsys_entry and should be
++ long gone by now. Just in case they haven't yet left, sleep here
++ until they are really gone.
++ */
++
++ while (fsrp->fr_hdlcnt) {
++ fsrp->fr_unmount++;
++ sv_wait(&fsrp->fr_queue, 1, &fsrp->fr_lock, lc);
++ lc = mutex_spinlock(&fsrp->fr_lock);
++ fsrp->fr_unmount--;
++ }
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++
++ /* Release all memory. */
++
++#ifdef CONFIG_PROC_FS
++ {
++ char buf[100];
++ sprintf(buf, DMAPI_DBG_PROCFS "/fsreg/0x%p", fsrp);
++ remove_proc_entry(buf, NULL);
++ }
++#endif
++ dm_fsys_ops_release(sb);
++ sv_destroy(&fsrp->fr_dispq);
++ sv_destroy(&fsrp->fr_queue);
++ spinlock_destroy(&fsrp->fr_lock);
++ kfree(fsrp->fr_msg);
++ kmem_cache_free(dm_fsreg_cachep, fsrp);
++}
++
++
++/* Get an inode for the object referenced by handlep. We cannot use
++ altgetvfs() because it fails if the VFS_OFFLINE bit is set, which means
++ that any call to dm_handle_to_ip() while a umount is in progress would
++ return an error, even if the umount can't possibly succeed because users
++ are in the filesystem. The requests would start to fail as soon as the
++ umount begins, even before the application receives the DM_EVENT_PREUNMOUNT
++ event.
++
++ dm_handle_to_ip() emulates the behavior of lookup() while an unmount is
++ in progress. Any call to dm_handle_to_ip() while the filesystem is in the
++ DM_STATE_UNMOUNTING state will block. If the unmount eventually succeeds,
++ the requests will wake up and fail. If the unmount fails, the requests will
++ wake up and complete normally.
++
++ While a filesystem is in state DM_STATE_MOUNTING, dm_handle_to_ip() will
++ fail all requests. Per the DMAPI spec, the only handles in the filesystem
++ which are valid during a mount event are the handles within the event
++ itself.
++*/
++
++struct inode *
++dm_handle_to_ip(
++ dm_handle_t *handlep,
++ short *typep)
++{
++ dm_fsreg_t *fsrp;
++ short type;
++ unsigned long lc; /* lock cookie */
++ int error = 0;
++ dm_fid_t *fidp;
++ struct super_block *sb;
++ struct inode *ip;
++ int filetype;
++ struct filesystem_dmapi_operations *dmapiops;
++
++ if ((fsrp = dm_find_fsreg_and_lock(&handlep->ha_fsid, &lc)) == NULL)
++ return NULL;
++
++ fidp = (dm_fid_t*)&handlep->ha_fid;
++ /* If mounting, and we are not asking for a filesystem handle,
++ * then fail the request. (dm_fid_len==0 for fshandle)
++ */
++ if ((fsrp->fr_state == DM_STATE_MOUNTING) &&
++ (fidp->dm_fid_len != 0)) {
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++ return NULL;
++ }
++
++ for (;;) {
++ if (fsrp->fr_state == DM_STATE_MOUNTING)
++ break;
++ if (fsrp->fr_state == DM_STATE_MOUNTED)
++ break;
++ if (fsrp->fr_state == DM_STATE_UNMOUNTED) {
++ if (fsrp->fr_unmount && fsrp->fr_hdlcnt == 0)
++ sv_broadcast(&fsrp->fr_queue);
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++ return NULL;
++ }
++
++ /* Must be DM_STATE_UNMOUNTING. */
++
++ fsrp->fr_hdlcnt++;
++ sv_wait(&fsrp->fr_queue, 1, &fsrp->fr_lock, lc);
++ lc = mutex_spinlock(&fsrp->fr_lock);
++ fsrp->fr_hdlcnt--;
++ }
++
++ fsrp->fr_vfscnt++;
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++
++ /* Now that the mutex is released, wait until we have access to the
++ inode.
++ */
++
++ sb = fsrp->fr_sb;
++ error = -ENOSYS;
++ dmapiops = dm_fsys_ops(sb);
++ ASSERT(dmapiops);
++ if (dmapiops->fh_to_inode)
++ error = dmapiops->fh_to_inode(sb, &ip, (void*)fidp);
++
++ lc = mutex_spinlock(&fsrp->fr_lock);
++
++ fsrp->fr_vfscnt--;
++ if (fsrp->fr_unmount && fsrp->fr_vfscnt == 0)
++ sv_broadcast(&fsrp->fr_queue);
++
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++ if (error || ip == NULL)
++ return NULL;
++
++ filetype = ip->i_mode & S_IFMT;
++ if (fidp->dm_fid_len == 0) {
++ type = DM_TDT_VFS;
++ } else if (filetype == S_IFREG) {
++ type = DM_TDT_REG;
++ } else if (filetype == S_IFDIR) {
++ type = DM_TDT_DIR;
++ } else if (filetype == S_IFLNK) {
++ type = DM_TDT_LNK;
++ } else {
++ type = DM_TDT_OTH;
++ }
++ *typep = type;
++ return ip;
++}
++
++
++int
++dm_ip_to_handle(
++ struct inode *ip,
++ dm_handle_t *handlep)
++{
++ int error;
++ dm_fid_t fid;
++ dm_fsid_t fsid;
++ int hsize;
++ struct filesystem_dmapi_operations *dops;
++
++ dops = dm_fsys_ops(ip->i_sb);
++ ASSERT(dops);
++
++ error = dops->inode_to_fh(ip, &fid, &fsid);
++ if (error)
++ return error;
++
++ memcpy(&handlep->ha_fsid, &fsid, sizeof(fsid));
++ memcpy(&handlep->ha_fid, &fid, fid.dm_fid_len + sizeof fid.dm_fid_len);
++ hsize = DM_HSIZE(*handlep);
++ memset((char *)handlep + hsize, 0, sizeof(*handlep) - hsize);
++ return 0;
++}
++
++
++/* Given an inode, check if that inode resides in filesystem that supports
++ DMAPI. Returns zero if the inode is in a DMAPI filesystem, otherwise
++ returns an errno.
++*/
++
++int
++dm_check_dmapi_ip(
++ struct inode *ip)
++{
++ dm_handle_t handle;
++ /* REFERENCED */
++ dm_fsreg_t *fsrp;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ if ((error = dm_ip_to_handle(ip, &handle)) != 0)
++ return(error);
++
++ if ((fsrp = dm_find_fsreg_and_lock(&handle.ha_fsid, &lc)) == NULL)
++ return(-EBADF);
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++ return(0);
++}
++
++
++/* Return a pointer to the DM_EVENT_MOUNT event while a mount is still in
++ progress. This is only called by dm_get_config and dm_get_config_events
++ which need to access the filesystem during a mount but which don't have
++ a session and token to use.
++*/
++
++dm_tokevent_t *
++dm_find_mount_tevp_and_lock(
++ dm_fsid_t *fsidp,
++ unsigned long *lcp) /* address of returned lock cookie */
++{
++ dm_fsreg_t *fsrp;
++
++ if ((fsrp = dm_find_fsreg_and_lock(fsidp, lcp)) == NULL)
++ return(NULL);
++
++ if (!fsrp->fr_tevp || fsrp->fr_state != DM_STATE_MOUNTING) {
++ mutex_spinunlock(&fsrp->fr_lock, *lcp);
++ return(NULL);
++ }
++ nested_spinlock(&fsrp->fr_tevp->te_lock);
++ nested_spinunlock(&fsrp->fr_lock);
++ return(fsrp->fr_tevp);
++}
++
++
++/* Wait interruptibly until a session registers disposition for 'event' in
++ filesystem 'sb'. Upon successful exit, both the filesystem's dm_fsreg_t
++ structure and the session's dm_session_t structure are locked. The caller
++ is responsible for unlocking both structures using the returned cookies.
++
++ Warning: The locks can be dropped in any order, but the 'lc2p' cookie MUST
++ BE USED FOR THE FIRST UNLOCK, and the lc1p cookie must be used for the
++ second unlock. If this is not done, the CPU will be interruptible while
++ holding a mutex, which could deadlock the machine!
++*/
++
++static int
++dm_waitfor_disp(
++ struct super_block *sb,
++ dm_tokevent_t *tevp,
++ dm_fsreg_t **fsrpp,
++ unsigned long *lc1p, /* addr of first returned lock cookie */
++ dm_session_t **sessionpp,
++ unsigned long *lc2p) /* addr of 2nd returned lock cookie */
++{
++ dm_eventtype_t event = tevp->te_msg.ev_type;
++ dm_session_t *s;
++ dm_fsreg_t *fsrp;
++ dm_fsid_t fsid;
++ struct filesystem_dmapi_operations *dops;
++
++ dops = dm_fsys_ops(sb);
++ ASSERT(dops);
++
++ dops->get_fsid(sb, &fsid);
++ if ((fsrp = dm_find_fsreg_and_lock(&fsid, lc1p)) == NULL)
++ return -ENOENT;
++
++ /* If no session is registered for this event in the specified
++ filesystem, then sleep interruptibly until one does.
++ */
++
++ for (;;) {
++ int rc = 0;
++
++ /* The dm_find_session_and_lock() call is needed because a
++ session that is in the process of being removed might still
++ be in the dm_fsreg_t structure but won't be in the
++ dm_sessions list.
++ */
++
++ if ((s = fsrp->fr_sessp[event]) != NULL &&
++ dm_find_session_and_lock(s->sn_sessid, &s, lc2p) == 0) {
++ break;
++ }
++
++ /* Noone is currently registered. DM_EVENT_UNMOUNT events
++ don't wait for anyone to register because the unmount is
++ already past the point of no return.
++ */
++
++ if (event == DM_EVENT_UNMOUNT) {
++ mutex_spinunlock(&fsrp->fr_lock, *lc1p);
++ return -ENOENT;
++ }
++
++ /* Wait until a session registers for disposition of this
++ event.
++ */
++
++ fsrp->fr_dispcnt++;
++ dm_link_event(tevp, &fsrp->fr_evt_dispq);
++
++ sv_wait_sig(&fsrp->fr_dispq, 1, &fsrp->fr_lock, *lc1p);
++ rc = signal_pending(current);
++
++ *lc1p = mutex_spinlock(&fsrp->fr_lock);
++ fsrp->fr_dispcnt--;
++ dm_unlink_event(tevp, &fsrp->fr_evt_dispq);
++#ifdef HAVE_DM_QUEUE_FLUSH
++ if (tevp->te_flags & DM_TEF_FLUSH) {
++ mutex_spinunlock(&fsrp->fr_lock, *lc1p);
++ return tevp->te_reply;
++ }
++#endif /* HAVE_DM_QUEUE_FLUSH */
++ if (rc) { /* if signal was received */
++ mutex_spinunlock(&fsrp->fr_lock, *lc1p);
++ return -EINTR;
++ }
++ }
++ *sessionpp = s;
++ *fsrpp = fsrp;
++ return 0;
++}
++
++
++/* Returns the session pointer for the session registered for an event
++ in the given sb. If successful, the session is locked upon return. The
++ caller is responsible for releasing the lock. If no session is currently
++ registered for the event, dm_waitfor_disp_session() will sleep interruptibly
++ until a registration occurs.
++*/
++
++int
++dm_waitfor_disp_session(
++ struct super_block *sb,
++ dm_tokevent_t *tevp,
++ dm_session_t **sessionpp,
++ unsigned long *lcp)
++{
++ dm_fsreg_t *fsrp;
++ unsigned long lc2;
++ int error;
++
++ if (tevp->te_msg.ev_type < 0 || tevp->te_msg.ev_type > DM_EVENT_MAX)
++ return(-EIO);
++
++ error = dm_waitfor_disp(sb, tevp, &fsrp, lcp, sessionpp, &lc2);
++ if (!error)
++ mutex_spinunlock(&fsrp->fr_lock, lc2); /* rev. cookie order*/
++ return(error);
++}
++
++
++/* Find the session registered for the DM_EVENT_DESTROY event on the specified
++ filesystem, sleeping if necessary until registration occurs. Once found,
++ copy the session's return-on-destroy attribute name, if any, back to the
++ caller.
++*/
++
++int
++dm_waitfor_destroy_attrname(
++ struct super_block *sbp,
++ dm_attrname_t *attrnamep)
++{
++ dm_tokevent_t *tevp;
++ dm_session_t *s;
++ dm_fsreg_t *fsrp;
++ int error;
++ unsigned long lc1; /* first lock cookie */
++ unsigned long lc2; /* second lock cookie */
++ void *msgp;
++
++ tevp = dm_evt_create_tevp(DM_EVENT_DESTROY, 1, (void**)&msgp);
++ error = dm_waitfor_disp(sbp, tevp, &fsrp, &lc1, &s, &lc2);
++ if (!error) {
++ *attrnamep = fsrp->fr_rattr; /* attribute or zeros */
++ mutex_spinunlock(&s->sn_qlock, lc2); /* rev. cookie order */
++ mutex_spinunlock(&fsrp->fr_lock, lc1);
++ }
++ dm_evt_rele_tevp(tevp,0);
++ return(error);
++}
++
++
++/* Unregisters the session for the disposition of all events on all
++ filesystems. This routine is not called until the session has been
++ dequeued from the session list and its session lock has been dropped,
++ but before the actual structure is freed, so it is safe to grab the
++ 'dm_reg_lock' here. If dm_waitfor_disp_session() happens to be called
++ by another thread, it won't find this session on the session list and
++ will wait until a new session registers.
++*/
++
++void
++dm_clear_fsreg(
++ dm_session_t *s)
++{
++ dm_fsreg_t *fsrp;
++ int event;
++ unsigned long lc; /* lock cookie */
++
++ lc = mutex_spinlock(&dm_reg_lock);
++
++ for (fsrp = dm_registers; fsrp != NULL; fsrp = fsrp->fr_next) {
++ nested_spinlock(&fsrp->fr_lock);
++ for (event = 0; event < DM_EVENT_MAX; event++) {
++ if (fsrp->fr_sessp[event] != s)
++ continue;
++ fsrp->fr_sessp[event] = NULL;
++ if (event == DM_EVENT_DESTROY)
++ memset(&fsrp->fr_rattr, 0, sizeof(fsrp->fr_rattr));
++ }
++ nested_spinunlock(&fsrp->fr_lock);
++ }
++
++ mutex_spinunlock(&dm_reg_lock, lc);
++}
++
++
++/*
++ * Return the handle for the object named by path.
++ */
++
++int
++dm_path_to_hdl(
++ char __user *path, /* any path name */
++ void __user *hanp, /* user's data buffer */
++ size_t __user *hlenp) /* set to size of data copied */
++{
++ /* REFERENCED */
++ dm_fsreg_t *fsrp;
++ dm_handle_t handle;
++ size_t hlen;
++ int error;
++ unsigned long lc; /* lock cookie */
++ struct nameidata nd;
++ struct inode *inode;
++ size_t len;
++ char *name;
++ struct filesystem_dmapi_operations *dops;
++
++ /* XXX get things straightened out so getname() works here? */
++ if (!(len = strnlen_user(path, PATH_MAX)))
++ return(-EFAULT);
++ if (len == 1)
++ return(-ENOENT);
++ if (len > PATH_MAX)
++ return(-ENAMETOOLONG);
++ name = kmalloc(len, GFP_KERNEL);
++ if (name == NULL) {
++ printk("%s/%d: kmalloc returned NULL\n", __FUNCTION__, __LINE__);
++ return(-ENOMEM);
++ }
++ if (copy_from_user(name, path, len)) {
++ kfree(name);
++ return(-EFAULT);
++ }
++
++ error = path_lookup(name, LOOKUP_POSITIVE, &nd);
++ kfree(name);
++ if (error)
++ return error;
++
++ ASSERT(nd.path.dentry);
++ ASSERT(nd.path.dentry->d_inode);
++ inode = igrab(nd.path.dentry->d_inode);
++ path_put(&nd.path);
++
++ dops = dm_fsys_ops(inode->i_sb);
++ if (dops == NULL) {
++ /* No longer in a dmapi-capable filesystem...Toto */
++ iput(inode);
++ return -EINVAL;
++ }
++
++ /* we need the inode */
++ error = dm_ip_to_handle(inode, &handle);
++ iput(inode);
++ if (error)
++ return(error);
++
++ if ((fsrp = dm_find_fsreg_and_lock(&handle.ha_fsid, &lc)) == NULL)
++ return(-EBADF);
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++
++ hlen = DM_HSIZE(handle);
++
++ if (copy_to_user(hanp, &handle, (int)hlen))
++ return(-EFAULT);
++ if (put_user(hlen,hlenp))
++ return(-EFAULT);
++ return 0;
++}
++
++
++/*
++ * Return the handle for the file system containing the object named by path.
++ */
++
++int
++dm_path_to_fshdl(
++ char __user *path, /* any path name */
++ void __user *hanp, /* user's data buffer */
++ size_t __user *hlenp) /* set to size of data copied */
++{
++ /* REFERENCED */
++ dm_fsreg_t *fsrp;
++ dm_handle_t handle;
++ size_t hlen;
++ int error;
++ unsigned long lc; /* lock cookie */
++ struct nameidata nd;
++ struct inode *inode;
++ size_t len;
++ char *name;
++ struct filesystem_dmapi_operations *dops;
++
++ /* XXX get things straightened out so getname() works here? */
++ if(!(len = strnlen_user(path, PATH_MAX)))
++ return(-EFAULT);
++ if (len == 1)
++ return(-ENOENT);
++ if (len > PATH_MAX)
++ return(-ENAMETOOLONG);
++ name = kmalloc(len, GFP_KERNEL);
++ if (name == NULL) {
++ printk("%s/%d: kmalloc returned NULL\n", __FUNCTION__, __LINE__);
++ return(-ENOMEM);
++ }
++ if (copy_from_user(name, path, len)) {
++ kfree(name);
++ return(-EFAULT);
++ }
++
++ error = path_lookup(name, LOOKUP_POSITIVE|LOOKUP_FOLLOW, &nd);
++ kfree(name);
++ if (error)
++ return error;
++
++ ASSERT(nd.path.dentry);
++ ASSERT(nd.path.dentry->d_inode);
++
++ inode = igrab(nd.path.dentry->d_inode);
++ path_put(&nd.path);
++
++ dops = dm_fsys_ops(inode->i_sb);
++ if (dops == NULL) {
++ /* No longer in a dmapi-capable filesystem...Toto */
++ iput(inode);
++ return -EINVAL;
++ }
++
++ error = dm_ip_to_handle(inode, &handle);
++ iput(inode);
++
++ if (error)
++ return(error);
++
++ if ((fsrp = dm_find_fsreg_and_lock(&handle.ha_fsid, &lc)) == NULL)
++ return(-EBADF);
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++
++ hlen = DM_FSHSIZE;
++ if(copy_to_user(hanp, &handle, (int)hlen))
++ return(-EFAULT);
++ if(put_user(hlen,hlenp))
++ return(-EFAULT);
++ return 0;
++}
++
++
++int
++dm_fd_to_hdl(
++ int fd, /* any file descriptor */
++ void __user *hanp, /* user's data buffer */
++ size_t __user *hlenp) /* set to size of data copied */
++{
++ /* REFERENCED */
++ dm_fsreg_t *fsrp;
++ dm_handle_t handle;
++ size_t hlen;
++ int error;
++ unsigned long lc; /* lock cookie */
++ struct file *filep = fget(fd);
++ struct inode *ip = filep->f_dentry->d_inode;
++
++ if (!filep)
++ return(-EBADF);
++ if ((error = dm_ip_to_handle(ip, &handle)) != 0)
++ return(error);
++
++ if ((fsrp = dm_find_fsreg_and_lock(&handle.ha_fsid, &lc)) == NULL)
++ return(-EBADF);
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++
++ hlen = DM_HSIZE(handle);
++ if (copy_to_user(hanp, &handle, (int)hlen))
++ return(-EFAULT);
++ fput(filep);
++ if(put_user(hlen, hlenp))
++ return(-EFAULT);
++ return 0;
++}
++
++
++/* Enable events on an object. */
++
++int
++dm_set_eventlist(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_eventset_t __user *eventsetp,
++ u_int maxevent)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_eventset_t eventset;
++ dm_tokdata_t *tdp;
++ int error;
++
++ if (copy_from_user(&eventset, eventsetp, sizeof(eventset)))
++ return(-EFAULT);
++
++ /* Do some minor sanity checking. */
++
++ if (maxevent == 0 || maxevent > DM_EVENT_MAX)
++ return(-EINVAL);
++
++ /* Access the specified object. */
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_ANY,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->set_eventlist(tdp->td_ip, tdp->td_right,
++ (tdp->td_type == DM_TDT_VFS ? DM_FSYS_OBJ : 0),
++ &eventset, maxevent);
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++/* Return the list of enabled events for an object. */
++
++int
++dm_get_eventlist(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int nelem,
++ dm_eventset_t __user *eventsetp,
++ u_int __user *nelemp)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ dm_eventset_t eventset;
++ u_int elem;
++ int error;
++
++ if (nelem == 0)
++ return(-EINVAL);
++
++ /* Access the specified object. */
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_ANY,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ /* Get the object's event list. */
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->get_eventlist(tdp->td_ip, tdp->td_right,
++ (tdp->td_type == DM_TDT_VFS ? DM_FSYS_OBJ : 0),
++ nelem, &eventset, &elem);
++
++ dm_app_put_tdp(tdp);
++
++ if (error)
++ return(error);
++
++ if (copy_to_user(eventsetp, &eventset, sizeof(eventset)))
++ return(-EFAULT);
++ if (put_user(nelem, nelemp))
++ return(-EFAULT);
++ return(0);
++}
++
++
++/* Register for disposition of events. The handle must either be the
++ global handle or must be the handle of a file system. The list of events
++ is pointed to by eventsetp.
++*/
++
++int
++dm_set_disp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_eventset_t __user *eventsetp,
++ u_int maxevent)
++{
++ dm_session_t *s;
++ dm_fsreg_t *fsrp;
++ dm_tokdata_t *tdp;
++ dm_eventset_t eventset;
++ int error;
++ unsigned long lc1; /* first lock cookie */
++ unsigned long lc2; /* second lock cookie */
++ u_int i;
++
++ /* Copy in and validate the event mask. Only the lower maxevent bits
++ are meaningful, so clear any bits set above maxevent.
++ */
++
++ if (maxevent == 0 || maxevent > DM_EVENT_MAX)
++ return(-EINVAL);
++ if (copy_from_user(&eventset, eventsetp, sizeof(eventset)))
++ return(-EFAULT);
++ eventset &= (1 << maxevent) - 1;
++
++ /* If the caller specified the global handle, then the only valid token
++ is DM_NO_TOKEN, and the only valid event in the event mask is
++ DM_EVENT_MOUNT. If it is set, add the session to the list of
++ sessions that want to receive mount events. If it is clear, remove
++ the session from the list. Since DM_EVENT_MOUNT events never block
++ waiting for a session to register, there is noone to wake up if we
++ do add the session to the list.
++ */
++
++ if (DM_GLOBALHAN(hanp, hlen)) {
++ if (token != DM_NO_TOKEN)
++ return(-EINVAL);
++ if ((error = dm_find_session_and_lock(sid, &s, &lc1)) != 0)
++ return(error);
++ if (eventset == 0) {
++ s->sn_flags &= ~DM_SN_WANTMOUNT;
++ error = 0;
++ } else if (eventset == 1 << DM_EVENT_MOUNT) {
++ s->sn_flags |= DM_SN_WANTMOUNT;
++ error = 0;
++ } else {
++ error = -EINVAL;
++ }
++ mutex_spinunlock(&s->sn_qlock, lc1);
++ return(error);
++ }
++
++ /* Since it's not the global handle, it had better be a filesystem
++ handle. Verify that the first 'maxevent' events in the event list
++ are all valid for a filesystem handle.
++ */
++
++ if (eventset & ~DM_VALID_DISP_EVENTS)
++ return(-EINVAL);
++
++ /* Verify that the session is valid, that the handle is a filesystem
++ handle, and that the filesystem is capable of sending events. (If
++ a dm_fsreg_t structure exists, then the filesystem can issue events.)
++ */
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VFS,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsrp = dm_find_fsreg_and_lock(&tdp->td_handle.ha_fsid, &lc1);
++ if (fsrp == NULL) {
++ dm_app_put_tdp(tdp);
++ return(-EINVAL);
++ }
++
++ /* Now that we own 'fsrp->fr_lock', get the lock on the session so that
++ it can't disappear while we add it to the filesystem's event mask.
++ */
++
++ if ((error = dm_find_session_and_lock(sid, &s, &lc2)) != 0) {
++ mutex_spinunlock(&fsrp->fr_lock, lc1);
++ dm_app_put_tdp(tdp);
++ return(error);
++ }
++
++ /* Update the event disposition array for this filesystem, adding
++ and/or removing the session as appropriate. If this session is
++ dropping registration for DM_EVENT_DESTROY, or is overriding some
++ other session's registration for DM_EVENT_DESTROY, then clear any
++ any attr-on-destroy attribute name also.
++ */
++
++ for (i = 0; i < DM_EVENT_MAX; i++) {
++ if (DMEV_ISSET(i, eventset)) {
++ if (i == DM_EVENT_DESTROY && fsrp->fr_sessp[i] != s)
++ memset(&fsrp->fr_rattr, 0, sizeof(fsrp->fr_rattr));
++ fsrp->fr_sessp[i] = s;
++ } else if (fsrp->fr_sessp[i] == s) {
++ if (i == DM_EVENT_DESTROY)
++ memset(&fsrp->fr_rattr, 0, sizeof(fsrp->fr_rattr));
++ fsrp->fr_sessp[i] = NULL;
++ }
++ }
++ mutex_spinunlock(&s->sn_qlock, lc2); /* reverse cookie order */
++
++ /* Wake up all processes waiting for a disposition on this filesystem
++ in case any of them happen to be waiting for an event which we just
++ added.
++ */
++
++ if (fsrp->fr_dispcnt)
++ sv_broadcast(&fsrp->fr_dispq);
++
++ mutex_spinunlock(&fsrp->fr_lock, lc1);
++
++ dm_app_put_tdp(tdp);
++ return(0);
++}
++
++
++/*
++ * Register a specific attribute name with a filesystem. The value of
++ * the attribute is to be returned with an asynchronous destroy event.
++ */
++
++int
++dm_set_return_on_destroy(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_attrname_t __user *attrnamep,
++ dm_boolean_t enable)
++{
++ dm_attrname_t attrname;
++ dm_tokdata_t *tdp;
++ dm_fsreg_t *fsrp;
++ dm_session_t *s;
++ int error;
++ unsigned long lc1; /* first lock cookie */
++ unsigned long lc2; /* second lock cookie */
++
++ /* If a dm_attrname_t is provided, copy it in and validate it. */
++
++ if (enable && (error = copy_from_user(&attrname, attrnamep, sizeof(attrname))) != 0)
++ return(error);
++
++ /* Validate the filesystem handle and use it to get the filesystem's
++ disposition structure.
++ */
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VFS,
++ DM_RIGHT_EXCL, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsrp = dm_find_fsreg_and_lock(&tdp->td_handle.ha_fsid, &lc1);
++ if (fsrp == NULL) {
++ dm_app_put_tdp(tdp);
++ return(-EINVAL);
++ }
++
++ /* Now that we own 'fsrp->fr_lock', get the lock on the session so that
++ it can't disappear while we add it to the filesystem's event mask.
++ */
++
++ if ((error = dm_find_session_and_lock(sid, &s, &lc2)) != 0) {
++ mutex_spinunlock(&fsrp->fr_lock, lc1);
++ dm_app_put_tdp(tdp);
++ return(error);
++ }
++
++ /* A caller cannot disable return-on-destroy if he is not registered
++ for DM_EVENT_DESTROY. Enabling return-on-destroy is an implicit
++ dm_set_disp() for DM_EVENT_DESTROY; we wake up all processes
++ waiting for a disposition in case any was waiting for a
++ DM_EVENT_DESTROY event.
++ */
++
++ error = 0;
++ if (enable) {
++ fsrp->fr_sessp[DM_EVENT_DESTROY] = s;
++ fsrp->fr_rattr = attrname;
++ if (fsrp->fr_dispcnt)
++ sv_broadcast(&fsrp->fr_dispq);
++ } else if (fsrp->fr_sessp[DM_EVENT_DESTROY] != s) {
++ error = -EINVAL;
++ } else {
++ memset(&fsrp->fr_rattr, 0, sizeof(fsrp->fr_rattr));
++ }
++ mutex_spinunlock(&s->sn_qlock, lc2); /* reverse cookie order */
++ mutex_spinunlock(&fsrp->fr_lock, lc1);
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_get_mountinfo(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp)
++{
++ dm_fsreg_t *fsrp;
++ dm_tokdata_t *tdp;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ /* Make sure that the caller's buffer is 8-byte aligned. */
++
++ if (((unsigned long)bufp & (sizeof(__u64) - 1)) != 0)
++ return(-EFAULT);
++
++ /* Verify that the handle is a filesystem handle, and that the
++ filesystem is capable of sending events. If not, return an error.
++ */
++
++ error = dm_app_get_tdp(sid, hanp, hlen, token, DM_TDT_VFS,
++ DM_RIGHT_SHARED, &tdp);
++ if (error != 0)
++ return(error);
++
++ /* Find the filesystem entry. This should always succeed as the
++ dm_app_get_tdp call created a filesystem reference. Once we find
++ the entry, drop the lock. The mountinfo message is never modified,
++ the filesystem entry can't disappear, and we don't want to hold a
++ spinlock while doing copyout calls.
++ */
++
++ fsrp = dm_find_fsreg_and_lock(&tdp->td_handle.ha_fsid, &lc);
++ if (fsrp == NULL) {
++ dm_app_put_tdp(tdp);
++ return(-EINVAL);
++ }
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++
++ /* Copy the message into the user's buffer and update his 'rlenp'. */
++
++ if (put_user(fsrp->fr_msgsize, rlenp)) {
++ error = -EFAULT;
++ } else if (fsrp->fr_msgsize > buflen) { /* user buffer not big enough */
++ error = -E2BIG;
++ } else if (copy_to_user(bufp, fsrp->fr_msg, fsrp->fr_msgsize)) {
++ error = -EFAULT;
++ } else {
++ error = 0;
++ }
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_getall_disp(
++ dm_sessid_t sid,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp)
++{
++ dm_session_t *s; /* pointer to session given by sid */
++ unsigned long lc1; /* first lock cookie */
++ unsigned long lc2; /* second lock cookie */
++ int totalsize;
++ int msgsize;
++ int fsyscnt;
++ dm_dispinfo_t *prevmsg;
++ dm_fsreg_t *fsrp;
++ int error;
++ char *kbuf;
++
++ int tmp3;
++ int tmp4;
++
++ /* Because the dm_getall_disp structure contains a __u64 field,
++ make sure that the buffer provided by the caller is aligned so
++ that he can read such fields successfully.
++ */
++
++ if (((unsigned long)bufp & (sizeof(__u64) - 1)) != 0)
++ return(-EFAULT);
++
++ /* Compute the size of a dm_dispinfo structure, rounding up to an
++ 8-byte boundary so that any subsequent structures will also be
++ aligned.
++ */
++
++#if 0
++ /* XXX ug, what is going on here? */
++ msgsize = (sizeof(dm_dispinfo_t) + DM_FSHSIZE + sizeof(uint64_t) - 1) &
++ ~(sizeof(uint64_t) - 1);
++#else
++ tmp3 = sizeof(dm_dispinfo_t) + DM_FSHSIZE;
++ tmp3 += sizeof(__u64);
++ tmp3 -= 1;
++ tmp4 = ~((int)sizeof(__u64) - 1);
++ msgsize = tmp3 & tmp4;
++#endif
++
++ /* Loop until we can get the right amount of temp space, being careful
++ not to hold a mutex during the allocation. Usually only one trip.
++ */
++
++ for (;;) {
++ if ((fsyscnt = dm_fsys_cnt) == 0) {
++ /*if (dm_cpoutsizet(rlenp, 0))*/
++ if (put_user(0,rlenp))
++ return(-EFAULT);
++ return(0);
++ }
++ kbuf = kmalloc(fsyscnt * msgsize, GFP_KERNEL);
++ if (kbuf == NULL) {
++ printk("%s/%d: kmalloc returned NULL\n", __FUNCTION__, __LINE__);
++ return -ENOMEM;
++ }
++
++ lc1 = mutex_spinlock(&dm_reg_lock);
++ if (fsyscnt == dm_fsys_cnt)
++ break;
++
++ mutex_spinunlock(&dm_reg_lock, lc1);
++ kfree(kbuf);
++ }
++
++ /* Find the indicated session and lock it. */
++
++ if ((error = dm_find_session_and_lock(sid, &s, &lc2)) != 0) {
++ mutex_spinunlock(&dm_reg_lock, lc1);
++ kfree(kbuf);
++ return(error);
++ }
++
++ /* Create a dm_dispinfo structure for each filesystem in which
++ this session has at least one event selected for disposition.
++ */
++
++ totalsize = 0; /* total bytes to transfer to the user */
++ prevmsg = NULL;
++
++ for (fsrp = dm_registers; fsrp; fsrp = fsrp->fr_next) {
++ dm_dispinfo_t *disp;
++ int event;
++ int found;
++
++ disp = (dm_dispinfo_t *)(kbuf + totalsize);
++
++ DMEV_ZERO(disp->di_eventset);
++
++ for (event = 0, found = 0; event < DM_EVENT_MAX; event++) {
++ if (fsrp->fr_sessp[event] != s)
++ continue;
++ DMEV_SET(event, disp->di_eventset);
++ found++;
++ }
++ if (!found)
++ continue;
++
++ disp->_link = 0;
++ disp->di_fshandle.vd_offset = sizeof(dm_dispinfo_t);
++ disp->di_fshandle.vd_length = DM_FSHSIZE;
++
++ memcpy((char *)disp + disp->di_fshandle.vd_offset,
++ &fsrp->fr_fsid, disp->di_fshandle.vd_length);
++
++ if (prevmsg)
++ prevmsg->_link = msgsize;
++
++ prevmsg = disp;
++ totalsize += msgsize;
++ }
++ mutex_spinunlock(&s->sn_qlock, lc2); /* reverse cookie order */
++ mutex_spinunlock(&dm_reg_lock, lc1);
++
++ if (put_user(totalsize, rlenp)) {
++ error = -EFAULT;
++ } else if (totalsize > buflen) { /* no more room */
++ error = -E2BIG;
++ } else if (totalsize && copy_to_user(bufp, kbuf, totalsize)) {
++ error = -EFAULT;
++ } else {
++ error = 0;
++ }
++
++ kfree(kbuf);
++ return(error);
++}
++
++int
++dm_open_by_handle_rvp(
++ unsigned int fd,
++ void __user *hanp,
++ size_t hlen,
++ int flags,
++ int *rvp)
++{
++ dm_handle_t handle;
++ int error;
++ short td_type;
++ struct dentry *dentry;
++ struct inode *inodep;
++ int new_fd;
++ struct file *mfilp;
++ struct file *filp;
++
++ if ((error = dm_copyin_handle(hanp, hlen, &handle)) != 0) {
++ return(error);
++ }
++
++ if ((inodep = dm_handle_to_ip(&handle, &td_type)) == NULL) {
++ return(-EBADF);
++ }
++ if ((td_type == DM_TDT_VFS) || (td_type == DM_TDT_OTH)) {
++ iput(inodep);
++ return(-EBADF);
++ }
++
++ if ((new_fd = get_unused_fd()) < 0) {
++ iput(inodep);
++ return(-EMFILE);
++ }
++
++ dentry = d_alloc_anon(inodep);
++ if (dentry == NULL) {
++ iput(inodep);
++ put_unused_fd(new_fd);
++ return(-ENOMEM);
++ }
++
++ mfilp = fget(fd);
++ if (!mfilp) {
++ dput(dentry);
++ put_unused_fd(new_fd);
++ return(-EBADF);
++ }
++
++ mntget(mfilp->f_vfsmnt);
++
++ /* Create file pointer */
++ filp = dentry_open(dentry, mfilp->f_vfsmnt, flags);
++ if (IS_ERR(filp)) {
++ put_unused_fd(new_fd);
++ fput(mfilp);
++ return PTR_ERR(filp);
++ }
++
++ if (td_type == DM_TDT_REG) {
++ struct filesystem_dmapi_operations *dmapiops;
++ dmapiops = dm_fsys_ops(inodep->i_sb);
++ if (dmapiops && dmapiops->get_invis_ops) {
++ /* invisible operation should not change atime */
++ filp->f_flags |= O_NOATIME;
++ filp->f_op = dmapiops->get_invis_ops(inodep);
++ }
++ }
++ fd_install(new_fd, filp);
++ fput(mfilp);
++ *rvp = new_fd;
++ return 0;
++}
++
++
++#ifdef HAVE_DM_QUEUE_FLUSH
++/* Find the threads that have a reference to our filesystem and force
++ them to return with the specified errno.
++ We look for them in each dm_fsreg_t's fr_evt_dispq.
++*/
++
++int
++dm_release_disp_threads(
++ dm_fsid_t *fsidp,
++ struct inode *inode, /* may be null */
++ int errno)
++{
++ unsigned long lc;
++ dm_fsreg_t *fsrp;
++ dm_tokevent_t *tevp;
++ dm_tokdata_t *tdp;
++ dm_eventq_t *queue;
++ int found_events = 0;
++
++ if ((fsrp = dm_find_fsreg_and_lock(fsidp, &lc)) == NULL){
++ return 0;
++ }
++
++ queue = &fsrp->fr_evt_dispq;
++ for (tevp = queue->eq_head; tevp; tevp = tevp->te_next) {
++ nested_spinlock(&tevp->te_lock);
++ if (inode) {
++ for (tdp = tevp->te_tdp; tdp; tdp = tdp->td_next) {
++ if( tdp->td_ip == inode ) {
++ tevp->te_flags |= DM_TEF_FLUSH;
++ tevp->te_reply = errno;
++ found_events = 1;
++ break;
++ }
++ }
++ }
++ else {
++ tevp->te_flags |= DM_TEF_FLUSH;
++ tevp->te_reply = errno;
++ found_events = 1;
++ }
++ nested_spinunlock(&tevp->te_lock);
++ }
++
++ if (found_events && fsrp->fr_dispcnt)
++ sv_broadcast(&fsrp->fr_dispq);
++ mutex_spinunlock(&fsrp->fr_lock, lc);
++ return 0;
++}
++#endif /* HAVE_DM_QUEUE_FLUSH */
+Index: linux-2.6.26/fs/dmapi/dmapi_right.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_right.c
+@@ -0,0 +1,1256 @@
++/*
++ * Copyright (c) 2000-2004 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++#include <asm/uaccess.h>
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++
++#define DM_FG_STHREAD 0x001 /* keep other threads from using tdp */
++#define DM_FG_MUSTEXIST 0x002 /* handle must exist in the event */
++#define DM_FG_DONTADD 0x004 /* don't add handle if not in event */
++
++/* Get a handle of the form (void *, size_t) from user space and convert it to
++ a handle_t. Do as much validation of the result as possible; any error
++ other than a bad address should return EBADF per the DMAPI spec.
++*/
++
++int
++dm_copyin_handle(
++ void __user *hanp, /* input, handle data */
++ size_t hlen, /* input, size of handle data */
++ dm_handle_t *handlep) /* output, copy of data */
++{
++ u_short len;
++ dm_fid_t *fidp;
++
++ fidp = (dm_fid_t*)&handlep->ha_fid;
++
++ if (hlen < sizeof(handlep->ha_fsid) || hlen > sizeof(*handlep))
++ return -EBADF;
++
++ if (copy_from_user(handlep, hanp, hlen))
++ return -EFAULT;
++
++ if (hlen < sizeof(*handlep))
++ memset((char *)handlep + hlen, 0, sizeof(*handlep) - hlen);
++
++ if (hlen == sizeof(handlep->ha_fsid))
++ return 0; /* FS handle, nothing more to check */
++
++ len = hlen - sizeof(handlep->ha_fsid) - sizeof(fidp->dm_fid_len);
++
++ if ((fidp->dm_fid_len != len) || fidp->dm_fid_pad)
++ return -EBADF;
++ return 0;
++}
++
++/* Allocate and initialize a tevp structure. Called from both application and
++ event threads.
++*/
++
++static dm_tokevent_t *
++dm_init_tevp(
++ int ev_size, /* size of event structure */
++ int var_size) /* size of variable-length data */
++{
++ dm_tokevent_t *tevp;
++ int msgsize;
++
++ /* Calculate the size of the event in bytes and allocate memory for it.
++ Zero all but the variable portion of the message, which will be
++ eventually overlaid by the caller with data.
++ */
++
++ msgsize = offsetof(dm_tokevent_t, te_event) + ev_size + var_size;
++ tevp = kmalloc(msgsize, GFP_KERNEL);
++ if (tevp == NULL) {
++ printk("%s/%d: kmalloc returned NULL\n", __FUNCTION__, __LINE__);
++ return NULL;
++ }
++ memset(tevp, 0, msgsize - var_size);
++
++ /* Now initialize all the non-zero fields. */
++
++ spinlock_init(&tevp->te_lock, "te_lock");
++ sv_init(&tevp->te_evt_queue, SV_DEFAULT, "te_evt_queue");
++ sv_init(&tevp->te_app_queue, SV_DEFAULT, "te_app_queue");
++ tevp->te_allocsize = msgsize;
++ tevp->te_msg.ev_type = DM_EVENT_INVALID;
++ tevp->te_flags = 0;
++
++ return(tevp);
++}
++
++
++/* Given the event type and the number of bytes of variable length data that
++ will follow the event, dm_evt_create_tevp() creates a dm_tokevent_t
++ structure to hold the event and initializes all the common event fields.
++
++ No locking is required for this routine because the caller is an event
++ thread, and is therefore the only thread that can see the event.
++*/
++
++dm_tokevent_t *
++dm_evt_create_tevp(
++ dm_eventtype_t event,
++ int variable_size,
++ void **msgpp)
++{
++ dm_tokevent_t *tevp;
++ int evsize;
++
++ switch (event) {
++ case DM_EVENT_READ:
++ case DM_EVENT_WRITE:
++ case DM_EVENT_TRUNCATE:
++ evsize = sizeof(dm_data_event_t);
++ break;
++
++ case DM_EVENT_DESTROY:
++ evsize = sizeof(dm_destroy_event_t);
++ break;
++
++ case DM_EVENT_MOUNT:
++ evsize = sizeof(dm_mount_event_t);
++ break;
++
++ case DM_EVENT_PREUNMOUNT:
++ case DM_EVENT_UNMOUNT:
++ case DM_EVENT_NOSPACE:
++ case DM_EVENT_CREATE:
++ case DM_EVENT_REMOVE:
++ case DM_EVENT_RENAME:
++ case DM_EVENT_SYMLINK:
++ case DM_EVENT_LINK:
++ case DM_EVENT_POSTCREATE:
++ case DM_EVENT_POSTREMOVE:
++ case DM_EVENT_POSTRENAME:
++ case DM_EVENT_POSTSYMLINK:
++ case DM_EVENT_POSTLINK:
++ case DM_EVENT_ATTRIBUTE:
++ case DM_EVENT_DEBUT: /* currently not supported */
++ case DM_EVENT_CLOSE: /* currently not supported */
++ evsize = sizeof(dm_namesp_event_t);
++ break;
++
++ case DM_EVENT_CANCEL: /* currently not supported */
++ evsize = sizeof(dm_cancel_event_t);
++ break;
++
++ case DM_EVENT_USER:
++ evsize = 0;
++ break;
++
++ default:
++ panic("dm_create_tevp: called with unknown event type %d\n",
++ event);
++ }
++
++ /* Allocate and initialize an event structure of the correct size. */
++
++ tevp = dm_init_tevp(evsize, variable_size);
++ if (tevp == NULL)
++ return NULL;
++ tevp->te_evt_ref = 1;
++
++ /* Fields ev_token, ev_sequence, and _link are all filled in when the
++ event is queued onto a session. Initialize all other fields here.
++ */
++
++ tevp->te_msg.ev_type = event;
++ tevp->te_msg.ev_data.vd_offset = offsetof(dm_tokevent_t, te_event) -
++ offsetof(dm_tokevent_t, te_msg);
++ tevp->te_msg.ev_data.vd_length = evsize + variable_size;
++
++ /* Give the caller a pointer to the event-specific structure. */
++
++ *msgpp = ((char *)&tevp->te_msg + tevp->te_msg.ev_data.vd_offset);
++ return(tevp);
++}
++
++
++/* Given a pointer to an event (tevp) and a pointer to a handle_t, look for a
++ tdp structure within the event which contains the handle_t. Either verify
++ that the event contains the tdp, or optionally add the tdp to the
++ event. Called only from application threads.
++
++ On entry, tevp->te_lock is held; it is dropped prior to return.
++*/
++
++static int
++dm_app_lookup_tdp(
++ dm_handle_t *handlep, /* the handle we are looking for */
++ dm_tokevent_t *tevp, /* the event to search for the handle */
++ unsigned long *lcp, /* address of active lock cookie */
++ short types, /* acceptable object types */
++ dm_right_t right, /* minimum right the object must have */
++ u_int flags,
++ dm_tokdata_t **tdpp) /* if ! NULL, pointer to matching tdp */
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ struct inode *ip;
++ int error;
++
++ /* Bump the tevp application reference counter so that the event
++ can't disappear in case we have to drop the lock for a while.
++ */
++
++ tevp->te_app_ref++;
++ *tdpp = NULL; /* assume failure */
++
++ for (;;) {
++ /* Look for a matching tdp in the tevp. */
++
++ for (tdp = tevp->te_tdp; tdp; tdp = tdp->td_next) {
++ if (DM_HANDLE_CMP(&tdp->td_handle, handlep) == 0)
++ break;
++ }
++
++ /* If the tdp exists, but either we need single-thread access
++ to the handle and can't get it, or some other thread already
++ has single-thread access, then sleep until we can try again.
++ */
++
++ if (tdp != NULL && tdp->td_app_ref &&
++ ((flags & DM_FG_STHREAD) ||
++ (tdp->td_flags & DM_TDF_STHREAD))) {
++ tevp->te_app_slp++;
++ sv_wait(&tevp->te_app_queue, 1,
++ &tevp->te_lock, *lcp);
++ *lcp = mutex_spinlock(&tevp->te_lock);
++ tevp->te_app_slp--;
++ continue;
++ }
++
++ if (tdp != NULL &&
++ (tdp->td_vcount > 0 || tdp->td_flags & DM_TDF_EVTREF)) {
++ /* We have an existing tdp with a non-zero inode
++ reference count. If it's the wrong type, return
++ an appropriate errno.
++ */
++
++ if (!(tdp->td_type & types)) {
++ mutex_spinunlock(&tevp->te_lock, *lcp);
++ dm_put_tevp(tevp, NULL); /* no destroy events */
++ return(-EOPNOTSUPP);
++ }
++
++ /* If the current access right isn't high enough,
++ complain.
++ */
++
++ if (tdp->td_right < right) {
++ mutex_spinunlock(&tevp->te_lock, *lcp);
++ dm_put_tevp(tevp, NULL); /* no destroy events */
++ return(-EACCES);
++ }
++
++ /* The handle is acceptable. Increment the tdp
++ application and inode references and mark the tdp
++ as single-threaded if necessary.
++ */
++
++ tdp->td_app_ref++;
++ if (flags & DM_FG_STHREAD)
++ tdp->td_flags |= DM_TDF_STHREAD;
++ tdp->td_vcount++;
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ (void)fsys_vector->obj_ref_hold(tdp->td_ip);
++
++ mutex_spinunlock(&tevp->te_lock, *lcp);
++ *tdpp = tdp;
++ return(0);
++ }
++
++ /* If the tdp is not in the tevp or does not have an inode
++ reference, check to make sure it is okay to add/update it.
++ */
++
++ if (flags & DM_FG_MUSTEXIST) {
++ mutex_spinunlock(&tevp->te_lock, *lcp);
++ dm_put_tevp(tevp, NULL); /* no destroy events */
++ return(-EACCES); /* i.e. an insufficient right */
++ }
++ if (flags & DM_FG_DONTADD) {
++ tevp->te_app_ref--;
++ mutex_spinunlock(&tevp->te_lock, *lcp);
++ return(0);
++ }
++
++ /* If a tdp structure doesn't yet exist, create one and link
++ it into the tevp. Drop the lock while we are doing this as
++ zallocs can go to sleep. Once we have the memory, make
++ sure that another thread didn't simultaneously add the same
++ handle to the same event. If so, toss ours and start over.
++ */
++
++ if (tdp == NULL) {
++ dm_tokdata_t *tmp;
++
++ mutex_spinunlock(&tevp->te_lock, *lcp);
++
++ tdp = kmem_cache_alloc(dm_tokdata_cachep, GFP_KERNEL);
++ if (tdp == NULL){
++ printk("%s/%d: kmem_cache_alloc(dm_tokdata_cachep) returned NULL\n", __FUNCTION__, __LINE__);
++ return(-ENOMEM);
++ }
++ memset(tdp, 0, sizeof(*tdp));
++
++ *lcp = mutex_spinlock(&tevp->te_lock);
++
++ for (tmp = tevp->te_tdp; tmp; tmp = tmp->td_next) {
++ if (DM_HANDLE_CMP(&tmp->td_handle, handlep) == 0)
++ break;
++ }
++ if (tmp) {
++ kmem_cache_free(dm_tokdata_cachep, tdp);
++ continue;
++ }
++
++ tdp->td_next = tevp->te_tdp;
++ tevp->te_tdp = tdp;
++ tdp->td_tevp = tevp;
++ tdp->td_handle = *handlep;
++ }
++
++ /* Temporarily single-thread access to the tdp so that other
++ threads don't touch it while we are filling the rest of the
++ fields in.
++ */
++
++ tdp->td_app_ref = 1;
++ tdp->td_flags |= DM_TDF_STHREAD;
++
++ /* Drop the spinlock while we access, validate, and obtain the
++ proper rights to the object. This can take a very long time
++ if the inode is not in memory, if the filesystem is
++ unmounting, or if the request_right() call should block
++ because some other tdp or kernel thread is holding a right.
++ */
++
++ mutex_spinunlock(&tevp->te_lock, *lcp);
++
++ if ((ip = dm_handle_to_ip(handlep, &tdp->td_type)) == NULL) {
++ error = -EBADF;
++ } else {
++ tdp->td_vcount = 1;
++ tdp->td_ip = ip;
++
++ /* The handle is usable. Check that the type of the
++ object matches one of the types that the caller
++ will accept.
++ */
++
++ if (!(types & tdp->td_type)) {
++ error = -EOPNOTSUPP;
++ } else if (right > DM_RIGHT_NULL) {
++ /* Attempt to get the rights required by the
++ caller. If rights can't be obtained, return
++ an error.
++ */
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->request_right(tdp->td_ip,
++ DM_RIGHT_NULL,
++ (tdp->td_type == DM_TDT_VFS ?
++ DM_FSYS_OBJ : 0),
++ DM_RR_WAIT, right);
++ if (!error) {
++ tdp->td_right = right;
++ }
++ } else {
++ error = 0;
++ }
++ }
++ if (error != 0) {
++ dm_put_tevp(tevp, tdp); /* destroy event risk, although tiny */
++ return(error);
++ }
++
++ *lcp = mutex_spinlock(&tevp->te_lock);
++
++ /* Wake up any threads which may have seen our tdp while we
++ were filling it in.
++ */
++
++ if (!(flags & DM_FG_STHREAD)) {
++ tdp->td_flags &= ~DM_TDF_STHREAD;
++ if (tevp->te_app_slp)
++ sv_broadcast(&tevp->te_app_queue);
++ }
++
++ mutex_spinunlock(&tevp->te_lock, *lcp);
++ *tdpp = tdp;
++ return(0);
++ }
++}
++
++
++/* dm_app_get_tdp_by_token() is called whenever the application request
++ contains a session ID and contains a token other than DM_NO_TOKEN.
++ Most of the callers provide a right that is either DM_RIGHT_SHARED or
++ DM_RIGHT_EXCL, but a few of the callers such as dm_obj_ref_hold() may
++ specify a right of DM_RIGHT_NULL.
++*/
++
++static int
++dm_app_get_tdp_by_token(
++ dm_sessid_t sid, /* an existing session ID */
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token, /* an existing token */
++ short types, /* acceptable object types */
++ dm_right_t right, /* minimum right the object must have */
++ u_int flags,
++ dm_tokdata_t **tdpp)
++{
++ dm_tokevent_t *tevp;
++ dm_handle_t handle;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ if (right < DM_RIGHT_NULL || right > DM_RIGHT_EXCL)
++ return(-EINVAL);
++
++ if ((error = dm_copyin_handle(hanp, hlen, &handle)) != 0)
++ return(error);
++
++ /* Find and lock the event which corresponds to the specified
++ session/token pair.
++ */
++
++ if ((error = dm_find_msg_and_lock(sid, token, &tevp, &lc)) != 0)
++ return(error);
++
++ return(dm_app_lookup_tdp(&handle, tevp, &lc, types,
++ right, flags, tdpp));
++}
++
++
++/* Function dm_app_get_tdp() must ONLY be called from routines associated with
++ application calls, e.g. dm_read_invis, dm_set_disp, etc. It must not be
++ called by a thread responsible for generating an event such as
++ dm_send_data_event()!
++
++ dm_app_get_tdp() is the interface used by all application calls other than
++ dm_get_events, dm_respond_event, dm_get_config, dm_get_config_events, and by
++ the dm_obj_ref_* and dm_*_right families of requests.
++
++ dm_app_get_tdp() converts a sid/hanp/hlen/token quad into a tdp pointer,
++ increments the number of active application threads in the event, and
++ increments the number of active application threads using the tdp. The
++ 'right' parameter must be either DM_RIGHT_SHARED or DM_RIGHT_EXCL. The
++ token may either be DM_NO_TOKEN, or can be a token received in a synchronous
++ event.
++*/
++
++int
++dm_app_get_tdp(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ short types,
++ dm_right_t right, /* minimum right */
++ dm_tokdata_t **tdpp)
++{
++ dm_session_t *s;
++ dm_handle_t handle;
++ dm_tokevent_t *tevp;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ ASSERT(right >= DM_RIGHT_SHARED);
++
++ /* If a token other than DM_NO_TOKEN is specified, find the event on
++ this session which owns the token and increment its reference count.
++ */
++
++ if (token != DM_NO_TOKEN) { /* look up existing tokevent struct */
++ return(dm_app_get_tdp_by_token(sid, hanp, hlen, token, types,
++ right, DM_FG_MUSTEXIST, tdpp));
++ }
++
++ /* The token is DM_NO_TOKEN. In this case we only want to verify that
++ the session ID is valid, and do not need to continue holding the
++ session lock after we know that to be true.
++ */
++
++ if ((error = dm_copyin_handle(hanp, hlen, &handle)) != 0)
++ return(error);
++
++ if ((error = dm_find_session_and_lock(sid, &s, &lc)) != 0)
++ return(error);
++ mutex_spinunlock(&s->sn_qlock, lc);
++
++ /* When DM_NO_TOKEN is used, we simply block until we can obtain the
++ right that we want (since the tevp contains no tdp structures).
++ The blocking when we eventually support it will occur within
++ fsys_vector->request_right().
++ */
++
++ tevp = dm_init_tevp(0, 0);
++ lc = mutex_spinlock(&tevp->te_lock);
++
++ return(dm_app_lookup_tdp(&handle, tevp, &lc, types, right, 0, tdpp));
++}
++
++
++/* dm_get_config_tdp() is only called by dm_get_config() and
++ dm_get_config_events(), which neither have a session ID nor a token.
++ Both of these calls are supposed to work even if the filesystem is in the
++ process of being mounted, as long as the caller only uses handles within
++ the mount event.
++*/
++
++int
++dm_get_config_tdp(
++ void __user *hanp,
++ size_t hlen,
++ dm_tokdata_t **tdpp)
++{
++ dm_handle_t handle;
++ dm_tokevent_t *tevp;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ if ((error = dm_copyin_handle(hanp, hlen, &handle)) != 0)
++ return(error);
++
++ tevp = dm_init_tevp(0, 0);
++ lc = mutex_spinlock(&tevp->te_lock);
++
++ /* Try to use the handle provided by the caller and assume DM_NO_TOKEN.
++ This will fail if the filesystem is in the process of being mounted.
++ */
++
++ error = dm_app_lookup_tdp(&handle, tevp, &lc, DM_TDT_ANY,
++ DM_RIGHT_NULL, 0, tdpp);
++
++ if (!error) {
++ return(0);
++ }
++
++ /* Perhaps the filesystem is still mounting, in which case we need to
++ see if this is one of the handles in the DM_EVENT_MOUNT tevp.
++ */
++
++ if ((tevp = dm_find_mount_tevp_and_lock(&handle.ha_fsid, &lc)) == NULL)
++ return(-EBADF);
++
++ return(dm_app_lookup_tdp(&handle, tevp, &lc, DM_TDT_ANY,
++ DM_RIGHT_NULL, DM_FG_MUSTEXIST, tdpp));
++}
++
++
++/* dm_put_tdp() is called to release any right held on the inode, and to
++ VN_RELE() all references held on the inode. It is the caller's
++ responsibility to ensure that no other application threads are using the
++ tdp, and if necessary to unlink the tdp from the tevp before calling
++ this routine and to free the tdp afterwards.
++*/
++
++static void
++dm_put_tdp(
++ dm_tokdata_t *tdp)
++{
++ ASSERT(tdp->td_app_ref <= 1);
++
++ /* If the application thread is holding a right, or if the event
++ thread had a right but it has disappeared because of a dm_pending
++ or Cntl-C, then we need to release it here.
++ */
++
++ if (tdp->td_right != DM_RIGHT_NULL) {
++ dm_fsys_vector_t *fsys_vector;
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ (void)fsys_vector->release_right(tdp->td_ip, tdp->td_right,
++ (tdp->td_type == DM_TDT_VFS ? DM_FSYS_OBJ : 0));
++ tdp->td_right = DM_RIGHT_NULL;
++ }
++
++ /* Given that we wouldn't be here if there was still an event thread,
++ this VN_RELE loop has the potential of generating a DM_EVENT_DESTROY
++ event if some other thread has unlinked the file.
++ */
++
++ while (tdp->td_vcount > 0) {
++ iput(tdp->td_ip);
++ tdp->td_vcount--;
++ }
++
++ tdp->td_flags &= ~(DM_TDF_HOLD|DM_TDF_RIGHT);
++ tdp->td_ip = NULL;
++}
++
++
++/* Function dm_put_tevp() must ONLY be called from routines associated with
++ application threads, e.g. dm_read_invis, dm_get_events, etc. It must not be
++ called by a thread responsible for generating an event, such as
++ dm_send_data_event.
++
++ PLEASE NOTE: It is possible for this routine to generate DM_EVENT_DESTROY
++ events, because its calls to dm_put_tdp drop inode references, and another
++ thread may have already unlinked a file whose inode we are de-referencing.
++ This sets the stage for various types of deadlock if the thread calling
++ dm_put_tevp is the same thread that calls dm_respond_event! In particular,
++ the dm_sent_destroy_event routine needs to obtain the dm_reg_lock,
++ dm_session_lock, and sn_qlock in order to queue the destroy event. No
++ caller of dm_put_tevp can hold any of these locks!
++
++ Other possible deadlocks are that dm_send_destroy_event could block waiting
++ for a thread to register for the event using dm_set_disp() and/or
++ dm_set_return_on_destroy, or it could block because the session's sn_newq
++ is at the dm_max_queued_msgs event limit. The only safe solution
++ (unimplemented) is to have a separate kernel thread for each filesystem
++ whose only job is to do the inode-dereferencing. That way dm_respond_event
++ will not block, so the application can keep calling dm_get_events to read
++ events even if the filesystem thread should block. (If the filesystem
++ thread blocks, so will all subsequent destroy events for the same
++ filesystem.)
++*/
++
++void
++dm_put_tevp(
++ dm_tokevent_t *tevp,
++ dm_tokdata_t *tdp)
++{
++ int free_tdp = 0;
++ unsigned long lc; /* lock cookie */
++
++ lc = mutex_spinlock(&tevp->te_lock);
++
++ if (tdp != NULL) {
++ if (tdp->td_vcount > 1 || (tdp->td_flags & DM_TDF_EVTREF)) {
++ ASSERT(tdp->td_app_ref > 0);
++
++ iput(tdp->td_ip);
++ tdp->td_vcount--;
++ } else {
++ ASSERT(tdp->td_app_ref == 1);
++
++ /* The inode reference count is either already at
++ zero (e.g. a failed dm_handle_to_ip() call in
++ dm_app_lookup_tdp()) or is going to zero. We can't
++ hold the lock while we decrement the count because
++ we could potentially end up being busy for a long
++ time in VOP_INACTIVATE. Use single-threading to
++ lock others out while we clean house.
++ */
++
++ tdp->td_flags |= DM_TDF_STHREAD;
++
++ /* WARNING - A destroy event is possible here if we are
++ giving up the last reference on an inode which has
++ been previously unlinked by some other thread!
++ */
++
++ mutex_spinunlock(&tevp->te_lock, lc);
++ dm_put_tdp(tdp);
++ lc = mutex_spinlock(&tevp->te_lock);
++
++ /* If this tdp is not one of the original tdps in the
++ event, then remove it from the tevp.
++ */
++
++ if (!(tdp->td_flags & DM_TDF_ORIG)) {
++ dm_tokdata_t **tdpp = &tevp->te_tdp;
++
++ while (*tdpp && *tdpp != tdp) {
++ tdpp = &(*tdpp)->td_next;
++ }
++ if (*tdpp == NULL) {
++ panic("dm_remove_tdp_from_tevp: tdp "
++ "%p not in tevp %p\n", tdp,
++ tevp);
++ }
++ *tdpp = tdp->td_next;
++ free_tdp++;
++ }
++ }
++
++ /* If this is the last app thread actively using the tdp, clear
++ any single-threading and wake up any other app threads who
++ might be waiting to use this tdp, single-threaded or
++ otherwise.
++ */
++
++ if (--tdp->td_app_ref == 0) {
++ if (tdp->td_flags & DM_TDF_STHREAD) {
++ tdp->td_flags &= ~DM_TDF_STHREAD;
++ if (tevp->te_app_slp)
++ sv_broadcast(&tevp->te_app_queue);
++ }
++ }
++
++ if (free_tdp) {
++ kmem_cache_free(dm_tokdata_cachep, tdp);
++ }
++ }
++
++ /* If other application threads are using this token/event, they will
++ do the cleanup.
++ */
++
++ if (--tevp->te_app_ref > 0) {
++ mutex_spinunlock(&tevp->te_lock, lc);
++ return;
++ }
++
++ /* If event generation threads are waiting for this thread to go away,
++ wake them up and let them do the cleanup.
++ */
++
++ if (tevp->te_evt_ref > 0) {
++ sv_broadcast(&tevp->te_evt_queue);
++ mutex_spinunlock(&tevp->te_lock, lc);
++ return;
++ }
++
++ /* This thread is the last active thread using the token/event. No
++ lock can be held while we disassemble the tevp because we could
++ potentially end up being busy for a long time in VOP_INACTIVATE.
++ */
++
++ mutex_spinunlock(&tevp->te_lock, lc);
++
++ /* WARNING - One or more destroy events are possible here if we are
++ giving up references on inodes which have been previously unlinked
++ by other kernel threads!
++ */
++
++ while ((tdp = tevp->te_tdp) != NULL) {
++ tevp->te_tdp = tdp->td_next;
++ dm_put_tdp(tdp);
++ kmem_cache_free(dm_tokdata_cachep, tdp);
++ }
++ spinlock_destroy(&tevp->te_lock);
++ sv_destroy(&tevp->te_evt_queue);
++ sv_destroy(&tevp->te_app_queue);
++ kfree(tevp);
++}
++
++
++/* No caller of dm_app_put_tevp can hold either of the locks dm_reg_lock,
++ dm_session_lock, or any sn_qlock! (See dm_put_tevp for details.)
++*/
++
++void
++dm_app_put_tdp(
++ dm_tokdata_t *tdp)
++{
++ dm_put_tevp(tdp->td_tevp, tdp);
++}
++
++
++/* dm_change_right is only called if the event thread is the one doing the
++ cleanup on a completed event. It looks at the current rights of a tdp
++ and compares that with the rights it had on the tdp when the event was
++ created. If different, it reaquires the original rights, then transfers
++ the rights back to being thread-based.
++*/
++
++static void
++dm_change_right(
++ dm_tokdata_t *tdp)
++{
++#ifdef HAVE_DMAPI_RIGHTS
++ dm_fsys_vector_t *fsys_vector;
++ int error;
++ u_int type;
++#endif
++
++ /* If the event doesn't have an inode reference, if the original right
++ was DM_RIGHT_NULL, or if the rights were never switched from being
++ thread-based to tdp-based, then there is nothing to do.
++ */
++
++ if (!(tdp->td_flags & DM_TDF_EVTREF))
++ return;
++
++ if (tdp->td_orig_right == DM_RIGHT_NULL)
++ return;
++
++ /* DEBUG - Need a check here for event-based rights. */
++
++#ifdef HAVE_DMAPI_RIGHTS
++ /* The "rights" vectors are stubs now anyway. When they are
++ * implemented then bhv locking will have to be sorted out.
++ */
++
++ /* If the current right is not the same as it was when the event was
++ created, first get back the original right.
++ */
++
++ if (tdp->td_right != tdp->td_orig_right) {
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ type = (tdp->td_type == DM_TDT_VFS ? DM_FSYS_OBJ : 0);
++
++ switch (tdp->td_orig_right) {
++ case DM_RIGHT_SHARED:
++ if (tdp->td_right == DM_RIGHT_EXCL) {
++ error = fsys_vector->downgrade_right(
++ tdp->td_ip, tdp->td_right, type);
++ if (!error)
++ break;
++ (void)fsys_vector->release_right(tdp->td_ip,
++ tdp->td_right, type);
++ }
++ (void)fsys_vector->request_right(tdp->td_ip,
++ tdp->td_right, type, DM_RR_WAIT,
++ tdp->td_orig_right);
++ break;
++
++ case DM_RIGHT_EXCL:
++ if (tdp->td_right == DM_RIGHT_SHARED) {
++ error = fsys_vector->upgrade_right(tdp->td_ip,
++ tdp->td_right, type);
++ if (!error)
++ break;
++ (void)fsys_vector->release_right(tdp->td_ip,
++ tdp->td_right, type);
++ }
++ (void)fsys_vector->request_right(tdp->td_ip,
++ tdp->td_right, type, DM_RR_WAIT,
++ tdp->td_orig_right);
++ break;
++ case DM_RIGHT_NULL:
++ break;
++ }
++ }
++#endif
++
++ /* We now have back the same level of rights as we had when the event
++ was generated. Now transfer the rights from being tdp-based back
++ to thread-based.
++ */
++
++ /* DEBUG - Add a call here to transfer rights back to thread-based. */
++
++ /* Finally, update the tdp so that we don't mess with the rights when
++ we eventually call dm_put_tdp.
++ */
++
++ tdp->td_right = DM_RIGHT_NULL;
++}
++
++
++/* This routine is only called by event threads. The calls to dm_put_tdp
++ are not a deadlock risk here because this is an event thread, and it is
++ okay for such a thread to block on an induced destroy event. Okay, maybe
++ there is a slight risk; say that the event contains three inodes all of
++ which have DM_RIGHT_EXCL, and say that we are at the dm_max_queued_msgs
++ limit, and that the first inode is already unlinked. In that case the
++ destroy event will block waiting to be queued, and the application thread
++ could happen to reference one of the other locked inodes. Deadlock.
++*/
++
++void
++dm_evt_rele_tevp(
++ dm_tokevent_t *tevp,
++ int droprights) /* non-zero, evt thread loses rights */
++{
++ dm_tokdata_t *tdp;
++ unsigned long lc; /* lock cookie */
++
++ lc = mutex_spinlock(&tevp->te_lock);
++
++ /* If we are here without DM_TEF_FINAL set and with at least one
++ application reference still remaining, then one of several
++ possibilities is true:
++ 1. This is an asynchronous event which has been queued but has not
++ yet been delivered, or which is in the process of being delivered.
++ 2. This is an unmount event (pseudo-asynchronous) yet to be
++ delivered or in the process of being delivered.
++ 3. This event had DM_FLAGS_NDELAY specified, and the application
++ has sent a dm_pending() reply for the event.
++ 4. This is a DM_EVENT_READ, DM_EVENT_WRITE, or DM_EVENT_TRUNCATE
++ event and the user typed a Cntl-C.
++ In all of these cases, the correct behavior is to leave the
++ responsibility of releasing any rights to the application threads
++ when they are done.
++ */
++
++ if (tevp->te_app_ref > 0 && !(tevp->te_flags & DM_TEF_FINAL)) {
++ tevp->te_evt_ref--;
++ for (tdp = tevp->te_tdp; tdp; tdp = tdp->td_next) {
++ if (tdp->td_flags & DM_TDF_EVTREF) {
++ tdp->td_flags &= ~DM_TDF_EVTREF;
++ if (tdp->td_vcount == 0) {
++ tdp->td_ip = NULL;
++ }
++ }
++ }
++ mutex_spinunlock(&tevp->te_lock, lc);
++ return; /* not the last thread */
++ }
++
++ /* If the application reference count is non-zero here, that can only
++ mean that dm_respond_event() has been called, but the application
++ still has one or more threads in the kernel that haven't let go of
++ the tevp. In these cases, the event thread must wait until all
++ application threads have given up their references, and their
++ rights to handles within the event.
++ */
++
++ while (tevp->te_app_ref) {
++ sv_wait(&tevp->te_evt_queue, 1, &tevp->te_lock, lc);
++ lc = mutex_spinlock(&tevp->te_lock);
++ }
++
++ /* This thread is the last active thread using the token/event. Reset
++ the rights of any inode that was part of the original event back
++ to their initial values before returning to the filesystem. The
++ exception is if the event failed (droprights is non-zero), in which
++ case we chose to return to the filesystem with all rights released.
++ Release the rights on any inode that was not part of the original
++ event. Give up all remaining application inode references
++ regardless of whether or not the inode was part of the original
++ event.
++ */
++
++ mutex_spinunlock(&tevp->te_lock, lc);
++
++ while ((tdp = tevp->te_tdp) != NULL) {
++ tevp->te_tdp = tdp->td_next;
++ if ((tdp->td_flags & DM_TDF_ORIG) &&
++ (tdp->td_flags & DM_TDF_EVTREF) &&
++ (!droprights)) {
++ dm_change_right(tdp);
++ }
++ dm_put_tdp(tdp);
++ kmem_cache_free(dm_tokdata_cachep, tdp);
++ }
++ spinlock_destroy(&tevp->te_lock);
++ sv_destroy(&tevp->te_evt_queue);
++ sv_destroy(&tevp->te_app_queue);
++ kfree(tevp);
++}
++
++
++/* dm_obj_ref_hold() is just a fancy way to get an inode reference on an object
++ to hold it in kernel memory.
++*/
++
++int
++dm_obj_ref_hold(
++ dm_sessid_t sid,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp_by_token(sid, hanp, hlen, token, DM_TDT_VNO,
++ DM_RIGHT_NULL, DM_FG_STHREAD, &tdp);
++
++ /* The tdp is single-threaded, so no mutex lock needed for update. */
++
++ if (error == 0) {
++ if (tdp->td_flags & DM_TDF_HOLD) { /* if already held */
++ error = -EBUSY;
++ } else {
++ tdp->td_flags |= DM_TDF_HOLD;
++ tdp->td_vcount++;
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ (void)fsys_vector->obj_ref_hold(tdp->td_ip);
++ }
++ dm_app_put_tdp(tdp);
++ }
++ return(error);
++}
++
++
++int
++dm_obj_ref_rele(
++ dm_sessid_t sid,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen)
++{
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp_by_token(sid, hanp, hlen, token, DM_TDT_VNO,
++ DM_RIGHT_NULL, DM_FG_MUSTEXIST|DM_FG_STHREAD, &tdp);
++
++ /* The tdp is single-threaded, so no mutex lock needed for update. */
++
++ if (error == 0) {
++ if (!(tdp->td_flags & DM_TDF_HOLD)) { /* if not held */
++ error = -EACCES; /* use the DM_FG_MUSTEXIST errno */
++ } else {
++ tdp->td_flags &= ~DM_TDF_HOLD;
++ iput(tdp->td_ip);
++ tdp->td_vcount--;
++ }
++ dm_app_put_tdp(tdp);
++ }
++ return(error);
++}
++
++
++int
++dm_obj_ref_query_rvp(
++ dm_sessid_t sid,
++ dm_token_t token,
++ void __user *hanp,
++ size_t hlen,
++ int *rvp)
++{
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp_by_token(sid, hanp, hlen, token, DM_TDT_VNO,
++ DM_RIGHT_NULL, DM_FG_DONTADD|DM_FG_STHREAD, &tdp);
++ if (error != 0)
++ return(error);
++
++ /* If the request is valid but the handle just isn't present in the
++ event or the hold flag isn't set, return zero, else return one.
++ */
++
++ if (tdp) {
++ if (tdp->td_flags & DM_TDF_HOLD) { /* if held */
++ *rvp = 1;
++ } else {
++ *rvp = 0;
++ }
++ dm_app_put_tdp(tdp);
++ } else {
++ *rvp = 0;
++ }
++ return(0);
++}
++
++
++int
++dm_downgrade_right(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp_by_token(sid, hanp, hlen, token, DM_TDT_ANY,
++ DM_RIGHT_EXCL, DM_FG_MUSTEXIST|DM_FG_STHREAD, &tdp);
++ if (error != 0)
++ return(error);
++
++ /* Attempt the downgrade. Filesystems which support rights but not
++ the downgrading of rights will return ENOSYS.
++ */
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->downgrade_right(tdp->td_ip, tdp->td_right,
++ (tdp->td_type == DM_TDT_VFS ? DM_FSYS_OBJ : 0));
++
++ /* The tdp is single-threaded, so no mutex lock needed for update. */
++
++ if (error == 0)
++ tdp->td_right = DM_RIGHT_SHARED;
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_query_right(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ dm_right_t __user *rightp)
++{
++ dm_tokdata_t *tdp;
++ dm_right_t right;
++ int error;
++
++ error = dm_app_get_tdp_by_token(sid, hanp, hlen, token, DM_TDT_ANY,
++ DM_RIGHT_NULL, DM_FG_DONTADD|DM_FG_STHREAD, &tdp);
++ if (error != 0)
++ return(error);
++
++ /* Get the current right and copy it to the caller. The tdp is
++ single-threaded, so no mutex lock is needed. If the tdp is not in
++ the event we are supposed to return DM_RIGHT_NULL in order to be
++ compatible with Veritas.
++ */
++
++ if (tdp) {
++ right = tdp->td_right;
++ dm_app_put_tdp(tdp);
++ } else {
++ right = DM_RIGHT_NULL;
++ }
++ if (copy_to_user(rightp, &right, sizeof(right)))
++ return(-EFAULT);
++ return(0);
++}
++
++
++int
++dm_release_right(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp_by_token(sid, hanp, hlen, token, DM_TDT_ANY,
++ DM_RIGHT_SHARED, DM_FG_MUSTEXIST|DM_FG_STHREAD, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->release_right(tdp->td_ip, tdp->td_right,
++ (tdp->td_type == DM_TDT_VFS ? DM_FSYS_OBJ : 0));
++
++ /* The tdp is single-threaded, so no mutex lock needed for update. */
++
++ if (error == 0) {
++ tdp->td_right = DM_RIGHT_NULL;
++ if (tdp->td_flags & DM_TDF_RIGHT) {
++ tdp->td_flags &= ~DM_TDF_RIGHT;
++ iput(tdp->td_ip);
++ tdp->td_vcount--;
++ }
++ }
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_request_right(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token,
++ u_int flags,
++ dm_right_t right)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp_by_token(sid, hanp, hlen, token, DM_TDT_ANY,
++ DM_RIGHT_NULL, DM_FG_STHREAD, &tdp);
++ if (error != 0)
++ return(error);
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->request_right(tdp->td_ip, tdp->td_right,
++ (tdp->td_type == DM_TDT_VFS ? DM_FSYS_OBJ : 0), flags, right);
++
++ /* The tdp is single-threaded, so no mutex lock is needed for update.
++
++ If this is the first dm_request_right call for this inode, then we
++ need to bump the inode reference count for two reasons. First of
++ all, it is supposed to be impossible for the file to disappear or
++ for the filesystem to be unmounted while a right is held on a file;
++ bumping the file's inode reference count ensures this. Second, if
++ rights are ever actually implemented, it will most likely be done
++ without changes to the on-disk inode, which means that we can't let
++ the inode become unreferenced while a right on it is held.
++ */
++
++ if (error == 0) {
++ if (!(tdp->td_flags & DM_TDF_RIGHT)) { /* if first call */
++ tdp->td_flags |= DM_TDF_RIGHT;
++ tdp->td_vcount++;
++ (void)fsys_vector->obj_ref_hold(tdp->td_ip);
++ }
++ tdp->td_right = right;
++ }
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
++
++
++int
++dm_upgrade_right(
++ dm_sessid_t sid,
++ void __user *hanp,
++ size_t hlen,
++ dm_token_t token)
++{
++ dm_fsys_vector_t *fsys_vector;
++ dm_tokdata_t *tdp;
++ int error;
++
++ error = dm_app_get_tdp_by_token(sid, hanp, hlen, token, DM_TDT_ANY,
++ DM_RIGHT_SHARED, DM_FG_MUSTEXIST|DM_FG_STHREAD, &tdp);
++ if (error != 0)
++ return(error);
++
++ /* If the object already has the DM_RIGHT_EXCL right, no need to
++ attempt an upgrade.
++ */
++
++ if (tdp->td_right == DM_RIGHT_EXCL) {
++ dm_app_put_tdp(tdp);
++ return(0);
++ }
++
++ /* Attempt the upgrade. Filesystems which support rights but not
++ the upgrading of rights will return ENOSYS.
++ */
++
++ fsys_vector = dm_fsys_vector(tdp->td_ip);
++ error = fsys_vector->upgrade_right(tdp->td_ip, tdp->td_right,
++ (tdp->td_type == DM_TDT_VFS ? DM_FSYS_OBJ : 0));
++
++ /* The tdp is single-threaded, so no mutex lock needed for update. */
++
++ if (error == 0)
++ tdp->td_right = DM_RIGHT_EXCL;
++
++ dm_app_put_tdp(tdp);
++ return(error);
++}
+Index: linux-2.6.26/fs/dmapi/dmapi_session.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_session.c
+@@ -0,0 +1,1825 @@
++/*
++ * Copyright (c) 2000-2005 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++
++#include <linux/init.h>
++#include <linux/proc_fs.h>
++#include <asm/uaccess.h>
++#ifdef CONFIG_PROC_FS
++#include <linux/module.h>
++#endif
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++dm_session_t *dm_sessions = NULL; /* head of session list */
++u_int dm_sessions_active = 0; /* # sessions currently active */
++dm_sessid_t dm_next_sessid = 1; /* next session ID to use */
++lock_t dm_session_lock = SPIN_LOCK_UNLOCKED;/* lock for session list */
++
++dm_token_t dm_next_token = 1; /* next token ID to use */
++dm_sequence_t dm_next_sequence = 1; /* next sequence number to use */
++lock_t dm_token_lock = SPIN_LOCK_UNLOCKED;/* dm_next_token/dm_next_sequence lock */
++
++int dm_max_queued_msgs = 2048; /* max # undelivered msgs/session */
++
++int dm_hash_buckets = 1009; /* prime -- number of buckets */
++
++#define DM_SHASH(sess,inodenum) \
++ ((sess)->sn_sesshash + do_mod((inodenum), dm_hash_buckets))
++
++
++#ifdef CONFIG_PROC_FS
++static int
++sessions_read_pfs(char *buffer, char **start, off_t offset,
++ int count, int *eof, void *data)
++{
++ int len;
++ dm_session_t *sessp = (dm_session_t*)data;
++
++#define CHKFULL if(len >= count) break;
++#define ADDBUF(a,b) len += sprintf(buffer + len, a, b); CHKFULL;
++
++ len=0;
++ while(1){
++ ADDBUF("sessp=0x%p\n", sessp);
++ ADDBUF("sn_next=0x%p\n", sessp->sn_next);
++ ADDBUF("sn_sessid=%d\n", sessp->sn_sessid);
++ ADDBUF("sn_flags=%x\n", sessp->sn_flags);
++ ADDBUF("sn_qlock=%c\n", '?');
++ ADDBUF("sn_readerq=%c\n", '?');
++ ADDBUF("sn_writerq=%c\n", '?');
++ ADDBUF("sn_readercnt=%u\n", sessp->sn_readercnt);
++ ADDBUF("sn_writercnt=%u\n", sessp->sn_writercnt);
++
++ ADDBUF("sn_newq.eq_head=0x%p\n", sessp->sn_newq.eq_head);
++ ADDBUF("sn_newq.eq_tail=0x%p\n", sessp->sn_newq.eq_tail);
++ ADDBUF("sn_newq.eq_count=%d\n", sessp->sn_newq.eq_count);
++
++ ADDBUF("sn_delq.eq_head=0x%p\n", sessp->sn_delq.eq_head);
++ ADDBUF("sn_delq.eq_tail=0x%p\n", sessp->sn_delq.eq_tail);
++ ADDBUF("sn_delq.eq_count=%d\n", sessp->sn_delq.eq_count);
++
++ ADDBUF("sn_evt_writerq.eq_head=0x%p\n", sessp->sn_evt_writerq.eq_head);
++ ADDBUF("sn_evt_writerq.eq_tail=0x%p\n", sessp->sn_evt_writerq.eq_tail);
++ ADDBUF("sn_evt_writerq.eq_count=%d\n", sessp->sn_evt_writerq.eq_count);
++
++ ADDBUF("sn_info=\"%s\"\n", sessp->sn_info);
++
++ break;
++ }
++
++ if (offset >= len) {
++ *start = buffer;
++ *eof = 1;
++ return 0;
++ }
++ *start = buffer + offset;
++ if ((len -= offset) > count)
++ return count;
++ *eof = 1;
++
++ return len;
++}
++#endif
++
++
++/* Link a session to the end of the session list. New sessions are always
++ added at the end of the list so that dm_enqueue_mount_event() doesn't
++ miss a session. The caller must have obtained dm_session_lock before
++ calling this routine.
++*/
++
++static void
++link_session(
++ dm_session_t *s)
++{
++ dm_session_t *tmp;
++
++ if ((tmp = dm_sessions) == NULL) {
++ dm_sessions = s;
++ } else {
++ while (tmp->sn_next != NULL)
++ tmp = tmp->sn_next;
++ tmp->sn_next = s;
++ }
++ s->sn_next = NULL;
++ dm_sessions_active++;
++}
++
++
++/* Remove a session from the session list. The caller must have obtained
++ dm_session_lock before calling this routine. unlink_session() should only
++ be used in situations where the session is known to be on the dm_sessions
++ list; otherwise it panics.
++*/
++
++static void
++unlink_session(
++ dm_session_t *s)
++{
++ dm_session_t *tmp;
++
++ if (dm_sessions == s) {
++ dm_sessions = dm_sessions->sn_next;
++ } else {
++ for (tmp = dm_sessions; tmp; tmp = tmp->sn_next) {
++ if (tmp->sn_next == s)
++ break;
++ }
++ if (tmp == NULL) {
++ panic("unlink_session: corrupt DMAPI session list, "
++ "dm_sessions %p, session %p\n",
++ dm_sessions, s);
++ }
++ tmp->sn_next = s->sn_next;
++ }
++ s->sn_next = NULL;
++ dm_sessions_active--;
++}
++
++
++/* Link an event to the end of an event queue. The caller must have obtained
++ the session's sn_qlock before calling this routine.
++*/
++
++void
++dm_link_event(
++ dm_tokevent_t *tevp,
++ dm_eventq_t *queue)
++{
++ if (queue->eq_tail) {
++ queue->eq_tail->te_next = tevp;
++ queue->eq_tail = tevp;
++ } else {
++ queue->eq_head = queue->eq_tail = tevp;
++ }
++ tevp->te_next = NULL;
++ queue->eq_count++;
++}
++
++
++/* Remove an event from an event queue. The caller must have obtained the
++ session's sn_qlock before calling this routine. dm_unlink_event() should
++ only be used in situations where the event is known to be on the queue;
++ otherwise it panics.
++*/
++
++void
++dm_unlink_event(
++ dm_tokevent_t *tevp,
++ dm_eventq_t *queue)
++{
++ dm_tokevent_t *tmp;
++
++ if (queue->eq_head == tevp) {
++ queue->eq_head = tevp->te_next;
++ if (queue->eq_head == NULL)
++ queue->eq_tail = NULL;
++ } else {
++ tmp = queue->eq_head;
++ while (tmp && tmp->te_next != tevp)
++ tmp = tmp->te_next;
++ if (tmp == NULL) {
++ panic("dm_unlink_event: corrupt DMAPI queue %p, "
++ "tevp %p\n", queue, tevp);
++ }
++ tmp->te_next = tevp->te_next;
++ if (tmp->te_next == NULL)
++ queue->eq_tail = tmp;
++ }
++ tevp->te_next = NULL;
++ queue->eq_count--;
++}
++
++/* Link a regular file event to a hash bucket. The caller must have obtained
++ the session's sn_qlock before calling this routine.
++ The tokevent must be for a regular file object--DM_TDT_REG.
++*/
++
++static void
++hash_event(
++ dm_session_t *s,
++ dm_tokevent_t *tevp)
++{
++ dm_sesshash_t *sh;
++ dm_ino_t ino;
++
++ if (s->sn_sesshash == NULL) {
++ s->sn_sesshash = kmalloc(dm_hash_buckets * sizeof(dm_sesshash_t), GFP_KERNEL);
++ if (s->sn_sesshash == NULL) {
++ printk("%s/%d: kmalloc returned NULL\n", __FUNCTION__, __LINE__);
++ return;
++ }
++ memset(s->sn_sesshash, 0, dm_hash_buckets * sizeof(dm_sesshash_t));
++ }
++
++ ino = (&tevp->te_tdp->td_handle.ha_fid)->dm_fid_ino;
++ sh = DM_SHASH(s, ino);
++
++#ifdef DM_SHASH_DEBUG
++ if (sh->h_next == NULL) {
++ s->sn_buckets_in_use++;
++ if (s->sn_buckets_in_use > s->sn_max_buckets_in_use)
++ s->sn_max_buckets_in_use++;
++ }
++ sh->maxlength++;
++ sh->curlength++;
++ sh->num_adds++;
++#endif
++
++ tevp->te_flags |= DM_TEF_HASHED;
++ tevp->te_hashnext = sh->h_next;
++ sh->h_next = tevp;
++}
++
++
++/* Remove a regular file event from a hash bucket. The caller must have
++ obtained the session's sn_qlock before calling this routine.
++ The tokevent must be for a regular file object--DM_TDT_REG.
++*/
++
++static void
++unhash_event(
++ dm_session_t *s,
++ dm_tokevent_t *tevp)
++{
++ dm_sesshash_t *sh;
++ dm_tokevent_t *tmp;
++ dm_ino_t ino;
++
++ if (s->sn_sesshash == NULL)
++ return;
++
++ ino = (&tevp->te_tdp->td_handle.ha_fid)->dm_fid_ino;
++ sh = DM_SHASH(s, ino);
++
++ if (sh->h_next == tevp) {
++ sh->h_next = tevp->te_hashnext; /* leap frog */
++ } else {
++ tmp = sh->h_next;
++ while (tmp->te_hashnext != tevp) {
++ tmp = tmp->te_hashnext;
++ }
++ tmp->te_hashnext = tevp->te_hashnext; /* leap frog */
++ }
++ tevp->te_hashnext = NULL;
++ tevp->te_flags &= ~DM_TEF_HASHED;
++
++#ifdef DM_SHASH_DEBUG
++ if (sh->h_next == NULL)
++ s->sn_buckets_in_use--;
++ sh->curlength--;
++ sh->num_dels++;
++#endif
++}
++
++
++/* Determine if this is a repeat event. The caller MUST be holding
++ the session lock.
++ The tokevent must be for a regular file object--DM_TDT_REG.
++ Returns:
++ 0 == match not found
++ 1 == match found
++*/
++
++static int
++repeated_event(
++ dm_session_t *s,
++ dm_tokevent_t *tevp)
++{
++ dm_sesshash_t *sh;
++ dm_data_event_t *d_event1;
++ dm_data_event_t *d_event2;
++ dm_tokevent_t *tevph;
++ dm_ino_t ino1;
++ dm_ino_t ino2;
++
++ if ((!s->sn_newq.eq_tail) && (!s->sn_delq.eq_tail)) {
++ return(0);
++ }
++ if (s->sn_sesshash == NULL) {
++ return(0);
++ }
++
++ ino1 = (&tevp->te_tdp->td_handle.ha_fid)->dm_fid_ino;
++ sh = DM_SHASH(s, ino1);
++
++ if (sh->h_next == NULL) {
++ /* bucket is empty, no match here */
++ return(0);
++ }
++
++ d_event1 = (dm_data_event_t *)((char *)&tevp->te_msg + tevp->te_msg.ev_data.vd_offset);
++ tevph = sh->h_next;
++ while (tevph) {
++ /* find something with the same event type and handle type */
++ if ((tevph->te_msg.ev_type == tevp->te_msg.ev_type) &&
++ (tevph->te_tdp->td_type == tevp->te_tdp->td_type)) {
++
++ ino2 = (&tevp->te_tdp->td_handle.ha_fid)->dm_fid_ino;
++ d_event2 = (dm_data_event_t *)((char *)&tevph->te_msg + tevph->te_msg.ev_data.vd_offset);
++
++ /* If the two events are operating on the same file,
++ and the same part of that file, then we have a
++ match.
++ */
++ if ((ino1 == ino2) &&
++ (d_event2->de_offset == d_event1->de_offset) &&
++ (d_event2->de_length == d_event1->de_length)) {
++ /* found a match */
++#ifdef DM_SHASH_DEBUG
++ sh->dup_hits++;
++#endif
++ return(1);
++ }
++ }
++ tevph = tevph->te_hashnext;
++ }
++
++ /* No match found */
++ return(0);
++}
++
++
++/* Return a pointer to a session given its session ID, or EINVAL if no session
++ has the session ID (per the DMAPI spec). The caller must have obtained
++ dm_session_lock before calling this routine.
++*/
++
++static int
++dm_find_session(
++ dm_sessid_t sid,
++ dm_session_t **sessionpp)
++{
++ dm_session_t *s;
++
++ for (s = dm_sessions; s; s = s->sn_next) {
++ if (s->sn_sessid == sid) {
++ *sessionpp = s;
++ return(0);
++ }
++ }
++ return(-EINVAL);
++}
++
++
++/* Return a pointer to a locked session given its session ID. '*lcp' is
++ used to obtain the session's sn_qlock. Caller is responsible for eventually
++ unlocking it.
++*/
++
++int
++dm_find_session_and_lock(
++ dm_sessid_t sid,
++ dm_session_t **sessionpp,
++ unsigned long *lcp) /* addr of returned lock cookie */
++{
++ int error;
++
++ for (;;) {
++ *lcp = mutex_spinlock(&dm_session_lock);
++
++ if ((error = dm_find_session(sid, sessionpp)) != 0) {
++ mutex_spinunlock(&dm_session_lock, *lcp);
++ return(error);
++ }
++ if (spin_trylock(&(*sessionpp)->sn_qlock)) {
++ nested_spinunlock(&dm_session_lock);
++ return(0); /* success */
++ }
++
++ /* If the second lock is not available, drop the first and
++ start over. This gives the CPU a chance to process any
++ interrupts, and also allows processes which want a sn_qlock
++ for a different session to proceed.
++ */
++
++ mutex_spinunlock(&dm_session_lock, *lcp);
++ }
++}
++
++
++/* Return a pointer to the event on the specified session's sn_delq which
++ contains the given token. The caller must have obtained the session's
++ sn_qlock before calling this routine.
++*/
++
++static int
++dm_find_msg(
++ dm_session_t *s,
++ dm_token_t token,
++ dm_tokevent_t **tevpp)
++{
++ dm_tokevent_t *tevp;
++
++ if (token <= DM_INVALID_TOKEN)
++ return(-EINVAL);
++
++ for (tevp = s->sn_delq.eq_head; tevp; tevp = tevp->te_next) {
++ if (tevp->te_msg.ev_token == token) {
++ *tevpp = tevp;
++ return(0);
++ }
++ }
++ return(-ESRCH);
++}
++
++
++/* Given a session ID and token, find the tevp on the specified session's
++ sn_delq which corresponds to that session ID/token pair. If a match is
++ found, lock the tevp's te_lock and return a pointer to the tevp.
++ '*lcp' is used to obtain the tevp's te_lock. The caller is responsible
++ for eventually unlocking it.
++*/
++
++int
++dm_find_msg_and_lock(
++ dm_sessid_t sid,
++ dm_token_t token,
++ dm_tokevent_t **tevpp,
++ unsigned long *lcp) /* address of returned lock cookie */
++{
++ dm_session_t *s;
++ int error;
++
++ if ((error = dm_find_session_and_lock(sid, &s, lcp)) != 0)
++ return(error);
++
++ if ((error = dm_find_msg(s, token, tevpp)) != 0) {
++ mutex_spinunlock(&s->sn_qlock, *lcp);
++ return(error);
++ }
++ nested_spinlock(&(*tevpp)->te_lock);
++ nested_spinunlock(&s->sn_qlock);
++ return(0);
++}
++
++
++/* Create a new session, or resume an old session if one is given. */
++
++int
++dm_create_session(
++ dm_sessid_t old,
++ char __user *info,
++ dm_sessid_t __user *new)
++{
++ dm_session_t *s;
++ dm_sessid_t sid;
++ char sessinfo[DM_SESSION_INFO_LEN];
++ size_t len;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ len = strnlen_user(info, DM_SESSION_INFO_LEN-1);
++ if (copy_from_user(sessinfo, info, len))
++ return(-EFAULT);
++ lc = mutex_spinlock(&dm_session_lock);
++ sid = dm_next_sessid++;
++ mutex_spinunlock(&dm_session_lock, lc);
++ if (copy_to_user(new, &sid, sizeof(sid)))
++ return(-EFAULT);
++
++ if (old == DM_NO_SESSION) {
++ s = kmem_cache_alloc(dm_session_cachep, GFP_KERNEL);
++ if (s == NULL) {
++ printk("%s/%d: kmem_cache_alloc(dm_session_cachep) returned NULL\n", __FUNCTION__, __LINE__);
++ return -ENOMEM;
++ }
++ memset(s, 0, sizeof(*s));
++
++ sv_init(&s->sn_readerq, SV_DEFAULT, "dmreadq");
++ sv_init(&s->sn_writerq, SV_DEFAULT, "dmwritq");
++ spinlock_init(&s->sn_qlock, "sn_qlock");
++ } else {
++ lc = mutex_spinlock(&dm_session_lock);
++ if ((error = dm_find_session(old, &s)) != 0) {
++ mutex_spinunlock(&dm_session_lock, lc);
++ return(error);
++ }
++ unlink_session(s);
++ mutex_spinunlock(&dm_session_lock, lc);
++#ifdef CONFIG_PROC_FS
++ {
++ char buf[100];
++ sprintf(buf, DMAPI_DBG_PROCFS "/sessions/0x%p", s);
++ remove_proc_entry(buf, NULL);
++ }
++#endif
++ }
++ memcpy(s->sn_info, sessinfo, len);
++ s->sn_info[len-1] = 0; /* if not NULL, then now 'tis */
++ s->sn_sessid = sid;
++ lc = mutex_spinlock(&dm_session_lock);
++ link_session(s);
++ mutex_spinunlock(&dm_session_lock, lc);
++#ifdef CONFIG_PROC_FS
++ {
++ char buf[100];
++ struct proc_dir_entry *entry;
++
++ sprintf(buf, DMAPI_DBG_PROCFS "/sessions/0x%p", s);
++ entry = create_proc_read_entry(buf, 0, NULL, sessions_read_pfs, s);
++ entry->owner = THIS_MODULE;
++ }
++#endif
++ return(0);
++}
++
++
++int
++dm_destroy_session(
++ dm_sessid_t sid)
++{
++ dm_session_t *s;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ /* The dm_session_lock must be held until the session is unlinked. */
++
++ lc = mutex_spinlock(&dm_session_lock);
++
++ if ((error = dm_find_session(sid, &s)) != 0) {
++ mutex_spinunlock(&dm_session_lock, lc);
++ return(error);
++ }
++ nested_spinlock(&s->sn_qlock);
++
++ /* The session exists. Check to see if it is still in use. If any
++ messages still exist on the sn_newq or sn_delq, or if any processes
++ are waiting for messages to arrive on the session, then the session
++ must not be destroyed.
++ */
++
++ if (s->sn_newq.eq_head || s->sn_readercnt || s->sn_delq.eq_head) {
++ nested_spinunlock(&s->sn_qlock);
++ mutex_spinunlock(&dm_session_lock, lc);
++ return(-EBUSY);
++ }
++
++ /* The session is not in use. Dequeue it from the session chain. */
++
++ unlink_session(s);
++ nested_spinunlock(&s->sn_qlock);
++ mutex_spinunlock(&dm_session_lock, lc);
++
++#ifdef CONFIG_PROC_FS
++ {
++ char buf[100];
++ sprintf(buf, DMAPI_DBG_PROCFS "/sessions/0x%p", s);
++ remove_proc_entry(buf, NULL);
++ }
++#endif
++
++ /* Now clear the sessions's disposition registration, and then destroy
++ the session structure.
++ */
++
++ dm_clear_fsreg(s);
++
++ spinlock_destroy(&s->sn_qlock);
++ sv_destroy(&s->sn_readerq);
++ sv_destroy(&s->sn_writerq);
++ if (s->sn_sesshash)
++ kfree(s->sn_sesshash);
++ kmem_cache_free(dm_session_cachep, s);
++ return(0);
++}
++
++
++/*
++ * Return a list of all active sessions.
++ */
++
++int
++dm_getall_sessions(
++ u_int nelem,
++ dm_sessid_t __user *sidp,
++ u_int __user *nelemp)
++{
++ dm_session_t *s;
++ u_int sesscnt;
++ dm_sessid_t *sesslist;
++ unsigned long lc; /* lock cookie */
++ int error;
++ int i;
++
++ /* Loop until we can get the right amount of temp space, being careful
++ not to hold a mutex during the allocation. Usually only one trip.
++ */
++
++ for (;;) {
++ if ((sesscnt = dm_sessions_active) == 0) {
++ /*if (suword(nelemp, 0))*/
++ if (put_user(0, nelemp))
++ return(-EFAULT);
++ return(0);
++ }
++ sesslist = kmalloc(sesscnt * sizeof(*sidp), GFP_KERNEL);
++ if (sesslist == NULL) {
++ printk("%s/%d: kmalloc returned NULL\n", __FUNCTION__, __LINE__);
++ return -ENOMEM;
++ }
++
++ lc = mutex_spinlock(&dm_session_lock);
++ if (sesscnt == dm_sessions_active)
++ break;
++
++ mutex_spinunlock(&dm_session_lock, lc);
++ kfree(sesslist);
++ }
++
++ /* Make a temp copy of the data, then release the mutex. */
++
++ for (i = 0, s = dm_sessions; i < sesscnt; i++, s = s->sn_next)
++ sesslist[i] = s->sn_sessid;
++
++ mutex_spinunlock(&dm_session_lock, lc);
++
++ /* Now copy the data to the user. */
++
++ if(put_user(sesscnt, nelemp)) {
++ error = -EFAULT;
++ } else if (sesscnt > nelem) {
++ error = -E2BIG;
++ } else if (copy_to_user(sidp, sesslist, sesscnt * sizeof(*sidp))) {
++ error = -EFAULT;
++ } else {
++ error = 0;
++ }
++ kfree(sesslist);
++ return(error);
++}
++
++
++/*
++ * Return the descriptive string associated with a session.
++ */
++
++int
++dm_query_session(
++ dm_sessid_t sid,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp)
++{
++ dm_session_t *s; /* pointer to session given by sid */
++ int len; /* length of session info string */
++ int error;
++ char sessinfo[DM_SESSION_INFO_LEN];
++ unsigned long lc; /* lock cookie */
++
++ if ((error = dm_find_session_and_lock(sid, &s, &lc)) != 0)
++ return(error);
++
++ len = strlen(s->sn_info) + 1; /* NULL terminated when created */
++ memcpy(sessinfo, s->sn_info, len);
++
++ mutex_spinunlock(&s->sn_qlock, lc);
++
++ /* Now that the mutex is released, copy the sessinfo to the user. */
++
++ if (put_user(len, rlenp)) {
++ error = -EFAULT;
++ } else if (len > buflen) {
++ error = -E2BIG;
++ } else if (copy_to_user(bufp, sessinfo, len)) {
++ error = -EFAULT;
++ } else {
++ error = 0;
++ }
++ return(error);
++}
++
++
++/*
++ * Return all of the previously delivered tokens (that is, their IDs)
++ * for the given session.
++ */
++
++int
++dm_getall_tokens(
++ dm_sessid_t sid, /* session obtaining tokens from */
++ u_int nelem, /* size of tokenbufp */
++ dm_token_t __user *tokenbufp,/* buffer to copy token IDs to */
++ u_int __user *nelemp) /* return number copied to tokenbufp */
++{
++ dm_session_t *s; /* pointer to session given by sid */
++ dm_tokevent_t *tevp; /* event message queue traversal */
++ unsigned long lc; /* lock cookie */
++ int tokcnt;
++ dm_token_t *toklist;
++ int error;
++ int i;
++
++ /* Loop until we can get the right amount of temp space, being careful
++ not to hold a mutex during the allocation. Usually only one trip.
++ */
++
++ for (;;) {
++ if ((error = dm_find_session_and_lock(sid, &s, &lc)) != 0)
++ return(error);
++ tokcnt = s->sn_delq.eq_count;
++ mutex_spinunlock(&s->sn_qlock, lc);
++
++ if (tokcnt == 0) {
++ /*if (suword(nelemp, 0))*/
++ if (put_user(0, nelemp))
++ return(-EFAULT);
++ return(0);
++ }
++ toklist = kmalloc(tokcnt * sizeof(*tokenbufp), GFP_KERNEL);
++ if (toklist == NULL) {
++ printk("%s/%d: kmalloc returned NULL\n", __FUNCTION__, __LINE__);
++ return -ENOMEM;
++ }
++
++ if ((error = dm_find_session_and_lock(sid, &s, &lc)) != 0) {
++ kfree(toklist);
++ return(error);
++ }
++
++ if (tokcnt == s->sn_delq.eq_count)
++ break;
++
++ mutex_spinunlock(&s->sn_qlock, lc);
++ kfree(toklist);
++ }
++
++ /* Make a temp copy of the data, then release the mutex. */
++
++ tevp = s->sn_delq.eq_head;
++ for (i = 0; i < tokcnt; i++, tevp = tevp->te_next)
++ toklist[i] = tevp->te_msg.ev_token;
++
++ mutex_spinunlock(&s->sn_qlock, lc);
++
++ /* Now copy the data to the user. */
++
++ if (put_user(tokcnt, nelemp)) {
++ error = -EFAULT;
++ } else if (tokcnt > nelem) {
++ error = -E2BIG;
++ } else if (copy_to_user(tokenbufp,toklist,tokcnt*sizeof(*tokenbufp))) {
++ error = -EFAULT;
++ } else {
++ error = 0;
++ }
++ kfree(toklist);
++ return(error);
++}
++
++
++/*
++ * Return the message identified by token.
++ */
++
++int
++dm_find_eventmsg(
++ dm_sessid_t sid,
++ dm_token_t token,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp)
++{
++ dm_tokevent_t *tevp; /* message identified by token */
++ int msgsize; /* size of message to copy out */
++ void *msg;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ /* Because some of the events (dm_data_event_t in particular) contain
++ __u64 fields, we need to make sure that the buffer provided by the
++ caller is aligned such that he can read those fields successfully.
++ */
++
++ if (((unsigned long)bufp & (sizeof(__u64) - 1)) != 0)
++ return(-EFAULT);
++
++ /* Allocate the right amount of temp space, being careful not to hold
++ a mutex during the allocation.
++ */
++
++ if ((error = dm_find_msg_and_lock(sid, token, &tevp, &lc)) != 0)
++ return(error);
++ msgsize = tevp->te_allocsize - offsetof(dm_tokevent_t, te_msg);
++ mutex_spinunlock(&tevp->te_lock, lc);
++
++ msg = kmalloc(msgsize, GFP_KERNEL);
++ if (msg == NULL) {
++ printk("%s/%d: kmalloc returned NULL\n", __FUNCTION__, __LINE__);
++ return -ENOMEM;
++ }
++
++ if ((error = dm_find_msg_and_lock(sid, token, &tevp, &lc)) != 0) {
++ kfree(msg);
++ return(error);
++ }
++
++ /* Make a temp copy of the data, then release the mutex. */
++
++ memcpy(msg, &tevp->te_msg, msgsize);
++ mutex_spinunlock(&tevp->te_lock, lc);
++
++ /* Now copy the data to the user. */
++
++ if (put_user(msgsize,rlenp)) {
++ error = -EFAULT;
++ } else if (msgsize > buflen) { /* user buffer not big enough */
++ error = -E2BIG;
++ } else if (copy_to_user( bufp, msg, msgsize )) {
++ error = -EFAULT;
++ } else {
++ error = 0;
++ }
++ kfree(msg);
++ return(error);
++}
++
++
++int
++dm_move_event(
++ dm_sessid_t srcsid,
++ dm_token_t token,
++ dm_sessid_t targetsid,
++ dm_token_t __user *rtokenp)
++{
++ dm_session_t *s1;
++ dm_session_t *s2;
++ dm_tokevent_t *tevp;
++ int error;
++ unsigned long lc; /* lock cookie */
++ int hash_it = 0;
++
++ lc = mutex_spinlock(&dm_session_lock);
++
++ if ((error = dm_find_session(srcsid, &s1)) != 0 ||
++ (error = dm_find_session(targetsid, &s2)) != 0 ||
++ (error = dm_find_msg(s1, token, &tevp)) != 0) {
++ mutex_spinunlock(&dm_session_lock, lc);
++ return(error);
++ }
++ dm_unlink_event(tevp, &s1->sn_delq);
++ if (tevp->te_flags & DM_TEF_HASHED) {
++ unhash_event(s1, tevp);
++ hash_it = 1;
++ }
++ dm_link_event(tevp, &s2->sn_delq);
++ if (hash_it)
++ hash_event(s2, tevp);
++ mutex_spinunlock(&dm_session_lock, lc);
++
++ if (copy_to_user(rtokenp, &token, sizeof(token)))
++ return(-EFAULT);
++ return(0);
++}
++
++
++/* ARGSUSED */
++int
++dm_pending(
++ dm_sessid_t sid,
++ dm_token_t token,
++ dm_timestruct_t __user *delay) /* unused */
++{
++ dm_tokevent_t *tevp;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ if ((error = dm_find_msg_and_lock(sid, token, &tevp, &lc)) != 0)
++ return(error);
++
++ tevp->te_flags |= DM_TEF_INTERMED;
++ if (tevp->te_evt_ref > 0) /* if event generation threads exist */
++ sv_broadcast(&tevp->te_evt_queue);
++
++ mutex_spinunlock(&tevp->te_lock, lc);
++ return(0);
++}
++
++
++int
++dm_get_events(
++ dm_sessid_t sid,
++ u_int maxmsgs,
++ u_int flags,
++ size_t buflen,
++ void __user *bufp,
++ size_t __user *rlenp)
++{
++ dm_session_t *s; /* pointer to session given by sid */
++ dm_tokevent_t *tevp; /* next event message on queue */
++ int error;
++ unsigned long lc1; /* first lock cookie */
++ unsigned long lc2 = 0; /* second lock cookie */
++ int totalsize;
++ int msgsize;
++ dm_eventmsg_t __user *prevmsg;
++ int prev_msgsize = 0;
++ u_int msgcnt;
++
++ /* Because some of the events (dm_data_event_t in particular) contain
++ __u64 fields, we need to make sure that the buffer provided by the
++ caller is aligned such that he can read those fields successfully.
++ */
++
++ if (((unsigned long)bufp & (sizeof(__u64) - 1)) != 0)
++ return(-EFAULT);
++
++ /* Find the indicated session and lock it. */
++
++ if ((error = dm_find_session_and_lock(sid, &s, &lc1)) != 0)
++ return(error);
++
++ /* Check for messages on sn_newq. If there aren't any that haven't
++ already been grabbed by another process, and if we are supposed to
++ to wait until one shows up, then go to sleep interruptibly on the
++ sn_readerq semaphore. The session can't disappear out from under
++ us as long as sn_readerq is non-zero.
++ */
++
++ for (;;) {
++ int rc;
++
++ for (tevp = s->sn_newq.eq_head; tevp; tevp = tevp->te_next) {
++ lc2 = mutex_spinlock(&tevp->te_lock);
++ if (!(tevp->te_flags & DM_TEF_LOCKED))
++ break;
++ mutex_spinunlock(&tevp->te_lock, lc2);
++ }
++ if (tevp)
++ break; /* got one! */
++
++ if (!(flags & DM_EV_WAIT)) {
++ mutex_spinunlock(&s->sn_qlock, lc1);
++ return(-EAGAIN);
++ }
++ s->sn_readercnt++;
++
++ sv_wait_sig(&s->sn_readerq, 1, &s->sn_qlock, lc1);
++ rc = signal_pending(current);
++
++ lc1 = mutex_spinlock(&s->sn_qlock);
++ s->sn_readercnt--;
++ if (rc) { /* if signal was received */
++ mutex_spinunlock(&s->sn_qlock, lc1);
++ return(-EINTR);
++ }
++ }
++
++ /* At least one message is available for delivery, and we have both the
++ session lock and event lock. Mark the event so that it is not
++ grabbed by other daemons, then drop both locks prior copying the
++ data to the caller's buffer. Leaving the event on the queue in a
++ marked state prevents both the session and the event from
++ disappearing out from under us while we don't have the locks.
++ */
++
++ tevp->te_flags |= DM_TEF_LOCKED;
++ mutex_spinunlock(&tevp->te_lock, lc2); /* reverse cookie order */
++ mutex_spinunlock(&s->sn_qlock, lc1);
++
++ /* Continue to deliver messages until there are no more, the
++ user's buffer becomes full, or we hit his maxmsgs limit.
++ */
++
++ totalsize = 0; /* total bytes transferred to the user */
++ prevmsg = NULL;
++ msgcnt = 0;
++
++ while (tevp) {
++ /* Compute the number of bytes to be moved, rounding up to an
++ 8-byte boundary so that any subsequent messages will also be
++ aligned.
++ */
++
++ msgsize = tevp->te_allocsize - offsetof(dm_tokevent_t, te_msg);
++ msgsize = (msgsize + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1);
++ totalsize += msgsize;
++
++ /* If it fits, copy the message into the user's buffer and
++ update his 'rlenp'. Update the _link pointer for any
++ previous message.
++ */
++
++ if (totalsize > buflen) { /* no more room */
++ error = -E2BIG;
++ } else if (put_user(totalsize, rlenp)) {
++ error = -EFAULT;
++ } else if (copy_to_user(bufp, &tevp->te_msg, msgsize)) {
++ error = -EFAULT;
++ } else if (prevmsg && put_user(prev_msgsize, &prevmsg->_link)) {
++ error = -EFAULT;
++ } else {
++ error = 0;
++ }
++
++ /* If an error occurred, just unmark the event and leave it on
++ the queue for someone else. Note that other daemons may
++ have gone to sleep because this event was marked, so wake
++ them up. Also, if at least one message has already been
++ delivered, then an error here is not really an error.
++ */
++
++ lc1 = mutex_spinlock(&s->sn_qlock);
++ lc2 = mutex_spinlock(&tevp->te_lock);
++ tevp->te_flags &= ~DM_TEF_LOCKED; /* drop the mark */
++
++ if (error) {
++ if (s->sn_readercnt)
++ sv_signal(&s->sn_readerq);
++
++ mutex_spinunlock(&tevp->te_lock, lc2); /* rev. order */
++ mutex_spinunlock(&s->sn_qlock, lc1);
++ if (prevmsg)
++ return(0);
++ if (error == -E2BIG && put_user(totalsize,rlenp))
++ error = -EFAULT;
++ return(error);
++ }
++
++ /* The message was successfully delivered. Unqueue it. */
++
++ dm_unlink_event(tevp, &s->sn_newq);
++
++ /* Wake up the first of any processes waiting for room on the
++ sn_newq.
++ */
++
++ if (s->sn_writercnt)
++ sv_signal(&s->sn_writerq);
++
++ /* If the message is synchronous, add it to the sn_delq while
++ still holding the lock. If it is asynchronous, free it.
++ */
++
++ if (tevp->te_msg.ev_token != DM_INVALID_TOKEN) { /* synch */
++ dm_link_event(tevp, &s->sn_delq);
++ mutex_spinunlock(&tevp->te_lock, lc2);
++ } else {
++ tevp->te_flags |= DM_TEF_FINAL;
++ if (tevp->te_flags & DM_TEF_HASHED)
++ unhash_event(s, tevp);
++ mutex_spinunlock(&tevp->te_lock, lc2);
++ dm_put_tevp(tevp, NULL);/* can't cause destroy events */
++ }
++
++ /* Update our notion of where we are in the user's buffer. If
++ he doesn't want any more messages, then stop.
++ */
++
++ prevmsg = (dm_eventmsg_t __user *)bufp;
++ prev_msgsize = msgsize;
++ bufp = (char __user *)bufp + msgsize;
++
++ msgcnt++;
++ if (maxmsgs && msgcnt >= maxmsgs) {
++ mutex_spinunlock(&s->sn_qlock, lc1);
++ break;
++ }
++
++ /* While still holding the sn_qlock, see if any additional
++ messages are available for delivery.
++ */
++
++ for (tevp = s->sn_newq.eq_head; tevp; tevp = tevp->te_next) {
++ lc2 = mutex_spinlock(&tevp->te_lock);
++ if (!(tevp->te_flags & DM_TEF_LOCKED)) {
++ tevp->te_flags |= DM_TEF_LOCKED;
++ mutex_spinunlock(&tevp->te_lock, lc2);
++ break;
++ }
++ mutex_spinunlock(&tevp->te_lock, lc2);
++ }
++ mutex_spinunlock(&s->sn_qlock, lc1);
++ }
++ return(0);
++}
++
++
++/*
++ * Remove an event message from the delivered queue, set the returned
++ * error where the event generator wants it, and wake up the generator.
++ * Also currently have the user side release any locks it holds...
++ */
++
++/* ARGSUSED */
++int
++dm_respond_event(
++ dm_sessid_t sid,
++ dm_token_t token,
++ dm_response_t response,
++ int reterror,
++ size_t buflen, /* unused */
++ void __user *respbufp) /* unused */
++{
++ dm_session_t *s; /* pointer to session given by sid */
++ dm_tokevent_t *tevp; /* event message queue traversal */
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ /* Sanity check the input parameters. */
++
++ switch (response) {
++ case DM_RESP_CONTINUE: /* continue must have reterror == 0 */
++ if (reterror != 0)
++ return(-EINVAL);
++ break;
++ case DM_RESP_ABORT: /* abort must have errno set */
++ if (reterror <= 0)
++ return(-EINVAL);
++ break;
++ case DM_RESP_DONTCARE:
++ reterror = -1; /* to distinguish DM_RESP_DONTCARE */
++ break;
++ default:
++ return(-EINVAL);
++ }
++
++ /* Hold session lock until the event is unqueued. */
++
++ if ((error = dm_find_session_and_lock(sid, &s, &lc)) != 0)
++ return(error);
++
++ if ((error = dm_find_msg(s, token, &tevp)) != 0) {
++ mutex_spinunlock(&s->sn_qlock, lc);
++ return(error);
++ }
++ nested_spinlock(&tevp->te_lock);
++
++ if ((response == DM_RESP_DONTCARE) &&
++ (tevp->te_msg.ev_type != DM_EVENT_MOUNT)) {
++ error = -EINVAL;
++ nested_spinunlock(&tevp->te_lock);
++ mutex_spinunlock(&s->sn_qlock, lc);
++ } else {
++ dm_unlink_event(tevp, &s->sn_delq);
++ if (tevp->te_flags & DM_TEF_HASHED)
++ unhash_event(s, tevp);
++ tevp->te_reply = -reterror; /* linux wants negative errno */
++ tevp->te_flags |= DM_TEF_FINAL;
++ if (tevp->te_evt_ref)
++ sv_broadcast(&tevp->te_evt_queue);
++ nested_spinunlock(&tevp->te_lock);
++ mutex_spinunlock(&s->sn_qlock, lc);
++ error = 0;
++
++ /* Absolutely no locks can be held when calling dm_put_tevp! */
++
++ dm_put_tevp(tevp, NULL); /* this can generate destroy events */
++ }
++ return(error);
++}
++
++/* The caller must hold sn_qlock.
++ This will return the tokevent locked.
++ */
++static dm_tokevent_t *
++__find_match_event_no_waiters_locked(
++ dm_tokevent_t *tevp1,
++ dm_eventq_t *queue)
++{
++ dm_tokevent_t *tevp2, *next_tevp;
++ dm_tokdata_t *tdp1 = tevp1->te_tdp;
++ dm_tokdata_t *tdp2;
++ dm_data_event_t *d_event1;
++ dm_data_event_t *d_event2;
++
++ d_event1 = (dm_data_event_t *)((char *)&tevp1->te_msg + tevp1->te_msg.ev_data.vd_offset);
++
++ for(tevp2 = queue->eq_head; tevp2; tevp2 = next_tevp) {
++ nested_spinlock(&tevp2->te_lock);
++ next_tevp = tevp2->te_next;
++
++ /* Just compare the first tdp's in each--there should
++ be just one, if it's the match we want.
++ */
++ tdp2 = tevp2->te_tdp;
++ if ((tevp2->te_msg.ev_type == tevp1->te_msg.ev_type) &&
++ (tevp2->te_tdp->td_type == tevp1->te_tdp->td_type) &&
++ (tevp2->te_evt_ref == 0) && (tdp2->td_next == NULL) &&
++ (memcmp(&tdp1->td_handle, &tdp2->td_handle,
++ sizeof(dm_handle_t)) == 0)) {
++
++ d_event2 = (dm_data_event_t *)((char *)&tevp2->te_msg + tevp2->te_msg.ev_data.vd_offset);
++
++
++ if ((d_event2->de_offset == d_event1->de_offset) &&
++ (d_event2->de_length == d_event1->de_length)) {
++ /* Match -- return it locked */
++ return tevp2;
++ }
++ }
++ nested_spinunlock(&tevp2->te_lock);
++ }
++ return NULL;
++}
++
++/* The caller must hold the sn_qlock.
++ The returned tokevent will be locked with nested_spinlock.
++ */
++static dm_tokevent_t *
++find_match_event_no_waiters_locked(
++ dm_session_t *s,
++ dm_tokevent_t *tevp)
++{
++ dm_tokevent_t *tevp2;
++
++ if ((!s->sn_newq.eq_tail) && (!s->sn_delq.eq_tail))
++ return NULL;
++ if (!tevp->te_tdp)
++ return NULL;
++ if (tevp->te_tdp->td_next) {
++ /* If it has multiple tdp's then don't bother trying to
++ find a match.
++ */
++ return NULL;
++ }
++ tevp2 = __find_match_event_no_waiters_locked(tevp, &s->sn_newq);
++ if (tevp2 == NULL)
++ tevp2 = __find_match_event_no_waiters_locked(tevp, &s->sn_delq);
++ /* returns a locked tokevent */
++ return tevp2;
++}
++
++
++
++/* Queue the filled in event message pointed to by tevp on the session s, and
++ (if a synchronous event) wait for the reply from the DMAPI application.
++ The caller MUST be holding the session lock before calling this routine!
++ The session lock is always released upon exit.
++ Returns:
++ -1 == don't care
++ 0 == success (or async event)
++ > 0 == errno describing reason for failure
++*/
++
++static int
++dm_enqueue(
++ dm_session_t *s,
++ unsigned long lc, /* input lock cookie */
++ dm_tokevent_t **tevpp, /* in/out parameter */
++ int sync,
++ int flags,
++ int interruptable)
++{
++ int is_unmount = 0;
++ int is_hashable = 0;
++ int reply;
++ dm_tokevent_t *tevp = *tevpp;
++
++ /* If the caller isn't planning to stick around for the result
++ and this request is identical to one that is already on the
++ queues then just give the caller an EAGAIN. Release the
++ session lock before returning.
++
++ We look only at NDELAY requests with an event type of READ,
++ WRITE, or TRUNCATE on objects that are regular files.
++ */
++
++ if ((flags & DM_FLAGS_NDELAY) && DM_EVENT_RDWRTRUNC(tevp) &&
++ (tevp->te_tdp->td_type == DM_TDT_REG)) {
++ if (repeated_event(s, tevp)) {
++ mutex_spinunlock(&s->sn_qlock, lc);
++ return -EAGAIN;
++ }
++ is_hashable = 1;
++ }
++
++ /* If the caller is a sync event then look for a matching sync
++ event. If there is a match and it doesn't currently have
++ event threads waiting on it, then we will drop our own
++ tokevent and jump on the matching event.
++ */
++ if (((flags & DM_FLAGS_NDELAY) == 0) && DM_EVENT_RDWRTRUNC(tevp) &&
++ (tevp->te_tdp->td_type == DM_TDT_REG)) {
++ dm_tokevent_t *tevp2;
++ if ((tevp2 = find_match_event_no_waiters_locked(s, tevp))) {
++ ASSERT(tevp2->te_evt_ref == 0);
++ tevp2->te_evt_ref++;
++ nested_spinunlock(&tevp2->te_lock);
++ nested_spinlock(&tevp->te_lock);
++ tevp->te_evt_ref--;
++ nested_spinunlock(&tevp->te_lock);
++ mutex_spinunlock(&s->sn_qlock, lc);
++ /* All locks have been released */
++ dm_evt_rele_tevp(tevp, 1);
++ *tevpp = tevp = tevp2;
++ goto wait_on_tevp;
++ }
++ }
++
++ if (tevp->te_msg.ev_type == DM_EVENT_UNMOUNT)
++ is_unmount = 1;
++
++ /* Check for room on sn_newq. If there is no room for new messages,
++ then go to sleep on the sn_writerq semaphore. The
++ session cannot disappear out from under us as long as sn_writercnt
++ is non-zero.
++ */
++
++ while (s->sn_newq.eq_count >= dm_max_queued_msgs) { /* no room */
++ s->sn_writercnt++;
++ dm_link_event(tevp, &s->sn_evt_writerq);
++ if (interruptable) {
++ sv_wait_sig(&s->sn_writerq, 1, &s->sn_qlock, lc);
++ if (signal_pending(current)) {
++ s->sn_writercnt--;
++ return -EINTR;
++ }
++ } else {
++ sv_wait(&s->sn_writerq, 1, &s->sn_qlock, lc);
++ }
++ lc = mutex_spinlock(&s->sn_qlock);
++ s->sn_writercnt--;
++ dm_unlink_event(tevp, &s->sn_evt_writerq);
++#ifdef HAVE_DM_QUEUE_FLUSH
++ /* We hold the sn_qlock, from here to after we get into
++ * the sn_newq. Any thread going through
++ * dm_release_threads() looking for us is already past us
++ * and has set the DM_TEF_FLUSH flag for us or is blocked on
++ * sn_qlock and will find us in sn_newq after we release
++ * the sn_qlock.
++ * We check for dop->flushing anyway, in case the
++ * dm_release_threads() already completed before we
++ * could enter dmapi.
++ */
++ if (!sync) {
++ /* async events are forced into the newq */
++ break;
++ }
++ if (tevp->te_flags & DM_TEF_FLUSH) {
++ mutex_spinunlock(&s->sn_qlock, lc);
++ return tevp->te_reply;
++ }
++ else {
++ struct filesystem_dmapi_operations *dops;
++ dm_tokdata_t *tdp;
++ int errno = 0;
++
++ nested_spinlock(&tevp->te_lock);
++ for (tdp = tevp->te_tdp; tdp; tdp = tdp->td_next) {
++ if (tdp->td_ip) {
++ dops = dm_fsys_ops(tdp->td_ip->i_sb);
++ ASSERT(dops);
++ if (dops->flushing)
++ errno = dops->flushing(tdp->td_ip);
++ if (errno) {
++ nested_spinunlock(&tevp->te_lock);
++ mutex_spinunlock(&s->sn_qlock, lc);
++ return errno;
++ }
++ }
++ }
++ nested_spinunlock(&tevp->te_lock);
++ }
++#endif /* HAVE_DM_QUEUE_FLUSH */
++ }
++
++ /* Assign a sequence number and token to the event and bump the
++ application reference count by one. We don't need 'te_lock' here
++ because this thread is still the only thread that can see the event.
++ */
++
++ nested_spinlock(&dm_token_lock);
++ tevp->te_msg.ev_sequence = dm_next_sequence++;
++ if (sync) {
++ tevp->te_msg.ev_token = dm_next_token++;
++ } else {
++ tevp->te_msg.ev_token = DM_INVALID_TOKEN;
++ }
++ nested_spinunlock(&dm_token_lock);
++
++ tevp->te_app_ref++;
++
++ /* Room exists on the sn_newq queue, so add this request. If the
++ queue was previously empty, wake up the first of any processes
++ that are waiting for an event.
++ */
++
++ dm_link_event(tevp, &s->sn_newq);
++ if (is_hashable)
++ hash_event(s, tevp);
++
++ if (s->sn_readercnt)
++ sv_signal(&s->sn_readerq);
++
++ mutex_spinunlock(&s->sn_qlock, lc);
++
++ /* Now that the message is queued, processes issuing asynchronous
++ events or DM_EVENT_UNMOUNT events are ready to continue.
++ */
++
++ if (!sync || is_unmount)
++ return 0;
++
++ /* Synchronous requests wait until a final reply is received. If the
++ caller supplied the DM_FLAGS_NDELAY flag, the process will return
++ EAGAIN if dm_pending() sets DM_TEF_INTERMED. We also let users
++ Cntl-C out of a read, write, and truncate requests.
++ */
++
++wait_on_tevp:
++ lc = mutex_spinlock(&tevp->te_lock);
++
++ while (!(tevp->te_flags & DM_TEF_FINAL)) {
++ if ((tevp->te_flags & DM_TEF_INTERMED) &&
++ (flags & DM_FLAGS_NDELAY)) {
++ mutex_spinunlock(&tevp->te_lock, lc);
++ return -EAGAIN;
++ }
++ if (tevp->te_msg.ev_type == DM_EVENT_READ ||
++ tevp->te_msg.ev_type == DM_EVENT_WRITE ||
++ tevp->te_msg.ev_type == DM_EVENT_TRUNCATE) {
++ sv_wait_sig(&tevp->te_evt_queue, 1, &tevp->te_lock, lc);
++ if (signal_pending(current)){
++ return -EINTR;
++ }
++ } else {
++ sv_wait(&tevp->te_evt_queue, 1, &tevp->te_lock, lc);
++ }
++ lc = mutex_spinlock(&tevp->te_lock);
++#ifdef HAVE_DM_QUEUE_FLUSH
++ /* Did we pop out because of queue flushing? */
++ if (tevp->te_flags & DM_TEF_FLUSH) {
++ mutex_spinunlock(&tevp->te_lock, lc);
++ return tevp->te_reply;
++ }
++#endif /* HAVE_DM_QUEUE_FLUSH */
++ }
++
++ /* Return both the tevp and the reply which was stored in the tevp by
++ dm_respond_event. The tevp structure has already been removed from
++ the reply queue by this point in dm_respond_event().
++ */
++
++ reply = tevp->te_reply;
++ mutex_spinunlock(&tevp->te_lock, lc);
++ return reply;
++}
++
++
++/* The filesystem is guaranteed to stay mounted while this event is
++ outstanding.
++*/
++
++int
++dm_enqueue_normal_event(
++ struct super_block *sb,
++ dm_tokevent_t **tevpp,
++ int flags)
++{
++ dm_session_t *s;
++ int error;
++ int sync;
++ unsigned long lc; /* lock cookie */
++
++ switch ((*tevpp)->te_msg.ev_type) {
++ case DM_EVENT_READ:
++ case DM_EVENT_WRITE:
++ case DM_EVENT_TRUNCATE:
++ case DM_EVENT_PREUNMOUNT:
++ case DM_EVENT_UNMOUNT:
++ case DM_EVENT_NOSPACE:
++ case DM_EVENT_CREATE:
++ case DM_EVENT_REMOVE:
++ case DM_EVENT_RENAME:
++ case DM_EVENT_SYMLINK:
++ case DM_EVENT_LINK:
++ case DM_EVENT_DEBUT: /* not currently supported */
++ sync = 1;
++ break;
++
++ case DM_EVENT_DESTROY:
++ case DM_EVENT_POSTCREATE:
++ case DM_EVENT_POSTREMOVE:
++ case DM_EVENT_POSTRENAME:
++ case DM_EVENT_POSTSYMLINK:
++ case DM_EVENT_POSTLINK:
++ case DM_EVENT_ATTRIBUTE:
++ case DM_EVENT_CLOSE: /* not currently supported */
++ case DM_EVENT_CANCEL: /* not currently supported */
++ sync = 0;
++ break;
++
++ default:
++ return(-EIO); /* garbage event number */
++ }
++
++ /* Wait until a session selects disposition for the event. The session
++ is locked upon return from dm_waitfor_disp_session().
++ */
++
++ if ((error = dm_waitfor_disp_session(sb, *tevpp, &s, &lc)) != 0)
++ return(error);
++
++ return(dm_enqueue(s, lc, tevpp, sync, flags, 0));
++}
++
++
++/* Traverse the session list checking for sessions with the WANTMOUNT flag
++ set. When one is found, send it the message. Possible responses to the
++ message are one of DONTCARE, CONTINUE, or ABORT. The action taken in each
++ case is:
++ DONTCARE (-1) - Send the event to the next session with WANTMOUNT set
++ CONTINUE ( 0) - Proceed with the mount, errno zero.
++ ABORT (>0) - Fail the mount, return the returned errno.
++
++ The mount request is sent to sessions in ascending session ID order.
++ Since the session list can change dramatically while this process is
++ sleeping in dm_enqueue(), this routine must use session IDs rather than
++ session pointers when keeping track of where it is in the list. Since
++ new sessions are always added at the end of the queue, and have increasing
++ session ID values, we don't have to worry about missing any session.
++*/
++
++int
++dm_enqueue_mount_event(
++ struct super_block *sb,
++ dm_tokevent_t *tevp)
++{
++ dm_session_t *s;
++ dm_sessid_t sid;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ /* Make the mounting filesystem visible to other DMAPI calls. */
++
++ if ((error = dm_add_fsys_entry(sb, tevp)) != 0){
++ return(error);
++ }
++
++ /* Walk through the session list presenting the mount event to each
++ session that is interested until a session accepts or rejects it,
++ or until all sessions ignore it.
++ */
++
++ for (sid = DM_NO_SESSION, error = 1; error > 0; sid = s->sn_sessid) {
++
++ lc = mutex_spinlock(&dm_session_lock);
++ for (s = dm_sessions; s; s = s->sn_next) {
++ if (s->sn_sessid > sid && s->sn_flags & DM_SN_WANTMOUNT) {
++ nested_spinlock(&s->sn_qlock);
++ nested_spinunlock(&dm_session_lock);
++ break;
++ }
++ }
++ if (s == NULL) {
++ mutex_spinunlock(&dm_session_lock, lc);
++ break; /* noone wants it; proceed with mount */
++ }
++ error = dm_enqueue(s, lc, &tevp, 1, 0, 0);
++ }
++
++ /* If the mount will be allowed to complete, then update the fsrp entry
++ accordingly. If the mount is to be aborted, remove the fsrp entry.
++ */
++
++ if (error >= 0) {
++ dm_change_fsys_entry(sb, DM_STATE_MOUNTED);
++ error = 0;
++ } else {
++ dm_remove_fsys_entry(sb);
++ }
++ return(error);
++}
++
++int
++dm_enqueue_sendmsg_event(
++ dm_sessid_t targetsid,
++ dm_tokevent_t *tevp,
++ int sync)
++{
++ dm_session_t *s;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ if ((error = dm_find_session_and_lock(targetsid, &s, &lc)) != 0)
++ return(error);
++
++ return(dm_enqueue(s, lc, &tevp, sync, 0, 1));
++}
++
++
++dm_token_t
++dm_enqueue_user_event(
++ dm_sessid_t sid,
++ dm_tokevent_t *tevp,
++ dm_token_t *tokenp)
++{
++ dm_session_t *s;
++ int error;
++ unsigned long lc; /* lock cookie */
++
++ /* Atomically find and lock the session whose session id is 'sid'. */
++
++ if ((error = dm_find_session_and_lock(sid, &s, &lc)) != 0)
++ return(error);
++
++ /* Assign a sequence number and token to the event, bump the
++ application reference count by one, and decrement the event
++ count because the caller gives up all ownership of the event.
++ We don't need 'te_lock' here because this thread is still the
++ only thread that can see the event.
++ */
++
++ nested_spinlock(&dm_token_lock);
++ tevp->te_msg.ev_sequence = dm_next_sequence++;
++ *tokenp = tevp->te_msg.ev_token = dm_next_token++;
++ nested_spinunlock(&dm_token_lock);
++
++ tevp->te_flags &= ~(DM_TEF_INTERMED|DM_TEF_FINAL);
++ tevp->te_app_ref++;
++ tevp->te_evt_ref--;
++
++ /* Add the request to the tail of the sn_delq. Now it's visible. */
++
++ dm_link_event(tevp, &s->sn_delq);
++ mutex_spinunlock(&s->sn_qlock, lc);
++
++ return(0);
++}
++
++#ifdef HAVE_DM_QUEUE_FLUSH
++/* If inode is non-null, find any tdp referencing that inode and flush the
++ * thread waiting on that inode and set DM_TEF_FLUSH for that tokevent.
++ * Otherwise, if inode is null, find any tdp referencing the specified fsid
++ * and flush that thread and set DM_TEF_FLUSH for that tokevent.
++ */
++static int
++dm_flush_events(
++ dm_session_t *s,
++ dm_fsid_t *fsidp,
++ struct inode *inode, /* may be null */
++ dm_eventq_t *queue,
++ int is_writerq,
++ int errno)
++{
++ dm_tokevent_t *tevp, *next_tevp;
++ dm_tokdata_t *tdp;
++ int found_events = 0;
++
++ ASSERT(fsidp);
++ for (tevp = queue->eq_head; tevp; tevp = next_tevp) {
++ nested_spinlock(&tevp->te_lock);
++ next_tevp = tevp->te_next;
++
++ for (tdp = tevp->te_tdp; tdp; tdp = tdp->td_next) {
++ if( inode ) {
++ if( tdp->td_ip == inode ) {
++ break;
++ }
++ }
++ else if(memcmp(fsidp, &tdp->td_handle.ha_fsid, sizeof(*fsidp)) == 0) {
++ break;
++ }
++ }
++
++ if (tdp != NULL) {
++ /* found a handle reference in this event */
++ ++found_events;
++ tevp->te_flags |= DM_TEF_FLUSH;
++
++ /* Set the reply value, unless dm_get_events is
++ already on this one.
++ */
++ if (! (tevp->te_flags & DM_TEF_LOCKED))
++ tevp->te_reply = errno;
++
++ /* If it is on the sn_evt_writerq or is being
++ used by dm_get_events then we're done with it.
++ */
++ if (is_writerq || (tevp->te_flags & DM_TEF_LOCKED)) {
++ nested_spinunlock(&tevp->te_lock);
++ continue;
++ }
++
++ /* If there is a thread waiting on a synchronous
++ event then be like dm_respond_event.
++ */
++
++ if ((tevp->te_evt_ref) &&
++ (tevp->te_msg.ev_token != DM_INVALID_TOKEN)) {
++
++ tevp->te_flags |= DM_TEF_FINAL;
++ dm_unlink_event(tevp, queue);
++ if (tevp->te_flags & DM_TEF_HASHED)
++ unhash_event(s, tevp);
++ sv_broadcast(&tevp->te_evt_queue);
++ nested_spinunlock(&tevp->te_lock);
++ dm_put_tevp(tevp, NULL);
++ continue;
++ }
++ }
++ nested_spinunlock(&tevp->te_lock);
++ }
++
++ return(found_events);
++}
++
++
++/* If inode is non-null then find any threads that have a reference to that
++ * inode and flush them with the specified errno.
++ * Otherwise,if inode is null, then find any threads that have a reference
++ * to that sb and flush them with the specified errno.
++ * We look for these threads in each session's sn_evt_writerq, sn_newq,
++ * and sn_delq.
++ */
++int
++dm_release_threads(
++ struct super_block *sb,
++ struct inode *inode, /* may be null */
++ int errno)
++{
++ dm_sessid_t sid;
++ dm_session_t *s;
++ unsigned long lc;
++ u_int sesscnt;
++ dm_sessid_t *sidlist;
++ int i;
++ int found_events = 0;
++ dm_fsid_t fsid;
++ struct filesystem_dmapi_operations *dops;
++
++ ASSERT(sb);
++ dops = dm_fsys_ops(sb);
++ ASSERT(dops);
++ dops->get_fsid(sb, &fsid);
++ dm_release_disp_threads(&fsid, inode, errno);
++
++ /* Loop until we can get the right amount of temp space, being careful
++ not to hold a mutex during the allocation. Usually only one trip.
++ */
++
++ for (;;) {
++ lc = mutex_spinlock(&dm_session_lock);
++ sesscnt = dm_sessions_active;
++ mutex_spinunlock(&dm_session_lock, lc);
++
++ if (sesscnt == 0)
++ return 0;
++
++ sidlist = kmalloc(sesscnt * sizeof(sid), GFP_KERNEL);
++
++ lc = mutex_spinlock(&dm_session_lock);
++ if (sesscnt == dm_sessions_active)
++ break;
++
++ mutex_spinunlock(&dm_session_lock, lc);
++ kfree(sidlist);
++ }
++
++ for (i = 0, s = dm_sessions; i < sesscnt; i++, s = s->sn_next)
++ sidlist[i] = s->sn_sessid;
++
++ mutex_spinunlock(&dm_session_lock, lc);
++
++
++ for (i = 0; i < sesscnt; i++) {
++ sid = sidlist[i];
++ if( dm_find_session_and_lock( sid, &s, &lc ) == 0 ){
++ found_events = dm_flush_events( s, &fsid, inode,
++ &s->sn_evt_writerq, 1,
++ errno );
++ if (found_events)
++ sv_broadcast(&s->sn_writerq);
++
++ dm_flush_events(s, &fsid, inode, &s->sn_newq, 0, errno);
++ dm_flush_events(s, &fsid, inode, &s->sn_delq, 0, errno);
++
++ mutex_spinunlock( &s->sn_qlock, lc );
++ }
++ }
++ kfree(sidlist);
++
++ return 0;
++}
++#endif /* HAVE_DM_QUEUE_FLUSH */
+Index: linux-2.6.26/fs/dmapi/dmapi_sysent.c
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/dmapi_sysent.c
+@@ -0,0 +1,805 @@
++/*
++ * Copyright (c) 2000-2005 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++
++/* Data Migration API (DMAPI)
++ */
++
++
++/* We're using MISC_MAJOR / MISC_DYNAMIC_MINOR. */
++
++#include <linux/version.h>
++#include <linux/kernel.h>
++#include <linux/miscdevice.h>
++#include <linux/major.h>
++#include <linux/init.h>
++#include <linux/proc_fs.h>
++#include <linux/module.h>
++#include <linux/smp_lock.h>
++
++#include <asm/uaccess.h>
++
++#include "dmapi.h"
++#include "dmapi_kern.h"
++#include "dmapi_private.h"
++
++struct kmem_cache *dm_fsreg_cachep = NULL;
++struct kmem_cache *dm_tokdata_cachep = NULL;
++struct kmem_cache *dm_session_cachep = NULL;
++struct kmem_cache *dm_fsys_map_cachep = NULL;
++struct kmem_cache *dm_fsys_vptr_cachep = NULL;
++
++static int
++dmapi_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
++ unsigned long arg)
++{
++ sys_dmapi_args_t kargs;
++ sys_dmapi_args_t *uap = &kargs;
++ int error = 0;
++ int rvp = -ENOSYS;
++ int use_rvp = 0;
++
++ if (!capable(CAP_MKNOD))
++ return -EPERM;
++
++ if( copy_from_user( &kargs, (sys_dmapi_args_t __user *)arg,
++ sizeof(sys_dmapi_args_t) ) )
++ return -EFAULT;
++
++ unlock_kernel();
++
++ switch (cmd) {
++ case DM_CLEAR_INHERIT:
++ error = dm_clear_inherit(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_attrname_t __user *) DM_Parg(uap,5));/* attrnamep */
++ break;
++ case DM_CREATE_BY_HANDLE:
++ error = dm_create_by_handle(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* dirhanp */
++ (size_t) DM_Uarg(uap,3), /* dirhlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (void __user *) DM_Parg(uap,5), /* hanp */
++ (size_t) DM_Uarg(uap,6), /* hlen */
++ (char __user *) DM_Parg(uap,7));/* cname */
++ break;
++ case DM_CREATE_SESSION:
++ error = dm_create_session(
++ (dm_sessid_t) DM_Uarg(uap,1), /* oldsid */
++ (char __user *) DM_Parg(uap,2), /* sessinfop */
++ (dm_sessid_t __user *) DM_Parg(uap,3));/* newsidp */
++ break;
++ case DM_CREATE_USEREVENT:
++ error = dm_create_userevent(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (size_t) DM_Uarg(uap,2), /* msglen */
++ (void __user *) DM_Parg(uap,3), /* msgdatap */
++ (dm_token_t __user *) DM_Parg(uap,4));/* tokenp */
++ break;
++ case DM_DESTROY_SESSION:
++ error = dm_destroy_session(
++ (dm_sessid_t) DM_Uarg(uap,1));/* sid */
++ break;
++ case DM_DOWNGRADE_RIGHT:
++ error = dm_downgrade_right(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4));/* token */
++ break;
++ case DM_FD_TO_HANDLE:
++ error = dm_fd_to_hdl(
++ (int) DM_Uarg(uap,1), /* fd */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t __user *) DM_Parg(uap,3));/* hlenp */
++ break;
++ case DM_FIND_EVENTMSG:
++ error = dm_find_eventmsg(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (dm_token_t) DM_Uarg(uap,2), /* token */
++ (size_t) DM_Uarg(uap,3), /* buflen */
++ (void __user *) DM_Parg(uap,4), /* bufp */
++ (size_t __user *) DM_Parg(uap,5));/* rlenp */
++ break;
++ case DM_GET_ALLOCINFO:
++ use_rvp = 1;
++ error = dm_get_allocinfo_rvp(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_off_t __user *) DM_Parg(uap,5), /* offp */
++ (u_int) DM_Uarg(uap,6), /* nelem */
++ (dm_extent_t __user *) DM_Parg(uap,7), /* extentp */
++ (u_int __user *) DM_Parg(uap,8), /* nelemp */
++ &rvp);
++ break;
++ case DM_GET_BULKALL:
++ use_rvp = 1;
++ error = dm_get_bulkall_rvp(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (u_int) DM_Uarg(uap,5), /* mask */
++ (dm_attrname_t __user *) DM_Parg(uap,6),/* attrnamep */
++ (dm_attrloc_t __user *) DM_Parg(uap,7),/* locp */
++ (size_t) DM_Uarg(uap,8), /* buflen */
++ (void __user *) DM_Parg(uap,9), /* bufp */
++ (size_t __user *) DM_Parg(uap,10),/* rlenp */
++ &rvp);
++ break;
++ case DM_GET_BULKATTR:
++ use_rvp = 1;
++ error = dm_get_bulkattr_rvp(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (u_int) DM_Uarg(uap,5), /* mask */
++ (dm_attrloc_t __user *)DM_Parg(uap,6), /* locp */
++ (size_t) DM_Uarg(uap,7), /* buflen */
++ (void __user *) DM_Parg(uap,8), /* bufp */
++ (size_t __user *) DM_Parg(uap,9), /* rlenp */
++ &rvp);
++ break;
++ case DM_GET_CONFIG:
++ error = dm_get_config(
++ (void __user *) DM_Parg(uap,1), /* hanp */
++ (size_t) DM_Uarg(uap,2), /* hlen */
++ (dm_config_t) DM_Uarg(uap,3), /* flagname */
++ (dm_size_t __user *)DM_Parg(uap,4));/* retvalp */
++ break;
++ case DM_GET_CONFIG_EVENTS:
++ error = dm_get_config_events(
++ (void __user *) DM_Parg(uap,1), /* hanp */
++ (size_t) DM_Uarg(uap,2), /* hlen */
++ (u_int) DM_Uarg(uap,3), /* nelem */
++ (dm_eventset_t __user *) DM_Parg(uap,4),/* eventsetp */
++ (u_int __user *) DM_Parg(uap,5));/* nelemp */
++ break;
++ case DM_GET_DIOINFO:
++ error = dm_get_dioinfo(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_dioinfo_t __user *)DM_Parg(uap,5));/* diop */
++ break;
++ case DM_GET_DIRATTRS:
++ use_rvp = 1;
++ error = dm_get_dirattrs_rvp(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (u_int) DM_Uarg(uap,5), /* mask */
++ (dm_attrloc_t __user *)DM_Parg(uap,6), /* locp */
++ (size_t) DM_Uarg(uap,7), /* buflen */
++ (void __user *) DM_Parg(uap,8), /* bufp */
++ (size_t __user *) DM_Parg(uap,9), /* rlenp */
++ &rvp);
++ break;
++ case DM_GET_DMATTR:
++ error = dm_get_dmattr(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_attrname_t __user *) DM_Parg(uap,5),/* attrnamep */
++ (size_t) DM_Uarg(uap,6), /* buflen */
++ (void __user *) DM_Parg(uap,7), /* bufp */
++ (size_t __user *) DM_Parg(uap,8));/* rlenp */
++
++ break;
++ case DM_GET_EVENTLIST:
++ error = dm_get_eventlist(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (u_int) DM_Uarg(uap,5), /* nelem */
++ (dm_eventset_t __user *) DM_Parg(uap,6),/* eventsetp */
++ (u_int __user *) DM_Parg(uap,7));/* nelemp */
++ break;
++ case DM_GET_EVENTS:
++ error = dm_get_events(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (u_int) DM_Uarg(uap,2), /* maxmsgs */
++ (u_int) DM_Uarg(uap,3), /* flags */
++ (size_t) DM_Uarg(uap,4), /* buflen */
++ (void __user *) DM_Parg(uap,5), /* bufp */
++ (size_t __user *) DM_Parg(uap,6));/* rlenp */
++ break;
++ case DM_GET_FILEATTR:
++ error = dm_get_fileattr(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (u_int) DM_Uarg(uap,5), /* mask */
++ (dm_stat_t __user *) DM_Parg(uap,6));/* statp */
++ break;
++ case DM_GET_MOUNTINFO:
++ error = dm_get_mountinfo(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (size_t) DM_Uarg(uap,5), /* buflen */
++ (void __user *) DM_Parg(uap,6), /* bufp */
++ (size_t __user *) DM_Parg(uap,7));/* rlenp */
++ break;
++ case DM_GET_REGION:
++ error = dm_get_region(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (u_int) DM_Uarg(uap,5), /* nelem */
++ (dm_region_t __user *) DM_Parg(uap,6), /* regbufp */
++ (u_int __user *) DM_Parg(uap,7));/* nelemp */
++ break;
++ case DM_GETALL_DISP:
++ error = dm_getall_disp(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (size_t) DM_Uarg(uap,2), /* buflen */
++ (void __user *) DM_Parg(uap,3), /* bufp */
++ (size_t __user *) DM_Parg(uap,4));/* rlenp */
++ break;
++ case DM_GETALL_DMATTR:
++ error = dm_getall_dmattr(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (size_t) DM_Uarg(uap,5), /* buflen */
++ (void __user *) DM_Parg(uap,6), /* bufp */
++ (size_t __user *) DM_Parg(uap,7));/* rlenp */
++ break;
++ case DM_GETALL_INHERIT:
++ error = dm_getall_inherit(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (u_int) DM_Uarg(uap,5), /* nelem */
++ (dm_inherit_t __user *)DM_Parg(uap,6), /* inheritbufp*/
++ (u_int __user *) DM_Parg(uap,7));/* nelemp */
++ break;
++ case DM_GETALL_SESSIONS:
++ error = dm_getall_sessions(
++ (u_int) DM_Uarg(uap,1), /* nelem */
++ (dm_sessid_t __user *) DM_Parg(uap,2), /* sidbufp */
++ (u_int __user *) DM_Parg(uap,3));/* nelemp */
++ break;
++ case DM_GETALL_TOKENS:
++ error = dm_getall_tokens(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (u_int) DM_Uarg(uap,2), /* nelem */
++ (dm_token_t __user *) DM_Parg(uap,3), /* tokenbufp */
++ (u_int __user *) DM_Parg(uap,4));/* nelemp */
++ break;
++ case DM_INIT_ATTRLOC:
++ error = dm_init_attrloc(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_attrloc_t __user *) DM_Parg(uap,5));/* locp */
++ break;
++ case DM_MKDIR_BY_HANDLE:
++ error = dm_mkdir_by_handle(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* dirhanp */
++ (size_t) DM_Uarg(uap,3), /* dirhlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (void __user *) DM_Parg(uap,5), /* hanp */
++ (size_t) DM_Uarg(uap,6), /* hlen */
++ (char __user *) DM_Parg(uap,7));/* cname */
++ break;
++ case DM_MOVE_EVENT:
++ error = dm_move_event(
++ (dm_sessid_t) DM_Uarg(uap,1), /* srcsid */
++ (dm_token_t) DM_Uarg(uap,2), /* token */
++ (dm_sessid_t) DM_Uarg(uap,3), /* targetsid */
++ (dm_token_t __user *) DM_Parg(uap,4));/* rtokenp */
++ break;
++ case DM_OBJ_REF_HOLD:
++ error = dm_obj_ref_hold(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (dm_token_t) DM_Uarg(uap,2), /* token */
++ (void __user *) DM_Parg(uap,3), /* hanp */
++ (size_t) DM_Uarg(uap,4));/* hlen */
++ break;
++ case DM_OBJ_REF_QUERY:
++ use_rvp = 1;
++ error = dm_obj_ref_query_rvp(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (dm_token_t) DM_Uarg(uap,2), /* token */
++ (void __user *) DM_Parg(uap,3), /* hanp */
++ (size_t) DM_Uarg(uap,4), /* hlen */
++ &rvp);
++ break;
++ case DM_OBJ_REF_RELE:
++ error = dm_obj_ref_rele(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (dm_token_t) DM_Uarg(uap,2), /* token */
++ (void __user *) DM_Parg(uap,3), /* hanp */
++ (size_t) DM_Uarg(uap,4));/* hlen */
++ break;
++ case DM_PATH_TO_FSHANDLE:
++ error = dm_path_to_fshdl(
++ (char __user *) DM_Parg(uap,1), /* path */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t __user *) DM_Parg(uap,3));/* hlenp */
++ break;
++ case DM_PATH_TO_HANDLE:
++ error = dm_path_to_hdl(
++ (char __user *) DM_Parg(uap,1), /* path */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t __user *) DM_Parg(uap,3));/* hlenp */
++ break;
++ case DM_PENDING:
++ error = dm_pending(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (dm_token_t) DM_Uarg(uap,2), /* token */
++ (dm_timestruct_t __user *) DM_Parg(uap,3));/* delay */
++ break;
++ case DM_PROBE_HOLE:
++ error = dm_probe_hole(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_off_t) DM_Uarg(uap,5), /* off */
++ (dm_size_t) DM_Uarg(uap,6), /* len */
++ (dm_off_t __user *) DM_Parg(uap,7), /* roffp */
++ (dm_size_t __user *) DM_Parg(uap,8));/* rlenp */
++ break;
++ case DM_PUNCH_HOLE:
++ error = dm_punch_hole(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_off_t) DM_Uarg(uap,5), /* off */
++ (dm_size_t) DM_Uarg(uap,6));/* len */
++ break;
++ case DM_QUERY_RIGHT:
++ error = dm_query_right(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_right_t __user *) DM_Parg(uap,5));/* rightp */
++ break;
++ case DM_QUERY_SESSION:
++ error = dm_query_session(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (size_t) DM_Uarg(uap,2), /* buflen */
++ (void __user *) DM_Parg(uap,3), /* bufp */
++ (size_t __user *) DM_Parg(uap,4));/* rlenp */
++ break;
++ case DM_READ_INVIS:
++ use_rvp = 1;
++ error = dm_read_invis_rvp(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_off_t) DM_Uarg(uap,5), /* off */
++ (dm_size_t) DM_Uarg(uap,6), /* len */
++ (void __user *) DM_Parg(uap,7), /* bufp */
++ &rvp);
++ break;
++ case DM_RELEASE_RIGHT:
++ error = dm_release_right(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4));/* token */
++ break;
++ case DM_REMOVE_DMATTR:
++ error = dm_remove_dmattr(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (int) DM_Uarg(uap,5), /* setdtime */
++ (dm_attrname_t __user *) DM_Parg(uap,6));/* attrnamep */
++ break;
++ case DM_REQUEST_RIGHT:
++ error = dm_request_right(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (u_int) DM_Uarg(uap,5), /* flags */
++ (dm_right_t) DM_Uarg(uap,6));/* right */
++ break;
++ case DM_RESPOND_EVENT:
++ error = dm_respond_event(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (dm_token_t) DM_Uarg(uap,2), /* token */
++ (dm_response_t) DM_Uarg(uap,3), /* response */
++ (int) DM_Uarg(uap,4), /* reterror */
++ (size_t) DM_Uarg(uap,5), /* buflen */
++ (void __user *) DM_Parg(uap,6));/* respbufp */
++ break;
++ case DM_SEND_MSG:
++ error = dm_send_msg(
++ (dm_sessid_t) DM_Uarg(uap,1), /* targetsid */
++ (dm_msgtype_t) DM_Uarg(uap,2), /* msgtype */
++ (size_t) DM_Uarg(uap,3), /* buflen */
++ (void __user *) DM_Parg(uap,4));/* bufp */
++ break;
++ case DM_SET_DISP:
++ error = dm_set_disp(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_eventset_t __user *) DM_Parg(uap,5),/* eventsetp */
++ (u_int) DM_Uarg(uap,6));/* maxevent */
++ break;
++ case DM_SET_DMATTR:
++ error = dm_set_dmattr(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_attrname_t __user *) DM_Parg(uap,5),/* attrnamep */
++ (int) DM_Uarg(uap,6), /* setdtime */
++ (size_t) DM_Uarg(uap,7), /* buflen */
++ (void __user *) DM_Parg(uap,8));/* bufp */
++ break;
++ case DM_SET_EVENTLIST:
++ error = dm_set_eventlist(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_eventset_t __user *) DM_Parg(uap,5),/* eventsetp */
++ (u_int) DM_Uarg(uap,6));/* maxevent */
++ break;
++ case DM_SET_FILEATTR:
++ error = dm_set_fileattr(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (u_int) DM_Uarg(uap,5), /* mask */
++ (dm_fileattr_t __user *)DM_Parg(uap,6));/* attrp */
++ break;
++ case DM_SET_INHERIT:
++ error = dm_set_inherit(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_attrname_t __user *)DM_Parg(uap,5),/* attrnamep */
++ (mode_t) DM_Uarg(uap,6));/* mode */
++ break;
++ case DM_SET_REGION:
++ error = dm_set_region(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (u_int) DM_Uarg(uap,5), /* nelem */
++ (dm_region_t __user *) DM_Parg(uap,6), /* regbufp */
++ (dm_boolean_t __user *) DM_Parg(uap,7));/* exactflagp */
++ break;
++ case DM_SET_RETURN_ON_DESTROY:
++ error = dm_set_return_on_destroy(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (dm_attrname_t __user *) DM_Parg(uap,5),/* attrnamep */
++ (dm_boolean_t) DM_Uarg(uap,6));/* enable */
++ break;
++ case DM_SYMLINK_BY_HANDLE:
++ error = dm_symlink_by_handle(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* dirhanp */
++ (size_t) DM_Uarg(uap,3), /* dirhlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (void __user *) DM_Parg(uap,5), /* hanp */
++ (size_t) DM_Uarg(uap,6), /* hlen */
++ (char __user *) DM_Parg(uap,7), /* cname */
++ (char __user *) DM_Parg(uap,8));/* path */
++ break;
++ case DM_SYNC_BY_HANDLE:
++ error = dm_sync_by_handle(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4));/* token */
++ break;
++ case DM_UPGRADE_RIGHT:
++ error = dm_upgrade_right(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4));/* token */
++ break;
++ case DM_WRITE_INVIS:
++ use_rvp = 1;
++ error = dm_write_invis_rvp(
++ (dm_sessid_t) DM_Uarg(uap,1), /* sid */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (dm_token_t) DM_Uarg(uap,4), /* token */
++ (int) DM_Uarg(uap,5), /* flags */
++ (dm_off_t) DM_Uarg(uap,6), /* off */
++ (dm_size_t) DM_Uarg(uap,7), /* len */
++ (void __user *) DM_Parg(uap,8), /* bufp */
++ &rvp);
++ break;
++ case DM_OPEN_BY_HANDLE:
++ use_rvp = 1;
++ error = dm_open_by_handle_rvp(
++ (unsigned int) DM_Uarg(uap,1), /* fd */
++ (void __user *) DM_Parg(uap,2), /* hanp */
++ (size_t) DM_Uarg(uap,3), /* hlen */
++ (int) DM_Uarg(uap,4), /* flags */
++ &rvp);
++ break;
++ default:
++ error = -ENOSYS;
++ break;
++ }
++
++ lock_kernel();
++
++ /* If it was an *_rvp() function, then
++ if error==0, return |rvp|
++ */
++ if( use_rvp && (error == 0) )
++ return rvp;
++ else
++ return error;
++}
++
++
++
++static int
++dmapi_open(struct inode *inode, struct file *file)
++{
++ return 0;
++}
++
++
++static int
++dmapi_release(struct inode *inode, struct file *file)
++{
++ return 0;
++}
++
++
++/* say hello, and let me know the device is hooked up */
++static ssize_t
++dmapi_dump(struct file *file, char __user *buf, size_t count, loff_t *ppos)
++{
++ char tmp[50];
++ int len;
++ if( *ppos == 0 ){
++ len = sprintf( tmp, "# " DM_VER_STR_CONTENTS "\n" );
++ if( copy_to_user(buf, tmp, len) )
++ return -EFAULT;
++ *ppos += 1;
++ return len;
++ }
++ return 0;
++}
++
++static struct file_operations dmapi_fops = {
++ .open = dmapi_open,
++ .ioctl = dmapi_ioctl,
++ .read = dmapi_dump,
++ .release = dmapi_release
++};
++
++static struct miscdevice dmapi_dev = {
++ .minor = MISC_DYNAMIC_MINOR,
++ .name = "dmapi",
++ .fops = &dmapi_fops
++};
++
++
++
++#ifdef CONFIG_PROC_FS
++static int
++dmapi_summary(char *buffer, char **start, off_t offset,
++ int count, int *eof, void *data)
++{
++ int len;
++
++ extern u_int dm_sessions_active;
++ extern dm_sessid_t dm_next_sessid;
++ extern dm_token_t dm_next_token;
++ extern dm_sequence_t dm_next_sequence;
++ extern int dm_fsys_cnt;
++
++#define CHKFULL if(len >= count) break;
++#define ADDBUF(a,b) len += sprintf(buffer + len, a, b); CHKFULL;
++
++ len=0;
++ while(1){
++ ADDBUF("dm_sessions_active=%u\n", dm_sessions_active);
++ ADDBUF("dm_next_sessid=%d\n", (int)dm_next_sessid);
++ ADDBUF("dm_next_token=%d\n", (int)dm_next_token);
++ ADDBUF("dm_next_sequence=%u\n", (u_int)dm_next_sequence);
++ ADDBUF("dm_fsys_cnt=%d\n", dm_fsys_cnt);
++
++ break;
++ }
++
++ if (offset >= len) {
++ *start = buffer;
++ *eof = 1;
++ return 0;
++ }
++ *start = buffer + offset;
++ if ((len -= offset) > count)
++ return count;
++ *eof = 1;
++
++ return len;
++}
++#endif
++
++
++static void __init
++dmapi_init_procfs(int dmapi_minor)
++{
++#ifdef CONFIG_PROC_FS
++ struct proc_dir_entry *entry;
++
++ if ((entry = proc_mkdir( DMAPI_DBG_PROCFS, NULL)) == NULL )
++ return;
++ entry->owner = THIS_MODULE;
++ entry->mode = S_IFDIR | S_IRUSR | S_IXUSR;
++
++ if ((entry = proc_mkdir( DMAPI_DBG_PROCFS "/fsreg", NULL)) == NULL )
++ return;
++ entry->owner = THIS_MODULE;
++
++ if ((entry = proc_mkdir( DMAPI_DBG_PROCFS "/sessions", NULL)) == NULL )
++ return;
++ entry->owner = THIS_MODULE;
++
++ entry = create_proc_read_entry( DMAPI_DBG_PROCFS "/summary",
++ 0, NULL, dmapi_summary, NULL);
++ entry->owner = THIS_MODULE;
++#endif
++}
++
++#if 0
++static void __exit
++dmapi_cleanup_procfs(void)
++{
++#ifdef CONFIG_PROC_FS
++ remove_proc_entry( DMAPI_DBG_PROCFS "/summary", NULL);
++ remove_proc_entry( DMAPI_DBG_PROCFS "/fsreg", NULL);
++ remove_proc_entry( DMAPI_DBG_PROCFS "/sessions", NULL);
++ remove_proc_entry( DMAPI_DBG_PROCFS, NULL);
++#endif
++}
++#endif
++
++int __init dmapi_init(void)
++{
++ int ret;
++
++ dm_tokdata_cachep = kmem_cache_create("dm_tokdata",
++ sizeof(struct dm_tokdata), 0, 0, NULL);
++ if (dm_tokdata_cachep == NULL)
++ goto out;
++
++ dm_fsreg_cachep = kmem_cache_create("dm_fsreg",
++ sizeof(struct dm_fsreg), 0, 0, NULL);
++ if (dm_fsreg_cachep == NULL)
++ goto out_free_tokdata_cachep;
++
++ dm_session_cachep = kmem_cache_create("dm_session",
++ sizeof(struct dm_session), 0, 0, NULL);
++ if (dm_session_cachep == NULL)
++ goto out_free_fsreg_cachep;
++
++ dm_fsys_map_cachep = kmem_cache_create("dm_fsys_map",
++ sizeof(dm_vector_map_t), 0, 0, NULL);
++ if (dm_fsys_map_cachep == NULL)
++ goto out_free_session_cachep;
++ dm_fsys_vptr_cachep = kmem_cache_create("dm_fsys_vptr",
++ sizeof(dm_fsys_vector_t), 0, 0, NULL);
++ if (dm_fsys_vptr_cachep == NULL)
++ goto out_free_fsys_map_cachep;
++
++ ret = misc_register(&dmapi_dev);
++ if (ret) {
++ printk(KERN_ERR "dmapi_init: misc_register returned %d\n", ret);
++ goto out_free_fsys_vptr_cachep;
++ }
++
++ dmapi_init_procfs(dmapi_dev.minor);
++ return 0;
++
++ out_free_fsys_vptr_cachep:
++ kmem_cache_destroy(dm_fsys_vptr_cachep);
++ out_free_fsys_map_cachep:
++ kmem_cache_destroy(dm_fsys_map_cachep);
++ out_free_session_cachep:
++ kmem_cache_destroy(dm_session_cachep);
++ out_free_fsreg_cachep:
++ kmem_cache_destroy(dm_fsreg_cachep);
++ out_free_tokdata_cachep:
++ kmem_cache_destroy(dm_tokdata_cachep);
++ out:
++ return -ENOMEM;
++}
++
++#if 0
++void __exit dmapi_uninit(void)
++{
++ misc_deregister(&dmapi_dev);
++ dmapi_cleanup_procfs();
++ kmem_cache_destroy(dm_tokdata_cachep);
++ kmem_cache_destroy(dm_fsreg_cachep);
++ kmem_cache_destroy(dm_session_cachep);
++ kmem_cache_destroy(dm_fsys_map_cachep);
++ kmem_cache_destroy(dm_fsys_vptr_cachep);
++}
++#endif
++
++module_init(dmapi_init);
++/*module_exit(dmapi_uninit);*/ /* Some other day */
++
++MODULE_AUTHOR("Silicon Graphics, Inc.");
++MODULE_DESCRIPTION("SGI Data Migration Subsystem");
++MODULE_LICENSE("GPL");
++
++EXPORT_SYMBOL(dm_send_mount_event);
++EXPORT_SYMBOL(dm_send_namesp_event);
++EXPORT_SYMBOL(dm_send_unmount_event);
++EXPORT_SYMBOL(dm_send_data_event);
++EXPORT_SYMBOL(dm_send_destroy_event);
++EXPORT_SYMBOL(dm_ip_to_handle);
++EXPORT_SYMBOL(dmapi_register);
++EXPORT_SYMBOL(dmapi_unregister);
++EXPORT_SYMBOL(dmapi_registered);
++EXPORT_SYMBOL(dm_release_threads);
+Index: linux-2.6.26/fs/dmapi/Makefile
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/Makefile
+@@ -0,0 +1,53 @@
++#
++# Copyright (c) 2000-2003 Silicon Graphics, Inc. All Rights Reserved.
++#
++# This program is free software; you can redistribute it and/or modify it
++# under the terms of version 2 of the GNU General Public License as
++# published by the Free Software Foundation.
++#
++# This program is distributed in the hope that it would be useful, but
++# WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++#
++# Further, this software is distributed without any warranty that it is
++# free of the rightful claim of any third person regarding infringement
++# or the like. Any license provided herein, whether implied or
++# otherwise, applies only to this software file. Patent licenses, if
++# any, provided herein do not apply to combinations of this program with
++# other software, or any other product whatsoever.
++#
++# You should have received a copy of the GNU General Public License along
++# with this program; if not, write the Free Software Foundation, Inc., 59
++# Temple Place - Suite 330, Boston MA 02111-1307, USA.
++#
++# Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++# Mountain View, CA 94043, or:
++#
++# http://www.sgi.com
++#
++# For further information regarding this notice, see:
++#
++# http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++#
++
++ifeq ($(CONFIG_DMAPI_DEBUG),y)
++ EXTRA_CFLAGS += -DDEBUG
++ EXTRA_CFLAGS += -g
++endif
++
++obj-$(CONFIG_DMAPI) += dmapi.o
++
++dmapi-y += dmapi_sysent.o \
++ dmapi_attr.o \
++ dmapi_config.o \
++ dmapi_bulkattr.o \
++ dmapi_dmattr.o \
++ dmapi_event.o \
++ dmapi_handle.o \
++ dmapi_hole.o \
++ dmapi_io.o \
++ dmapi_mountinfo.o \
++ dmapi_region.o \
++ dmapi_register.o \
++ dmapi_right.o \
++ dmapi_session.o
+Index: linux-2.6.26/fs/dmapi/Status
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/Status
+@@ -0,0 +1,128 @@
++Jan21,04 - dm_get_bulkall is now implemented. roehrich
++
++for linux:
++
++
++68 external interfaces in libdm
++
++ 56 of those interfaces go through to dmi(), the kernel side of DMAPI
++
++
++
++Functions known to work
++----------------------------------------------
++
++dm_create_session
++dm_create_userevent
++dm_destroy_session
++dm_getall_sessions
++dm_getall_tokens
++dm_get_allocinfo
++dm_get_bulkall
++dm_get_bulkattr
++dm_get_config_events
++dm_get_dmattr
++dm_get_eventlist
++dm_get_events
++dm_get_fileattr
++dm_get_region
++dm_handle_free
++dm_init_attrloc
++dm_init_service
++dm_obj_ref_hold
++dm_obj_ref_query
++dm_obj_ref_rele
++dm_path_to_fshandle
++dm_path_to_handle
++dm_punch_hole
++dm_query_session
++dm_read_invis
++dm_remove_dmattr
++dm_respond_event
++dm_send_msg
++dm_set_disp
++dm_set_dmattr
++dm_set_eventlist
++dm_set_fileattr
++dm_set_region
++dm_sync_by_handle
++dm_write_invis
++35
++
++Functions that seem to work (would like more rigorous test case)
++------------------------------------------
++
++dm_pending
++dm_probe_hole - one test case of test_hole.c fails
++dm_request_right
++3
++
++Functions untested but probably work
++----------------------------------------------
++
++dm_find_eventmsg
++dm_handle_cmp
++dm_handle_to_fshandle
++dm_handle_to_ino
++dm_release_right
++5
++
++Functions that do not work
++-----------------------------------------
++
++dm_get_dioinfo - directio not implemented
++1
++
++Functions not supported in SGI DMAPI
++-------------------------------------------------------------
++
++dm_clear_inherit
++dm_create_by_handle
++dm_getall_inherit
++dm_mkdir_by_handle
++dm_set_inherit
++dm_symlink_by_handle
++
++
++
++
++Functions that seem to work (would like more rigorous test case)
++----------------------------------------------------------------
++
++dm_get_config
++dm_downgrade_right
++dm_get_mountinfo
++dm_set_return_on_destory
++dm_upgrade_right
++
++
++
++Functions that do not work
++-----------------------------------------------------------------
++
++dm_fd_to_handle - Irix getf not implemented on linux
++dm_get_dirattrs - null pointer reference
++dm_handle_to_path
++dm_getall_dmattr - needs a copy_from_user in place of useracc
++
++
++Functions that are untested, but probably work
++-----------------------------------------------------------------
++
++dm_getall_disp
++dm_handle_hash
++dm_handle_is_valid
++dm_handle_to_fsid
++dm_handle_to_igen
++dm_make_fshandle
++dm_make_handle
++dm_move_event
++dm_query_right
++
++
++
++Other things not working
++----------------------------------
++
++- read/write events for memory-mapped I/O?
++
+Index: linux-2.6.26/fs/dmapi/sv.h
+===================================================================
+--- /dev/null
++++ linux-2.6.26/fs/dmapi/sv.h
+@@ -0,0 +1,89 @@
++/*
++ * Copyright (c) 2000-2002 Silicon Graphics, Inc. All Rights Reserved.
++ *
++ * This program is free software; you can redistribute it and/or modify it
++ * under the terms of version 2 of the GNU General Public License as
++ * published by the Free Software Foundation.
++ *
++ * This program is distributed in the hope that it would be useful, but
++ * WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
++ *
++ * Further, this software is distributed without any warranty that it is
++ * free of the rightful claim of any third person regarding infringement
++ * or the like. Any license provided herein, whether implied or
++ * otherwise, applies only to this software file. Patent licenses, if
++ * any, provided herein do not apply to combinations of this program with
++ * other software, or any other product whatsoever.
++ *
++ * You should have received a copy of the GNU General Public License along
++ * with this program; if not, write the Free Software Foundation, Inc., 59
++ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
++ *
++ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
++ * Mountain View, CA 94043, or:
++ *
++ * http://www.sgi.com
++ *
++ * For further information regarding this notice, see:
++ *
++ * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
++ */
++#ifndef __DMAPI_SV_H__
++#define __DMAPI_SV_H__
++
++#include <linux/wait.h>
++#include <linux/sched.h>
++#include <linux/spinlock.h>
++
++/*
++ * Synchronisation variables.
++ *
++ * (Parameters "pri", "svf" and "rts" are not implemented)
++ */
++
++typedef struct sv_s {
++ wait_queue_head_t waiters;
++} sv_t;
++
++#define SV_FIFO 0x0 /* sv_t is FIFO type */
++#define SV_LIFO 0x2 /* sv_t is LIFO type */
++#define SV_PRIO 0x4 /* sv_t is PRIO type */
++#define SV_KEYED 0x6 /* sv_t is KEYED type */
++#define SV_DEFAULT SV_FIFO
++
++
++static inline void _sv_wait(sv_t *sv, spinlock_t *lock, int state,
++ unsigned long timeout)
++{
++ DECLARE_WAITQUEUE(wait, current);
++
++ add_wait_queue_exclusive(&sv->waiters, &wait);
++ __set_current_state(state);
++ spin_unlock(lock);
++
++ schedule_timeout(timeout);
++
++ remove_wait_queue(&sv->waiters, &wait);
++}
++
++#define init_sv(sv,type,name,flag) \
++ init_waitqueue_head(&(sv)->waiters)
++#define sv_init(sv,flag,name) \
++ init_waitqueue_head(&(sv)->waiters)
++#define sv_destroy(sv) \
++ /*NOTHING*/
++#define sv_wait(sv, pri, lock, s) \
++ _sv_wait(sv, lock, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT)
++#define sv_wait_sig(sv, pri, lock, s) \
++ _sv_wait(sv, lock, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT)
++#define sv_timedwait(sv, pri, lock, s, svf, ts, rts) \
++ _sv_wait(sv, lock, TASK_UNINTERRUPTIBLE, timespec_to_jiffies(ts))
++#define sv_timedwait_sig(sv, pri, lock, s, svf, ts, rts) \
++ _sv_wait(sv, lock, TASK_INTERRUPTIBLE, timespec_to_jiffies(ts))
++#define sv_signal(sv) \
++ wake_up(&(sv)->waiters)
++#define sv_broadcast(sv) \
++ wake_up_all(&(sv)->waiters)
++
++#endif /* __DMAPI_SV_H__ */
projects / people / pmueller / ipfire-2.x.git / blobdiff