3 files changed, 83 insertions, 9 deletions

diff --git a/mm/madvise.c b/mm/madvise.c
index 2b7cf0400a21..ae0ae3ea299a 100644
--- a/mm/madvise.c
+++ b/mm/madvise.c
@@ -140,6 +140,36 @@ static long madvise_dontneed(struct vm_area_struct * vma,
         return 0;
 }
 
+/*
+ * Application wants to free up the pages and associated backing store.
+ * This is effectively punching a hole into the middle of a file.
+ *
+ * NOTE: Currently, only shmfs/tmpfs is supported for this operation.
+ * Other filesystems return -ENOSYS.
+ */
+static long madvise_remove(struct vm_area_struct *vma,
+                                unsigned long start, unsigned long end)
+{
+        struct address_space *mapping;
+        loff_t offset, endoff;
+
+        if (vma->vm_flags & (VM_LOCKED|VM_NONLINEAR|VM_HUGETLB))
+                return -EINVAL;
+
+        if (!vma->vm_file || !vma->vm_file->f_mapping
+                || !vma->vm_file->f_mapping->host) {
+                        return -EINVAL;
+        }
+
+        mapping = vma->vm_file->f_mapping;
+
+        offset = (loff_t)(start - vma->vm_start)
+                        + ((loff_t)vma->vm_pgoff << PAGE_SHIFT);
+        endoff = (loff_t)(end - vma->vm_start - 1)
+                        + ((loff_t)vma->vm_pgoff << PAGE_SHIFT);
+        return  vmtruncate_range(mapping->host, offset, endoff);
+}
+
 static long
 madvise_vma(struct vm_area_struct *vma, struct vm_area_struct **prev,
                 unsigned long start, unsigned long end, int behavior)
@@ -152,6 +182,9 @@ madvise_vma(struct vm_area_struct *vma, struct vm_area_struct **prev,
         case MADV_RANDOM:
                 error = madvise_behavior(vma, prev, start, end, behavior);
                 break;
+        case MADV_REMOVE:
+                error = madvise_remove(vma, start, end);
+                break;
 
         case MADV_WILLNEED:
                 error = madvise_willneed(vma, prev, start, end);
@@ -190,6 +223,8 @@ madvise_vma(struct vm_area_struct *vma, struct vm_area_struct **prev,
  *              some pages ahead.
  *  MADV_DONTNEED - the application is finished with the given range,
  *              so the kernel can free resources associated with it.
+ *  MADV_REMOVE - the application wants to free up the given range of
+ *              pages and associated backing store.
  *
  * return values:
  *  zero    - success
diff --git a/mm/memory.c b/mm/memory.c
index d8dde07a3656..e249088908c4 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -1770,9 +1770,32 @@ out_big:
 out_busy:
         return -ETXTBSY;
 }
-
 EXPORT_SYMBOL(vmtruncate);
 
+int vmtruncate_range(struct inode *inode, loff_t offset, loff_t end)
+{
+        struct address_space *mapping = inode->i_mapping;
+
+        /*
+         * If the underlying filesystem is not going to provide
+         * a way to truncate a range of blocks (punch a hole) -
+         * we should return failure right now.
+         */
+        if (!inode->i_op || !inode->i_op->truncate_range)
+                return -ENOSYS;
+
+        down(&inode->i_sem);
+        down_write(&inode->i_alloc_sem);
+        unmap_mapping_range(mapping, offset, (end - offset), 1);
+        truncate_inode_pages_range(mapping, offset, end);
+        inode->i_op->truncate_range(inode, offset, end);
+        up_write(&inode->i_alloc_sem);
+        up(&inode->i_sem);
+
+        return 0;
+}
+EXPORT_SYMBOL(vmtruncate_range);
+
 /* 
  * Primitive swap readahead code. We simply read an aligned block of
  * (1 << page_cluster) entries in the swap area. This method is chosen
diff --git a/mm/shmem.c b/mm/shmem.c
index d9fc277940da..65c148efa2ed 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -457,7 +457,7 @@ static void shmem_free_pages(struct list_head *next)
         } while (next);
 }
 
-static void shmem_truncate(struct inode *inode)
+static void shmem_truncate_range(struct inode *inode, loff_t start, loff_t end)
 {
         struct shmem_inode_info *info = SHMEM_I(inode);
         unsigned long idx;
@@ -475,18 +475,27 @@ static void shmem_truncate(struct inode *inode)
         long nr_swaps_freed = 0;
         int offset;
         int freed;
+        int punch_hole = 0;
 
         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
-        idx = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+        idx = (start + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
         if (idx >= info->next_index)
                 return;
 
         spin_lock(&info->lock);
         info->flags |= SHMEM_TRUNCATE;
-        limit = info->next_index;
-        info->next_index = idx;
+        if (likely(end == (loff_t) -1)) {
+                limit = info->next_index;
+                info->next_index = idx;
+        } else {
+                limit = (end + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+                if (limit > info->next_index)
+                        limit = info->next_index;
+                punch_hole = 1;
+        }
+
         topdir = info->i_indirect;
-        if (topdir && idx <= SHMEM_NR_DIRECT) {
+        if (topdir && idx <= SHMEM_NR_DIRECT && !punch_hole) {
                 info->i_indirect = NULL;
                 nr_pages_to_free++;
                 list_add(&topdir->lru, &pages_to_free);
@@ -573,11 +582,12 @@ static void shmem_truncate(struct inode *inode)
                         set_page_private(subdir, page_private(subdir) - freed);
                         if (offset)
                                 spin_unlock(&info->lock);
-                        BUG_ON(page_private(subdir) > offset);
+                        if (!punch_hole)
+                                BUG_ON(page_private(subdir) > offset);
                 }
                 if (offset)
                         offset = 0;
-                else if (subdir) {
+                else if (subdir && !page_private(subdir)) {
                         dir[diroff] = NULL;
                         nr_pages_to_free++;
                         list_add(&subdir->lru, &pages_to_free);
@@ -594,7 +604,7 @@ done2:
                  * Also, though shmem_getpage checks i_size before adding to
                  * cache, no recheck after: so fix the narrow window there too.
                  */
-                truncate_inode_pages(inode->i_mapping, inode->i_size);
+                truncate_inode_pages_range(inode->i_mapping, start, end);
         }
 
         spin_lock(&info->lock);
@@ -614,6 +624,11 @@ done2:
         }
 }
 
+static void shmem_truncate(struct inode *inode)
+{
+        shmem_truncate_range(inode, inode->i_size, (loff_t)-1);
+}
+
 static int shmem_notify_change(struct dentry *dentry, struct iattr *attr)
 {
         struct inode *inode = dentry->d_inode;
@@ -2083,6 +2098,7 @@ static struct file_operations shmem_file_operations = {
 static struct inode_operations shmem_inode_operations = {
         .truncate       = shmem_truncate,
         .setattr        = shmem_notify_change,
+        .truncate_range = shmem_truncate_range,
 };
 
 static struct inode_operations shmem_dir_inode_operations = {