git://git.onelab.eu / linux-2.6.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
fedora core 6 1.2949 + vserver 2.2.0
[linux-2.6.git] / fs / locks.c
diff --git a/fs/locks.c b/fs/locks.c
index af50ed2..9f4fd59 100644 (file)
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -125,6 +125,7 @@
 #include <linux/syscalls.h>
 #include <linux/time.h>
 #include <linux/rcupdate.h>
+#include <linux/vs_base.h>
 #include <linux/vs_limit.h>
 
 #include <asm/semaphore.h>
@@ -143,14 +144,14 @@ int lease_break_time = 45;
 static LIST_HEAD(file_lock_list);
 static LIST_HEAD(blocked_list);
 
-static kmem_cache_t *filelock_cache __read_mostly;
+static struct kmem_cache *filelock_cache __read_mostly;
 
 /* Allocate an empty lock structure. */
 static struct file_lock *locks_alloc_lock(void)
 {
        if (!vx_locks_avail(1))
                return NULL;
-       return kmem_cache_alloc(filelock_cache, SLAB_KERNEL);
+       return kmem_cache_alloc(filelock_cache, GFP_KERNEL);
 }
 
 static void locks_release_private(struct file_lock *fl)
@@ -204,7 +205,7 @@ EXPORT_SYMBOL(locks_init_lock);
  * Initialises the fields of the file lock which are invariant for
  * free file_locks.
  */
-static void init_once(void *foo, kmem_cache_t *cache, unsigned long flags)
+static void init_once(void *foo, struct kmem_cache *cache, unsigned long flags)
 {
        struct file_lock *lock = (struct file_lock *) foo;
 
@@ -293,6 +294,8 @@ static int flock_make_lock(struct file *filp, struct file_lock **lock,
        fl->fl_type = type;
        fl->fl_end = OFFSET_MAX;
 
+       vxd_assert(filp->f_xid == vx_current_xid(),
+               "f_xid(%d) == current(%d)", filp->f_xid, vx_current_xid());
        fl->fl_xid = filp->f_xid;
        vx_locks_inc(fl);
        
@@ -323,14 +326,14 @@ static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
        off_t start, end;
 
        switch (l->l_whence) {
-       case 0: /*SEEK_SET*/
+       case SEEK_SET:
                start = 0;
                break;
-       case 1: /*SEEK_CUR*/
+       case SEEK_CUR:
                start = filp->f_pos;
                break;
-       case 2: /*SEEK_END*/
-               start = i_size_read(filp->f_dentry->d_inode);
+       case SEEK_END:
+               start = i_size_read(filp->f_path.dentry->d_inode);
                break;
        default:
                return -EINVAL;
@@ -373,14 +376,14 @@ static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,
        loff_t start;
 
        switch (l->l_whence) {
-       case 0: /*SEEK_SET*/
+       case SEEK_SET:
                start = 0;
                break;
-       case 1: /*SEEK_CUR*/
+       case SEEK_CUR:
                start = filp->f_pos;
                break;
-       case 2: /*SEEK_END*/
-               start = i_size_read(filp->f_dentry->d_inode);
+       case SEEK_END:
+               start = i_size_read(filp->f_path.dentry->d_inode);
                break;
        default:
                return -EINVAL;
@@ -481,6 +484,9 @@ static int lease_alloc(struct file *filp, int type, struct file_lock **flp)
                goto out;
 
        fl->fl_xid = vx_current_xid();
+       if (filp)
+               vxd_assert(filp->f_xid == fl->fl_xid,
+                       "f_xid(%d) == fl_xid(%d)", filp->f_xid, fl->fl_xid);
        vx_locks_inc(fl);
        error = lease_init(filp, type, fl);
        if (error) {
@@ -684,7 +690,7 @@ posix_test_lock(struct file *filp, struct file_lock *fl,
        struct file_lock *cfl;
 
        lock_kernel();
-       for (cfl = filp->f_dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) {
+       for (cfl = filp->f_path.dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) {
                if (!IS_POSIX(cfl))
                        continue;
                if (posix_locks_conflict(cfl, fl))
@@ -746,7 +752,7 @@ static int flock_lock_file(struct file *filp, struct file_lock *request)
 {
        struct file_lock *new_fl = NULL;
        struct file_lock **before;
-       struct inode * inode = filp->f_dentry->d_inode;
+       struct inode * inode = filp->f_path.dentry->d_inode;
        int error = 0;
        int found = 0;
 
@@ -785,6 +791,7 @@ static int flock_lock_file(struct file *filp, struct file_lock *request)
        if (found)
                cond_resched();
 
+       new_fl->fl_xid = -1;
 find_conflict:
        for_each_lock(inode, before) {
                struct file_lock *fl = *before;
@@ -802,8 +809,8 @@ find_conflict:
        if (request->fl_flags & FL_ACCESS)
                goto out;
        locks_copy_lock(new_fl, request);
-       vx_locks_inc(new_fl);
        locks_insert_lock(&inode->i_flock, new_fl);
+       vx_locks_inc(new_fl);
        new_fl = NULL;
        error = 0;
 
@@ -825,6 +832,8 @@ static int __posix_lock_file_conf(struct inode *inode, struct file_lock *request
        struct file_lock **before;
        int error, added = 0;
 
+       vxd_assert(xid == vx_current_xid(),
+               "xid(%d) == current(%d)", xid, vx_current_xid());
        /*
         * We may need two file_lock structures for this operation,
         * so we get them in advance to avoid races.
@@ -1036,7 +1045,7 @@ static int __posix_lock_file_conf(struct inode *inode, struct file_lock *request
  */
 int posix_lock_file(struct file *filp, struct file_lock *fl)
 {
-       return __posix_lock_file_conf(filp->f_dentry->d_inode,
+       return __posix_lock_file_conf(filp->f_path.dentry->d_inode,
                fl, NULL, filp->f_xid);
 }
 EXPORT_SYMBOL(posix_lock_file);
@@ -1052,7 +1061,7 @@ EXPORT_SYMBOL(posix_lock_file);
 int posix_lock_file_conf(struct file *filp, struct file_lock *fl,
                        struct file_lock *conflock)
 {
-       return __posix_lock_file_conf(filp->f_dentry->d_inode,
+       return __posix_lock_file_conf(filp->f_path.dentry->d_inode,
                fl, conflock, filp->f_xid);
 }
 EXPORT_SYMBOL(posix_lock_file_conf);
@@ -1353,8 +1362,8 @@ int fcntl_getlease(struct file *filp)
        int type = F_UNLCK;
 
        lock_kernel();
-       time_out_leases(filp->f_dentry->d_inode);
-       for (fl = filp->f_dentry->d_inode->i_flock; fl && IS_LEASE(fl);
+       time_out_leases(filp->f_path.dentry->d_inode);
+       for (fl = filp->f_path.dentry->d_inode->i_flock; fl && IS_LEASE(fl);
                        fl = fl->fl_next) {
                if (fl->fl_file == filp) {
                        type = fl->fl_type & ~F_INPROGRESS;
@@ -1379,7 +1388,7 @@ int fcntl_getlease(struct file *filp)
 static int __setlease(struct file *filp, long arg, struct file_lock **flp)
 {
        struct file_lock *fl, **before, **my_before = NULL, *lease;
-       struct dentry *dentry = filp->f_dentry;
+       struct dentry *dentry = filp->f_path.dentry;
        struct inode *inode = dentry->d_inode;
        int error, rdlease_count = 0, wrlease_count = 0;
 
@@ -1447,8 +1456,8 @@ static int __setlease(struct file *filp, long arg, struct file_lock **flp)
                goto out;
 
        locks_copy_lock(fl, lease);
-
        locks_insert_lock(before, fl);
+       vx_locks_inc(fl);
 
        *flp = fl;
        error = 0;
@@ -1468,7 +1477,7 @@ out:
 
 int setlease(struct file *filp, long arg, struct file_lock **lease)
 {
-       struct dentry *dentry = filp->f_dentry;
+       struct dentry *dentry = filp->f_path.dentry;
        struct inode *inode = dentry->d_inode;
        int error;
 
@@ -1502,7 +1511,7 @@ EXPORT_SYMBOL(setlease);
 int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
 {
        struct file_lock fl, *flp = &fl;
-       struct dentry *dentry = filp->f_dentry;
+       struct dentry *dentry = filp->f_path.dentry;
        struct inode *inode = dentry->d_inode;
        int error;
 
@@ -1534,7 +1543,7 @@ int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
                goto out_unlock;
        }
 
-       error = f_setown(filp, current->pid, 0);
+       error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0);
 out_unlock:
        unlock_kernel();
        return error;
@@ -1705,6 +1714,8 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
        if (file_lock == NULL)
                return -ENOLCK;
 
+       vxd_assert(filp->f_xid == vx_current_xid(),
+               "f_xid(%d) == current(%d)", filp->f_xid, vx_current_xid());
        file_lock->fl_xid = filp->f_xid;
        vx_locks_inc(file_lock);
 
@@ -1715,7 +1726,7 @@ int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
        if (copy_from_user(&flock, l, sizeof(flock)))
                goto out;
 
-       inode = filp->f_dentry->d_inode;
+       inode = filp->f_path.dentry->d_inode;
 
        /* Don't allow mandatory locks on files that may be memory mapped
         * and shared.
@@ -1851,6 +1862,8 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
        if (file_lock == NULL)
                return -ENOLCK;
 
+       vxd_assert(filp->f_xid == vx_current_xid(),
+               "f_xid(%d) == current(%d)", filp->f_xid, vx_current_xid());
        file_lock->fl_xid = filp->f_xid;
        vx_locks_inc(file_lock);
 
@@ -1861,7 +1874,7 @@ int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
        if (copy_from_user(&flock, l, sizeof(flock)))
                goto out;
 
-       inode = filp->f_dentry->d_inode;
+       inode = filp->f_path.dentry->d_inode;
 
        /* Don't allow mandatory locks on files that may be memory mapped
         * and shared.
@@ -1948,7 +1961,7 @@ void locks_remove_posix(struct file *filp, fl_owner_t owner)
         * posix_lock_file().  Another process could be setting a lock on this
         * file at the same time, but we wouldn't remove that lock anyway.
         */
-       if (!filp->f_dentry->d_inode->i_flock)
+       if (!filp->f_path.dentry->d_inode->i_flock)
                return;
 
        lock.fl_type = F_UNLCK;
@@ -1977,7 +1990,7 @@ EXPORT_SYMBOL(locks_remove_posix);
  */
 void locks_remove_flock(struct file *filp)
 {
-       struct inode * inode = filp->f_dentry->d_inode; 
+       struct inode * inode = filp->f_path.dentry->d_inode;
        struct file_lock *fl;
        struct file_lock **before;
 
@@ -2046,7 +2059,7 @@ static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx)
        struct inode *inode = NULL;
 
        if (fl->fl_file != NULL)
-               inode = fl->fl_file->f_dentry->d_inode;
+               inode = fl->fl_file->f_path.dentry->d_inode;
 
        out += sprintf(out, "%d:%s ", id, pfx);
        if (IS_POSIX(fl)) {
@@ -2150,7 +2163,7 @@ int get_locks_status(char *buffer, char **start, off_t offset, int length)
                struct list_head *btmp;
                struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link);
 
-               if (!vx_check(fl->fl_xid, VX_IDENT|VX_WATCH))
+               if (!vx_check(fl->fl_xid, VS_WATCH_P|VS_IDENT))
                        continue;
 
                lock_get_status(q, fl, ++i, "");
linux-2.6