Add <sys/types.h> to headers included for userspace in <linux/input.h>

[pandora-kernel.git] / fs / locks.c

diff --git a/fs/locks.c b/fs/locks.c
index 4d9e71d..6f99c0a 100644 (file)
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -168,18 +168,9 @@ static void locks_release_private(struct file_lock *fl)
 /* Free a lock which is not in use. */
 static void locks_free_lock(struct file_lock *fl)
 {
-       if (fl == NULL) {
-               BUG();
-               return;
-       }
-       if (waitqueue_active(&fl->fl_wait))
-               panic("Attempting to free lock with active wait queue");
-
-       if (!list_empty(&fl->fl_block))
-               panic("Attempting to free lock with active block list");
-
-       if (!list_empty(&fl->fl_link))
-               panic("Attempting to free lock on active lock list");
+       BUG_ON(waitqueue_active(&fl->fl_wait));
+       BUG_ON(!list_empty(&fl->fl_block));
+       BUG_ON(!list_empty(&fl->fl_link));
 
        locks_release_private(fl);
        kmem_cache_free(filelock_cache, fl);
@@ -455,15 +446,14 @@ static struct lock_manager_operations lease_manager_ops = {
  */
 static int lease_init(struct file *filp, int type, struct file_lock *fl)
  {
+       if (assign_type(fl, type) != 0)
+               return -EINVAL;
+
        fl->fl_owner = current->files;
        fl->fl_pid = current->tgid;
 
        fl->fl_file = filp;
        fl->fl_flags = FL_LEASE;
-       if (assign_type(fl, type) != 0) {
-               locks_free_lock(fl);
-               return -EINVAL;
-       }
        fl->fl_start = 0;
        fl->fl_end = OFFSET_MAX;
        fl->fl_ops = NULL;
@@ -475,16 +465,19 @@ static int lease_init(struct file *filp, int type, struct file_lock *fl)
 static int lease_alloc(struct file *filp, int type, struct file_lock **flp)
 {
        struct file_lock *fl = locks_alloc_lock();
-       int error;
+       int error = -ENOMEM;
 
        if (fl == NULL)
-               return -ENOMEM;
+               goto out;
 
        error = lease_init(filp, type, fl);
-       if (error)
-               return error;
+       if (error) {
+               locks_free_lock(fl);
+               fl = NULL;
+       }
+out:
        *flp = fl;
-       return 0;
+       return error;
 }
 
 /* Check if two locks overlap each other.
@@ -735,8 +728,9 @@ EXPORT_SYMBOL(posix_locks_deadlock);
  * at the head of the list, but that's secret knowledge known only to
  * flock_lock_file and posix_lock_file.
  */
-static int flock_lock_file(struct file *filp, struct file_lock *new_fl)
+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;
        int error = 0;
@@ -751,17 +745,19 @@ static int flock_lock_file(struct file *filp, struct file_lock *new_fl)
                        continue;
                if (filp != fl->fl_file)
                        continue;
-               if (new_fl->fl_type == fl->fl_type)
+               if (request->fl_type == fl->fl_type)
                        goto out;
                found = 1;
                locks_delete_lock(before);
                break;
        }
-       unlock_kernel();
 
-       if (new_fl->fl_type == F_UNLCK)
-               return 0;
+       if (request->fl_type == F_UNLCK)
+               goto out;
 
+       new_fl = locks_alloc_lock();
+       if (new_fl == NULL)
+               goto out;
        /*
         * If a higher-priority process was blocked on the old file lock,
         * give it the opportunity to lock the file.
@@ -769,26 +765,27 @@ static int flock_lock_file(struct file *filp, struct file_lock *new_fl)
        if (found)
                cond_resched();
 
-       lock_kernel();
        for_each_lock(inode, before) {
                struct file_lock *fl = *before;
                if (IS_POSIX(fl))
                        break;
                if (IS_LEASE(fl))
                        continue;
-               if (!flock_locks_conflict(new_fl, fl))
+               if (!flock_locks_conflict(request, fl))
                        continue;
                error = -EAGAIN;
-               if (new_fl->fl_flags & FL_SLEEP) {
-                       locks_insert_block(fl, new_fl);
-               }
+               if (request->fl_flags & FL_SLEEP)
+                       locks_insert_block(fl, request);
                goto out;
        }
+       locks_copy_lock(new_fl, request);
        locks_insert_lock(&inode->i_flock, new_fl);
-       error = 0;
+       new_fl = NULL;
 
 out:
        unlock_kernel();
+       if (new_fl)
+               locks_free_lock(new_fl);
        return error;
 }
 
@@ -1377,6 +1374,7 @@ static int __setlease(struct file *filp, long arg, struct file_lock **flp)
                goto out;
 
        if (my_before != NULL) {
+               *flp = *my_before;
                error = lease->fl_lmops->fl_change(my_before, arg);
                goto out;
        }
@@ -1569,9 +1567,7 @@ asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
                error = flock_lock_file_wait(filp, lock);
 
  out_free:
-       if (list_empty(&lock->fl_link)) {
-               locks_free_lock(lock);
-       }
+       locks_free_lock(lock);
 
  out_putf:
        fput(filp);
@@ -2237,7 +2233,12 @@ void steal_locks(fl_owner_t from)
 
        lock_kernel();
        j = 0;
-       rcu_read_lock();
+
+       /*
+        * We are not taking a ref to the file structures, so
+        * we need to acquire ->file_lock.
+        */
+       spin_lock(&files->file_lock);
        fdt = files_fdtable(files);
        for (;;) {
                unsigned long set;
@@ -2255,7 +2256,7 @@ void steal_locks(fl_owner_t from)
                        set >>= 1;
                }
        }
-       rcu_read_unlock();
+       spin_unlock(&files->file_lock);
        unlock_kernel();
 }
 EXPORT_SYMBOL(steal_locks);