vm audit: add VM_DONTEXPAND to mmap for drivers that need it

[sfrench/cifs-2.6.git] / drivers / char / drm / drm_vm.c

diff --git a/drivers/char/drm/drm_vm.c b/drivers/char/drm/drm_vm.c
index b5c5b9fa84c3cd55bf7e0c8343fe6e6dc15771c3..ef5e6b130c4845aa8b3ad68b36538b34d90e6311 100644 (file)
--- a/drivers/char/drm/drm_vm.c
+++ b/drivers/char/drm/drm_vm.c
@@ -79,11 +79,11 @@ static pgprot_t drm_io_prot(uint32_t map_type, struct vm_area_struct *vma)
 static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
                                                unsigned long address)
 {
-       drm_file_t *priv = vma->vm_file->private_data;
-       drm_device_t *dev = priv->head->dev;
-       drm_map_t *map = NULL;
-       drm_map_list_t *r_list;
-       drm_hash_item_t *hash;
+       struct drm_file *priv = vma->vm_file->private_data;
+       struct drm_device *dev = priv->head->dev;
+       struct drm_map *map = NULL;
+       struct drm_map_list *r_list;
+       struct drm_hash_item *hash;
 
        /*
         * Find the right map
@@ -97,7 +97,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
        if (drm_ht_find_item(&dev->map_hash, vma->vm_pgoff, &hash))
                goto vm_nopage_error;
 
-       r_list = drm_hash_entry(hash, drm_map_list_t, hash);
+       r_list = drm_hash_entry(hash, struct drm_map_list, hash);
        map = r_list->map;
 
        if (map && map->type == _DRM_AGP) {
@@ -116,7 +116,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
                /*
                 * It's AGP memory - find the real physical page to map
                 */
-               for (agpmem = dev->agp->memory; agpmem; agpmem = agpmem->next) {
+               list_for_each_entry(agpmem, &dev->agp->memory, head) {
                        if (agpmem->bound <= baddr &&
                            agpmem->bound + agpmem->pages * PAGE_SIZE > baddr)
                                break;
@@ -163,7 +163,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
 static __inline__ struct page *drm_do_vm_shm_nopage(struct vm_area_struct *vma,
                                                    unsigned long address)
 {
-       drm_map_t *map = (drm_map_t *) vma->vm_private_data;
+       struct drm_map *map = (struct drm_map *) vma->vm_private_data;
        unsigned long offset;
        unsigned long i;
        struct page *page;
@@ -194,12 +194,11 @@ static __inline__ struct page *drm_do_vm_shm_nopage(struct vm_area_struct *vma,
  */
 static void drm_vm_shm_close(struct vm_area_struct *vma)
 {
-       drm_file_t *priv = vma->vm_file->private_data;
-       drm_device_t *dev = priv->head->dev;
-       drm_vma_entry_t *pt, *prev, *next;
-       drm_map_t *map;
-       drm_map_list_t *r_list;
-       struct list_head *list;
+       struct drm_file *priv = vma->vm_file->private_data;
+       struct drm_device *dev = priv->head->dev;
+       struct drm_vma_entry *pt, *temp;
+       struct drm_map *map;
+       struct drm_map_list *r_list;
        int found_maps = 0;
 
        DRM_DEBUG("0x%08lx,0x%08lx\n",
@@ -209,30 +208,22 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
        map = vma->vm_private_data;
 
        mutex_lock(&dev->struct_mutex);
-       for (pt = dev->vmalist, prev = NULL; pt; pt = next) {
-               next = pt->next;
+       list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
                if (pt->vma->vm_private_data == map)
                        found_maps++;
                if (pt->vma == vma) {
-                       if (prev) {
-                               prev->next = pt->next;
-                       } else {
-                               dev->vmalist = pt->next;
-                       }
+                       list_del(&pt->head);
                        drm_free(pt, sizeof(*pt), DRM_MEM_VMAS);
-               } else {
-                       prev = pt;
                }
        }
+
        /* We were the only map that was found */
        if (found_maps == 1 && map->flags & _DRM_REMOVABLE) {
                /* Check to see if we are in the maplist, if we are not, then
                 * we delete this mappings information.
                 */
                found_maps = 0;
-               list = &dev->maplist->head;
-               list_for_each(list, &dev->maplist->head) {
-                       r_list = list_entry(list, drm_map_list_t, head);
+               list_for_each_entry(r_list, &dev->maplist, head) {
                        if (r_list->map == map)
                                found_maps++;
                }
@@ -283,9 +274,9 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
 static __inline__ struct page *drm_do_vm_dma_nopage(struct vm_area_struct *vma,
                                                    unsigned long address)
 {
-       drm_file_t *priv = vma->vm_file->private_data;
-       drm_device_t *dev = priv->head->dev;
-       drm_device_dma_t *dma = dev->dma;
+       struct drm_file *priv = vma->vm_file->private_data;
+       struct drm_device *dev = priv->head->dev;
+       struct drm_device_dma *dma = dev->dma;
        unsigned long offset;
        unsigned long page_nr;
        struct page *page;
@@ -319,10 +310,10 @@ static __inline__ struct page *drm_do_vm_dma_nopage(struct vm_area_struct *vma,
 static __inline__ struct page *drm_do_vm_sg_nopage(struct vm_area_struct *vma,
                                                   unsigned long address)
 {
-       drm_map_t *map = (drm_map_t *) vma->vm_private_data;
-       drm_file_t *priv = vma->vm_file->private_data;
-       drm_device_t *dev = priv->head->dev;
-       drm_sg_mem_t *entry = dev->sg;
+       struct drm_map *map = (struct drm_map *) vma->vm_private_data;
+       struct drm_file *priv = vma->vm_file->private_data;
+       struct drm_device *dev = priv->head->dev;
+       struct drm_sg_mem *entry = dev->sg;
        unsigned long offset;
        unsigned long map_offset;
        unsigned long page_offset;
@@ -414,9 +405,9 @@ static struct vm_operations_struct drm_vm_sg_ops = {
  */
 static void drm_vm_open_locked(struct vm_area_struct *vma)
 {
-       drm_file_t *priv = vma->vm_file->private_data;
-       drm_device_t *dev = priv->head->dev;
-       drm_vma_entry_t *vma_entry;
+       struct drm_file *priv = vma->vm_file->private_data;
+       struct drm_device *dev = priv->head->dev;
+       struct drm_vma_entry *vma_entry;
 
        DRM_DEBUG("0x%08lx,0x%08lx\n",
                  vma->vm_start, vma->vm_end - vma->vm_start);
@@ -425,16 +416,15 @@ static void drm_vm_open_locked(struct vm_area_struct *vma)
        vma_entry = drm_alloc(sizeof(*vma_entry), DRM_MEM_VMAS);
        if (vma_entry) {
                vma_entry->vma = vma;
-               vma_entry->next = dev->vmalist;
                vma_entry->pid = current->pid;
-               dev->vmalist = vma_entry;
+               list_add(&vma_entry->head, &dev->vmalist);
        }
 }
 
 static void drm_vm_open(struct vm_area_struct *vma)
 {
-       drm_file_t *priv = vma->vm_file->private_data;
-       drm_device_t *dev = priv->head->dev;
+       struct drm_file *priv = vma->vm_file->private_data;
+       struct drm_device *dev = priv->head->dev;
 
        mutex_lock(&dev->struct_mutex);
        drm_vm_open_locked(vma);
@@ -451,22 +441,18 @@ static void drm_vm_open(struct vm_area_struct *vma)
  */
 static void drm_vm_close(struct vm_area_struct *vma)
 {
-       drm_file_t *priv = vma->vm_file->private_data;
-       drm_device_t *dev = priv->head->dev;
-       drm_vma_entry_t *pt, *prev;
+       struct drm_file *priv = vma->vm_file->private_data;
+       struct drm_device *dev = priv->head->dev;
+       struct drm_vma_entry *pt, *temp;
 
        DRM_DEBUG("0x%08lx,0x%08lx\n",
                  vma->vm_start, vma->vm_end - vma->vm_start);
        atomic_dec(&dev->vma_count);
 
        mutex_lock(&dev->struct_mutex);
-       for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
+       list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
                if (pt->vma == vma) {
-                       if (prev) {
-                               prev->next = pt->next;
-                       } else {
-                               dev->vmalist = pt->next;
-                       }
+                       list_del(&pt->head);
                        drm_free(pt, sizeof(*pt), DRM_MEM_VMAS);
                        break;
                }
@@ -477,7 +463,7 @@ static void drm_vm_close(struct vm_area_struct *vma)
 /**
  * mmap DMA memory.
  *
- * \param filp file pointer.
+ * \param file_priv DRM file private.
  * \param vma virtual memory area.
  * \return zero on success or a negative number on failure.
  *
@@ -486,9 +472,9 @@ static void drm_vm_close(struct vm_area_struct *vma)
  */
 static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma)
 {
-       drm_file_t *priv = filp->private_data;
-       drm_device_t *dev;
-       drm_device_dma_t *dma;
+       struct drm_file *priv = filp->private_data;
+       struct drm_device *dev;
+       struct drm_device_dma *dma;
        unsigned long length = vma->vm_end - vma->vm_start;
 
        dev = priv->head->dev;
@@ -520,13 +506,14 @@ static int drm_mmap_dma(struct file *filp, struct vm_area_struct *vma)
        vma->vm_ops = &drm_vm_dma_ops;
 
        vma->vm_flags |= VM_RESERVED;   /* Don't swap */
+       vma->vm_flags |= VM_DONTEXPAND;
 
        vma->vm_file = filp;    /* Needed for drm_vm_open() */
        drm_vm_open_locked(vma);
        return 0;
 }
 
-unsigned long drm_core_get_map_ofs(drm_map_t * map)
+unsigned long drm_core_get_map_ofs(struct drm_map * map)
 {
        return map->offset;
 }
@@ -547,7 +534,7 @@ EXPORT_SYMBOL(drm_core_get_reg_ofs);
 /**
  * mmap DMA memory.
  *
- * \param filp file pointer.
+ * \param file_priv DRM file private.
  * \param vma virtual memory area.
  * \return zero on success or a negative number on failure.
  *
@@ -559,11 +546,11 @@ EXPORT_SYMBOL(drm_core_get_reg_ofs);
  */
 static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
 {
-       drm_file_t *priv = filp->private_data;
-       drm_device_t *dev = priv->head->dev;
-       drm_map_t *map = NULL;
+       struct drm_file *priv = filp->private_data;
+       struct drm_device *dev = priv->head->dev;
+       struct drm_map *map = NULL;
        unsigned long offset = 0;
-       drm_hash_item_t *hash;
+       struct drm_hash_item *hash;
 
        DRM_DEBUG("start = 0x%lx, end = 0x%lx, page offset = 0x%lx\n",
                  vma->vm_start, vma->vm_end, vma->vm_pgoff);
@@ -588,7 +575,7 @@ static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
                return -EINVAL;
        }
 
-       map = drm_hash_entry(hash, drm_map_list_t, hash)->map;
+       map = drm_hash_entry(hash, struct drm_map_list, hash)->map;
        if (!map || ((map->flags & _DRM_RESTRICTED) && !capable(CAP_SYS_ADMIN)))
                return -EPERM;
 
@@ -669,6 +656,7 @@ static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
                return -EINVAL; /* This should never happen. */
        }
        vma->vm_flags |= VM_RESERVED;   /* Don't swap */
+       vma->vm_flags |= VM_DONTEXPAND;
 
        vma->vm_file = filp;    /* Needed for drm_vm_open() */
        drm_vm_open_locked(vma);
@@ -677,8 +665,8 @@ static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma)
 
 int drm_mmap(struct file *filp, struct vm_area_struct *vma)
 {
-       drm_file_t *priv = filp->private_data;
-       drm_device_t *dev = priv->head->dev;
+       struct drm_file *priv = filp->private_data;
+       struct drm_device *dev = priv->head->dev;
        int ret;
 
        mutex_lock(&dev->struct_mutex);