*/
 
 #include <linux/buffer_head.h>
-#include <linux/smp_lock.h>
 #include "efs.h"
 
 static int efs_readdir(struct file *, void *, filldir_t);
 
 const struct file_operations efs_dir_operations = {
+       .llseek         = generic_file_llseek,
        .read           = generic_read_dir,
        .readdir        = efs_readdir,
 };
        if (inode->i_size & (EFS_DIRBSIZE-1))
                printk(KERN_WARNING "EFS: WARNING: readdir(): directory size not a multiple of EFS_DIRBSIZE\n");
 
-       lock_kernel();
-
        /* work out where this entry can be found */
        block = filp->f_pos >> EFS_DIRBSIZE_BITS;
 
 
        filp->f_pos = (block << EFS_DIRBSIZE_BITS) | slot;
 out:
-       unlock_kernel();
        return 0;
 }
 
 
 
 #include <linux/buffer_head.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/exportfs.h>
 #include "efs.h"
 
        efs_ino_t inodenum;
        struct inode * inode = NULL;
 
-       lock_kernel();
        inodenum = efs_find_entry(dir, dentry->d_name.name, dentry->d_name.len);
        if (inodenum) {
                inode = efs_iget(dir->i_sb, inodenum);
-               if (IS_ERR(inode)) {
-                       unlock_kernel();
+               if (IS_ERR(inode))
                        return ERR_CAST(inode);
-               }
        }
-       unlock_kernel();
 
        return d_splice_alias(inode, dentry);
 }
        struct dentry *parent = ERR_PTR(-ENOENT);
        efs_ino_t ino;
 
-       lock_kernel();
        ino = efs_find_entry(child->d_inode, "..", 2);
        if (ino)
                parent = d_obtain_alias(efs_iget(child->d_inode->i_sb, ino));
-       unlock_kernel();
 
        return parent;
 }
 
 #include <linux/string.h>
 #include <linux/pagemap.h>
 #include <linux/buffer_head.h>
-#include <linux/smp_lock.h>
 #include "efs.h"
 
 static int efs_symlink_readpage(struct file *file, struct page *page)
   
        err = -ENAMETOOLONG;
        if (size > 2 * EFS_BLOCKSIZE)
-               goto fail_notlocked;
+               goto fail;
   
-       lock_kernel();
        /* read first 512 bytes of link target */
        err = -EIO;
        bh = sb_bread(inode->i_sb, efs_bmap(inode, 0));
                brelse(bh);
        }
        link[size] = '\0';
-       unlock_kernel();
        SetPageUptodate(page);
        kunmap(page);
        unlock_page(page);
        return 0;
 fail:
-       unlock_kernel();
-fail_notlocked:
        SetPageError(page);
        kunmap(page);
        unlock_page(page);