Piteball/android_kernel_google_msm
1
0
Fork 0
mirror of https://github.com/followmsi/android_kernel_google_msm.git synced 2024-11-06 23:17:41 +00:00
Code Issues Projects Releases Wiki Activity

Revert "shmem: fix faulting into a hole, not taking i_mutex"

Browse source 
This reverts commit 0f5a4a003f.

Change-Id: Id26b748385c0ab269a455299c8ed55e58a90d23e
This commit is contained in:
Arne Coucheron 2019-10-03 04:04:52 +02:00 committed by surblazer
parent 010eab88fb
commit 50b7af5612
1 changed files with 20 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
mm/shmem.c
View file

@ -84,7 +84,6 @@ static struct vfsmount *shm_mnt;
* a time): we would prefer not to enlarge the shmem inode just for that.
*/
struct shmem_falloc {
wait_queue_head_t *waitq; /* faults into hole wait for punch to end */
pgoff_t start; /* start of range currently being fallocated */
pgoff_t next; /* the next page offset to be fallocated */
};
@ -1077,57 +1076,37 @@ static int shmem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
* Trinity finds that probing a hole which tmpfs is punching can
* prevent the hole-punch from ever completing: which in turn
* locks writers out with its hold on i_mutex. So refrain from
* faulting pages into the hole while it's being punched. Although
* shmem_truncate_range() does remove the additions, it may be unable to
* keep up, as each new page needs its own unmap_mapping_range() call,
* and the i_mmap tree grows ever slower to scan if new vmas are added.
*
* It does not matter if we sometimes reach this check just before the
* hole-punch begins, so that one fault then races with the punch:
* we just need to make racing faults a rare case.
*
* The implementation below would be much simpler if we just used a
* standard mutex or completion: but we cannot take i_mutex in fault,
* and bloating every shmem inode for this unlikely case would be sad.
* faulting pages into the hole while it's being punched, and
* wait on i_mutex to be released if vmf->flags permits.
*/
if (unlikely(inode->i_private)) {
struct shmem_falloc *shmem_falloc;
spin_lock(&inode->i_lock);
shmem_falloc = inode->i_private;
if (shmem_falloc &&
vmf->pgoff >= shmem_falloc->start &&
vmf->pgoff < shmem_falloc->next) {
wait_queue_head_t *shmem_falloc_waitq;
DEFINE_WAIT(shmem_fault_wait);
ret = VM_FAULT_NOPAGE;
if (!shmem_falloc ||
vmf->pgoff < shmem_falloc->start ||
vmf->pgoff >= shmem_falloc->next)
shmem_falloc = NULL;
spin_unlock(&inode->i_lock);
/*
* i_lock has protected us from taking shmem_falloc seriously
* once return from vmtruncate_range() went back up that stack.
* i_lock does not serialize with i_mutex at all, but it does
* not matter if sometimes we wait unnecessarily, or sometimes
* miss out on waiting: we just need to make those cases rare.
*/
if (shmem_falloc) {
if ((vmf->flags & FAULT_FLAG_ALLOW_RETRY) &&
!(vmf->flags & FAULT_FLAG_RETRY_NOWAIT)) {
/* It's polite to up mmap_sem if we can */
up_read(&vma->vm_mm->mmap_sem);
ret = VM_FAULT_RETRY;
mutex_lock(&inode->i_mutex);
mutex_unlock(&inode->i_mutex);
return VM_FAULT_RETRY;
}
shmem_falloc_waitq = shmem_falloc->waitq;
prepare_to_wait(shmem_falloc_waitq, &shmem_fault_wait,
TASK_UNINTERRUPTIBLE);
spin_unlock(&inode->i_lock);
schedule();
/*
* shmem_falloc_waitq points into the vmtruncate_range()
* stack of the hole-punching task: shmem_falloc_waitq
* is usually invalid by the time we reach here, but
* finish_wait() does not dereference it in that case;
* though i_lock needed lest racing with wake_up_all().
*/
spin_lock(&inode->i_lock);
finish_wait(shmem_falloc_waitq, &shmem_fault_wait);
spin_unlock(&inode->i_lock);
return ret;
/* cond_resched? Leave that to GUP or return to user */
return VM_FAULT_NOPAGE;
}
spin_unlock(&inode->i_lock);
}
error = shmem_getpage(inode, vmf->pgoff, &vmf->page, SGP_CACHE, &ret);
@ -1158,9 +1137,7 @@ int vmtruncate_range(struct inode *inode, loff_t lstart, loff_t lend)
struct address_space *mapping = inode->i_mapping;
loff_t unmap_start = round_up(lstart, PAGE_SIZE);
loff_t unmap_end = round_down(1 + lend, PAGE_SIZE) - 1;
DECLARE_WAIT_QUEUE_HEAD_ONSTACK(shmem_falloc_waitq);
shmem_falloc.waitq = &shmem_falloc_waitq;
shmem_falloc.start = unmap_start >> PAGE_SHIFT;
shmem_falloc.next = (unmap_end + 1) >> PAGE_SHIFT;
spin_lock(&inode->i_lock);
@ -1175,7 +1152,6 @@ int vmtruncate_range(struct inode *inode, loff_t lstart, loff_t lend)
spin_lock(&inode->i_lock);
inode->i_private = NULL;
wake_up_all(&shmem_falloc_waitq);
spin_unlock(&inode->i_lock);
}
mutex_unlock(&inode->i_mutex);