Merge 'staging-next' to Linus's tree
Greg Kroah-Hartman [Thu, 28 Oct 2010 16:44:56 +0000 (09:44 -0700)]
This merges the staging-next tree to Linus's tree and resolves
some conflicts that were present due to changes in other trees that were
affected by files here.

Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

40 files changed:
1  2 
MAINTAINERS
arch/arm/mach-omap2/Makefile
arch/arm/plat-omap/common.c
arch/arm/plat-omap/devices.c
drivers/misc/Kconfig
drivers/misc/Makefile
drivers/staging/Kconfig
drivers/staging/Makefile
drivers/staging/autofs/Kconfig
drivers/staging/autofs/root.c
drivers/staging/comedi/comedi_fops.c
drivers/staging/comedi/drivers/cb_pcimdas.c
drivers/staging/comedi/drivers/ni_labpc.c
drivers/staging/comedi/drivers/rtd520.c
drivers/staging/crystalhd/crystalhd_lnx.c
drivers/staging/dream/pmem.c
drivers/staging/frontier/alphatrack.c
drivers/staging/frontier/tranzport.c
drivers/staging/hv/blkvsc_drv.c
drivers/staging/hv/netvsc_drv.c
drivers/staging/hv/storvsc_drv.c
drivers/staging/iio/industrialio-core.c
drivers/staging/iio/industrialio-ring.c
drivers/staging/lirc/lirc_imon.c
drivers/staging/lirc/lirc_sasem.c
drivers/staging/quickstart/quickstart.c
drivers/staging/smbfs/Kconfig
drivers/staging/smbfs/dir.c
drivers/staging/smbfs/inode.c
drivers/staging/smbfs/proc.c
drivers/staging/spectra/Kconfig
drivers/staging/tidspbridge/rmgr/drv_interface.c
drivers/staging/wlags49_h2/wl_main.c
drivers/staging/zram/zram_drv.c
fs/Kconfig
fs/Makefile
fs/compat.c
fs/compat_ioctl.c
include/linux/Kbuild
include/linux/tty.h

diff --cc MAINTAINERS
Simple merge
Simple merge
  #include <linux/io.h>
  #include <linux/omapfb.h>
  
 -#include <mach/hardware.h>
 -#include <asm/system.h>
 -#include <asm/pgtable.h>
 -#include <asm/mach/map.h>
 -#include <asm/setup.h>
 -
  #include <plat/common.h>
  #include <plat/board.h>
 -#include <plat/control.h>
 -#include <plat/mux.h>
 -#include <plat/fpga.h>
 -#include <plat/serial.h>
  #include <plat/vram.h>
+ #include <plat/dsp.h>
  
 -#include <plat/clock.h>
 -
 -#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
 -# include "../mach-omap2/sdrc.h"
 -#endif
  
  #define NO_LENGTH_CHECK 0xffffffff
  
@@@ -64,4 -88,272 +65,5 @@@ void __init omap_reserve(void
  {
        omapfb_reserve_sdram_memblock();
        omap_vram_reserve_sdram_memblock();
+       omap_dsp_reserve_sdram_memblock();
  }
 -
 -/*
 - * 32KHz clocksource ... always available, on pretty most chips except
 - * OMAP 730 and 1510.  Other timers could be used as clocksources, with
 - * higher resolution in free-running counter modes (e.g. 12 MHz xtal),
 - * but systems won't necessarily want to spend resources that way.
 - */
 -
 -#define OMAP16XX_TIMER_32K_SYNCHRONIZED               0xfffbc410
 -
 -#if !(defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP15XX))
 -
 -#include <linux/clocksource.h>
 -
 -/*
 - * offset_32k holds the init time counter value. It is then subtracted
 - * from every counter read to achieve a counter that counts time from the
 - * kernel boot (needed for sched_clock()).
 - */
 -static u32 offset_32k __read_mostly;
 -
 -#ifdef CONFIG_ARCH_OMAP16XX
 -static cycle_t omap16xx_32k_read(struct clocksource *cs)
 -{
 -      return omap_readl(OMAP16XX_TIMER_32K_SYNCHRONIZED) - offset_32k;
 -}
 -#else
 -#define omap16xx_32k_read     NULL
 -#endif
 -
 -#ifdef CONFIG_ARCH_OMAP2420
 -static cycle_t omap2420_32k_read(struct clocksource *cs)
 -{
 -      return omap_readl(OMAP2420_32KSYNCT_BASE + 0x10) - offset_32k;
 -}
 -#else
 -#define omap2420_32k_read     NULL
 -#endif
 -
 -#ifdef CONFIG_ARCH_OMAP2430
 -static cycle_t omap2430_32k_read(struct clocksource *cs)
 -{
 -      return omap_readl(OMAP2430_32KSYNCT_BASE + 0x10) - offset_32k;
 -}
 -#else
 -#define omap2430_32k_read     NULL
 -#endif
 -
 -#ifdef CONFIG_ARCH_OMAP3
 -static cycle_t omap34xx_32k_read(struct clocksource *cs)
 -{
 -      return omap_readl(OMAP3430_32KSYNCT_BASE + 0x10) - offset_32k;
 -}
 -#else
 -#define omap34xx_32k_read     NULL
 -#endif
 -
 -#ifdef CONFIG_ARCH_OMAP4
 -static cycle_t omap44xx_32k_read(struct clocksource *cs)
 -{
 -      return omap_readl(OMAP4430_32KSYNCT_BASE + 0x10) - offset_32k;
 -}
 -#else
 -#define omap44xx_32k_read     NULL
 -#endif
 -
 -/*
 - * Kernel assumes that sched_clock can be called early but may not have
 - * things ready yet.
 - */
 -static cycle_t omap_32k_read_dummy(struct clocksource *cs)
 -{
 -      return 0;
 -}
 -
 -static struct clocksource clocksource_32k = {
 -      .name           = "32k_counter",
 -      .rating         = 250,
 -      .read           = omap_32k_read_dummy,
 -      .mask           = CLOCKSOURCE_MASK(32),
 -      .shift          = 10,
 -      .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 -};
 -
 -/*
 - * Returns current time from boot in nsecs. It's OK for this to wrap
 - * around for now, as it's just a relative time stamp.
 - */
 -unsigned long long sched_clock(void)
 -{
 -      return clocksource_cyc2ns(clocksource_32k.read(&clocksource_32k),
 -                                clocksource_32k.mult, clocksource_32k.shift);
 -}
 -
 -/**
 - * read_persistent_clock -  Return time from a persistent clock.
 - *
 - * Reads the time from a source which isn't disabled during PM, the
 - * 32k sync timer.  Convert the cycles elapsed since last read into
 - * nsecs and adds to a monotonically increasing timespec.
 - */
 -static struct timespec persistent_ts;
 -static cycles_t cycles, last_cycles;
 -void read_persistent_clock(struct timespec *ts)
 -{
 -      unsigned long long nsecs;
 -      cycles_t delta;
 -      struct timespec *tsp = &persistent_ts;
 -
 -      last_cycles = cycles;
 -      cycles = clocksource_32k.read(&clocksource_32k);
 -      delta = cycles - last_cycles;
 -
 -      nsecs = clocksource_cyc2ns(delta,
 -                                 clocksource_32k.mult, clocksource_32k.shift);
 -
 -      timespec_add_ns(tsp, nsecs);
 -      *ts = *tsp;
 -}
 -
 -static int __init omap_init_clocksource_32k(void)
 -{
 -      static char err[] __initdata = KERN_ERR
 -                      "%s: can't register clocksource!\n";
 -
 -      if (cpu_is_omap16xx() || cpu_class_is_omap2()) {
 -              struct clk *sync_32k_ick;
 -
 -              if (cpu_is_omap16xx())
 -                      clocksource_32k.read = omap16xx_32k_read;
 -              else if (cpu_is_omap2420())
 -                      clocksource_32k.read = omap2420_32k_read;
 -              else if (cpu_is_omap2430())
 -                      clocksource_32k.read = omap2430_32k_read;
 -              else if (cpu_is_omap34xx())
 -                      clocksource_32k.read = omap34xx_32k_read;
 -              else if (cpu_is_omap44xx())
 -                      clocksource_32k.read = omap44xx_32k_read;
 -              else
 -                      return -ENODEV;
 -
 -              sync_32k_ick = clk_get(NULL, "omap_32ksync_ick");
 -              if (sync_32k_ick)
 -                      clk_enable(sync_32k_ick);
 -
 -              clocksource_32k.mult = clocksource_hz2mult(32768,
 -                                          clocksource_32k.shift);
 -
 -              offset_32k = clocksource_32k.read(&clocksource_32k);
 -
 -              if (clocksource_register(&clocksource_32k))
 -                      printk(err, clocksource_32k.name);
 -      }
 -      return 0;
 -}
 -arch_initcall(omap_init_clocksource_32k);
 -
 -#endif        /* !(defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP15XX)) */
 -
 -/* Global address base setup code */
 -
 -#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
 -
 -static void __init __omap2_set_globals(struct omap_globals *omap2_globals)
 -{
 -      omap2_set_globals_tap(omap2_globals);
 -      omap2_set_globals_sdrc(omap2_globals);
 -      omap2_set_globals_control(omap2_globals);
 -      omap2_set_globals_prcm(omap2_globals);
 -      omap2_set_globals_uart(omap2_globals);
 -}
 -
 -#endif
 -
 -#if defined(CONFIG_ARCH_OMAP2420)
 -
 -static struct omap_globals omap242x_globals = {
 -      .class  = OMAP242X_CLASS,
 -      .tap    = OMAP2_L4_IO_ADDRESS(0x48014000),
 -      .sdrc   = OMAP2420_SDRC_BASE,
 -      .sms    = OMAP2420_SMS_BASE,
 -      .ctrl   = OMAP2420_CTRL_BASE,
 -      .prm    = OMAP2420_PRM_BASE,
 -      .cm     = OMAP2420_CM_BASE,
 -      .uart1_phys     = OMAP2_UART1_BASE,
 -      .uart2_phys     = OMAP2_UART2_BASE,
 -      .uart3_phys     = OMAP2_UART3_BASE,
 -};
 -
 -void __init omap2_set_globals_242x(void)
 -{
 -      __omap2_set_globals(&omap242x_globals);
 -}
 -#endif
 -
 -#if defined(CONFIG_ARCH_OMAP2430)
 -
 -static struct omap_globals omap243x_globals = {
 -      .class  = OMAP243X_CLASS,
 -      .tap    = OMAP2_L4_IO_ADDRESS(0x4900a000),
 -      .sdrc   = OMAP243X_SDRC_BASE,
 -      .sms    = OMAP243X_SMS_BASE,
 -      .ctrl   = OMAP243X_CTRL_BASE,
 -      .prm    = OMAP2430_PRM_BASE,
 -      .cm     = OMAP2430_CM_BASE,
 -      .uart1_phys     = OMAP2_UART1_BASE,
 -      .uart2_phys     = OMAP2_UART2_BASE,
 -      .uart3_phys     = OMAP2_UART3_BASE,
 -};
 -
 -void __init omap2_set_globals_243x(void)
 -{
 -      __omap2_set_globals(&omap243x_globals);
 -}
 -#endif
 -
 -#if defined(CONFIG_ARCH_OMAP3)
 -
 -static struct omap_globals omap3_globals = {
 -      .class  = OMAP343X_CLASS,
 -      .tap    = OMAP2_L4_IO_ADDRESS(0x4830A000),
 -      .sdrc   = OMAP343X_SDRC_BASE,
 -      .sms    = OMAP343X_SMS_BASE,
 -      .ctrl   = OMAP343X_CTRL_BASE,
 -      .prm    = OMAP3430_PRM_BASE,
 -      .cm     = OMAP3430_CM_BASE,
 -      .uart1_phys     = OMAP3_UART1_BASE,
 -      .uart2_phys     = OMAP3_UART2_BASE,
 -      .uart3_phys     = OMAP3_UART3_BASE,
 -      .uart4_phys     = OMAP3_UART4_BASE,     /* Only on 3630 */
 -};
 -
 -void __init omap2_set_globals_3xxx(void)
 -{
 -      __omap2_set_globals(&omap3_globals);
 -}
 -
 -void __init omap3_map_io(void)
 -{
 -      omap2_set_globals_3xxx();
 -      omap34xx_map_common_io();
 -}
 -#endif
 -
 -#if defined(CONFIG_ARCH_OMAP4)
 -static struct omap_globals omap4_globals = {
 -      .class  = OMAP443X_CLASS,
 -      .tap    = OMAP2_L4_IO_ADDRESS(OMAP443X_SCM_BASE),
 -      .ctrl   = OMAP443X_CTRL_BASE,
 -      .prm    = OMAP4430_PRM_BASE,
 -      .cm     = OMAP4430_CM_BASE,
 -      .cm2    = OMAP4430_CM2_BASE,
 -      .uart1_phys     = OMAP4_UART1_BASE,
 -      .uart2_phys     = OMAP4_UART2_BASE,
 -      .uart3_phys     = OMAP4_UART3_BASE,
 -      .uart4_phys     = OMAP4_UART4_BASE,
 -};
 -
 -void __init omap2_set_globals_443x(void)
 -{
 -      omap2_set_globals_tap(&omap4_globals);
 -      omap2_set_globals_control(&omap4_globals);
 -      omap2_set_globals_prcm(&omap4_globals);
 -      omap2_set_globals_uart(&omap4_globals);
 -}
 -#endif
 -
Simple merge
Simple merge
@@@ -37,6 -33,6 +37,7 @@@ obj-$(CONFIG_IWMC3200TOP)      += iwmc3
  obj-$(CONFIG_HMC6352)         += hmc6352.o
  obj-y                         += eeprom/
  obj-y                         += cb710/
 -obj-$(CONFIG_VMWARE_BALLOON)  += vmware_balloon.o
 +obj-$(CONFIG_VMWARE_BALLOON)  += vmw_balloon.o
  obj-$(CONFIG_ARM_CHARLCD)     += arm-charlcd.o
 +obj-$(CONFIG_PCH_PHUB)                += pch_phub.o
+ obj-y                         += ti-st/
Simple merge
Simple merge
Simple merge
index 0000000,70210aa..0fdec4b
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,643 +1,645 @@@
+ /* -*- linux-c -*- --------------------------------------------------------- *
+  *
+  * drivers/staging/autofs/root.c
+  *
+  *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
+  *
+  * This file is part of the Linux kernel and is made available under
+  * the terms of the GNU General Public License, version 2, or at your
+  * option, any later version, incorporated herein by reference.
+  *
+  * ------------------------------------------------------------------------- */
+ #include <linux/capability.h>
+ #include <linux/errno.h>
+ #include <linux/stat.h>
+ #include <linux/slab.h>
+ #include <linux/param.h>
+ #include <linux/time.h>
+ #include <linux/compat.h>
+ #include <linux/smp_lock.h>
+ #include "autofs_i.h"
+ static int autofs_root_readdir(struct file *,void *,filldir_t);
+ static struct dentry *autofs_root_lookup(struct inode *,struct dentry *, struct nameidata *);
+ static int autofs_root_symlink(struct inode *,struct dentry *,const char *);
+ static int autofs_root_unlink(struct inode *,struct dentry *);
+ static int autofs_root_rmdir(struct inode *,struct dentry *);
+ static int autofs_root_mkdir(struct inode *,struct dentry *,int);
+ static long autofs_root_ioctl(struct file *,unsigned int,unsigned long);
++#ifdef CONFIG_COMPAT
+ static long autofs_root_compat_ioctl(struct file *,unsigned int,unsigned long);
++#endif
+ const struct file_operations autofs_root_operations = {
+       .llseek         = generic_file_llseek,
+       .read           = generic_read_dir,
+       .readdir        = autofs_root_readdir,
+       .unlocked_ioctl = autofs_root_ioctl,
+ #ifdef CONFIG_COMPAT
+       .compat_ioctl   = autofs_root_compat_ioctl,
+ #endif
+ };
+ const struct inode_operations autofs_root_inode_operations = {
+         .lookup               = autofs_root_lookup,
+         .unlink               = autofs_root_unlink,
+         .symlink      = autofs_root_symlink,
+         .mkdir                = autofs_root_mkdir,
+         .rmdir                = autofs_root_rmdir,
+ };
+ static int autofs_root_readdir(struct file *filp, void *dirent, filldir_t filldir)
+ {
+       struct autofs_dir_ent *ent = NULL;
+       struct autofs_dirhash *dirhash;
+       struct autofs_sb_info *sbi;
+       struct inode * inode = filp->f_path.dentry->d_inode;
+       off_t onr, nr;
+       lock_kernel();
+       sbi = autofs_sbi(inode->i_sb);
+       dirhash = &sbi->dirhash;
+       nr = filp->f_pos;
+       switch(nr)
+       {
+       case 0:
+               if (filldir(dirent, ".", 1, nr, inode->i_ino, DT_DIR) < 0)
+                       goto out;
+               filp->f_pos = ++nr;
+               /* fall through */
+       case 1:
+               if (filldir(dirent, "..", 2, nr, inode->i_ino, DT_DIR) < 0)
+                       goto out;
+               filp->f_pos = ++nr;
+               /* fall through */
+       default:
+               while (onr = nr, ent = autofs_hash_enum(dirhash,&nr,ent)) {
+                       if (!ent->dentry || d_mountpoint(ent->dentry)) {
+                               if (filldir(dirent,ent->name,ent->len,onr,ent->ino,DT_UNKNOWN) < 0)
+                                       goto out;
+                               filp->f_pos = nr;
+                       }
+               }
+               break;
+       }
+ out:
+       unlock_kernel();
+       return 0;
+ }
+ static int try_to_fill_dentry(struct dentry *dentry, struct super_block *sb, struct autofs_sb_info *sbi)
+ {
+       struct inode * inode;
+       struct autofs_dir_ent *ent;
+       int status = 0;
+       if (!(ent = autofs_hash_lookup(&sbi->dirhash, &dentry->d_name))) {
+               do {
+                       if (status && dentry->d_inode) {
+                               if (status != -ENOENT)
+                                       printk("autofs warning: lookup failure on positive dentry, status = %d, name = %s\n", status, dentry->d_name.name);
+                               return 0; /* Try to get the kernel to invalidate this dentry */
+                       }
+                       /* Turn this into a real negative dentry? */
+                       if (status == -ENOENT) {
+                               dentry->d_time = jiffies + AUTOFS_NEGATIVE_TIMEOUT;
+                               dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
+                               return 1;
+                       } else if (status) {
+                               /* Return a negative dentry, but leave it "pending" */
+                               return 1;
+                       }
+                       status = autofs_wait(sbi, &dentry->d_name);
+               } while (!(ent = autofs_hash_lookup(&sbi->dirhash, &dentry->d_name)));
+       }
+       /* Abuse this field as a pointer to the directory entry, used to
+          find the expire list pointers */
+       dentry->d_time = (unsigned long) ent;
+       
+       if (!dentry->d_inode) {
+               inode = autofs_iget(sb, ent->ino);
+               if (IS_ERR(inode)) {
+                       /* Failed, but leave pending for next time */
+                       return 1;
+               }
+               dentry->d_inode = inode;
+       }
+       /* If this is a directory that isn't a mount point, bitch at the
+          daemon and fix it in user space */
+       if (S_ISDIR(dentry->d_inode->i_mode) && !d_mountpoint(dentry)) {
+               return !autofs_wait(sbi, &dentry->d_name);
+       }
+       /* We don't update the usages for the autofs daemon itself, this
+          is necessary for recursive autofs mounts */
+       if (!autofs_oz_mode(sbi)) {
+               autofs_update_usage(&sbi->dirhash,ent);
+       }
+       dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
+       return 1;
+ }
+ /*
+  * Revalidate is called on every cache lookup.  Some of those
+  * cache lookups may actually happen while the dentry is not
+  * yet completely filled in, and revalidate has to delay such
+  * lookups..
+  */
+ static int autofs_revalidate(struct dentry * dentry, struct nameidata *nd)
+ {
+       struct inode * dir;
+       struct autofs_sb_info *sbi;
+       struct autofs_dir_ent *ent;
+       int res;
+       lock_kernel();
+       dir = dentry->d_parent->d_inode;
+       sbi = autofs_sbi(dir->i_sb);
+       /* Pending dentry */
+       if (dentry->d_flags & DCACHE_AUTOFS_PENDING) {
+               if (autofs_oz_mode(sbi))
+                       res = 1;
+               else
+                       res = try_to_fill_dentry(dentry, dir->i_sb, sbi);
+               unlock_kernel();
+               return res;
+       }
+       /* Negative dentry.. invalidate if "old" */
+       if (!dentry->d_inode) {
+               unlock_kernel();
+               return (dentry->d_time - jiffies <= AUTOFS_NEGATIVE_TIMEOUT);
+       }
+               
+       /* Check for a non-mountpoint directory */
+       if (S_ISDIR(dentry->d_inode->i_mode) && !d_mountpoint(dentry)) {
+               if (autofs_oz_mode(sbi))
+                       res = 1;
+               else
+                       res = try_to_fill_dentry(dentry, dir->i_sb, sbi);
+               unlock_kernel();
+               return res;
+       }
+       /* Update the usage list */
+       if (!autofs_oz_mode(sbi)) {
+               ent = (struct autofs_dir_ent *) dentry->d_time;
+               if (ent)
+                       autofs_update_usage(&sbi->dirhash,ent);
+       }
+       unlock_kernel();
+       return 1;
+ }
+ static const struct dentry_operations autofs_dentry_operations = {
+       .d_revalidate   = autofs_revalidate,
+ };
+ static struct dentry *autofs_root_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+ {
+       struct autofs_sb_info *sbi;
+       int oz_mode;
+       DPRINTK(("autofs_root_lookup: name = "));
+       lock_kernel();
+       autofs_say(dentry->d_name.name,dentry->d_name.len);
+       if (dentry->d_name.len > NAME_MAX) {
+               unlock_kernel();
+               return ERR_PTR(-ENAMETOOLONG);/* File name too long to exist */
+       }
+       sbi = autofs_sbi(dir->i_sb);
+       oz_mode = autofs_oz_mode(sbi);
+       DPRINTK(("autofs_lookup: pid = %u, pgrp = %u, catatonic = %d, "
+                               "oz_mode = %d\n", task_pid_nr(current),
+                               task_pgrp_nr(current), sbi->catatonic,
+                               oz_mode));
+       /*
+        * Mark the dentry incomplete, but add it. This is needed so
+        * that the VFS layer knows about the dentry, and we can count
+        * on catching any lookups through the revalidate.
+        *
+        * Let all the hard work be done by the revalidate function that
+        * needs to be able to do this anyway..
+        *
+        * We need to do this before we release the directory semaphore.
+        */
+       dentry->d_op = &autofs_dentry_operations;
+       dentry->d_flags |= DCACHE_AUTOFS_PENDING;
+       d_add(dentry, NULL);
+       mutex_unlock(&dir->i_mutex);
+       autofs_revalidate(dentry, nd);
+       mutex_lock(&dir->i_mutex);
+       /*
+        * If we are still pending, check if we had to handle
+        * a signal. If so we can force a restart..
+        */
+       if (dentry->d_flags & DCACHE_AUTOFS_PENDING) {
+               /* See if we were interrupted */
+               if (signal_pending(current)) {
+                       sigset_t *sigset = &current->pending.signal;
+                       if (sigismember (sigset, SIGKILL) ||
+                           sigismember (sigset, SIGQUIT) ||
+                           sigismember (sigset, SIGINT)) {
+                               unlock_kernel();
+                               return ERR_PTR(-ERESTARTNOINTR);
+                       }
+               }
+       }
+       unlock_kernel();
+       /*
+        * If this dentry is unhashed, then we shouldn't honour this
+        * lookup even if the dentry is positive.  Returning ENOENT here
+        * doesn't do the right thing for all system calls, but it should
+        * be OK for the operations we permit from an autofs.
+        */
+       if (dentry->d_inode && d_unhashed(dentry))
+               return ERR_PTR(-ENOENT);
+       return NULL;
+ }
+ static int autofs_root_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
+ {
+       struct autofs_sb_info *sbi = autofs_sbi(dir->i_sb);
+       struct autofs_dirhash *dh = &sbi->dirhash;
+       struct autofs_dir_ent *ent;
+       unsigned int n;
+       int slsize;
+       struct autofs_symlink *sl;
+       struct inode *inode;
+       DPRINTK(("autofs_root_symlink: %s <- ", symname));
+       autofs_say(dentry->d_name.name,dentry->d_name.len);
+       lock_kernel();
+       if (!autofs_oz_mode(sbi)) {
+               unlock_kernel();
+               return -EACCES;
+       }
+       if (autofs_hash_lookup(dh, &dentry->d_name)) {
+               unlock_kernel();
+               return -EEXIST;
+       }
+       n = find_first_zero_bit(sbi->symlink_bitmap,AUTOFS_MAX_SYMLINKS);
+       if (n >= AUTOFS_MAX_SYMLINKS) {
+               unlock_kernel();
+               return -ENOSPC;
+       }
+       set_bit(n,sbi->symlink_bitmap);
+       sl = &sbi->symlink[n];
+       sl->len = strlen(symname);
+       sl->data = kmalloc(slsize = sl->len+1, GFP_KERNEL);
+       if (!sl->data) {
+               clear_bit(n,sbi->symlink_bitmap);
+               unlock_kernel();
+               return -ENOSPC;
+       }
+       ent = kmalloc(sizeof(struct autofs_dir_ent), GFP_KERNEL);
+       if (!ent) {
+               kfree(sl->data);
+               clear_bit(n,sbi->symlink_bitmap);
+               unlock_kernel();
+               return -ENOSPC;
+       }
+       ent->name = kmalloc(dentry->d_name.len+1, GFP_KERNEL);
+       if (!ent->name) {
+               kfree(sl->data);
+               kfree(ent);
+               clear_bit(n,sbi->symlink_bitmap);
+               unlock_kernel();
+               return -ENOSPC;
+       }
+       memcpy(sl->data,symname,slsize);
+       sl->mtime = get_seconds();
+       ent->ino = AUTOFS_FIRST_SYMLINK + n;
+       ent->hash = dentry->d_name.hash;
+       memcpy(ent->name, dentry->d_name.name, 1+(ent->len = dentry->d_name.len));
+       ent->dentry = NULL;     /* We don't keep the dentry for symlinks */
+       autofs_hash_insert(dh,ent);
+       inode = autofs_iget(dir->i_sb, ent->ino);
+       if (IS_ERR(inode))
+               return PTR_ERR(inode);
+       d_instantiate(dentry, inode);
+       unlock_kernel();
+       return 0;
+ }
+ /*
+  * NOTE!
+  *
+  * Normal filesystems would do a "d_delete()" to tell the VFS dcache
+  * that the file no longer exists. However, doing that means that the
+  * VFS layer can turn the dentry into a negative dentry, which we
+  * obviously do not want (we're dropping the entry not because it
+  * doesn't exist, but because it has timed out).
+  *
+  * Also see autofs_root_rmdir()..
+  */
+ static int autofs_root_unlink(struct inode *dir, struct dentry *dentry)
+ {
+       struct autofs_sb_info *sbi = autofs_sbi(dir->i_sb);
+       struct autofs_dirhash *dh = &sbi->dirhash;
+       struct autofs_dir_ent *ent;
+       unsigned int n;
+       /* This allows root to remove symlinks */
+       lock_kernel();
+       if (!autofs_oz_mode(sbi) && !capable(CAP_SYS_ADMIN)) {
+               unlock_kernel();
+               return -EACCES;
+       }
+       ent = autofs_hash_lookup(dh, &dentry->d_name);
+       if (!ent) {
+               unlock_kernel();
+               return -ENOENT;
+       }
+       n = ent->ino - AUTOFS_FIRST_SYMLINK;
+       if (n >= AUTOFS_MAX_SYMLINKS) {
+               unlock_kernel();
+               return -EISDIR; /* It's a directory, dummy */
+       }
+       if (!test_bit(n,sbi->symlink_bitmap)) {
+               unlock_kernel();
+               return -EINVAL; /* Nonexistent symlink?  Shouldn't happen */
+       }
+       
+       dentry->d_time = (unsigned long)(struct autofs_dirhash *)NULL;
+       autofs_hash_delete(ent);
+       clear_bit(n,sbi->symlink_bitmap);
+       kfree(sbi->symlink[n].data);
+       d_drop(dentry);
+       
+       unlock_kernel();
+       return 0;
+ }
+ static int autofs_root_rmdir(struct inode *dir, struct dentry *dentry)
+ {
+       struct autofs_sb_info *sbi = autofs_sbi(dir->i_sb);
+       struct autofs_dirhash *dh = &sbi->dirhash;
+       struct autofs_dir_ent *ent;
+       lock_kernel();
+       if (!autofs_oz_mode(sbi)) {
+               unlock_kernel();
+               return -EACCES;
+       }
+       ent = autofs_hash_lookup(dh, &dentry->d_name);
+       if (!ent) {
+               unlock_kernel();
+               return -ENOENT;
+       }
+       if ((unsigned int)ent->ino < AUTOFS_FIRST_DIR_INO) {
+               unlock_kernel();
+               return -ENOTDIR; /* Not a directory */
+       }
+       if (ent->dentry != dentry) {
+               printk("autofs_rmdir: odentry != dentry for entry %s\n", dentry->d_name.name);
+       }
+       dentry->d_time = (unsigned long)(struct autofs_dir_ent *)NULL;
+       autofs_hash_delete(ent);
+       drop_nlink(dir);
+       d_drop(dentry);
+       unlock_kernel();
+       return 0;
+ }
+ static int autofs_root_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+ {
+       struct autofs_sb_info *sbi = autofs_sbi(dir->i_sb);
+       struct autofs_dirhash *dh = &sbi->dirhash;
+       struct autofs_dir_ent *ent;
+       struct inode *inode;
+       ino_t ino;
+       lock_kernel();
+       if (!autofs_oz_mode(sbi)) {
+               unlock_kernel();
+               return -EACCES;
+       }
+       ent = autofs_hash_lookup(dh, &dentry->d_name);
+       if (ent) {
+               unlock_kernel();
+               return -EEXIST;
+       }
+       if (sbi->next_dir_ino < AUTOFS_FIRST_DIR_INO) {
+               printk("autofs: Out of inode numbers -- what the heck did you do??\n");
+               unlock_kernel();
+               return -ENOSPC;
+       }
+       ino = sbi->next_dir_ino++;
+       ent = kmalloc(sizeof(struct autofs_dir_ent), GFP_KERNEL);
+       if (!ent) {
+               unlock_kernel();
+               return -ENOSPC;
+       }
+       ent->name = kmalloc(dentry->d_name.len+1, GFP_KERNEL);
+       if (!ent->name) {
+               kfree(ent);
+               unlock_kernel();
+               return -ENOSPC;
+       }
+       ent->hash = dentry->d_name.hash;
+       memcpy(ent->name, dentry->d_name.name, 1+(ent->len = dentry->d_name.len));
+       ent->ino = ino;
+       ent->dentry = dentry;
+       autofs_hash_insert(dh,ent);
+       inc_nlink(dir);
+       inode = autofs_iget(dir->i_sb, ino);
+       if (IS_ERR(inode)) {
+               drop_nlink(dir);
+               return PTR_ERR(inode);
+       }
+       d_instantiate(dentry, inode);
+       unlock_kernel();
+       return 0;
+ }
+ /* Get/set timeout ioctl() operation */
+ #ifdef CONFIG_COMPAT
+ static inline int autofs_compat_get_set_timeout(struct autofs_sb_info *sbi,
+                                        unsigned int __user *p)
+ {
+       unsigned long ntimeout;
+       if (get_user(ntimeout, p) ||
+           put_user(sbi->exp_timeout / HZ, p))
+               return -EFAULT;
+       if (ntimeout > UINT_MAX/HZ)
+               sbi->exp_timeout = 0;
+       else
+               sbi->exp_timeout = ntimeout * HZ;
+       return 0;
+ }
+ #endif
+ static inline int autofs_get_set_timeout(struct autofs_sb_info *sbi,
+                                        unsigned long __user *p)
+ {
+       unsigned long ntimeout;
+       if (get_user(ntimeout, p) ||
+           put_user(sbi->exp_timeout / HZ, p))
+               return -EFAULT;
+       if (ntimeout > ULONG_MAX/HZ)
+               sbi->exp_timeout = 0;
+       else
+               sbi->exp_timeout = ntimeout * HZ;
+       return 0;
+ }
+ /* Return protocol version */
+ static inline int autofs_get_protover(int __user *p)
+ {
+       return put_user(AUTOFS_PROTO_VERSION, p);
+ }
+ /* Perform an expiry operation */
+ static inline int autofs_expire_run(struct super_block *sb,
+                                   struct autofs_sb_info *sbi,
+                                   struct vfsmount *mnt,
+                                   struct autofs_packet_expire __user *pkt_p)
+ {
+       struct autofs_dir_ent *ent;
+       struct autofs_packet_expire pkt;
+       memset(&pkt,0,sizeof pkt);
+       pkt.hdr.proto_version = AUTOFS_PROTO_VERSION;
+       pkt.hdr.type = autofs_ptype_expire;
+       if (!sbi->exp_timeout || !(ent = autofs_expire(sb,sbi,mnt)))
+               return -EAGAIN;
+       pkt.len = ent->len;
+       memcpy(pkt.name, ent->name, pkt.len);
+       pkt.name[pkt.len] = '\0';
+       if (copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)))
+               return -EFAULT;
+       return 0;
+ }
+ /*
+  * ioctl()'s on the root directory is the chief method for the daemon to
+  * generate kernel reactions
+  */
+ static int autofs_do_root_ioctl(struct inode *inode, struct file *filp,
+                            unsigned int cmd, unsigned long arg)
+ {
+       struct autofs_sb_info *sbi = autofs_sbi(inode->i_sb);
+       void __user *argp = (void __user *)arg;
+       DPRINTK(("autofs_ioctl: cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u\n",cmd,arg,sbi,task_pgrp_nr(current)));
+       if (_IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) ||
+            _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT)
+               return -ENOTTY;
+       
+       if (!autofs_oz_mode(sbi) && !capable(CAP_SYS_ADMIN))
+               return -EPERM;
+       
+       switch(cmd) {
+       case AUTOFS_IOC_READY:  /* Wait queue: go ahead and retry */
+               return autofs_wait_release(sbi,(autofs_wqt_t)arg,0);
+       case AUTOFS_IOC_FAIL:   /* Wait queue: fail with ENOENT */
+               return autofs_wait_release(sbi,(autofs_wqt_t)arg,-ENOENT);
+       case AUTOFS_IOC_CATATONIC: /* Enter catatonic mode (daemon shutdown) */
+               autofs_catatonic_mode(sbi);
+               return 0;
+       case AUTOFS_IOC_PROTOVER: /* Get protocol version */
+               return autofs_get_protover(argp);
+ #ifdef CONFIG_COMPAT
+       case AUTOFS_IOC_SETTIMEOUT32:
+               return autofs_compat_get_set_timeout(sbi, argp);
+ #endif
+       case AUTOFS_IOC_SETTIMEOUT:
+               return autofs_get_set_timeout(sbi, argp);
+       case AUTOFS_IOC_EXPIRE:
+               return autofs_expire_run(inode->i_sb, sbi, filp->f_path.mnt,
+                                        argp);
+       default:
+               return -ENOSYS;
+       }
+ }
+ static long autofs_root_ioctl(struct file *filp,
+                            unsigned int cmd, unsigned long arg)
+ {
+       int ret;
+       lock_kernel();
+       ret = autofs_do_root_ioctl(filp->f_path.dentry->d_inode,
+                                  filp, cmd, arg);
+       unlock_kernel();
+       return ret;
+ }
+ #ifdef CONFIG_COMPAT
+ static long autofs_root_compat_ioctl(struct file *filp,
+                            unsigned int cmd, unsigned long arg)
+ {
+       struct inode *inode = filp->f_path.dentry->d_inode;
+       int ret;
+       lock_kernel();
+       if (cmd == AUTOFS_IOC_READY || cmd == AUTOFS_IOC_FAIL)
+               ret = autofs_do_root_ioctl(inode, filp, cmd, arg);
+       else
+               ret = autofs_do_root_ioctl(inode, filp, cmd,
+                       (unsigned long)compat_ptr(arg));
+       unlock_kernel();
+       return ret;
+ }
+ #endif
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 0000000,936b3bb..f088ea2
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,702 +1,696 @@@
+ /*
+  *  dir.c
+  *
+  *  Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
+  *  Copyright (C) 1997 by Volker Lendecke
+  *
+  *  Please add a note about your changes to smbfs in the ChangeLog file.
+  */
+ #include <linux/time.h>
+ #include <linux/errno.h>
+ #include <linux/kernel.h>
+ #include <linux/smp_lock.h>
+ #include <linux/ctype.h>
+ #include <linux/net.h>
+ #include <linux/sched.h>
+ #include "smb_fs.h"
+ #include "smb_mount.h"
+ #include "smbno.h"
+ #include "smb_debug.h"
+ #include "proto.h"
+ static int smb_readdir(struct file *, void *, filldir_t);
+ static int smb_dir_open(struct inode *, struct file *);
+ static struct dentry *smb_lookup(struct inode *, struct dentry *, struct nameidata *);
+ static int smb_create(struct inode *, struct dentry *, int, struct nameidata *);
+ static int smb_mkdir(struct inode *, struct dentry *, int);
+ static int smb_rmdir(struct inode *, struct dentry *);
+ static int smb_unlink(struct inode *, struct dentry *);
+ static int smb_rename(struct inode *, struct dentry *,
+                     struct inode *, struct dentry *);
+ static int smb_make_node(struct inode *,struct dentry *,int,dev_t);
+ static int smb_link(struct dentry *, struct inode *, struct dentry *);
+ const struct file_operations smb_dir_operations =
+ {
+       .llseek         = generic_file_llseek,
+       .read           = generic_read_dir,
+       .readdir        = smb_readdir,
+       .unlocked_ioctl = smb_ioctl,
+       .open           = smb_dir_open,
+ };
+ const struct inode_operations smb_dir_inode_operations =
+ {
+       .create         = smb_create,
+       .lookup         = smb_lookup,
+       .unlink         = smb_unlink,
+       .mkdir          = smb_mkdir,
+       .rmdir          = smb_rmdir,
+       .rename         = smb_rename,
+       .getattr        = smb_getattr,
+       .setattr        = smb_notify_change,
+ };
+ const struct inode_operations smb_dir_inode_operations_unix =
+ {
+       .create         = smb_create,
+       .lookup         = smb_lookup,
+       .unlink         = smb_unlink,
+       .mkdir          = smb_mkdir,
+       .rmdir          = smb_rmdir,
+       .rename         = smb_rename,
+       .getattr        = smb_getattr,
+       .setattr        = smb_notify_change,
+       .symlink        = smb_symlink,
+       .mknod          = smb_make_node,
+       .link           = smb_link,
+ };
+ /*
+  * Read a directory, using filldir to fill the dirent memory.
+  * smb_proc_readdir does the actual reading from the smb server.
+  *
+  * The cache code is almost directly taken from ncpfs
+  */
+ static int 
+ smb_readdir(struct file *filp, void *dirent, filldir_t filldir)
+ {
+       struct dentry *dentry = filp->f_path.dentry;
+       struct inode *dir = dentry->d_inode;
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       union  smb_dir_cache *cache = NULL;
+       struct smb_cache_control ctl;
+       struct page *page = NULL;
+       int result;
+       ctl.page  = NULL;
+       ctl.cache = NULL;
+       VERBOSE("reading %s/%s, f_pos=%d\n",
+               DENTRY_PATH(dentry),  (int) filp->f_pos);
+       result = 0;
+       lock_kernel();
+       switch ((unsigned int) filp->f_pos) {
+       case 0:
+               if (filldir(dirent, ".", 1, 0, dir->i_ino, DT_DIR) < 0)
+                       goto out;
+               filp->f_pos = 1;
+               /* fallthrough */
+       case 1:
+               if (filldir(dirent, "..", 2, 1, parent_ino(dentry), DT_DIR) < 0)
+                       goto out;
+               filp->f_pos = 2;
+       }
+       /*
+        * Make sure our inode is up-to-date.
+        */
+       result = smb_revalidate_inode(dentry);
+       if (result)
+               goto out;
+       page = grab_cache_page(&dir->i_data, 0);
+       if (!page)
+               goto read_really;
+       ctl.cache = cache = kmap(page);
+       ctl.head  = cache->head;
+       if (!PageUptodate(page) || !ctl.head.eof) {
+               VERBOSE("%s/%s, page uptodate=%d, eof=%d\n",
+                        DENTRY_PATH(dentry), PageUptodate(page),ctl.head.eof);
+               goto init_cache;
+       }
+       if (filp->f_pos == 2) {
+               if (jiffies - ctl.head.time >= SMB_MAX_AGE(server))
+                       goto init_cache;
+               /*
+                * N.B. ncpfs checks mtime of dentry too here, we don't.
+                *   1. common smb servers do not update mtime on dir changes
+                *   2. it requires an extra smb request
+                *      (revalidate has the same timeout as ctl.head.time)
+                *
+                * Instead smbfs invalidates its own cache on local changes
+                * and remote changes are not seen until timeout.
+                */
+       }
+       if (filp->f_pos > ctl.head.end)
+               goto finished;
+       ctl.fpos = filp->f_pos + (SMB_DIRCACHE_START - 2);
+       ctl.ofs  = ctl.fpos / SMB_DIRCACHE_SIZE;
+       ctl.idx  = ctl.fpos % SMB_DIRCACHE_SIZE;
+       for (;;) {
+               if (ctl.ofs != 0) {
+                       ctl.page = find_lock_page(&dir->i_data, ctl.ofs);
+                       if (!ctl.page)
+                               goto invalid_cache;
+                       ctl.cache = kmap(ctl.page);
+                       if (!PageUptodate(ctl.page))
+                               goto invalid_cache;
+               }
+               while (ctl.idx < SMB_DIRCACHE_SIZE) {
+                       struct dentry *dent;
+                       int res;
+                       dent = smb_dget_fpos(ctl.cache->dentry[ctl.idx],
+                                            dentry, filp->f_pos);
+                       if (!dent)
+                               goto invalid_cache;
+                       res = filldir(dirent, dent->d_name.name,
+                                     dent->d_name.len, filp->f_pos,
+                                     dent->d_inode->i_ino, DT_UNKNOWN);
+                       dput(dent);
+                       if (res)
+                               goto finished;
+                       filp->f_pos += 1;
+                       ctl.idx += 1;
+                       if (filp->f_pos > ctl.head.end)
+                               goto finished;
+               }
+               if (ctl.page) {
+                       kunmap(ctl.page);
+                       SetPageUptodate(ctl.page);
+                       unlock_page(ctl.page);
+                       page_cache_release(ctl.page);
+                       ctl.page = NULL;
+               }
+               ctl.idx  = 0;
+               ctl.ofs += 1;
+       }
+ invalid_cache:
+       if (ctl.page) {
+               kunmap(ctl.page);
+               unlock_page(ctl.page);
+               page_cache_release(ctl.page);
+               ctl.page = NULL;
+       }
+       ctl.cache = cache;
+ init_cache:
+       smb_invalidate_dircache_entries(dentry);
+       ctl.head.time = jiffies;
+       ctl.head.eof = 0;
+       ctl.fpos = 2;
+       ctl.ofs = 0;
+       ctl.idx = SMB_DIRCACHE_START;
+       ctl.filled = 0;
+       ctl.valid  = 1;
+ read_really:
+       result = server->ops->readdir(filp, dirent, filldir, &ctl);
+       if (result == -ERESTARTSYS && page)
+               ClearPageUptodate(page);
+       if (ctl.idx == -1)
+               goto invalid_cache;     /* retry */
+       ctl.head.end = ctl.fpos - 1;
+       ctl.head.eof = ctl.valid;
+ finished:
+       if (page) {
+               cache->head = ctl.head;
+               kunmap(page);
+               if (result != -ERESTARTSYS)
+                       SetPageUptodate(page);
+               unlock_page(page);
+               page_cache_release(page);
+       }
+       if (ctl.page) {
+               kunmap(ctl.page);
+               SetPageUptodate(ctl.page);
+               unlock_page(ctl.page);
+               page_cache_release(ctl.page);
+       }
+ out:
+       unlock_kernel();
+       return result;
+ }
+ static int
+ smb_dir_open(struct inode *dir, struct file *file)
+ {
+       struct dentry *dentry = file->f_path.dentry;
+       struct smb_sb_info *server;
+       int error = 0;
+       VERBOSE("(%s/%s)\n", dentry->d_parent->d_name.name,
+               file->f_path.dentry->d_name.name);
+       /*
+        * Directory timestamps in the core protocol aren't updated
+        * when a file is added, so we give them a very short TTL.
+        */
+       lock_kernel();
+       server = server_from_dentry(dentry);
+       if (server->opt.protocol < SMB_PROTOCOL_LANMAN2) {
+               unsigned long age = jiffies - SMB_I(dir)->oldmtime;
+               if (age > 2*HZ)
+                       smb_invalid_dir_cache(dir);
+       }
+       /*
+        * Note: in order to allow the smbmount process to open the
+        * mount point, we only revalidate if the connection is valid or
+        * if the process is trying to access something other than the root.
+        */
+       if (server->state == CONN_VALID || !IS_ROOT(dentry))
+               error = smb_revalidate_inode(dentry);
+       unlock_kernel();
+       return error;
+ }
+ /*
+  * Dentry operations routines
+  */
+ static int smb_lookup_validate(struct dentry *, struct nameidata *);
+ static int smb_hash_dentry(struct dentry *, struct qstr *);
+ static int smb_compare_dentry(struct dentry *, struct qstr *, struct qstr *);
+ static int smb_delete_dentry(struct dentry *);
+ static const struct dentry_operations smbfs_dentry_operations =
+ {
+       .d_revalidate   = smb_lookup_validate,
+       .d_hash         = smb_hash_dentry,
+       .d_compare      = smb_compare_dentry,
+       .d_delete       = smb_delete_dentry,
+ };
+ static const struct dentry_operations smbfs_dentry_operations_case =
+ {
+       .d_revalidate   = smb_lookup_validate,
+       .d_delete       = smb_delete_dentry,
+ };
+ /*
+  * This is the callback when the dcache has a lookup hit.
+  */
+ static int
+ smb_lookup_validate(struct dentry * dentry, struct nameidata *nd)
+ {
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       struct inode * inode = dentry->d_inode;
+       unsigned long age = jiffies - dentry->d_time;
+       int valid;
+       /*
+        * The default validation is based on dentry age:
+        * we believe in dentries for a few seconds.  (But each
+        * successful server lookup renews the timestamp.)
+        */
+       valid = (age <= SMB_MAX_AGE(server));
+ #ifdef SMBFS_DEBUG_VERBOSE
+       if (!valid)
+               VERBOSE("%s/%s not valid, age=%lu\n", 
+                       DENTRY_PATH(dentry), age);
+ #endif
+       if (inode) {
+               lock_kernel();
+               if (is_bad_inode(inode)) {
+                       PARANOIA("%s/%s has dud inode\n", DENTRY_PATH(dentry));
+                       valid = 0;
+               } else if (!valid)
+                       valid = (smb_revalidate_inode(dentry) == 0);
+               unlock_kernel();
+       } else {
+               /*
+                * What should we do for negative dentries?
+                */
+       }
+       return valid;
+ }
+ static int 
+ smb_hash_dentry(struct dentry *dir, struct qstr *this)
+ {
+       unsigned long hash;
+       int i;
+       hash = init_name_hash();
+       for (i=0; i < this->len ; i++)
+               hash = partial_name_hash(tolower(this->name[i]), hash);
+       this->hash = end_name_hash(hash);
+   
+       return 0;
+ }
+ static int
+ smb_compare_dentry(struct dentry *dir, struct qstr *a, struct qstr *b)
+ {
+       int i, result = 1;
+       if (a->len != b->len)
+               goto out;
+       for (i=0; i < a->len; i++) {
+               if (tolower(a->name[i]) != tolower(b->name[i]))
+                       goto out;
+       }
+       result = 0;
+ out:
+       return result;
+ }
+ /*
+  * This is the callback from dput() when d_count is going to 0.
+  * We use this to unhash dentries with bad inodes.
+  */
+ static int
+ smb_delete_dentry(struct dentry * dentry)
+ {
+       if (dentry->d_inode) {
+               if (is_bad_inode(dentry->d_inode)) {
+                       PARANOIA("bad inode, unhashing %s/%s\n",
+                                DENTRY_PATH(dentry));
+                       return 1;
+               }
+       } else {
+               /* N.B. Unhash negative dentries? */
+       }
+       return 0;
+ }
+ /*
+  * Initialize a new dentry
+  */
+ void
+ smb_new_dentry(struct dentry *dentry)
+ {
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       if (server->mnt->flags & SMB_MOUNT_CASE)
+               dentry->d_op = &smbfs_dentry_operations_case;
+       else
+               dentry->d_op = &smbfs_dentry_operations;
+       dentry->d_time = jiffies;
+ }
+ /*
+  * Whenever a lookup succeeds, we know the parent directories
+  * are all valid, so we want to update the dentry timestamps.
+  * N.B. Move this to dcache?
+  */
+ void
+ smb_renew_times(struct dentry * dentry)
+ {
+       dget(dentry);
 -      spin_lock(&dentry->d_lock);
 -      for (;;) {
 -              struct dentry *parent;
++      dentry->d_time = jiffies;
 -              dentry->d_time = jiffies;
 -              if (IS_ROOT(dentry))
 -                      break;
 -              parent = dentry->d_parent;
 -              dget(parent);
 -              spin_unlock(&dentry->d_lock);
++      while (!IS_ROOT(dentry)) {
++              struct dentry *parent = dget_parent(dentry);
+               dput(dentry);
+               dentry = parent;
 -              spin_lock(&dentry->d_lock);
++
++              dentry->d_time = jiffies;
+       }
 -      spin_unlock(&dentry->d_lock);
+       dput(dentry);
+ }
+ static struct dentry *
+ smb_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+ {
+       struct smb_fattr finfo;
+       struct inode *inode;
+       int error;
+       struct smb_sb_info *server;
+       error = -ENAMETOOLONG;
+       if (dentry->d_name.len > SMB_MAXNAMELEN)
+               goto out;
+       /* Do not allow lookup of names with backslashes in */
+       error = -EINVAL;
+       if (memchr(dentry->d_name.name, '\\', dentry->d_name.len))
+               goto out;
+       lock_kernel();
+       error = smb_proc_getattr(dentry, &finfo);
+ #ifdef SMBFS_PARANOIA
+       if (error && error != -ENOENT)
+               PARANOIA("find %s/%s failed, error=%d\n",
+                        DENTRY_PATH(dentry), error);
+ #endif
+       inode = NULL;
+       if (error == -ENOENT)
+               goto add_entry;
+       if (!error) {
+               error = -EACCES;
+               finfo.f_ino = iunique(dentry->d_sb, 2);
+               inode = smb_iget(dir->i_sb, &finfo);
+               if (inode) {
+       add_entry:
+                       server = server_from_dentry(dentry);
+                       if (server->mnt->flags & SMB_MOUNT_CASE)
+                               dentry->d_op = &smbfs_dentry_operations_case;
+                       else
+                               dentry->d_op = &smbfs_dentry_operations;
+                       d_add(dentry, inode);
+                       smb_renew_times(dentry);
+                       error = 0;
+               }
+       }
+       unlock_kernel();
+ out:
+       return ERR_PTR(error);
+ }
+ /*
+  * This code is common to all routines creating a new inode.
+  */
+ static int
+ smb_instantiate(struct dentry *dentry, __u16 fileid, int have_id)
+ {
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       struct inode *inode;
+       int error;
+       struct smb_fattr fattr;
+       VERBOSE("file %s/%s, fileid=%u\n", DENTRY_PATH(dentry), fileid);
+       error = smb_proc_getattr(dentry, &fattr);
+       if (error)
+               goto out_close;
+       smb_renew_times(dentry);
+       fattr.f_ino = iunique(dentry->d_sb, 2);
+       inode = smb_iget(dentry->d_sb, &fattr);
+       if (!inode)
+               goto out_no_inode;
+       if (have_id) {
+               struct smb_inode_info *ei = SMB_I(inode);
+               ei->fileid = fileid;
+               ei->access = SMB_O_RDWR;
+               ei->open = server->generation;
+       }
+       d_instantiate(dentry, inode);
+ out:
+       return error;
+ out_no_inode:
+       error = -EACCES;
+ out_close:
+       if (have_id) {
+               PARANOIA("%s/%s failed, error=%d, closing %u\n",
+                        DENTRY_PATH(dentry), error, fileid);
+               smb_close_fileid(dentry, fileid);
+       }
+       goto out;
+ }
+ /* N.B. How should the mode argument be used? */
+ static int
+ smb_create(struct inode *dir, struct dentry *dentry, int mode,
+               struct nameidata *nd)
+ {
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       __u16 fileid;
+       int error;
+       struct iattr attr;
+       VERBOSE("creating %s/%s, mode=%d\n", DENTRY_PATH(dentry), mode);
+       lock_kernel();
+       smb_invalid_dir_cache(dir);
+       error = smb_proc_create(dentry, 0, get_seconds(), &fileid);
+       if (!error) {
+               if (server->opt.capabilities & SMB_CAP_UNIX) {
+                       /* Set attributes for new file */
+                       attr.ia_valid = ATTR_MODE;
+                       attr.ia_mode = mode;
+                       error = smb_proc_setattr_unix(dentry, &attr, 0, 0);
+               }
+               error = smb_instantiate(dentry, fileid, 1);
+       } else {
+               PARANOIA("%s/%s failed, error=%d\n",
+                        DENTRY_PATH(dentry), error);
+       }
+       unlock_kernel();
+       return error;
+ }
+ /* N.B. How should the mode argument be used? */
+ static int
+ smb_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+ {
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       int error;
+       struct iattr attr;
+       lock_kernel();
+       smb_invalid_dir_cache(dir);
+       error = smb_proc_mkdir(dentry);
+       if (!error) {
+               if (server->opt.capabilities & SMB_CAP_UNIX) {
+                       /* Set attributes for new directory */
+                       attr.ia_valid = ATTR_MODE;
+                       attr.ia_mode = mode;
+                       error = smb_proc_setattr_unix(dentry, &attr, 0, 0);
+               }
+               error = smb_instantiate(dentry, 0, 0);
+       }
+       unlock_kernel();
+       return error;
+ }
+ static int
+ smb_rmdir(struct inode *dir, struct dentry *dentry)
+ {
+       struct inode *inode = dentry->d_inode;
+       int error;
+       /*
+        * Close the directory if it's open.
+        */
+       lock_kernel();
+       smb_close(inode);
+       /*
+        * Check that nobody else is using the directory..
+        */
+       error = -EBUSY;
+       if (!d_unhashed(dentry))
+               goto out;
+       smb_invalid_dir_cache(dir);
+       error = smb_proc_rmdir(dentry);
+ out:
+       unlock_kernel();
+       return error;
+ }
+ static int
+ smb_unlink(struct inode *dir, struct dentry *dentry)
+ {
+       int error;
+       /*
+        * Close the file if it's open.
+        */
+       lock_kernel();
+       smb_close(dentry->d_inode);
+       smb_invalid_dir_cache(dir);
+       error = smb_proc_unlink(dentry);
+       if (!error)
+               smb_renew_times(dentry);
+       unlock_kernel();
+       return error;
+ }
+ static int
+ smb_rename(struct inode *old_dir, struct dentry *old_dentry,
+          struct inode *new_dir, struct dentry *new_dentry)
+ {
+       int error;
+       /*
+        * Close any open files, and check whether to delete the
+        * target before attempting the rename.
+        */
+       lock_kernel();
+       if (old_dentry->d_inode)
+               smb_close(old_dentry->d_inode);
+       if (new_dentry->d_inode) {
+               smb_close(new_dentry->d_inode);
+               error = smb_proc_unlink(new_dentry);
+               if (error) {
+                       VERBOSE("unlink %s/%s, error=%d\n",
+                               DENTRY_PATH(new_dentry), error);
+                       goto out;
+               }
+               /* FIXME */
+               d_delete(new_dentry);
+       }
+       smb_invalid_dir_cache(old_dir);
+       smb_invalid_dir_cache(new_dir);
+       error = smb_proc_mv(old_dentry, new_dentry);
+       if (!error) {
+               smb_renew_times(old_dentry);
+               smb_renew_times(new_dentry);
+       }
+ out:
+       unlock_kernel();
+       return error;
+ }
+ /*
+  * FIXME: samba servers won't let you create device nodes unless uid/gid
+  * matches the connection credentials (and we don't know which those are ...)
+  */
+ static int
+ smb_make_node(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
+ {
+       int error;
+       struct iattr attr;
+       attr.ia_valid = ATTR_MODE | ATTR_UID | ATTR_GID;
+       attr.ia_mode = mode;
+       current_euid_egid(&attr.ia_uid, &attr.ia_gid);
+       if (!new_valid_dev(dev))
+               return -EINVAL;
+       smb_invalid_dir_cache(dir);
+       error = smb_proc_setattr_unix(dentry, &attr, MAJOR(dev), MINOR(dev));
+       if (!error) {
+               error = smb_instantiate(dentry, 0, 0);
+       }
+       return error;
+ }
+ /*
+  * dentry = existing file
+  * new_dentry = new file
+  */
+ static int
+ smb_link(struct dentry *dentry, struct inode *dir, struct dentry *new_dentry)
+ {
+       int error;
+       DEBUG1("smb_link old=%s/%s new=%s/%s\n",
+              DENTRY_PATH(dentry), DENTRY_PATH(new_dentry));
+       smb_invalid_dir_cache(dir);
+       error = smb_proc_link(server_from_dentry(dentry), dentry, new_dentry);
+       if (!error) {
+               smb_renew_times(dentry);
+               error = smb_instantiate(new_dentry, 0, 0);
+       }
+       return error;
+ }
index 0000000,9287599..552951a
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,839 +1,843 @@@
+ /*
+  *  inode.c
+  *
+  *  Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
+  *  Copyright (C) 1997 by Volker Lendecke
+  *
+  *  Please add a note about your changes to smbfs in the ChangeLog file.
+  */
+ #include <linux/module.h>
+ #include <linux/time.h>
+ #include <linux/kernel.h>
+ #include <linux/mm.h>
+ #include <linux/string.h>
+ #include <linux/stat.h>
+ #include <linux/errno.h>
+ #include <linux/slab.h>
+ #include <linux/init.h>
+ #include <linux/file.h>
+ #include <linux/dcache.h>
+ #include <linux/smp_lock.h>
+ #include <linux/nls.h>
+ #include <linux/seq_file.h>
+ #include <linux/mount.h>
+ #include <linux/net.h>
+ #include <linux/vfs.h>
+ #include <linux/highuid.h>
+ #include <linux/sched.h>
+ #include <asm/system.h>
+ #include <asm/uaccess.h>
+ #include "smb_fs.h"
+ #include "smbno.h"
+ #include "smb_mount.h"
+ #include "smb_debug.h"
+ #include "getopt.h"
+ #include "proto.h"
+ /* Always pick a default string */
+ #ifdef CONFIG_SMB_NLS_REMOTE
+ #define SMB_NLS_REMOTE CONFIG_SMB_NLS_REMOTE
+ #else
+ #define SMB_NLS_REMOTE ""
+ #endif
+ #define SMB_TTL_DEFAULT 1000
+ static void smb_evict_inode(struct inode *);
+ static void smb_put_super(struct super_block *);
+ static int  smb_statfs(struct dentry *, struct kstatfs *);
+ static int  smb_show_options(struct seq_file *, struct vfsmount *);
+ static struct kmem_cache *smb_inode_cachep;
+ static struct inode *smb_alloc_inode(struct super_block *sb)
+ {
+       struct smb_inode_info *ei;
+       ei = (struct smb_inode_info *)kmem_cache_alloc(smb_inode_cachep, GFP_KERNEL);
+       if (!ei)
+               return NULL;
+       return &ei->vfs_inode;
+ }
+ static void smb_destroy_inode(struct inode *inode)
+ {
+       kmem_cache_free(smb_inode_cachep, SMB_I(inode));
+ }
+ static void init_once(void *foo)
+ {
+       struct smb_inode_info *ei = (struct smb_inode_info *) foo;
+       inode_init_once(&ei->vfs_inode);
+ }
+ static int init_inodecache(void)
+ {
+       smb_inode_cachep = kmem_cache_create("smb_inode_cache",
+                                            sizeof(struct smb_inode_info),
+                                            0, (SLAB_RECLAIM_ACCOUNT|
+                                               SLAB_MEM_SPREAD),
+                                            init_once);
+       if (smb_inode_cachep == NULL)
+               return -ENOMEM;
+       return 0;
+ }
+ static void destroy_inodecache(void)
+ {
+       kmem_cache_destroy(smb_inode_cachep);
+ }
+ static int smb_remount(struct super_block *sb, int *flags, char *data)
+ {
+       *flags |= MS_NODIRATIME;
+       return 0;
+ }
+ static const struct super_operations smb_sops =
+ {
+       .alloc_inode    = smb_alloc_inode,
+       .destroy_inode  = smb_destroy_inode,
+       .drop_inode     = generic_delete_inode,
+       .evict_inode    = smb_evict_inode,
+       .put_super      = smb_put_super,
+       .statfs         = smb_statfs,
+       .show_options   = smb_show_options,
+       .remount_fs     = smb_remount,
+ };
+ /* We are always generating a new inode here */
+ struct inode *
+ smb_iget(struct super_block *sb, struct smb_fattr *fattr)
+ {
+       struct smb_sb_info *server = SMB_SB(sb);
+       struct inode *result;
+       DEBUG1("smb_iget: %p\n", fattr);
+       result = new_inode(sb);
+       if (!result)
+               return result;
+       result->i_ino = fattr->f_ino;
+       SMB_I(result)->open = 0;
+       SMB_I(result)->fileid = 0;
+       SMB_I(result)->access = 0;
+       SMB_I(result)->flags = 0;
+       SMB_I(result)->closed = 0;
+       SMB_I(result)->openers = 0;
+       smb_set_inode_attr(result, fattr);
+       if (S_ISREG(result->i_mode)) {
+               result->i_op = &smb_file_inode_operations;
+               result->i_fop = &smb_file_operations;
+               result->i_data.a_ops = &smb_file_aops;
+       } else if (S_ISDIR(result->i_mode)) {
+               if (server->opt.capabilities & SMB_CAP_UNIX)
+                       result->i_op = &smb_dir_inode_operations_unix;
+               else
+                       result->i_op = &smb_dir_inode_operations;
+               result->i_fop = &smb_dir_operations;
+       } else if (S_ISLNK(result->i_mode)) {
+               result->i_op = &smb_link_inode_operations;
+       } else {
+               init_special_inode(result, result->i_mode, fattr->f_rdev);
+       }
+       insert_inode_hash(result);
+       return result;
+ }
+ /*
+  * Copy the inode data to a smb_fattr structure.
+  */
+ void
+ smb_get_inode_attr(struct inode *inode, struct smb_fattr *fattr)
+ {
+       memset(fattr, 0, sizeof(struct smb_fattr));
+       fattr->f_mode   = inode->i_mode;
+       fattr->f_nlink  = inode->i_nlink;
+       fattr->f_ino    = inode->i_ino;
+       fattr->f_uid    = inode->i_uid;
+       fattr->f_gid    = inode->i_gid;
+       fattr->f_size   = inode->i_size;
+       fattr->f_mtime  = inode->i_mtime;
+       fattr->f_ctime  = inode->i_ctime;
+       fattr->f_atime  = inode->i_atime;
+       fattr->f_blocks = inode->i_blocks;
+       fattr->attr     = SMB_I(inode)->attr;
+       /*
+        * Keep the attributes in sync with the inode permissions.
+        */
+       if (fattr->f_mode & S_IWUSR)
+               fattr->attr &= ~aRONLY;
+       else
+               fattr->attr |= aRONLY;
+ }
+ /*
+  * Update the inode, possibly causing it to invalidate its pages if mtime/size
+  * is different from last time.
+  */
+ void
+ smb_set_inode_attr(struct inode *inode, struct smb_fattr *fattr)
+ {
+       struct smb_inode_info *ei = SMB_I(inode);
+       /*
+        * A size change should have a different mtime, or same mtime
+        * but different size.
+        */
+       time_t last_time = inode->i_mtime.tv_sec;
+       loff_t last_sz = inode->i_size;
+       inode->i_mode   = fattr->f_mode;
+       inode->i_nlink  = fattr->f_nlink;
+       inode->i_uid    = fattr->f_uid;
+       inode->i_gid    = fattr->f_gid;
+       inode->i_ctime  = fattr->f_ctime;
+       inode->i_blocks = fattr->f_blocks;
+       inode->i_size   = fattr->f_size;
+       inode->i_mtime  = fattr->f_mtime;
+       inode->i_atime  = fattr->f_atime;
+       ei->attr = fattr->attr;
+       /*
+        * Update the "last time refreshed" field for revalidation.
+        */
+       ei->oldmtime = jiffies;
+       if (inode->i_mtime.tv_sec != last_time || inode->i_size != last_sz) {
+               VERBOSE("%ld changed, old=%ld, new=%ld, oz=%ld, nz=%ld\n",
+                       inode->i_ino,
+                       (long) last_time, (long) inode->i_mtime.tv_sec,
+                       (long) last_sz, (long) inode->i_size);
+               if (!S_ISDIR(inode->i_mode))
+                       invalidate_remote_inode(inode);
+       }
+ }
+ /*
+  * This is called if the connection has gone bad ...
+  * try to kill off all the current inodes.
+  */
+ void
+ smb_invalidate_inodes(struct smb_sb_info *server)
+ {
+       VERBOSE("\n");
+       shrink_dcache_sb(SB_of(server));
 -      invalidate_inodes(SB_of(server));
+ }
+ /*
+  * This is called to update the inode attributes after
+  * we've made changes to a file or directory.
+  */
+ static int
+ smb_refresh_inode(struct dentry *dentry)
+ {
+       struct inode *inode = dentry->d_inode;
+       int error;
+       struct smb_fattr fattr;
+       error = smb_proc_getattr(dentry, &fattr);
+       if (!error) {
+               smb_renew_times(dentry);
+               /*
+                * Check whether the type part of the mode changed,
+                * and don't update the attributes if it did.
+                *
+                * And don't dick with the root inode
+                */
+               if (inode->i_ino == 2)
+                       return error;
+               if (S_ISLNK(inode->i_mode))
+                       return error;   /* VFS will deal with it */
+               if ((inode->i_mode & S_IFMT) == (fattr.f_mode & S_IFMT)) {
+                       smb_set_inode_attr(inode, &fattr);
+               } else {
+                       /*
+                        * Big trouble! The inode has become a new object,
+                        * so any operations attempted on it are invalid.
+                        *
+                        * To limit damage, mark the inode as bad so that
+                        * subsequent lookup validations will fail.
+                        */
+                       PARANOIA("%s/%s changed mode, %07o to %07o\n",
+                                DENTRY_PATH(dentry),
+                                inode->i_mode, fattr.f_mode);
+                       fattr.f_mode = inode->i_mode; /* save mode */
+                       make_bad_inode(inode);
+                       inode->i_mode = fattr.f_mode; /* restore mode */
+                       /*
+                        * No need to worry about unhashing the dentry: the
+                        * lookup validation will see that the inode is bad.
+                        * But we do want to invalidate the caches ...
+                        */
+                       if (!S_ISDIR(inode->i_mode))
+                               invalidate_remote_inode(inode);
+                       else
+                               smb_invalid_dir_cache(inode);
+                       error = -EIO;
+               }
+       }
+       return error;
+ }
+ /*
+  * This is called when we want to check whether the inode
+  * has changed on the server.  If it has changed, we must
+  * invalidate our local caches.
+  */
+ int
+ smb_revalidate_inode(struct dentry *dentry)
+ {
+       struct smb_sb_info *s = server_from_dentry(dentry);
+       struct inode *inode = dentry->d_inode;
+       int error = 0;
+       DEBUG1("smb_revalidate_inode\n");
+       lock_kernel();
+       /*
+        * Check whether we've recently refreshed the inode.
+        */
+       if (time_before(jiffies, SMB_I(inode)->oldmtime + SMB_MAX_AGE(s))) {
+               VERBOSE("up-to-date, ino=%ld, jiffies=%lu, oldtime=%lu\n",
+                       inode->i_ino, jiffies, SMB_I(inode)->oldmtime);
+               goto out;
+       }
+       error = smb_refresh_inode(dentry);
+ out:
+       unlock_kernel();
+       return error;
+ }
+ /*
+  * This routine is called when i_nlink == 0 and i_count goes to 0.
+  * All blocking cleanup operations need to go here to avoid races.
+  */
+ static void
+ smb_evict_inode(struct inode *ino)
+ {
+       DEBUG1("ino=%ld\n", ino->i_ino);
+       truncate_inode_pages(&ino->i_data, 0);
+       end_writeback(ino);
+       lock_kernel();
+       if (smb_close(ino))
+               PARANOIA("could not close inode %ld\n", ino->i_ino);
+       unlock_kernel();
+ }
+ static struct option opts[] = {
+       { "version",    0, 'v' },
+       { "win95",      SMB_MOUNT_WIN95, 1 },
+       { "oldattr",    SMB_MOUNT_OLDATTR, 1 },
+       { "dirattr",    SMB_MOUNT_DIRATTR, 1 },
+       { "case",       SMB_MOUNT_CASE, 1 },
+       { "uid",        0, 'u' },
+       { "gid",        0, 'g' },
+       { "file_mode",  0, 'f' },
+       { "dir_mode",   0, 'd' },
+       { "iocharset",  0, 'i' },
+       { "codepage",   0, 'c' },
+       { "ttl",        0, 't' },
+       { NULL,         0, 0}
+ };
+ static int
+ parse_options(struct smb_mount_data_kernel *mnt, char *options)
+ {
+       int c;
+       unsigned long flags;
+       unsigned long value;
+       char *optarg;
+       char *optopt;
+       flags = 0;
+       while ( (c = smb_getopt("smbfs", &options, opts,
+                               &optopt, &optarg, &flags, &value)) > 0) {
+               VERBOSE("'%s' -> '%s'\n", optopt, optarg ? optarg : "<none>");
+               switch (c) {
+               case 1:
+                       /* got a "flag" option */
+                       break;
+               case 'v':
+                       if (value != SMB_MOUNT_VERSION) {
+                       printk ("smbfs: Bad mount version %ld, expected %d\n",
+                               value, SMB_MOUNT_VERSION);
+                               return 0;
+                       }
+                       mnt->version = value;
+                       break;
+               case 'u':
+                       mnt->uid = value;
+                       flags |= SMB_MOUNT_UID;
+                       break;
+               case 'g':
+                       mnt->gid = value;
+                       flags |= SMB_MOUNT_GID;
+                       break;
+               case 'f':
+                       mnt->file_mode = (value & S_IRWXUGO) | S_IFREG;
+                       flags |= SMB_MOUNT_FMODE;
+                       break;
+               case 'd':
+                       mnt->dir_mode = (value & S_IRWXUGO) | S_IFDIR;
+                       flags |= SMB_MOUNT_DMODE;
+                       break;
+               case 'i':
+                       strlcpy(mnt->codepage.local_name, optarg, 
+                               SMB_NLS_MAXNAMELEN);
+                       break;
+               case 'c':
+                       strlcpy(mnt->codepage.remote_name, optarg,
+                               SMB_NLS_MAXNAMELEN);
+                       break;
+               case 't':
+                       mnt->ttl = value;
+                       break;
+               default:
+                       printk ("smbfs: Unrecognized mount option %s\n",
+                               optopt);
+                       return -1;
+               }
+       }
+       mnt->flags = flags;
+       return c;
+ }
+ /*
+  * smb_show_options() is for displaying mount options in /proc/mounts.
+  * It tries to avoid showing settings that were not changed from their
+  * defaults.
+  */
+ static int
+ smb_show_options(struct seq_file *s, struct vfsmount *m)
+ {
+       struct smb_mount_data_kernel *mnt = SMB_SB(m->mnt_sb)->mnt;
+       int i;
+       for (i = 0; opts[i].name != NULL; i++)
+               if (mnt->flags & opts[i].flag)
+                       seq_printf(s, ",%s", opts[i].name);
+       if (mnt->flags & SMB_MOUNT_UID)
+               seq_printf(s, ",uid=%d", mnt->uid);
+       if (mnt->flags & SMB_MOUNT_GID)
+               seq_printf(s, ",gid=%d", mnt->gid);
+       if (mnt->mounted_uid != 0)
+               seq_printf(s, ",mounted_uid=%d", mnt->mounted_uid);
+       /* 
+        * Defaults for file_mode and dir_mode are unknown to us; they
+        * depend on the current umask of the user doing the mount.
+        */
+       if (mnt->flags & SMB_MOUNT_FMODE)
+               seq_printf(s, ",file_mode=%04o", mnt->file_mode & S_IRWXUGO);
+       if (mnt->flags & SMB_MOUNT_DMODE)
+               seq_printf(s, ",dir_mode=%04o", mnt->dir_mode & S_IRWXUGO);
+       if (strcmp(mnt->codepage.local_name, CONFIG_NLS_DEFAULT))
+               seq_printf(s, ",iocharset=%s", mnt->codepage.local_name);
+       if (strcmp(mnt->codepage.remote_name, SMB_NLS_REMOTE))
+               seq_printf(s, ",codepage=%s", mnt->codepage.remote_name);
+       if (mnt->ttl != SMB_TTL_DEFAULT)
+               seq_printf(s, ",ttl=%d", mnt->ttl);
+       return 0;
+ }
+ static void
+ smb_unload_nls(struct smb_sb_info *server)
+ {
+       unload_nls(server->remote_nls);
+       unload_nls(server->local_nls);
+ }
+ static void
+ smb_put_super(struct super_block *sb)
+ {
+       struct smb_sb_info *server = SMB_SB(sb);
+       lock_kernel();
+       smb_lock_server(server);
+       server->state = CONN_INVALID;
+       smbiod_unregister_server(server);
+       smb_close_socket(server);
+       if (server->conn_pid)
+               kill_pid(server->conn_pid, SIGTERM, 1);
+       bdi_destroy(&server->bdi);
+       kfree(server->ops);
+       smb_unload_nls(server);
+       sb->s_fs_info = NULL;
+       smb_unlock_server(server);
+       put_pid(server->conn_pid);
+       kfree(server);
+       unlock_kernel();
+ }
+ static int smb_fill_super(struct super_block *sb, void *raw_data, int silent)
+ {
+       struct smb_sb_info *server;
+       struct smb_mount_data_kernel *mnt;
+       struct smb_mount_data *oldmnt;
+       struct inode *root_inode;
+       struct smb_fattr root;
+       int ver;
+       void *mem;
+       static int warn_count;
++      lock_kernel();
++
+       if (warn_count < 5) {
+               warn_count++;
+               printk(KERN_EMERG "smbfs is deprecated and will be removed"
+                       " from the 2.6.37 kernel. Please migrate to cifs\n");
+       }
+       if (!raw_data)
+               goto out_no_data;
+       oldmnt = (struct smb_mount_data *) raw_data;
+       ver = oldmnt->version;
+       if (ver != SMB_MOUNT_OLDVERSION && cpu_to_be32(ver) != SMB_MOUNT_ASCII)
+               goto out_wrong_data;
+       sb->s_flags |= MS_NODIRATIME;
+       sb->s_blocksize = 1024; /* Eh...  Is this correct? */
+       sb->s_blocksize_bits = 10;
+       sb->s_magic = SMB_SUPER_MAGIC;
+       sb->s_op = &smb_sops;
+       sb->s_time_gran = 100;
+       server = kzalloc(sizeof(struct smb_sb_info), GFP_KERNEL);
+       if (!server)
+               goto out_no_server;
+       sb->s_fs_info = server;
+       
+       if (bdi_setup_and_register(&server->bdi, "smbfs", BDI_CAP_MAP_COPY))
+               goto out_bdi;
+       sb->s_bdi = &server->bdi;
+       server->super_block = sb;
+       server->mnt = NULL;
+       server->sock_file = NULL;
+       init_waitqueue_head(&server->conn_wq);
+       init_MUTEX(&server->sem);
+       INIT_LIST_HEAD(&server->entry);
+       INIT_LIST_HEAD(&server->xmitq);
+       INIT_LIST_HEAD(&server->recvq);
+       server->conn_error = 0;
+       server->conn_pid = NULL;
+       server->state = CONN_INVALID; /* no connection yet */
+       server->generation = 0;
+       /* Allocate the global temp buffer and some superblock helper structs */
+       /* FIXME: move these to the smb_sb_info struct */
+       VERBOSE("alloc chunk = %lu\n", sizeof(struct smb_ops) +
+               sizeof(struct smb_mount_data_kernel));
+       mem = kmalloc(sizeof(struct smb_ops) +
+                     sizeof(struct smb_mount_data_kernel), GFP_KERNEL);
+       if (!mem)
+               goto out_no_mem;
+       server->ops = mem;
+       smb_install_null_ops(server->ops);
+       server->mnt = mem + sizeof(struct smb_ops);
+       /* Setup NLS stuff */
+       server->remote_nls = NULL;
+       server->local_nls = NULL;
+       mnt = server->mnt;
+       memset(mnt, 0, sizeof(struct smb_mount_data_kernel));
+       strlcpy(mnt->codepage.local_name, CONFIG_NLS_DEFAULT,
+               SMB_NLS_MAXNAMELEN);
+       strlcpy(mnt->codepage.remote_name, SMB_NLS_REMOTE,
+               SMB_NLS_MAXNAMELEN);
+       mnt->ttl = SMB_TTL_DEFAULT;
+       if (ver == SMB_MOUNT_OLDVERSION) {
+               mnt->version = oldmnt->version;
+               SET_UID(mnt->uid, oldmnt->uid);
+               SET_GID(mnt->gid, oldmnt->gid);
+               mnt->file_mode = (oldmnt->file_mode & S_IRWXUGO) | S_IFREG;
+               mnt->dir_mode = (oldmnt->dir_mode & S_IRWXUGO) | S_IFDIR;
+               mnt->flags = (oldmnt->file_mode >> 9) | SMB_MOUNT_UID |
+                       SMB_MOUNT_GID | SMB_MOUNT_FMODE | SMB_MOUNT_DMODE;
+       } else {
+               mnt->file_mode = S_IRWXU | S_IRGRP | S_IXGRP |
+                               S_IROTH | S_IXOTH | S_IFREG;
+               mnt->dir_mode = S_IRWXU | S_IRGRP | S_IXGRP |
+                               S_IROTH | S_IXOTH | S_IFDIR;
+               if (parse_options(mnt, raw_data))
+                       goto out_bad_option;
+       }
+       mnt->mounted_uid = current_uid();
+       smb_setcodepage(server, &mnt->codepage);
+       /*
+        * Display the enabled options
+        * Note: smb_proc_getattr uses these in 2.4 (but was changed in 2.2)
+        */
+       if (mnt->flags & SMB_MOUNT_OLDATTR)
+               printk("SMBFS: Using core getattr (Win 95 speedup)\n");
+       else if (mnt->flags & SMB_MOUNT_DIRATTR)
+               printk("SMBFS: Using dir ff getattr\n");
+       if (smbiod_register_server(server) < 0) {
+               printk(KERN_ERR "smbfs: failed to start smbiod\n");
+               goto out_no_smbiod;
+       }
+       /*
+        * Keep the super block locked while we get the root inode.
+        */
+       smb_init_root_dirent(server, &root, sb);
+       root_inode = smb_iget(sb, &root);
+       if (!root_inode)
+               goto out_no_root;
+       sb->s_root = d_alloc_root(root_inode);
+       if (!sb->s_root)
+               goto out_no_root;
+       smb_new_dentry(sb->s_root);
++      unlock_kernel();
+       return 0;
+ out_no_root:
+       iput(root_inode);
+ out_no_smbiod:
+       smb_unload_nls(server);
+ out_bad_option:
+       kfree(mem);
+ out_no_mem:
+       bdi_destroy(&server->bdi);
+ out_bdi:
+       if (!server->mnt)
+               printk(KERN_ERR "smb_fill_super: allocation failure\n");
+       sb->s_fs_info = NULL;
+       kfree(server);
+       goto out_fail;
+ out_wrong_data:
+       printk(KERN_ERR "smbfs: mount_data version %d is not supported\n", ver);
+       goto out_fail;
+ out_no_data:
+       printk(KERN_ERR "smb_fill_super: missing data argument\n");
+ out_fail:
++      unlock_kernel();
+       return -EINVAL;
+ out_no_server:
+       printk(KERN_ERR "smb_fill_super: cannot allocate struct smb_sb_info\n");
++      unlock_kernel();
+       return -ENOMEM;
+ }
+ static int
+ smb_statfs(struct dentry *dentry, struct kstatfs *buf)
+ {
+       int result;
+       
+       lock_kernel();
+       result = smb_proc_dskattr(dentry, buf);
+       unlock_kernel();
+       buf->f_type = SMB_SUPER_MAGIC;
+       buf->f_namelen = SMB_MAXPATHLEN;
+       return result;
+ }
+ int smb_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
+ {
+       int err = smb_revalidate_inode(dentry);
+       if (!err)
+               generic_fillattr(dentry->d_inode, stat);
+       return err;
+ }
+ int
+ smb_notify_change(struct dentry *dentry, struct iattr *attr)
+ {
+       struct inode *inode = dentry->d_inode;
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       unsigned int mask = (S_IFREG | S_IFDIR | S_IRWXUGO);
+       int error, changed, refresh = 0;
+       struct smb_fattr fattr;
+       lock_kernel();
+       error = smb_revalidate_inode(dentry);
+       if (error)
+               goto out;
+       if ((error = inode_change_ok(inode, attr)) < 0)
+               goto out;
+       error = -EPERM;
+       if ((attr->ia_valid & ATTR_UID) && (attr->ia_uid != server->mnt->uid))
+               goto out;
+       if ((attr->ia_valid & ATTR_GID) && (attr->ia_uid != server->mnt->gid))
+               goto out;
+       if ((attr->ia_valid & ATTR_MODE) && (attr->ia_mode & ~mask))
+               goto out;
+       if ((attr->ia_valid & ATTR_SIZE) != 0) {
+               VERBOSE("changing %s/%s, old size=%ld, new size=%ld\n",
+                       DENTRY_PATH(dentry),
+                       (long) inode->i_size, (long) attr->ia_size);
+               filemap_write_and_wait(inode->i_mapping);
+               error = smb_open(dentry, O_WRONLY);
+               if (error)
+                       goto out;
+               error = server->ops->truncate(inode, attr->ia_size);
+               if (error)
+                       goto out;
+               truncate_setsize(inode, attr->ia_size);
+               refresh = 1;
+       }
+       if (server->opt.capabilities & SMB_CAP_UNIX) {
+               /* For now we don't want to set the size with setattr_unix */
+               attr->ia_valid &= ~ATTR_SIZE;
+               /* FIXME: only call if we actually want to set something? */
+               error = smb_proc_setattr_unix(dentry, attr, 0, 0);
+               if (!error)
+                       refresh = 1;
+               goto out;
+       }
+       /*
+        * Initialize the fattr and check for changed fields.
+        * Note: CTIME under SMB is creation time rather than
+        * change time, so we don't attempt to change it.
+        */
+       smb_get_inode_attr(inode, &fattr);
+       changed = 0;
+       if ((attr->ia_valid & ATTR_MTIME) != 0) {
+               fattr.f_mtime = attr->ia_mtime;
+               changed = 1;
+       }
+       if ((attr->ia_valid & ATTR_ATIME) != 0) {
+               fattr.f_atime = attr->ia_atime;
+               /* Earlier protocols don't have an access time */
+               if (server->opt.protocol >= SMB_PROTOCOL_LANMAN2)
+                       changed = 1;
+       }
+       if (changed) {
+               error = smb_proc_settime(dentry, &fattr);
+               if (error)
+                       goto out;
+               refresh = 1;
+       }
+       /*
+        * Check for mode changes ... we're extremely limited in
+        * what can be set for SMB servers: just the read-only bit.
+        */
+       if ((attr->ia_valid & ATTR_MODE) != 0) {
+               VERBOSE("%s/%s mode change, old=%x, new=%x\n",
+                       DENTRY_PATH(dentry), fattr.f_mode, attr->ia_mode);
+               changed = 0;
+               if (attr->ia_mode & S_IWUSR) {
+                       if (fattr.attr & aRONLY) {
+                               fattr.attr &= ~aRONLY;
+                               changed = 1;
+                       }
+               } else {
+                       if (!(fattr.attr & aRONLY)) {
+                               fattr.attr |= aRONLY;
+                               changed = 1;
+                       }
+               }
+               if (changed) {
+                       error = smb_proc_setattr(dentry, &fattr);
+                       if (error)
+                               goto out;
+                       refresh = 1;
+               }
+       }
+       error = 0;
+ out:
+       if (refresh)
+               smb_refresh_inode(dentry);
+       unlock_kernel();
+       return error;
+ }
+ static int smb_get_sb(struct file_system_type *fs_type,
+       int flags, const char *dev_name, void *data, struct vfsmount *mnt)
+ {
+       return get_sb_nodev(fs_type, flags, data, smb_fill_super, mnt);
+ }
+ static struct file_system_type smb_fs_type = {
+       .owner          = THIS_MODULE,
+       .name           = "smbfs",
+       .get_sb         = smb_get_sb,
+       .kill_sb        = kill_anon_super,
+       .fs_flags       = FS_BINARY_MOUNTDATA,
+ };
+ static int __init init_smb_fs(void)
+ {
+       int err;
+       DEBUG1("registering ...\n");
+       err = init_inodecache();
+       if (err)
+               goto out_inode;
+       err = smb_init_request_cache();
+       if (err)
+               goto out_request;
+       err = register_filesystem(&smb_fs_type);
+       if (err)
+               goto out;
+       return 0;
+ out:
+       smb_destroy_request_cache();
+ out_request:
+       destroy_inodecache();
+ out_inode:
+       return err;
+ }
+ static void __exit exit_smb_fs(void)
+ {
+       DEBUG1("unregistering ...\n");
+       unregister_filesystem(&smb_fs_type);
+       smb_destroy_request_cache();
+       destroy_inodecache();
+ }
+ module_init(init_smb_fs)
+ module_exit(exit_smb_fs)
+ MODULE_LICENSE("GPL");
index 0000000,2fb079c..ba37b1f
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,3506 +1,3502 @@@
+ /*
+  *  proc.c
+  *
+  *  Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
+  *  Copyright (C) 1997 by Volker Lendecke
+  *
+  *  Please add a note about your changes to smbfs in the ChangeLog file.
+  */
+ #include <linux/types.h>
+ #include <linux/capability.h>
+ #include <linux/errno.h>
+ #include <linux/slab.h>
+ #include <linux/fs.h>
+ #include <linux/file.h>
+ #include <linux/stat.h>
+ #include <linux/fcntl.h>
+ #include <linux/dcache.h>
+ #include <linux/nls.h>
+ #include <linux/smp_lock.h>
+ #include <linux/net.h>
+ #include <linux/vfs.h>
+ #include <net/sock.h>
+ #include <asm/string.h>
+ #include <asm/div64.h>
+ #include "smb_fs.h"
+ #include "smbno.h"
+ #include "smb_mount.h"
+ #include "smb_debug.h"
+ #include "proto.h"
+ #include "request.h"
+ /* Features. Undefine if they cause problems, this should perhaps be a
+    config option. */
+ #define SMBFS_POSIX_UNLINK 1
+ /* Allow smb_retry to be interrupted. */
+ #define SMB_RETRY_INTR
+ #define SMB_VWV(packet)  ((packet) + SMB_HEADER_LEN)
+ #define SMB_CMD(packet)  (*(packet+8))
+ #define SMB_WCT(packet)  (*(packet+SMB_HEADER_LEN - 1))
+ #define SMB_DIRINFO_SIZE 43
+ #define SMB_STATUS_SIZE  21
+ #define SMB_ST_BLKSIZE        (PAGE_SIZE)
+ #define SMB_ST_BLKSHIFT       (PAGE_SHIFT)
+ static struct smb_ops smb_ops_core;
+ static struct smb_ops smb_ops_os2;
+ static struct smb_ops smb_ops_win95;
+ static struct smb_ops smb_ops_winNT;
+ static struct smb_ops smb_ops_unix;
+ static struct smb_ops smb_ops_null;
+ static void
+ smb_init_dirent(struct smb_sb_info *server, struct smb_fattr *fattr);
+ static void
+ smb_finish_dirent(struct smb_sb_info *server, struct smb_fattr *fattr);
+ static int
+ smb_proc_getattr_core(struct smb_sb_info *server, struct dentry *dir,
+                     struct smb_fattr *fattr);
+ static int
+ smb_proc_getattr_ff(struct smb_sb_info *server, struct dentry *dentry,
+                   struct smb_fattr *fattr);
+ static int
+ smb_proc_setattr_core(struct smb_sb_info *server, struct dentry *dentry,
+                     u16 attr);
+ static int
+ smb_proc_setattr_ext(struct smb_sb_info *server,
+                    struct inode *inode, struct smb_fattr *fattr);
+ static int
+ smb_proc_query_cifsunix(struct smb_sb_info *server);
+ static void
+ install_ops(struct smb_ops *dst, struct smb_ops *src);
+ static void
+ str_upper(char *name, int len)
+ {
+       while (len--)
+       {
+               if (*name >= 'a' && *name <= 'z')
+                       *name -= ('a' - 'A');
+               name++;
+       }
+ }
+ #if 0
+ static void
+ str_lower(char *name, int len)
+ {
+       while (len--)
+       {
+               if (*name >= 'A' && *name <= 'Z')
+                       *name += ('a' - 'A');
+               name++;
+       }
+ }
+ #endif
+ /* reverse a string inline. This is used by the dircache walking routines */
+ static void reverse_string(char *buf, int len)
+ {
+       char c;
+       char *end = buf+len-1;
+       while(buf < end) {
+               c = *buf;
+               *(buf++) = *end;
+               *(end--) = c;
+       }
+ }
+ /* no conversion, just a wrapper for memcpy. */
+ static int convert_memcpy(unsigned char *output, int olen,
+                         const unsigned char *input, int ilen,
+                         struct nls_table *nls_from,
+                         struct nls_table *nls_to)
+ {
+       if (olen < ilen)
+               return -ENAMETOOLONG;
+       memcpy(output, input, ilen);
+       return ilen;
+ }
+ static inline int write_char(unsigned char ch, char *output, int olen)
+ {
+       if (olen < 4)
+               return -ENAMETOOLONG;
+       sprintf(output, ":x%02x", ch);
+       return 4;
+ }
+ static inline int write_unichar(wchar_t ch, char *output, int olen)
+ {
+       if (olen < 5)
+               return -ENAMETOOLONG;
+       sprintf(output, ":%04x", ch);
+       return 5;
+ }
+ /* convert from one "codepage" to another (possibly being utf8). */
+ static int convert_cp(unsigned char *output, int olen,
+                     const unsigned char *input, int ilen,
+                     struct nls_table *nls_from,
+                     struct nls_table *nls_to)
+ {
+       int len = 0;
+       int n;
+       wchar_t ch;
+       while (ilen > 0) {
+               /* convert by changing to unicode and back to the new cp */
+               n = nls_from->char2uni(input, ilen, &ch);
+               if (n == -EINVAL) {
+                       ilen--;
+                       n = write_char(*input++, output, olen);
+                       if (n < 0)
+                               goto fail;
+                       output += n;
+                       olen -= n;
+                       len += n;
+                       continue;
+               } else if (n < 0)
+                       goto fail;
+               input += n;
+               ilen -= n;
+               n = nls_to->uni2char(ch, output, olen);
+               if (n == -EINVAL)
+                       n = write_unichar(ch, output, olen);
+               if (n < 0)
+                       goto fail;
+               output += n;
+               olen -= n;
+               len += n;
+       }
+       return len;
+ fail:
+       return n;
+ }
+ /* ----------------------------------------------------------- */
+ /*
+  * nls_unicode
+  *
+  * This encodes/decodes little endian unicode format
+  */
+ static int uni2char(wchar_t uni, unsigned char *out, int boundlen)
+ {
+       if (boundlen < 2)
+               return -EINVAL;
+       *out++ = uni & 0xff;
+       *out++ = uni >> 8;
+       return 2;
+ }
+ static int char2uni(const unsigned char *rawstring, int boundlen, wchar_t *uni)
+ {
+       if (boundlen < 2)
+               return -EINVAL;
+       *uni = (rawstring[1] << 8) | rawstring[0];
+       return 2;
+ }
+ static struct nls_table unicode_table = {
+       .charset        = "unicode",
+       .uni2char       = uni2char,
+       .char2uni       = char2uni,
+ };
+ /* ----------------------------------------------------------- */
+ static int setcodepage(struct nls_table **p, char *name)
+ {
+       struct nls_table *nls;
+       if (!name || !*name) {
+               nls = NULL;
+       } else if ( (nls = load_nls(name)) == NULL) {
+               printk (KERN_ERR "smbfs: failed to load nls '%s'\n", name);
+               return -EINVAL;
+       }
+       /* if already set, unload the previous one. */
+       if (*p && *p != &unicode_table)
+               unload_nls(*p);
+       *p = nls;
+       return 0;
+ }
+ /* Handles all changes to codepage settings. */
+ int smb_setcodepage(struct smb_sb_info *server, struct smb_nls_codepage *cp)
+ {
+       int n = 0;
+       smb_lock_server(server);
+       /* Don't load any nls_* at all, if no remote is requested */
+       if (!*cp->remote_name)
+               goto out;
+       /* local */
+       n = setcodepage(&server->local_nls, cp->local_name);
+       if (n != 0)
+               goto out;
+       /* remote */
+       if (!strcmp(cp->remote_name, "unicode")) {
+               server->remote_nls = &unicode_table;
+       } else {
+               n = setcodepage(&server->remote_nls, cp->remote_name);
+               if (n != 0)
+                       setcodepage(&server->local_nls, NULL);
+       }
+ out:
+       if (server->local_nls != NULL && server->remote_nls != NULL)
+               server->ops->convert = convert_cp;
+       else
+               server->ops->convert = convert_memcpy;
+       smb_unlock_server(server);
+       return n;
+ }
+ /*****************************************************************************/
+ /*                                                                           */
+ /*  Encoding/Decoding section                                                */
+ /*                                                                           */
+ /*****************************************************************************/
+ static __u8 *
+ smb_encode_smb_length(__u8 * p, __u32 len)
+ {
+       *p = 0;
+       *(p+1) = 0;
+       *(p+2) = (len & 0xFF00) >> 8;
+       *(p+3) = (len & 0xFF);
+       if (len > 0xFFFF)
+       {
+               *(p+1) = 1;
+       }
+       return p + 4;
+ }
+ /*
+  * smb_build_path: build the path to entry and name storing it in buf.
+  * The path returned will have the trailing '\0'.
+  */
+ static int smb_build_path(struct smb_sb_info *server, unsigned char *buf,
+                         int maxlen,
+                         struct dentry *entry, struct qstr *name)
+ {
+       unsigned char *path = buf;
+       int len;
+       int unicode = (server->mnt->flags & SMB_MOUNT_UNICODE) != 0;
+       if (maxlen < (2<<unicode))
+               return -ENAMETOOLONG;
+       if (maxlen > SMB_MAXPATHLEN + 1)
+               maxlen = SMB_MAXPATHLEN + 1;
+       if (entry == NULL)
+               goto test_name_and_out;
+       /*
+        * If IS_ROOT, we have to do no walking at all.
+        */
+       if (IS_ROOT(entry) && !name) {
+               *path++ = '\\';
+               if (unicode) *path++ = '\0';
+               *path++ = '\0';
+               if (unicode) *path++ = '\0';
+               return path-buf;
+       }
+       /*
+        * Build the path string walking the tree backward from end to ROOT
+        * and store it in reversed order [see reverse_string()]
+        */
+       dget(entry);
 -      spin_lock(&entry->d_lock);
+       while (!IS_ROOT(entry)) {
+               struct dentry *parent;
+               if (maxlen < (3<<unicode)) {
 -                      spin_unlock(&entry->d_lock);
+                       dput(entry);
+                       return -ENAMETOOLONG;
+               }
++              spin_lock(&entry->d_lock);
+               len = server->ops->convert(path, maxlen-2, 
+                                     entry->d_name.name, entry->d_name.len,
+                                     server->local_nls, server->remote_nls);
+               if (len < 0) {
+                       spin_unlock(&entry->d_lock);
+                       dput(entry);
+                       return len;
+               }
+               reverse_string(path, len);
+               path += len;
+               if (unicode) {
+                       /* Note: reverse order */
+                       *path++ = '\0';
+                       maxlen--;
+               }
+               *path++ = '\\';
+               maxlen -= len+1;
 -
 -              parent = entry->d_parent;
 -              dget(parent);
+               spin_unlock(&entry->d_lock);
++
++              parent = dget_parent(entry);
+               dput(entry);
+               entry = parent;
 -              spin_lock(&entry->d_lock);
+       }
 -      spin_unlock(&entry->d_lock);
+       dput(entry);
+       reverse_string(buf, path-buf);
+       /* maxlen has space for at least one char */
+ test_name_and_out:
+       if (name) {
+               if (maxlen < (3<<unicode))
+                       return -ENAMETOOLONG;
+               *path++ = '\\';
+               if (unicode) {
+                       *path++ = '\0';
+                       maxlen--;
+               }
+               len = server->ops->convert(path, maxlen-2, 
+                                     name->name, name->len,
+                                     server->local_nls, server->remote_nls);
+               if (len < 0)
+                       return len;
+               path += len;
+               maxlen -= len+1;
+       }
+       /* maxlen has space for at least one char */
+       *path++ = '\0';
+       if (unicode) *path++ = '\0';
+       return path-buf;
+ }
+ static int smb_encode_path(struct smb_sb_info *server, char *buf, int maxlen,
+                          struct dentry *dir, struct qstr *name)
+ {
+       int result;
+       result = smb_build_path(server, buf, maxlen, dir, name);
+       if (result < 0)
+               goto out;
+       if (server->opt.protocol <= SMB_PROTOCOL_COREPLUS)
+               str_upper(buf, result);
+ out:
+       return result;
+ }
+ /* encode_path for non-trans2 request SMBs */
+ static int smb_simple_encode_path(struct smb_request *req, char **p,
+                                 struct dentry * entry, struct qstr * name)
+ {
+       struct smb_sb_info *server = req->rq_server;
+       char *s = *p;
+       int res;
+       int maxlen = ((char *)req->rq_buffer + req->rq_bufsize) - s;
+       int unicode = (server->mnt->flags & SMB_MOUNT_UNICODE);
+       if (!maxlen)
+               return -ENAMETOOLONG;
+       *s++ = 4;       /* ASCII data format */
+       /*
+        * SMB Unicode strings must be 16bit aligned relative the start of the
+        * packet. If they are not they must be padded with 0.
+        */
+       if (unicode) {
+               int align = s - (char *)req->rq_buffer;
+               if (!(align & 1)) {
+                       *s++ = '\0';
+                       maxlen--;
+               }
+       }
+       res = smb_encode_path(server, s, maxlen-1, entry, name);
+       if (res < 0)
+               return res;
+       *p = s + res;
+       return 0;
+ }
+ /* The following are taken directly from msdos-fs */
+ /* Linear day numbers of the respective 1sts in non-leap years. */
+ static int day_n[] =
+ {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0, 0};
+                 /* JanFebMarApr May Jun Jul Aug Sep Oct Nov Dec */
+ static time_t
+ utc2local(struct smb_sb_info *server, time_t time)
+ {
+       return time - server->opt.serverzone*60;
+ }
+ static time_t
+ local2utc(struct smb_sb_info *server, time_t time)
+ {
+       return time + server->opt.serverzone*60;
+ }
+ /* Convert a MS-DOS time/date pair to a UNIX date (seconds since 1 1 70). */
+ static time_t
+ date_dos2unix(struct smb_sb_info *server, __u16 date, __u16 time)
+ {
+       int month, year;
+       time_t secs;
+       /* first subtract and mask after that... Otherwise, if
+          date == 0, bad things happen */
+       month = ((date >> 5) - 1) & 15;
+       year = date >> 9;
+       secs = (time & 31) * 2 + 60 * ((time >> 5) & 63) + (time >> 11) * 3600 + 86400 *
+           ((date & 31) - 1 + day_n[month] + (year / 4) + year * 365 - ((year & 3) == 0 &&
+                                                  month < 2 ? 1 : 0) + 3653);
+       /* days since 1.1.70 plus 80's leap day */
+       return local2utc(server, secs);
+ }
+ /* Convert linear UNIX date to a MS-DOS time/date pair. */
+ static void
+ date_unix2dos(struct smb_sb_info *server,
+             int unix_date, __u16 *date, __u16 *time)
+ {
+       int day, year, nl_day, month;
+       unix_date = utc2local(server, unix_date);
+       if (unix_date < 315532800)
+               unix_date = 315532800;
+       *time = (unix_date % 60) / 2 +
+               (((unix_date / 60) % 60) << 5) +
+               (((unix_date / 3600) % 24) << 11);
+       day = unix_date / 86400 - 3652;
+       year = day / 365;
+       if ((year + 3) / 4 + 365 * year > day)
+               year--;
+       day -= (year + 3) / 4 + 365 * year;
+       if (day == 59 && !(year & 3)) {
+               nl_day = day;
+               month = 2;
+       } else {
+               nl_day = (year & 3) || day <= 59 ? day : day - 1;
+               for (month = 1; month < 12; month++)
+                       if (day_n[month] > nl_day)
+                               break;
+       }
+       *date = nl_day - day_n[month - 1] + 1 + (month << 5) + (year << 9);
+ }
+ /* The following are taken from fs/ntfs/util.c */
+ #define NTFS_TIME_OFFSET ((u64)(369*365 + 89) * 24 * 3600 * 10000000)
+ /*
+  * Convert the NT UTC (based 1601-01-01, in hundred nanosecond units)
+  * into Unix UTC (based 1970-01-01, in seconds).
+  */
+ static struct timespec
+ smb_ntutc2unixutc(u64 ntutc)
+ {
+       struct timespec ts;
+       /* FIXME: what about the timezone difference? */
+       /* Subtract the NTFS time offset, then convert to 1s intervals. */
+       u64 t = ntutc - NTFS_TIME_OFFSET;
+       ts.tv_nsec = do_div(t, 10000000) * 100;
+       ts.tv_sec = t; 
+       return ts;
+ }
+ /* Convert the Unix UTC into NT time */
+ static u64
+ smb_unixutc2ntutc(struct timespec ts)
+ {
+       /* Note: timezone conversion is probably wrong. */
+       /* return ((u64)utc2local(server, t)) * 10000000 + NTFS_TIME_OFFSET; */
+       return ((u64)ts.tv_sec) * 10000000 + ts.tv_nsec/100 + NTFS_TIME_OFFSET;
+ }
+ #define MAX_FILE_MODE 6
+ static mode_t file_mode[] = {
+       S_IFREG, S_IFDIR, S_IFLNK, S_IFCHR, S_IFBLK, S_IFIFO, S_IFSOCK
+ };
+ static int smb_filetype_to_mode(u32 filetype)
+ {
+       if (filetype > MAX_FILE_MODE) {
+               PARANOIA("Filetype out of range: %d\n", filetype);
+               return S_IFREG;
+       }
+       return file_mode[filetype];
+ }
+ static u32 smb_filetype_from_mode(int mode)
+ {
+       if (S_ISREG(mode))
+               return UNIX_TYPE_FILE;
+       if (S_ISDIR(mode))
+               return UNIX_TYPE_DIR;
+       if (S_ISLNK(mode))
+               return UNIX_TYPE_SYMLINK;
+       if (S_ISCHR(mode))
+               return UNIX_TYPE_CHARDEV;
+       if (S_ISBLK(mode))
+               return UNIX_TYPE_BLKDEV;
+       if (S_ISFIFO(mode))
+               return UNIX_TYPE_FIFO;
+       if (S_ISSOCK(mode))
+               return UNIX_TYPE_SOCKET;
+       return UNIX_TYPE_UNKNOWN;
+ }
+ /*****************************************************************************/
+ /*                                                                           */
+ /*  Support section.                                                         */
+ /*                                                                           */
+ /*****************************************************************************/
+ __u32
+ smb_len(__u8 * p)
+ {
+       return ((*(p+1) & 0x1) << 16L) | (*(p+2) << 8L) | *(p+3);
+ }
+ static __u16
+ smb_bcc(__u8 * packet)
+ {
+       int pos = SMB_HEADER_LEN + SMB_WCT(packet) * sizeof(__u16);
+       return WVAL(packet, pos);
+ }
+ /* smb_valid_packet: We check if packet fulfills the basic
+    requirements of a smb packet */
+ static int
+ smb_valid_packet(__u8 * packet)
+ {
+       return (packet[4] == 0xff
+               && packet[5] == 'S'
+               && packet[6] == 'M'
+               && packet[7] == 'B'
+               && (smb_len(packet) + 4 == SMB_HEADER_LEN
+                   + SMB_WCT(packet) * 2 + smb_bcc(packet)));
+ }
+ /* smb_verify: We check if we got the answer we expected, and if we
+    got enough data. If bcc == -1, we don't care. */
+ static int
+ smb_verify(__u8 * packet, int command, int wct, int bcc)
+ {
+       if (SMB_CMD(packet) != command)
+               goto bad_command;
+       if (SMB_WCT(packet) < wct)
+               goto bad_wct;
+       if (bcc != -1 && smb_bcc(packet) < bcc)
+               goto bad_bcc;
+       return 0;
+ bad_command:
+       printk(KERN_ERR "smb_verify: command=%x, SMB_CMD=%x??\n",
+              command, SMB_CMD(packet));
+       goto fail;
+ bad_wct:
+       printk(KERN_ERR "smb_verify: command=%x, wct=%d, SMB_WCT=%d??\n",
+              command, wct, SMB_WCT(packet));
+       goto fail;
+ bad_bcc:
+       printk(KERN_ERR "smb_verify: command=%x, bcc=%d, SMB_BCC=%d??\n",
+              command, bcc, smb_bcc(packet));
+ fail:
+       return -EIO;
+ }
+ /*
+  * Returns the maximum read or write size for the "payload". Making all of the
+  * packet fit within the negotiated max_xmit size.
+  *
+  * N.B. Since this value is usually computed before locking the server,
+  * the server's packet size must never be decreased!
+  */
+ static inline int
+ smb_get_xmitsize(struct smb_sb_info *server, int overhead)
+ {
+       return server->opt.max_xmit - overhead;
+ }
+ /*
+  * Calculate the maximum read size
+  */
+ int
+ smb_get_rsize(struct smb_sb_info *server)
+ {
+       /* readX has 12 parameters, read has 5 */
+       int overhead = SMB_HEADER_LEN + 12 * sizeof(__u16) + 2 + 1 + 2;
+       int size = smb_get_xmitsize(server, overhead);
+       VERBOSE("xmit=%d, size=%d\n", server->opt.max_xmit, size);
+       return size;
+ }
+ /*
+  * Calculate the maximum write size
+  */
+ int
+ smb_get_wsize(struct smb_sb_info *server)
+ {
+       /* writeX has 14 parameters, write has 5 */
+       int overhead = SMB_HEADER_LEN + 14 * sizeof(__u16) + 2 + 1 + 2;
+       int size = smb_get_xmitsize(server, overhead);
+       VERBOSE("xmit=%d, size=%d\n", server->opt.max_xmit, size);
+       return size;
+ }
+ /*
+  * Convert SMB error codes to -E... errno values.
+  */
+ int
+ smb_errno(struct smb_request *req)
+ {
+       int errcls = req->rq_rcls;
+       int error  = req->rq_err;
+       char *class = "Unknown";
+       VERBOSE("errcls %d  code %d  from command 0x%x\n",
+               errcls, error, SMB_CMD(req->rq_header));
+       if (errcls == ERRDOS) {
+               switch (error) {
+               case ERRbadfunc:
+                       return -EINVAL;
+               case ERRbadfile:
+               case ERRbadpath:
+                       return -ENOENT;
+               case ERRnofids:
+                       return -EMFILE;
+               case ERRnoaccess:
+                       return -EACCES;
+               case ERRbadfid:
+                       return -EBADF;
+               case ERRbadmcb:
+                       return -EREMOTEIO;
+               case ERRnomem:
+                       return -ENOMEM;
+               case ERRbadmem:
+                       return -EFAULT;
+               case ERRbadenv:
+               case ERRbadformat:
+                       return -EREMOTEIO;
+               case ERRbadaccess:
+                       return -EACCES;
+               case ERRbaddata:
+                       return -E2BIG;
+               case ERRbaddrive:
+                       return -ENXIO;
+               case ERRremcd:
+                       return -EREMOTEIO;
+               case ERRdiffdevice:
+                       return -EXDEV;
+               case ERRnofiles:
+                       return -ENOENT;
+               case ERRbadshare:
+                       return -ETXTBSY;
+               case ERRlock:
+                       return -EDEADLK;
+               case ERRfilexists:
+                       return -EEXIST;
+               case ERROR_INVALID_PARAMETER:
+                       return -EINVAL;
+               case ERROR_DISK_FULL:
+                       return -ENOSPC;
+               case ERROR_INVALID_NAME:
+                       return -ENOENT;
+               case ERROR_DIR_NOT_EMPTY:
+                       return -ENOTEMPTY;
+               case ERROR_NOT_LOCKED:
+                        return -ENOLCK;
+               case ERROR_ALREADY_EXISTS:
+                       return -EEXIST;
+               default:
+                       class = "ERRDOS";
+                       goto err_unknown;
+               }
+       } else if (errcls == ERRSRV) {
+               switch (error) {
+               /* N.B. This is wrong ... EIO ? */
+               case ERRerror:
+                       return -ENFILE;
+               case ERRbadpw:
+                       return -EINVAL;
+               case ERRbadtype:
+               case ERRtimeout:
+                       return -EIO;
+               case ERRaccess:
+                       return -EACCES;
+               /*
+                * This is a fatal error, as it means the "tree ID"
+                * for this connection is no longer valid. We map
+                * to a special error code and get a new connection.
+                */
+               case ERRinvnid:
+                       return -EBADSLT;
+               default:
+                       class = "ERRSRV";
+                       goto err_unknown;
+               }
+       } else if (errcls == ERRHRD) {
+               switch (error) {
+               case ERRnowrite:
+                       return -EROFS;
+               case ERRbadunit:
+                       return -ENODEV;
+               case ERRnotready:
+                       return -EUCLEAN;
+               case ERRbadcmd:
+               case ERRdata:
+                       return -EIO;
+               case ERRbadreq:
+                       return -ERANGE;
+               case ERRbadshare:
+                       return -ETXTBSY;
+               case ERRlock:
+                       return -EDEADLK;
+               case ERRdiskfull:
+                       return -ENOSPC;
+               default:
+                       class = "ERRHRD";
+                       goto err_unknown;
+               }
+       } else if (errcls == ERRCMD) {
+               class = "ERRCMD";
+       } else if (errcls == SUCCESS) {
+               return 0;       /* This is the only valid 0 return */
+       }
+ err_unknown:
+       printk(KERN_ERR "smb_errno: class %s, code %d from command 0x%x\n",
+              class, error, SMB_CMD(req->rq_header));
+       return -EIO;
+ }
+ /* smb_request_ok: We expect the server to be locked. Then we do the
+    request and check the answer completely. When smb_request_ok
+    returns 0, you can be quite sure that everything went well. When
+    the answer is <=0, the returned number is a valid unix errno. */
+ static int
+ smb_request_ok(struct smb_request *req, int command, int wct, int bcc)
+ {
+       int result;
+       req->rq_resp_wct = wct;
+       req->rq_resp_bcc = bcc;
+       result = smb_add_request(req);
+       if (result != 0) {
+               DEBUG1("smb_request failed\n");
+               goto out;
+       }
+       if (smb_valid_packet(req->rq_header) != 0) {
+               PARANOIA("invalid packet!\n");
+               goto out;
+       }
+       result = smb_verify(req->rq_header, command, wct, bcc);
+ out:
+       return result;
+ }
+ /*
+  * This implements the NEWCONN ioctl. It installs the server pid,
+  * sets server->state to CONN_VALID, and wakes up the waiting process.
+  */
+ int
+ smb_newconn(struct smb_sb_info *server, struct smb_conn_opt *opt)
+ {
+       struct file *filp;
+       struct sock *sk;
+       int error;
+       VERBOSE("fd=%d, pid=%d\n", opt->fd, current->pid);
+       smb_lock_server(server);
+       /*
+        * Make sure we don't already have a valid connection ...
+        */
+       error = -EINVAL;
+       if (server->state == CONN_VALID)
+               goto out;
+       error = -EACCES;
+       if (current_uid() != server->mnt->mounted_uid &&
+           !capable(CAP_SYS_ADMIN))
+               goto out;
+       error = -EBADF;
+       filp = fget(opt->fd);
+       if (!filp)
+               goto out;
+       if (!smb_valid_socket(filp->f_path.dentry->d_inode))
+               goto out_putf;
+       server->sock_file = filp;
+       server->conn_pid = get_pid(task_pid(current));
+       server->opt = *opt;
+       server->generation += 1;
+       server->state = CONN_VALID;
+       error = 0;
+       if (server->conn_error) {
+               /*
+                * conn_error is the returncode we originally decided to
+                * drop the old connection on. This message should be positive
+                * and not make people ask questions on why smbfs is printing
+                * error messages ...
+                */
+               printk(KERN_INFO "SMB connection re-established (%d)\n",
+                      server->conn_error);
+               server->conn_error = 0;
+       }
+       /*
+        * Store the server in sock user_data (Only used by sunrpc)
+        */
+       sk = SOCKET_I(filp->f_path.dentry->d_inode)->sk;
+       sk->sk_user_data = server;
+       /* chain into the data_ready callback */
+       server->data_ready = xchg(&sk->sk_data_ready, smb_data_ready);
+       /* check if we have an old smbmount that uses seconds for the 
+          serverzone */
+       if (server->opt.serverzone > 12*60 || server->opt.serverzone < -12*60)
+               server->opt.serverzone /= 60;
+       /* now that we have an established connection we can detect the server
+          type and enable bug workarounds */
+       if (server->opt.protocol < SMB_PROTOCOL_LANMAN2)
+               install_ops(server->ops, &smb_ops_core);
+       else if (server->opt.protocol == SMB_PROTOCOL_LANMAN2)
+               install_ops(server->ops, &smb_ops_os2);
+       else if (server->opt.protocol == SMB_PROTOCOL_NT1 &&
+                (server->opt.max_xmit < 0x1000) &&
+                !(server->opt.capabilities & SMB_CAP_NT_SMBS)) {
+               /* FIXME: can we kill the WIN95 flag now? */
+               server->mnt->flags |= SMB_MOUNT_WIN95;
+               VERBOSE("detected WIN95 server\n");
+               install_ops(server->ops, &smb_ops_win95);
+       } else {
+               /*
+                * Samba has max_xmit 65535
+                * NT4spX has max_xmit 4536 (or something like that)
+                * win2k has ...
+                */
+               VERBOSE("detected NT1 (Samba, NT4/5) server\n");
+               install_ops(server->ops, &smb_ops_winNT);
+       }
+       /* FIXME: the win9x code wants to modify these ... (seek/trunc bug) */
+       if (server->mnt->flags & SMB_MOUNT_OLDATTR) {
+               server->ops->getattr = smb_proc_getattr_core;
+       } else if (server->mnt->flags & SMB_MOUNT_DIRATTR) {
+               server->ops->getattr = smb_proc_getattr_ff;
+       }
+       /* Decode server capabilities */
+       if (server->opt.capabilities & SMB_CAP_LARGE_FILES) {
+               /* Should be ok to set this now, as no one can access the
+                  mount until the connection has been established. */
+               SB_of(server)->s_maxbytes = ~0ULL >> 1;
+               VERBOSE("LFS enabled\n");
+       }
+       if (server->opt.capabilities & SMB_CAP_UNICODE) {
+               server->mnt->flags |= SMB_MOUNT_UNICODE;
+               VERBOSE("Unicode enabled\n");
+       } else {
+               server->mnt->flags &= ~SMB_MOUNT_UNICODE;
+       }
+ #if 0
+       /* flags we may test for other patches ... */
+       if (server->opt.capabilities & SMB_CAP_LARGE_READX) {
+               VERBOSE("Large reads enabled\n");
+       }
+       if (server->opt.capabilities & SMB_CAP_LARGE_WRITEX) {
+               VERBOSE("Large writes enabled\n");
+       }
+ #endif
+       if (server->opt.capabilities & SMB_CAP_UNIX) {
+               struct inode *inode;
+               VERBOSE("Using UNIX CIFS extensions\n");
+               install_ops(server->ops, &smb_ops_unix);
+               inode = SB_of(server)->s_root->d_inode;
+               if (inode)
+                       inode->i_op = &smb_dir_inode_operations_unix;
+       }
+       VERBOSE("protocol=%d, max_xmit=%d, pid=%d capabilities=0x%x\n",
+               server->opt.protocol, server->opt.max_xmit,
+               pid_nr(server->conn_pid), server->opt.capabilities);
+       /* FIXME: this really should be done by smbmount. */
+       if (server->opt.max_xmit > SMB_MAX_PACKET_SIZE) {
+               server->opt.max_xmit = SMB_MAX_PACKET_SIZE;
+       }
+       smb_unlock_server(server);
+       smbiod_wake_up();
+       if (server->opt.capabilities & SMB_CAP_UNIX)
+               smb_proc_query_cifsunix(server);
+       server->conn_complete++;
+       wake_up_interruptible_all(&server->conn_wq);
+       return error;
+ out:
+       smb_unlock_server(server);
+       smbiod_wake_up();
+       return error;
+ out_putf:
+       fput(filp);
+       goto out;
+ }
+ /* smb_setup_header: We completely set up the packet. You only have to
+    insert the command-specific fields */
+ __u8 *
+ smb_setup_header(struct smb_request *req, __u8 command, __u16 wct, __u16 bcc)
+ {
+       __u32 xmit_len = SMB_HEADER_LEN + wct * sizeof(__u16) + bcc + 2;
+       __u8 *p = req->rq_header;
+       struct smb_sb_info *server = req->rq_server;
+       p = smb_encode_smb_length(p, xmit_len - 4);
+       *p++ = 0xff;
+       *p++ = 'S';
+       *p++ = 'M';
+       *p++ = 'B';
+       *p++ = command;
+       memset(p, '\0', 19);
+       p += 19;
+       p += 8;
+       if (server->opt.protocol > SMB_PROTOCOL_CORE) {
+               int flags = SMB_FLAGS_CASELESS_PATHNAMES;
+               int flags2 = SMB_FLAGS2_LONG_PATH_COMPONENTS |
+                       SMB_FLAGS2_EXTENDED_ATTRIBUTES; /* EA? not really ... */
+               *(req->rq_header + smb_flg) = flags;
+               if (server->mnt->flags & SMB_MOUNT_UNICODE)
+                       flags2 |= SMB_FLAGS2_UNICODE_STRINGS;
+               WSET(req->rq_header, smb_flg2, flags2);
+       }
+       *p++ = wct;             /* wct */
+       p += 2 * wct;
+       WSET(p, 0, bcc);
+       /* Include the header in the data to send */
+       req->rq_iovlen = 1;
+       req->rq_iov[0].iov_base = req->rq_header;
+       req->rq_iov[0].iov_len  = xmit_len - bcc;
+       return req->rq_buffer;
+ }
+ static void
+ smb_setup_bcc(struct smb_request *req, __u8 *p)
+ {
+       u16 bcc = p - req->rq_buffer;
+       u8 *pbcc = req->rq_header + SMB_HEADER_LEN + 2*SMB_WCT(req->rq_header);
+       WSET(pbcc, 0, bcc);
+       smb_encode_smb_length(req->rq_header, SMB_HEADER_LEN + 
+                             2*SMB_WCT(req->rq_header) - 2 + bcc);
+       /* Include the "bytes" in the data to send */
+       req->rq_iovlen = 2;
+       req->rq_iov[1].iov_base = req->rq_buffer;
+       req->rq_iov[1].iov_len  = bcc;
+ }
+ static int
+ smb_proc_seek(struct smb_sb_info *server, __u16 fileid,
+             __u16 mode, off_t offset)
+ {
+       int result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, 0)))
+               goto out;
+       smb_setup_header(req, SMBlseek, 4, 0);
+       WSET(req->rq_header, smb_vwv0, fileid);
+       WSET(req->rq_header, smb_vwv1, mode);
+       DSET(req->rq_header, smb_vwv2, offset);
+       req->rq_flags |= SMB_REQ_NORETRY;
+       result = smb_request_ok(req, SMBlseek, 2, 0);
+       if (result < 0) {
+               result = 0;
+               goto out_free;
+       }
+       result = DVAL(req->rq_header, smb_vwv0);
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ static int
+ smb_proc_open(struct smb_sb_info *server, struct dentry *dentry, int wish)
+ {
+       struct inode *ino = dentry->d_inode;
+       struct smb_inode_info *ei = SMB_I(ino);
+       int mode, read_write = 0x42, read_only = 0x40;
+       int res;
+       char *p;
+       struct smb_request *req;
+       /*
+        * Attempt to open r/w, unless there are no write privileges.
+        */
+       mode = read_write;
+       if (!(ino->i_mode & (S_IWUSR | S_IWGRP | S_IWOTH)))
+               mode = read_only;
+ #if 0
+       /* FIXME: why is this code not in? below we fix it so that a caller
+          wanting RO doesn't get RW. smb_revalidate_inode does some 
+          optimization based on access mode. tail -f needs it to be correct.
+          We must open rw since we don't do the open if called a second time
+          with different 'wish'. Is that not supported by smb servers? */
+       if (!(wish & (O_WRONLY | O_RDWR)))
+               mode = read_only;
+ #endif
+       res = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       retry:
+       p = smb_setup_header(req, SMBopen, 2, 0);
+       WSET(req->rq_header, smb_vwv0, mode);
+       WSET(req->rq_header, smb_vwv1, aSYSTEM | aHIDDEN | aDIR);
+       res = smb_simple_encode_path(req, &p, dentry, NULL);
+       if (res < 0)
+               goto out_free;
+       smb_setup_bcc(req, p);
+       res = smb_request_ok(req, SMBopen, 7, 0);
+       if (res != 0) {
+               if (mode == read_write &&
+                   (res == -EACCES || res == -ETXTBSY || res == -EROFS))
+               {
+                       VERBOSE("%s/%s R/W failed, error=%d, retrying R/O\n",
+                               DENTRY_PATH(dentry), res);
+                       mode = read_only;
+                       req->rq_flags = 0;
+                       goto retry;
+               }
+               goto out_free;
+       }
+       /* We should now have data in vwv[0..6]. */
+       ei->fileid = WVAL(req->rq_header, smb_vwv0);
+       ei->attr   = WVAL(req->rq_header, smb_vwv1);
+       /* smb_vwv2 has mtime */
+       /* smb_vwv4 has size  */
+       ei->access = (WVAL(req->rq_header, smb_vwv6) & SMB_ACCMASK);
+       ei->open = server->generation;
+ out_free:
+       smb_rput(req);
+ out:
+       return res;
+ }
+ /*
+  * Make sure the file is open, and check that the access
+  * is compatible with the desired access.
+  */
+ int
+ smb_open(struct dentry *dentry, int wish)
+ {
+       struct inode *inode = dentry->d_inode;
+       int result;
+       __u16 access;
+       result = -ENOENT;
+       if (!inode) {
+               printk(KERN_ERR "smb_open: no inode for dentry %s/%s\n",
+                      DENTRY_PATH(dentry));
+               goto out;
+       }
+       if (!smb_is_open(inode)) {
+               struct smb_sb_info *server = server_from_inode(inode);
+               result = 0;
+               if (!smb_is_open(inode))
+                       result = smb_proc_open(server, dentry, wish);
+               if (result)
+                       goto out;
+               /*
+                * A successful open means the path is still valid ...
+                */
+               smb_renew_times(dentry);
+       }
+       /*
+        * Check whether the access is compatible with the desired mode.
+        */
+       result = 0;
+       access = SMB_I(inode)->access;
+       if (access != wish && access != SMB_O_RDWR) {
+               PARANOIA("%s/%s access denied, access=%x, wish=%x\n",
+                        DENTRY_PATH(dentry), access, wish);
+               result = -EACCES;
+       }
+ out:
+       return result;
+ }
+ static int 
+ smb_proc_close(struct smb_sb_info *server, __u16 fileid, __u32 mtime)
+ {
+       struct smb_request *req;
+       int result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, 0)))
+               goto out;
+       smb_setup_header(req, SMBclose, 3, 0);
+       WSET(req->rq_header, smb_vwv0, fileid);
+       DSET(req->rq_header, smb_vwv1, utc2local(server, mtime));
+       req->rq_flags |= SMB_REQ_NORETRY;
+       result = smb_request_ok(req, SMBclose, 0, 0);
+       smb_rput(req);
+ out:
+       return result;
+ }
+ /*
+  * Win NT 4.0 has an apparent bug in that it fails to update the
+  * modify time when writing to a file. As a workaround, we update
+  * both modify and access time locally, and post the times to the
+  * server when closing the file.
+  */
+ static int 
+ smb_proc_close_inode(struct smb_sb_info *server, struct inode * ino)
+ {
+       struct smb_inode_info *ei = SMB_I(ino);
+       int result = 0;
+       if (smb_is_open(ino))
+       {
+               /*
+                * We clear the open flag in advance, in case another
+                * process observes the value while we block below.
+                */
+               ei->open = 0;
+               /*
+                * Kludge alert: SMB timestamps are accurate only to
+                * two seconds ... round the times to avoid needless
+                * cache invalidations!
+                */
+               if (ino->i_mtime.tv_sec & 1) { 
+                       ino->i_mtime.tv_sec--;
+                       ino->i_mtime.tv_nsec = 0; 
+               }
+               if (ino->i_atime.tv_sec & 1) {
+                       ino->i_atime.tv_sec--;
+                       ino->i_atime.tv_nsec = 0;
+               }
+               /*
+                * If the file is open with write permissions,
+                * update the time stamps to sync mtime and atime.
+                */
+               if ((server->opt.capabilities & SMB_CAP_UNIX) == 0 &&
+                   (server->opt.protocol >= SMB_PROTOCOL_LANMAN2) &&
+                   !(ei->access == SMB_O_RDONLY))
+               {
+                       struct smb_fattr fattr;
+                       smb_get_inode_attr(ino, &fattr);
+                       smb_proc_setattr_ext(server, ino, &fattr);
+               }
+               result = smb_proc_close(server, ei->fileid, ino->i_mtime.tv_sec);
+               /*
+                * Force a revalidation after closing ... some servers
+                * don't post the size until the file has been closed.
+                */
+               if (server->opt.protocol < SMB_PROTOCOL_NT1)
+                       ei->oldmtime = 0;
+               ei->closed = jiffies;
+       }
+       return result;
+ }
+ int
+ smb_close(struct inode *ino)
+ {
+       int result = 0;
+       if (smb_is_open(ino)) {
+               struct smb_sb_info *server = server_from_inode(ino);
+               result = smb_proc_close_inode(server, ino);
+       }
+       return result;
+ }
+ /*
+  * This is used to close a file following a failed instantiate.
+  * Since we don't have an inode, we can't use any of the above.
+  */
+ int
+ smb_close_fileid(struct dentry *dentry, __u16 fileid)
+ {
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       int result;
+       result = smb_proc_close(server, fileid, get_seconds());
+       return result;
+ }
+ /* In smb_proc_read and smb_proc_write we do not retry, because the
+    file-id would not be valid after a reconnection. */
+ static void
+ smb_proc_read_data(struct smb_request *req)
+ {
+       req->rq_iov[0].iov_base = req->rq_buffer;
+       req->rq_iov[0].iov_len  = 3;
+       req->rq_iov[1].iov_base = req->rq_page;
+       req->rq_iov[1].iov_len  = req->rq_rsize;
+       req->rq_iovlen = 2;
+       req->rq_rlen = smb_len(req->rq_header) + 4 - req->rq_bytes_recvd;
+ }
+ static int
+ smb_proc_read(struct inode *inode, loff_t offset, int count, char *data)
+ {
+       struct smb_sb_info *server = server_from_inode(inode);
+       __u16 returned_count, data_len;
+       unsigned char *buf;
+       int result;
+       struct smb_request *req;
+       u8 rbuf[4];
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, 0)))
+               goto out;
+       smb_setup_header(req, SMBread, 5, 0);
+       buf = req->rq_header;
+       WSET(buf, smb_vwv0, SMB_I(inode)->fileid);
+       WSET(buf, smb_vwv1, count);
+       DSET(buf, smb_vwv2, offset);
+       WSET(buf, smb_vwv4, 0);
+       req->rq_page = data;
+       req->rq_rsize = count;
+       req->rq_callback = smb_proc_read_data;
+       req->rq_buffer = rbuf;
+       req->rq_flags |= SMB_REQ_NORETRY | SMB_REQ_STATIC;
+       result = smb_request_ok(req, SMBread, 5, -1);
+       if (result < 0)
+               goto out_free;
+       returned_count = WVAL(req->rq_header, smb_vwv0);
+       data_len = WVAL(rbuf, 1);
+       if (returned_count != data_len) {
+               printk(KERN_NOTICE "smb_proc_read: returned != data_len\n");
+               printk(KERN_NOTICE "smb_proc_read: ret_c=%d, data_len=%d\n",
+                      returned_count, data_len);
+       }
+       result = data_len;
+ out_free:
+       smb_rput(req);
+ out:
+       VERBOSE("ino=%ld, fileid=%d, count=%d, result=%d\n",
+               inode->i_ino, SMB_I(inode)->fileid, count, result);
+       return result;
+ }
+ static int
+ smb_proc_write(struct inode *inode, loff_t offset, int count, const char *data)
+ {
+       struct smb_sb_info *server = server_from_inode(inode);
+       int result;
+       u16 fileid = SMB_I(inode)->fileid;
+       u8 buf[4];
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, 0)))
+               goto out;
+       VERBOSE("ino=%ld, fileid=%d, count=%d@%Ld\n",
+               inode->i_ino, fileid, count, offset);
+       smb_setup_header(req, SMBwrite, 5, count + 3);
+       WSET(req->rq_header, smb_vwv0, fileid);
+       WSET(req->rq_header, smb_vwv1, count);
+       DSET(req->rq_header, smb_vwv2, offset);
+       WSET(req->rq_header, smb_vwv4, 0);
+       buf[0] = 1;
+       WSET(buf, 1, count);    /* yes, again ... */
+       req->rq_iov[1].iov_base = buf;
+       req->rq_iov[1].iov_len = 3;
+       req->rq_iov[2].iov_base = (char *) data;
+       req->rq_iov[2].iov_len = count;
+       req->rq_iovlen = 3;
+       req->rq_flags |= SMB_REQ_NORETRY;
+       result = smb_request_ok(req, SMBwrite, 1, 0);
+       if (result >= 0)
+               result = WVAL(req->rq_header, smb_vwv0);
+       smb_rput(req);
+ out:
+       return result;
+ }
+ /*
+  * In smb_proc_readX and smb_proc_writeX we do not retry, because the
+  * file-id would not be valid after a reconnection.
+  */
+ #define SMB_READX_MAX_PAD      64
+ static void
+ smb_proc_readX_data(struct smb_request *req)
+ {
+       /* header length, excluding the netbios length (-4) */
+       int hdrlen = SMB_HEADER_LEN + req->rq_resp_wct*2 - 2;
+       int data_off = WVAL(req->rq_header, smb_vwv6);
+       /*
+        * Some genius made the padding to the data bytes arbitrary.
+        * So we must first calculate the amount of padding used by the server.
+        */
+       data_off -= hdrlen;
+       if (data_off > SMB_READX_MAX_PAD || data_off < 0) {
+               PARANOIA("offset is larger than SMB_READX_MAX_PAD or negative!\n");
+               PARANOIA("%d > %d || %d < 0\n", data_off, SMB_READX_MAX_PAD, data_off);
+               req->rq_rlen = req->rq_bufsize + 1;
+               return;
+       }
+       req->rq_iov[0].iov_base = req->rq_buffer;
+       req->rq_iov[0].iov_len  = data_off;
+       req->rq_iov[1].iov_base = req->rq_page;
+       req->rq_iov[1].iov_len  = req->rq_rsize;
+       req->rq_iovlen = 2;
+       req->rq_rlen = smb_len(req->rq_header) + 4 - req->rq_bytes_recvd;
+ }
+ static int
+ smb_proc_readX(struct inode *inode, loff_t offset, int count, char *data)
+ {
+       struct smb_sb_info *server = server_from_inode(inode);
+       unsigned char *buf;
+       int result;
+       struct smb_request *req;
+       static char pad[SMB_READX_MAX_PAD];
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, 0)))
+               goto out;
+       smb_setup_header(req, SMBreadX, 12, 0);
+       buf = req->rq_header;
+       WSET(buf, smb_vwv0, 0x00ff);
+       WSET(buf, smb_vwv1, 0);
+       WSET(buf, smb_vwv2, SMB_I(inode)->fileid);
+       DSET(buf, smb_vwv3, (u32)offset);               /* low 32 bits */
+       WSET(buf, smb_vwv5, count);
+       WSET(buf, smb_vwv6, 0);
+       DSET(buf, smb_vwv7, 0);
+       WSET(buf, smb_vwv9, 0);
+       DSET(buf, smb_vwv10, (u32)(offset >> 32));      /* high 32 bits */
+       WSET(buf, smb_vwv11, 0);
+       req->rq_page = data;
+       req->rq_rsize = count;
+       req->rq_callback = smb_proc_readX_data;
+       req->rq_buffer = pad;
+       req->rq_bufsize = SMB_READX_MAX_PAD;
+       req->rq_flags |= SMB_REQ_STATIC | SMB_REQ_NORETRY;
+       result = smb_request_ok(req, SMBreadX, 12, -1);
+       if (result < 0)
+               goto out_free;
+       result = WVAL(req->rq_header, smb_vwv5);
+ out_free:
+       smb_rput(req);
+ out:
+       VERBOSE("ino=%ld, fileid=%d, count=%d, result=%d\n",
+               inode->i_ino, SMB_I(inode)->fileid, count, result);
+       return result;
+ }
+ static int
+ smb_proc_writeX(struct inode *inode, loff_t offset, int count, const char *data)
+ {
+       struct smb_sb_info *server = server_from_inode(inode);
+       int result;
+       u8 *p;
+       static u8 pad[4];
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, 0)))
+               goto out;
+       VERBOSE("ino=%ld, fileid=%d, count=%d@%Ld\n",
+               inode->i_ino, SMB_I(inode)->fileid, count, offset);
+       p = smb_setup_header(req, SMBwriteX, 14, count + 1);
+       WSET(req->rq_header, smb_vwv0, 0x00ff);
+       WSET(req->rq_header, smb_vwv1, 0);
+       WSET(req->rq_header, smb_vwv2, SMB_I(inode)->fileid);
+       DSET(req->rq_header, smb_vwv3, (u32)offset);    /* low 32 bits */
+       DSET(req->rq_header, smb_vwv5, 0);
+       WSET(req->rq_header, smb_vwv7, 0);              /* write mode */
+       WSET(req->rq_header, smb_vwv8, 0);
+       WSET(req->rq_header, smb_vwv9, 0);
+       WSET(req->rq_header, smb_vwv10, count);         /* data length */
+       WSET(req->rq_header, smb_vwv11, smb_vwv12 + 2 + 1);
+       DSET(req->rq_header, smb_vwv12, (u32)(offset >> 32));
+       req->rq_iov[1].iov_base = pad;
+       req->rq_iov[1].iov_len = 1;
+       req->rq_iov[2].iov_base = (char *) data;
+       req->rq_iov[2].iov_len = count;
+       req->rq_iovlen = 3;
+       req->rq_flags |= SMB_REQ_NORETRY;
+       result = smb_request_ok(req, SMBwriteX, 6, 0);
+       if (result >= 0)
+               result = WVAL(req->rq_header, smb_vwv2);
+       smb_rput(req);
+ out:
+       return result;
+ }
+ int
+ smb_proc_create(struct dentry *dentry, __u16 attr, time_t ctime, __u16 *fileid)
+ {
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       char *p;
+       int result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       p = smb_setup_header(req, SMBcreate, 3, 0);
+       WSET(req->rq_header, smb_vwv0, attr);
+       DSET(req->rq_header, smb_vwv1, utc2local(server, ctime));
+       result = smb_simple_encode_path(req, &p, dentry, NULL);
+       if (result < 0)
+               goto out_free;
+       smb_setup_bcc(req, p);
+       result = smb_request_ok(req, SMBcreate, 1, 0);
+       if (result < 0)
+               goto out_free;
+       *fileid = WVAL(req->rq_header, smb_vwv0);
+       result = 0;
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ int
+ smb_proc_mv(struct dentry *old_dentry, struct dentry *new_dentry)
+ {
+       struct smb_sb_info *server = server_from_dentry(old_dentry);
+       char *p;
+       int result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       p = smb_setup_header(req, SMBmv, 1, 0);
+       WSET(req->rq_header, smb_vwv0, aSYSTEM | aHIDDEN | aDIR);
+       result = smb_simple_encode_path(req, &p, old_dentry, NULL);
+       if (result < 0)
+               goto out_free;
+       result = smb_simple_encode_path(req, &p, new_dentry, NULL);
+       if (result < 0)
+               goto out_free;
+       smb_setup_bcc(req, p);
+       if ((result = smb_request_ok(req, SMBmv, 0, 0)) < 0)
+               goto out_free;
+       result = 0;
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ /*
+  * Code common to mkdir and rmdir.
+  */
+ static int
+ smb_proc_generic_command(struct dentry *dentry, __u8 command)
+ {
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       char *p;
+       int result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       p = smb_setup_header(req, command, 0, 0);
+       result = smb_simple_encode_path(req, &p, dentry, NULL);
+       if (result < 0)
+               goto out_free;
+       smb_setup_bcc(req, p);
+       result = smb_request_ok(req, command, 0, 0);
+       if (result < 0)
+               goto out_free;
+       result = 0;
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ int
+ smb_proc_mkdir(struct dentry *dentry)
+ {
+       return smb_proc_generic_command(dentry, SMBmkdir);
+ }
+ int
+ smb_proc_rmdir(struct dentry *dentry)
+ {
+       return smb_proc_generic_command(dentry, SMBrmdir);
+ }
+ #if SMBFS_POSIX_UNLINK
+ /*
+  * Removes readonly attribute from a file. Used by unlink to give posix
+  * semantics.
+  */
+ static int
+ smb_set_rw(struct dentry *dentry,struct smb_sb_info *server)
+ {
+       int result;
+       struct smb_fattr fattr;
+       /* FIXME: cifsUE should allow removing a readonly file. */
+       /* first get current attribute */
+       smb_init_dirent(server, &fattr);
+       result = server->ops->getattr(server, dentry, &fattr);
+       smb_finish_dirent(server, &fattr);
+       if (result < 0)
+               return result;
+       /* if RONLY attribute is set, remove it */
+       if (fattr.attr & aRONLY) {  /* read only attribute is set */
+               fattr.attr &= ~aRONLY;
+               result = smb_proc_setattr_core(server, dentry, fattr.attr);
+       }
+       return result;
+ }
+ #endif
+ int
+ smb_proc_unlink(struct dentry *dentry)
+ {
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       int flag = 0;
+       char *p;
+       int result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       retry:
+       p = smb_setup_header(req, SMBunlink, 1, 0);
+       WSET(req->rq_header, smb_vwv0, aSYSTEM | aHIDDEN);
+       result = smb_simple_encode_path(req, &p, dentry, NULL);
+       if (result < 0)
+               goto out_free;
+       smb_setup_bcc(req, p);
+       if ((result = smb_request_ok(req, SMBunlink, 0, 0)) < 0) {
+ #if SMBFS_POSIX_UNLINK
+               if (result == -EACCES && !flag) {
+                       /* Posix semantics is for the read-only state
+                          of a file to be ignored in unlink(). In the
+                          SMB world a unlink() is refused on a
+                          read-only file. To make things easier for
+                          unix users we try to override the files
+                          permission if the unlink fails with the
+                          right error.
+                          This introduces a race condition that could
+                          lead to a file being written by someone who
+                          shouldn't have access, but as far as I can
+                          tell that is unavoidable */
+                       /* remove RONLY attribute and try again */
+                       result = smb_set_rw(dentry,server);
+                       if (result == 0) {
+                               flag = 1;
+                               req->rq_flags = 0;
+                               goto retry;
+                       }
+               }
+ #endif
+               goto out_free;
+       }
+       result = 0;
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ int
+ smb_proc_flush(struct smb_sb_info *server, __u16 fileid)
+ {
+       int result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, 0)))
+               goto out;
+       smb_setup_header(req, SMBflush, 1, 0);
+       WSET(req->rq_header, smb_vwv0, fileid);
+       req->rq_flags |= SMB_REQ_NORETRY;
+       result = smb_request_ok(req, SMBflush, 0, 0);
+       smb_rput(req);
+ out:
+       return result;
+ }
+ static int
+ smb_proc_trunc32(struct inode *inode, loff_t length)
+ {
+       /*
+        * Writing 0bytes is old-SMB magic for truncating files.
+        * MAX_NON_LFS should prevent this from being called with a too
+        * large offset.
+        */
+       return smb_proc_write(inode, length, 0, NULL);
+ }
+ static int
+ smb_proc_trunc64(struct inode *inode, loff_t length)
+ {
+       struct smb_sb_info *server = server_from_inode(inode);
+       int result;
+       char *param;
+       char *data;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, 14)))
+               goto out;
+       param = req->rq_buffer;
+       data = req->rq_buffer + 6;
+       /* FIXME: must we also set allocation size? winNT seems to do that */
+       WSET(param, 0, SMB_I(inode)->fileid);
+       WSET(param, 2, SMB_SET_FILE_END_OF_FILE_INFO);
+       WSET(param, 4, 0);
+       LSET(data, 0, length);
+       req->rq_trans2_command = TRANSACT2_SETFILEINFO;
+       req->rq_ldata = 8;
+       req->rq_data  = data;
+       req->rq_lparm = 6;
+       req->rq_parm  = param;
+       req->rq_flags |= SMB_REQ_NORETRY;
+       result = smb_add_request(req);
+       if (result < 0)
+               goto out_free;
+       result = 0;
+       if (req->rq_rcls != 0)
+               result = smb_errno(req);
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ static int
+ smb_proc_trunc95(struct inode *inode, loff_t length)
+ {
+       struct smb_sb_info *server = server_from_inode(inode);
+       int result = smb_proc_trunc32(inode, length);
+  
+       /*
+        * win9x doesn't appear to update the size immediately.
+        * It will return the old file size after the truncate,
+        * confusing smbfs. So we force an update.
+        *
+        * FIXME: is this still necessary?
+        */
+       smb_proc_flush(server, SMB_I(inode)->fileid);
+       return result;
+ }
+ static void
+ smb_init_dirent(struct smb_sb_info *server, struct smb_fattr *fattr)
+ {
+       memset(fattr, 0, sizeof(*fattr));
+       fattr->f_nlink = 1;
+       fattr->f_uid = server->mnt->uid;
+       fattr->f_gid = server->mnt->gid;
+       fattr->f_unix = 0;
+ }
+ static void
+ smb_finish_dirent(struct smb_sb_info *server, struct smb_fattr *fattr)
+ {
+       if (fattr->f_unix)
+               return;
+       fattr->f_mode = server->mnt->file_mode;
+       if (fattr->attr & aDIR) {
+               fattr->f_mode = server->mnt->dir_mode;
+               fattr->f_size = SMB_ST_BLKSIZE;
+       }
+       /* Check the read-only flag */
+       if (fattr->attr & aRONLY)
+               fattr->f_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
+       /* How many 512 byte blocks do we need for this file? */
+       fattr->f_blocks = 0;
+       if (fattr->f_size != 0)
+               fattr->f_blocks = 1 + ((fattr->f_size-1) >> 9);
+       return;
+ }
+ void
+ smb_init_root_dirent(struct smb_sb_info *server, struct smb_fattr *fattr,
+                    struct super_block *sb)
+ {
+       smb_init_dirent(server, fattr);
+       fattr->attr = aDIR;
+       fattr->f_ino = 2; /* traditional root inode number */
+       fattr->f_mtime = current_fs_time(sb);
+       smb_finish_dirent(server, fattr);
+ }
+ /*
+  * Decode a dirent for old protocols
+  *
+  * qname is filled with the decoded, and possibly translated, name.
+  * fattr receives decoded attributes
+  *
+  * Bugs Noted:
+  * (1) Pathworks servers may pad the name with extra spaces.
+  */
+ static char *
+ smb_decode_short_dirent(struct smb_sb_info *server, char *p,
+                       struct qstr *qname, struct smb_fattr *fattr,
+                       unsigned char *name_buf)
+ {
+       int len;
+       /*
+        * SMB doesn't have a concept of inode numbers ...
+        */
+       smb_init_dirent(server, fattr);
+       fattr->f_ino = 0;       /* FIXME: do we need this? */
+       p += SMB_STATUS_SIZE;   /* reserved (search_status) */
+       fattr->attr = *p;
+       fattr->f_mtime.tv_sec = date_dos2unix(server, WVAL(p, 3), WVAL(p, 1));
+       fattr->f_mtime.tv_nsec = 0;
+       fattr->f_size = DVAL(p, 5);
+       fattr->f_ctime = fattr->f_mtime;
+       fattr->f_atime = fattr->f_mtime;
+       qname->name = p + 9;
+       len = strnlen(qname->name, 12);
+       /*
+        * Trim trailing blanks for Pathworks servers
+        */
+       while (len > 2 && qname->name[len-1] == ' ')
+               len--;
+       smb_finish_dirent(server, fattr);
+ #if 0
+       /* FIXME: These only work for ascii chars, and recent smbmount doesn't
+          allow the flag to be set anyway. It kills const. Remove? */
+       switch (server->opt.case_handling) {
+       case SMB_CASE_UPPER:
+               str_upper(entry->name, len);
+               break;
+       case SMB_CASE_LOWER:
+               str_lower(entry->name, len);
+               break;
+       default:
+               break;
+       }
+ #endif
+       qname->len = 0;
+       len = server->ops->convert(name_buf, SMB_MAXNAMELEN,
+                                  qname->name, len,
+                                  server->remote_nls, server->local_nls);
+       if (len > 0) {
+               qname->len = len;
+               qname->name = name_buf;
+               DEBUG1("len=%d, name=%.*s\n",qname->len,qname->len,qname->name);
+       }
+       return p + 22;
+ }
+ /*
+  * This routine is used to read in directory entries from the network.
+  * Note that it is for short directory name seeks, i.e.: protocol <
+  * SMB_PROTOCOL_LANMAN2
+  */
+ static int
+ smb_proc_readdir_short(struct file *filp, void *dirent, filldir_t filldir,
+                      struct smb_cache_control *ctl)
+ {
+       struct dentry *dir = filp->f_path.dentry;
+       struct smb_sb_info *server = server_from_dentry(dir);
+       struct qstr qname;
+       struct smb_fattr fattr;
+       char *p;
+       int result;
+       int i, first, entries_seen, entries;
+       int entries_asked = (server->opt.max_xmit - 100) / SMB_DIRINFO_SIZE;
+       __u16 bcc;
+       __u16 count;
+       char status[SMB_STATUS_SIZE];
+       static struct qstr mask = {
+               .name   = "*.*",
+               .len    = 3,
+       };
+       unsigned char *last_status;
+       struct smb_request *req;
+       unsigned char *name_buf;
+       VERBOSE("%s/%s\n", DENTRY_PATH(dir));
+       lock_kernel();
+       result = -ENOMEM;
+       if (! (name_buf = kmalloc(SMB_MAXNAMELEN, GFP_KERNEL)))
+               goto out;
+       first = 1;
+       entries = 0;
+       entries_seen = 2; /* implicit . and .. */
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, server->opt.max_xmit)))
+               goto out_name;
+       while (1) {
+               p = smb_setup_header(req, SMBsearch, 2, 0);
+               WSET(req->rq_header, smb_vwv0, entries_asked);
+               WSET(req->rq_header, smb_vwv1, aDIR);
+               if (first == 1) {
+                       result = smb_simple_encode_path(req, &p, dir, &mask);
+                       if (result < 0)
+                               goto out_free;
+                       if (p + 3 > (char *)req->rq_buffer + req->rq_bufsize) {
+                               result = -ENAMETOOLONG;
+                               goto out_free;
+                       }
+                       *p++ = 5;
+                       WSET(p, 0, 0);
+                       p += 2;
+                       first = 0;
+               } else {
+                       if (p + 5 + SMB_STATUS_SIZE >
+                           (char *)req->rq_buffer + req->rq_bufsize) {
+                               result = -ENAMETOOLONG;
+                               goto out_free;
+                       }
+                               
+                       *p++ = 4;
+                       *p++ = 0;
+                       *p++ = 5;
+                       WSET(p, 0, SMB_STATUS_SIZE);
+                       p += 2;
+                       memcpy(p, status, SMB_STATUS_SIZE);
+                       p += SMB_STATUS_SIZE;
+               }
+               smb_setup_bcc(req, p);
+               result = smb_request_ok(req, SMBsearch, 1, -1);
+               if (result < 0) {
+                       if ((req->rq_rcls == ERRDOS) && 
+                           (req->rq_err  == ERRnofiles))
+                               break;
+                       goto out_free;
+               }
+               count = WVAL(req->rq_header, smb_vwv0);
+               if (count <= 0)
+                       break;
+               result = -EIO;
+               bcc = smb_bcc(req->rq_header);
+               if (bcc != count * SMB_DIRINFO_SIZE + 3)
+                       goto out_free;
+               p = req->rq_buffer + 3;
+               /* Make sure the response fits in the buffer. Fixed sized 
+                  entries means we don't have to check in the decode loop. */
+               last_status = req->rq_buffer + 3 + (count-1) * SMB_DIRINFO_SIZE;
+               if (last_status + SMB_DIRINFO_SIZE >=
+                   req->rq_buffer + req->rq_bufsize) {
+                       printk(KERN_ERR "smb_proc_readdir_short: "
+                              "last dir entry outside buffer! "
+                              "%d@%p  %d@%p\n", SMB_DIRINFO_SIZE, last_status,
+                              req->rq_bufsize, req->rq_buffer);
+                       goto out_free;
+               }
+               /* Read the last entry into the status field. */
+               memcpy(status, last_status, SMB_STATUS_SIZE);
+               /* Now we are ready to parse smb directory entries. */
+               for (i = 0; i < count; i++) {
+                       p = smb_decode_short_dirent(server, p, 
+                                                   &qname, &fattr, name_buf);
+                       if (qname.len == 0)
+                               continue;
+                       if (entries_seen == 2 && qname.name[0] == '.') {
+                               if (qname.len == 1)
+                                       continue;
+                               if (qname.name[1] == '.' && qname.len == 2)
+                                       continue;
+                       }
+                       if (!smb_fill_cache(filp, dirent, filldir, ctl, 
+                                           &qname, &fattr))
+                               ;       /* stop reading? */
+                       entries_seen++;
+               }
+       }
+       result = entries;
+ out_free:
+       smb_rput(req);
+ out_name:
+       kfree(name_buf);
+ out:
+       unlock_kernel();
+       return result;
+ }
+ static void smb_decode_unix_basic(struct smb_fattr *fattr, struct smb_sb_info *server, char *p)
+ {
+       u64 size, disk_bytes;
+       /* FIXME: verify nls support. all is sent as utf8? */
+       fattr->f_unix = 1;
+       fattr->f_mode = 0;
+       /* FIXME: use the uniqueID from the remote instead? */
+       /* 0 L file size in bytes */
+       /* 8 L file size on disk in bytes (block count) */
+       /* 40 L uid */
+       /* 48 L gid */
+       /* 56 W file type */
+       /* 60 L devmajor */
+       /* 68 L devminor */
+       /* 76 L unique ID (inode) */
+       /* 84 L permissions */
+       /* 92 L link count */
+       size = LVAL(p, 0);
+       disk_bytes = LVAL(p, 8);
+       /*
+        * Some samba versions round up on-disk byte usage
+        * to 1MB boundaries, making it useless. When seeing
+        * that, use the size instead.
+        */
+       if (!(disk_bytes & 0xfffff))
+               disk_bytes = size+511;
+       fattr->f_size = size;
+       fattr->f_blocks = disk_bytes >> 9;
+       fattr->f_ctime = smb_ntutc2unixutc(LVAL(p, 16));
+       fattr->f_atime = smb_ntutc2unixutc(LVAL(p, 24));
+       fattr->f_mtime = smb_ntutc2unixutc(LVAL(p, 32));
+       if (server->mnt->flags & SMB_MOUNT_UID)
+               fattr->f_uid = server->mnt->uid;
+       else
+               fattr->f_uid = LVAL(p, 40);
+       if (server->mnt->flags & SMB_MOUNT_GID)
+               fattr->f_gid = server->mnt->gid;
+       else
+               fattr->f_gid = LVAL(p, 48);
+       fattr->f_mode |= smb_filetype_to_mode(WVAL(p, 56));
+       if (S_ISBLK(fattr->f_mode) || S_ISCHR(fattr->f_mode)) {
+               __u64 major = LVAL(p, 60);
+               __u64 minor = LVAL(p, 68);
+               fattr->f_rdev = MKDEV(major & 0xffffffff, minor & 0xffffffff);
+               if (MAJOR(fattr->f_rdev) != (major & 0xffffffff) ||
+               MINOR(fattr->f_rdev) != (minor & 0xffffffff))
+                       fattr->f_rdev = 0;
+       }
+       fattr->f_mode |= LVAL(p, 84);
+       if ( (server->mnt->flags & SMB_MOUNT_DMODE) &&
+            (S_ISDIR(fattr->f_mode)) )
+               fattr->f_mode = (server->mnt->dir_mode & S_IRWXUGO) | S_IFDIR;
+       else if ( (server->mnt->flags & SMB_MOUNT_FMODE) &&
+                 !(S_ISDIR(fattr->f_mode)) )
+               fattr->f_mode = (server->mnt->file_mode & S_IRWXUGO) |
+                               (fattr->f_mode & S_IFMT);
+ }
+ /*
+  * Interpret a long filename structure using the specified info level:
+  *   level 1 for anything below NT1 protocol
+  *   level 260 for NT1 protocol
+  *
+  * qname is filled with the decoded, and possibly translated, name
+  * fattr receives decoded attributes.
+  *
+  * Bugs Noted:
+  * (1) Win NT 4.0 appends a null byte to names and counts it in the length!
+  */
+ static char *
+ smb_decode_long_dirent(struct smb_sb_info *server, char *p, int level,
+                      struct qstr *qname, struct smb_fattr *fattr,
+                      unsigned char *name_buf)
+ {
+       char *result;
+       unsigned int len = 0;
+       int n;
+       __u16 date, time;
+       int unicode = (server->mnt->flags & SMB_MOUNT_UNICODE);
+       /*
+        * SMB doesn't have a concept of inode numbers ...
+        */
+       smb_init_dirent(server, fattr);
+       fattr->f_ino = 0;       /* FIXME: do we need this? */
+       switch (level) {
+       case 1:
+               len = *((unsigned char *) p + 22);
+               qname->name = p + 23;
+               result = p + 24 + len;
+               date = WVAL(p, 0);
+               time = WVAL(p, 2);
+               fattr->f_ctime.tv_sec = date_dos2unix(server, date, time);
+               fattr->f_ctime.tv_nsec = 0;
+               date = WVAL(p, 4);
+               time = WVAL(p, 6);
+               fattr->f_atime.tv_sec = date_dos2unix(server, date, time);
+               fattr->f_atime.tv_nsec = 0;
+               date = WVAL(p, 8);
+               time = WVAL(p, 10);
+               fattr->f_mtime.tv_sec = date_dos2unix(server, date, time);
+               fattr->f_mtime.tv_nsec = 0;
+               fattr->f_size = DVAL(p, 12);
+               /* ULONG allocation size */
+               fattr->attr = WVAL(p, 20);
+               VERBOSE("info 1 at %p, len=%d, name=%.*s\n",
+                       p, len, len, qname->name);
+               break;
+       case 260:
+               result = p + WVAL(p, 0);
+               len = DVAL(p, 60);
+               if (len > 255) len = 255;
+               /* NT4 null terminates, unless we are using unicode ... */
+               qname->name = p + 94;
+               if (!unicode && len && qname->name[len-1] == '\0')
+                       len--;
+               fattr->f_ctime = smb_ntutc2unixutc(LVAL(p, 8));
+               fattr->f_atime = smb_ntutc2unixutc(LVAL(p, 16));
+               fattr->f_mtime = smb_ntutc2unixutc(LVAL(p, 24));
+               /* change time (32) */
+               fattr->f_size = LVAL(p, 40);
+               /* alloc size (48) */
+               fattr->attr = DVAL(p, 56);
+               VERBOSE("info 260 at %p, len=%d, name=%.*s\n",
+                       p, len, len, qname->name);
+               break;
+       case SMB_FIND_FILE_UNIX:
+               result = p + WVAL(p, 0);
+               qname->name = p + 108;
+               len = strlen(qname->name);
+               /* FIXME: should we check the length?? */
+               p += 8;
+               smb_decode_unix_basic(fattr, server, p);
+               VERBOSE("info SMB_FIND_FILE_UNIX at %p, len=%d, name=%.*s\n",
+                       p, len, len, qname->name);
+               break;
+       default:
+               PARANOIA("Unknown info level %d\n", level);
+               result = p + WVAL(p, 0);
+               goto out;
+       }
+       smb_finish_dirent(server, fattr);
+ #if 0
+       /* FIXME: These only work for ascii chars, and recent smbmount doesn't
+          allow the flag to be set anyway. Remove? */
+       switch (server->opt.case_handling) {
+       case SMB_CASE_UPPER:
+               str_upper(qname->name, len);
+               break;
+       case SMB_CASE_LOWER:
+               str_lower(qname->name, len);
+               break;
+       default:
+               break;
+       }
+ #endif
+       qname->len = 0;
+       n = server->ops->convert(name_buf, SMB_MAXNAMELEN,
+                                qname->name, len,
+                                server->remote_nls, server->local_nls);
+       if (n > 0) {
+               qname->len = n;
+               qname->name = name_buf;
+       }
+ out:
+       return result;
+ }
+ /* findfirst/findnext flags */
+ #define SMB_CLOSE_AFTER_FIRST (1<<0)
+ #define SMB_CLOSE_IF_END (1<<1)
+ #define SMB_REQUIRE_RESUME_KEY (1<<2)
+ #define SMB_CONTINUE_BIT (1<<3)
+ /*
+  * Note: samba-2.0.7 (at least) has a very similar routine, cli_list, in
+  * source/libsmb/clilist.c. When looking for smb bugs in the readdir code,
+  * go there for advise.
+  *
+  * Bugs Noted:
+  * (1) When using Info Level 1 Win NT 4.0 truncates directory listings 
+  * for certain patterns of names and/or lengths. The breakage pattern
+  * is completely reproducible and can be toggled by the creation of a
+  * single file. (E.g. echo hi >foo breaks, rm -f foo works.)
+  */
+ static int
+ smb_proc_readdir_long(struct file *filp, void *dirent, filldir_t filldir,
+                     struct smb_cache_control *ctl)
+ {
+       struct dentry *dir = filp->f_path.dentry;
+       struct smb_sb_info *server = server_from_dentry(dir);
+       struct qstr qname;
+       struct smb_fattr fattr;
+       unsigned char *p, *lastname;
+       char *mask, *param;
+       __u16 command;
+       int first, entries_seen;
+       /* Both NT and OS/2 accept info level 1 (but see note below). */
+       int info_level = 260;
+       const int max_matches = 512;
+       unsigned int ff_searchcount = 0;
+       unsigned int ff_eos = 0;
+       unsigned int ff_lastname = 0;
+       unsigned int ff_dir_handle = 0;
+       unsigned int loop_count = 0;
+       unsigned int mask_len, i;
+       int result;
+       struct smb_request *req;
+       unsigned char *name_buf;
+       static struct qstr star = {
+               .name   = "*",
+               .len    = 1,
+       };
+       lock_kernel();
+       /*
+        * We always prefer unix style. Use info level 1 for older
+        * servers that don't do 260.
+        */
+       if (server->opt.capabilities & SMB_CAP_UNIX)
+               info_level = SMB_FIND_FILE_UNIX;
+       else if (server->opt.protocol < SMB_PROTOCOL_NT1)
+               info_level = 1;
+       result = -ENOMEM;
+       if (! (name_buf = kmalloc(SMB_MAXNAMELEN+2, GFP_KERNEL)))
+               goto out;
+       if (! (req = smb_alloc_request(server, server->opt.max_xmit)))
+               goto out_name;
+       param = req->rq_buffer;
+       /*
+        * Encode the initial path
+        */
+       mask = param + 12;
+       result = smb_encode_path(server, mask, SMB_MAXPATHLEN+1, dir, &star);
+       if (result <= 0)
+               goto out_free;
+       mask_len = result - 1;  /* mask_len is strlen, not #bytes */
+       result = 0;
+       first = 1;
+       VERBOSE("starting mask_len=%d, mask=%s\n", mask_len, mask);
+       entries_seen = 2;
+       ff_eos = 0;
+       while (ff_eos == 0) {
+               loop_count += 1;
+               if (loop_count > 10) {
+                       printk(KERN_WARNING "smb_proc_readdir_long: "
+                              "Looping in FIND_NEXT??\n");
+                       result = -EIO;
+                       break;
+               }
+               if (first != 0) {
+                       command = TRANSACT2_FINDFIRST;
+                       WSET(param, 0, aSYSTEM | aHIDDEN | aDIR);
+                       WSET(param, 2, max_matches);    /* max count */
+                       WSET(param, 4, SMB_CLOSE_IF_END);
+                       WSET(param, 6, info_level);
+                       DSET(param, 8, 0);
+               } else {
+                       command = TRANSACT2_FINDNEXT;
+                       VERBOSE("handle=0x%X, lastname=%d, mask=%.*s\n",
+                               ff_dir_handle, ff_lastname, mask_len, mask);
+                       WSET(param, 0, ff_dir_handle);  /* search handle */
+                       WSET(param, 2, max_matches);    /* max count */
+                       WSET(param, 4, info_level);
+                       DSET(param, 6, 0);
+                       WSET(param, 10, SMB_CONTINUE_BIT|SMB_CLOSE_IF_END);
+               }
+               req->rq_trans2_command = command;
+               req->rq_ldata = 0;
+               req->rq_data  = NULL;
+               req->rq_lparm = 12 + mask_len + 1;
+               req->rq_parm  = param;
+               req->rq_flags = 0;
+               result = smb_add_request(req);
+               if (result < 0) {
+                       PARANOIA("error=%d, breaking\n", result);
+                       break;
+               }
+               if (req->rq_rcls == ERRSRV && req->rq_err == ERRerror) {
+                       /* a damn Win95 bug - sometimes it clags if you 
+                          ask it too fast */
+                       schedule_timeout_interruptible(msecs_to_jiffies(200));
+                       continue;
+                 }
+               if (req->rq_rcls != 0) {
+                       result = smb_errno(req);
+                       PARANOIA("name=%s, result=%d, rcls=%d, err=%d\n",
+                                mask, result, req->rq_rcls, req->rq_err);
+                       break;
+               }
+               /* parse out some important return info */
+               if (first != 0) {
+                       ff_dir_handle = WVAL(req->rq_parm, 0);
+                       ff_searchcount = WVAL(req->rq_parm, 2);
+                       ff_eos = WVAL(req->rq_parm, 4);
+                       ff_lastname = WVAL(req->rq_parm, 8);
+               } else {
+                       ff_searchcount = WVAL(req->rq_parm, 0);
+                       ff_eos = WVAL(req->rq_parm, 2);
+                       ff_lastname = WVAL(req->rq_parm, 6);
+               }
+               if (ff_searchcount == 0)
+                       break;
+               /* Now we are ready to parse smb directory entries. */
+               /* point to the data bytes */
+               p = req->rq_data;
+               for (i = 0; i < ff_searchcount; i++) {
+                       /* make sure we stay within the buffer */
+                       if (p >= req->rq_data + req->rq_ldata) {
+                               printk(KERN_ERR "smb_proc_readdir_long: "
+                                      "dirent pointer outside buffer! "
+                                      "%p  %d@%p\n",
+                                      p, req->rq_ldata, req->rq_data);
+                               result = -EIO; /* always a comm. error? */
+                               goto out_free;
+                       }
+                       p = smb_decode_long_dirent(server, p, info_level,
+                                                  &qname, &fattr, name_buf);
+                       /* ignore . and .. from the server */
+                       if (entries_seen == 2 && qname.name[0] == '.') {
+                               if (qname.len == 1)
+                                       continue;
+                               if (qname.name[1] == '.' && qname.len == 2)
+                                       continue;
+                       }
+                       if (!smb_fill_cache(filp, dirent, filldir, ctl, 
+                                           &qname, &fattr))
+                               ;       /* stop reading? */
+                       entries_seen++;
+               }
+               VERBOSE("received %d entries, eos=%d\n", ff_searchcount,ff_eos);
+               /*
+                * We might need the lastname for continuations.
+                *
+                * Note that some servers (win95?) point to the filename and
+                * others (NT4, Samba using NT1) to the dir entry. We assume
+                * here that those who do not point to a filename do not need
+                * this info to continue the listing.
+                *
+                * OS/2 needs this and talks infolevel 1.
+                * NetApps want lastname with infolevel 260.
+                * win2k want lastname with infolevel 260, and points to
+                *       the record not to the name.
+                * Samba+CifsUnixExt doesn't need lastname.
+                *
+                * Both are happy if we return the data they point to. So we do.
+                * (FIXME: above is not true with win2k)
+                */
+               mask_len = 0;
+               if (info_level != SMB_FIND_FILE_UNIX &&
+                   ff_lastname > 0 && ff_lastname < req->rq_ldata) {
+                       lastname = req->rq_data + ff_lastname;
+                       switch (info_level) {
+                       case 260:
+                               mask_len = req->rq_ldata - ff_lastname;
+                               break;
+                       case 1:
+                               /* lastname points to a length byte */
+                               mask_len = *lastname++;
+                               if (ff_lastname + 1 + mask_len > req->rq_ldata)
+                                       mask_len = req->rq_ldata - ff_lastname - 1;
+                               break;
+                       }
+                       /*
+                        * Update the mask string for the next message.
+                        */
+                       if (mask_len > 255)
+                               mask_len = 255;
+                       if (mask_len)
+                               strncpy(mask, lastname, mask_len);
+               }
+               mask_len = strnlen(mask, mask_len);
+               VERBOSE("new mask, len=%d@%d of %d, mask=%.*s\n",
+                       mask_len, ff_lastname, req->rq_ldata, mask_len, mask);
+               first = 0;
+               loop_count = 0;
+       }
+ out_free:
+       smb_rput(req);
+ out_name:
+       kfree(name_buf);
+ out:
+       unlock_kernel();
+       return result;
+ }
+ /*
+  * This version uses the trans2 TRANSACT2_FINDFIRST message 
+  * to get the attribute data.
+  *
+  * Bugs Noted:
+  */
+ static int
+ smb_proc_getattr_ff(struct smb_sb_info *server, struct dentry *dentry,
+                       struct smb_fattr *fattr)
+ {
+       char *param, *mask;
+       __u16 date, time;
+       int mask_len, result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       param = req->rq_buffer;
+       mask = param + 12;
+       mask_len = smb_encode_path(server, mask, SMB_MAXPATHLEN+1, dentry,NULL);
+       if (mask_len < 0) {
+               result = mask_len;
+               goto out_free;
+       }
+       VERBOSE("name=%s, len=%d\n", mask, mask_len);
+       WSET(param, 0, aSYSTEM | aHIDDEN | aDIR);
+       WSET(param, 2, 1);      /* max count */
+       WSET(param, 4, 1);      /* close after this call */
+       WSET(param, 6, 1);      /* info_level */
+       DSET(param, 8, 0);
+       req->rq_trans2_command = TRANSACT2_FINDFIRST;
+       req->rq_ldata = 0;
+       req->rq_data  = NULL;
+       req->rq_lparm = 12 + mask_len;
+       req->rq_parm  = param;
+       req->rq_flags = 0;
+       result = smb_add_request(req);
+       if (result < 0)
+               goto out_free;
+       if (req->rq_rcls != 0) {
+               result = smb_errno(req);
+ #ifdef SMBFS_PARANOIA
+               if (result != -ENOENT)
+                       PARANOIA("error for %s, rcls=%d, err=%d\n",
+                                mask, req->rq_rcls, req->rq_err);
+ #endif
+               goto out_free;
+       }
+       /* Make sure we got enough data ... */
+       result = -EINVAL;
+       if (req->rq_ldata < 22 || WVAL(req->rq_parm, 2) != 1) {
+               PARANOIA("bad result for %s, len=%d, count=%d\n",
+                        mask, req->rq_ldata, WVAL(req->rq_parm, 2));
+               goto out_free;
+       }
+       /*
+        * Decode the response into the fattr ...
+        */
+       date = WVAL(req->rq_data, 0);
+       time = WVAL(req->rq_data, 2);
+       fattr->f_ctime.tv_sec = date_dos2unix(server, date, time);
+       fattr->f_ctime.tv_nsec = 0;
+       date = WVAL(req->rq_data, 4);
+       time = WVAL(req->rq_data, 6);
+       fattr->f_atime.tv_sec = date_dos2unix(server, date, time);
+       fattr->f_atime.tv_nsec = 0;
+       date = WVAL(req->rq_data, 8);
+       time = WVAL(req->rq_data, 10);
+       fattr->f_mtime.tv_sec = date_dos2unix(server, date, time);
+       fattr->f_mtime.tv_nsec = 0;
+       VERBOSE("name=%s, date=%x, time=%x, mtime=%ld\n",
+               mask, date, time, fattr->f_mtime.tv_sec);
+       fattr->f_size = DVAL(req->rq_data, 12);
+       /* ULONG allocation size */
+       fattr->attr = WVAL(req->rq_data, 20);
+       result = 0;
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ static int
+ smb_proc_getattr_core(struct smb_sb_info *server, struct dentry *dir,
+                     struct smb_fattr *fattr)
+ {
+       int result;
+       char *p;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       p = smb_setup_header(req, SMBgetatr, 0, 0);
+       result = smb_simple_encode_path(req, &p, dir, NULL);
+       if (result < 0)
+               goto out_free;
+       smb_setup_bcc(req, p);
+       if ((result = smb_request_ok(req, SMBgetatr, 10, 0)) < 0)
+               goto out_free;
+       fattr->attr    = WVAL(req->rq_header, smb_vwv0);
+       fattr->f_mtime.tv_sec = local2utc(server, DVAL(req->rq_header, smb_vwv1));
+       fattr->f_mtime.tv_nsec = 0;
+       fattr->f_size  = DVAL(req->rq_header, smb_vwv3);
+       fattr->f_ctime = fattr->f_mtime; 
+       fattr->f_atime = fattr->f_mtime; 
+ #ifdef SMBFS_DEBUG_TIMESTAMP
+       printk("getattr_core: %s/%s, mtime=%ld\n",
+              DENTRY_PATH(dir), fattr->f_mtime);
+ #endif
+       result = 0;
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ /*
+  * Bugs Noted:
+  * (1) Win 95 swaps the date and time fields in the standard info level.
+  */
+ static int
+ smb_proc_getattr_trans2(struct smb_sb_info *server, struct dentry *dir,
+                       struct smb_request *req, int infolevel)
+ {
+       char *p, *param;
+       int result;
+       param = req->rq_buffer;
+       WSET(param, 0, infolevel);
+       DSET(param, 2, 0);
+       result = smb_encode_path(server, param+6, SMB_MAXPATHLEN+1, dir, NULL);
+       if (result < 0)
+               goto out;
+       p = param + 6 + result;
+       req->rq_trans2_command = TRANSACT2_QPATHINFO;
+       req->rq_ldata = 0;
+       req->rq_data  = NULL;
+       req->rq_lparm = p - param;
+       req->rq_parm  = param;
+       req->rq_flags = 0;
+       result = smb_add_request(req);
+       if (result < 0)
+               goto out;
+       if (req->rq_rcls != 0) {
+               VERBOSE("for %s: result=%d, rcls=%d, err=%d\n",
+                       &param[6], result, req->rq_rcls, req->rq_err);
+               result = smb_errno(req);
+               goto out;
+       }
+       result = -ENOENT;
+       if (req->rq_ldata < 22) {
+               PARANOIA("not enough data for %s, len=%d\n",
+                        &param[6], req->rq_ldata);
+               goto out;
+       }
+       result = 0;
+ out:
+       return result;
+ }
+ static int
+ smb_proc_getattr_trans2_std(struct smb_sb_info *server, struct dentry *dir,
+                           struct smb_fattr *attr)
+ {
+       u16 date, time;
+       int off_date = 0, off_time = 2;
+       int result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       result = smb_proc_getattr_trans2(server, dir, req, SMB_INFO_STANDARD);
+       if (result < 0)
+               goto out_free;
+       /*
+        * Kludge alert: Win 95 swaps the date and time field,
+        * contrary to the CIFS docs and Win NT practice.
+        */
+       if (server->mnt->flags & SMB_MOUNT_WIN95) {
+               off_date = 2;
+               off_time = 0;
+       }
+       date = WVAL(req->rq_data, off_date);
+       time = WVAL(req->rq_data, off_time);
+       attr->f_ctime.tv_sec = date_dos2unix(server, date, time);
+       attr->f_ctime.tv_nsec = 0;
+       date = WVAL(req->rq_data, 4 + off_date);
+       time = WVAL(req->rq_data, 4 + off_time);
+       attr->f_atime.tv_sec = date_dos2unix(server, date, time);
+       attr->f_atime.tv_nsec = 0;
+       date = WVAL(req->rq_data, 8 + off_date);
+       time = WVAL(req->rq_data, 8 + off_time);
+       attr->f_mtime.tv_sec = date_dos2unix(server, date, time);
+       attr->f_mtime.tv_nsec = 0;
+ #ifdef SMBFS_DEBUG_TIMESTAMP
+       printk(KERN_DEBUG "getattr_trans2: %s/%s, date=%x, time=%x, mtime=%ld\n",
+              DENTRY_PATH(dir), date, time, attr->f_mtime);
+ #endif
+       attr->f_size = DVAL(req->rq_data, 12);
+       attr->attr = WVAL(req->rq_data, 20);
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ static int
+ smb_proc_getattr_trans2_all(struct smb_sb_info *server, struct dentry *dir,
+                           struct smb_fattr *attr)
+ {
+       struct smb_request *req;
+       int result;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       result = smb_proc_getattr_trans2(server, dir, req,
+                                        SMB_QUERY_FILE_ALL_INFO);
+       if (result < 0)
+               goto out_free;
+       attr->f_ctime = smb_ntutc2unixutc(LVAL(req->rq_data, 0));
+       attr->f_atime = smb_ntutc2unixutc(LVAL(req->rq_data, 8));
+       attr->f_mtime = smb_ntutc2unixutc(LVAL(req->rq_data, 16));
+       /* change (24) */
+       attr->attr = WVAL(req->rq_data, 32);
+       /* pad? (34) */
+       /* allocated size (40) */
+       attr->f_size = LVAL(req->rq_data, 48);
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ static int
+ smb_proc_getattr_unix(struct smb_sb_info *server, struct dentry *dir,
+                     struct smb_fattr *attr)
+ {
+       struct smb_request *req;
+       int result;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       result = smb_proc_getattr_trans2(server, dir, req,
+                                        SMB_QUERY_FILE_UNIX_BASIC);
+       if (result < 0)
+               goto out_free;
+       smb_decode_unix_basic(attr, server, req->rq_data);
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ static int
+ smb_proc_getattr_95(struct smb_sb_info *server, struct dentry *dir,
+                   struct smb_fattr *attr)
+ {
+       struct inode *inode = dir->d_inode;
+       int result;
+       /* FIXME: why not use the "all" version? */
+       result = smb_proc_getattr_trans2_std(server, dir, attr);
+       if (result < 0)
+               goto out;
+       /*
+        * None of the getattr versions here can make win9x return the right
+        * filesize if there are changes made to an open file.
+        * A seek-to-end does return the right size, but we only need to do
+        * that on files we have written.
+        */
+       if (inode && SMB_I(inode)->flags & SMB_F_LOCALWRITE &&
+           smb_is_open(inode))
+       {
+               __u16 fileid = SMB_I(inode)->fileid;
+               attr->f_size = smb_proc_seek(server, fileid, 2, 0);
+       }
+ out:
+       return result;
+ }
+ static int
+ smb_proc_ops_wait(struct smb_sb_info *server)
+ {
+       int result;
+       result = wait_event_interruptible_timeout(server->conn_wq,
+                               server->conn_complete, 30*HZ);
+       if (!result || signal_pending(current))
+               return -EIO;
+       return 0;
+ }
+ static int
+ smb_proc_getattr_null(struct smb_sb_info *server, struct dentry *dir,
+                         struct smb_fattr *fattr)
+ {
+       int result;
+       if (smb_proc_ops_wait(server) < 0)
+               return -EIO;
+       smb_init_dirent(server, fattr);
+       result = server->ops->getattr(server, dir, fattr);
+       smb_finish_dirent(server, fattr);
+       return result;
+ }
+ static int
+ smb_proc_readdir_null(struct file *filp, void *dirent, filldir_t filldir,
+                     struct smb_cache_control *ctl)
+ {
+       struct smb_sb_info *server = server_from_dentry(filp->f_path.dentry);
+       if (smb_proc_ops_wait(server) < 0)
+               return -EIO;
+       return server->ops->readdir(filp, dirent, filldir, ctl);
+ }
+ int
+ smb_proc_getattr(struct dentry *dir, struct smb_fattr *fattr)
+ {
+       struct smb_sb_info *server = server_from_dentry(dir);
+       int result;
+       smb_init_dirent(server, fattr);
+       result = server->ops->getattr(server, dir, fattr);
+       smb_finish_dirent(server, fattr);
+       return result;
+ }
+ /*
+  * Because of bugs in the core protocol, we use this only to set
+  * attributes. See smb_proc_settime() below for timestamp handling.
+  *
+  * Bugs Noted:
+  * (1) If mtime is non-zero, both Win 3.1 and Win 95 fail
+  * with an undocumented error (ERRDOS code 50). Setting
+  * mtime to 0 allows the attributes to be set.
+  * (2) The extra parameters following the name string aren't
+  * in the CIFS docs, but seem to be necessary for operation.
+  */
+ static int
+ smb_proc_setattr_core(struct smb_sb_info *server, struct dentry *dentry,
+                     __u16 attr)
+ {
+       char *p;
+       int result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       p = smb_setup_header(req, SMBsetatr, 8, 0);
+       WSET(req->rq_header, smb_vwv0, attr);
+       DSET(req->rq_header, smb_vwv1, 0); /* mtime */
+       WSET(req->rq_header, smb_vwv3, 0); /* reserved values */
+       WSET(req->rq_header, smb_vwv4, 0);
+       WSET(req->rq_header, smb_vwv5, 0);
+       WSET(req->rq_header, smb_vwv6, 0);
+       WSET(req->rq_header, smb_vwv7, 0);
+       result = smb_simple_encode_path(req, &p, dentry, NULL);
+       if (result < 0)
+               goto out_free;
+       if (p + 2 > (char *)req->rq_buffer + req->rq_bufsize) {
+               result = -ENAMETOOLONG;
+               goto out_free;
+       }
+       *p++ = 4;
+       *p++ = 0;
+       smb_setup_bcc(req, p);
+       result = smb_request_ok(req, SMBsetatr, 0, 0);
+       if (result < 0)
+               goto out_free;
+       result = 0;
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ /*
+  * Because of bugs in the trans2 setattr messages, we must set
+  * attributes and timestamps separately. The core SMBsetatr
+  * message seems to be the only reliable way to set attributes.
+  */
+ int
+ smb_proc_setattr(struct dentry *dir, struct smb_fattr *fattr)
+ {
+       struct smb_sb_info *server = server_from_dentry(dir);
+       int result;
+       VERBOSE("setting %s/%s, open=%d\n", 
+               DENTRY_PATH(dir), smb_is_open(dir->d_inode));
+       result = smb_proc_setattr_core(server, dir, fattr->attr);
+       return result;
+ }
+ /*
+  * Sets the timestamps for an file open with write permissions.
+  */
+ static int
+ smb_proc_setattr_ext(struct smb_sb_info *server,
+                     struct inode *inode, struct smb_fattr *fattr)
+ {
+       __u16 date, time;
+       int result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, 0)))
+               goto out;
+       smb_setup_header(req, SMBsetattrE, 7, 0);
+       WSET(req->rq_header, smb_vwv0, SMB_I(inode)->fileid);
+       /* We don't change the creation time */
+       WSET(req->rq_header, smb_vwv1, 0);
+       WSET(req->rq_header, smb_vwv2, 0);
+       date_unix2dos(server, fattr->f_atime.tv_sec, &date, &time);
+       WSET(req->rq_header, smb_vwv3, date);
+       WSET(req->rq_header, smb_vwv4, time);
+       date_unix2dos(server, fattr->f_mtime.tv_sec, &date, &time);
+       WSET(req->rq_header, smb_vwv5, date);
+       WSET(req->rq_header, smb_vwv6, time);
+ #ifdef SMBFS_DEBUG_TIMESTAMP
+       printk(KERN_DEBUG "smb_proc_setattr_ext: date=%d, time=%d, mtime=%ld\n",
+              date, time, fattr->f_mtime);
+ #endif
+       req->rq_flags |= SMB_REQ_NORETRY;
+       result = smb_request_ok(req, SMBsetattrE, 0, 0);
+       if (result < 0)
+               goto out_free;
+       result = 0;
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ /*
+  * Bugs Noted:
+  * (1) The TRANSACT2_SETPATHINFO message under Win NT 4.0 doesn't
+  * set the file's attribute flags.
+  */
+ static int
+ smb_proc_setattr_trans2(struct smb_sb_info *server,
+                       struct dentry *dir, struct smb_fattr *fattr)
+ {
+       __u16 date, time;
+       char *p, *param;
+       int result;
+       char data[26];
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       param = req->rq_buffer;
+       WSET(param, 0, 1);      /* Info level SMB_INFO_STANDARD */
+       DSET(param, 2, 0);
+       result = smb_encode_path(server, param+6, SMB_MAXPATHLEN+1, dir, NULL);
+       if (result < 0)
+               goto out_free;
+       p = param + 6 + result;
+       WSET(data, 0, 0); /* creation time */
+       WSET(data, 2, 0);
+       date_unix2dos(server, fattr->f_atime.tv_sec, &date, &time);
+       WSET(data, 4, date);
+       WSET(data, 6, time);
+       date_unix2dos(server, fattr->f_mtime.tv_sec, &date, &time);
+       WSET(data, 8, date);
+       WSET(data, 10, time);
+ #ifdef SMBFS_DEBUG_TIMESTAMP
+       printk(KERN_DEBUG "setattr_trans2: %s/%s, date=%x, time=%x, mtime=%ld\n", 
+              DENTRY_PATH(dir), date, time, fattr->f_mtime);
+ #endif
+       DSET(data, 12, 0); /* size */
+       DSET(data, 16, 0); /* blksize */
+       WSET(data, 20, 0); /* attr */
+       DSET(data, 22, 0); /* ULONG EA size */
+       req->rq_trans2_command = TRANSACT2_SETPATHINFO;
+       req->rq_ldata = 26;
+       req->rq_data  = data;
+       req->rq_lparm = p - param;
+       req->rq_parm  = param;
+       req->rq_flags = 0;
+       result = smb_add_request(req);
+       if (result < 0)
+               goto out_free;
+       result = 0;
+       if (req->rq_rcls != 0)
+               result = smb_errno(req);
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ /*
+  * ATTR_MODE      0x001
+  * ATTR_UID       0x002
+  * ATTR_GID       0x004
+  * ATTR_SIZE      0x008
+  * ATTR_ATIME     0x010
+  * ATTR_MTIME     0x020
+  * ATTR_CTIME     0x040
+  * ATTR_ATIME_SET 0x080
+  * ATTR_MTIME_SET 0x100
+  * ATTR_FORCE     0x200       
+  * ATTR_ATTR_FLAG 0x400
+  *
+  * major/minor should only be set by mknod.
+  */
+ int
+ smb_proc_setattr_unix(struct dentry *d, struct iattr *attr,
+                     unsigned int major, unsigned int minor)
+ {
+       struct smb_sb_info *server = server_from_dentry(d);
+       u64 nttime;
+       char *p, *param;
+       int result;
+       char data[100];
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       param = req->rq_buffer;
+       DEBUG1("valid flags = 0x%04x\n", attr->ia_valid);
+       WSET(param, 0, SMB_SET_FILE_UNIX_BASIC);
+       DSET(param, 2, 0);
+       result = smb_encode_path(server, param+6, SMB_MAXPATHLEN+1, d, NULL);
+       if (result < 0)
+               goto out_free;
+       p = param + 6 + result;
+       /* 0 L file size in bytes */
+       /* 8 L file size on disk in bytes (block count) */
+       /* 40 L uid */
+       /* 48 L gid */
+       /* 56 W file type enum */
+       /* 60 L devmajor */
+       /* 68 L devminor */
+       /* 76 L unique ID (inode) */
+       /* 84 L permissions */
+       /* 92 L link count */
+       LSET(data, 0, SMB_SIZE_NO_CHANGE);
+       LSET(data, 8, SMB_SIZE_NO_CHANGE);
+       LSET(data, 16, SMB_TIME_NO_CHANGE);
+       LSET(data, 24, SMB_TIME_NO_CHANGE);
+       LSET(data, 32, SMB_TIME_NO_CHANGE);
+       LSET(data, 40, SMB_UID_NO_CHANGE);
+       LSET(data, 48, SMB_GID_NO_CHANGE);
+       DSET(data, 56, smb_filetype_from_mode(attr->ia_mode));
+       LSET(data, 60, major);
+       LSET(data, 68, minor);
+       LSET(data, 76, 0);
+       LSET(data, 84, SMB_MODE_NO_CHANGE);
+       LSET(data, 92, 0);
+       if (attr->ia_valid & ATTR_SIZE) {
+               LSET(data, 0, attr->ia_size);
+               LSET(data, 8, 0); /* can't set anyway */
+       }
+       /*
+        * FIXME: check the conversion function it the correct one
+        *
+        * we can't set ctime but we might as well pass this to the server
+        * and let it ignore it.
+        */
+       if (attr->ia_valid & ATTR_CTIME) {
+               nttime = smb_unixutc2ntutc(attr->ia_ctime);
+               LSET(data, 16, nttime);
+       }
+       if (attr->ia_valid & ATTR_ATIME) {
+               nttime = smb_unixutc2ntutc(attr->ia_atime);
+               LSET(data, 24, nttime);
+       }
+       if (attr->ia_valid & ATTR_MTIME) {
+               nttime = smb_unixutc2ntutc(attr->ia_mtime);
+               LSET(data, 32, nttime);
+       }
+       
+       if (attr->ia_valid & ATTR_UID) {
+               LSET(data, 40, attr->ia_uid);
+       }
+       if (attr->ia_valid & ATTR_GID) {
+               LSET(data, 48, attr->ia_gid); 
+       }
+       
+       if (attr->ia_valid & ATTR_MODE) {
+               LSET(data, 84, attr->ia_mode);
+       }
+       req->rq_trans2_command = TRANSACT2_SETPATHINFO;
+       req->rq_ldata = 100;
+       req->rq_data  = data;
+       req->rq_lparm = p - param;
+       req->rq_parm  = param;
+       req->rq_flags = 0;
+       result = smb_add_request(req);
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ /*
+  * Set the modify and access timestamps for a file.
+  *
+  * Incredibly enough, in all of SMB there is no message to allow
+  * setting both attributes and timestamps at once. 
+  *
+  * Bugs Noted:
+  * (1) Win 95 doesn't support the TRANSACT2_SETFILEINFO message 
+  * with info level 1 (INFO_STANDARD).
+  * (2) Win 95 seems not to support setting directory timestamps.
+  * (3) Under the core protocol apparently the only way to set the
+  * timestamp is to open and close the file.
+  */
+ int
+ smb_proc_settime(struct dentry *dentry, struct smb_fattr *fattr)
+ {
+       struct smb_sb_info *server = server_from_dentry(dentry);
+       struct inode *inode = dentry->d_inode;
+       int result;
+       VERBOSE("setting %s/%s, open=%d\n",
+               DENTRY_PATH(dentry), smb_is_open(inode));
+       /* setting the time on a Win95 server fails (tridge) */
+       if (server->opt.protocol >= SMB_PROTOCOL_LANMAN2 && 
+           !(server->mnt->flags & SMB_MOUNT_WIN95)) {
+               if (smb_is_open(inode) && SMB_I(inode)->access != SMB_O_RDONLY)
+                       result = smb_proc_setattr_ext(server, inode, fattr);
+               else
+                       result = smb_proc_setattr_trans2(server, dentry, fattr);
+       } else {
+               /*
+                * Fail silently on directories ... timestamp can't be set?
+                */
+               result = 0;
+               if (S_ISREG(inode->i_mode)) {
+                       /*
+                        * Set the mtime by opening and closing the file.
+                        * Note that the file is opened read-only, but this
+                        * still allows us to set the date (tridge)
+                        */
+                       result = -EACCES;
+                       if (!smb_is_open(inode))
+                               smb_proc_open(server, dentry, SMB_O_RDONLY);
+                       if (smb_is_open(inode)) {
+                               inode->i_mtime = fattr->f_mtime;
+                               result = smb_proc_close_inode(server, inode);
+                       }
+               }
+       }
+       return result;
+ }
+ int
+ smb_proc_dskattr(struct dentry *dentry, struct kstatfs *attr)
+ {
+       struct smb_sb_info *server = SMB_SB(dentry->d_sb);
+       int result;
+       char *p;
+       long unit;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, 0)))
+               goto out;
+       smb_setup_header(req, SMBdskattr, 0, 0);
+       if ((result = smb_request_ok(req, SMBdskattr, 5, 0)) < 0)
+               goto out_free;
+       p = SMB_VWV(req->rq_header);
+       unit = (WVAL(p, 2) * WVAL(p, 4)) >> SMB_ST_BLKSHIFT;
+       attr->f_blocks = WVAL(p, 0) * unit;
+       attr->f_bsize  = SMB_ST_BLKSIZE;
+       attr->f_bavail = attr->f_bfree = WVAL(p, 6) * unit;
+       result = 0;
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ int
+ smb_proc_read_link(struct smb_sb_info *server, struct dentry *d,
+                  char *buffer, int len)
+ {
+       char *p, *param;
+       int result;
+       struct smb_request *req;
+       DEBUG1("readlink of %s/%s\n", DENTRY_PATH(d));
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       param = req->rq_buffer;
+       WSET(param, 0, SMB_QUERY_FILE_UNIX_LINK);
+       DSET(param, 2, 0);
+       result = smb_encode_path(server, param+6, SMB_MAXPATHLEN+1, d, NULL);
+       if (result < 0)
+               goto out_free;
+       p = param + 6 + result;
+       req->rq_trans2_command = TRANSACT2_QPATHINFO;
+       req->rq_ldata = 0;
+       req->rq_data  = NULL;
+       req->rq_lparm = p - param;
+       req->rq_parm  = param;
+       req->rq_flags = 0;
+       result = smb_add_request(req);
+       if (result < 0)
+               goto out_free;
+       DEBUG1("for %s: result=%d, rcls=%d, err=%d\n",
+               &param[6], result, req->rq_rcls, req->rq_err);
+       /* copy data up to the \0 or buffer length */
+       result = len;
+       if (req->rq_ldata < len)
+               result = req->rq_ldata;
+       strncpy(buffer, req->rq_data, result);
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ /*
+  * Create a symlink object called dentry which points to oldpath.
+  * Samba does not permit dangling links but returns a suitable error message.
+  */
+ int
+ smb_proc_symlink(struct smb_sb_info *server, struct dentry *d,
+                const char *oldpath)
+ {
+       char *p, *param;
+       int result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       param = req->rq_buffer;
+       WSET(param, 0, SMB_SET_FILE_UNIX_LINK);
+       DSET(param, 2, 0);
+       result = smb_encode_path(server, param + 6, SMB_MAXPATHLEN+1, d, NULL);
+       if (result < 0)
+               goto out_free;
+       p = param + 6 + result;
+       req->rq_trans2_command = TRANSACT2_SETPATHINFO;
+       req->rq_ldata = strlen(oldpath) + 1;
+       req->rq_data  = (char *) oldpath;
+       req->rq_lparm = p - param;
+       req->rq_parm  = param;
+       req->rq_flags = 0;
+       result = smb_add_request(req);
+       if (result < 0)
+               goto out_free;
+       DEBUG1("for %s: result=%d, rcls=%d, err=%d\n",
+               &param[6], result, req->rq_rcls, req->rq_err);
+       result = 0;
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ /*
+  * Create a hard link object called new_dentry which points to dentry.
+  */
+ int
+ smb_proc_link(struct smb_sb_info *server, struct dentry *dentry,
+             struct dentry *new_dentry)
+ {
+       char *p, *param;
+       int result;
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, PAGE_SIZE)))
+               goto out;
+       param = req->rq_buffer;
+       WSET(param, 0, SMB_SET_FILE_UNIX_HLINK);
+       DSET(param, 2, 0);
+       result = smb_encode_path(server, param + 6, SMB_MAXPATHLEN+1,
+                                new_dentry, NULL);
+       if (result < 0)
+               goto out_free;
+       p = param + 6 + result;
+       /* Grr, pointless separation of parameters and data ... */
+       req->rq_data = p;
+       req->rq_ldata = smb_encode_path(server, p, SMB_MAXPATHLEN+1,
+                                       dentry, NULL);
+       req->rq_trans2_command = TRANSACT2_SETPATHINFO;
+       req->rq_lparm = p - param;
+       req->rq_parm  = param;
+       req->rq_flags = 0;
+       result = smb_add_request(req);
+       if (result < 0)
+               goto out_free;
+       DEBUG1("for %s: result=%d, rcls=%d, err=%d\n",
+              &param[6], result, req->rq_rcls, req->rq_err);
+       result = 0;
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ static int
+ smb_proc_query_cifsunix(struct smb_sb_info *server)
+ {
+       int result;
+       int major, minor;
+       u64 caps;
+       char param[2];
+       struct smb_request *req;
+       result = -ENOMEM;
+       if (! (req = smb_alloc_request(server, 100)))
+               goto out;
+       WSET(param, 0, SMB_QUERY_CIFS_UNIX_INFO);
+       req->rq_trans2_command = TRANSACT2_QFSINFO;
+       req->rq_ldata = 0;
+       req->rq_data  = NULL;
+       req->rq_lparm = 2;
+       req->rq_parm  = param;
+       req->rq_flags = 0;
+       result = smb_add_request(req);
+       if (result < 0)
+               goto out_free;
+       if (req->rq_ldata < 12) {
+               PARANOIA("Not enough data\n");
+               goto out_free;
+       }
+       major = WVAL(req->rq_data, 0);
+       minor = WVAL(req->rq_data, 2);
+       DEBUG1("Server implements CIFS Extensions for UNIX systems v%d.%d\n",
+              major, minor);
+       /* FIXME: verify that we are ok with this major/minor? */
+       caps = LVAL(req->rq_data, 4);
+       DEBUG1("Server capabilities 0x%016llx\n", caps);
+ out_free:
+       smb_rput(req);
+ out:
+       return result;
+ }
+ static void
+ install_ops(struct smb_ops *dst, struct smb_ops *src)
+ {
+       memcpy(dst, src, sizeof(void *) * SMB_OPS_NUM_STATIC);
+ }
+ /* < LANMAN2 */
+ static struct smb_ops smb_ops_core =
+ {
+       .read           = smb_proc_read,
+       .write          = smb_proc_write,
+       .readdir        = smb_proc_readdir_short,
+       .getattr        = smb_proc_getattr_core,
+       .truncate       = smb_proc_trunc32,
+ };
+ /* LANMAN2, OS/2, others? */
+ static struct smb_ops smb_ops_os2 =
+ {
+       .read           = smb_proc_read,
+       .write          = smb_proc_write,
+       .readdir        = smb_proc_readdir_long,
+       .getattr        = smb_proc_getattr_trans2_std,
+       .truncate       = smb_proc_trunc32,
+ };
+ /* Win95, and possibly some NetApp versions too */
+ static struct smb_ops smb_ops_win95 =
+ {
+       .read           = smb_proc_read,    /* does not support 12word readX */
+       .write          = smb_proc_write,
+       .readdir        = smb_proc_readdir_long,
+       .getattr        = smb_proc_getattr_95,
+       .truncate       = smb_proc_trunc95,
+ };
+ /* Samba, NT4 and NT5 */
+ static struct smb_ops smb_ops_winNT =
+ {
+       .read           = smb_proc_readX,
+       .write          = smb_proc_writeX,
+       .readdir        = smb_proc_readdir_long,
+       .getattr        = smb_proc_getattr_trans2_all,
+       .truncate       = smb_proc_trunc64,
+ };
+ /* Samba w/ unix extensions. Others? */
+ static struct smb_ops smb_ops_unix =
+ {
+       .read           = smb_proc_readX,
+       .write          = smb_proc_writeX,
+       .readdir        = smb_proc_readdir_long,
+       .getattr        = smb_proc_getattr_unix,
+       /* FIXME: core/ext/time setattr needs to be cleaned up! */
+       /* .setattr     = smb_proc_setattr_unix, */
+       .truncate       = smb_proc_trunc64,
+ };
+ /* Place holder until real ops are in place */
+ static struct smb_ops smb_ops_null =
+ {
+       .readdir        = smb_proc_readdir_null,
+       .getattr        = smb_proc_getattr_null,
+ };
+ void smb_install_null_ops(struct smb_ops *ops)
+ {
+       install_ops(ops, &smb_ops_null);
+ }
Simple merge
Simple merge
Simple merge
diff --cc fs/Kconfig
Simple merge
diff --cc fs/Makefile
Simple merge
diff --cc fs/compat.c
Simple merge
@@@ -1457,11 -1501,11 +1438,7 @@@ static long do_ioctl_trans(int fd, unsi
        case MTIOCGET32:
        case MTIOCPOS32:
                return mt_ioctl_trans(fd, cmd, argp);
 -      /* Raw devices */
 -      case RAW_SETBIND:
 -      case RAW_GETBIND:
 -              return raw_ioctl(fd, cmd, argp);
  #endif
-       /* One SMB ioctl needs translations. */
- #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t)
-       case SMB_IOC_GETMOUNTUID_32:
-               return do_smb_getmountuid(fd, cmd, argp);
        /* Serial */
        case TIOCGSERIAL:
        case TIOCSSERIAL:
Simple merge
Simple merge