switch ->create() to umode_t
[linux-2.6.git] / fs / ncpfs / dir.c
index a9f7a8a..98d1b8c 100644 (file)
  *
  */
 
-#include <linux/config.h>
 
 #include <linux/time.h>
 #include <linux/errno.h>
 #include <linux/stat.h>
 #include <linux/kernel.h>
-#include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/mm.h>
+#include <linux/namei.h>
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
-#include <linux/smp_lock.h>
 
-#include <linux/ncp_fs.h>
-
-#include "ncplib_kernel.h"
+#include "ncp_fs.h"
 
 static void ncp_read_volume_list(struct file *, void *, filldir_t,
                                struct ncp_cache_control *);
@@ -34,10 +30,10 @@ static void ncp_do_readdir(struct file *, void *, filldir_t,
 
 static int ncp_readdir(struct file *, void *, filldir_t);
 
-static int ncp_create(struct inode *, struct dentry *, int, struct nameidata *);
+static int ncp_create(struct inode *, struct dentry *, umode_t, struct nameidata *);
 static struct dentry *ncp_lookup(struct inode *, struct dentry *, struct nameidata *);
 static int ncp_unlink(struct inode *, struct dentry *);
-static int ncp_mkdir(struct inode *, struct dentry *, int);
+static int ncp_mkdir(struct inode *, struct dentry *, umode_t);
 static int ncp_rmdir(struct inode *, struct dentry *);
 static int ncp_rename(struct inode *, struct dentry *,
                      struct inode *, struct dentry *);
@@ -49,14 +45,18 @@ extern int ncp_symlink(struct inode *, struct dentry *, const char *);
 #define ncp_symlink NULL
 #endif
                      
-struct file_operations ncp_dir_operations =
+const struct file_operations ncp_dir_operations =
 {
+       .llseek         = generic_file_llseek,
        .read           = generic_read_dir,
        .readdir        = ncp_readdir,
-       .ioctl          = ncp_ioctl,
+       .unlocked_ioctl = ncp_ioctl,
+#ifdef CONFIG_COMPAT
+       .compat_ioctl   = ncp_compat_ioctl,
+#endif
 };
 
-struct inode_operations ncp_dir_inode_operations =
+const struct inode_operations ncp_dir_inode_operations =
 {
        .create         = ncp_create,
        .lookup         = ncp_lookup,
@@ -73,11 +73,14 @@ struct inode_operations ncp_dir_inode_operations =
  * Dentry operations routines
  */
 static int ncp_lookup_validate(struct dentry *, struct nameidata *);
-static int ncp_hash_dentry(struct dentry *, struct qstr *);
-static int ncp_compare_dentry (struct dentry *, struct qstr *, struct qstr *);
-static int ncp_delete_dentry(struct dentry *);
-
-static struct dentry_operations ncp_dentry_operations =
+static int ncp_hash_dentry(const struct dentry *, const struct inode *,
+               struct qstr *);
+static int ncp_compare_dentry(const struct dentry *, const struct inode *,
+               const struct dentry *, const struct inode *,
+               unsigned int, const char *, const struct qstr *);
+static int ncp_delete_dentry(const struct dentry *);
+
+const struct dentry_operations ncp_dentry_operations =
 {
        .d_revalidate   = ncp_lookup_validate,
        .d_hash         = ncp_hash_dentry,
@@ -85,28 +88,49 @@ static struct dentry_operations ncp_dentry_operations =
        .d_delete       = ncp_delete_dentry,
 };
 
-struct dentry_operations ncp_root_dentry_operations =
+#define ncp_namespace(i)       (NCP_SERVER(i)->name_space[NCP_FINFO(i)->volNumber])
+
+static inline int ncp_preserve_entry_case(struct inode *i, __u32 nscreator)
 {
-       .d_hash         = ncp_hash_dentry,
-       .d_compare      = ncp_compare_dentry,
-       .d_delete       = ncp_delete_dentry,
-};
+#ifdef CONFIG_NCPFS_SMALLDOS
+       int ns = ncp_namespace(i);
+
+       if ((ns == NW_NS_DOS)
+#ifdef CONFIG_NCPFS_OS2_NS
+               || ((ns == NW_NS_OS2) && (nscreator == NW_NS_DOS))
+#endif /* CONFIG_NCPFS_OS2_NS */
+          )
+               return 0;
+#endif /* CONFIG_NCPFS_SMALLDOS */
+       return 1;
+}
 
+#define ncp_preserve_case(i)   (ncp_namespace(i) != NW_NS_DOS)
+
+static inline int ncp_case_sensitive(const struct inode *i)
+{
+#ifdef CONFIG_NCPFS_NFS_NS
+       return ncp_namespace(i) == NW_NS_NFS;
+#else
+       return 0;
+#endif /* CONFIG_NCPFS_NFS_NS */
+}
 
 /*
  * Note: leave the hash unchanged if the directory
  * is case-sensitive.
  */
 static int 
-ncp_hash_dentry(struct dentry *dentry, struct qstr *this)
+ncp_hash_dentry(const struct dentry *dentry, const struct inode *inode,
+               struct qstr *this)
 {
-       struct nls_table *t;
-       unsigned long hash;
-       int i;
+       if (!ncp_case_sensitive(inode)) {
+               struct super_block *sb = dentry->d_sb;
+               struct nls_table *t;
+               unsigned long hash;
+               int i;
 
-       t = NCP_IO_TABLE(dentry);
-
-       if (!ncp_case_sensitive(dentry->d_inode)) {
+               t = NCP_IO_TABLE(sb);
                hash = init_name_hash();
                for (i=0; i<this->len ; i++)
                        hash = partial_name_hash(ncp_tolower(t, this->name[i]),
@@ -117,15 +141,17 @@ ncp_hash_dentry(struct dentry *dentry, struct qstr *this)
 }
 
 static int
-ncp_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)
+ncp_compare_dentry(const struct dentry *parent, const struct inode *pinode,
+               const struct dentry *dentry, const struct inode *inode,
+               unsigned int len, const char *str, const struct qstr *name)
 {
-       if (a->len != b->len)
+       if (len != name->len)
                return 1;
 
-       if (ncp_case_sensitive(dentry->d_inode))
-               return strncmp(a->name, b->name, a->len);
+       if (ncp_case_sensitive(pinode))
+               return strncmp(str, name->name, len);
 
-       return ncp_strnicmp(NCP_IO_TABLE(dentry), a->name, b->name, a->len);
+       return ncp_strnicmp(NCP_IO_TABLE(pinode->i_sb), str, name->name, len);
 }
 
 /*
@@ -134,7 +160,7 @@ ncp_compare_dentry(struct dentry *dentry, struct qstr *a, struct qstr *b)
  * Closing files can be safely postponed until iput() - it's done there anyway.
  */
 static int
-ncp_delete_dentry(struct dentry * dentry)
+ncp_delete_dentry(const struct dentry * dentry)
 {
        struct inode *inode = dentry->d_inode;
 
@@ -264,7 +290,7 @@ leave_me:;
 
 
 static int
-__ncp_lookup_validate(struct dentry * dentry, struct nameidata *nd)
+ncp_lookup_validate(struct dentry *dentry, struct nameidata *nd)
 {
        struct ncp_server *server;
        struct dentry *parent;
@@ -273,6 +299,12 @@ __ncp_lookup_validate(struct dentry * dentry, struct nameidata *nd)
        int res, val = 0, len;
        __u8 __name[NCP_MAXPATHLEN + 1];
 
+       if (dentry == dentry->d_sb->s_root)
+               return 1;
+
+       if (nd->flags & LOOKUP_RCU)
+               return -ECHILD;
+
        parent = dget_parent(dentry);
        dir = parent->d_inode;
 
@@ -281,9 +313,6 @@ __ncp_lookup_validate(struct dentry * dentry, struct nameidata *nd)
 
        server = NCP_SERVER(dir);
 
-       if (!ncp_conn_valid(server))
-               goto finished;
-
        /*
         * Inspired by smbfs:
         * The default validation is based on dentry age:
@@ -302,8 +331,11 @@ __ncp_lookup_validate(struct dentry * dentry, struct nameidata *nd)
        if (ncp_is_server_root(dir)) {
                res = ncp_io2vol(server, __name, &len, dentry->d_name.name,
                                 dentry->d_name.len, 1);
-               if (!res)
+               if (!res) {
                        res = ncp_lookup_volume(server, __name, &(finfo.i));
+                       if (!res)
+                               ncp_update_known_namespace(server, finfo.i.volNumber, NULL);
+               }
        } else {
                res = ncp_io2vol(server, __name, &len, dentry->d_name.name,
                                 dentry->d_name.len, !ncp_preserve_case(dir));
@@ -318,13 +350,17 @@ __ncp_lookup_validate(struct dentry * dentry, struct nameidata *nd)
         * what we remember, it's not valid any more.
         */
        if (!res) {
-               if (finfo.i.dirEntNum == NCP_FINFO(dentry->d_inode)->dirEntNum) {
+               struct inode *inode = dentry->d_inode;
+
+               mutex_lock(&inode->i_mutex);
+               if (finfo.i.dirEntNum == NCP_FINFO(inode)->dirEntNum) {
                        ncp_new_dentry(dentry);
                        val=1;
                } else
                        DDPRINTK("ncp_lookup_validate: found, but dirEntNum changed\n");
 
-               ncp_update_inode2(dentry->d_inode, &finfo);
+               ncp_update_inode2(inode, &finfo);
+               mutex_unlock(&inode->i_mutex);
        }
 
 finished:
@@ -333,16 +369,6 @@ finished:
        return val;
 }
 
-static int
-ncp_lookup_validate(struct dentry * dentry, struct nameidata *nd)
-{
-       int res;
-       lock_kernel();
-       res = __ncp_lookup_validate(dentry, nd);
-       unlock_kernel();
-       return res;
-}
-
 static struct dentry *
 ncp_dget_fpos(struct dentry *dentry, struct dentry *parent, unsigned long fpos)
 {
@@ -362,21 +388,21 @@ ncp_dget_fpos(struct dentry *dentry, struct dentry *parent, unsigned long fpos)
        }
 
        /* If a pointer is invalid, we search the dentry. */
-       spin_lock(&dcache_lock);
+       spin_lock(&parent->d_lock);
        next = parent->d_subdirs.next;
        while (next != &parent->d_subdirs) {
-               dent = list_entry(next, struct dentry, d_child);
+               dent = list_entry(next, struct dentry, d_u.d_child);
                if ((unsigned long)dent->d_fsdata == fpos) {
                        if (dent->d_inode)
-                               dget_locked(dent);
+                               dget(dent);
                        else
                                dent = NULL;
-                       spin_unlock(&dcache_lock);
+                       spin_unlock(&parent->d_lock);
                        goto out;
                }
                next = next->next;
        }
-       spin_unlock(&dcache_lock);
+       spin_unlock(&parent->d_lock);
        return NULL;
 
 out:
@@ -400,7 +426,7 @@ static time_t ncp_obtain_mtime(struct dentry *dentry)
 
 static int ncp_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-       struct dentry *dentry = filp->f_dentry;
+       struct dentry *dentry = filp->f_path.dentry;
        struct inode *inode = dentry->d_inode;
        struct page *page = NULL;
        struct ncp_server *server = NCP_SERVER(inode);
@@ -409,8 +435,6 @@ static int ncp_readdir(struct file *filp, void *dirent, filldir_t filldir)
        int result, mtime_valid = 0;
        time_t mtime = 0;
 
-       lock_kernel();
-
        ctl.page  = NULL;
        ctl.cache = NULL;
 
@@ -419,6 +443,7 @@ static int ncp_readdir(struct file *filp, void *dirent, filldir_t filldir)
                (int) filp->f_pos);
 
        result = -EIO;
+       /* Do not generate '.' and '..' when server is dead. */
        if (!ncp_conn_valid(server))
                goto out;
 
@@ -530,6 +555,12 @@ read_really:
        ctl.head.end = ctl.fpos - 1;
        ctl.head.eof = ctl.valid;
 finished:
+       if (ctl.page) {
+               kunmap(ctl.page);
+               SetPageUptodate(ctl.page);
+               unlock_page(ctl.page);
+               page_cache_release(ctl.page);
+       }
        if (page) {
                cache->head = ctl.head;
                kunmap(page);
@@ -537,23 +568,17 @@ finished:
                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
 ncp_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
-               struct ncp_cache_control *ctrl, struct ncp_entry_info *entry)
+               struct ncp_cache_control *ctrl, struct ncp_entry_info *entry,
+               int inval_childs)
 {
-       struct dentry *newdent, *dentry = filp->f_dentry;
-       struct inode *newino, *inode = dentry->d_inode;
+       struct dentry *newdent, *dentry = filp->f_path.dentry;
+       struct inode *dir = dentry->d_inode;
        struct ncp_cache_control ctl = *ctrl;
        struct qstr qname;
        int valid = 0;
@@ -562,16 +587,16 @@ ncp_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
        __u8 __name[NCP_MAXPATHLEN + 1];
 
        qname.len = sizeof(__name);
-       if (ncp_vol2io(NCP_SERVER(inode), __name, &qname.len,
+       if (ncp_vol2io(NCP_SERVER(dir), __name, &qname.len,
                        entry->i.entryName, entry->i.nameLen,
-                       !ncp_preserve_entry_case(inode, entry->i.NSCreator)))
+                       !ncp_preserve_entry_case(dir, entry->i.NSCreator)))
                return 1; /* I'm not sure */
 
        qname.name = __name;
        qname.hash = full_name_hash(qname.name, qname.len);
 
        if (dentry->d_op && dentry->d_op->d_hash)
-               if (dentry->d_op->d_hash(dentry, &qname) != 0)
+               if (dentry->d_op->d_hash(dentry, dentry->d_inode, &qname) != 0)
                        goto end_advance;
 
        newdent = d_lookup(dentry, &qname);
@@ -582,22 +607,40 @@ ncp_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
                        goto end_advance;
        } else {
                hashed = 1;
-               memcpy((char *) newdent->d_name.name, qname.name,
-                                                       newdent->d_name.len);
+
+               /* If case sensitivity changed for this volume, all entries below this one
+                  should be thrown away.  This entry itself is not affected, as its case
+                  sensitivity is controlled by its own parent. */
+               if (inval_childs)
+                       shrink_dcache_parent(newdent);
+
+               /*
+                * NetWare's OS2 namespace is case preserving yet case
+                * insensitive.  So we update dentry's name as received from
+                * server. Parent dir's i_mutex is locked because we're in
+                * readdir.
+                */
+               dentry_update_name_case(newdent, &qname);
        }
 
        if (!newdent->d_inode) {
+               struct inode *inode;
+
                entry->opened = 0;
-               entry->ino = iunique(inode->i_sb, 2);
-               newino = ncp_iget(inode->i_sb, entry);
-               if (newino) {
-                       newdent->d_op = &ncp_dentry_operations;
-                       d_instantiate(newdent, newino);
+               entry->ino = iunique(dir->i_sb, 2);
+               inode = ncp_iget(dir->i_sb, entry);
+               if (inode) {
+                       d_instantiate(newdent, inode);
                        if (!hashed)
                                d_rehash(newdent);
                }
-       } else
-               ncp_update_inode2(newdent->d_inode, entry);
+       } else {
+               struct inode *inode = newdent->d_inode;
+
+               mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
+               ncp_update_inode2(inode, entry);
+               mutex_unlock(&inode->i_mutex);
+       }
 
        if (newdent->d_inode) {
                ino = newdent->d_inode->i_ino;
@@ -615,7 +658,7 @@ ncp_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
                ctl.cache = NULL;
                ctl.idx  -= NCP_DIRCACHE_SIZE;
                ctl.ofs  += 1;
-               ctl.page  = grab_cache_page(&inode->i_data, ctl.ofs);
+               ctl.page  = grab_cache_page(&dir->i_data, ctl.ofs);
                if (ctl.page)
                        ctl.cache = kmap(ctl.page);
        }
@@ -631,7 +674,7 @@ end_advance:
                if (!ino)
                        ino = find_inode_number(dentry, &qname);
                if (!ino)
-                       ino = iunique(inode->i_sb, 2);
+                       ino = iunique(dir->i_sb, 2);
                ctl.filled = filldir(dirent, qname.name, qname.len,
                                     filp->f_pos, ino, DT_UNKNOWN);
                if (!ctl.filled)
@@ -647,7 +690,7 @@ static void
 ncp_read_volume_list(struct file *filp, void *dirent, filldir_t filldir,
                        struct ncp_cache_control *ctl)
 {
-       struct dentry *dentry = filp->f_dentry;
+       struct dentry *dentry = filp->f_path.dentry;
        struct inode *inode = dentry->d_inode;
        struct ncp_server *server = NCP_SERVER(inode);
        struct ncp_volume_info info;
@@ -658,6 +701,7 @@ ncp_read_volume_list(struct file *filp, void *dirent, filldir_t filldir,
                        (unsigned long) filp->f_pos);
 
        for (i = 0; i < NCP_NUMBER_OF_VOLUMES; i++) {
+               int inval_dentry;
 
                if (ncp_get_volume_info_with_number(server, i, &info) != 0)
                        return;
@@ -673,8 +717,9 @@ ncp_read_volume_list(struct file *filp, void *dirent, filldir_t filldir,
                                info.volume_name);
                        continue;
                }
+               inval_dentry = ncp_update_known_namespace(server, entry.i.volNumber, NULL);
                entry.volume = entry.i.volNumber;
-               if (!ncp_fill_cache(filp, dirent, filldir, ctl, &entry))
+               if (!ncp_fill_cache(filp, dirent, filldir, ctl, &entry, inval_dentry))
                        return;
        }
 }
@@ -683,7 +728,7 @@ static void
 ncp_do_readdir(struct file *filp, void *dirent, filldir_t filldir,
                                                struct ncp_cache_control *ctl)
 {
-       struct dentry *dentry = filp->f_dentry;
+       struct dentry *dentry = filp->f_path.dentry;
        struct inode *dir = dentry->d_inode;
        struct ncp_server *server = NCP_SERVER(dir);
        struct nw_search_sequence seq;
@@ -737,7 +782,7 @@ ncp_do_readdir(struct file *filp, void *dirent, filldir_t filldir,
                        rpl += onerpl;
                        rpls -= onerpl;
                        entry.volume = entry.i.volNumber;
-                       if (!ncp_fill_cache(filp, dirent, filldir, ctl, &entry))
+                       if (!ncp_fill_cache(filp, dirent, filldir, ctl, &entry, 0))
                                break;
                }
        } while (more);
@@ -773,17 +818,19 @@ int ncp_conn_logged_in(struct super_block *sb)
                if (dent) {
                        struct inode* ino = dent->d_inode;
                        if (ino) {
+                               ncp_update_known_namespace(server, volNumber, NULL);
                                NCP_FINFO(ino)->volNumber = volNumber;
                                NCP_FINFO(ino)->dirEntNum = dirEntNum;
                                NCP_FINFO(ino)->DosDirNum = DosDirNum;
+                               result = 0;
                        } else {
                                DPRINTK("ncpfs: sb->s_root->d_inode == NULL!\n");
                        }
                } else {
                        DPRINTK("ncpfs: sb->s_root == NULL!\n");
                }
-       }
-       result = 0;
+       } else
+               result = 0;
 
 out:
        return result;
@@ -797,7 +844,6 @@ static struct dentry *ncp_lookup(struct inode *dir, struct dentry *dentry, struc
        int error, res, len;
        __u8 __name[NCP_MAXPATHLEN + 1];
 
-       lock_kernel();
        error = -EIO;
        if (!ncp_conn_valid(server))
                goto finished;
@@ -811,6 +857,8 @@ static struct dentry *ncp_lookup(struct inode *dir, struct dentry *dentry, struc
                                 dentry->d_name.len, 1);
                if (!res)
                        res = ncp_lookup_volume(server, __name, &(finfo.i));
+                       if (!res)
+                               ncp_update_known_namespace(server, finfo.i.volNumber, NULL);
        } else {
                res = ncp_io2vol(server, __name, &len, dentry->d_name.name,
                                 dentry->d_name.len, !ncp_preserve_case(dir));
@@ -837,14 +885,12 @@ static struct dentry *ncp_lookup(struct inode *dir, struct dentry *dentry, struc
        if (inode) {
                ncp_new_dentry(dentry);
 add_entry:
-               dentry->d_op = &ncp_dentry_operations;
                d_add(dentry, inode);
                error = 0;
        }
 
 finished:
        PPRINTK("ncp_lookup: result=%d\n", error);
-       unlock_kernel();
        return ERR_PTR(error);
 }
 
@@ -885,11 +931,6 @@ int ncp_create_new(struct inode *dir, struct dentry *dentry, int mode,
        PPRINTK("ncp_create_new: creating %s/%s, mode=%x\n",
                dentry->d_parent->d_name.name, dentry->d_name.name, mode);
 
-       error = -EIO;
-       lock_kernel();
-       if (!ncp_conn_valid(server))
-               goto out;
-
        ncp_age_dentry(server, dentry);
        len = sizeof(__name);
        error = ncp_io2vol(server, __name, &len, dentry->d_name.name,
@@ -915,6 +956,8 @@ int ncp_create_new(struct inode *dir, struct dentry *dentry, int mode,
                if (result) {
                        if (result == 0x87)
                                error = -ENAMETOOLONG;
+                       else if (result < 0)
+                               error = result;
                        DPRINTK("ncp_create: %s/%s failed\n",
                                dentry->d_parent->d_name.name, dentry->d_name.name);
                        goto out;
@@ -933,17 +976,16 @@ int ncp_create_new(struct inode *dir, struct dentry *dentry, int mode,
 
        error = ncp_instantiate(dir, dentry, &finfo);
 out:
-       unlock_kernel();
        return error;
 }
 
-static int ncp_create(struct inode *dir, struct dentry *dentry, int mode,
+static int ncp_create(struct inode *dir, struct dentry *dentry, umode_t mode,
                struct nameidata *nd)
 {
        return ncp_create_new(dir, dentry, mode, 0, 0);
 }
 
-static int ncp_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+static int ncp_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 {
        struct ncp_entry_info finfo;
        struct ncp_server *server = NCP_SERVER(dir);
@@ -953,11 +995,6 @@ static int ncp_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        DPRINTK("ncp_mkdir: making %s/%s\n",
                dentry->d_parent->d_name.name, dentry->d_name.name);
 
-       error = -EIO;
-       lock_kernel();
-       if (!ncp_conn_valid(server))
-               goto out;
-
        ncp_age_dentry(server, dentry);
        len = sizeof(__name);
        error = ncp_io2vol(server, __name, &len, dentry->d_name.name,
@@ -965,12 +1002,11 @@ static int ncp_mkdir(struct inode *dir, struct dentry *dentry, int mode)
        if (error)
                goto out;
 
-       error = -EACCES;
-       if (ncp_open_create_file_or_subdir(server, dir, __name,
+       error = ncp_open_create_file_or_subdir(server, dir, __name,
                                           OC_MODE_CREATE, aDIR,
                                           cpu_to_le16(0xffff),
-                                          &finfo) == 0)
-       {
+                                          &finfo);
+       if (error == 0) {
                if (ncp_is_nfs_extras(server, finfo.volume)) {
                        mode |= S_IFDIR;
                        finfo.i.nfs.mode = mode;
@@ -981,9 +1017,10 @@ static int ncp_mkdir(struct inode *dir, struct dentry *dentry, int mode)
                                goto out;
                }
                error = ncp_instantiate(dir, dentry, &finfo);
+       } else if (error > 0) {
+               error = -EACCES;
        }
 out:
-       unlock_kernel();
        return error;
 }
 
@@ -996,11 +1033,11 @@ static int ncp_rmdir(struct inode *dir, struct dentry *dentry)
        DPRINTK("ncp_rmdir: removing %s/%s\n",
                dentry->d_parent->d_name.name, dentry->d_name.name);
 
-       error = -EIO;
-       lock_kernel();
-       if (!ncp_conn_valid(server))
-               goto out;
-
+       /*
+        * fail with EBUSY if there are still references to this
+        * directory.
+        */
+       dentry_unhash(dentry);
        error = -EBUSY;
        if (!d_unhashed(dentry))
                goto out;
@@ -1034,11 +1071,10 @@ static int ncp_rmdir(struct inode *dir, struct dentry *dentry)
                        error = -ENOENT;
                        break;
                default:
-                       error = -EACCES;
+                       error = result < 0 ? result : -EACCES;
                        break;
                }
 out:
-       unlock_kernel();
        return error;
 }
 
@@ -1048,15 +1084,10 @@ static int ncp_unlink(struct inode *dir, struct dentry *dentry)
        struct ncp_server *server;
        int error;
 
-       lock_kernel();
        server = NCP_SERVER(dir);
        DPRINTK("ncp_unlink: unlinking %s/%s\n",
                dentry->d_parent->d_name.name, dentry->d_name.name);
        
-       error = -EIO;
-       if (!ncp_conn_valid(server))
-               goto out;
-
        /*
         * Check whether to close the file ...
         */
@@ -1095,12 +1126,9 @@ static int ncp_unlink(struct inode *dir, struct dentry *dentry)
                        error = -ENOENT;
                        break;
                default:
-                       error = -EACCES;
+                       error = error < 0 ? error : -EACCES;
                        break;
        }
-               
-out:
-       unlock_kernel();
        return error;
 }
 
@@ -1116,10 +1144,16 @@ static int ncp_rename(struct inode *old_dir, struct dentry *old_dentry,
                old_dentry->d_parent->d_name.name, old_dentry->d_name.name,
                new_dentry->d_parent->d_name.name, new_dentry->d_name.name);
 
-       error = -EIO;
-       lock_kernel();
-       if (!ncp_conn_valid(server))
-               goto out;
+       if (new_dentry->d_inode && S_ISDIR(new_dentry->d_inode->i_mode)) {
+               /*
+                * fail with EBUSY if there are still references to this
+                * directory.
+                */
+               dentry_unhash(new_dentry);
+               error = -EBUSY;
+               if (!d_unhashed(new_dentry))
+                       goto out;
+       }
 
        ncp_age_dentry(server, old_dentry);
        ncp_age_dentry(server, new_dentry);
@@ -1159,11 +1193,10 @@ static int ncp_rename(struct inode *old_dir, struct dentry *old_dentry,
                        error = -ENOENT;
                        break;
                default:
-                       error = -EACCES;
+                       error = error < 0 ? error : -EACCES;
                        break;
        }
 out:
-       unlock_kernel();
        return error;
 }
 
@@ -1239,7 +1272,7 @@ ncp_date_unix2dos(int unix_date, __le16 *time, __le16 *date)
                month = 2;
        } else {
                nl_day = (year & 3) || day <= 59 ? day : day - 1;
-               for (month = 0; month < 12; month++)
+               for (month = 1; month < 12; month++)
                        if (day_n[month] > nl_day)
                                break;
        }