Ceph » Linux kernel client

There should be a race in 'filp_close()`, for example in a single process a file is opened twice with two different file descripters in two different threads: filpA for Userspace ThreadA and filpB for Userspace ThreadB, then both ThreadA and ThreadB set posix locks for the file:

Userspace ThreadA:                                      Userspace ThreadB:
 filp_close():                                           filp_close():
   ->locks_remove_posix(filpA):                            ->locks_remove_posix(filpB):
     ->vfs_lock_file():                                      ->vfs_lock_file():
       ->ceph_lock():                                          ->ceph_lock():
         ->posix_lock_file(): 
           ->__posix_lock_file():
             ->Iterate and remove all the inode's
               posix locks with the same owner,
               which all the posix lock owner are
               the same: current->files.
               This will also close ThreadB's
               posix lock.
                                                                 ->posix_lock_file():
                                                                   ->__posix_lock_file():
                                                                     ->Will do nothing since there
                                                                       is no any posix lock in the
                                                                       inode
                                                                   ->locks_dispose_list():
                                                                     ->Do nothing too.
                                                           ->fput(filpB):
                                                             ->__fput(filpB):
                                                               ->file->f_path.dentry = NULL;
                                                               ->file->f_inode = NULL;
             ->locks_dispose_list():
               ->locks_free_lock():
                 ->locks_release_private():
                   ->Remove both ThreadA and ThreadB
                     posix locks. And when accessing
                     filpB it will crash.
   ->fput(filpA)

The ThreadA and ThreadB in kernel space will share the same file descripters, if my understanding is correct the posix locks' owner will be the same: current->files.