Whamcloud - gitweb
land 0.5.20.3 b_devel onto HEAD (b_devel will remain)
authorpschwan <pschwan>
Sun, 2 Mar 2003 05:23:24 +0000 (05:23 +0000)
committerpschwan <pschwan>
Sun, 2 Mar 2003 05:23:24 +0000 (05:23 +0000)
163 files changed:
lustre/ChangeLog
lustre/Makefile.am
lustre/Rules
lustre/archdep.m4
lustre/autogen.sh
lustre/cobd/cache_obd.c
lustre/cobd/lproc_cache.c
lustre/conf/lustre.dtd
lustre/conf/lustre2ldif.xsl
lustre/conf/top.ldif
lustre/configure.in
lustre/extN/Makefile.am
lustre/extN/ext3-2.4-ino_t.diff [new file with mode: 0644]
lustre/extN/ext3-2.4.18-ino_sb_macro.diff
lustre/extN/ext3-largefile.diff [new file with mode: 0644]
lustre/extN/extN-san.diff [new file with mode: 0644]
lustre/include/liblustre.h [new file with mode: 0644]
lustre/include/linux/lprocfs_status.h
lustre/include/linux/lustre_dlm.h
lustre/include/linux/lustre_export.h
lustre/include/linux/lustre_fsfilt.h
lustre/include/linux/lustre_handles.h [new file with mode: 0644]
lustre/include/linux/lustre_idl.h
lustre/include/linux/lustre_import.h
lustre/include/linux/lustre_lib.h
lustre/include/linux/lustre_lite.h
lustre/include/linux/lustre_mds.h
lustre/include/linux/lustre_net.h
lustre/include/linux/obd.h
lustre/include/linux/obd_class.h
lustre/include/linux/obd_filter.h
lustre/include/linux/obd_lov.h
lustre/include/linux/obd_ost.h
lustre/include/linux/obd_support.h
lustre/kernel_patches/patches/iod-rmap-exports.patch
lustre/kernel_patches/patches/lustre-2.5.patch
lustre/kernel_patches/patches/lustre_version.patch
lustre/kernel_patches/patches/vfs_intent-2.4.18-18.patch
lustre/kernel_patches/patches/vfs_intent_hp.patch
lustre/kernel_patches/pc/lustre-2.5.pc [new file with mode: 0644]
lustre/kernel_patches/pc/vfs_intent-2.4.18-18.pc
lustre/kernel_patches/series/vanilla-2.5 [new file with mode: 0644]
lustre/kernel_patches/which_patch
lustre/ldlm/Makefile.am
lustre/ldlm/l_lock.c
lustre/ldlm/ldlm_extent.c
lustre/ldlm/ldlm_lock.c
lustre/ldlm/ldlm_lockd.c
lustre/ldlm/ldlm_request.c
lustre/ldlm/ldlm_resource.c
lustre/lib/client.c
lustre/lib/mds_updates.c
lustre/lib/obd_pack.c
lustre/lib/simple.c
lustre/lib/target.c
lustre/liblustre/.cvsignore [new file with mode: 0644]
lustre/liblustre/Makefile.am [new file with mode: 0644]
lustre/liblustre/libtest.c [new file with mode: 0644]
lustre/llite/commit_callback.c
lustre/llite/dcache.c
lustre/llite/dir.c
lustre/llite/file.c
lustre/llite/lproc_llite.c
lustre/llite/namei.c
lustre/llite/rw.c
lustre/llite/super.c
lustre/llite/super25.c
lustre/llite/symlink.c
lustre/llite/sysctl.c
lustre/lov/Makefile.am
lustre/lov/lov_obd.c
lustre/lov/lov_pack.c
lustre/lov/lproc_lov.c
lustre/mdc/lproc_mdc.c
lustre/mdc/mdc_reint.c
lustre/mdc/mdc_request.c
lustre/mds/handler.c
lustre/mds/lproc_mds.c
lustre/mds/mds_fs.c
lustre/mds/mds_lov.c
lustre/mds/mds_open.c
lustre/mds/mds_reint.c
lustre/obdclass/Makefile.am
lustre/obdclass/class_obd.c
lustre/obdclass/debug.c
lustre/obdclass/fsfilt_ext3.c
lustre/obdclass/fsfilt_extN.c
lustre/obdclass/fsfilt_reiserfs.c
lustre/obdclass/genops.c
lustre/obdclass/lprocfs_status.c
lustre/obdclass/lustre_handles.c [new file with mode: 0644]
lustre/obdclass/lustre_peer.c [new file with mode: 0644]
lustre/obdclass/statfs_pack.c
lustre/obdclass/sysctl.c
lustre/obdclass/uuid.c
lustre/obdecho/Makefile.am
lustre/obdecho/echo.c
lustre/obdecho/echo_client.c
lustre/obdecho/lproc_echo.c
lustre/obdfilter/Makefile.am
lustre/obdfilter/filter.c
lustre/obdfilter/lproc_obdfilter.c
lustre/osc/Makefile.am
lustre/osc/lproc_osc.c
lustre/osc/osc_request.c
lustre/ost/ost_handler.c
lustre/ptlbd/client.c
lustre/ptlbd/rpc.c
lustre/ptlbd/server.c
lustre/ptlrpc/Makefile.am
lustre/ptlrpc/client.c
lustre/ptlrpc/connection.c
lustre/ptlrpc/events.c
lustre/ptlrpc/niobuf.c
lustre/ptlrpc/pack_generic.c
lustre/ptlrpc/recovd.c
lustre/ptlrpc/recover.c
lustre/ptlrpc/rpc.c
lustre/ptlrpc/service.c
lustre/scripts/lustre.spec.in
lustre/tests/.cvsignore
lustre/tests/Makefile.am
lustre/tests/acceptance-metadata-double.sh [new file with mode: 0644]
lustre/tests/acceptance-metadata-single.sh
lustre/tests/acceptance-small.sh
lustre/tests/ba-echo.sh
lustre/tests/ba-mount.sh
lustre/tests/compile.sh [new file with mode: 0644]
lustre/tests/directio.c
lustre/tests/lkcdmap
lustre/tests/llmount.sh
lustre/tests/local.sh
lustre/tests/mcr-individual-ost-nogw-config.sh
lustre/tests/mcr-mds-failover-config.sh
lustre/tests/mcr-routed-config.sh
lustre/tests/mcr.sh
lustre/tests/mcrlov.sh
lustre/tests/mlink.c [new file with mode: 0755]
lustre/tests/mount2.sh
lustre/tests/open_delay.c
lustre/tests/recovery-cleanup.sh [new file with mode: 0755]
lustre/tests/recovery-small.sh
lustre/tests/runiozone
lustre/tests/runtests
lustre/tests/sanity.sh
lustre/tests/statmany.c
lustre/tests/statone.c [new file with mode: 0644]
lustre/tests/tchmod.c
lustre/tests/testreq.c
lustre/tests/uml.sh
lustre/tests/wantedi.c
lustre/utils/.cvsignore
lustre/utils/Makefile.am
lustre/utils/lconf.in
lustre/utils/lctl.c
lustre/utils/lfind.c
lustre/utils/lmc
lustre/utils/obd.c
lustre/utils/obdbarrier.c
lustre/utils/obdctl.h
lustre/utils/obdio.c
lustre/utils/obdiolib.c
lustre/utils/obdstat.c

index 05209b5..61193c7 100644 (file)
@@ -1,8 +1,25 @@
 TBD
-       * version v0_5_21
-       * bug fixes
-        - workaround for gcc 3.2, which has macro-argument issues (850)
-        - lmc/lconf syntax change for OST UUIDs
+       * version v0_5_21
+       * bug fixes
+       - LDLM_DEBUG macro fix, for gcc 3.2 (850)
+       - failed open()s could cause deadlock; fixed (867, 869)
+       - stop cancelling OST locks when files are closed (481)
+       - overlapping XID spaces caused network corruption (851, 853)
+       - fix unsafe fsfilt counter arithmetic; change to atomic_t
+       - setattr_raw added, to do single-RPC, server-side setattrs
+       - lmc/lconf syntax change for OST UUIDs
+       - fix crashy race condition between ptlrpc_free_req and osc_close
+       - don't use request in mdc_enqueue if we hit a timeout (889)
+       - don't set the inode i_size for regular files from the MDS (896)
+       - handle out of order completion AST (842)
+       - don't LBUG if a lock request times out after receiving AST (913)
+       - avoid d_rehash race in ll_find_alias by rehashing inside dcache_lock
+       - if a bad lock AST arrives, send an error instead of dropping entirely
+       - return 0 from revalidate2 if ll_intent_lock returns -EINTR (912)
+       - fix leak in bulk IO when only partially completed (899, 900, 926)
+       * protocol changes
+       - READPAGE and SETATTRs which don't take server-side locks get
+         their own portal
 
 2003-02-11  Phil Schwan  <phil@clusterfs.com>
        * version v0_5_20
@@ -31,7 +48,7 @@ TBD
         - client verifies file size before zeroing page past EOF (445)
         - OST now writes last allocated objid to disk with allocation (108)
         - LOV on echo now works (409)
-        * protocol changes
+       * protocol changes
         - mds_reint_unlink sends a new buffer, with the EA included.  this
           buffer is only valid if body->valid & OBD_MD_FLEASIZE, which is only
           set if a regular file was being unlinked, and it was the last link
index 3edac96..f16f126 100644 (file)
@@ -6,14 +6,20 @@
 AUTOMAKE_OPTIONS = foreign
 
 if LINUX25
-DIRS24 = mds
+DIRS24 = 
 else
-DIRS24 = extN mds
+DIRS24 = extN ptlbd
 endif
 
-# NOTE: keep extN before mds and obdfilter
-SUBDIRS = $(DIRS24) obdclass utils ptlrpc ldlm lib obdfilter mdc osc ost llite
-SUBDIRS+= obdecho lov cobd ptlbd tests doc scripts conf
+if LIBLUSTRE
+SUBDIRS = lov obdclass ptlrpc obdecho ldlm osc liblustre utils
+else
+# NOTE: keep extN before obdclass, mds, and obdfilter.  Keep obdclass as early
+# as possible, to have the best chance at stopping with "wrong kernel version"
+# instead of some related build failure.
+SUBDIRS = $(DIRS24) obdclass mds utils ptlrpc ldlm lib obdfilter mdc osc ost
+SUBDIRS+= llite obdecho lov cobd tests doc scripts conf
+endif
 
 DIST_SUBDIRS = $(SUBDIRS)
 EXTRA_DIST = BUGS FDL Rules include archdep.m4 kernel_patches
index 069e89a..d4e5ed7 100644 (file)
@@ -10,6 +10,7 @@
 #  name_SOURCES = my.c files.c
 #  include $(top_srcdir)/Rules
 
+
 $(MODULE).o: $($(MODULE)_OBJECTS)
        $(LD) -m "`$(LD) --help | awk '/supported emulations/ {print $$4}'`" -r -o $(MODULE).o $($(MODULE)_OBJECTS)
 
index 58a6576..2bdd785 100644 (file)
@@ -1,4 +1,10 @@
+AC_ARG_WITH(lib, [  --with-lib compile lustre library], host_cpu="lib")
+
 AC_MSG_CHECKING(if you are running user mode linux for $host_cpu ...)
+if test $host_cpu = "lib" ; then 
+        host_cpu="lib"
+       AC_MSG_RESULT(no building Lustre library)
+else
 if test -e $LINUX/include/asm-um ; then
 if test  X`ls -id $LINUX/include/asm/ | awk '{print $1}'` = X`ls -id $LINUX/include/asm-um | awk '{print $1}'` ; then
        host_cpu="um";
@@ -10,19 +16,41 @@ fi
 else 
         AC_MSG_RESULT(no (asm-um missing))
 fi
+fi
 
 AC_MSG_CHECKING(setting make flags system architecture: )
 case ${host_cpu} in
+       lib )
+       AC_MSG_RESULT($host_cpu)
+       KCFLAGS='-g -Wall '
+       KCPPFLAGS='-D__arch_lib__ '
+        MOD_LINK=elf_i386
+;;
        um )
        AC_MSG_RESULT($host_cpu)
        KCFLAGS='-g -Wall -pipe -Wno-trigraphs -Wstrict-prototypes -fno-strict-aliasing -fno-common '
-       KCPPFLAGS='-D__KERNEL__ -U__i386__ -Ui386 -DUM_FASTCALL -D__arch_um__ -DSUBARCH="i386" -DNESTING=0 -D_LARGEFILE64_SOURCE  -Derrno=kernel_errno -DPATCHLEVEL=4 -DMODULE -I$(LINUX)/arch/um/include '
+        case ${linux25} in
+                yes )
+                KCPPFLAGS='-D__KERNEL__ -U__i386__ -Ui386 -DUM_FASTCALL -D__arch_um__ -DSUBARCH="i386" -DNESTING=0 -D_LARGEFILE64_SOURCE  -Derrno=kernel_errno -DPATCHLEVEL=4 -DMODULE -I$(LINUX)/arch/um/include -I$(LINUX)/arch/um/kernel/tt/include -O2 -nostdinc -iwithprefix include -DKBUILD_BASENAME=$(MODULE) -DKBUILD_MODNAME=$(MODULE) '
+        ;;
+                * )
+               KCPPFLAGS='-D__KERNEL__ -U__i386__ -Ui386 -DUM_FASTCALL -D__arch_um__ -DSUBARCH="i386" -DNESTING=0 -D_LARGEFILE64_SOURCE  -Derrno=kernel_errno -DPATCHLEVEL=4 -DMODULE -I$(LINUX)/arch/um/include '
+       ;;
+       esac
+
         MOD_LINK=elf_i386
 ;;
        i*86 )
        AC_MSG_RESULT($host_cpu)
         KCFLAGS='-g -O2 -Wall -Wstrict-prototypes -pipe'
-        KCPPFLAGS='-D__KERNEL__ -DMODULE '
+        case ${linux25} in
+                yes )
+               KCPPFLAGS='-D__KERNEL__ -DMODULE -march=i686 -I$(LINUX)/include/asm-i386/mach-default -nostdinc -iwithprefix include ' 
+        ;;
+                * )
+               KCPPFLAGS='-D__KERNEL__ -DMODULE '
+       ;;
+       esac
         MOD_LINK=elf_i386
 ;;
 
@@ -74,6 +102,7 @@ case ${host_cpu} in
 ;;
 esac
 
+if test $host_cpu != lib ; then 
 AC_MSG_CHECKING(for MODVERSIONS)
 if egrep -e 'MODVERSIONS.*1' $LINUX/include/linux/autoconf.h >/dev/null 2>&1;
 then
@@ -92,6 +121,7 @@ else
        SMPFLAG=
        AC_MSG_RESULT(no)
 fi
+fi
 
 CFLAGS="$KCFLAGS $MFLAGS"
 ARCHCPPFLAGS="$KCPPFLAGS"
index 9accad4..087ff09 100644 (file)
@@ -2,5 +2,5 @@
 
 find . -type d -name .deps | xargs rm -rf
 aclocal &&
-automake --add-missing &&
+${AUTOMAKE:-automake} --add-missing &&
 ${AUTOCONF:-autoconf}
index 72a05cc..67b4e62 100644 (file)
 
 #define DEBUG_SUBSYSTEM S_COBD
 
+#include <linux/version.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+#include <linux/init.h>
+#endif
 #include <linux/obd_support.h>
 #include <linux/lustre_lib.h>
 #include <linux/lustre_net.h>
index 5170829..7e5c267 100644 (file)
@@ -33,16 +33,20 @@ static int rd_target(char *page, char **start, off_t off, int count,
                      int *eof, void *data)
 {
         struct obd_device    *dev = (struct obd_device*)data;
-       struct lustre_handle *conn = &dev->u.cobd.cobd_target;
+       struct lustre_handle *conn;
        struct obd_export    *exp;
        int    rc;
 
+        LASSERT(dev != NULL);
+        conn = &dev->u.cobd.cobd_target;
+
        if ((dev->obd_flags & OBD_SET_UP) == 0)
                rc = snprintf (page, count, "not set up\n");
        else {
                exp = class_conn2export (conn);
                LASSERT(exp != NULL);
-               rc = snprintf(page, count, "%s\n", exp->exp_obd->obd_uuid.uuid);
+               rc = snprintf(page, count, "%s\n", 
+                              exp->exp_obd->obd_uuid.uuid);
        }
        return (rc);
 }
@@ -51,16 +55,20 @@ static int rd_cache(char *page, char **start, off_t off, int count,
                     int *eof, void *data)
 {
         struct obd_device    *dev = (struct obd_device*)data;
-       struct lustre_handle *conn = &dev->u.cobd.cobd_cache;
+       struct lustre_handle *conn;
        struct obd_export    *exp;
        int    rc;
 
+        LASSERT(dev != NULL);
+        conn = &dev->u.cobd.cobd_cache;
+
        if ((dev->obd_flags & OBD_SET_UP) == 0)
                rc = snprintf (page, count, "not set up\n");
        else {
                exp = class_conn2export (conn);
                LASSERT (exp != NULL);
-               rc = snprintf(page, count, "%s\n", exp->exp_obd->obd_uuid.uuid);
+               rc = snprintf(page, count, "%s\n", 
+                              exp->exp_obd->obd_uuid.uuid);
        }
        return (rc);
 }
index 73f7c95..8d575a6 100644 (file)
 <!ENTITY % objref.attr    "uuidref CDATA #REQUIRED">
 
 <!-- main elements -->
-<!ELEMENT lustre (node | profile | mountpoint | ldlm | echoclient |
-                  mds | obd | ost | lov | lovconfig)*>
+<!ELEMENT lustre (node | profile | mountpoint | ldlm | ptlrpc |echoclient |
+                  mds | mdsdev| ost | osd | lov | lovconfig)*>
 
-<!ELEMENT node (network | profile_ref)*>
+<!ELEMENT node (network | routetbl | profile_ref)*>
 <!ATTLIST node %object.attr;
                router CDATA #IMPLIED>
                
@@ -29,9 +29,9 @@
                 lo CDATA #REQUIRED
                 hi CDATA #IMPLIED >
 
-<!ELEMENT profile (ldlm_ref | network_ref | obd_ref | ost_ref |
-                   echoclient_ref | mdsdev_ref | lov_ref |
-                   lovconfig_ref| mountpoint_ref)*>
+<!ELEMENT profile (ldlm_ref | ptlrpc_ref | network_ref | routetbl_ref |
+                   osd_ref | mdsdev_ref | lovconfig_ref|
+                   echoclient_ref | mountpoint_ref)*>
 <!ATTLIST profile %object.attr;>
 
 <!ELEMENT mountpoint (path | fileset | mds_ref | obd_ref)*>
 <!ELEMENT ldlm EMPTY>
 <!ATTLIST ldlm %object.attr;>
 
-<!ELEMENT obd (fstype | devpath | devsize | autoformat | active_ref)*>
-<!ATTLIST obd %object.attr; 
-              obdtype (obdfilter | obdecho) 'obdfilter'>
+<!ELEMENT ptlrpc EMPTY>
+<!ATTLIST ptlrpc %object.attr;>
 
-<!ELEMENT ost (network_ref | obd_ref | failover_ref)*>
+<!ELEMENT osd (fstype | devpath | devsize | autoformat | 
+               target_ref | node_ref)*>
+<!ATTLIST osd %object.attr; 
+              osdtype (obdfilter | obdecho) 'obdfilter'>
+
+<!ELEMENT ost (active_ref)*>
 <!ATTLIST ost %object.attr;>
 
-<!ELEMENT mds (active_ref)*>
+<!ELEMENT mds (active_ref | lovconfig_ref)*>
 <!ATTLIST mds %object.attr;>
 
 <!ELEMENT mdsdev (fstype | devpath | devsize | autoformat | 
-                  mds_ref | network_ref )*>
+                  target_ref | node_ref )*>
 <!ATTLIST mdsdev %object.attr;>
 
 <!ELEMENT lov (mds_ref |(obd_ref)+)*>
@@ -71,8 +75,8 @@
 <!ELEMENT fstype        %object.content;>
 <!ELEMENT nid           %object.content;>
 <!ELEMENT port          %object.content;>
-<!ELEMENT send_mem      %object.content;>
-<!ELEMENT recv_mem      %object.content;>
+<!ELEMENT sendmem      %object.content;>
+<!ELEMENT recvmem      %object.content;>
 <!ELEMENT autoformat    %object.content;>
 <!ELEMENT activetarget  %object.content;>
 <!ELEMENT devpath       %object.content;>
 <!-- object reference tag elements -->
 <!ELEMENT network_ref     %objref.content;>
 <!ATTLIST network_ref     %objref.attr;>
+<!ELEMENT routetbl_ref    %objref.content;>
+<!ATTLIST routetbl_ref    %objref.attr;>
 <!ELEMENT node_ref        %objref.content;>
 <!ATTLIST node_ref        %objref.attr;>
 <!ELEMENT profile_ref     %objref.content;>
 <!ATTLIST profile_ref     %objref.attr;>
-<!ELEMENT obd_ref         %objref.content;>
-<!ATTLIST obd_ref         %objref.attr;>
+<!ELEMENT osd_ref         %objref.content;>
+<!ATTLIST osd_ref         %objref.attr;>
 <!ELEMENT mds_ref         %objref.content;>
 <!ATTLIST mds_ref         %objref.attr;>
 <!ELEMENT mdsdev_ref      %objref.content;>
 <!ATTLIST mdsdev_ref      %objref.attr;>
+<!ELEMENT obd_ref         %objref.content;>
+<!ATTLIST obd_ref         %objref.attr;>
 <!ELEMENT ost_ref         %objref.content;>
 <!ATTLIST ost_ref         %objref.attr;>
+<!ELEMENT active_ref         %objref.content;>
+<!ATTLIST active_ref         %objref.attr;>
+<!ELEMENT target_ref         %objref.content;>
+<!ATTLIST target_ref         %objref.attr;>
 <!ELEMENT lov_ref         %objref.content;>
 <!ATTLIST lov_ref         %objref.attr;>
 <!ELEMENT lovconfig_ref   %objref.content;>
 <!ATTLIST lovconfig_ref   %objref.attr;>
 <!ELEMENT mountpoint_ref  %objref.content;>
 <!ATTLIST mountpoint_ref  %objref.attr;>
-<!ELEMENT echoclient_ref %objref.content;>
-<!ATTLIST echoclient_ref %objref.attr;>
+<!ELEMENT echoclient_ref  %objref.content;>
+<!ATTLIST echoclient_ref  %objref.attr;>
 <!ELEMENT failover_ref    %objref.content;>
 <!ATTLIST failover_ref    %objref.attr;>
 <!ELEMENT ldlm_ref        %objref.content;>
 <!ATTLIST ldlm_ref        %objref.attr;>
+<!ELEMENT ptlrpc_ref      %objref.content;>
+<!ATTLIST ptlrpc_ref      %objref.attr;>
 
 
index c7ea957..f3c1364 100644 (file)
@@ -76,8 +76,8 @@ devpath: <value-of select="devpath"/>
 <if test="devsize">
 devsize: <value-of select="devsize"/>
 </if>
-networkRef: <value-of select="network_ref/@uuidref"/>
-mdsRef: <value-of select="mds_ref/@uuidref"/>
+nodeRef: <value-of select="node_ref/@uuidref"/>
+targetRef: <value-of select="target_ref/@uuidref"/>
 <text>
 </text>
 </template>
@@ -104,13 +104,14 @@ uuid: <value-of select="@uuid"/><apply-templates/>
 </text>
 </template>
 
-<template match="obd">
+<template match="osd">
 dn: uuid=<value-of select="@uuid"/>,<value-of select="$basedn"/>
-objectClass: OBD
+objectClass: OSD
 lustreName: <value-of select="@name"/>
 uuid: <value-of select="@uuid"/>
-activeRef: <value-of select="active_ref/@uuidref"/>
-obdtype: <value-of select="@obdtype"/>
+nodeRef: <value-of select="node_ref/@uuidref"/>
+targetRef: <value-of select="target_ref/@uuidref"/>
+osdtype: <value-of select="@osdtype"/>
 <if test="fstype">
 fstype: <value-of select="fstype"/>
 </if>
@@ -163,15 +164,31 @@ uuid: <value-of select="@uuid"/>
 </text>
 </template>
 
+<template match="ptlrpc">
+dn: uuid=<value-of select="@uuid"/>,<value-of select="$basedn"/>
+objectClass: PTLRPC
+lustreName: <value-of select="@name"/>
+uuid: <value-of select="@uuid"/>
+<text>
+</text>
+</template>
 
 <template match="ldlm_ref">
 ldlmRef: <value-of select="@uuidref"/>
 </template>
 
+<template match="ptlrpc_ref">
+ptlrpcRef: <value-of select="@uuidref"/>
+</template>
+
 <template match="obd_ref">
 obdRef: <value-of select="@uuidref"/>
 </template>
 
+<template match="osd_ref">
+osdRef: <value-of select="@uuidref"/>
+</template>
+
 <template match="ost_ref">
 ostRef: <value-of select="@uuidref"/>
 </template>
index 8629444..d0cfdac 100644 (file)
@@ -1,4 +1,4 @@
 dn: fs=lustre
 fs:lustre
 objectClass: lustre
-desc: Lustre Config
+lustreDesc: Lustre Config
index d51fb40..6384d30 100644 (file)
@@ -20,6 +20,10 @@ bad_cc() {
        echo "  please get an updated compiler."
        AC_MSG_ERROR(sorry)
 }
+TMP_VERSION=`echo $CC_VERSION | cut -c 1-16`
+if test "$TMP_VERSION" = "gcc version 2.95"; then
+        bad_cc
+fi
 case "$CC_VERSION" in 
        # ost_pack_niobuf putting 64bit NTOH temporaries on the stack
        # without "sub    $0xc,%esp" to protect the stack from being
@@ -53,6 +57,17 @@ fi
 AC_SUBST(LIBREADLINE)
 AC_SUBST(HAVE_LIBREADLINE)
 
+# XXX this should be a runtime option
+AC_ARG_ENABLE(ost_recovery, [  --enable-ost-recovery: enable support for ost recovery],,
+             enable_ost_recovery="yes")
+if test "$enable_ost_recovery" = "yes" ; then
+   ENABLE_OST_RECOVERY="-DOST_RECOVERY=1"
+else 
+   HAVE_LIBREADLINE=""
+fi
+AC_SUBST(ENABLE_OST_RECOVERY)
+
+
 # Kernel build environment.
 ac_default_prefix=
 bindir='${exec_prefix}/usr/bin'
@@ -65,22 +80,18 @@ AC_ARG_ENABLE(linuxdir, [  --enable-linuxdir=[path] (deprecated) set path to Lin
 LINUX=$enable_linuxdir
 AC_SUBST(LINUX)
 
-sinclude(archdep.m4)
-
 AC_MSG_CHECKING(if you are running linux 2.5...)
 if test -e $LINUX/include/linux/namei.h ; then
-       linux25=yes
+       linux25="yes"
        AC_MSG_RESULT(yes)
 else
-       linux25=no
+       linux25="no"
        AC_MSG_RESULT(no)
 fi
 AM_CONDITIONAL(LINUX25, test x$linux25 = xyes)
 
-# Changed by Amrut Joshi on 01/13/2003
-#KINCFLAGS='-I. -I$(top_srcdir)/include -I$(PORTALS)/include -I$(LINUX)/include'
-KINCFLAGS='-I$(top_srcdir)/include -I$(PORTALS)/include -I$(LINUX)/include'
-CPPFLAGS="$KINCFLAGS $ARCHCPPFLAGS"
+sinclude(archdep.m4)
+
 
 portalsdir_def='$(top_srcdir)/../portals'
 AC_ARG_WITH(portals, [  --with-portals=[path] set path to Portals source (default=../portals)], enable_portalsdir=$withval)
@@ -104,12 +115,27 @@ AC_ARG_ENABLE(portalslib, [  --enable-portalslib=[path] (deprecated) set path to
 if ! test -z "$enable_portalslib"; then
        PORTALSLIB=${enable_portalslib}
 fi
+AC_SUBST(PORTALSLIB)
 
+AM_CONDITIONAL(LIBLUSTRE, test x$host_cpu = xlib)
+AC_MSG_CHECKING(if you are building lib lustre)
+if test "$host_cpu" = "lib"; then
+   AC_MSG_RESULT(yes)
+   libdir='${exec_prefix}/lib/lustre'
+else
+   AC_MSG_RESULT(no)
+fi
 
-AC_SUBST(PORTALSLIB)
+if test $host_cpu != "lib" ; then 
+KINCFLAGS='-I$(top_srcdir)/include -I$(PORTALS)/include -I$(LINUX)/include'
+else
+KINCFLAGS='-I$(top_srcdir)/include -I$(PORTALS)/include'
+fi
+CPPFLAGS="$KINCFLAGS $ARCHCPPFLAGS"
 
-AC_MSG_CHECKING(if make dep has been run in kernel source)
-if test -f $LINUX/include/linux/config.h ; then
+if test $host_cpu != "lib" ; then 
+AC_MSG_CHECKING(if make dep has been run in kernel source (host $host_cpu) )
+if  test -f $LINUX/include/linux/config.h ; then
        AC_MSG_RESULT(yes)
 else
        AC_MSG_ERROR(** cannot find $LINUX/include/linux/config.h. Run make dep in $LINUX.)
@@ -122,7 +148,6 @@ else
        AC_MSG_ERROR(** cannot find $LINUX/include/linux/autoconf.h. Run make config in $LINUX.)
 fi
 
-
 AC_MSG_CHECKING(for Linux release)
 
 dnl We need to rid ourselves of the nasty [ ] quotes.
@@ -140,6 +165,7 @@ AC_SUBST(modulefsdir)
 AC_MSG_RESULT($RELEASE)
 AC_SUBST(RELEASE)
 
+fi
 # Directories for documentation and demos.
 docdir='${prefix}/usr/share/doc/$(PACKAGE)'
 AC_SUBST(docdir)
@@ -151,6 +177,7 @@ AC_SUBST(demodir)
 # AM_CONFIG_HEADER(include/config.h)
 
 AC_OUTPUT(Makefile lib/Makefile ldlm/Makefile obdecho/Makefile ptlrpc/Makefile \
+       liblustre/Makefile \
        lov/Makefile osc/Makefile mdc/Makefile mds/Makefile ost/Makefile \
        cobd/Makefile ptlbd/Makefile conf/Makefile \
        utils/Makefile utils/lconf tests/Makefile obdfilter/Makefile \
index 3fc2b66..d1de59b 100644 (file)
@@ -15,9 +15,9 @@ EXTRA_PROGRAMS = extN
 #       (or other RH < 12.5 kernels) use the "chaos22" patch instead.
 EXTN_FIXES = patch-2.4.18-chaos22
 #EXTN_FIXES = ext3-2.4.18-fixes.diff
-EXTNP = htree-ext3-2.4.18.diff linux-2.4.18ea-0.8.26.diff
+EXTNP = htree-ext3-2.4.18.diff linux-2.4.18ea-0.8.26.diff ext3-2.4-ino_t.diff
 EXTNP+= ext3-2.4.18-ino_sb_macro.diff extN-misc-fixup.diff extN-noread.diff
-EXTNP+= extN-wantedi.diff
+EXTNP+= extN-wantedi.diff extN-san.diff extN-2.4.18-ino_sb_fixup.diff
 #EXTNP+= extN-iget-debug.diff
 EXTNC = balloc.c bitmap.c dir.c file.c fsync.c ialloc.c inode.c ioctl.c
 EXTNC+= namei.c super.c symlink.c
@@ -27,8 +27,8 @@ EXTN_EXTRA += include/linux/quotaops.h
 extN_SOURCES = $(EXTNC) xattr.c # punch.c
 extN_DEPENDENCIES = patch-stamp
 EXTRA_DIST = $(EXTNP) $(EXTN_FIXES) \
-       extN-2.4.18-ino_sb_fixup.diff extN-2.4.18-exports.diff \
-       $(wildcard extN.patch-*)
+       ext3-largefile.diff extN-2.4.18-exports.diff \
+       ext3-use-after-free.diff ext3-unmount_sync.diff $(wildcard extN.patch-*)
 DISTCLEANFILES = -r $(extN_SOURCES) sed-stamp patch-stamp *.orig *.rej
 SUB=-e "s/ext3/extN/g" -e "s/EXT3/EXTN/g" -e "s/extern __inline__/static inline/"
 
@@ -80,14 +80,14 @@ sed-stamp:
        rm -rf $(extN_orig) $(extN_include_orig)
        mkdir $(extN_orig) $(extN_include_orig)
        list='$(EXTNC)'; for f in $$list; do                                  \
-          echo "creating $(extN_orig)/$$f";                            \
-          sed $(SUB) $(LINUX)/fs/ext3/$$f > $(extN_orig)/$$f; \
-        done
+          echo "creating $(extN_orig)/$$f";                                   \
+          sed $(SUB) $(LINUX)/fs/ext3/$$f > $(extN_orig)/$$f;                 \
+       done
        list='$(EXTNI)'; for i in $$list; do                                  \
           s=`echo $$i | sed "s/extN/ext3/"`;                                  \
-          echo "creating $(extN_include_orig)/$$i"; \
-          sed $(SUB) $(LINUX)/include/linux/$$s > $(extN_include_orig)/$$i; \
-        done
+          echo "creating $(extN_include_orig)/$$i";                           \
+          sed $(SUB) $(LINUX)/include/linux/$$s > $(extN_include_orig)/$$i;   \
+       done
        echo timestamp > $@
 
 
@@ -117,18 +117,15 @@ patch-stamp: sed-stamp $(EXTNP)
            grep -q extN_mark_inode_dirty && list="$(EXTN_FIXES) $$list";     \
          grep -q "if (do_sync_supers)" $(extN_orig)/super.c &&               \
            list="ext3-unmount_sync.diff $$list";                             \
+         grep -q "ext3_journal_start(inode, 2)" $(extN_orig)/inode.c ||      \
+           list="ext3-largefile.diff $$list";                                \
+         grep -q "EXPORT_SYMBOL(extN_bread)" $(extN_orig)/super.c ||         \
+           list="$$list extN-2.4.18-exports.diff";                           \
          for p in $$list; do                                                 \
            echo "applying patch $$p";                                        \
            sed $(SUB) $(srcdir)/$$p |                                        \
              (cd $(top_builddir) && patch -p1) || exit $$?;                  \
          done;                                                               \
-         echo "It is OK if the next patch says it is skipping this patch";   \
-         echo "applying patch $(srcdir)/extN-2.4.18-exports.diff";           \
-         (cd $(top_builddir) &&                                              \
-           patch -N -p1) < $(srcdir)/extN-2.4.18-exports.diff;               \
-         echo "applying patch $(srcdir)/extN-2.4.18-ino_sb_fix.diff";        \
-         (cd $(top_builddir) &&                                              \
-           patch -p1) < $(srcdir)/extN-2.4.18-ino_sb_fixup.diff || exit $$?; \
        fi
        echo timestamp > $@
 
diff --git a/lustre/extN/ext3-2.4-ino_t.diff b/lustre/extN/ext3-2.4-ino_t.diff
new file mode 100644 (file)
index 0000000..ce1bd88
--- /dev/null
@@ -0,0 +1,138 @@
+--- linux/fs/ext3/ialloc.c.orig        Sat Oct 19 11:42:23 2002
++++ linux/fs/ext3/ialloc.c     Sat Jan  4 12:14:18 2003
+@@ -64,8 +64,8 @@ static int read_inode_bitmap (struct sup
+       if (!bh) {
+               ext3_error (sb, "read_inode_bitmap",
+                           "Cannot read inode bitmap - "
+-                          "block_group = %lu, inode_bitmap = %lu",
+-                          block_group, (unsigned long) gdp->bg_inode_bitmap);
++                          "block_group = %lu, inode_bitmap = %u",
++                          block_group, gdp->bg_inode_bitmap);
+               retval = -EIO;
+       }
+       /*
+@@ -531,19 +532,19 @@ out:
+ }
+ /* Verify that we are loading a valid orphan from disk */
+-struct inode *ext3_orphan_get (struct super_block * sb, ino_t ino)
++struct inode *ext3_orphan_get(struct super_block *sb, unsigned long ino)
+ {
+-      ino_t max_ino = le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count);
++      unsigned long max_ino = le32_to_cpu(EXT3_SB(sb)->s_es->s_inodes_count);
+       unsigned long block_group;
+       int bit;
+       int bitmap_nr;
+       struct buffer_head *bh;
+       struct inode *inode = NULL;
+-      
++
+       /* Error cases - e2fsck has already cleaned up for us */
+       if (ino > max_ino) {
+               ext3_warning(sb, __FUNCTION__,
+-                           "bad orphan ino %ld!  e2fsck was run?\n", ino);
++                           "bad orphan ino %lu!  e2fsck was run?\n", ino);
+               return NULL;
+       }
+@@ -552,7 +553,7 @@ struct inode *ext3_orphan_get (struct su
+       if ((bitmap_nr = load_inode_bitmap(sb, block_group)) < 0 ||
+           !(bh = EXT3_SB(sb)->s_inode_bitmap[bitmap_nr])) {
+               ext3_warning(sb, __FUNCTION__,
+-                           "inode bitmap error for orphan %ld\n", ino);
++                           "inode bitmap error for orphan %lu\n", ino);
+               return NULL;
+       }
+@@ -563,7 +564,7 @@ struct inode *ext3_orphan_get (struct su
+       if (!ext3_test_bit(bit, bh->b_data) || !(inode = iget(sb, ino)) ||
+           is_bad_inode(inode) || NEXT_ORPHAN(inode) > max_ino) {
+               ext3_warning(sb, __FUNCTION__,
+-                           "bad orphan inode %ld!  e2fsck was run?\n", ino);
++                           "bad orphan inode %lu!  e2fsck was run?\n", ino);
+               printk(KERN_NOTICE "ext3_test_bit(bit=%d, block=%ld) = %d\n",
+                      bit, bh->b_blocknr, ext3_test_bit(bit, bh->b_data));
+               printk(KERN_NOTICE "inode=%p\n", inode);
+@@ -570,9 +571,9 @@ struct inode *ext3_orphan_get (struct su
+               if (inode) {
+                       printk(KERN_NOTICE "is_bad_inode(inode)=%d\n",
+                              is_bad_inode(inode));
+-                      printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%d\n",
++                      printk(KERN_NOTICE "NEXT_ORPHAN(inode)=%u\n",
+                              NEXT_ORPHAN(inode));
+-                      printk(KERN_NOTICE "max_ino=%ld\n", max_ino);
++                      printk(KERN_NOTICE "max_ino=%lu\n", max_ino);
+               }
+               /* Avoid freeing blocks if we got a bad deleted inode */
+               if (inode && inode->i_nlink == 0)
+--- linux/fs/ext3/namei.c.orig Sat Oct 19 11:42:45 2002
++++ linux/fs/ext3/namei.c      Sat Jan  4 12:13:27 2003
+@@ -716,10 +716,10 @@ int ext3_orphan_del(handle_t *handle, st
+ {
+       struct list_head *prev;
+       struct ext3_sb_info *sbi;
+-      ino_t ino_next; 
++      unsigned long ino_next;
+       struct ext3_iloc iloc;
+       int err = 0;
+-      
++
+       lock_super(inode->i_sb);
+       if (list_empty(&inode->u.ext3_i.i_orphan)) {
+               unlock_super(inode->i_sb);
+@@ -730,7 +730,7 @@ int ext3_orphan_del(handle_t *handle, st
+       prev = inode->u.ext3_i.i_orphan.prev;
+       sbi = EXT3_SB(inode->i_sb);
+-      jbd_debug(4, "remove inode %ld from orphan list\n", inode->i_ino);
++      jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);
+       list_del(&inode->u.ext3_i.i_orphan);
+       INIT_LIST_HEAD(&inode->u.ext3_i.i_orphan);
+@@ -741,13 +741,13 @@ int ext3_orphan_del(handle_t *handle, st
+        * list in memory. */
+       if (!handle)
+               goto out;
+-      
++
+       err = ext3_reserve_inode_write(handle, inode, &iloc);
+       if (err)
+               goto out_err;
+       if (prev == &sbi->s_orphan) {
+-              jbd_debug(4, "superblock will point to %ld\n", ino_next);
++              jbd_debug(4, "superblock will point to %lu\n", ino_next);
+               BUFFER_TRACE(sbi->s_sbh, "get_write_access");
+               err = ext3_journal_get_write_access(handle, sbi->s_sbh);
+               if (err)
+@@ -758,8 +758,8 @@ int ext3_orphan_del(handle_t *handle, st
+               struct ext3_iloc iloc2;
+               struct inode *i_prev =
+                       list_entry(prev, struct inode, u.ext3_i.i_orphan);
+-              
+-              jbd_debug(4, "orphan inode %ld will point to %ld\n",
++
++              jbd_debug(4, "orphan inode %lu will point to %lu\n",
+                         i_prev->i_ino, ino_next);
+               err = ext3_reserve_inode_write(handle, i_prev, &iloc2);
+               if (err)
+@@ -774,7 +774,7 @@ int ext3_orphan_del(handle_t *handle, st
+       if (err)
+               goto out_brelse;
+-out_err:      
++out_err: 
+       ext3_std_error(inode->i_sb, err);
+ out:
+       unlock_super(inode->i_sb);
+--- linux/include/linux/ext3_fs.h.orig Thu Jan  2 16:10:24 2003
++++ linux/include/linux/ext3_fs.h      Sat Jan  4 12:25:41 2003
+@@ -622,7 +622,7 @@ extern int ext3_sync_file (struct file *
+ /* ialloc.c */
+ extern struct inode * ext3_new_inode (handle_t *, const struct inode *, int);
+ extern void ext3_free_inode (handle_t *, struct inode *);
+-extern struct inode * ext3_orphan_get (struct super_block *, ino_t);
++extern struct inode * ext3_orphan_get (struct super_block *, unsigned long);
+ extern unsigned long ext3_count_free_inodes (struct super_block *);
+ extern void ext3_check_inodes_bitmap (struct super_block *);
+ extern unsigned long ext3_count_free (struct buffer_head *, unsigned);
index a49d5da..cc47588 100644 (file)
        struct list_head *prev;
 +      struct ext3_inode_info *ei = EXT3_I(inode);
        struct ext3_sb_info *sbi;
-       ino_t ino_next; 
+       unsigned long ino_next;
        struct ext3_iloc iloc;
        int err = 0;
-       
        lock_super(inode->i_sb);
 -      if (list_empty(&inode->u.ext3_i.i_orphan)) {
 +      if (list_empty(&ei->i_orphan)) {
 +      prev = ei->i_orphan.prev;
        sbi = EXT3_SB(inode->i_sb);
  
-       jbd_debug(4, "remove inode %ld from orphan list\n", inode->i_ino);
+       jbd_debug(4, "remove inode %lu from orphan list\n", inode->i_ino);
  
 -      list_del(&inode->u.ext3_i.i_orphan);
 -      INIT_LIST_HEAD(&inode->u.ext3_i.i_orphan);
  
        /* If we're on an error path, we may not have a valid
         * transaction handle with which to update the orphan list on
-@@ -1520,9 +1520,8 @@ int ext3_orphan_del(handle_t *handle, st
+@@ -1520,8 +1520,7 @@ int ext3_orphan_del(handle_t *handle, st
                err = ext3_journal_dirty_metadata(handle, sbi->s_sbh);
        } else {
                struct ext3_iloc iloc2;
 -              struct inode *i_prev =
 -                      list_entry(prev, struct inode, u.ext3_i.i_orphan);
--              
 +              struct inode *i_prev = orphan_list_entry(prev);
-+
-               jbd_debug(4, "orphan inode %ld will point to %ld\n",
+               jbd_debug(4, "orphan inode %lu will point to %lu\n",
                          i_prev->i_ino, ino_next);
-               err = ext3_reserve_inode_write(handle, i_prev, &iloc2);
 @@ -1695,10 +1695,10 @@ static int ext3_symlink (struct inode * 
                        goto out_no_entry;
        } else {
diff --git a/lustre/extN/ext3-largefile.diff b/lustre/extN/ext3-largefile.diff
new file mode 100644 (file)
index 0000000..db41aab
--- /dev/null
@@ -0,0 +1,23 @@
+Under rare conditions (filesystem corruption, really) it is possible
+for ext3_dirty_inode() to require _two_ blocks for the transaction: one
+for the inode and one to update the superblock - to set
+EXT3_FEATURE_RO_COMPAT_LARGE_FILE.  This causes the filesystem to go
+BUG.
+
+So reserve an additional block for that eventuality.
+
+
+ fs/ext3/inode.c |    2 +-
+ 1 files changed, 1 insertion(+), 1 deletion(-)
+
+--- 25/fs/ext3/inode.c~ext3-transaction-reserved-blocks        Sat Dec 14 18:28:21 2002
++++ 25-akpm/fs/ext3/inode.c    Sat Dec 14 18:28:21 2002
+@@ -2698,7 +2698,7 @@ void ext3_dirty_inode(struct inode *inod
+       handle_t *handle;
+       lock_kernel();
+-      handle = ext3_journal_start(inode, 1);
++      handle = ext3_journal_start(inode, 2);
+       if (IS_ERR(handle))
+               goto out;
+       if (current_handle &&
diff --git a/lustre/extN/extN-san.diff b/lustre/extN/extN-san.diff
new file mode 100644 (file)
index 0000000..4d0f277
--- /dev/null
@@ -0,0 +1,88 @@
+--- lustre/extN/inode.orig.c   2002-12-29 18:48:56.000000000 +0800
++++ lustre/extN/inode.c        2002-12-29 19:17:24.000000000 +0800
+@@ -2728,3 +2728,85 @@
+  * here, in extN_aops_journal_start() to ensure that the forthcoming "see if we
+  * need to extend" test in extN_prepare_write() succeeds.  
+  */
++
++/* for each block: 1 ind + 1 dind + 1 tind
++ * for each block: 3 bitmap blocks
++ * for each block: 3 group descriptor blocks
++ * i inode block
++ * 1 superblock
++ * 2 * EXTN_SINGLEDATA_TRANS_BLOCKS for the quote files
++ * ((1+1+1) * 3 * nblocks) + 1 + 1 + 2 * EXTN_SINGLEDATA_TRANS_BLOCKS
++ *
++ * XXX assuming:
++ * (1) fs logic block size == page size
++ * (2) extN in writeback mode
++ */
++static inline int extN_san_write_trans_blocks(int nblocks)
++{
++      int ret;
++      
++      ret = (1 + 1 + 1) * 3 * nblocks + 1 + 1;
++
++#ifdef CONFIG_QUOTA
++      ret += 2 * EXTN_SINGLEDATA_TRANS_BLOCKS;
++#endif
++
++      return ret;
++}
++
++/* Alloc blocks for an inode, while don't create any buffer/page
++ * for data I/O; set the inode size if file is extended.
++ *
++ * @inode:    target inode
++ * @blocks:   array of logic block number
++ * @nblocks:  how many blocks need be alloced
++ * @newsize:  new filesize we should set
++ *
++ * return:    0 success, otherwise failed
++ *            (*blocks) contains physical block number alloced
++ *
++ * XXX this assume the fs block size == page size
++ */
++int extN_prep_san_write(struct inode *inode, long *blocks,
++                      int nblocks, loff_t newsize)
++{
++      handle_t *handle;
++      struct buffer_head bh_tmp;
++      int needed_blocks;
++      int i, ret = 0, ret2;
++
++      needed_blocks = extN_san_write_trans_blocks(nblocks);
++
++      lock_kernel();
++      handle = extN_journal_start(inode, needed_blocks);
++      if (IS_ERR(handle)) {
++              unlock_kernel();
++              return PTR_ERR(handle);
++      }
++      unlock_kernel();
++
++      /* alloc blocks one by one */
++      for (i = 0; i < nblocks; i++) {
++              ret = extN_get_block_handle(handle, inode, blocks[i],
++                                              &bh_tmp, 1);
++              if (ret)
++                      break;
++
++              blocks[i] = bh_tmp.b_blocknr;
++      }
++
++      /* set inode size if needed */
++      if (!ret && (newsize > inode->i_size)) {
++              inode->i_size = newsize;
++              extN_mark_inode_dirty(handle, inode);
++      }
++
++      lock_kernel();
++      ret2 = extN_journal_stop(handle, inode);
++      unlock_kernel();
++
++      if (!ret)
++              ret = ret2;
++      return ret;
++}
++EXPORT_SYMBOL(extN_prep_san_write);
diff --git a/lustre/include/liblustre.h b/lustre/include/liblustre.h
new file mode 100644 (file)
index 0000000..0b37021
--- /dev/null
@@ -0,0 +1,431 @@
+/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
+ * vim:expandtab:shiftwidth=8:tabstop=8:
+ *
+ *  Copyright (C) 2001 Cluster File Systems, Inc. <info@clusterfs.com>
+ *
+ *   This file is part of Lustre, http://www.lustre.org.
+ *
+ *   Lustre 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.
+ *
+ *   Lustre is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with Lustre; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * User-space Lustre headers.
+ *
+ */
+#ifndef LIBLUSTRE_H__
+#define LIBLUSTRE_H__
+
+#include <sys/mman.h>
+#include <asm/page.h>
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/vfs.h>
+
+#include <portals/list.h>
+#include <portals/p30.h>
+
+/* definitions for liblustre */
+
+/* always adopt 2.5 definitions */
+#define LINUX_VERSION_CODE 1
+#define KERNEL_VERSION(a,b,c) 0
+
+static inline void inter_module_put(void *a)
+{
+        return;
+}
+
+extern ptl_handle_ni_t         tcpnal_ni;
+
+static inline void *inter_module_get(char *arg)
+{
+
+        if (strcmp(arg, "tcpnal_ni") == 0 )
+                return &tcpnal_ni;
+        else
+                return NULL;
+
+}
+
+
+/* cheats for now */
+
+struct work_struct {
+        void (*ws_task)(void *arg);
+        void *ws_arg;
+};
+
+static inline void prepare_work(struct work_struct *q, void (*t)(void *),
+                                void *arg)
+{
+        q->ws_task = t;
+        q->ws_arg = arg;
+        return;
+}
+
+static inline void schedule_work(struct work_struct *q)
+{
+        q->ws_task(q->ws_arg);
+}
+
+
+#define strnlen(a,b) strlen(a)
+static inline void *kmalloc(int size, int prot)
+{
+        return malloc(size);
+}
+#define vmalloc malloc
+#define vfree free
+#define kfree(a) free(a)
+#define GFP_KERNEL 1
+#define GFP_HIGHUSER 1
+#define IS_ERR(a) (abs((int)(a)) < 500 ? 1 : 0)
+#define PTR_ERR(a) ((int)(a))
+
+#define capable(foo) 1
+#define CAP_SYS_ADMIN 1
+
+typedef struct {
+        void *cwd;
+
+}mm_segment_t;
+
+typedef void *read_proc_t;
+typedef void *write_proc_t;
+
+
+/* modules */
+
+struct module {
+        int count;
+};
+
+static inline void MODULE_AUTHOR(char *name)
+{
+        printf("%s\n", name);
+}
+#define MODULE_DESCRIPTION(name) MODULE_AUTHOR(name)
+#define MODULE_LICENSE(name) MODULE_AUTHOR(name)
+
+#define THIS_MODULE NULL
+#define __init
+#define __exit
+
+/* devices */
+
+static inline int misc_register(void *foo)
+{
+        return 0;
+}
+#define misc_deregister misc_register
+
+#define __MOD_INC_USE_COUNT(m)  do {int a = 1; a++; } while (0)
+#define __MOD_DEC_USE_COUNT(m)  do {int a = 1; a++; } while (0)
+#define MOD_INC_USE_COUNT  do {int a = 1; a++; } while (0)
+#define MOD_DEC_USE_COUNT  do {int a = 1; a++; } while (0)
+
+/* module initialization */
+extern int init_obdclass(void);
+extern int ptlrpc_init(void);
+extern int ldlm_init(void);
+extern int osc_init(void);
+extern int lov_init(void);
+extern int echo_client_init(void);
+
+
+
+/* general stuff */
+#define jiffies 0
+
+#define EXPORT_SYMBOL(S)
+
+typedef int spinlock_t;
+typedef __u64 kdev_t;
+
+#define SPIN_LOCK_UNLOCKED 0
+#define spin_lock(l) do {int a = 1; a++; } while (0)
+#define spin_unlock(l) do {int a= 1; a++; } while (0)
+#define spin_lock_init(l) do {int a= 1; a++; } while (0)
+static inline void spin_lock_bh(spinlock_t *l)
+{
+        return;
+}
+static inline void spin_unlock_bh(spinlock_t *l)
+{
+        return;
+}
+static inline void spin_lock_irqrestore(a,b)
+{
+        return;
+}
+static inline void spin_unlock_irqrestore(a,b)
+{
+        return;
+}
+static inline void spin_lock_irqsave(a,b)
+{
+        return;
+}
+
+#define barrier() do {int a= 1; a++; } while (0)
+
+/* registering symbols */
+
+#define ERESTARTSYS ERESTART
+#define HZ 1
+
+/* random */
+
+static inline void get_random_bytes(void *ptr, int size)
+{
+        static int r;
+        int *p = (int *)ptr;
+        int *end = p + (size / sizeof(int));
+        r = rand();
+        while ( p + sizeof(int) < end ) {
+                *p = r;
+                p++;
+        }
+}
+
+/* memory */
+
+static inline int copy_from_user(void *a,void *b, int c)
+{
+        memcpy(a,b,c);
+        return 0;
+}
+
+static inline int copy_to_user(void *a,void *b, int c)
+{
+        memcpy(a,b,c);
+        return 0;
+}
+
+
+/* slabs */
+typedef struct {
+         int size;
+} kmem_cache_t;
+#define SLAB_HWCACHE_ALIGN 0
+static inline kmem_cache_t *kmem_cache_create(name,objsize,cdum,d,e,f)
+{
+        kmem_cache_t *c;
+        c = malloc(sizeof(*c));
+        if (!c)
+                return NULL;
+        c->size = objsize;
+        return c;
+};
+
+static inline int kmem_cache_destroy(kmem_cache_t *a)
+{
+        free(a);
+        return 0;
+}
+#define kmem_cache_validate(a,b) 1
+#define kmem_cache_alloc(cache, prio) malloc(cache->size)
+#define kmem_cache_free(cache, obj) OBD_FREE(obj, cache->size)
+#define PORTAL_SLAB_ALLOC(lock,cache,size) do { lock = kmem_cache_alloc(cache,prio); } while (0)
+#define PORTAL_SLAB_FREE(lock,cache,size) do { lock = kmem_cache_alloc(cache,prio); } while (0)
+
+struct page {
+        void *addr;
+        int index;
+};
+
+#define kmap(page) (page)->addr
+#define kunmap(a) do { int foo = 1; foo++; } while (0)
+
+static inline struct page *alloc_pages(mask,foo)
+{
+        struct page *pg = malloc(sizeof(*pg));
+
+        if (!pg)
+                return NULL;
+#ifdef MAP_ANONYMOUS
+        pg->addr = mmap(0, PAGE_SIZE, PROT_WRITE, MAP_ANONYMOUS, 0, 0);
+#else
+        pg->addr = malloc(PAGE_SIZE);
+#endif
+
+        if (!pg->addr) {
+                free(pg);
+                return NULL;
+        }
+        return pg;
+}
+
+static inline void __free_pages(struct page *pg, int what)
+{
+#ifdef MAP_ANONYMOUS
+        munmap(pg->addr, PAGE_SIZE);
+#else
+        free(pg->addr);
+#endif
+        free(pg);
+}
+
+/* arithmetic */
+#define do_div(a,b) (a)/(b)
+
+/* dentries / intents */
+struct lookup_intent {
+        void *it_iattr;
+};
+
+struct iattr {
+        int mode;
+};
+
+struct dentry {
+        int d_count;
+};
+struct file {
+        struct dentry *f_dentry;
+        void *private_data;
+} ;
+
+struct vfsmount {
+        void *pwd;
+};
+#define cpu_to_le32(x) ((__u32)(x))
+
+/* semaphores */
+struct semaphore {
+        int count;
+};
+
+#define down(a) do {(a)->count++;} while (0)
+#define up(a) do {(a)->count--;} while (0)
+#define sema_init(a,b) do { (a)->count = b; } while (0)
+
+typedef struct  {
+        struct list_head sleepers;
+} wait_queue_head_t;
+
+typedef struct  {
+        struct list_head sleeping;
+        void *process;
+} wait_queue_t;
+
+struct signal {
+        int signal;
+};
+
+struct task_struct {
+        int state;
+        struct signal pending;
+        char comm[32];
+        int pid;
+};
+
+extern struct task_struct *current;
+
+
+
+#define set_current_state(foo) do { current->state = foo; } while (0)
+
+#define init_waitqueue_entry(q,p) do { (q)->process = p; } while (0)
+#define add_wait_queue(q,p) do {  list_add(&(q)->sleepers, &(p)->sleeping); } while (0)
+#define del_wait_queue(p) do { list_del(&(p)->sleeping); } while (0)
+#define remove_wait_queue(q,p) do { list_del(&(p)->sleeping); } while (0)
+
+#define init_waitqueue_head(l) INIT_LIST_HEAD(&(l)->sleepers)
+#define wake_up(l) do { int a; a++; } while (0)
+#define wait_event(l,m) do { int a; a++; } while (0)
+#define TASK_INTERRUPTIBLE 0
+#define TASK_UNINTERRUPTIBLE 1
+#define TASK_RUNNING 2
+
+
+#define schedule() do { int a; a++; } while (0)
+static inline int schedule_timeout(t)
+{
+        return 0;
+}
+
+#define lock_kernel() do { int a; a++; } while (0)
+#define daemonize(l) do { int a; a++; } while (0)
+#define sigfillset(l) do { int a; a++; } while (0)
+#define recalc_sigpending(l) do { int a; a++; } while (0)
+#define kernel_thread(l,m,n)
+
+static inline int call_usermodehelper(char *prog, char **argv, char **evnp)
+{
+        return 0;
+}
+
+
+
+#define KERN_INFO
+
+
+
+struct timer_list {
+        struct list_head tl_list;
+        void (*function)(unsigned long unused);
+        void *data;
+        int expires;
+};
+
+static inline int timer_pending(struct timer_list *l)
+{
+        if (l->expires > jiffies)
+                return 1;
+        else
+                return 0;
+}
+
+static inline int init_timer(struct timer_list *l)
+{
+        INIT_LIST_HEAD(&l->tl_list);
+        return 0;
+}
+
+static inline void mod_timer(struct timer_list *l, int thetime)
+{
+        l->expires = thetime;
+}
+
+static inline void del_timer(struct timer_list *l)
+{
+        free(l);
+}
+
+typedef struct { volatile int counter; } atomic_t;
+
+#define atomic_read(a) ((a)->counter)
+#define atomic_set(a,b) do {(a)->counter = b; } while (0)
+#define atomic_dec_and_test(a) ((--((a)->counter)) == 0)
+#define atomic_inc(a)  (((a)->counter)++)
+#define atomic_dec(a)  do { (a)->counter--; } while (0)
+#define atomic_add(b,a)  do {(a)->counter += b;} while (0)
+#define atomic_sub(b,a)  do {(a)->counter -= b;} while (0)
+
+#define LBUG() do { sleep(1000000); } while (0)
+
+#include <linux/obd_support.h>
+#include <linux/lustre_idl.h>
+#include <linux/lustre_lib.h>
+#include <linux/lustre_import.h>
+#include <linux/lustre_export.h>
+#include <linux/lustre_net.h>
+
+
+#endif
+
index 14a713c..cd8f12b 100644 (file)
 #ifndef _LPROCFS_SNMP_H
 #define _LPROCFS_SNMP_H
 
+#ifdef __KERNEL__
 #include <linux/autoconf.h>
 #include <linux/proc_fs.h>
+#endif
 
 #ifndef LPROCFS
 #ifdef  CONFIG_PROC_FS  /* Ensure that /proc is configured */
@@ -48,9 +50,6 @@ struct lprocfs_static_vars {
 /* class_obd.c */
 extern struct proc_dir_entry *proc_lustre_root;
 
-extern void lprocfs_init_vars(struct lprocfs_static_vars *var);
-extern void lprocfs_init_multi_vars(unsigned int idx, 
-                                    struct lprocfs_static_vars *var);
 
 #define LPROCFS_INIT_MULTI_VARS(array, size)                              \
 void lprocfs_init_multi_vars(unsigned int idx,                            \
@@ -63,6 +62,7 @@ void lprocfs_init_multi_vars(unsigned int idx,                            \
    x->obd_vars = glob[idx].obd_vars;                                      \
 }                                                                         \
 
+#ifdef LPROCFS
 #define LPROCFS_INIT_VARS(vclass, vinstance)           \
 void lprocfs_init_vars(struct lprocfs_static_vars *x)  \
 {                                                      \
@@ -70,7 +70,9 @@ void lprocfs_init_vars(struct lprocfs_static_vars *x)  \
         x->obd_vars = vinstance;                       \
 }                                                      \
 
-#ifdef LPROCFS
+extern void lprocfs_init_vars(struct lprocfs_static_vars *var);
+extern void lprocfs_init_multi_vars(unsigned int idx, 
+                                    struct lprocfs_static_vars *var);
 /* lprocfs_status.c */
 extern int lprocfs_add_vars(struct proc_dir_entry *root,
                             struct lprocfs_vars *var,
@@ -133,6 +135,7 @@ int fct_name(char *page, char **start, off_t off,                \
 static inline struct proc_dir_entry *
 lprocfs_register(const char *name, struct proc_dir_entry *parent,
                  struct lprocfs_vars *list, void *data) { return NULL; }
+static inline void lprocfs_init_vars(struct lprocfs_static_vars *x) { return; }
 static inline int lprocfs_add_vars(struct proc_dir_entry *root,
                                    struct lprocfs_vars *var,
                                    void *data) { return 0; }
index 9fad75f..c120225 100644 (file)
@@ -7,12 +7,13 @@
 #define _LUSTRE_DLM_H__
 
 #ifdef __KERNEL__
-
 #include <linux/proc_fs.h>
+#endif 
+
 #include <linux/lustre_lib.h>
 #include <linux/lustre_net.h>
 #include <linux/lustre_import.h>
-#include <linux/handles.h>
+#include <linux/lustre_handles.h>
 
 struct obd_ops;
 struct obd_device;
@@ -197,9 +198,6 @@ typedef int (*ldlm_res_policy)(struct ldlm_namespace *, struct ldlm_lock **,
 #define LDLM_MIN_TYPE 10
 #define LDLM_MAX_TYPE 11
 
-extern ldlm_res_compat ldlm_res_compat_table [];
-extern ldlm_res_policy ldlm_res_policy_table [];
-
 struct ldlm_resource {
         struct ldlm_namespace *lr_namespace;
         struct list_head       lr_hash;
@@ -235,8 +233,8 @@ struct ldlm_ast_work {
 
 /* Per-export ldlm state. */
 struct ldlm_export_data {
-        struct list_head        led_held_locks;
-        struct obd_import       led_import;
+        struct list_head       led_held_locks; /* protected by namespace lock */
+        struct obd_import      led_import;
 };
 
 extern struct obd_ops ldlm_obd_ops;
@@ -295,11 +293,9 @@ do {                                                                          \
         }                                                                     \
 } while (0)
 
-/* I hate hate hate hate hate this.  This cannot stay.  bug 850. -phil */
-#define LDLM_DEBUG0(lock, format) __LDLM_DEBUG(D_DLMTRACE, lock, format"%s","")
-
-#define LDLM_DEBUG(lock, format, a...) __LDLM_DEBUG(D_DLMTRACE, lock, format, a)
-#define LDLM_ERROR(lock, format, a...) __LDLM_DEBUG(D_ERROR, lock, format, a)
+#define LDLM_DEBUG(lock, format, a...) __LDLM_DEBUG(D_DLMTRACE, lock, \
+                                                    format, ## a)
+#define LDLM_ERROR(lock, format, a...) __LDLM_DEBUG(D_ERROR, lock, format, ## a)
 
 #define LDLM_DEBUG_NOLOCK(format, a...)                 \
         CDEBUG(D_DLMTRACE, "### " format "\n" , ## a)
@@ -473,7 +469,6 @@ int ldlm_cancel_lru(struct ldlm_namespace *ns);
 int mds_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
                      void *data, int flag);
 
-#endif /* __KERNEL__ */
 
 /* ioctls for trying requests */
 #define IOC_LDLM_TYPE                   'f'
index 74b8dca..694bd3e 100644 (file)
@@ -10,8 +10,6 @@
 #ifndef __EXPORT_H
 #define __EXPORT_H
 
-#ifdef __KERNEL__
-
 #include <linux/lustre_idl.h>
 #include <linux/lustre_dlm.h>
 #include <linux/lustre_mds.h>
@@ -22,10 +20,6 @@ struct lov_export_data {
         struct list_head led_open_head;
 };
 
-struct ost_export_data {
-        struct obd_uuid oed_uuid; /* client UUID */
-};
-
 struct ec_export_data { /* echo client */
         struct list_head eced_open_head;
         struct list_head eced_locks;
@@ -43,7 +37,6 @@ struct obd_export {
                 struct mds_export_data    eu_mds_data;
                 struct filter_export_data eu_filter_data;
                 struct lov_export_data    eu_lov_data;
-                struct ost_export_data    eu_ost_data;
                 struct ec_export_data     eu_ec_data;
         } u;
 };
@@ -51,11 +44,9 @@ struct obd_export {
 #define exp_mds_data    u.eu_mds_data
 #define exp_lov_data    u.eu_lov_data
 #define exp_filter_data u.eu_filter_data
-#define exp_ost_data    u.eu_ost_data
 #define exp_ec_data     u.eu_ec_data
 
 extern struct obd_export *class_conn2export(struct lustre_handle *conn);
 extern struct obd_device *class_conn2obd(struct lustre_handle *conn);
-#endif /* __KERNEL__ */
 
 #endif /* __EXPORT_H */
index 341d082..6b0cbfa 100644 (file)
@@ -57,6 +57,8 @@ struct fsfilt_operations {
                                      void *handle, fsfilt_cb_t cb_func);
         int     (* fs_statfs)(struct super_block *sb, struct obd_statfs *osfs);
         int     (* fs_sync)(struct super_block *sb);
+        int     (* fs_prep_san_write)(struct inode *inode, long *blocks,
+                                      int nblocks, loff_t newsize);
 };
 
 extern int fsfilt_register_ops(struct fsfilt_operations *fs_ops);
@@ -77,6 +79,7 @@ extern void fsfilt_put_ops(struct fsfilt_operations *fs_ops);
 static inline void *fsfilt_start(struct obd_device *obd,
                                  struct inode *inode, int op)
 {
+        ENTRY;
         return obd->obd_fsops->fs_start(inode, op);
 }
 
@@ -91,6 +94,7 @@ static inline int fsfilt_commit(struct obd_device *obd, struct inode *inode,
                                 void *handle)
 {
         return obd->obd_fsops->fs_commit(inode, handle);
+        EXIT;
 }
 
 static inline int fsfilt_setattr(struct obd_device *obd, struct dentry *dentry,
@@ -152,6 +156,15 @@ static inline int fsfilt_sync(struct obd_device *obd, struct super_block *fs)
         return obd->obd_fsops->fs_sync(fs);
 }
 
+static inline int fs_prep_san_write(struct obd_device *obd,
+                                    struct inode *inode,
+                                    long *blocks,
+                                    int nblocks,
+                                    loff_t newsize)
+{
+        return obd->obd_fsops->fs_prep_san_write(inode, blocks,
+                                                 nblocks, newsize);
+}
 #endif /* __KERNEL__ */
 
 #endif
diff --git a/lustre/include/linux/lustre_handles.h b/lustre/include/linux/lustre_handles.h
new file mode 100644 (file)
index 0000000..f644cf1
--- /dev/null
@@ -0,0 +1,39 @@
+#ifndef __LINUX_HANDLES_H_
+#define __LINUX_HANDLES_H_
+
+#ifdef __KERNEL__
+#include <asm/types.h>
+#include <asm/atomic.h>
+#include <linux/list.h>
+#endif
+
+typedef void (*portals_handle_addref_cb)(void *object);
+
+/* These handles are most easily used by having them appear at the very top of
+ * whatever object that you want to make handles for.  ie:
+ *
+ * struct ldlm_lock {
+ *         struct portals_handle handle;
+ *         ...
+ * };
+ *
+ * Now you're able to assign the results of cookie2handle directly to an
+ * ldlm_lock.  If it's not at the top, you'll want to hack up a macro that
+ * uses some offsetof() magic. */
+
+struct portals_handle {
+        struct list_head h_link;
+        __u64 h_cookie;
+        portals_handle_addref_cb h_addref;
+};
+
+/* handles.c */
+
+/* Add a handle to the hash table */
+void class_handle_hash(struct portals_handle *, portals_handle_addref_cb);
+void class_handle_unhash(struct portals_handle *);
+void *class_handle2object(__u64 cookie);
+int class_handle_init(void);
+void class_handle_cleanup(void);
+
+#endif
index 6e11240..3ef86ac 100644 (file)
@@ -29,6 +29,7 @@
 # include <asm/types.h>
 # include <linux/types.h>
 # include <linux/list.h>
+# include <linux/string.h> /* for strncpy, below */
 #else
 # define __KERNEL__
 # include <asm/types.h>
@@ -53,8 +54,8 @@ struct obd_uuid {
 
 static inline void obd_str2uuid(struct obd_uuid *uuid, char *tmp)
 {
-        strncpy(uuid->uuid, tmp, sizeof(uuid->uuid));
-        uuid->uuid[sizeof(uuid->uuid) - 1] = '\0';
+        strncpy(uuid->uuid, tmp, sizeof(*uuid));
+        uuid->uuid[sizeof(*uuid) - 1] = '\0';
 }
 
 /* FOO_REQUEST_PORTAL is for incoming requests on the FOO
@@ -64,17 +65,17 @@ static inline void obd_str2uuid(struct obd_uuid *uuid, char *tmp)
 
 #define CONNMGR_REQUEST_PORTAL  1
 #define CONNMGR_REPLY_PORTAL    2
-#define OSC_REQUEST_PORTAL      3
+//#define OSC_REQUEST_PORTAL      3
 #define OSC_REPLY_PORTAL        4
 #define OSC_BULK_PORTAL         5
 #define OST_REQUEST_PORTAL      6
-#define OST_REPLY_PORTAL        7
+//#define OST_REPLY_PORTAL        7
 #define OST_BULK_PORTAL         8
-#define MDC_REQUEST_PORTAL      9
+//#define MDC_REQUEST_PORTAL      9
 #define MDC_REPLY_PORTAL        10
-#define MDC_BULK_PORTAL         11
+//#define MDC_BULK_PORTAL         11
 #define MDS_REQUEST_PORTAL      12
-#define MDS_REPLY_PORTAL        13
+//#define MDS_REPLY_PORTAL        13
 #define MDS_BULK_PORTAL         14
 #define LDLM_CB_REQUEST_PORTAL     15
 #define LDLM_CB_REPLY_PORTAL       16
@@ -83,7 +84,8 @@ static inline void obd_str2uuid(struct obd_uuid *uuid, char *tmp)
 #define PTLBD_REQUEST_PORTAL           19
 #define PTLBD_REPLY_PORTAL             20
 #define PTLBD_BULK_PORTAL              21
-#define MDS_GETATTR_PORTAL      22
+#define MDS_SETATTR_PORTAL      22
+#define MDS_READPAGE_PORTAL     23
 
 #define SVC_KILLED               1
 #define SVC_EVENT                2
@@ -201,6 +203,9 @@ static inline void lustre_msg_set_op_flags(struct lustre_msg *msg, int flags)
 #define OST_OPEN       11
 #define OST_CLOSE      12
 #define OST_STATFS     13
+#define OST_SAN_READ   14
+#define OST_SAN_WRITE  15
+#define OST_SYNCFS     16
 
 
 typedef uint64_t        obd_id;
@@ -221,6 +226,10 @@ typedef uint32_t        obd_count;
 #define OBD_FL_OBDMDEXISTS      (0x00000002)
 
 #define OBD_INLINESZ    60
+#define FD_OSTDATA_SIZE 32
+#if (FD_OSTDATA_SIZE > OBD_INLINESZ)
+# error FD_OSTDATA_SIZE must be smaller than OBD_INLINESZ
+#endif
 
 /* Note: 64-bit types are 64-bit aligned in structure */
 struct obdo {
@@ -282,8 +291,9 @@ struct lov_mds_md {
 #define OBD_MD_FLEASIZE (0x00020000)    /* extended attribute data */
 #define OBD_MD_LINKNAME (0x00040000)    /* symbolic link target */
 #define OBD_MD_FLHANDLE (0x00080000)    /* file handle */
+#define OBD_MD_FLCKSUM  (0x00100000)    /* bulk data checksum */
 #define OBD_MD_FLNOTOBD (~(OBD_MD_FLOBDFLG | OBD_MD_FLBLOCKS | OBD_MD_LINKNAME|\
-                           OBD_MD_FLEASIZE | OBD_MD_FLHANDLE))
+                           OBD_MD_FLEASIZE | OBD_MD_FLHANDLE | OBD_MD_FLCKSUM))
 
 struct obd_statfs {
         __u64           os_type;
@@ -319,7 +329,7 @@ struct niobuf_remote {
         __u32 len;
         __u32 xid;
         __u32 flags;
-};
+} __attribute__((packed));
 
 /* request structure for OST's */
 
@@ -334,16 +344,19 @@ struct ost_body {
  */
 
 /* opcodes */
-#define MDS_GETATTR      1
-#define MDS_GETATTR_NAME 2
-#define MDS_CLOSE        3
-#define MDS_REINT        4
-#define MDS_READPAGE     6
-#define MDS_CONNECT      7
-#define MDS_DISCONNECT   8
-#define MDS_GETSTATUS    9
-#define MDS_STATFS       10
-#define MDS_GETLOVINFO   11
+#define MDS_GETATTR      33
+#define MDS_GETATTR_NAME 34
+#define MDS_CLOSE        35
+#define MDS_REINT        36
+#define MDS_READPAGE     37
+#define MDS_CONNECT      38
+#define MDS_DISCONNECT   39
+#define MDS_GETSTATUS    40
+#define MDS_STATFS       41
+#define MDS_GETLOVINFO   42
+/*
+ * Do not exceed 63 
+ */
 
 #define REINT_SETATTR  1
 #define REINT_CREATE   2
@@ -360,8 +373,6 @@ struct ost_body {
 #define IT_OPEN_CREATE  (1 << 4)
 #define IT_OPEN_OPEN    (1 << 5)
 
-#define IT_UNLINK (1<<8)
-
 #define REINT_OPCODE_MASK 0xff /* opcodes must fit into this mask */
 #define REINT_REPLAYING 0x1000 /* masked into the opcode to indicate replay */
 
@@ -489,6 +500,8 @@ struct mds_rec_rename {
         __u32           rn_fsuid;
         __u32           rn_fsgid;
         __u32           rn_cap;
+        __u32           rn_suppgid1;
+        __u32           rn_suppgid2;
         struct ll_fid   rn_fid1;
         struct ll_fid   rn_fid2;
 };
index 36cd54f..4fc2581 100644 (file)
 #ifndef __IMPORT_H
 #define __IMPORT_H
 
-#ifdef __KERNEL__
 
 #define IMP_INVALID       1
 #define IMP_REPLAYABLE    2
 
-typedef int (*import_recover_t)(struct obd_import *imp, int phase);
 
+struct obd_import;
+typedef int (*import_recover_t)(struct obd_import *imp, int phase);
 #include <linux/lustre_idl.h>
 
 struct obd_import {
@@ -36,18 +36,15 @@ struct obd_import {
         struct obd_device        *imp_obd;
         int                       imp_flags;
         int                       imp_level;
-        __u64                     imp_last_xid;
-        __u64                     imp_last_bulk_xid;
         __u64                     imp_max_transno;
         __u64                     imp_peer_committed_transno;
 
-        /* Protects flags, level, last_xid, *_list */
+        /* Protects flags, level, *_list */
         spinlock_t                imp_lock;
 };
 
 extern struct obd_import *class_conn2cliimp(struct lustre_handle *);
 extern struct obd_import *class_conn2ldlmimp(struct lustre_handle *);
 
-#endif /* __KERNEL__ */
 
 #endif /* __IMPORT_H */
index 54750c0..41c67ff 100644 (file)
 #endif
 #endif
 
-#ifdef __KERNEL__
-/* l_net.c */
+/* target.c */
 struct ptlrpc_request;
 struct obd_device;
 struct recovd_data;
 struct recovd_obd;
 struct obd_export;
 #include <linux/lustre_ha.h>
+#include <linux/lustre_net.h>
+
 
-int target_handle_connect(struct ptlrpc_request *req);
+int target_handle_connect(struct ptlrpc_request *req, svc_handler_t handler);
 int target_handle_disconnect(struct ptlrpc_request *req);
 int target_handle_reconnect(struct lustre_handle *conn, struct obd_export *exp,
                             struct obd_uuid *cluuid);
+int target_revoke_connection(struct recovd_data *rd, int phase);
+
+#define OBD_RECOVERY_TIMEOUT (obd_timeout * 5 * HZ / 2) /* *waves hands* */
+void target_start_recovery_timer(struct obd_device *obd, svc_handler_t handler);
+void target_abort_recovery(void *data);
+int target_queue_recovery_request(struct ptlrpc_request *req,
+                                  struct obd_device *obd);
+int target_queue_final_reply(struct ptlrpc_request *req, int rc);
+
+/* client.c */
 int client_obd_connect(struct lustre_handle *conn, struct obd_device *obd,
                        struct obd_uuid *cluuid, struct recovd_obd *recovd,
                        ptlrpc_recovery_cb_t recover);
 int client_obd_disconnect(struct lustre_handle *conn);
 int client_obd_setup(struct obd_device *obddev, obd_count len, void *buf);
+int client_sanobd_setup(struct obd_device *obddev, obd_count len, void *buf);
 int client_obd_cleanup(struct obd_device * obddev);
 struct client_obd *client_conn2cli(struct lustre_handle *conn);
 struct obd_device *client_tgtuuid2obd(struct obd_uuid *tgtuuid);
 
-int target_revoke_connection(struct recovd_data *rd, int phase);
-
+/* statfs_pack.c */
 int obd_self_statfs(struct obd_device *dev, struct statfs *sfs);
 
 /* l_lock.c */
@@ -113,6 +124,8 @@ int lustre_fread(struct file *file, char *str, int len, loff_t *off);
 int lustre_fwrite(struct file *file, const char *str, int len, loff_t *off);
 int lustre_fsync(struct file *file);
 
+#ifdef __KERNEL__
+
 static inline void l_dput(struct dentry *de)
 {
         if (!de || IS_ERR(de))
@@ -148,7 +161,7 @@ static inline void ldlm_object2handle(void *object, struct lustre_handle *handle
 /*
  *   OBD IOCTLS
  */
-#define OBD_IOCTL_VERSION 0x00010001
+#define OBD_IOCTL_VERSION 0x00010002
 
 struct obd_ioctl_data {
         uint32_t ioc_len;
@@ -165,7 +178,10 @@ struct obd_ioctl_data {
         obd_size         ioc_count;
         obd_off          ioc_offset;
         uint32_t         ioc_dev;
-        uint32_t         ____padding;
+        uint32_t         ioc_command;
+
+        uint64_t ioc_nid;
+        uint32_t ioc_nal;
 
         /* buffers the kernel will treat as user pointers */
         uint32_t ioc_plen1;
@@ -260,8 +276,9 @@ static inline int obd_ioctl_is_invalid(struct obd_ioctl_data *data)
                 printk("OBD ioctl: plen2 set but NULL pointer\n");
                 return 1;
         }
-        if (obd_ioctl_packlen(data) != data->ioc_len ) {
-                printk("OBD ioctl: packlen exceeds ioc_len\n");
+        if (obd_ioctl_packlen(data) != data->ioc_len) {
+                printk("OBD ioctl: packlen exceeds ioc_len (%d != %d)\n",
+                       obd_ioctl_packlen(data), data->ioc_len);
                 return 1;
         }
 #if 0
@@ -344,7 +361,7 @@ static inline int obd_ioctl_unpack(struct obd_ioctl_data *data, char *pbuf,
 
         return 0;
 }
-#else
+#endif
 
 #include <linux/obd_support.h>
 
@@ -415,7 +432,6 @@ static inline int obd_ioctl_getdata(char **buf, int *len, void *arg)
         EXIT;
         return 0;
 }
-#endif
 
 #define OBD_IOC_CREATE                 _IOR ('f', 101, long)
 #define OBD_IOC_SETUP                  _IOW ('f', 102, long)
@@ -464,12 +480,34 @@ static inline int obd_ioctl_getdata(char **buf, int *len, void *arg)
 
 #define OBD_GET_VERSION                _IOWR ('f', 144, long)
 
+#define OBD_IOC_ADD_UUID               _IOWR ('f', 145, long)
+#define OBD_IOC_DEL_UUID               _IOWR ('f', 146, long)
+#define OBD_IOC_CLOSE_UUID             _IOWR ('f', 147, long)
+
 #define ECHO_IOC_GET_STRIPE            _IOWR('f', 200, long)
 #define ECHO_IOC_SET_STRIPE            _IOWR('f', 201, long)
 #define ECHO_IOC_ENQUEUE               _IOWR('f', 202, long)
 #define ECHO_IOC_CANCEL                _IOWR('f', 203, long)
 
 
+#define CHECKSUM_BULK 0
+
+#if CHECKSUM_BULK
+static inline void ost_checksum(__u64 *cksum, void *addr, int len)
+{
+        unsigned char *ptr = (unsigned char *)addr;
+        __u64          sum = 0;
+
+        /* very stupid, but means I don't have to think about byte order */
+        while (len-- > 0)
+                sum += *ptr++;
+
+        *cksum = (*cksum << 2) + sum;
+}
+#else
+#define ost_checksum(cksum, addr, len) do {} while (0)
+#endif
+
 /*
  * l_wait_event is a flexible sleeping function, permitting simple caller
  * configuration of interrupt and timeout sensitivity along with actions to
@@ -537,11 +575,17 @@ struct l_wait_info {
         lwi_cb_data:    data                                                   \
 })
 
+#ifdef __KERNEL__
+#define l_sigismember sigismember
+#else
+#define l_sigismember(a,b) (*(a) & b)
+#endif
+
 /* XXX this should be one mask-check */
 #define l_killable_pending(task)                                               \
-(sigismember(&(task->pending.signal), SIGKILL) ||                              \
- sigismember(&(task->pending.signal), SIGINT) ||                               \
- sigismember(&(task->pending.signal), SIGTERM))
+(l_sigismember(&(task->pending.signal), SIGKILL) ||                              \
l_sigismember(&(task->pending.signal), SIGINT) ||                               \
l_sigismember(&(task->pending.signal), SIGTERM))
 
 #define __l_wait_event(wq, condition, info, ret)                               \
 do {                                                                           \
index 0c56fcd..0c29c79 100644 (file)
 #include <linux/lustre_mds.h>
 #include <linux/lustre_ha.h>
 
+
 extern kmem_cache_t *ll_file_data_slab;
 struct ll_file_data {
         struct lustre_handle fd_mdshandle;
-        struct lustre_handle fd_osthandle;
         struct ptlrpc_request *fd_req;
+        char fd_ostdata[FD_OSTDATA_SIZE];
         __u32 fd_flags;
 };
 
@@ -51,12 +52,10 @@ struct ll_read_inode2_cookie {
         struct lov_mds_md *lic_lmm;
 };
 
-#define LL_INLINESZ      60
 struct ll_inode_info {
         struct lov_stripe_md *lli_smd;
         char                 *lli_symlink_name;
         struct semaphore      lli_open_sem;
-        atomic_t              lli_open_count; /* see ll_file_release */
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
         struct inode          lli_vfs_inode;
 #endif
@@ -245,13 +244,13 @@ extern struct file_operations ll_file_operations;
 extern struct inode_operations ll_file_inode_operations;
 extern struct inode_operations ll_special_inode_operations;
 struct ldlm_lock;
-int ll_lock_callback(struct ldlm_lock *, struct ldlm_lock_desc *, void *data, int flag);
+int ll_lock_callback(struct ldlm_lock *, struct ldlm_lock_desc *, void *data,
+                     int flag);
 int ll_size_lock(struct inode *, struct lov_stripe_md *, obd_off start,
                  int mode, struct lustre_handle *);
 int ll_size_unlock(struct inode *, struct lov_stripe_md *, int mode,
                    struct lustre_handle *);
-int ll_file_size(struct inode *inode, struct lov_stripe_md *md,
-                 struct lustre_handle *);
+int ll_file_size(struct inode *inode, struct lov_stripe_md *md, char *ostdata);
 int ll_create_objects(struct super_block *sb, obd_id id, uid_t uid,
                       gid_t gid, struct lov_stripe_md **lsmp);
 
@@ -262,6 +261,7 @@ void ll_truncate(struct inode *inode);
 
 /* super.c */
 void ll_update_inode(struct inode *, struct mds_body *, struct lov_mds_md *);
+int ll_setattr_raw(struct inode *inode, struct iattr *attr);
 
 /* symlink.c */
 extern struct inode_operations ll_fast_symlink_inode_operations;
index 133f7af..0a881b1 100644 (file)
@@ -27,8 +27,8 @@
 #define _LUSTRE_MDS_H
 
 #ifdef __KERNEL__
-
 #include <linux/fs.h>
+#endif
 #include <linux/kp30.h>
 #include <linux/lustre_idl.h>
 
@@ -45,11 +45,12 @@ struct ll_file_data;
 #define LUSTRE_MDT_NAME "mdt"
 #define LUSTRE_MDC_NAME "mdc"
 
-struct mdc_rpc_lock { 
+struct mdc_rpc_lock {
         struct semaphore rpcl_sem;
         struct lookup_intent *rpcl_it;
 };
 extern struct mdc_rpc_lock mdc_rpc_lock;
+extern struct mdc_rpc_lock mdc_setattr_lock;
 
 static inline void mdc_init_rpc_lock(struct mdc_rpc_lock *lck)
 {
@@ -108,7 +109,8 @@ struct mds_update_record {
         __u32 ur_gid;
         __u64 ur_time;
         __u32 ur_flags;
-        __u32 ur_suppgid;
+        __u32 ur_suppgid1;
+        __u32 ur_suppgid2;
 };
 
 #define MDS_LR_CLIENT  8192
@@ -117,13 +119,12 @@ struct mds_update_record {
 #define MDS_CLIENT_SLOTS 17
 
 #define MDS_MOUNT_RECOV 2
-#define MDS_RECOVERY_TIMEOUT (obd_timeout * 5 * HZ / 2) /* *waves hands* */
 
 /* Data stored per server at the head of the last_rcvd file.  In le32 order. */
 struct mds_server_data {
         __u8 msd_uuid[37];      /* server UUID */
         __u8 uuid_padding[3];   /* unused */
-        __u64 msd_last_rcvd;    /* last completed transaction ID */
+        __u64 msd_last_transno; /* last completed transaction ID */
         __u64 msd_mount_count;  /* MDS incarnation number */
         __u8 padding[512 - 56];
 };
@@ -132,10 +133,12 @@ struct mds_server_data {
 struct mds_client_data {
         __u8 mcd_uuid[37];      /* client UUID */
         __u8 uuid_padding[3];   /* unused */
-        __u64 mcd_last_rcvd;    /* last completed transaction ID */
         __u64 mcd_mount_count;  /* MDS incarnation number */
-        __u64 mcd_last_xid;     /* client RPC xid for the last transaction */
-        __u8 padding[MDS_LR_SIZE - 64];
+        __u64 mcd_last_transno; /* last completed transaction ID */
+        __u64 mcd_last_xid;     /* xid for the last transaction */
+        __u32 mcd_last_result;  /* result from last RPC */
+        __u32 mcd_last_data;    /* per-op data (disposition for open &c.) */
+        __u8 padding[MDS_LR_SIZE - 58];
 };
 
 /* In-memory access to client data from MDS struct */
@@ -144,15 +147,14 @@ struct mds_export_data {
         spinlock_t              med_open_lock;
         struct mds_client_data *med_mcd;
         int                     med_off;
-        __u64                   med_last_xid;
-        struct lustre_msg      *med_last_reply;
-        int                     med_last_replen;
+        struct ptlrpc_request  *med_outstanding_reply;
 };
 
 /* file data for open files on MDS */
 struct mds_file_data {
         struct list_head     mfd_list;
         __u64                mfd_servercookie;
+        __u64                mfd_xid;
         struct file         *mfd_file;
 };
 
@@ -212,6 +214,8 @@ struct dentry *mds_fid2dentry(struct mds_obd *mds, struct ll_fid *fid,
 int mds_reint(struct ptlrpc_request *req, int offset, struct lustre_handle *);
 int mds_pack_md(struct obd_device *mds, struct lustre_msg *msg,
                 int offset, struct mds_body *body, struct inode *inode);
+void mds_steal_ack_locks(struct mds_export_data *med,
+                         struct ptlrpc_request *req);
 
 /* mds/mds_fs.c */
 int mds_fs_setup(struct obd_device *obddev, struct vfsmount *mnt);
@@ -268,7 +272,6 @@ int mds_client_add(struct mds_obd *mds, struct mds_export_data *med,
                    int cl_off);
 int mds_client_free(struct obd_export *exp);
 
-#endif /* __KERNEL__ */
 
 /* ioctls for trying requests */
 #define IOC_REQUEST_TYPE                   'f'
@@ -282,4 +285,18 @@ int mds_client_free(struct obd_export *exp);
 #define IOC_REQUEST_CLOSE               _IOWR('f', 35, long)
 #define IOC_REQUEST_MAX_NR               35
 
+#define MDS_CHECK_RESENT(req, reconstruct)                                     \
+{                                                                              \
+        if (lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT) {               \
+                struct mds_client_data *mcd =                                  \
+                        req->rq_export->exp_mds_data.med_mcd;                  \
+                if (mcd->mcd_last_xid == req->rq_xid) {                        \
+                        reconstruct;                                           \
+                        RETURN(0);                                             \
+                }                                                              \
+                DEBUG_REQ(D_HA, req, "no reply for RESENT req (have "LPD64")", \
+                          mcd->mcd_last_xid);                                  \
+        }                                                                      \
+}
+
 #endif
index e2c9db3..8c50212 100644 (file)
 #ifndef _LUSTRE_NET_H
 #define _LUSTRE_NET_H
 
+#ifdef __KERNEL__
+#include <linux/version.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 #include <linux/tqueue.h>
+#else
+#include <linux/workqueue.h>
+#endif
+#endif 
+
 #include <linux/kp30.h>
 // #include <linux/obd.h>
 #include <portals/p30.h>
 
 #define CONN_INVALID 1
 
+struct ptlrpc_peer {
+        ptl_nid_t         peer_nid;
+        struct ptlrpc_ni *peer_ni;
+};
+
 struct ptlrpc_connection {
         struct list_head        c_link;
-        struct lustre_peer      c_peer;
+        struct ptlrpc_peer      c_peer;
         struct obd_uuid         c_local_uuid;  /* XXX do we need this? */
         struct obd_uuid         c_remote_uuid;
 
@@ -134,19 +147,21 @@ struct ptlrpc_client {
 };
 
 /* state flags of requests */
-#define PTL_RPC_FL_INTR      (1 << 0)
+#define PTL_RPC_FL_INTR      (1 << 0)  /* reply wait was interrupted by user */
 #define PTL_RPC_FL_REPLIED   (1 << 1)  /* reply was received */
-#define PTL_RPC_FL_SENT      (1 << 2)
-#define PTL_BULK_FL_SENT     (1 << 3)
-#define PTL_BULK_FL_RCVD     (1 << 4)
-#define PTL_RPC_FL_ERR       (1 << 5)
-#define PTL_RPC_FL_TIMEOUT   (1 << 6)
-#define PTL_RPC_FL_RESEND    (1 << 7)
-#define PTL_RPC_FL_RESTART   (1 << 8)  /* operation must be restarted */
-#define PTL_RPC_FL_FINISHED  (1 << 9)
+#define PTL_RPC_FL_SENT      (1 << 2)  /* request was sent */
+#define PTL_RPC_FL_WANT_ACK  (1 << 3)  /* reply is awaiting an ACK */
+#define PTL_BULK_FL_SENT     (1 << 4)  /* outgoing bulk was sent */
+#define PTL_BULK_FL_RCVD     (1 << 5)  /* incoming bulk was recieved */
+#define PTL_RPC_FL_ERR       (1 << 6)  /* request failed due to RPC error */
+#define PTL_RPC_FL_TIMEOUT   (1 << 7)  /* request timed out waiting for reply */
+#define PTL_RPC_FL_RESEND    (1 << 8)  /* retransmit the request */
+#define PTL_RPC_FL_RESTART   (1 << 9)  /* operation must be restarted */
 #define PTL_RPC_FL_RETAIN    (1 << 10) /* retain for replay after reply */
 #define PTL_RPC_FL_REPLAY    (1 << 11) /* replay upon recovery */
 #define PTL_RPC_FL_ALLOCREP  (1 << 12) /* reply buffer allocated */
+#define PTL_RPC_FL_NO_RESEND (1 << 13) /* don't automatically resend this req */
+#define PTL_RPC_FL_RESENT    (1 << 14) /* server rcvd resend of this req */
 
 struct ptlrpc_request {
         int rq_type; /* one of PTL_RPC_MSG_* */
@@ -168,8 +183,7 @@ struct ptlrpc_request {
         __u64 rq_xid;
 
         int rq_level;
-        //        void * rq_reply_handle;
-        wait_queue_head_t rq_wait_for_rep;
+        wait_queue_head_t rq_wait_for_rep; /* XXX also _for_ack */
 
         /* incoming reply */
         ptl_md_t rq_reply_md;
@@ -178,7 +192,7 @@ struct ptlrpc_request {
         /* outgoing req/rep */
         ptl_md_t rq_req_md;
 
-        struct lustre_peer rq_peer; /* XXX see service.c can this be factored away? */
+        struct ptlrpc_peer rq_peer; /* XXX see service.c can this be factored away? */
         struct obd_export *rq_export;
         struct ptlrpc_connection *rq_connection;
         struct obd_import *rq_import;
@@ -186,6 +200,12 @@ struct ptlrpc_request {
 
         void (*rq_replay_cb)(struct ptlrpc_request *);
         void  *rq_replay_data;
+
+        /* Only used on the server side for tracking acks. */
+        struct ptlrpc_req_ack_lock {
+                struct lustre_handle lock;
+                __u32                mode;
+        } rq_ack_locks[4];
 };
 
 #define DEBUG_REQ(level, req, fmt, args...)                                    \
@@ -259,41 +279,57 @@ struct ptlrpc_thread {
 
 struct ptlrpc_request_buffer_desc {
         struct list_head       rqbd_list;
-        struct ptlrpc_service *rqbd_service;
+        struct ptlrpc_srv_ni  *rqbd_srv_ni;
         ptl_handle_me_t        rqbd_me_h;
         atomic_t               rqbd_refcount;
         char                  *rqbd_buffer;
 };
 
+struct ptlrpc_ni {
+        /* Generic interface state */
+        char                   *pni_name;
+        ptl_handle_ni_t         pni_ni_h;
+        ptl_handle_eq_t         pni_request_out_eq_h;
+        ptl_handle_eq_t         pni_reply_in_eq_h;
+        ptl_handle_eq_t         pni_reply_out_eq_h;
+        ptl_handle_eq_t         pni_bulk_put_source_eq_h;
+        ptl_handle_eq_t         pni_bulk_put_sink_eq_h;
+        ptl_handle_eq_t         pni_bulk_get_source_eq_h;
+        ptl_handle_eq_t         pni_bulk_get_sink_eq_h;
+};
+
+struct ptlrpc_srv_ni {
+        /* Interface-specific service state */
+        struct ptlrpc_service  *sni_service;    /* owning service */
+        struct ptlrpc_ni       *sni_ni;         /* network interface */
+        ptl_handle_eq_t         sni_eq_h;       /* event queue handle */
+        struct list_head        sni_rqbds;      /* all the request buffer descriptors */
+        __u32                   sni_nrqbds;     /* # request buffers */
+        atomic_t                sni_nrqbds_receiving; /* # request buffers posted */
+};
+
 struct ptlrpc_service {
         time_t srv_time;
         time_t srv_timeout;
 
-        /* incoming request buffers */
-        /* FIXME: perhaps a list of EQs, if multiple NIs are used? */
-
+        struct list_head srv_ni_list;          /* list of interfaces */
         __u32            srv_max_req_size;     /* biggest request to receive */
         __u32            srv_buf_size;         /* # bytes in a request buffer */
-        struct list_head srv_rqbds;            /* all the request buffer descriptors */
-        __u32            srv_nrqbds;           /* # request buffers */
-        atomic_t         srv_nrqbds_receiving; /* # request buffers posted for input */
 
         __u32 srv_req_portal;
         __u32 srv_rep_portal;
 
         __u32 srv_xid;
 
-        /* event queue */
-        ptl_handle_eq_t srv_eq_h;
-
-        struct lustre_peer srv_self;
-
         wait_queue_head_t srv_waitq; /* all threads sleep on this */
 
         spinlock_t srv_lock;
         struct list_head srv_threads;
         int (*srv_handler)(struct ptlrpc_request *req);
         char *srv_name;  /* only statically allocated strings here; we don't clean them */
+
+        int                  srv_interface_rover;
+        struct ptlrpc_srv_ni srv_interfaces[0];
 };
 
 static inline void ptlrpc_hdl2req(struct ptlrpc_request *req,
@@ -307,9 +343,14 @@ typedef void (*bulk_callback_t)(struct ptlrpc_bulk_desc *, void *);
 
 typedef int (*svc_handler_t)(struct ptlrpc_request *req);
 
+/* rpc/events.c */
+extern struct ptlrpc_ni ptlrpc_interfaces[];
+extern int              ptlrpc_ninterfaces;
+extern int ptlrpc_uuid_to_peer (struct obd_uuid *uuid, struct ptlrpc_peer *peer);
+
 /* rpc/connection.c */
 void ptlrpc_readdress_connection(struct ptlrpc_connection *, struct obd_uuid *uuid);
-struct ptlrpc_connection *ptlrpc_get_connection(struct lustre_peer *peer,
+struct ptlrpc_connection *ptlrpc_get_connection(struct ptlrpc_peer *peer,
                                                 struct obd_uuid *uuid);
 int ptlrpc_put_connection(struct ptlrpc_connection *c);
 struct ptlrpc_connection *ptlrpc_connection_addref(struct ptlrpc_connection *);
@@ -326,6 +367,7 @@ int ptlrpc_register_bulk_get(struct ptlrpc_bulk_desc *);
 int ptlrpc_abort_bulk(struct ptlrpc_bulk_desc *bulk);
 struct obd_brw_set *obd_brw_set_new(void);
 void obd_brw_set_add(struct obd_brw_set *, struct ptlrpc_bulk_desc *);
+void obd_brw_set_del(struct ptlrpc_bulk_desc *);
 void obd_brw_set_free(struct obd_brw_set *);
 
 int ptlrpc_reply(struct ptlrpc_service *svc, struct ptlrpc_request *req);
@@ -346,6 +388,7 @@ int ll_brw_sync_wait(struct obd_brw_set *, int phase);
 int ptlrpc_queue_wait(struct ptlrpc_request *req);
 void ptlrpc_continue_req(struct ptlrpc_request *req);
 int ptlrpc_replay_req(struct ptlrpc_request *req);
+int ptlrpc_abort(struct ptlrpc_request *req);
 void ptlrpc_restart_req(struct ptlrpc_request *req);
 void ptlrpc_abort_inflight(struct obd_import *imp, int dying_import);
 
@@ -364,8 +407,7 @@ void ptlrpc_retain_replayable_request(struct ptlrpc_request *req,
 /* rpc/service.c */
 struct ptlrpc_service *
 ptlrpc_init_svc(__u32 nevents, __u32 nbufs, __u32 bufsize, __u32 max_req_size,
-                int req_portal, int rep_portal,
-                struct obd_uuid *uuid, svc_handler_t, char *name);
+                int req_portal, int rep_portal, svc_handler_t, char *name);
 void ptlrpc_stop_all_threads(struct ptlrpc_service *svc);
 int ptlrpc_start_thread(struct obd_device *dev, struct ptlrpc_service *svc,
                         char *name);
@@ -385,6 +427,9 @@ int lustre_msg_size(int count, int *lengths);
 int lustre_unpack_msg(struct lustre_msg *m, int len);
 void *lustre_msg_buf(struct lustre_msg *m, int n);
 
+/* rpc/rpc.c */
+__u32 ptlrpc_next_xid(void);
+
 static inline void ptlrpc_bulk_decref(struct ptlrpc_bulk_desc *desc)
 {
         CDEBUG(D_PAGE, "%p -> %d\n", desc, atomic_read(&desc->bd_refcount) - 1);
index acc59c2..f3163fe 100644 (file)
@@ -38,6 +38,8 @@ struct lov_stripe_md {
 #ifdef __KERNEL__
 # include <linux/fs.h>
 # include <linux/list.h>
+# include <linux/sched.h> /* for struct task_struct, for current.h */
+# include <asm/current.h> /* for smp_lock.h */
 # include <linux/smp_lock.h>
 # include <linux/proc_fs.h>
 
@@ -45,6 +47,7 @@ struct lov_stripe_md {
 # include <linux/lustre_idl.h>
 # include <linux/lustre_mds.h>
 # include <linux/lustre_export.h>
+#endif
 
 struct obd_type {
         struct list_head typ_chain;
@@ -72,7 +75,8 @@ struct obd_ucred {
         __u32 ouc_fsuid;
         __u32 ouc_fsgid;
         __u32 ouc_cap;
-        __u32 ouc_suppgid;
+        __u32 ouc_suppgid1;
+        __u32 ouc_suppgid2;
 };
 
 #define OBD_RUN_CTXT_MAGIC      0xC0FFEEAA
@@ -98,6 +102,12 @@ struct obd_run_ctxt {
 
 struct ost_server_data;
 
+#define FILTER_TRANSNO_SEM
+
+#ifndef OST_RECOVERY
+#undef FILTER_TRANSNO_SEM
+#endif
+
 struct filter_obd {
         char *fo_fstype;
         struct super_block *fo_sb;
@@ -105,18 +115,23 @@ struct filter_obd {
         struct obd_run_ctxt fo_ctxt;
         struct dentry *fo_dentry_O;
         struct dentry *fo_dentry_O_mode[16];
+        struct dentry **fo_dentry_O_sub;
         spinlock_t fo_objidlock;        /* protects fo_lastobjid increment */
+#ifdef FILTER_TRANSNO_SEM
         struct semaphore fo_transno_sem;
+#else
+        spinlock_t fo_translock;        /* protects fsd_last_rcvd increment */
+#endif
         struct file *fo_rcvd_filp;
         struct filter_server_data *fo_fsd;
+        unsigned long *fo_last_rcvd_slots;
 
-        __u64 fo_next_recovery_transno;
-        int   fo_recoverable_clients;
         struct file_operations *fo_fop;
         struct inode_operations *fo_iop;
         struct address_space_operations *fo_aops;
         struct list_head fo_export_list;
         spinlock_t fo_fddlock;          /* protects setting dentry->d_fsdata */
+        int fo_subdir_count;
 };
 
 struct mds_server_data;
@@ -130,11 +145,13 @@ struct client_obd {
          * call obd_size_wiremd() all the time. */
         int                  cl_max_mds_easize;
         struct obd_device   *cl_containing_lov;
+        kdev_t               cl_sandev;
 };
 
 struct mds_obd {
         struct ptlrpc_service           *mds_service;
-        struct ptlrpc_service           *mds_getattr_service;
+        struct ptlrpc_service           *mds_setattr_service;
+        struct ptlrpc_service           *mds_readpage_service;
 
         struct super_block              *mds_sb;
         struct vfsmount                 *mds_vfsmnt;
@@ -145,21 +162,12 @@ struct mds_obd {
 
         int                              mds_max_mdsize;
         struct file                     *mds_rcvd_filp;
-        struct semaphore                 mds_transno_sem;
-        __u64                            mds_last_rcvd;
+        spinlock_t                       mds_transno_lock;
+        __u64                            mds_last_transno;
         __u64                            mds_mount_count;
         struct ll_fid                    mds_rootfid;
         struct mds_server_data          *mds_server_data;
 
-        wait_queue_head_t                mds_next_transno_waitq;
-        __u64                            mds_next_recovery_transno;
-        int                              mds_recoverable_clients;
-        struct list_head                 mds_recovery_queue;
-        struct list_head                 mds_delayed_reply_queue;
-        spinlock_t                       mds_processing_task_lock;
-        pid_t                            mds_processing_task;
-        struct timer_list                mds_recovery_timer;
-        
         int                              mds_has_lov_desc;
         struct lov_desc                  mds_lov_desc;
 };
@@ -267,12 +275,13 @@ struct niobuf_local {
         struct dentry *dentry;
 };
 
+/* Don't conflict with on-wire flags OBD_BRW_WRITE, etc */
+#define N_LOCAL_TEMP_PAGE 0x10000000
+
 struct obd_trans_info {
         __u64     oti_transno;
 };
 
-#define N_LOCAL_TEMP_PAGE 0x00000001
-
 /* corresponds to one of the obd's */
 struct obd_device {
         struct obd_type *obd_type;
@@ -292,6 +301,18 @@ struct obd_device {
         spinlock_t obd_dev_lock;
         __u64                  obd_last_committed;
         struct fsfilt_operations *obd_fsops;
+
+        /* XXX encapsulate all this recovery data into one struct */
+        svc_handler_t                    obd_recovery_handler;
+        int                              obd_recoverable_clients;
+        spinlock_t                       obd_processing_task_lock;
+        pid_t                            obd_processing_task;
+        __u64                            obd_next_recovery_transno;
+        wait_queue_head_t                obd_next_transno_waitq;
+        struct timer_list                obd_recovery_timer;
+        struct list_head                 obd_recovery_queue;
+        struct list_head                 obd_delayed_reply_queue;
+
         union {
                 struct ext2_obd ext2;
                 struct filter_obd filter;
@@ -334,6 +355,7 @@ struct obd_ops {
 
 
         int (*o_statfs)(struct lustre_handle *conn, struct obd_statfs *osfs);
+        int (*o_syncfs)(struct lustre_handle *conn);
         int (*o_packmd)(struct lustre_handle *, struct lov_mds_md **wire_tgt,
                         struct lov_stripe_md *mem_src);
         int (*o_unpackmd)(struct lustre_handle *,
@@ -355,7 +377,7 @@ struct obd_ops {
                        struct lov_stripe_md *ea, struct obd_trans_info *oti);
         int (*o_brw)(int rw, struct lustre_handle *conn,
                      struct lov_stripe_md *ea, obd_count oa_bufs,
-                     struct brw_page *pgarr, struct obd_brw_set *, 
+                     struct brw_page *pgarr, struct obd_brw_set *,
                      struct obd_trans_info *oti);
         int (*o_punch)(struct lustre_handle *conn, struct obdo *tgt,
                        struct lov_stripe_md *ea, obd_size count,
@@ -388,6 +410,8 @@ struct obd_ops {
                         __u32 mode, struct lustre_handle *);
         int (*o_cancel_unused)(struct lustre_handle *, struct lov_stripe_md *,
                                int local_only);
+        int (*o_san_preprw)(int cmd, struct lustre_handle *conn,
+                            int objcount, struct obd_ioobj *obj,
+                            int niocount, struct niobuf_remote *remote);
 };
-#endif /* __KERNEL */
 #endif /* __OBD_H */
index 8e160ad..f626bab 100644 (file)
 #include <linux/types.h>
 #include <linux/fs.h>
 #include <linux/time.h>
+#endif 
 
 #include <linux/obd_support.h>
+#include <linux/lustre_import.h>
+#include <linux/lustre_net.h>
 #include <linux/obd.h>
 #include <linux/lustre_lib.h>
 #include <linux/lustre_idl.h>
 #include <linux/lustre_mds.h>
 #include <linux/lustre_dlm.h>
 #include <linux/lprocfs_status.h>
-#endif
+
 
 /* OBD Device Declarations */
 #define MAX_OBD_DEVICES 128
@@ -56,8 +59,9 @@ extern struct obd_device obd_dev[MAX_OBD_DEVICES];
 #define OBD_NO_TRANSNO     0x20 /* XXX needs better name */
 
 /* OBD Operations Declarations */
+extern struct obd_device *class_conn2obd(struct lustre_handle *);
+extern struct obd_export *class_conn2export(struct lustre_handle *);
 
-#ifdef __KERNEL__
 static inline int obd_check_conn(struct lustre_handle *conn)
 {
         struct obd_device *obd;
@@ -65,6 +69,7 @@ static inline int obd_check_conn(struct lustre_handle *conn)
                 CERROR("NULL conn\n");
                 RETURN(-ENOTCONN);
         }
+
         obd = class_conn2obd(conn);
         if (!obd) {
                 CERROR("NULL obd\n");
@@ -408,6 +413,19 @@ static inline int obd_statfs(struct lustre_handle *conn,struct obd_statfs *osfs)
         RETURN(rc);
 }
 
+static inline int obd_syncfs(struct lustre_handle *conn)
+{
+        struct obd_export *exp;
+        int rc;
+        ENTRY;
+
+        OBD_CHECK_SETUP(conn, exp);
+        OBD_CHECK_OP(exp->exp_obd, syncfs);
+
+        rc = OBP(exp->exp_obd, syncfs)(conn);
+        RETURN(rc);
+}
+
 static inline int obd_punch(struct lustre_handle *conn, struct obdo *oa,
                             struct lov_stripe_md *ea, obd_size start,
                             obd_size end, struct obd_trans_info *oti)
@@ -542,7 +560,21 @@ static inline int obd_cancel_unused(struct lustre_handle *conn,
         RETURN(rc);
 }
 
-#endif
+static inline int obd_san_preprw(int cmd, struct lustre_handle *conn,
+                                 int objcount, struct obd_ioobj *obj,
+                                 int niocount, struct niobuf_remote *remote)
+{
+        struct obd_export *exp;
+        int rc;
+
+        OBD_CHECK_SETUP(conn, exp);
+        OBD_CHECK_OP(exp->exp_obd, preprw);
+
+        rc = OBP(exp->exp_obd, san_preprw)(cmd, conn, objcount, obj,
+                                           niocount, remote);
+        RETURN(rc);
+}
+
 
 /* OBD Metadata Support */
 
@@ -554,24 +586,6 @@ static inline struct lustre_handle *obdo_handle(struct obdo *oa)
         return (struct lustre_handle *)&oa->o_inline;
 }
 
-static inline void obd_oa2handle(struct lustre_handle *handle, struct obdo *oa)
-{
-        if (oa->o_valid |= OBD_MD_FLHANDLE) {
-                struct lustre_handle *oa_handle = obdo_handle(oa);
-                memcpy(handle, oa_handle, sizeof(*handle));
-        }
-}
-
-static inline void obd_handle2oa(struct obdo *oa, struct lustre_handle *handle)
-{
-        if (handle && handle->addr) {
-                struct lustre_handle *oa_handle = obdo_handle(oa);
-                memcpy(oa_handle, handle, sizeof(*handle));
-                oa->o_valid |= OBD_MD_FLHANDLE;
-        }
-}
-
-#ifdef __KERNEL__
 /* support routines */
 extern kmem_cache_t *obdo_cachep;
 static inline struct obdo *obdo_alloc(void)
@@ -593,10 +607,12 @@ static inline void obdo_free(struct obdo *oa)
         kmem_cache_free(obdo_cachep, oa);
 }
 
+#ifdef __KERNEL__
 static inline void obdo_from_iattr(struct obdo *oa, struct iattr *attr)
 {
         unsigned int ia_valid = attr->ia_valid;
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
         if (ia_valid & ATTR_ATIME) {
                 oa->o_atime = attr->ia_atime;
                 oa->o_valid |= OBD_MD_FLATIME;
@@ -609,6 +625,21 @@ static inline void obdo_from_iattr(struct obdo *oa, struct iattr *attr)
                 oa->o_ctime = attr->ia_ctime;
                 oa->o_valid |= OBD_MD_FLCTIME;
         }
+#else
+        if (ia_valid & ATTR_ATIME) {
+                oa->o_atime = attr->ia_atime.tv_sec;
+                oa->o_valid |= OBD_MD_FLATIME;
+        }
+        if (ia_valid & ATTR_MTIME) {
+                oa->o_mtime = attr->ia_mtime.tv_sec;
+                oa->o_valid |= OBD_MD_FLMTIME;
+        }
+        if (ia_valid & ATTR_CTIME) {
+                oa->o_ctime = attr->ia_ctime.tv_sec;
+                oa->o_valid |= OBD_MD_FLCTIME;
+        }
+#endif
+
         if (ia_valid & ATTR_SIZE) {
                 oa->o_size = attr->ia_size;
                 oa->o_valid |= OBD_MD_FLSIZE;
@@ -634,6 +665,7 @@ static inline void iattr_from_obdo(struct iattr *attr, struct obdo *oa,
                                    obd_flag valid)
 {
         memset(attr, 0, sizeof(*attr));
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
         if (valid & OBD_MD_FLATIME) {
                 attr->ia_atime = oa->o_atime;
                 attr->ia_valid |= ATTR_ATIME;
@@ -646,6 +678,20 @@ static inline void iattr_from_obdo(struct iattr *attr, struct obdo *oa,
                 attr->ia_ctime = oa->o_ctime;
                 attr->ia_valid |= ATTR_CTIME;
         }
+#else
+        if (valid & OBD_MD_FLATIME) {
+                attr->ia_atime.tv_sec = oa->o_atime;
+                attr->ia_valid |= ATTR_ATIME;
+        }
+        if (valid & OBD_MD_FLMTIME) {
+                attr->ia_mtime.tv_sec = oa->o_mtime;
+                attr->ia_valid |= ATTR_MTIME;
+        }
+        if (valid & OBD_MD_FLCTIME) {
+                attr->ia_ctime.tv_sec = oa->o_ctime;
+                attr->ia_valid |= ATTR_CTIME;
+        }
+#endif
         if (valid & OBD_MD_FLSIZE) {
                 attr->ia_size = oa->o_size;
                 attr->ia_valid |= ATTR_SIZE;
@@ -683,12 +729,21 @@ static inline void iattr_from_obdo(struct iattr *attr, struct obdo *oa,
 static inline void obdo_from_inode(struct obdo *dst, struct inode *src,
                                    obd_flag valid)
 {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
         if (valid & OBD_MD_FLATIME)
                 dst->o_atime = src->i_atime;
         if (valid & OBD_MD_FLMTIME)
                 dst->o_mtime = src->i_mtime;
         if (valid & OBD_MD_FLCTIME)
                 dst->o_ctime = src->i_ctime;
+#else
+        if (valid & OBD_MD_FLATIME)
+                dst->o_atime = src->i_atime.tv_sec;
+        if (valid & OBD_MD_FLMTIME)
+                dst->o_mtime = src->i_mtime.tv_sec;
+        if (valid & OBD_MD_FLCTIME)
+                dst->o_ctime = src->i_ctime.tv_sec;
+#endif
         if (valid & OBD_MD_FLSIZE)
                 dst->o_size = src->i_size;
         if (valid & OBD_MD_FLBLOCKS)   /* allocation of space */
@@ -720,12 +775,21 @@ static inline void obdo_to_inode(struct inode *dst, struct obdo *src,
 {
         valid &= src->o_valid;
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
         if (valid & OBD_MD_FLATIME)
                 dst->i_atime = src->o_atime;
         if (valid & OBD_MD_FLMTIME)
                 dst->i_mtime = src->o_mtime;
         if (valid & OBD_MD_FLCTIME && src->o_ctime > dst->i_ctime)
                 dst->i_ctime = src->o_ctime;
+#else
+        if (valid & OBD_MD_FLATIME)
+                dst->i_atime.tv_sec = src->o_atime;
+        if (valid & OBD_MD_FLMTIME)
+                dst->i_mtime.tv_sec = src->o_mtime;
+        if (valid & OBD_MD_FLCTIME && src->o_ctime > dst->i_ctime.tv_sec)
+                dst->i_ctime.tv_sec = src->o_ctime;
+#endif
         if (valid & OBD_MD_FLSIZE)
                 dst->i_size = src->o_size;
         if (valid & OBD_MD_FLBLOCKS) /* allocation of space */
@@ -841,7 +905,6 @@ static inline int obdo_cmp_md(struct obdo *dst, struct obdo *src,
 }
 
 
-#ifdef __KERNEL__
 /* I'm as embarrassed about this as you are.
  *
  * <shaver> // XXX do not look into _superhack with remaining eye
@@ -895,7 +958,6 @@ struct obd_class_user_conn {
         struct lustre_handle   ocuc_conn;
 };
 
-#endif
 
 /* sysctl.c */
 extern void obd_sysctl_init (void);
@@ -905,4 +967,12 @@ extern void obd_sysctl_clean (void);
 typedef __u8 class_uuid_t[16];
 //int class_uuid_parse(struct obd_uuid in, class_uuid_t out);
 void class_uuid_unparse(class_uuid_t in, struct obd_uuid *out);
+
+/* lustre_peer.c    */
+int lustre_uuid_to_peer(char *uuid, struct lustre_peer *peer);
+int class_add_uuid(char *uuid, __u64 nid, __u32 nal);
+int class_del_uuid (char *uuid);
+void class_init_uuidlist(void);
+void class_exit_uuidlist(void);
+
 #endif /* __LINUX_OBD_CLASS_H */
index 16a4d03..26850d8 100644 (file)
@@ -32,6 +32,8 @@
 #define FILTER_LR_CLIENT_START   8192
 #define FILTER_LR_CLIENT_SIZE    128
 
+#define FILTER_SUBDIR_COUNT      32            /* set to zero for no subdirs */
+
 #define FILTER_MOUNT_RECOV 2
 #define FILTER_RECOVERY_TIMEOUT (obd_timeout * 5 * HZ / 2) /* *waves hands* */
 
 struct filter_server_data {
         __u8  fsd_uuid[37];        /* server UUID */
         __u8  fsd_uuid_padding[3]; /* unused */
-        __u64 fsd_last_objid;      /* last completed transaction ID */
+        __u64 fsd_last_objid;      /* last created object ID */
         __u64 fsd_last_rcvd;       /* last completed transaction ID */
         __u64 fsd_mount_count;     /* FILTER incarnation number */
-        __u8  fsd_padding[FILTER_LR_SERVER_SIZE - 64]; /*  */
+        __u32 fsd_feature_compat;  /* compatible feature flags */
+        __u32 fsd_feature_rocompat;/* read-only compatible feature flags */
+        __u32 fsd_feature_incompat;/* incompatible feature flags */
+        __u32 fsd_server_size;     /* size of server data area */
+        __u32 fsd_client_start;    /* start of per-client data area */
+        __u16 fsd_client_size;     /* size of per-client data area */
+        __u16 fsd_subdir_count;    /* number of subdirectories for objects */
+        __u8  fsd_padding[FILTER_LR_SERVER_SIZE - 88];
 };
 
 /* Data stored per client in the last_rcvd file.  In le32 order. */
@@ -52,15 +61,20 @@ struct filter_client_data {
         __u64 fcd_last_rcvd;       /* last completed transaction ID */
         __u64 fcd_mount_count;     /* FILTER incarnation number */
         __u64 fcd_last_xid;        /* client RPC xid for the last transaction */
-        __u8  fcd_padding[FILTER_LR_CLIENT_SIZE - 64]; 
+        __u8  fcd_padding[FILTER_LR_CLIENT_SIZE - 64];
 };
 
+#ifndef OBD_FILTER_SAN_DEVICENAME
+#define OBD_FILTER_SAN_DEVICENAME "sanobdfilter"
+#endif
+
 /* In-memory access to client data from OST struct */
 struct filter_export_data {
         struct list_head  fed_open_head; /* files to close on disconnect */
         spinlock_t        fed_lock;      /* protects fed_open_head */
         struct filter_client_data  *fed_fcd;
-        int               fed_lr_off;
+        loff_t            fed_lr_off;
+        int               fed_lr_idx;
 };
 
 /* file data for open files on OST */
@@ -71,6 +85,7 @@ struct filter_file_data {
 };
 
 struct filter_dentry_data {
+        obd_id           fdd_objid;
         atomic_t         fdd_open_count;
         int              fdd_flags;
 };
index acdac15..ff3e689 100644 (file)
@@ -5,8 +5,6 @@
 #ifndef _OBD_LOV_H__
 #define _OBD_LOV_H__
 
-#ifdef __KERNEL__
-
 #define OBD_LOV_DEVICENAME "lov"
 
 void lov_unpackdesc(struct lov_desc *ld);
@@ -16,7 +14,6 @@ static inline int lov_stripe_md_size(int stripes)
 {
         return sizeof(struct lov_stripe_md) + stripes*sizeof(struct lov_oinfo);
 }
-#endif
 
 static inline int lov_mds_md_size(int stripes)
 {
index 5de0a25..f8d1486 100644 (file)
@@ -31,6 +31,8 @@
 
 #define LUSTRE_OST_NAME "ost"
 #define LUSTRE_OSC_NAME "osc"
+#define LUSTRE_SANOSC_NAME "sanosc"
+#define LUSTRE_SANOST_NAME "sanost"
 
 /* ost/ost_pack.c */
 void ost_pack_niobuf(void **tmp, __u64 offset, __u32 len, __u32 flags,
index 69e4126..a4d676d 100644 (file)
 #ifndef _OBD_SUPPORT
 #define _OBD_SUPPORT
 
+#ifdef __KERNEL__
 #include <linux/config.h>
 #include <linux/autoconf.h>
 #include <linux/slab.h>
 #include <linux/highmem.h>
+#else
+
+#endif
 #include <linux/kp30.h>
 
 /* global variables */
@@ -88,6 +92,7 @@ extern unsigned long obd_sync_filter;
 #define OBD_FAIL_OST_HANDLE_UNPACK       0x20d
 #define OBD_FAIL_OST_BRW_WRITE_BULK      0x20e
 #define OBD_FAIL_OST_BRW_READ_BULK       0x20f
+#define OBD_FAIL_OST_SYNCFS_NET          0x210
 
 #define OBD_FAIL_LDLM                    0x300
 #define OBD_FAIL_LDLM_NAMESPACE_NEW      0x301
@@ -103,6 +108,9 @@ extern unsigned long obd_sync_filter;
 #define OBD_FAIL_OSC_LOCK_BL_AST         0x403
 #define OBD_FAIL_OSC_LOCK_CP_AST         0x404
 
+#define OBD_FAIL_PTLRPC                  0x500
+#define OBD_FAIL_PTLRPC_ACK              0x501
+
 /* preparation for a more advanced failure testbed (not functional yet) */
 #define OBD_FAIL_MASK_SYS    0x0000FF00
 #define OBD_FAIL_MASK_LOC    (0x000000FF | OBD_FAIL_MASK_SYS)
@@ -127,10 +135,12 @@ do {                                                                         \
         }                                                                    \
 } while(0)
 
+#define fixme() CDEBUG(D_OTHER, "FIXME\n");
+
+#ifdef __KERNEL__
 #include <linux/types.h>
 #include <linux/blkdev.h>
 
-#define fixme() CDEBUG(D_OTHER, "FIXME\n");
 
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 #define ll_bdevname(a) __bdevname((a))
@@ -140,9 +150,11 @@ do {                                                                         \
 #define ll_bdevname(a) bdevname((a))
 #endif
 
+
 static inline void OBD_FAIL_WRITE(int id, kdev_t dev)
 {
         if (OBD_FAIL_CHECK(id)) {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 #ifdef CONFIG_DEV_RDONLY
                 CERROR("obd_fail_loc=%x, fail write operation on %s\n",
                        id, ll_bdevname(dev));
@@ -151,11 +163,23 @@ static inline void OBD_FAIL_WRITE(int id, kdev_t dev)
                 CERROR("obd_fail_loc=%x, can't fail write operation on %s\n",
                        id, ll_bdevname(dev));
 #endif
+#else
+#ifdef CONFIG_DEV_RDONLY
+                CERROR("obd_fail_loc=%x, fail write operation on %s\n",
+                       id, ll_bdevname(dev.value));
+                dev_set_rdonly(dev, 2);
+#else
+                CERROR("obd_fail_loc=%x, can't fail write operation on %s\n",
+                       id, ll_bdevname(dev.value));
+#endif
+#endif
                 /* We set FAIL_ONCE because we never "un-fail" a device */
                 obd_fail_loc |= OBD_FAILED | OBD_FAIL_ONCE;
         }
 }
 
+#endif  /* __KERNEL__ */
+
 #define OBD_ALLOC(ptr, size)                                            \
 do {                                                                    \
         void *lptr;                                                     \
@@ -177,9 +201,9 @@ do {                                                                    \
 } while (0)
 
 #ifdef CONFIG_DEBUG_SLAB
-#define POISON(lptr, s) do {} while (0)
+#define POISON(lptr, c, s) do {} while (0)
 #else
-#define POISON(lptr, s) memset(lptr, 0x5a, s)
+#define POISON(lptr, c, s) memset(lptr, c, s)
 #endif
 
 #define OBD_FREE(ptr, size)                                             \
@@ -187,7 +211,7 @@ do {                                                                    \
         void *lptr = (ptr);                                             \
         int s = (size);                                                 \
         LASSERT(lptr);                                                  \
-        POISON(lptr, s);                                                \
+        POISON(lptr, 0x5a, s);                                          \
         kfree(lptr);                                                    \
         atomic_sub(s, &obd_memory);                                     \
         CDEBUG(D_MALLOC, "kfreed '" #ptr "': %d at %p (tot %d).\n",     \
index 00eba97..8df0d82 100644 (file)
@@ -1,6 +1,14 @@
---- linux-chaos/fs/inode.c.b_io_export Wed Jan 29 16:56:15 2003
-+++ linux-chaos/fs/inode.c     Wed Jan 29 16:56:27 2003
-@@ -66,7 +66,8 @@
+--- linux/fs/inode.c.b_io      2003-02-18 16:39:16.000000000 -0800
++++ linux/fs/inode.c   2003-02-18 16:39:45.000000000 -0800
+@@ -5,6 +5,7 @@
+  */
+ #include <linux/config.h>
++#include <linux/module.h>
+ #include <linux/fs.h>
+ #include <linux/string.h>
+ #include <linux/mm.h>
+@@ -66,7 +67,8 @@
   * NOTE! You also have to own the lock if you change
   * the i_state of an inode while it is in use..
   */
@@ -10,8 +18,8 @@
  
  /*
   * Statistics gathering..
---- linux-chaos/fs/Makefile.b_io_export        Wed Jan 29 16:56:45 2003
-+++ linux-chaos/fs/Makefile    Wed Jan 29 16:56:53 2003
+--- linux/fs/Makefile.b_io     2003-02-18 16:39:16.000000000 -0800
++++ linux/fs/Makefile  2003-02-18 16:39:37.000000000 -0800
 @@ -7,7 +7,7 @@
  
  O_TARGET := fs.o
  mod-subdirs :=        nls
  
  obj-y :=      open.o read_write.o devices.o file_table.o buffer.o \
---- linux-chaos/mm/filemap.c.b_io_export       Wed Jan 29 16:50:39 2003
-+++ linux-chaos/mm/filemap.c   Wed Jan 29 16:51:11 2003
-@@ -65,6 +65,7 @@
-  *                    pagecache_lock
+--- linux/mm/vmscan.c.b_io     2003-02-18 16:39:16.000000000 -0800
++++ linux/mm/vmscan.c  2003-02-18 16:40:01.000000000 -0800
+@@ -14,6 +14,8 @@
+  *  Multiqueue VM started 5.8.00, Rik van Riel.
   */
- spinlock_cacheline_t pagemap_lru_lock_cacheline = {SPIN_LOCK_UNLOCKED};
-+EXPORT_SYMBOL(pagemap_lru_lock_cacheline);
  
- #define CLUSTER_PAGES         (1 << page_cluster)
- #define CLUSTER_OFFSET(x)     (((x) >> page_cluster) << page_cluster)
---- linux-chaos/mm/vmscan.c.b_io_export        Wed Jan 29 16:51:58 2003
-+++ linux-chaos/mm/vmscan.c    Wed Jan 29 16:55:16 2003
-@@ -839,6 +839,7 @@
++#include <linux/config.h>
++#include <linux/module.h>
+ #include <linux/slab.h>
+ #include <linux/kernel_stat.h>
+ #include <linux/swap.h>
+@@ -837,6 +839,7 @@
        set_current_state(TASK_RUNNING);
        remove_wait_queue(&kswapd_done, &wait);
  }
  
  static void wakeup_memwaiters(void)
  {
---- linux-chaos/mm/Makefile.b_io_export        Wed Jan 29 16:52:46 2003
-+++ linux-chaos/mm/Makefile    Wed Jan 29 16:54:23 2003
+--- linux/mm/Makefile.b_io     2003-02-18 16:39:16.000000000 -0800
++++ linux/mm/Makefile  2003-02-18 16:39:37.000000000 -0800
 @@ -9,7 +9,7 @@
  
  O_TARGET := mm.o
  
 -export-objs := shmem.o filemap.o memory.o page_alloc.o mempool.o
-+export-objs := shmem.o filemap.o memory.o page_alloc.o mempool.o vmscan.c
++export-objs := shmem.o filemap.o memory.o page_alloc.o mempool.o vmscan.o
  
  obj-y  := memory.o mmap.o filemap.o mprotect.o mlock.o mremap.o \
            vmalloc.o slab.o bootmem.o swap.o vmscan.o page_io.o \
index 5e88d35..71d372f 100644 (file)
@@ -1,31 +1,19 @@
-# This is a BitKeeper generated patch for the following project:
-# Project Name: Linux kernel tree
-# This patch format is intended for GNU patch command version 2.5 or higher.
-# This patch includes the following deltas:
-#                 ChangeSet    1.810   -> 1.811  
-#            kernel/ksyms.c    1.149   -> 1.150  
-#       fs/driverfs/inode.c    1.52    -> 1.53   
-#        include/linux/fs.h    1.175   -> 1.176  
-#      include/linux/namei.h   1.3     -> 1.4    
-#                fs/namei.c    1.56    -> 1.57   
-#             fs/nfsd/vfs.c    1.44    -> 1.45   
-#      arch/um/kernel/mem.c    1.5     -> 1.6    
-#        net/unix/af_unix.c    1.29    -> 1.30   
-#                 mm/slab.c    1.33    -> 1.34   
-#          fs/sysfs/inode.c    1.55    -> 1.56   
-#      include/linux/slab.h    1.13    -> 1.14   
-#      include/linux/dcache.h  1.19    -> 1.20   
-#
-# The following is the BitKeeper ChangeSet Log
-# --------------------------------------------
-# 02/10/20     braam@clusterfs.com     1.811
-# Changes for Lustre
-# --------------------------------------------
-#
-diff -Nru a/arch/um/kernel/mem.c b/arch/um/kernel/mem.c
---- a/arch/um/kernel/mem.c     Sun Dec  8 02:49:38 2002
-+++ b/arch/um/kernel/mem.c     Sun Dec  8 02:49:38 2002
-@@ -656,6 +656,22 @@
+ arch/um/kernel/mem.c   |   18 +++++++++++-
+ fs/namei.c             |   71 +++++++++++++++++++++++++++++++++++--------------
+ fs/nfsd/vfs.c          |    2 -
+ fs/sysfs/inode.c       |    2 -
+ include/linux/dcache.h |   27 ++++++++++++++++++
+ include/linux/fs.h     |   20 +++++++++++++
+ include/linux/namei.h  |    3 +-
+ include/linux/slab.h   |    1 
+ kernel/ksyms.c         |    7 ++++
+ mm/slab.c              |    5 +++
+ net/unix/af_unix.c     |    2 -
+ 11 files changed, 132 insertions(+), 26 deletions(-)
+
+--- linux-2.5.59/arch/um/kernel/mem.c~lustre-2.5       2003-02-22 21:56:58.000000000 +0800
++++ linux-2.5.59-root/arch/um/kernel/mem.c     2003-02-22 21:56:58.000000000 +0800
+@@ -639,6 +639,22 @@ struct page *pte_mem_map(pte_t pte)
        return(phys_mem_map(pte_val(pte)));
  }
  
@@ -48,7 +36,7 @@ diff -Nru a/arch/um/kernel/mem.c b/arch/um/kernel/mem.c
  struct mem_region *page_region(struct page *page, int *index_out)
  {
        int i;
-@@ -743,7 +759,7 @@
+@@ -726,7 +742,7 @@ extern unsigned long region_pa(void *vir
                   (addr <= region->start + region->len))
                        return(mk_phys(addr - region->start, i));
        }
@@ -57,22 +45,9 @@ diff -Nru a/arch/um/kernel/mem.c b/arch/um/kernel/mem.c
        return(0);
  }
  
-diff -Nru a/fs/driverfs/inode.c b/fs/driverfs/inode.c
---- a/fs/driverfs/inode.c      Sun Dec  8 02:49:38 2002
-+++ b/fs/driverfs/inode.c      Sun Dec  8 02:49:38 2002
-@@ -523,7 +523,7 @@
-       qstr.name = name;
-       qstr.len = strlen(name);
-       qstr.hash = full_name_hash(name,qstr.len);
--      return lookup_hash(&qstr,parent);
-+      return lookup_hash(&qstr,parent, NULL);
- }
- /**
-diff -Nru a/fs/namei.c b/fs/namei.c
---- a/fs/namei.c       Sun Dec  8 02:49:38 2002
-+++ b/fs/namei.c       Sun Dec  8 02:49:38 2002
-@@ -265,6 +265,9 @@
+--- linux-2.5.59/fs/namei.c~lustre-2.5 2003-02-22 21:56:58.000000000 +0800
++++ linux-2.5.59-root/fs/namei.c       2003-02-22 21:56:58.000000000 +0800
+@@ -265,6 +265,9 @@ int deny_write_access(struct file * file
  
  void path_release(struct nameidata *nd)
  {
@@ -82,7 +57,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
        dput(nd->dentry);
        mntput(nd->mnt);
  }
-@@ -273,10 +276,18 @@
+@@ -273,10 +276,18 @@ void path_release(struct nameidata *nd)
   * Internal lookup() using the new generic dcache.
   * SMP-safe
   */
@@ -102,7 +77,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
        if (dentry && dentry->d_op && dentry->d_op->d_revalidate) {
                if (!dentry->d_op->d_revalidate(dentry, flags) && !d_invalidate(dentry)) {
                        dput(dentry);
-@@ -351,7 +362,7 @@
+@@ -351,7 +362,7 @@ ok:
   * make sure that nobody added the entry to the dcache in the meantime..
   * SMP-safe
   */
@@ -111,7 +86,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
  {
        struct dentry * result;
        struct inode *dir = parent->d_inode;
-@@ -369,7 +380,10 @@
+@@ -369,7 +380,10 @@ static struct dentry * real_lookup(struc
                struct dentry * dentry = d_alloc(parent, name);
                result = ERR_PTR(-ENOMEM);
                if (dentry) {
@@ -123,7 +98,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
                        if (result)
                                dput(dentry);
                        else {
-@@ -391,6 +405,12 @@
+@@ -391,6 +405,12 @@ static struct dentry * real_lookup(struc
                        dput(result);
                        result = ERR_PTR(-ENOENT);
                }
@@ -136,7 +111,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
        }
        return result;
  }
-@@ -534,7 +554,7 @@
+@@ -534,7 +554,7 @@ dcache_miss:
        unlock_nd(nd);
  
  need_lookup:
@@ -145,7 +120,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
        if (IS_ERR(dentry))
                goto fail;
        mntget(mnt);
-@@ -684,7 +704,7 @@
+@@ -684,7 +704,7 @@ int link_path_walk(const char * name, st
                        nd->dentry = next.dentry;
                }
                err = -ENOTDIR; 
@@ -154,7 +129,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
                        break;
                continue;
                /* here ends the main loop */
-@@ -737,7 +757,8 @@
+@@ -737,7 +757,8 @@ last_component:
                        break;
                if (lookup_flags & LOOKUP_DIRECTORY) {
                        err = -ENOTDIR; 
@@ -164,7 +139,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
                                break;
                }
                goto return_base;
-@@ -886,7 +907,8 @@
+@@ -886,7 +907,8 @@ int path_lookup(const char *name, unsign
   * needs parent already locked. Doesn't follow mounts.
   * SMP-safe.
   */
@@ -174,7 +149,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
  {
        struct dentry * dentry;
        struct inode *inode;
-@@ -909,13 +931,16 @@
+@@ -909,13 +931,16 @@ struct dentry * lookup_hash(struct qstr 
                        goto out;
        }
  
@@ -192,8 +167,8 @@ diff -Nru a/fs/namei.c b/fs/namei.c
 +                        dentry = inode->i_op->lookup(inode, new);
                if (!dentry) {
                        dentry = new;
-                       security_ops->inode_post_lookup(inode, dentry);
-@@ -927,7 +952,7 @@
+                       security_inode_post_lookup(inode, dentry);
+@@ -927,7 +952,7 @@ out:
  }
  
  /* SMP-safe */
@@ -202,7 +177,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
  {
        unsigned long hash;
        struct qstr this;
-@@ -947,11 +972,16 @@
+@@ -947,11 +972,16 @@ struct dentry * lookup_one_len(const cha
        }
        this.hash = end_name_hash(hash);
  
@@ -220,7 +195,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
  /*
   *    namei()
   *
-@@ -1268,7 +1298,7 @@
+@@ -1268,7 +1298,7 @@ int open_namei(const char * pathname, in
  
        dir = nd->dentry;
        down(&dir->d_inode->i_sem);
@@ -229,7 +204,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
  
  do_last:
        error = PTR_ERR(dentry);
-@@ -1370,7 +1400,7 @@
+@@ -1371,7 +1401,7 @@ do_link:
        }
        dir = nd->dentry;
        down(&dir->d_inode->i_sem);
@@ -238,7 +213,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
        putname(nd->last.name);
        goto do_last;
  }
-@@ -1384,7 +1414,7 @@
+@@ -1385,7 +1415,7 @@ static struct dentry *lookup_create(stru
        dentry = ERR_PTR(-EEXIST);
        if (nd->last_type != LAST_NORM)
                goto fail;
@@ -247,7 +222,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
        if (IS_ERR(dentry))
                goto fail;
        if (!is_dir && nd->last.name[nd->last.len] && !dentry->d_inode)
-@@ -1614,7 +1644,7 @@
+@@ -1617,7 +1647,7 @@ asmlinkage long sys_rmdir(const char * p
                        goto exit1;
        }
        down(&nd.dentry->d_inode->i_sem);
@@ -256,7 +231,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
        error = PTR_ERR(dentry);
        if (!IS_ERR(dentry)) {
                error = vfs_rmdir(nd.dentry->d_inode, dentry);
-@@ -1675,7 +1705,7 @@
+@@ -1677,7 +1707,7 @@ asmlinkage long sys_unlink(const char * 
        if (nd.last_type != LAST_NORM)
                goto exit1;
        down(&nd.dentry->d_inode->i_sem);
@@ -265,7 +240,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
        error = PTR_ERR(dentry);
        if (!IS_ERR(dentry)) {
                /* Why not before? Because we want correct error value */
-@@ -1949,7 +1979,8 @@
+@@ -1951,7 +1981,8 @@ int vfs_rename_other(struct inode *old_d
  }
  
  int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
@@ -275,7 +250,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
  {
        int error;
        int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
-@@ -2020,7 +2051,7 @@
+@@ -2022,7 +2053,7 @@ static inline int do_rename(const char *
  
        trap = lock_rename(new_dir, old_dir);
  
@@ -284,7 +259,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
        error = PTR_ERR(old_dentry);
        if (IS_ERR(old_dentry))
                goto exit3;
-@@ -2040,7 +2071,7 @@
+@@ -2042,7 +2073,7 @@ static inline int do_rename(const char *
        error = -EINVAL;
        if (old_dentry == trap)
                goto exit4;
@@ -293,7 +268,7 @@ diff -Nru a/fs/namei.c b/fs/namei.c
        error = PTR_ERR(new_dentry);
        if (IS_ERR(new_dentry))
                goto exit4;
-@@ -2050,7 +2081,7 @@
+@@ -2052,7 +2083,7 @@ static inline int do_rename(const char *
                goto exit5;
  
        error = vfs_rename(old_dir->d_inode, old_dentry,
@@ -302,10 +277,9 @@ diff -Nru a/fs/namei.c b/fs/namei.c
  exit5:
        dput(new_dentry);
  exit4:
-diff -Nru a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
---- a/fs/nfsd/vfs.c    Sun Dec  8 02:49:38 2002
-+++ b/fs/nfsd/vfs.c    Sun Dec  8 02:49:38 2002
-@@ -1292,7 +1292,7 @@
+--- linux-2.5.59/fs/nfsd/vfs.c~lustre-2.5      2003-02-22 21:56:58.000000000 +0800
++++ linux-2.5.59-root/fs/nfsd/vfs.c    2003-02-22 21:56:58.000000000 +0800
+@@ -1337,7 +1337,7 @@ nfsd_rename(struct svc_rqst *rqstp, stru
                        err = nfserr_perm;
        } else
  #endif
@@ -314,10 +288,9 @@ diff -Nru a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
        if (!err && EX_ISSYNC(tfhp->fh_export)) {
                nfsd_sync_dir(tdentry);
                nfsd_sync_dir(fdentry);
-diff -Nru a/fs/sysfs/inode.c b/fs/sysfs/inode.c
---- a/fs/sysfs/inode.c Sun Dec  8 02:49:39 2002
-+++ b/fs/sysfs/inode.c Sun Dec  8 02:49:39 2002
-@@ -471,7 +471,7 @@
+--- linux-2.5.59/fs/sysfs/inode.c~lustre-2.5   2003-02-22 21:56:58.000000000 +0800
++++ linux-2.5.59-root/fs/sysfs/inode.c 2003-02-22 21:56:58.000000000 +0800
+@@ -539,7 +539,7 @@ static struct dentry * get_dentry(struct
        qstr.name = name;
        qstr.len = strlen(name);
        qstr.hash = full_name_hash(name,qstr.len);
@@ -325,36 +298,38 @@ diff -Nru a/fs/sysfs/inode.c b/fs/sysfs/inode.c
 +      return lookup_hash(&qstr,parent,NULL);
  }
  
- /**
-diff -Nru a/include/linux/dcache.h b/include/linux/dcache.h
---- a/include/linux/dcache.h   Sun Dec  8 02:49:39 2002
-+++ b/include/linux/dcache.h   Sun Dec  8 02:49:39 2002
-@@ -9,6 +9,24 @@
- #include <linux/spinlock.h>
- #include <asm/page.h>                 /* for BUG() */
-+#define IT_OPEN  (1)
-+#define IT_CREAT  (1<<1)
-+#define IT_MKDIR  (1<<2)
-+#define IT_LINK  (1<<3)
-+#define IT_LINK2  (1<<4)
-+#define IT_SYMLINK  (1<<5)
-+#define IT_UNLINK  (1<<6)
-+#define IT_RMDIR  (1<<7)
-+#define IT_RENAME  (1<<8)
-+#define IT_RENAME2  (1<<9)
-+#define IT_READDIR  (1<<10)
-+#define IT_GETATTR  (1<<11)
-+#define IT_SETATTR  (1<<12)
-+#define IT_READLINK  (1<<13)
-+#define IT_MKNOD  (1<<14)
-+#define IT_LOOKUP  (1<<15)
+--- linux-2.5.59/include/linux/dcache.h~lustre-2.5     2003-02-22 21:56:58.000000000 +0800
++++ linux-2.5.59-root/include/linux/dcache.h   2003-02-22 22:02:55.000000000 +0800
+@@ -11,6 +11,27 @@
+ struct vfsmount;
++#define IT_OPEN     (1)
++#define IT_CREAT    (1<<1)
++#define IT_READDIR  (1<<2)
++#define IT_GETATTR  (1<<3)
++#define IT_LOOKUP   (1<<4)
++#define IT_UNLINK   (1<<5)
++
++
++struct lookup_intent {
++       int it_op;
++       int it_mode;
++       int it_flags;
++       int it_disposition;
++       int it_status;
++       struct iattr *it_iattr;
++       __u64 it_lock_handle[2];
++       int it_lock_mode;
++       void *it_data;
++};
 +
 +
  /*
   * linux/include/linux/dcache.h
   *
-@@ -30,6 +48,8 @@
+@@ -32,6 +53,8 @@ struct qstr {
        unsigned int hash;
  };
  
@@ -363,7 +338,7 @@ diff -Nru a/include/linux/dcache.h b/include/linux/dcache.h
  struct dentry_stat_t {
        int nr_dentry;
        int nr_unused;
-@@ -79,6 +99,7 @@
+@@ -81,6 +104,7 @@ struct dentry {
        struct list_head d_subdirs;     /* our children */
        struct list_head d_alias;       /* inode alias list */
        int d_mounted;
@@ -371,7 +346,7 @@ diff -Nru a/include/linux/dcache.h b/include/linux/dcache.h
        struct qstr d_name;
        unsigned long d_time;           /* used by d_revalidate */
        struct dentry_operations  *d_op;
-@@ -96,6 +117,8 @@
+@@ -100,6 +124,8 @@ struct dentry_operations {
        int (*d_delete)(struct dentry *);
        void (*d_release)(struct dentry *);
        void (*d_iput)(struct dentry *, struct inode *);
@@ -380,10 +355,27 @@ diff -Nru a/include/linux/dcache.h b/include/linux/dcache.h
  };
  
  /* the dentry parameter passed to d_hash and d_compare is the parent
-diff -Nru a/include/linux/fs.h b/include/linux/fs.h
---- a/include/linux/fs.h       Sun Dec  8 02:49:38 2002
-+++ b/include/linux/fs.h       Sun Dec  8 02:49:38 2002
-@@ -700,7 +700,7 @@
+@@ -139,6 +165,7 @@ d_iput:            no              no              yes
+       */
+ #define DCACHE_REFERENCED     0x0008  /* Recently used, don't discard. */
++#define DCACHE_LUSTRE_INVALID         0x0010  /* Lustre invalidated */
+ extern spinlock_t dcache_lock;
+ extern rwlock_t dparent_lock;
+--- linux-2.5.59/include/linux/fs.h~lustre-2.5 2003-02-22 21:56:58.000000000 +0800
++++ linux-2.5.59-root/include/linux/fs.h       2003-02-22 22:52:58.000000000 +0800
+@@ -234,6 +234,9 @@ typedef int (get_blocks_t)(struct inode 
+ #define ATTR_ATTR_FLAG        1024
+ #define ATTR_KILL_SUID        2048
+ #define ATTR_KILL_SGID        4096
++#define ATTR_RAW              8192    /* file system, not vfs will massage attrs */
++#define ATTR_FROM_OPEN        16384    /* called from open path, ie O_TRUNC */
++
+ /*
+  * This is the Inode Attributes structure, used for notify_change().  It
+@@ -676,7 +679,7 @@ extern int vfs_symlink(struct inode *, s
  extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
  extern int vfs_rmdir(struct inode *, struct dentry *);
  extern int vfs_unlink(struct inode *, struct dentry *);
@@ -392,45 +384,51 @@ diff -Nru a/include/linux/fs.h b/include/linux/fs.h
  
  /*
   * File types
-@@ -769,6 +769,8 @@
+@@ -762,19 +765,33 @@ struct file_operations {
  struct inode_operations {
        int (*create) (struct inode *,struct dentry *,int);
        struct dentry * (*lookup) (struct inode *,struct dentry *);
 +      struct dentry * (*lookup2) (struct inode *,struct dentry *, 
 +                                    struct lookup_intent *);
        int (*link) (struct dentry *,struct inode *,struct dentry *);
++      int (*link2) (struct inode *,struct inode *, const char *, int);
        int (*unlink) (struct inode *,struct dentry *);
++      int (*unlink2) (struct inode *, const char *, int);
        int (*symlink) (struct inode *,struct dentry *,const char *);
-@@ -995,6 +997,7 @@
++      int (*symlink2) (struct inode *, const char *, int, const char *);
+       int (*mkdir) (struct inode *,struct dentry *,int);
++      int (*mkdir2) (struct inode *, const char *, int,int);
+       int (*rmdir) (struct inode *,struct dentry *);
++      int (*rmdir2) (struct inode *, const char *, int);
+       int (*mknod) (struct inode *,struct dentry *,int,dev_t);
++      int (*mknod2) (struct inode *, const char *, int,int,int);
+       int (*rename) (struct inode *, struct dentry *,
+                       struct inode *, struct dentry *);
++      int (*rename2) (struct inode *, struct inode *,
++                      const char *oldname, int oldlen,
++                      const char *newname, int newlen);
+       int (*readlink) (struct dentry *, char *,int);
+       int (*follow_link) (struct dentry *, struct nameidata *);
++      int (*follow_link2) (struct dentry *, struct nameidata *,
++                              struct lookup_intent *it);
+       void (*truncate) (struct inode *);
+       int (*permission) (struct inode *, int);
+       int (*setattr) (struct dentry *, struct iattr *);
++      int (*setattr_raw) (struct inode *, struct iattr *);
+       int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
+       int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
+       ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
+@@ -987,6 +1004,7 @@ extern int register_filesystem(struct fi
  extern int unregister_filesystem(struct file_system_type *);
  extern struct vfsmount *kern_mount(struct file_system_type *);
  extern int may_umount(struct vfsmount *);
 +struct vfsmount *do_kern_mount(const char *type, int flags, char *name, void *data);
  extern long do_mount(char *, char *, char *, unsigned long, void *);
  
- #define kern_umount mntput
-diff -Nru a/include/linux/namei.h b/include/linux/namei.h
---- a/include/linux/namei.h    Sun Dec  8 02:49:38 2002
-+++ b/include/linux/namei.h    Sun Dec  8 02:49:38 2002
-@@ -5,6 +5,17 @@
- struct vfsmount;
-+struct lookup_intent {
-+      int it_op;
-+      int it_mode;
-+      int it_disposition;
-+      int it_status;
-+      struct iattr *it_iattr;
-+      __u64 it_lock_handle[2];
-+      int it_lock_mode;
-+      void *it_data;
-+};
-+
- struct nameidata {
-       struct dentry   *dentry;
-       struct vfsmount *mnt;
-@@ -13,6 +24,7 @@
+ extern int vfs_statfs(struct super_block *, struct statfs *);
+--- linux-2.5.59/include/linux/namei.h~lustre-2.5      2003-02-22 21:56:58.000000000 +0800
++++ linux-2.5.59-root/include/linux/namei.h    2003-02-22 21:56:58.000000000 +0800
+@@ -13,6 +13,7 @@ struct nameidata {
        int             last_type;
        struct dentry   *old_dentry;
        struct vfsmount *old_mnt;
@@ -438,7 +436,7 @@ diff -Nru a/include/linux/namei.h b/include/linux/namei.h
  };
  
  /*
-@@ -46,7 +58,7 @@
+@@ -46,7 +47,7 @@ extern int FASTCALL(link_path_walk(const
  extern void path_release(struct nameidata *);
  
  extern struct dentry * lookup_one_len(const char *, struct dentry *, int);
@@ -447,10 +445,9 @@ diff -Nru a/include/linux/namei.h b/include/linux/namei.h
  
  extern int follow_down(struct vfsmount **, struct dentry **);
  extern int follow_up(struct vfsmount **, struct dentry **);
-diff -Nru a/include/linux/slab.h b/include/linux/slab.h
---- a/include/linux/slab.h     Sun Dec  8 02:49:39 2002
-+++ b/include/linux/slab.h     Sun Dec  8 02:49:39 2002
-@@ -56,6 +56,7 @@
+--- linux-2.5.59/include/linux/slab.h~lustre-2.5       2003-02-22 21:56:58.000000000 +0800
++++ linux-2.5.59-root/include/linux/slab.h     2003-02-22 21:56:58.000000000 +0800
+@@ -56,6 +56,7 @@ extern int kmem_cache_destroy(kmem_cache
  extern int kmem_cache_shrink(kmem_cache_t *);
  extern void *kmem_cache_alloc(kmem_cache_t *, int);
  extern void kmem_cache_free(kmem_cache_t *, void *);
@@ -458,90 +455,46 @@ diff -Nru a/include/linux/slab.h b/include/linux/slab.h
  extern unsigned int kmem_cache_size(kmem_cache_t *);
  
  extern void *kmalloc(size_t, int);
-diff -Nru a/kernel/ksyms.c b/kernel/ksyms.c
---- a/kernel/ksyms.c   Sun Dec  8 02:49:38 2002
-+++ b/kernel/ksyms.c   Sun Dec  8 02:49:38 2002
-@@ -365,6 +365,13 @@
- EXPORT_SYMBOL(tty_get_baud_rate);
- EXPORT_SYMBOL(do_SAK);
+--- linux-2.5.59/kernel/ksyms.c~lustre-2.5     2003-02-22 21:56:58.000000000 +0800
++++ linux-2.5.59-root/kernel/ksyms.c   2003-02-22 21:56:58.000000000 +0800
+@@ -376,6 +376,7 @@ EXPORT_SYMBOL(unregister_filesystem);
+ EXPORT_SYMBOL(kern_mount);
+ EXPORT_SYMBOL(__mntput);
+ EXPORT_SYMBOL(may_umount);
++EXPORT_SYMBOL(reparent_to_init);
+ /* executable format registration */
+ EXPORT_SYMBOL(register_binfmt);
+@@ -406,6 +407,12 @@ EXPORT_SYMBOL(request_irq);
+ EXPORT_SYMBOL(free_irq);
+ EXPORT_SYMBOL(irq_stat);
  
 +/* lustre */
-+EXPORT_SYMBOL(panic_notifier_list);
-+//EXPORT_SYMBOL(pagecache_lock_cacheline);
 +EXPORT_SYMBOL(do_kern_mount);
 +EXPORT_SYMBOL(exit_files);
 +EXPORT_SYMBOL(kmem_cache_validate);
 +
- /* filesystem registration */
- EXPORT_SYMBOL(register_filesystem);
- EXPORT_SYMBOL(unregister_filesystem);
-diff -Nru a/mm/slab.c b/mm/slab.c
---- a/mm/slab.c        Sun Dec  8 02:49:39 2002
-+++ b/mm/slab.c        Sun Dec  8 02:49:39 2002
-@@ -1236,6 +1236,59 @@
-  * Called with the cache-lock held.
-  */
-+extern struct page *check_get_page(unsigned long kaddr);
-+struct page *page_mem_map(struct page *page);
-+static int kmem_check_cache_obj (kmem_cache_t * cachep,
-+                               slab_t *slabp, void * objp)
-+{
-+      int i;
-+      unsigned int objnr;
-+
-+#if DEBUG
-+      if (cachep->flags & SLAB_RED_ZONE) {
-+              objp -= BYTES_PER_WORD;
-+              if ( *(unsigned long *)objp != RED_MAGIC2)
-+                      /* Either write before start, or a double free. */
-+                      return 0;
-+              if (*(unsigned long *)(objp+cachep->objsize -
-+                              BYTES_PER_WORD) != RED_MAGIC2)
-+                      /* Either write past end, or a double free. */
-+                      return 0;
-+      }
-+#endif
-+
-+      objnr = (objp-slabp->s_mem)/cachep->objsize;
-+      if (objnr >= cachep->num)
-+              return 0;
-+      if (objp != slabp->s_mem + objnr*cachep->objsize)
-+              return 0;
-+
-+      /* Check slab's freelist to see if this obj is there. */
-+      for (i = slabp->free; i != BUFCTL_END; i = slab_bufctl(slabp)[i]) {
-+              if (i == objnr)
-+                      return 0;
-+      }
-+      return 1;
-+}
-+
 +
+ /* waitqueue handling */
+ EXPORT_SYMBOL(add_wait_queue);
+ EXPORT_SYMBOL(add_wait_queue_exclusive);
+--- linux-2.5.59/mm/slab.c~lustre-2.5  2003-02-22 21:56:58.000000000 +0800
++++ linux-2.5.59-root/mm/slab.c        2003-02-22 21:56:58.000000000 +0800
+@@ -1793,6 +1793,11 @@ static inline void __cache_free (kmem_ca
+       }
+ }
 +int kmem_cache_validate(kmem_cache_t *cachep, void *objp)
 +{
-+      struct page *page = check_get_page((unsigned long)objp);
-+
-+      if (!page_mem_map(page))
-+              return 0;
-+
-+      if (!PageSlab(page))
-+              return 0;
-+
-+      /* XXX check for freed slab objects ? */
-+      if (!kmem_check_cache_obj(cachep, GET_PAGE_SLAB(page), objp))
-+              return 0;
-+
-+      return (cachep == GET_PAGE_CACHE(page));
++      return 1;
 +}
 +
- #if DEBUG
- static int kmem_extra_free_checks (kmem_cache_t * cachep,
-                       slab_t *slabp, void * objp)
-diff -Nru a/net/unix/af_unix.c b/net/unix/af_unix.c
---- a/net/unix/af_unix.c       Sun Dec  8 02:49:38 2002
-+++ b/net/unix/af_unix.c       Sun Dec  8 02:49:38 2002
-@@ -715,7 +715,7 @@
+ /**
+  * kmem_cache_alloc - Allocate an object
+  * @cachep: The cache to allocate from.
+--- linux-2.5.59/net/unix/af_unix.c~lustre-2.5 2003-02-22 21:56:58.000000000 +0800
++++ linux-2.5.59-root/net/unix/af_unix.c       2003-02-22 21:56:58.000000000 +0800
+@@ -719,7 +719,7 @@ static int unix_bind(struct socket *sock
                /*
                 * Do the final lookup.
                 */
@@ -550,3 +503,5 @@ diff -Nru a/net/unix/af_unix.c b/net/unix/af_unix.c
                err = PTR_ERR(dentry);
                if (IS_ERR(dentry))
                        goto out_mknod_unlock;
+
+_
index 9ed43cf..d7b6dce 100644 (file)
@@ -5,8 +5,8 @@
  1 files changed, 1 insertion(+)
 
 --- /dev/null  Fri Aug 30 17:31:37 2002
-+++ linux-2.4.18-18.8.0-l7-root/include/linux/lustre_version.h Mon Jan 20 12:24:45 2003
++++ linux-2.4.18-18.8.0-l12-braam/include/linux/lustre_version.h       Thu Feb 13 07:58:33 2003
 @@ -0,0 +1 @@
-+#define LUSTRE_KERNEL_VERSION 10
++#define LUSTRE_KERNEL_VERSION 13
 
 _
index 7384675..5c1f090 100644 (file)
@@ -1,15 +1,16 @@
- fs/dcache.c            |    8 +
- fs/namei.c             |  288 ++++++++++++++++++++++++++++++++++++++++---------
+ fs/dcache.c            |   20 ++
+ fs/exec.c              |   18 +-
+ fs/namei.c             |  338 ++++++++++++++++++++++++++++++++++++++++---------
  fs/nfsd/vfs.c          |    2 
- fs/open.c              |   53 +++++++--
- fs/stat.c              |    9 +
- include/linux/dcache.h |   25 ++++
- include/linux/fs.h     |   22 +++
+ fs/open.c              |  120 +++++++++++++++--
+ fs/stat.c              |    8 -
+ include/linux/dcache.h |   28 ++++
+ include/linux/fs.h     |   27 +++
  kernel/ksyms.c         |    1 
8 files changed, 345 insertions(+), 63 deletions(-)
9 files changed, 478 insertions(+), 84 deletions(-)
 
---- linux-2.4.18-49chaos-lustre9/fs/dcache.c~vfs_intent-2.4.18-18      Wed Jan 29 12:43:32 2003
-+++ linux-2.4.18-49chaos-lustre9-root/fs/dcache.c      Wed Jan 29 12:43:32 2003
+--- linux-2.4.18-18.8.0-l12/fs/dcache.c~vfs_intent-2.4.18-18   Wed Feb 26 16:54:17 2003
++++ linux-2.4.18-18.8.0-l12-phil/fs/dcache.c   Wed Feb 26 17:31:36 2003
 @@ -186,6 +186,13 @@ int d_invalidate(struct dentry * dentry)
                spin_unlock(&dcache_lock);
                return 0;
        INIT_LIST_HEAD(&dentry->d_hash);
        INIT_LIST_HEAD(&dentry->d_lru);
        INIT_LIST_HEAD(&dentry->d_subdirs);
---- linux-2.4.18-49chaos-lustre9/fs/namei.c~vfs_intent-2.4.18-18       Wed Jan 29 12:43:32 2003
-+++ linux-2.4.18-49chaos-lustre9-root/fs/namei.c       Wed Feb  5 16:23:06 2003
+@@ -859,13 +867,19 @@ void d_delete(struct dentry * dentry)
+  * Adds a dentry to the hash according to its name.
+  */
+  
+-void d_rehash(struct dentry * entry)
++void __d_rehash(struct dentry * entry, int lock)
+ {
+       struct list_head *list = d_hash(entry->d_parent, entry->d_name.hash);
+       if (!list_empty(&entry->d_hash)) BUG();
+-      spin_lock(&dcache_lock);
++      if (lock) spin_lock(&dcache_lock);
+       list_add(&entry->d_hash, list);
+-      spin_unlock(&dcache_lock);
++      if (lock) spin_unlock(&dcache_lock);
++}
++EXPORT_SYMBOL(__d_rehash);
++
++void d_rehash(struct dentry * entry)
++{
++      __d_rehash(entry, 1);
+ }
+ #define do_switch(x,y) do { \
+--- linux-2.4.18-18.8.0-l12/fs/namei.c~vfs_intent-2.4.18-18    Wed Feb 26 16:54:17 2003
++++ linux-2.4.18-18.8.0-l12-phil/fs/namei.c    Wed Feb 26 16:54:17 2003
 @@ -94,6 +94,13 @@
   * XEmacs seems to be relying on it...
   */
        path_release(nd);
        return -ELOOP;
  }
-@@ -449,7 +482,8 @@ static inline void follow_dotdot(struct 
+@@ -381,15 +414,26 @@ int follow_up(struct vfsmount **mnt, str
+       return __follow_up(mnt, dentry);
+ }
+-static inline int __follow_down(struct vfsmount **mnt, struct dentry **dentry)
++static inline int __follow_down(struct vfsmount **mnt, struct dentry **dentry,
++                              struct lookup_intent *it)
+ {
+       struct vfsmount *mounted;
+       spin_lock(&dcache_lock);
+       mounted = lookup_mnt(*mnt, *dentry);
+       if (mounted) {
++              int opc = 0, mode = 0;
+               *mnt = mntget(mounted);
+               spin_unlock(&dcache_lock);
++              if (it) {
++                      opc = it->it_op;
++                      mode = it->it_mode;
++              }
++              intent_release(*dentry, it);
++              if (it) {
++                      it->it_op = opc;
++                      it->it_mode = mode;
++              }
+               dput(*dentry);
+               mntput(mounted->mnt_parent);
+               *dentry = dget(mounted->mnt_root);
+@@ -401,7 +445,7 @@ static inline int __follow_down(struct v
+ int follow_down(struct vfsmount **mnt, struct dentry **dentry)
+ {
+-      return __follow_down(mnt,dentry);
++      return __follow_down(mnt,dentry,NULL);
+ }
+  
+ static inline void follow_dotdot(struct nameidata *nd)
+@@ -437,7 +481,7 @@ static inline void follow_dotdot(struct 
+               mntput(nd->mnt);
+               nd->mnt = parent;
+       }
+-      while (d_mountpoint(nd->dentry) && __follow_down(&nd->mnt, &nd->dentry))
++      while (d_mountpoint(nd->dentry) && __follow_down(&nd->mnt, &nd->dentry, NULL))
+               ;
+ }
+@@ -449,7 +493,8 @@ static inline void follow_dotdot(struct 
   *
   * We expect 'base' to be positive and a directory.
   */
  {
        struct dentry *dentry;
        struct inode *inode;
-@@ -526,12 +560,12 @@ int link_path_walk(const char * name, st
+@@ -526,18 +571,18 @@ int link_path_walk(const char * name, st
                                break;
                }
                /* This does the actual lookups.. */
                        err = PTR_ERR(dentry);
                        if (IS_ERR(dentry))
                                break;
-@@ -548,8 +582,8 @@ int link_path_walk(const char * name, st
+               }
+               /* Check mountpoints.. */
+-              while (d_mountpoint(dentry) && __follow_down(&nd->mnt, &dentry))
++              while (d_mountpoint(dentry) && __follow_down(&nd->mnt, &dentry, NULL))
+                       ;
+               err = -ENOENT;
+@@ -548,8 +593,8 @@ int link_path_walk(const char * name, st
                if (!inode->i_op)
                        goto out_dput;
  
                        dput(dentry);
                        if (err)
                                goto return_err;
-@@ -565,7 +599,7 @@ int link_path_walk(const char * name, st
+@@ -565,7 +610,7 @@ int link_path_walk(const char * name, st
                        nd->dentry = dentry;
                }
                err = -ENOTDIR; 
                        break;
                continue;
                /* here ends the main loop */
-@@ -592,12 +626,12 @@ last_component:
+@@ -592,22 +637,23 @@ last_component:
                        if (err < 0)
                                break;
                }
                        err = PTR_ERR(dentry);
                        if (IS_ERR(dentry))
                                break;
-@@ -606,8 +640,9 @@ last_component:
+               }
+-              while (d_mountpoint(dentry) && __follow_down(&nd->mnt, &dentry))
++              while (d_mountpoint(dentry) && __follow_down(&nd->mnt, &dentry, it))
                        ;
                inode = dentry->d_inode;
                if ((lookup_flags & LOOKUP_FOLLOW)
                        dput(dentry);
                        if (err)
                                goto return_err;
-@@ -621,7 +656,8 @@ last_component:
+@@ -621,7 +667,8 @@ last_component:
                        goto no_inode;
                if (lookup_flags & LOOKUP_DIRECTORY) {
                        err = -ENOTDIR; 
                                break;
                }
                goto return_base;
-@@ -658,15 +694,28 @@ out_dput:
+@@ -658,15 +705,28 @@ out_dput:
                dput(dentry);
                break;
        }
  }
  
  /* SMP-safe */
-@@ -751,6 +800,17 @@ walk_init_root(const char *name, struct 
+@@ -751,6 +811,17 @@ walk_init_root(const char *name, struct 
  }
  
  /* SMP-safe */
  int path_lookup(const char *path, unsigned flags, struct nameidata *nd)
  {
        int error = 0;
-@@ -779,7 +839,8 @@ int path_init(const char *name, unsigned
+@@ -779,7 +850,8 @@ int path_init(const char *name, unsigned
   * needs parent already locked. Doesn't follow mounts.
   * SMP-safe.
   */
  {
        struct dentry * dentry;
        struct inode *inode;
-@@ -802,13 +863,16 @@ struct dentry * lookup_hash(struct qstr 
+@@ -802,13 +874,16 @@ struct dentry * lookup_hash(struct qstr 
                        goto out;
        }
  
                dentry = inode->i_op->lookup(inode, new);
                unlock_kernel();
                if (!dentry)
-@@ -820,6 +884,12 @@ out:
+@@ -820,6 +895,12 @@ out:
        return dentry;
  }
  
  /* SMP-safe */
  struct dentry * lookup_one_len(const char * name, struct dentry * base, int len)
  {
-@@ -841,7 +911,7 @@ struct dentry * lookup_one_len(const cha
+@@ -841,7 +922,7 @@ struct dentry * lookup_one_len(const cha
        }
        this.hash = end_name_hash(hash);
  
  access:
        return ERR_PTR(-EACCES);
  }
-@@ -872,6 +942,23 @@ int __user_walk(const char *name, unsign
+@@ -872,6 +953,23 @@ int __user_walk(const char *name, unsign
        return err;
  }
  
  /*
   * It's inline, so penalty for filesystems that don't use sticky bit is
   * minimal.
-@@ -1045,14 +1132,17 @@ int may_open(struct nameidata *nd, int a
+@@ -1045,14 +1143,17 @@ int may_open(struct nameidata *nd, int a
          return get_lease(inode, flag);
  }
  
        int count = 0;
  
        if ((flag+1) & O_ACCMODE)
-@@ -1066,7 +1156,7 @@ struct file *filp_open(const char * path
+@@ -1066,7 +1167,7 @@ struct file *filp_open(const char * path
         * The simplest case - just a plain lookup.
         */
        if (!(flag & O_CREAT)) {
                if (error)
                        return ERR_PTR(error);
                dentry = nd.dentry;
-@@ -1076,6 +1166,8 @@ struct file *filp_open(const char * path
+@@ -1076,6 +1177,8 @@ struct file *filp_open(const char * path
        /*
         * Create - we need to know the parent.
         */
        error = path_lookup(pathname, LOOKUP_PARENT, &nd);
        if (error)
                return ERR_PTR(error);
-@@ -1091,7 +1183,7 @@ struct file *filp_open(const char * path
+@@ -1091,7 +1194,7 @@ struct file *filp_open(const char * path
  
        dir = nd.dentry;
        down(&dir->d_inode->i_sem);
  
  do_last:
        error = PTR_ERR(dentry);
-@@ -1100,6 +1192,7 @@ do_last:
+@@ -1100,6 +1203,7 @@ do_last:
                goto exit;
        }
  
        /* Negative dentry, just create the file */
        if (!dentry->d_inode) {
                error = vfs_create(dir->d_inode, dentry,
-@@ -1134,7 +1227,8 @@ do_last:
+@@ -1129,12 +1233,13 @@ do_last:
+               error = -ELOOP;
+               if (flag & O_NOFOLLOW)
+                       goto exit_dput;
+-              while (__follow_down(&nd.mnt,&dentry) && d_mountpoint(dentry));
++              while (__follow_down(&nd.mnt,&dentry,&it) && d_mountpoint(dentry));
+       }
        error = -ENOENT;
        if (!dentry->d_inode)
                goto exit_dput;
                goto do_link;
  
        dput(nd.dentry);
-@@ -1149,11 +1243,13 @@ ok:
+@@ -1149,11 +1254,13 @@ ok:
        if (!S_ISREG(nd.dentry->d_inode->i_mode))
                open_flags &= ~O_TRUNC;
  
        path_release(&nd);
        return ERR_PTR(error);
  
-@@ -1172,7 +1268,12 @@ do_link:
+@@ -1172,10 +1279,15 @@ do_link:
         * are done. Procfs-like symlinks just set LAST_BIND.
         */
        UPDATE_ATIME(dentry->d_inode);
 +              intent_release(dentry, &it);
        dput(dentry);
        if (error)
-               return error;
-@@ -1194,13 +1295,15 @@ do_link:
+-              return error;
++              return ERR_PTR(error);
+       if (nd.last_type == LAST_BIND) {
+               dentry = nd.dentry;
+               goto ok;
+@@ -1194,13 +1306,15 @@ do_link:
        }
        dir = nd.dentry;
        down(&dir->d_inode->i_sem);
  {
        struct dentry *dentry;
  
-@@ -1208,7 +1311,7 @@ static struct dentry *lookup_create(stru
+@@ -1208,7 +1322,7 @@ static struct dentry *lookup_create(stru
        dentry = ERR_PTR(-EEXIST);
        if (nd->last_type != LAST_NORM)
                goto fail;
        if (IS_ERR(dentry))
                goto fail;
        if (!is_dir && nd->last.name[nd->last.len] && !dentry->d_inode)
-@@ -1264,7 +1367,19 @@ asmlinkage long sys_mknod(const char * f
+@@ -1264,7 +1378,19 @@ asmlinkage long sys_mknod(const char * f
        error = path_lookup(tmp, LOOKUP_PARENT, &nd);
        if (error)
                goto out;
 +                                 nd.last.name,
 +                                 nd.last.len,
 +                                 mode, dev);
-+              /* the file system want to use normal vfs path now */
++              /* the file system wants to use normal vfs path now */
 +              if (error != -EOPNOTSUPP)
 +                      goto out2;
 +      }
        error = PTR_ERR(dentry);
  
        mode &= ~current->fs->umask;
-@@ -1285,6 +1400,7 @@ asmlinkage long sys_mknod(const char * f
+@@ -1285,6 +1411,7 @@ asmlinkage long sys_mknod(const char * f
                dput(dentry);
        }
        up(&nd.dentry->d_inode->i_sem);
        path_release(&nd);
  out:
        putname(tmp);
-@@ -1332,7 +1448,17 @@ asmlinkage long sys_mkdir(const char * p
+@@ -1332,7 +1459,17 @@ asmlinkage long sys_mkdir(const char * p
                error = path_lookup(tmp, LOOKUP_PARENT, &nd);
                if (error)
                        goto out;
 +                                         nd.last.name,
 +                                         nd.last.len,
 +                                         mode);
-+                      /* the file system want to use normal vfs path now */
++                      /* the file system wants to use normal vfs path now */
 +                      if (error != -EOPNOTSUPP)
 +                              goto out2;
 +              }
                error = PTR_ERR(dentry);
                if (!IS_ERR(dentry)) {
                        error = vfs_mkdir(nd.dentry->d_inode, dentry,
-@@ -1340,6 +1466,7 @@ asmlinkage long sys_mkdir(const char * p
+@@ -1340,6 +1477,7 @@ asmlinkage long sys_mkdir(const char * p
                        dput(dentry);
                }
                up(&nd.dentry->d_inode->i_sem);
                path_release(&nd);
  out:
                putname(tmp);
-@@ -1440,8 +1567,17 @@ asmlinkage long sys_rmdir(const char * p
+@@ -1440,8 +1578,33 @@ asmlinkage long sys_rmdir(const char * p
                        error = -EBUSY;
                        goto exit1;
        }
 +      if (nd.dentry->d_inode->i_op->rmdir2) {
 +              struct inode_operations *op = nd.dentry->d_inode->i_op;
++              struct dentry *last;
++
++              down(&nd.dentry->d_inode->i_sem);
++              last = lookup_hash_it(&nd.last, nd.dentry, NULL);
++              up(&nd.dentry->d_inode->i_sem);
++              if (IS_ERR(last)) {
++                      error = PTR_ERR(last);
++                      goto exit1;
++              }
++              if (d_mountpoint(last)) {
++                      dput(last);
++                      error = -EBUSY;
++                      goto exit1;
++              }
++              dput(last);
++
 +              error = op->rmdir2(nd.dentry->d_inode,
 +                                 nd.last.name,
 +                                 nd.last.len);
-+              /* the file system want to use normal vfs path now */
++              /* the file system wants to use normal vfs path now */
 +              if (error != -EOPNOTSUPP)
 +                      goto exit1;
 +      }
        error = PTR_ERR(dentry);
        if (!IS_ERR(dentry)) {
                error = vfs_rmdir(nd.dentry->d_inode, dentry);
-@@ -1499,8 +1635,17 @@ asmlinkage long sys_unlink(const char * 
+@@ -1499,8 +1662,17 @@ asmlinkage long sys_unlink(const char * 
        error = -EISDIR;
        if (nd.last_type != LAST_NORM)
                goto exit1;
 +              error = op->unlink2(nd.dentry->d_inode,
 +                                  nd.last.name,
 +                                  nd.last.len);
-+              /* the file system want to use normal vfs path now */
++              /* the file system wants to use normal vfs path now */
 +              if (error != -EOPNOTSUPP)
 +                      goto exit1;
 +      }
        error = PTR_ERR(dentry);
        if (!IS_ERR(dentry)) {
                /* Why not before? Because we want correct error value */
-@@ -1567,15 +1712,26 @@ asmlinkage long sys_symlink(const char *
+@@ -1567,15 +1739,26 @@ asmlinkage long sys_symlink(const char *
                error = path_lookup(to, LOOKUP_PARENT, &nd);
                if (error)
                        goto out;
 +                                           nd.last.name,
 +                                           nd.last.len,
 +                                           from);
-+                      /* the file system want to use normal vfs path now */
++                      /* the file system wants to use normal vfs path now */
 +                      if (error != -EOPNOTSUPP)
 +                              goto out2;
 +              }
                putname(to);
        }
        putname(from);
-@@ -1642,7 +1798,7 @@ asmlinkage long sys_link(const char * ol
+@@ -1642,7 +1825,7 @@ asmlinkage long sys_link(const char * ol
                struct dentry *new_dentry;
                struct nameidata nd, old_nd;
  
                if (error)
                        goto exit;
                error = path_lookup(to, LOOKUP_PARENT, &nd);
-@@ -1651,7 +1807,17 @@ asmlinkage long sys_link(const char * ol
+@@ -1651,7 +1834,17 @@ asmlinkage long sys_link(const char * ol
                error = -EXDEV;
                if (old_nd.mnt != nd.mnt)
                        goto out_release;
 +                                        nd.dentry->d_inode,
 +                                        nd.last.name,
 +                                        nd.last.len);
-+                      /* the file system want to use normal vfs path now */
++                      /* the file system wants to use normal vfs path now */
 +                      if (error != -EOPNOTSUPP)
 +                              goto out_release;
 +              }
                error = PTR_ERR(new_dentry);
                if (!IS_ERR(new_dentry)) {
                        error = vfs_link(old_nd.dentry, nd.dentry->d_inode, new_dentry);
-@@ -1695,7 +1861,8 @@ exit:
+@@ -1695,7 +1888,8 @@ exit:
   *       locking].
   */
  int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
  {
        int error;
        struct inode *target;
-@@ -1753,6 +1920,7 @@ int vfs_rename_dir(struct inode *old_dir
+@@ -1753,6 +1947,7 @@ int vfs_rename_dir(struct inode *old_dir
                error = -EBUSY;
        else 
                error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
        if (target) {
                if (!error)
                        target->i_flags |= S_DEAD;
-@@ -1774,7 +1942,8 @@ out_unlock:
+@@ -1774,7 +1969,8 @@ out_unlock:
  }
  
  int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
  {
        int error;
  
-@@ -1805,6 +1974,7 @@ int vfs_rename_other(struct inode *old_d
+@@ -1805,6 +2001,7 @@ int vfs_rename_other(struct inode *old_d
                error = -EBUSY;
        else
                error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
        double_up(&old_dir->i_zombie, &new_dir->i_zombie);
        if (error)
                return error;
-@@ -1816,13 +1986,14 @@ int vfs_rename_other(struct inode *old_d
+@@ -1816,13 +2013,14 @@ int vfs_rename_other(struct inode *old_d
  }
  
  int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        if (!error) {
                if (old_dir == new_dir)
                        inode_dir_notify(old_dir, DN_RENAME);
-@@ -1862,9 +2033,23 @@ static inline int do_rename(const char *
-       if (newnd.last_type != LAST_NORM)
-               goto exit2;
+@@ -1864,7 +2062,7 @@ static inline int do_rename(const char *
  
-+      if (old_dir->d_inode->i_op->rename2) {
-+              lock_kernel();
-+              error = old_dir->d_inode->i_op->rename2(old_dir->d_inode,
-+                                                      new_dir->d_inode,
-+                                                      oldnd.last.name,
-+                                                      oldnd.last.len,
-+                                                      newnd.last.name,
-+                                                      newnd.last.len);
-+              unlock_kernel();
-+              /* the file system want to use normal vfs path now */
-+              if (error != -EOPNOTSUPP)
-+                      goto exit2;
-+      }
-+
        double_lock(new_dir, old_dir);
  
 -      old_dentry = lookup_hash(&oldnd.last, old_dir);
        error = PTR_ERR(old_dentry);
        if (IS_ERR(old_dentry))
                goto exit3;
-@@ -1880,14 +2065,14 @@ static inline int do_rename(const char *
+@@ -1880,16 +2078,37 @@ static inline int do_rename(const char *
                if (newnd.last.name[newnd.last.len])
                        goto exit4;
        }
        if (IS_ERR(new_dentry))
                goto exit4;
  
++      if (old_dir->d_inode->i_op->rename2) {
++              lock_kernel();
++              /* don't rename mount point. mds will take care of
++               * the rest sanity checking */
++              if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry)) {
++                      error = -EBUSY;
++                      goto exit5;
++              }
++
++              error = old_dir->d_inode->i_op->rename2(old_dir->d_inode,
++                                                      new_dir->d_inode,
++                                                      oldnd.last.name,
++                                                      oldnd.last.len,
++                                                      newnd.last.name,
++                                                      newnd.last.len);
++              unlock_kernel();
++              /* the file system wants to use normal vfs path now */
++              if (error != -EOPNOTSUPP)
++                      goto exit5;
++      }
++
        lock_kernel();
        error = vfs_rename(old_dir->d_inode, old_dentry,
 -                                 new_dir->d_inode, new_dentry);
 +                                 new_dir->d_inode, new_dentry, NULL);
        unlock_kernel();
+-
++exit5:
        dput(new_dentry);
-@@ -1940,7 +2125,8 @@ out:
+ exit4:
+       dput(old_dentry);
+@@ -1940,7 +2159,8 @@ out:
  }
  
  static inline int
  {
        int res = 0;
        char *name;
-@@ -1953,7 +2139,7 @@ __vfs_follow_link(struct nameidata *nd, 
+@@ -1953,7 +2173,7 @@ __vfs_follow_link(struct nameidata *nd, 
                        /* weird __emul_prefix() stuff did it */
                        goto out;
        }
  out:
        if (current->link_count || res || nd->last_type!=LAST_NORM)
                return res;
-@@ -1975,7 +2161,13 @@ fail:
+@@ -1975,7 +2195,13 @@ fail:
  
  int vfs_follow_link(struct nameidata *nd, const char *link)
  {
  }
  
  /* get the link contents into pagecache */
-@@ -2017,7 +2209,7 @@ int page_follow_link(struct dentry *dent
+@@ -2017,7 +2243,7 @@ int page_follow_link(struct dentry *dent
  {
        struct page *page = NULL;
        char *s = page_getlink(dentry, &page);
        if (page) {
                kunmap(page);
                page_cache_release(page);
---- linux-2.4.18-49chaos-lustre9/fs/nfsd/vfs.c~vfs_intent-2.4.18-18    Wed Jan 29 12:43:32 2003
-+++ linux-2.4.18-49chaos-lustre9-root/fs/nfsd/vfs.c    Wed Jan 29 12:43:32 2003
+--- linux-2.4.18-18.8.0-l12/fs/nfsd/vfs.c~vfs_intent-2.4.18-18 Wed Feb 26 16:54:17 2003
++++ linux-2.4.18-18.8.0-l12-phil/fs/nfsd/vfs.c Wed Feb 26 16:54:17 2003
 @@ -1298,7 +1298,7 @@ nfsd_rename(struct svc_rqst *rqstp, stru
                        err = nfserr_perm;
        } else
        unlock_kernel();
        if (!err && EX_ISSYNC(tfhp->fh_export)) {
                nfsd_sync_dir(tdentry);
---- linux-2.4.18-49chaos-lustre9/fs/open.c~vfs_intent-2.4.18-18        Wed Jan 29 12:43:32 2003
-+++ linux-2.4.18-49chaos-lustre9-root/fs/open.c        Wed Jan 29 12:43:32 2003
-@@ -19,6 +19,9 @@
+--- linux-2.4.18-18.8.0-l12/fs/open.c~vfs_intent-2.4.18-18     Wed Feb 26 16:54:17 2003
++++ linux-2.4.18-18.8.0-l12-phil/fs/open.c     Wed Feb 26 16:54:17 2003
+@@ -19,6 +19,8 @@
  #include <asm/uaccess.h>
  
  #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
 +extern int path_walk_it(const char *name, struct nameidata *nd,
 +                      struct lookup_intent *it);
-+extern void intent_release(struct dentry *de, struct lookup_intent *it);
  
  int vfs_statfs(struct super_block *sb, struct statfs *buf)
  {
-@@ -118,12 +121,13 @@ static inline long do_sys_truncate(const
+@@ -95,9 +97,10 @@ void fd_install(unsigned int fd, struct 
+       write_unlock(&files->file_lock);
+ }
+-int do_truncate(struct dentry *dentry, loff_t length)
++int do_truncate(struct dentry *dentry, loff_t length, int called_from_open)
+ {
+       struct inode *inode = dentry->d_inode;
++      struct inode_operations *op = dentry->d_inode->i_op;
+       int error;
+       struct iattr newattrs;
+@@ -108,7 +111,14 @@ int do_truncate(struct dentry *dentry, l
+       down(&inode->i_sem);
+       newattrs.ia_size = length;
+       newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
+-      error = notify_change(dentry, &newattrs);
++      if (called_from_open)
++              newattrs.ia_valid |= ATTR_FROM_OPEN;
++      if (op->setattr_raw) {
++              newattrs.ia_valid |= ATTR_RAW;
++              newattrs.ia_ctime = CURRENT_TIME;
++              error = op->setattr_raw(inode, &newattrs);
++      } else 
++              error = notify_change(dentry, &newattrs);
+       up(&inode->i_sem);
+       return error;
+ }
+@@ -118,12 +128,13 @@ static inline long do_sys_truncate(const
        struct nameidata nd;
        struct inode * inode;
        int error;
-+      struct lookup_intent it = { .it_op = IT_TRUNC };
++      struct lookup_intent it = { .it_op = IT_GETATTR };
  
        error = -EINVAL;
        if (length < 0) /* sorry, but loff_t says... */
        if (error)
                goto out;
        inode = nd.dentry->d_inode;
-@@ -168,6 +172,7 @@ static inline long do_sys_truncate(const
+@@ -163,11 +174,13 @@ static inline long do_sys_truncate(const
+       error = locks_verify_truncate(inode, NULL, length);
+       if (!error) {
+               DQUOT_INIT(inode);
+-              error = do_truncate(nd.dentry, length);
++              intent_release(nd.dentry, &it);
++              error = do_truncate(nd.dentry, length, 0);
+       }
        put_write_access(inode);
  
  dput_and_out:
        path_release(&nd);
  out:
        return error;
-@@ -259,8 +264,9 @@ asmlinkage long sys_utime(char * filenam
-       struct nameidata nd;
+@@ -215,7 +228,7 @@ static inline long do_sys_ftruncate(unsi
+       error = locks_verify_truncate(inode, file, length);
+       if (!error)
+-              error = do_truncate(dentry, length);
++              error = do_truncate(dentry, length, 0);
+ out_putf:
+       fput(file);
+ out:
+@@ -260,11 +273,13 @@ asmlinkage long sys_utime(char * filenam
        struct inode * inode;
        struct iattr newattrs;
-+      struct lookup_intent it = { .it_op = IT_SETATTR };
  
 -      error = user_path_walk(filename, &nd);
-+      error = user_path_walk_it(filename, &nd, &it);
++      error = user_path_walk_it(filename, &nd, NULL);
        if (error)
                goto out;
        inode = nd.dentry->d_inode;
-@@ -286,6 +292,7 @@ asmlinkage long sys_utime(char * filenam
++      /* this is safe without a Lustre lock because it only depends
++         on the super block */
+       error = -EROFS;
+       if (IS_RDONLY(inode))
+               goto dput_and_out;
+@@ -279,11 +294,29 @@ asmlinkage long sys_utime(char * filenam
+                       goto dput_and_out;
+               newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
+-      } else {
++      }
++
++      if (inode->i_op->setattr_raw) {
++              struct inode_operations *op = nd.dentry->d_inode->i_op;
++
++              newattrs.ia_valid |= ATTR_RAW;
++              error = op->setattr_raw(inode, &newattrs);
++              /* the file system wants to use normal vfs path now */
++              if (error != -EOPNOTSUPP)
++                      goto dput_and_out;
++      }
++
++      error = -EROFS;
++      if (IS_RDONLY(inode))
++              goto dput_and_out;
++
++      error = -EPERM;
++      if (!times) {
+               if (current->fsuid != inode->i_uid &&
+                   (error = permission(inode,MAY_WRITE)) != 0)
+                       goto dput_and_out;
        }
++
        error = notify_change(nd.dentry, &newattrs);
  dput_and_out:
-+      intent_release(nd.dentry, &it);
        path_release(&nd);
- out:
-       return error;
-@@ -303,8 +310,9 @@ asmlinkage long sys_utimes(char * filena
-       struct nameidata nd;
+@@ -304,12 +337,14 @@ asmlinkage long sys_utimes(char * filena
        struct inode * inode;
        struct iattr newattrs;
-+      struct lookup_intent it = { .it_op = IT_SETATTR };
  
 -      error = user_path_walk(filename, &nd);
-+      error = user_path_walk_it(filename, &nd, &it);
++      error = user_path_walk_it(filename, &nd, NULL);
  
        if (error)
                goto out;
-@@ -331,6 +339,7 @@ asmlinkage long sys_utimes(char * filena
-       }
-       error = notify_change(nd.dentry, &newattrs);
- dput_and_out:
-+      intent_release(nd.dentry, &it);
-       path_release(&nd);
- out:
-       return error;
-@@ -347,6 +356,7 @@ asmlinkage long sys_access(const char * 
+       inode = nd.dentry->d_inode;
++      /* this is safe without a Lustre lock because it only depends
++         on the super block */
+       error = -EROFS;
+       if (IS_RDONLY(inode))
+               goto dput_and_out;
+@@ -324,7 +359,20 @@ asmlinkage long sys_utimes(char * filena
+               newattrs.ia_atime = times[0].tv_sec;
+               newattrs.ia_mtime = times[1].tv_sec;
+               newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
+-      } else {
++      }
++
++      if (inode->i_op->setattr_raw) {
++              struct inode_operations *op = nd.dentry->d_inode->i_op;
++
++              newattrs.ia_valid |= ATTR_RAW;
++              error = op->setattr_raw(inode, &newattrs);
++              /* the file system wants to use normal vfs path now */
++              if (error != -EOPNOTSUPP)
++                      goto dput_and_out;
++      }
++
++      error = -EPERM;
++      if (!utimes) {
+               if (current->fsuid != inode->i_uid &&
+                   (error = permission(inode,MAY_WRITE)) != 0)
+                       goto dput_and_out;
+@@ -347,6 +395,7 @@ asmlinkage long sys_access(const char * 
        int old_fsuid, old_fsgid;
        kernel_cap_t old_cap;
        int res;
  
        if (mode & ~S_IRWXO)    /* where's F_OK, X_OK, W_OK, R_OK? */
                return -EINVAL;
-@@ -364,13 +374,14 @@ asmlinkage long sys_access(const char * 
+@@ -364,13 +413,14 @@ asmlinkage long sys_access(const char * 
        else
                current->cap_effective = current->cap_permitted;
  
                path_release(&nd);
        }
  
-@@ -385,8 +396,11 @@ asmlinkage long sys_chdir(const char * f
+@@ -385,8 +435,11 @@ asmlinkage long sys_chdir(const char * f
  {
        int error;
        struct nameidata nd;
        if (error)
                goto out;
  
-@@ -397,6 +411,7 @@ asmlinkage long sys_chdir(const char * f
+@@ -397,6 +450,7 @@ asmlinkage long sys_chdir(const char * f
        set_fs_pwd(current->fs, nd.mnt, nd.dentry);
  
  dput_and_out:
        path_release(&nd);
  out:
        return error;
-@@ -436,9 +451,10 @@ asmlinkage long sys_chroot(const char * 
+@@ -436,9 +490,10 @@ asmlinkage long sys_chroot(const char * 
  {
        int error;
        struct nameidata nd;
        if (error)
                goto out;
  
-@@ -454,6 +470,7 @@ asmlinkage long sys_chroot(const char * 
+@@ -454,6 +509,7 @@ asmlinkage long sys_chroot(const char * 
        set_fs_altroot();
        error = 0;
  dput_and_out:
        path_release(&nd);
  out:
        return error;
-@@ -498,8 +515,9 @@ asmlinkage long sys_chmod(const char * f
-       struct inode * inode;
-       int error;
-       struct iattr newattrs;
-+      struct lookup_intent it = { .it_op = IT_SETATTR };
+@@ -508,6 +564,18 @@ asmlinkage long sys_chmod(const char * f
+       if (IS_RDONLY(inode))
+               goto dput_and_out;
  
--      error = user_path_walk(filename, &nd);
-+      error = user_path_walk_it(filename, &nd, &it);
-       if (error)
++      if (inode->i_op->setattr_raw) {
++              struct inode_operations *op = nd.dentry->d_inode->i_op;
++
++              newattrs.ia_mode = mode;
++              newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
++              newattrs.ia_valid |= ATTR_RAW;
++              error = op->setattr_raw(inode, &newattrs);
++              /* the file system wants to use normal vfs path now */
++              if (error != -EOPNOTSUPP)
++                      goto dput_and_out;
++      }
++
+       error = -EPERM;
+       if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
+               goto dput_and_out;
+@@ -538,6 +606,20 @@ static int chown_common(struct dentry * 
+       error = -EROFS;
+       if (IS_RDONLY(inode))
                goto out;
-       inode = nd.dentry->d_inode;
-@@ -519,6 +537,7 @@ asmlinkage long sys_chmod(const char * f
-       error = notify_change(nd.dentry, &newattrs);
- dput_and_out:
-+      intent_release(nd.dentry, &it);
-       path_release(&nd);
- out:
-       return error;
-@@ -588,10 +607,12 @@ asmlinkage long sys_chown(const char * f
- {
-       struct nameidata nd;
-       int error;
-+      struct lookup_intent it = { .it_op = IT_SETATTR };
--      error = user_path_walk(filename, &nd);
-+      error = user_path_walk_it(filename, &nd, &it);
-       if (!error) {
-               error = chown_common(nd.dentry, user, group);
-+              intent_release(nd.dentry, &it);
-               path_release(&nd);
-       }
-       return error;
-@@ -601,10 +622,12 @@ asmlinkage long sys_lchown(const char * 
- {
-       struct nameidata nd;
-       int error;
-+      struct lookup_intent it = { .it_op = IT_SETATTR };
--      error = user_path_walk_link(filename, &nd);
-+      error = user_path_walk_link_it(filename, &nd, &it);
-       if (!error) {
-               error = chown_common(nd.dentry, user, group);
-+              intent_release(nd.dentry, &it);
-               path_release(&nd);
-       }
-       return error;
-@@ -628,7 +651,8 @@ extern ssize_t do_readahead(struct file 
++
++      if (inode->i_op->setattr_raw) {
++              struct inode_operations *op = dentry->d_inode->i_op;
++
++              newattrs.ia_uid = user;
++              newattrs.ia_gid = group;
++              newattrs.ia_valid = ATTR_UID | ATTR_GID;
++              newattrs.ia_valid |= ATTR_RAW;
++              error = op->setattr_raw(inode, &newattrs);
++              /* the file system wants to use normal vfs path now */
++              if (error != -EOPNOTSUPP)
++                      return error;
++      }
++
+       error = -EPERM;
+       if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
+               goto out;
+@@ -628,7 +710,8 @@ extern ssize_t do_readahead(struct file 
  /* for files over a certains size it doesn't pay to do readahead on open */
  #define READAHEAD_CUTOFF 48000
  
  {
        struct file * f;
        struct inode *inode;
-@@ -693,6 +717,7 @@ struct file *dentry_open(struct dentry *
+@@ -649,7 +732,7 @@ struct file *dentry_open(struct dentry *
+               error = locks_verify_locked(inode);
+               if (!error) {
+                       DQUOT_INIT(inode);
+-                      error = do_truncate(dentry, 0);
++                      error = do_truncate(dentry, 0, 1);
+               }
+               if (error || !(f->f_mode & FMODE_WRITE))
+                       put_write_access(inode);
+@@ -693,6 +776,7 @@ struct file *dentry_open(struct dentry *
                do_readahead(f, 0, (48 * 1024) >> PAGE_SHIFT);
        
  
        return f;
  
  cleanup_all:
-@@ -707,11 +732,17 @@ cleanup_all:
+@@ -707,11 +791,17 @@ cleanup_all:
  cleanup_file:
        put_filp(f);
  cleanup_dentry:
  /*
   * Find an empty file descriptor entry, and mark it busy.
   */
---- linux-2.4.18-49chaos-lustre9/fs/stat.c~vfs_intent-2.4.18-18        Wed Jan 29 12:43:32 2003
-+++ linux-2.4.18-49chaos-lustre9-root/fs/stat.c        Wed Jan 29 12:43:32 2003
-@@ -13,6 +13,7 @@
- #include <asm/uaccess.h>
-+extern void intent_release(struct dentry *de, struct lookup_intent *it);
- /*
-  * Revalidate the inode. This is required for proper NFS attribute caching.
-  */
-@@ -104,10 +105,12 @@ int vfs_stat(char *name, struct kstat *s
+--- linux-2.4.18-18.8.0-l12/fs/stat.c~vfs_intent-2.4.18-18     Wed Feb 26 16:54:17 2003
++++ linux-2.4.18-18.8.0-l12-phil/fs/stat.c     Wed Feb 26 16:54:17 2003
+@@ -104,10 +104,12 @@ int vfs_stat(char *name, struct kstat *s
  {
        struct nameidata nd;
        int error;
                path_release(&nd);
        }
        return error;
-@@ -117,10 +120,12 @@ int vfs_lstat(char *name, struct kstat *
+@@ -117,10 +119,12 @@ int vfs_lstat(char *name, struct kstat *
  {
        struct nameidata nd;
        int error;
                path_release(&nd);
        }
        return error;
---- linux-2.4.18-49chaos-lustre9/include/linux/dcache.h~vfs_intent-2.4.18-18   Wed Jan 29 12:43:32 2003
-+++ linux-2.4.18-49chaos-lustre9-root/include/linux/dcache.h   Wed Jan 29 12:43:32 2003
-@@ -6,6 +6,27 @@
+--- linux-2.4.18-18.8.0-l12/fs/exec.c~vfs_intent-2.4.18-18     Wed Feb 26 16:54:17 2003
++++ linux-2.4.18-18.8.0-l12-phil/fs/exec.c     Wed Feb 26 16:54:17 2003
+@@ -103,13 +103,18 @@ static inline void put_binfmt(struct lin
+  *
+  * Also note that we take the address to load from from the file itself.
+  */
++extern struct file *dentry_open_it(struct dentry *dentry, struct vfsmount *mnt,
++                          int flags, struct lookup_intent *it);
++int path_lookup_it(const char *path, unsigned flags, struct nameidata *nd,
++                 struct lookup_intent *it);
+ asmlinkage long sys_uselib(const char * library)
+ {
+       struct file * file;
+       struct nameidata nd;
+       int error;
++      struct lookup_intent it = { .it_op = IT_OPEN, .it_flags = O_RDONLY };
+-      error = user_path_walk(library, &nd);
++      error = user_path_walk_it(library, &nd, &it);
+       if (error)
+               goto out;
+@@ -121,7 +126,8 @@ asmlinkage long sys_uselib(const char * 
+       if (error)
+               goto exit;
+-      file = dentry_open(nd.dentry, nd.mnt, O_RDONLY);
++      file = dentry_open_it(nd.dentry, nd.mnt, O_RDONLY, &it);
++      intent_release(nd.dentry, &it);
+       error = PTR_ERR(file);
+       if (IS_ERR(file))
+               goto out;
+@@ -350,8 +356,9 @@ struct file *open_exec(const char *name)
+       struct inode *inode;
+       struct file *file;
+       int err = 0;
++      struct lookup_intent it = { .it_op = IT_OPEN, .it_flags = O_RDONLY };
+-      err = path_lookup(name, LOOKUP_FOLLOW|LOOKUP_POSITIVE, &nd);
++      err = path_lookup_it(name, LOOKUP_FOLLOW|LOOKUP_POSITIVE, &nd, &it);
+       file = ERR_PTR(err);
+       if (!err) {
+               inode = nd.dentry->d_inode;
+@@ -363,7 +370,8 @@ struct file *open_exec(const char *name)
+                               err = -EACCES;
+                       file = ERR_PTR(err);
+                       if (!err) {
+-                              file = dentry_open(nd.dentry, nd.mnt, O_RDONLY);
++                              file = dentry_open_it(nd.dentry, nd.mnt, O_RDONLY, &it);
++                              intent_release(nd.dentry, &it);
+                               if (!IS_ERR(file)) {
+                                       err = deny_write_access(file);
+                                       if (err) {
+@@ -976,7 +984,7 @@ int do_coredump(long signr, struct pt_re
+               goto close_fail;
+       if (!file->f_op->write)
+               goto close_fail;
+-      if (do_truncate(file->f_dentry, 0) != 0)
++      if (do_truncate(file->f_dentry, 0, 0) != 0)
+               goto close_fail;
+       retval = binfmt->core_dump(signr, regs, file);
+--- linux-2.4.18-18.8.0-l12/include/linux/dcache.h~vfs_intent-2.4.18-18        Wed Feb 26 16:54:17 2003
++++ linux-2.4.18-18.8.0-l12-phil/include/linux/dcache.h        Wed Feb 26 17:01:30 2003
+@@ -6,6 +6,25 @@
  #include <asm/atomic.h>
  #include <linux/mount.h>
  
 +#define IT_CREAT    (1<<1)
 +#define IT_READDIR  (1<<2)
 +#define IT_GETATTR  (1<<3)
-+#define IT_SETATTR  (1<<4)
-+#define IT_TRUNC    (1<<5)
-+#define IT_READLINK (1<<6)
-+#define IT_LOOKUP   (1<<7)
++#define IT_LOOKUP   (1<<4)
++#define IT_UNLINK   (1<<5)
 +
 +struct lookup_intent {
 +      int it_op;
  /*
   * linux/include/linux/dcache.h
   *
-@@ -78,6 +99,7 @@ struct dentry {
+@@ -78,6 +97,7 @@ struct dentry {
        unsigned long d_time;           /* used by d_revalidate */
        struct dentry_operations  *d_op;
        struct super_block * d_sb;      /* The root of the dentry tree */
        unsigned long d_vfs_flags;
        void * d_fsdata;                /* fs-specific data */
        void * d_extra_attributes;      /* TUX-specific data */
-@@ -91,6 +113,8 @@ struct dentry_operations {
+@@ -91,8 +111,15 @@ struct dentry_operations {
        int (*d_delete)(struct dentry *);
        void (*d_release)(struct dentry *);
        void (*d_iput)(struct dentry *, struct inode *);
 +      void (*d_intent_release)(struct dentry *, struct lookup_intent *);
  };
  
++/* defined in fs/namei.c */
++extern void intent_release(struct dentry *de, struct lookup_intent *it);
++/* defined in fs/dcache.c */
++extern void __d_rehash(struct dentry * entry, int lock);
++
  /* the dentry parameter passed to d_hash and d_compare is the parent
-@@ -124,6 +148,7 @@ d_iput:            no              no              yes
+  * directory of the entries to be compared. It is used in case these
+  * functions need any directory specific information for determining
+@@ -124,6 +151,7 @@ d_iput:            no              no              yes
                                         * s_nfsd_free_path semaphore will be down
                                         */
  #define DCACHE_REFERENCED     0x0008  /* Recently used, don't discard. */
  
  extern spinlock_t dcache_lock;
  
---- linux-2.4.18-49chaos-lustre9/include/linux/fs.h~vfs_intent-2.4.18-18       Wed Jan 29 12:43:32 2003
-+++ linux-2.4.18-49chaos-lustre9-root/include/linux/fs.h       Wed Jan 29 12:43:32 2003
-@@ -576,6 +576,7 @@ struct file {
+--- linux-2.4.18-18.8.0-l12/include/linux/fs.h~vfs_intent-2.4.18-18    Wed Feb 26 16:54:17 2003
++++ linux-2.4.18-18.8.0-l12-phil/include/linux/fs.h    Wed Feb 26 17:31:42 2003
+@@ -338,6 +338,8 @@ extern void set_bh_page(struct buffer_he
+ #define ATTR_MTIME_SET        256
+ #define ATTR_FORCE    512     /* Not a change, but a change it */
+ #define ATTR_ATTR_FLAG        1024
++#define ATTR_RAW      2048    /* file system, not vfs will massage attrs */
++#define ATTR_FROM_OPEN        4096    /* called from open path, ie O_TRUNC */
+ /*
+  * This is the Inode Attributes structure, used for notify_change().  It
+@@ -576,6 +578,7 @@ struct file {
  
        /* needed for tty driver, and maybe others */
        void                    *private_data;
  
        /* preallocated helper kiobuf to speedup O_DIRECT */
        struct kiobuf           *f_iobuf;
-@@ -836,7 +837,9 @@ extern int vfs_symlink(struct inode *, s
+@@ -836,7 +839,9 @@ extern int vfs_symlink(struct inode *, s
  extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
  extern int vfs_rmdir(struct inode *, struct dentry *);
  extern int vfs_unlink(struct inode *, struct dentry *);
  
  /*
   * File types
-@@ -897,16 +900,28 @@ struct file_operations {
+@@ -897,20 +902,33 @@ struct file_operations {
  struct inode_operations {
        int (*create) (struct inode *,struct dentry *,int);
        struct dentry * (*lookup) (struct inode *,struct dentry *);
        void (*truncate) (struct inode *);
        int (*permission) (struct inode *, int);
        int (*revalidate) (struct dentry *);
-@@ -1383,6 +1398,7 @@ typedef int (*read_actor_t)(read_descrip
+       int (*setattr) (struct dentry *, struct iattr *);
++      int (*setattr_raw) (struct inode *, struct iattr *);
+       int (*getattr) (struct dentry *, struct iattr *);
+ };
+@@ -1112,7 +1130,7 @@ static inline int get_lease(struct inode
+ asmlinkage long sys_open(const char *, int, int);
+ asmlinkage long sys_close(unsigned int);      /* yes, it's really unsigned */
+-extern int do_truncate(struct dentry *, loff_t start);
++extern int do_truncate(struct dentry *, loff_t start, int called_from_open);
+ extern struct file *filp_open(const char *, int, int);
+ extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
+@@ -1381,6 +1399,7 @@ typedef int (*read_actor_t)(read_descrip
  extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
  
  extern int FASTCALL(__user_walk(const char *, unsigned, struct nameidata *));
  extern int FASTCALL(path_init(const char *, unsigned, struct nameidata *));
  extern int FASTCALL(path_walk(const char *, struct nameidata *));
  extern int FASTCALL(path_lookup(const char *, unsigned, struct nameidata *));
-@@ -1394,6 +1410,8 @@ extern struct dentry * lookup_one_len(co
+@@ -1392,6 +1411,8 @@ extern struct dentry * lookup_one_len(co
  extern struct dentry * lookup_hash(struct qstr *, struct dentry *);
  #define user_path_walk(name,nd)        __user_walk(name, LOOKUP_FOLLOW|LOOKUP_POSITIVE, nd)
  #define user_path_walk_link(name,nd) __user_walk(name, LOOKUP_POSITIVE, nd)
  
  extern void inode_init_once(struct inode *);
  extern void iput(struct inode *);
-@@ -1494,6 +1512,8 @@ extern struct file_operations generic_ro
+@@ -1492,6 +1513,8 @@ extern struct file_operations generic_ro
  
  extern int vfs_readlink(struct dentry *, char *, int, const char *);
  extern int vfs_follow_link(struct nameidata *, const char *);
  extern int page_readlink(struct dentry *, char *, int);
  extern int page_follow_link(struct dentry *, struct nameidata *);
  extern struct inode_operations page_symlink_inode_operations;
---- linux-2.4.18-49chaos-lustre9/kernel/ksyms.c~vfs_intent-2.4.18-18   Wed Jan 29 12:43:32 2003
-+++ linux-2.4.18-49chaos-lustre9-root/kernel/ksyms.c   Wed Jan 29 12:43:32 2003
-@@ -294,6 +294,7 @@ EXPORT_SYMBOL(read_cache_page);
+--- linux-2.4.18-18.8.0-l12/kernel/ksyms.c~vfs_intent-2.4.18-18        Wed Feb 26 16:54:17 2003
++++ linux-2.4.18-18.8.0-l12-phil/kernel/ksyms.c        Wed Feb 26 16:54:17 2003
+@@ -293,6 +293,7 @@ EXPORT_SYMBOL(read_cache_page);
  EXPORT_SYMBOL(set_page_dirty);
  EXPORT_SYMBOL(vfs_readlink);
  EXPORT_SYMBOL(vfs_follow_link);
  EXPORT_SYMBOL(page_readlink);
  EXPORT_SYMBOL(page_follow_link);
  EXPORT_SYMBOL(page_symlink_inode_operations);
-
-_
index 63f09b3..fa0998a 100644 (file)
@@ -1,15 +1,16 @@
- fs/dcache.c            |    3 
- fs/namei.c             |  306 ++++++++++++++++++++++++++++++++++++++++---------
+ fs/dcache.c            |    8 
+ fs/namei.c             |  335 +++++++++++++++++----
  fs/nfsd/vfs.c          |    2 
- fs/open.c              |   63 +++++++---
- fs/stat.c              |   29 +++-
- include/linux/dcache.h |   31 ++++
- include/linux/fs.h     |   22 +++
+ fs/open.c              |  142 +++++++-
+ fs/stat.c              |   24 +
+ include/linux/dcache.h |   26 +
+ include/linux/fs.h     |   2+
  kernel/ksyms.c         |    1 
- 8 files changed, 384 insertions(+), 73 deletions(-)
-
---- linux-2.4.19-hp2_pnnl2/fs/dcache.c~vfs_intent_hp   Sun Jan 19 19:04:47 2003
-+++ linux-2.4.19-hp2_pnnl2-root/fs/dcache.c    Sun Jan 19 19:04:47 2003
+ fs/exec.c                   |   18 -
+ 9 files changed, 487 insertions(+), 96 deletions(-)
+--- linux-2.4.19-hp2_pnnl4/fs/dcache.c~vfs_intent_hp   Sun Jan 19 19:04:47 2003
++++ linux-2.4.19-hp2_pnnl4-root/fs/dcache.c    Sun Jan 19 19:04:47 2003
 @@ -186,6 +188,13 @@ int d_invalidate(struct dentry * dentry)
                spin_unlock(&dcache_lock);
                return 0;
        INIT_LIST_HEAD(&dentry->d_hash);
        INIT_LIST_HEAD(&dentry->d_lru);
        INIT_LIST_HEAD(&dentry->d_subdirs);
---- linux-2.4.19-hp2_pnnl2/fs/namei.c~vfs_intent_hp    Sun Jan 19 19:04:47 2003
-+++ linux-2.4.19-hp2_pnnl2-root/fs/namei.c     Sun Jan 19 19:35:55 2003
+@@ -859,13 +867,19 @@ void d_delete(struct dentry * dentry)
+  * Adds a dentry to the hash according to its name.
+  */
+  
+-void d_rehash(struct dentry * entry)
++void __d_rehash(struct dentry * entry, int lock)
+ {
+       struct list_head *list = d_hash(entry->d_parent, entry->d_name.hash);
+       if (!list_empty(&entry->d_hash)) BUG();
+-      spin_lock(&dcache_lock);
++      if (lock) spin_lock(&dcache_lock);
+       list_add(&entry->d_hash, list);
+-      spin_unlock(&dcache_lock);
++      if (lock) spin_unlock(&dcache_lock);
++}
++EXPORT_SYMBOL(__d_rehash);
++
++void d_rehash(struct dentry * entry)
++{
++      __d_rehash(entry, 1);
+ }
+ #define do_switch(x,y) do { \
+--- linux-2.4.19-hp2_pnnl4/fs/namei.c~vfs_intent_hp    Sun Jan 19 19:04:47 2003
++++ linux-2.4.19-hp2_pnnl4-root/fs/namei.c     Sun Jan 19 19:35:55 2003
 @@ -94,6 +97,13 @@
   * XEmacs seems to be relying on it...
   */
        path_release(nd);
        return -ELOOP;
  }
+@@ -381,15 +416,26 @@ int follow_up(struct vfsmount **mnt, str
+       return __follow_up(mnt, dentry);
+ }
+-static inline int __follow_down(struct vfsmount **mnt, struct dentry **dentry)
++static inline int __follow_down(struct vfsmount **mnt, struct dentry **dentry,
++                              struct lookup_intent *it)
+ {
+       struct vfsmount *mounted;
+       spin_lock(&dcache_lock);
+       mounted = lookup_mnt(*mnt, *dentry);
+       if (mounted) {
++              int opc = 0, mode = 0;
+               *mnt = mntget(mounted);
+               spin_unlock(&dcache_lock);
++              if (it) {
++                      opc = it->it_op;
++                      mode = it->it_mode;
++              }
++              intent_release(*dentry, it);
++              if (it) {
++                      it->it_op = opc;
++                      it->it_mode = mode;
++              }
+               dput(*dentry);
+               mntput(mounted->mnt_parent);
+               *dentry = dget(mounted->mnt_root);
+@@ -401,7 +447,7 @@ static inline int __follow_down(struct v
+ int follow_down(struct vfsmount **mnt, struct dentry **dentry)
+ {
+-      return __follow_down(mnt,dentry);
++      return __follow_down(mnt,dentry,NULL);
+ }
+  
+ static inline void follow_dotdot(struct nameidata *nd)
+@@ -437,7 +483,7 @@ static inline void follow_dotdot(struct 
+               mntput(nd->mnt);
+               nd->mnt = parent;
+       }
+-      while (d_mountpoint(nd->dentry) && __follow_down(&nd->mnt, &nd->dentry))
++      while (d_mountpoint(nd->dentry) && __follow_down(&nd->mnt, &nd->dentry, NULL))
+               ;
+ }
 @@ -447,7 +482,8 @@ static inline void follow_dotdot(struct 
   *
   * We expect 'base' to be positive and a directory.
  {
        struct dentry *dentry;
        struct inode *inode;
-@@ -520,9 +556,9 @@ int link_path_walk(const char * name, st
+@@ -520,15 +556,15 @@ int link_path_walk(const char * name, st
                                break;
                }
                /* This does the actual lookups.. */
                        err = PTR_ERR(dentry);
                        if (IS_ERR(dentry))
                                break;
+               }
+               /* Check mountpoints.. */
+-              while (d_mountpoint(dentry) && __follow_down(&nd->mnt, &dentry))
++              while (d_mountpoint(dentry) && __follow_down(&nd->mnt, &dentry, NULL))
+                       ;
+               err = -ENOENT;
 @@ -539,8 +575,8 @@ int link_path_walk(const char * name, st
                if (!inode->i_op)
                        goto out_dput;
                        break;
                continue;
                /* here ends the main loop */
-@@ -583,9 +619,9 @@ last_component:
+@@ -583,19 +619,20 @@ last_component:
                        if (err < 0)
                                break;
                }
                        err = PTR_ERR(dentry);
                        if (IS_ERR(dentry))
                                break;
-@@ -594,8 +630,9 @@ last_component:
+               }
+-              while (d_mountpoint(dentry) && __follow_down(&nd->mnt, &dentry))
++              while (d_mountpoint(dentry) && __follow_down(&nd->mnt, &dentry, it))
                        ;
                inode = dentry->d_inode;
                if ((lookup_flags & LOOKUP_FOLLOW)
        /* Negative dentry, just create the file */
        if (!dentry->d_inode) {
                if (!IS_POSIXACL(dir->d_inode))
-@@ -1071,7 +1156,8 @@ do_last:
+@@ -1066,12 +1151,13 @@ do_last:
+               error = -ELOOP;
+               if (flag & O_NOFOLLOW)
+                       goto exit_dput;
+-              while (__follow_down(&nd->mnt,&dentry) && d_mountpoint(dentry));
++              while (__follow_down(&nd->mnt,&dentry,it) && d_mountpoint(dentry));
+       }
        error = -ENOENT;
        if (!dentry->d_inode)
                goto exit_dput;
                goto do_link;
  
        dput(nd->dentry);
+@@ -1145,7 +1231,7 @@ do_last:
+               if (!error) {
+                       DQUOT_INIT(inode);
+                       
+-                      error = do_truncate(dentry, 0);
++                      error = do_truncate(dentry, 0, 1);
+               }
+               put_write_access(inode);
+               if (error)
 @@ -1157,8 +1243,10 @@ ok:
        return 0;
  
 +                                 nd.last.name,
 +                                 nd.last.len,
 +                                 mode, dev);
-+              /* the file system want to use normal vfs path now */
++              /* the file system wants to use normal vfs path now */
 +              if (error != -EOPNOTSUPP)
 +                      goto out2;
 +      }
 +                                         nd.last.name,
 +                                         nd.last.len,
 +                                         mode);
-+                      /* the file system want to use normal vfs path now */
++                      /* the file system wants to use normal vfs path now */
 +                      if (error != -EOPNOTSUPP)
 +                              goto out2;
 +              }
                path_release(&nd);
  out:
                putname(tmp);
-@@ -1450,8 +1578,17 @@ asmlinkage long sys_rmdir(const char * p
+@@ -1450,8 +1578,33 @@ asmlinkage long sys_rmdir(const char * p
                        error = -EBUSY;
                        goto exit1;
        }
 +      if (nd.dentry->d_inode->i_op->rmdir2) {
 +              struct inode_operations *op = nd.dentry->d_inode->i_op;
++              struct dentry *last;
++
++              down(&nd.dentry->d_inode->i_sem);
++              last = lookup_hash_it(&nd.last, nd.dentry, NULL);
++              up(&nd.dentry->d_inode->i_sem);
++              if (IS_ERR(last)) {
++                      error = PTR_ERR(last);
++                      goto exit1;
++              }
++              if (d_mountpoint(last)) {
++                      dput(last);
++                      error = -EBUSY;
++                      goto exit1;
++              }
++              dput(last);
++
 +              error = op->rmdir2(nd.dentry->d_inode,
 +                                 nd.last.name,
 +                                 nd.last.len);
-+              /* the file system want to use normal vfs path now */
++              /* the file system wants to use normal vfs path now */
 +              if (error != -EOPNOTSUPP)
 +                      goto exit1;
 +      }
 +              error = op->unlink2(nd.dentry->d_inode,
 +                                  nd.last.name,
 +                                  nd.last.len);
-+              /* the file system want to use normal vfs path now */
++              /* the file system wants to use normal vfs path now */
 +              if (error != -EOPNOTSUPP)
 +                      goto exit1;
 +      }
                if (error)
                        goto out;
 -              dentry = lookup_create(&nd, 0);
-+              if (nd.dentry->d_inode->i_op->symlink2) {
++              if (nd.dentry->d_inode->i_op->symlink2) {
 +                      struct inode_operations *op = nd.dentry->d_inode->i_op;
 +                      error = op->symlink2(nd.dentry->d_inode,
 +                                           nd.last.name,
 +                                           nd.last.len,
 +                                           from);
-+                      /* the file system want to use normal vfs path now */
++                      /* the file system wants to use normal vfs path now */
 +                      if (error != -EOPNOTSUPP)
 +                              goto out2;
 +              }
 +                                        nd.dentry->d_inode,
 +                                        nd.last.name,
 +                                        nd.last.len);
-+                      /* the file system want to use normal vfs path now */
++                      /* the file system wants to use normal vfs path now */
 +                      if (error != -EOPNOTSUPP)
 +                              goto out_release;
 +              }
        if (!error) {
                if (old_dir == new_dir)
                        inode_dir_notify(old_dir, DN_RENAME);
-@@ -1886,9 +2068,23 @@ static inline int do_rename(const char *
-       if (newnd.last_type != LAST_NORM)
-               goto exit2;
+@@ -1888,7 +2070,7 @@ static inline int do_rename(const char *
  
-+      if (old_dir->d_inode->i_op->rename2) {
-+              lock_kernel();
-+              error = old_dir->d_inode->i_op->rename2(old_dir->d_inode,
-+                                                      new_dir->d_inode,
-+                                                      oldnd.last.name,
-+                                                      oldnd.last.len,
-+                                                      newnd.last.name,
-+                                                      newnd.last.len);
-+              unlock_kernel();
-+              /* the file system want to use normal vfs path now */
-+              if (error != -EOPNOTSUPP)
-+                      goto exit2;
-+      }
-+
        double_lock(new_dir, old_dir);
  
 -      old_dentry = lookup_hash(&oldnd.last, old_dir);
        error = PTR_ERR(old_dentry);
        if (IS_ERR(old_dentry))
                goto exit3;
-@@ -1904,14 +2100,14 @@ static inline int do_rename(const char *
+@@ -1904,16 +2086,37 @@ static inline int do_rename(const char *
                if (newnd.last.name[newnd.last.len])
                        goto exit4;
        }
        if (IS_ERR(new_dentry))
                goto exit4;
  
++      if (old_dir->d_inode->i_op->rename2) {
++              lock_kernel();
++              /* don't rename mount point. mds will take care of
++               * the rest sanity checking */
++              if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry)) {
++                      error = -EBUSY;
++                      goto exit5;
++              }
++
++              error = old_dir->d_inode->i_op->rename2(old_dir->d_inode,
++                                                      new_dir->d_inode,
++                                                      oldnd.last.name,
++                                                      oldnd.last.len,
++                                                      newnd.last.name,
++                                                      newnd.last.len);
++              unlock_kernel();
++              /* the file system wants to use normal vfs path now */
++              if (error != -EOPNOTSUPP)
++                      goto exit5;
++      }
++
        lock_kernel();
        error = vfs_rename(old_dir->d_inode, old_dentry,
 -                                 new_dir->d_inode, new_dentry);
 +                                 new_dir->d_inode, new_dentry, NULL);
        unlock_kernel();
+-
++exit5:
        dput(new_dentry);
+ exit4:
+       dput(old_dentry);
 @@ -1964,7 +2163,8 @@ out:
  }
  
        if (page) {
                kunmap(page);
                page_cache_release(page);
---- linux-2.4.19-hp2_pnnl2/fs/nfsd/vfs.c~vfs_intent_hp Sun Jan 19 19:04:47 2003
-+++ linux-2.4.19-hp2_pnnl2-root/fs/nfsd/vfs.c  Sun Jan 19 19:37:57 2003
+--- linux-2.4.19-hp2_pnnl4/fs/nfsd/vfs.c~vfs_intent_hp Sun Jan 19 19:04:47 2003
++++ linux-2.4.19-hp2_pnnl4-root/fs/nfsd/vfs.c  Sun Jan 19 19:37:57 2003
 @@ -1295,7 +1295,7 @@ nfsd_rename(struct svc_rqst *rqstp, stru
                        err = nfserr_perm;
        } else
        if (!err && EX_ISSYNC(tfhp->fh_export)) {
                nfsd_sync_dir(tdentry);
                nfsd_sync_dir(fdentry);
---- linux-2.4.19-hp2_pnnl2/fs/open.c~vfs_intent_hp     Sun Jan 19 19:04:47 2003
-+++ linux-2.4.19-hp2_pnnl2-root/fs/open.c      Sun Jan 19 19:41:00 2003
-@@ -19,6 +19,9 @@
+--- linux-2.4.19-hp2_pnnl4/fs/open.c~vfs_intent_hp     Sun Jan 19 19:04:47 2003
++++ linux-2.4.19-hp2_pnnl4-root/fs/open.c      Sun Jan 19 19:41:00 2003
+@@ -19,6 +19,8 @@
  #include <asm/uaccess.h>
  
  #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
 +extern int path_walk_it(const char *name, struct nameidata *nd,
 +                      struct lookup_intent *it);
-+extern void intent_release(struct dentry *de, struct lookup_intent *it);
  
  int vfs_statfs(struct super_block *sb, struct statfs *buf)
  {
+@@ -95,9 +97,10 @@ void fd_install(unsigned int fd, struct 
+       write_unlock(&files->file_lock);
+ }
+-int do_truncate(struct dentry *dentry, loff_t length)
++int do_truncate(struct dentry *dentry, loff_t length, int called_from_open)
+ {
+       struct inode *inode = dentry->d_inode;
++      struct inode_operations *op = dentry->d_inode->i_op;
+       int error;
+       struct iattr newattrs;
+@@ -108,7 +111,14 @@ int do_truncate(struct dentry *dentry, l
+       down(&inode->i_sem);
+       newattrs.ia_size = length;
+       newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
+-      error = notify_change(dentry, &newattrs);
++      if (called_from_open)
++              newattrs.ia_valid |= ATTR_FROM_OPEN;
++      if (op->setattr_raw) {
++              newattrs.ia_valid |= ATTR_RAW;
++              newattrs.ia_ctime = CURRENT_TIME;
++              error = op->setattr_raw(inode, &newattrs);
++      } else 
++              error = notify_change(dentry, &newattrs);
+       up(&inode->i_sem);
+       return error;
+ }
 @@ -118,12 +121,13 @@ static inline long do_sys_truncate(const
        struct nameidata nd;
        struct inode * inode;
        int error;
-+      struct lookup_intent it = { .it_op = IT_TRUNC };
++      struct lookup_intent it = { .it_op = IT_GETATTR };
  
        error = -EINVAL;
        if (length < 0) /* sorry, but loff_t says... */
        if (error)
                goto out;
        inode = nd.dentry->d_inode;
-@@ -168,6 +172,7 @@ static inline long do_sys_truncate(const
+@@ -163,11 +167,13 @@ static inline long do_sys_truncate(const
+       error = locks_verify_truncate(inode, NULL, length);
+       if (!error) {
+               DQUOT_INIT(inode);
+-              error = do_truncate(nd.dentry, length);
++              intent_release(nd.dentry, &it);
++              error = do_truncate(nd.dentry, length, 0);
+       }
        put_write_access(inode);
  
  dput_and_out:
        path_release(&nd);
  out:
        return error;
-@@ -259,8 +264,9 @@ asmlinkage long sys_utime(char * filenam
-       struct nameidata nd;
+@@ -215,7 +228,7 @@ static inline long do_sys_ftruncate(unsi
+       error = locks_verify_truncate(inode, file, length);
+       if (!error)
+-              error = do_truncate(dentry, length);
++              error = do_truncate(dentry, length, 0);
+ out_putf:
+       fput(file);
+ out:
+@@ -260,11 +273,13 @@ asmlinkage long sys_utime(char * filenam
        struct inode * inode;
        struct iattr newattrs;
-+      struct lookup_intent it = { .it_op = IT_SETATTR };
  
 -      error = user_path_walk(filename, &nd);
-+      error = user_path_walk_it(filename, &nd, &it);
++      error = user_path_walk_it(filename, &nd, NULL);
        if (error)
                goto out;
        inode = nd.dentry->d_inode;
-@@ -286,6 +292,7 @@ asmlinkage long sys_utime(char * filenam
++      /* this is safe without a Lustre lock because it only depends
++         on the super block */
+       error = -EROFS;
+       if (IS_RDONLY(inode))
+               goto dput_and_out;
+@@ -279,11 +294,29 @@ asmlinkage long sys_utime(char * filenam
+                       goto dput_and_out;
+               newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
+-      } else {
++      }
++
++      if (inode->i_op->setattr_raw) {
++              struct inode_operations *op = nd.dentry->d_inode->i_op;
++
++              newattrs.ia_valid |= ATTR_RAW;
++              error = op->setattr_raw(inode, &newattrs);
++              /* the file system wants to use normal vfs path now */
++              if (error != -EOPNOTSUPP)
++                      goto dput_and_out;
++      }
++
++      error = -EROFS;
++      if (IS_RDONLY(inode))
++              goto dput_and_out;
++
++      error = -EPERM;
++      if (!times) {
+               if (current->fsuid != inode->i_uid &&
+                   (error = permission(inode,MAY_WRITE)) != 0)
+                       goto dput_and_out;
        }
++
        error = notify_change(nd.dentry, &newattrs);
  dput_and_out:
-+      intent_release(nd.dentry, &it);
        path_release(&nd);
- out:
-       return error;
-@@ -303,8 +310,9 @@ asmlinkage long sys_utimes(char * filena
-       struct nameidata nd;
+@@ -304,12 +337,14 @@ asmlinkage long sys_utimes(char * filena
        struct inode * inode;
        struct iattr newattrs;
-+      struct lookup_intent it = { .it_op = IT_SETATTR };
  
 -      error = user_path_walk(filename, &nd);
-+      error = user_path_walk_it(filename, &nd, &it);
++      error = user_path_walk_it(filename, &nd, NULL);
  
        if (error)
                goto out;
-@@ -331,6 +339,7 @@ asmlinkage long sys_utimes(char * filena
-       }
-       error = notify_change(nd.dentry, &newattrs);
- dput_and_out:
-+      intent_release(nd.dentry, &it);
-       path_release(&nd);
- out:
-       return error;
+       inode = nd.dentry->d_inode;
++      /* this is safe without a Lustre lock because it only depends
++         on the super block */
+       error = -EROFS;
+       if (IS_RDONLY(inode))
+               goto dput_and_out;
+@@ -324,7 +359,20 @@ asmlinkage long sys_utimes(char * filena
+               newattrs.ia_atime = times[0].tv_sec;
+               newattrs.ia_mtime = times[1].tv_sec;
+               newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
+-      } else {
++      }
++
++      if (inode->i_op->setattr_raw) {
++              struct inode_operations *op = nd.dentry->d_inode->i_op;
++
++              newattrs.ia_valid |= ATTR_RAW;
++              error = op->setattr_raw(inode, &newattrs);
++              /* the file system wants to use normal vfs path now */
++              if (error != -EOPNOTSUPP)
++                      goto dput_and_out;
++      }
++
++      error = -EPERM;
++      if (!utimes) {
+               if (current->fsuid != inode->i_uid &&
+                   (error = permission(inode,MAY_WRITE)) != 0)
+                       goto dput_and_out;
 @@ -347,6 +356,7 @@ asmlinkage long sys_access(const char * 
        int old_fsuid, old_fsgid;
        kernel_cap_t old_cap;
        path_release(&nd);
  out:
        return error;
-@@ -515,8 +530,9 @@ asmlinkage long sys_chmod(const char * f
-       struct inode * inode;
-       int error;
-       struct iattr newattrs;
-+      struct lookup_intent it = { .it_op = IT_SETATTR };
+@@ -508,6 +564,18 @@ asmlinkage long sys_chmod(const char * f
+       if (IS_RDONLY(inode))
+               goto dput_and_out;
  
--      error = user_path_walk(filename, &nd);
-+      error = user_path_walk_it(filename, &nd, &it);
-       if (error)
++      if (inode->i_op->setattr_raw) {
++              struct inode_operations *op = nd.dentry->d_inode->i_op;
++
++              newattrs.ia_mode = mode;
++              newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
++              newattrs.ia_valid |= ATTR_RAW;
++              error = op->setattr_raw(inode, &newattrs);
++              /* the file system wants to use normal vfs path now */
++              if (error != -EOPNOTSUPP)
++                      goto dput_and_out;
++      }
++
+       error = -EPERM;
+       if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
+               goto dput_and_out;
+@@ -538,6 +606,20 @@ static int chown_common(struct dentry * 
+       error = -EROFS;
+       if (IS_RDONLY(inode))
+               goto out;
++
++      if (inode->i_op->setattr_raw) {
++              struct inode_operations *op = dentry->d_inode->i_op;
++
++              newattrs.ia_uid = user;
++              newattrs.ia_gid = group;
++              newattrs.ia_valid = ATTR_UID | ATTR_GID;
++              newattrs.ia_valid |= ATTR_RAW;
++              error = op->setattr_raw(inode, &newattrs);
++              /* the file system wants to use normal vfs path now */
++              if (error != -EOPNOTSUPP)
++                      return error;
++      }
++
+       error = -EPERM;
+       if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
                goto out;
-       inode = nd.dentry->d_inode;
-@@ -536,6 +552,7 @@ asmlinkage long sys_chmod(const char * f
-       error = notify_change(nd.dentry, &newattrs);
- dput_and_out:
-+      intent_release(nd.dentry, &it);
-       path_release(&nd);
- out:
-       return error;
-@@ -605,10 +622,12 @@ asmlinkage long sys_chown(const char * f
- {
-       struct nameidata nd;
-       int error;
-+      struct lookup_intent it = { .it_op = IT_SETATTR };
--      error = user_path_walk(filename, &nd);
-+      error = user_path_walk_it(filename, &nd, &it);
-       if (!error) {
-               error = chown_common(nd.dentry, user, group);
-+              intent_release(nd.dentry, &it);
-               path_release(&nd);
-       }
-       return error;
-@@ -618,10 +637,12 @@ asmlinkage long sys_lchown(const char * 
- {
-       struct nameidata nd;
-       int error;
-+      struct lookup_intent it = { .it_op = IT_SETATTR };
--      error = user_path_walk_link(filename, &nd);
-+      error = user_path_walk_link_it(filename, &nd, &it);
-       if (!error) {
-               error = chown_common(nd.dentry, user, group);
-+              intent_release(nd.dentry, &it);
-               path_release(&nd);
-       }
-       return error;
 @@ -655,10 +676,16 @@ asmlinkage long sys_fchown(unsigned int 
   * for the internal routines (ie open_namei()/follow_link() etc). 00 is
   * used by symlinks.
  /*
   * Find an empty file descriptor entry, and mark it busy.
   */
---- linux-2.4.19-hp2_pnnl2/fs/stat.c~vfs_intent_hp     Sun Jan 19 19:04:47 2003
-+++ linux-2.4.19-hp2_pnnl2-root/fs/stat.c      Sun Jan 19 19:44:51 2003
-@@ -13,6 +13,7 @@
- #include <asm/uaccess.h>
-+extern void intent_release(struct dentry *de, struct lookup_intent *it);
- /*
-  * Revalidate the inode. This is required for proper NFS attribute caching.
-  */
+--- linux-2.4.19-hp2_pnnl4/fs/stat.c~vfs_intent_hp     Sun Jan 19 19:04:47 2003
++++ linux-2.4.19-hp2_pnnl4-root/fs/stat.c      Sun Jan 19 19:44:51 2003
 @@ -135,13 +136,15 @@ static int cp_new_stat(struct inode * in
  asmlinkage long sys_stat(char * filename, struct __old_kernel_stat * statbuf)
  {
                path_release(&nd);
        }
        return error;
-@@ -247,11 +256,12 @@ asmlinkage long sys_readlink(const char 
- {
-       struct nameidata nd;
-       int error;
-+      struct lookup_intent it = { .it_op = IT_READLINK };
-       if (bufsiz <= 0)
-               return -EINVAL;
--      error = user_path_walk_link(path, &nd);
-+      error = user_path_walk_link_it(path, &nd, &it);
-       if (!error) {
-               struct inode * inode = nd.dentry->d_inode;
-@@ -261,6 +271,7 @@ asmlinkage long sys_readlink(const char 
-                       UPDATE_ATIME(inode);
-                       error = inode->i_op->readlink(nd.dentry, buf, bufsiz);
-               }
-+              intent_release(nd.dentry, &it);
-               path_release(&nd);
-       }
-       return error;
 @@ -333,12 +344,14 @@ asmlinkage long sys_stat64(char * filena
  {
        struct nameidata nd;
                path_release(&nd);
        }
        return error;
---- linux-2.4.19-hp2_pnnl2/include/linux/dcache.h~vfs_intent_hp        Sun Jan 19 19:04:47 2003
-+++ linux-2.4.19-hp2_pnnl2-root/include/linux/dcache.h Sun Jan 19 19:04:48 2003
-@@ -6,6 +6,27 @@
+--- linux-2.4.19-hp2_pnnl4/fs/exec.c~vfs_intent_hp     Sun Feb  9 01:14:52 2003
++++ linux-2.4.19-hp2_pnnl4-root/fs/exec.c      Sun Feb  9 01:29:49 2003
+@@ -103,13 +104,18 @@ static inline void put_binfmt(struct lin
+  *
+  * Also note that we take the address to load from from the file itself.
+  */
++extern struct file *dentry_open_it(struct dentry *dentry, struct vfsmount *mnt,
++                          int flags, struct lookup_intent *it);
++int path_lookup_it(const char *path, unsigned flags, struct nameidata *nd,
++                 struct lookup_intent *it);
+ asmlinkage long sys_uselib(const char * library)
+ {
+       struct file * file;
+       struct nameidata nd;
+       int error;
++      struct lookup_intent it = { .it_op = IT_OPEN, .it_flags = O_RDONLY };
+-      error = user_path_walk(library, &nd);
++      error = user_path_walk_it(library, &nd, &it);
+       if (error)
+               goto out;
+@@ -121,7 +127,8 @@ asmlinkage long sys_uselib(const char * 
+       if (error)
+               goto exit;
+-      file = dentry_open(nd.dentry, nd.mnt, O_RDONLY);
++      file = dentry_open_it(nd.dentry, nd.mnt, O_RDONLY, &it);
++      intent_release(nd.dentry, &it);
+       error = PTR_ERR(file);
+       if (IS_ERR(file))
+               goto out;
+@@ -350,9 +350,10 @@ struct file *open_exec(const char *name)
+       struct inode *inode;
+       struct file *file;
+       int err = 0;
++      struct lookup_intent it = { .it_op = IT_OPEN, .it_flags = O_RDONLY };
+       if (path_init(name, LOOKUP_FOLLOW|LOOKUP_POSITIVE, &nd))
+-              err = path_walk(name, &nd);
++              err = path_walk_it(name, &nd, &it);
+       file = ERR_PTR(err);
+       if (!err) {
+               inode = nd.dentry->d_inode;
+@@ -363,7 +369,8 @@ struct file *open_exec(const char *name)
+                               err = -EACCES;
+                       file = ERR_PTR(err);
+                       if (!err) {
+-                              file = dentry_open(nd.dentry, nd.mnt, O_RDONLY);
++                              file = dentry_open_it(nd.dentry, nd.mnt, O_RDONLY, &it);
++                              intent_release(nd.dentry, &it);
+                               if (!IS_ERR(file)) {
+                                       err = deny_write_access(file);
+                                       if (err) {
+@@ -976,7 +986,7 @@ int do_coredump(long signr, struct pt_re
+               goto close_fail;
+       if (!file->f_op->write)
+               goto close_fail;
+-      if (do_truncate(file->f_dentry, 0) != 0)
++      if (do_truncate(file->f_dentry, 0, 0) != 0)
+               goto close_fail;
+       retval = binfmt->core_dump(signr, regs, file);
+--- linux-2.4.19-hp2_pnnl4/include/linux/dcache.h~vfs_intent_hp        Sun Jan 19 19:04:47 2003
++++ linux-2.4.19-hp2_pnnl4-root/include/linux/dcache.h Sun Jan 19 19:04:48 2003
+@@ -6,6 +6,25 @@
  #include <asm/atomic.h>
  #include <linux/mount.h>
  
 +#define IT_CREAT    (1<<1)
 +#define IT_READDIR  (1<<2)
 +#define IT_GETATTR  (1<<3)
-+#define IT_SETATTR  (1<<4)
-+#define IT_TRUNC    (1<<5)
-+#define IT_READLINK (1<<6)
-+#define IT_LOOKUP   (1<<7)
++#define IT_LOOKUP   (1<<4)
++#define IT_UNLINK   (1<<5)
 +
 +struct lookup_intent {
 +      int it_op;
        unsigned long d_vfs_flags;
        void * d_fsdata;                /* fs-specific data */
        unsigned char d_iname[DNAME_INLINE_LEN]; /* small names */
-@@ -90,6 +119,8 @@ struct dentry_operations {
+@@ -90,8 +119,15 @@ struct dentry_operations {
        int (*d_delete)(struct dentry *);
        void (*d_release)(struct dentry *);
        void (*d_iput)(struct dentry *, struct inode *);
 +      void (*d_intent_release)(struct dentry *, struct lookup_intent *);
  };
  
++/* defined in fs/namei.c */
++extern void intent_release(struct dentry *de, struct lookup_intent *it);
++/* defined in fs/dcache.c */
++extern void __d_rehash(struct dentry * entry, int lock);
++
  /* the dentry parameter passed to d_hash and d_compare is the parent
-@@ -124,6 +148,7 @@ d_iput:            no              no              yes
+  * directory of the entries to be compared. It is used in case these
+  * functions need any directory specific information for determining
+@@ -124,6 +149,7 @@ d_iput:            no              no              yes
                                         * s_nfsd_free_path semaphore will be down
                                         */
  #define DCACHE_REFERENCED     0x0008  /* Recently used, don't discard. */
  
  extern spinlock_t dcache_lock;
  
---- linux-2.4.19-hp2_pnnl2/include/linux/fs.h~vfs_intent_hp    Sun Jan 19 19:04:47 2003
-+++ linux-2.4.19-hp2_pnnl2-root/include/linux/fs.h     Sun Jan 19 19:04:48 2003
+--- linux-2.4.19-hp2_pnnl4/include/linux/fs.h~vfs_intent_hp    Sun Jan 19 19:04:47 2003
++++ linux-2.4.19-hp2_pnnl4-root/include/linux/fs.h     Sun Jan 19 19:04:48 2003
+@@ -338,6 +338,8 @@ extern void set_bh_page(struct buffer_he
+ #define ATTR_MTIME_SET        256
+ #define ATTR_FORCE    512     /* Not a change, but a change it */
+ #define ATTR_ATTR_FLAG        1024
++#define ATTR_RAW      2048    /* file system, not vfs will massage attrs */
++#define ATTR_FROM_OPEN        4096    /* called from open path, ie O_TRUNC */
+ /*
+  * This is the Inode Attributes structure, used for notify_change().  It
 @@ -575,6 +575,7 @@ struct file {
  
        /* needed for tty driver, and maybe others */
  
  /*
   * File types
-@@ -876,16 +879,28 @@ struct file_operations {
+@@ -876,20 +879,33 @@ struct file_operations {
  struct inode_operations {
        int (*create) (struct inode *,struct dentry *,int);
        struct dentry * (*lookup) (struct inode *,struct dentry *);
        void (*truncate) (struct inode *);
        int (*permission) (struct inode *, int);
        int (*revalidate) (struct dentry *);
+       int (*setattr) (struct dentry *, struct iattr *);
++      int (*setattr_raw) (struct inode *, struct iattr *);
+       int (*getattr) (struct dentry *, struct iattr *);
+       int (*setxattr) (struct dentry *, const char *, void *, size_t, int);
+       ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
+@@ -1112,7 +1130,7 @@ static inline int get_lease(struct inode
+ asmlinkage long sys_open(const char *, int, int);
+ asmlinkage long sys_close(unsigned int);      /* yes, it's really unsigned */
+-extern int do_truncate(struct dentry *, loff_t start);
++extern int do_truncate(struct dentry *, loff_t start, int called_from_open);
+ extern struct file *filp_open(const char *, int, int);
+ extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
 @@ -1354,6 +1369,7 @@ typedef int (*read_actor_t)(read_descrip
  extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
  
  extern int page_readlink(struct dentry *, char *, int);
  extern int page_follow_link(struct dentry *, struct nameidata *);
  extern struct inode_operations page_symlink_inode_operations;
---- linux-2.4.19-hp2_pnnl2/kernel/ksyms.c~vfs_intent_hp        Sun Jan 19 19:04:47 2003
-+++ linux-2.4.19-hp2_pnnl2-root/kernel/ksyms.c Sun Jan 19 19:04:48 2003
+--- linux-2.4.19-hp2_pnnl4/kernel/ksyms.c~vfs_intent_hp        Sun Jan 19 19:04:47 2003
++++ linux-2.4.19-hp2_pnnl4-root/kernel/ksyms.c Sun Jan 19 19:04:48 2003
 @@ -293,6 +293,7 @@ EXPORT_SYMBOL(read_cache_page);
  EXPORT_SYMBOL(set_page_dirty);
  EXPORT_SYMBOL(vfs_readlink);
  EXPORT_SYMBOL(page_readlink);
  EXPORT_SYMBOL(page_follow_link);
  EXPORT_SYMBOL(page_symlink_inode_operations);
-
-_
diff --git a/lustre/kernel_patches/pc/lustre-2.5.pc b/lustre/kernel_patches/pc/lustre-2.5.pc
new file mode 100644 (file)
index 0000000..71434ea
--- /dev/null
@@ -0,0 +1,11 @@
+arch/um/kernel/mem.c
+fs/namei.c
+fs/nfsd/vfs.c
+fs/sysfs/inode.c
+include/linux/dcache.h
+include/linux/fs.h
+include/linux/namei.h
+include/linux/slab.h
+kernel/ksyms.c
+mm/slab.c
+net/unix/af_unix.c
index 881576c..dd2b1c8 100644 (file)
@@ -3,6 +3,7 @@ fs/namei.c
 fs/nfsd/vfs.c
 fs/open.c
 fs/stat.c
+fs/exec.c
 include/linux/dcache.h
 include/linux/fs.h
 kernel/ksyms.c
diff --git a/lustre/kernel_patches/series/vanilla-2.5 b/lustre/kernel_patches/series/vanilla-2.5
new file mode 100644 (file)
index 0000000..3269420
--- /dev/null
@@ -0,0 +1,2 @@
+lustre_version.patch
+lustre-2.5.patch
index 4a5e662..b7af3d9 100644 (file)
@@ -6,3 +6,5 @@ series/hp-pnnl              ** Note: functionally equivalent to 2.4.19
    linux-2.4.18-hp2_pnnl2
 series/vanilla-2.4.19       ** Not officially supported
    linux-2.4.19
+series/lin-2.5.44
+   uml-2.5.44
index a76ff4a..d0c4199 100644 (file)
@@ -4,12 +4,21 @@
 # See the file COPYING in this distribution
 
 DEFS= 
+
+LDLMSOURCES= l_lock.c ldlm_lock.c ldlm_resource.c  \
+ldlm_extent.c ldlm_request.c ldlm_lockd.c
+
+if LIBLUSTRE
+lib_LIBRARIES = libldlm.a
+libldlm_a_SOURCES = $(LDLMSOURCES)
+else
 MODULE = ldlm
 modulefs_DATA = ldlm.o
 EXTRA_PROGRAMS = ldlm
 
-ldlm_SOURCES = l_lock.c ldlm_lock.c ldlm_resource.c ldlm_lockd.c \
-ldlm_extent.c ldlm_request.c
+ldlm_SOURCES = $(LDLMSOURCES)
+endif
 
 include $(top_srcdir)/Rules
 
+
index e8ffd5b..c439eed 100644 (file)
@@ -20,6 +20,8 @@
  *
  */
 
+#define DEBUG_SUBSYSTEM S_LDLM
+#ifdef __KERNEL__
 #include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/mm.h>
 #include <linux/pagemap.h>
 #include <linux/smp_lock.h>
+#else 
+#include <liblustre.h>
+#endif
 
-#define DEBUG_SUBSYSTEM S_LDLM
-
+#include <linux/lustre_dlm.h>
 #include <linux/obd_class.h>
 #include <linux/lustre_lib.h>
 
index 5a84909..9b10854 100644 (file)
@@ -1,19 +1,34 @@
 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
  * vim:expandtab:shiftwidth=8:tabstop=8:
  *
- * Copyright (C) 2002 Cluster File Systems, Inc.
+ *  Copyright (c) 2002 Cluster File Systems, Inc.
+ *   Author: Peter Braam <braam@clusterfs.com>
+ *   Author: Phil Schwan <phil@clusterfs.com>
  *
- * This code is issued under the GNU General Public License.
- * See the file COPYING in this distribution
+ *   This file is part of Lustre, http://www.lustre.org.
  *
- * by Cluster File Systems, Inc.
- * authors, Peter Braam <braam@clusterfs.com> & 
- *          Phil Schwan <phil@clusterfs.com>
+ *   Lustre 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.
+ *
+ *   Lustre is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with Lustre; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #define DEBUG_SUBSYSTEM S_LDLM
+#ifndef __KERNEL__
+# include <liblustre.h>
+#endif
 
 #include <linux/lustre_dlm.h>
+#include <linux/obd_support.h>
+#include <linux/lustre_lib.h>
 
 /* This function will be called to judge if the granted queue of another child
  * (read: another extent) is conflicting and needs its granted queue walked to
@@ -47,17 +62,17 @@ static void policy_internal(struct list_head *queue, struct ldlm_extent *req_ex,
                 struct ldlm_lock *lock;
                 lock = list_entry(tmp, struct ldlm_lock, l_res_link);
 
-                if (lock->l_extent.end < req_ex->start)
+                if (lock->l_extent.end < req_ex->start) {
                         new_ex->start = MIN(lock->l_extent.end, new_ex->start);
-                else {
+                else {
                         if (lock->l_extent.start < req_ex->start &&
                             !lockmode_compat(lock->l_req_mode, mode))
                                 /* Policy: minimize conflict overlap */
                                 new_ex->start = req_ex->start;
                 }
-                if (lock->l_extent.start > req_ex->end)
+                if (lock->l_extent.start > req_ex->end) {
                         new_ex->end = MAX(lock->l_extent.start, new_ex->end);
-                else {
+                else {
                         if (lock->l_extent.end > req_ex->end &&
                             !lockmode_compat(lock->l_req_mode, mode))
                                 /* Policy: minimize conflict overlap */
index e08ddb4..81cc428 100644 (file)
 
 #define DEBUG_SUBSYSTEM S_LDLM
 
+#ifdef __KERNEL__
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/lustre_dlm.h>
 #include <linux/lustre_mds.h>
+#else
+#include <liblustre.h>
+#include <linux/kp30.h>
+#endif
+
 #include <linux/obd_class.h>
 
 //struct lustre_lock ldlm_everything_lock;
@@ -46,6 +52,7 @@ char *ldlm_typename[] = {
         [LDLM_EXTENT] "EXT",
 };
 
+#ifdef __KERNEL__
 char *ldlm_it2str(int it)
 {
         switch (it) {
@@ -59,10 +66,6 @@ char *ldlm_it2str(int it)
                 return "readdir";
         case IT_GETATTR:
                 return "getattr";
-        case IT_TRUNC:
-                return "truncate";
-        case IT_SETATTR:
-                return "setattr";
         case IT_LOOKUP:
                 return "lookup";
         case IT_UNLINK:
@@ -72,13 +75,14 @@ char *ldlm_it2str(int it)
                 return "UNKNOWN";
         }
 }
+#endif
 
 extern kmem_cache_t *ldlm_lock_slab;
 struct lustre_lock ldlm_handle_lock;
 
 static int ldlm_plain_compat(struct ldlm_lock *a, struct ldlm_lock *b);
 
-ldlm_res_compat ldlm_res_compat_table[] = {
+static ldlm_res_compat ldlm_res_compat_table[] = {
         [LDLM_PLAIN] ldlm_plain_compat,
         [LDLM_EXTENT] ldlm_extent_compat,
 };
@@ -97,7 +101,7 @@ static int ldlm_plain_policy(struct ldlm_namespace *ns, struct ldlm_lock **lock,
         return ELDLM_OK;
 }
 
-ldlm_res_policy ldlm_res_policy_table[] = {
+static ldlm_res_policy ldlm_res_policy_table[] = {
         [LDLM_PLAIN] ldlm_plain_policy,
         [LDLM_EXTENT] ldlm_extent_policy,
 };
@@ -136,7 +140,7 @@ void ldlm_lock_put(struct ldlm_lock *lock)
 
         if (atomic_dec_and_test(&lock->l_refc)) {
                 l_lock(&ns->ns_lock);
-                LDLM_DEBUG0(lock, "final lock_put on destroyed lock, freeing");
+                LDLM_DEBUG(lock, "final lock_put on destroyed lock, freeing");
                 LASSERT(lock->l_destroyed);
                 LASSERT(list_empty(&lock->l_res_link));
 
@@ -207,7 +211,7 @@ void ldlm_lock_destroy(struct ldlm_lock *lock)
 
         list_del_init(&lock->l_export_chain);
         ldlm_lock_remove_from_lru(lock);
-        portals_handle_unhash(&lock->l_handle);
+        class_handle_unhash(&lock->l_handle);
 
 #if 0
         /* Wake anyone waiting for this lock */
@@ -270,7 +274,7 @@ static struct ldlm_lock *ldlm_lock_new(struct ldlm_lock *parent,
         }
 
         INIT_LIST_HEAD(&lock->l_handle.h_link);
-        portals_handle_hash(&lock->l_handle, lock_handle_addref);
+        class_handle_hash(&lock->l_handle, lock_handle_addref);
 
         RETURN(lock);
 }
@@ -314,7 +318,7 @@ int ldlm_lock_change_resource(struct ldlm_namespace *ns, struct ldlm_lock *lock,
 
 void ldlm_lock2handle(struct ldlm_lock *lock, struct lustre_handle *lockh)
 {
-        memset(&lockh->addr, 0x69, sizeof(lockh->addr));
+        POISON(&lockh->addr, 0x69, sizeof(lockh->addr));
         lockh->cookie = lock->l_handle.h_cookie;
 }
 
@@ -329,7 +333,7 @@ struct ldlm_lock *__ldlm_handle2lock(struct lustre_handle *handle, int flags)
 
         LASSERT(handle);
 
-        lock = portals_handle2object(handle->cookie);
+        lock = class_handle2object(handle->cookie);
         if (lock == NULL)
                 RETURN(NULL);
 
@@ -388,7 +392,7 @@ void ldlm_lock2desc(struct ldlm_lock *lock, struct ldlm_lock_desc *desc)
 }
 
 static void ldlm_add_ast_work_item(struct ldlm_lock *lock,
-                                   struct ldlm_lock *new, 
+                                   struct ldlm_lock *new,
                                    void *data, int datalen)
 {
         struct ldlm_ast_work *w;
@@ -479,12 +483,18 @@ void ldlm_lock_decref_internal(struct ldlm_lock *lock, __u32 mode)
                         CERROR("FL_CBPENDING set on non-local lock--just a "
                                "warning\n");
 
-                LDLM_DEBUG0(lock, "final decref done on cbpending lock");
+                LDLM_DEBUG(lock, "final decref done on cbpending lock");
+
+                if (lock->l_blocking_ast == NULL) {
+                        /* The lock wasn't even fully formed; just destroy it */
+                        ldlm_lock_destroy(lock);
+                }
                 l_unlock(&ns->ns_lock);
 
                 /* FIXME: need a real 'desc' here */
-                lock->l_blocking_ast(lock, NULL, lock->l_data,
-                                     LDLM_CB_BLOCKING);
+                if (lock->l_blocking_ast != NULL)
+                        lock->l_blocking_ast(lock, NULL, lock->l_data,
+                                             LDLM_CB_BLOCKING);
         } else if (ns->ns_client && !lock->l_readers && !lock->l_writers) {
                 /* If this is a client-side namespace and this was the last
                  * reference, put it on the LRU. */
@@ -710,7 +720,7 @@ int ldlm_lock_match(struct ldlm_namespace *ns, int flags,
                         lock->l_completion_ast(lock, LDLM_FL_WAIT_NOREPROC, NULL);
         }
         if (rc)
-                LDLM_DEBUG0(lock, "matched");
+                LDLM_DEBUG(lock, "matched");
         else
                 LDLM_DEBUG_NOLOCK("not matched");
 
@@ -866,10 +876,10 @@ ldlm_error_t ldlm_lock_enqueue(struct ldlm_namespace *ns,
         ldlm_grant_lock(lock, NULL, 0);
         EXIT;
       out:
-        l_unlock(&ns->ns_lock);
         /* Don't set 'completion_ast' until here so that if the lock is granted
          * immediately we don't do an unnecessary completion call. */
         lock->l_completion_ast = completion;
+        l_unlock(&ns->ns_lock);
         return ELDLM_OK;
 }
 
@@ -906,13 +916,27 @@ int ldlm_run_ast_work(struct list_head *rpc_list)
                 struct ldlm_ast_work *w =
                         list_entry(tmp, struct ldlm_ast_work, w_list);
 
-                if (w->w_blocking)
+                /* It's possible to receive a completion AST before we've set
+                 * the l_completion_ast pointer: either because the AST arrived
+                 * before the reply, or simply because there's a small race
+                 * window between receiving the reply and finishing the local
+                 * enqueue. (bug 842)
+                 *
+                 * This can't happen with the blocking_ast, however, because we
+                 * will never call the local blocking_ast until we drop our
+                 * reader/writer reference, which we won't do until we get the
+                 * reply and finish enqueueing. */
+                if (w->w_blocking) {
+                        LASSERT(w->w_lock->l_blocking_ast != NULL);
                         rc = w->w_lock->l_blocking_ast
                                 (w->w_lock, &w->w_desc, w->w_data,
                                  LDLM_CB_BLOCKING);
-                else
+                } else if (w->w_lock->l_completion_ast != NULL) {
                         rc = w->w_lock->l_completion_ast(w->w_lock, w->w_flags,
                                                          w->w_data);
+                } else {
+                        rc = 0;
+                }
                 if (rc == -ERESTART)
                         retval = rc;
                 else if (rc)
@@ -974,7 +998,7 @@ void ldlm_cancel_callback(struct ldlm_lock *lock)
                         lock->l_blocking_ast(lock, NULL, lock->l_data,
                                              LDLM_CB_CANCELING);
                 else
-                        LDLM_DEBUG0(lock, "no blocking ast");
+                        LDLM_DEBUG(lock, "no blocking ast");
         }
         l_unlock(&lock->l_resource->lr_namespace->ns_lock);
 }
@@ -994,7 +1018,7 @@ void ldlm_lock_cancel(struct ldlm_lock *lock)
         /* Please do not, no matter how tempting, remove this LBUG without
          * talking to me first. -phik */
         if (lock->l_readers || lock->l_writers) {
-                LDLM_DEBUG0(lock, "lock still has references");
+                LDLM_DEBUG(lock, "lock still has references");
                 ldlm_lock_dump(D_OTHER, lock);
                 LBUG();
         }
@@ -1113,8 +1137,9 @@ void ldlm_lock_dump(int level, struct ldlm_lock *lock)
         CDEBUG(level, "  -- Lock dump: %p (%s) (rc: %d)\n", lock, ver,
                atomic_read(&lock->l_refc));
         if (lock->l_export && lock->l_export->exp_connection)
-                CDEBUG(level, "  Node: NID %x (rhandle: "LPX64")\n",
+                CDEBUG(level, "  Node: NID "LPX64" on %s (rhandle: "LPX64")\n",
                        lock->l_export->exp_connection->c_peer.peer_nid,
+                       lock->l_export->exp_connection->c_peer.peer_ni->pni_name,
                        lock->l_remote_handle.cookie);
         else
                 CDEBUG(level, "  Node: local\n");
index 61bb91e..c1d3182 100644 (file)
 #define EXPORT_SYMTAB
 #define DEBUG_SUBSYSTEM S_LDLM
 
+#ifdef __KERNEL__
 #include <linux/module.h>
 #include <linux/slab.h>
-#include <linux/lustre_dlm.h>
 #include <linux/init.h>
+#else 
+#include <liblustre.h>
+#endif
+
+#include <linux/lustre_dlm.h>
 #include <linux/obd_class.h>
 
+
 extern kmem_cache_t *ldlm_resource_slab;
 extern kmem_cache_t *ldlm_lock_slab;
 extern struct lustre_lock ldlm_handle_lock;
@@ -130,6 +136,12 @@ int ldlm_del_waiting_lock(struct ldlm_lock *lock)
         RETURN(1);
 }
 
+static inline void ldlm_failed_ast(struct ldlm_lock *lock)
+{
+        /* XXX diagnostic */
+        recovd_conn_fail(lock->l_export->exp_connection);
+}
+
 int ldlm_server_blocking_ast(struct ldlm_lock *lock,
                              struct ldlm_lock_desc *desc,
                              void *data, int flag)
@@ -170,7 +182,7 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock,
                sizeof(body->lock_handle1));
         memcpy(&body->lock_desc, desc, sizeof(*desc));
 
-        LDLM_DEBUG0(lock, "server preparing blocking AST");
+        LDLM_DEBUG(lock, "server preparing blocking AST");
         req->rq_replen = lustre_msg_size(0, NULL);
 
         ldlm_add_waiting_lock(lock);
@@ -180,7 +192,7 @@ int ldlm_server_blocking_ast(struct ldlm_lock *lock,
         rc = ptlrpc_queue_wait(req);
         if (rc == -ETIMEDOUT || rc == -EINTR) {
                 ldlm_del_waiting_lock(lock);
-                ldlm_expired_completion_wait(lock);
+                ldlm_failed_ast(lock);
         } else if (rc) {
                 CERROR("client returned %d from blocking AST for lock %p\n",
                        req->rq_status, lock);
@@ -220,14 +232,14 @@ int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data)
         body->lock_flags = flags;
         ldlm_lock2desc(lock, &body->lock_desc);
 
-        LDLM_DEBUG0(lock, "server preparing completion AST");
+        LDLM_DEBUG(lock, "server preparing completion AST");
         req->rq_replen = lustre_msg_size(0, NULL);
 
         req->rq_level = LUSTRE_CONN_RECOVD;
         rc = ptlrpc_queue_wait(req);
         if (rc == -ETIMEDOUT || rc == -EINTR) {
                 ldlm_del_waiting_lock(lock);
-                ldlm_expired_completion_wait(lock);
+                ldlm_failed_ast(lock);
         } else if (rc) {
                 CERROR("client returned %d from completion AST for lock %p\n",
                        req->rq_status, lock);
@@ -291,7 +303,7 @@ int ldlm_handle_enqueue(struct ptlrpc_request *req,
 
         memcpy(&lock->l_remote_handle, &dlm_req->lock_handle1,
                sizeof(lock->l_remote_handle));
-        LDLM_DEBUG0(lock, "server-side enqueue handler, new lock created");
+        LDLM_DEBUG(lock, "server-side enqueue handler, new lock created");
 
         LASSERT(req->rq_export);
         lock->l_export = req->rq_export;
@@ -358,7 +370,7 @@ int ldlm_handle_convert(struct ptlrpc_request *req)
         if (!lock) {
                 req->rq_status = EINVAL;
         } else {
-                LDLM_DEBUG0(lock, "server-side convert handler START");
+                LDLM_DEBUG(lock, "server-side convert handler START");
                 ldlm_lock_convert(lock, dlm_req->lock_desc.l_req_mode,
                                   &dlm_rep->lock_flags);
                 if (ldlm_del_waiting_lock(lock))
@@ -368,7 +380,7 @@ int ldlm_handle_convert(struct ptlrpc_request *req)
 
         if (lock) {
                 ldlm_reprocess_all(lock->l_resource);
-                LDLM_DEBUG0(lock, "server-side convert handler END");
+                LDLM_DEBUG(lock, "server-side convert handler END");
                 LDLM_LOCK_PUT(lock);
         } else
                 LDLM_DEBUG_NOLOCK("server-side convert handler END");
@@ -403,7 +415,7 @@ int ldlm_handle_cancel(struct ptlrpc_request *req)
                                   dlm_req->lock_handle1.cookie);
                 req->rq_status = ESTALE;
         } else {
-                LDLM_DEBUG0(lock, "server-side cancel handler START");
+                LDLM_DEBUG(lock, "server-side cancel handler START");
                 ldlm_lock_cancel(lock);
                 if (ldlm_del_waiting_lock(lock))
                         CDEBUG(D_DLMTRACE, "cancelled waiting lock %p\n", lock);
@@ -415,7 +427,7 @@ int ldlm_handle_cancel(struct ptlrpc_request *req)
 
         if (lock) {
                 ldlm_reprocess_all(lock->l_resource);
-                LDLM_DEBUG0(lock, "server-side cancel handler END");
+                LDLM_DEBUG(lock, "server-side cancel handler END");
                 LDLM_LOCK_PUT(lock);
         }
 
@@ -439,30 +451,30 @@ static int ldlm_handle_bl_callback(struct ptlrpc_request *req,
 
         lock = ldlm_handle2lock_ns(ns, &dlm_req->lock_handle1);
         if (!lock) {
-                CERROR("blocking callback on lock "LPX64" - lock disappeared\n",
-                       dlm_req->lock_handle1.cookie);
+                CDEBUG(D_INFO, "blocking callback on lock "LPX64
+                       " - lock disappeared\n", dlm_req->lock_handle1.cookie);
                 RETURN(-EINVAL);
         }
 
-        LDLM_DEBUG0(lock, "client blocking AST callback handler START");
+        LDLM_DEBUG(lock, "client blocking AST callback handler START");
 
-        l_lock(&lock->l_resource->lr_namespace->ns_lock);
+        l_lock(&ns->ns_lock);
         lock->l_flags |= LDLM_FL_CBPENDING;
         do_ast = (!lock->l_readers && !lock->l_writers);
-        l_unlock(&lock->l_resource->lr_namespace->ns_lock);
+        l_unlock(&ns->ns_lock);
 
         if (do_ast) {
                 LDLM_DEBUG(lock, "already unused, calling "
                            "callback (%p)", lock->l_blocking_ast);
-                if (lock->l_blocking_ast != NULL) {
+                if (lock->l_blocking_ast != NULL)
                         lock->l_blocking_ast(lock, &dlm_req->lock_desc,
                                              lock->l_data, LDLM_CB_BLOCKING);
-                }
-        } else
-                LDLM_DEBUG0(lock, "Lock still has references, will be"
-                            " cancelled later");
+        } else {
+                LDLM_DEBUG(lock, "Lock still has references, will be"
+                           " cancelled later");
+        }
 
-        LDLM_DEBUG0(lock, "client blocking callback handler END");
+        LDLM_DEBUG(lock, "client blocking callback handler END");
         LDLM_LOCK_PUT(lock);
         RETURN(0);
 }
@@ -486,7 +498,7 @@ static int ldlm_handle_cp_callback(struct ptlrpc_request *req,
                 RETURN(-EINVAL);
         }
 
-        LDLM_DEBUG0(lock, "client completion callback handler START");
+        LDLM_DEBUG(lock, "client completion callback handler START");
 
         l_lock(&ns->ns_lock);
 
@@ -494,7 +506,7 @@ static int ldlm_handle_cp_callback(struct ptlrpc_request *req,
          * then we might need to switch lock modes, resources, or extents. */
         if (dlm_req->lock_desc.l_granted_mode != lock->l_req_mode) {
                 lock->l_req_mode = dlm_req->lock_desc.l_granted_mode;
-                LDLM_DEBUG0(lock, "completion AST, new lock mode");
+                LDLM_DEBUG(lock, "completion AST, new lock mode");
         }
         if (lock->l_resource->lr_type == LDLM_EXTENT)
                 memcpy(&lock->l_extent, &dlm_req->lock_desc.l_extent,
@@ -505,13 +517,13 @@ static int ldlm_handle_cp_callback(struct ptlrpc_request *req,
                    sizeof(lock->l_resource->lr_name)) != 0) {
                 ldlm_lock_change_resource(ns, lock,
                                          dlm_req->lock_desc.l_resource.lr_name);
-                LDLM_DEBUG0(lock, "completion AST, new resource");
+                LDLM_DEBUG(lock, "completion AST, new resource");
         }
         lock->l_resource->lr_tmp = &ast_list;
         ldlm_grant_lock(lock, req, sizeof(*req));
         lock->l_resource->lr_tmp = NULL;
         l_unlock(&ns->ns_lock);
-        LDLM_DEBUG0(lock, "callback handler finished, about to run_ast_work");
+        LDLM_DEBUG(lock, "callback handler finished, about to run_ast_work");
         LDLM_LOCK_PUT(lock);
 
         ldlm_run_ast_work(&ast_list);
@@ -544,7 +556,8 @@ static int ldlm_callback_handler(struct ptlrpc_request *req)
                 dlm_req = lustre_msg_buf(req->rq_reqmsg, 0);
                 CERROR("-->