- Update to 2.6.32.4

  - security fixes
  - bug fixes
  - obsoletes:
    - patches.arch/module-handle-ppc64-relocating-kcrctabs-when-config_relocatable-y
    - patches.drivers/alsa-sp1-hda-53-alc861vd-capture-fix
    - patches.fixes/audit_untag_chunk.patch
    - patches.fixes/quota-fix-reserved-space-management-for-ordinary-fs.patch
    - patches.fixes/signal-fix-kernel-information-leak-with-print-fatal-signals-1

suse-commit: 121401a1f3a6e858e5915a3ae000650aa2455cb6

diff --cc Makefile
Simple merge

diff --cc arch/ia64/kernel/sys_ia64.c
Simple merge

diff --cc arch/sparc/kernel/sys_sparc_64.c
Simple merge

diff --cc arch/x86/Kconfig.cpu
Simple merge

diff --cc arch/x86/kernel/sys_x86_64.c
Simple merge

diff --cc drivers/char/agp/intel-agp.c
Simple merge

diff --cc drivers/gpu/drm/i915/i915_dma.c
Simple merge

diff --cc drivers/gpu/drm/i915/i915_drv.h
Simple merge

diff --cc drivers/gpu/drm/i915/i915_gem.c
Simple merge

diff --cc drivers/gpu/drm/i915/i915_reg.h
Simple merge

diff --cc drivers/gpu/drm/i915/intel_display.c
Simple merge

diff --cc fs/fcntl.c
Simple merge

diff --cc fs/nfsd/vfs.c
Simple merge

diff --cc include/linux/syscalls.h
Simple merge

diff --cc ipc/shm.c
Simple merge

diff --cc kernel/cgroup.c
Simple merge

diff --cc kernel/module.c
Simple merge

diff --cc kernel/sysctl.c
Simple merge

diff --cc mm/mmap.c
Simple merge

diff --cc mm/mremap.c
index d6740a1,8451908..4c4c803
--- 1/mm/mremap.c
--- 2/mm/mremap.c
+++ b/mm/mremap.c
@@@ -261,6 -261,137 +261,137 @@@ static unsigned long move_vma(struct vm
        return new_addr;
  }
  
+ static struct vm_area_struct *vma_to_resize(unsigned long addr,
+       unsigned long old_len, unsigned long new_len, unsigned long *p)
+ {
+       struct mm_struct *mm = current->mm;
+       struct vm_area_struct *vma = find_vma(mm, addr);
+ 
+       if (!vma || vma->vm_start > addr)
+               goto Efault;
+ 
+       if (is_vm_hugetlb_page(vma))
+               goto Einval;
+ 
+       /* We can't remap across vm area boundaries */
+       if (old_len > vma->vm_end - addr)
+               goto Efault;
+ 
+       if (vma->vm_flags & (VM_DONTEXPAND | VM_PFNMAP)) {
+               if (new_len > old_len)
+                       goto Efault;
+       }
+ 
+       if (vma->vm_flags & VM_LOCKED) {
+               unsigned long locked, lock_limit;
+               locked = mm->locked_vm << PAGE_SHIFT;
 -              lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
++              lock_limit = rlimit(RLIMIT_MEMLOCK);
+               locked += new_len - old_len;
+               if (locked > lock_limit && !capable(CAP_IPC_LOCK))
+                       goto Eagain;
+       }
+ 
+       if (!may_expand_vm(mm, (new_len - old_len) >> PAGE_SHIFT))
+               goto Enomem;
+ 
+       if (vma->vm_flags & VM_ACCOUNT) {
+               unsigned long charged = (new_len - old_len) >> PAGE_SHIFT;
+               if (security_vm_enough_memory(charged))
+                       goto Efault;
+               *p = charged;
+       }
+ 
+       return vma;
+ 
+ Efault:       /* very odd choice for most of the cases, but... */
+       return ERR_PTR(-EFAULT);
+ Einval:
+       return ERR_PTR(-EINVAL);
+ Enomem:
+       return ERR_PTR(-ENOMEM);
+ Eagain:
+       return ERR_PTR(-EAGAIN);
+ }
+ 
+ static unsigned long mremap_to(unsigned long addr,
+       unsigned long old_len, unsigned long new_addr,
+       unsigned long new_len)
+ {
+       struct mm_struct *mm = current->mm;
+       struct vm_area_struct *vma;
+       unsigned long ret = -EINVAL;
+       unsigned long charged = 0;
+       unsigned long map_flags;
+ 
+       if (new_addr & ~PAGE_MASK)
+               goto out;
+ 
+       if (new_len > TASK_SIZE || new_addr > TASK_SIZE - new_len)
+               goto out;
+ 
+       /* Check if the location we're moving into overlaps the
+        * old location at all, and fail if it does.
+        */
+       if ((new_addr <= addr) && (new_addr+new_len) > addr)
+               goto out;
+ 
+       if ((addr <= new_addr) && (addr+old_len) > new_addr)
+               goto out;
+ 
+       ret = security_file_mmap(NULL, 0, 0, 0, new_addr, 1);
+       if (ret)
+               goto out;
+ 
+       ret = do_munmap(mm, new_addr, new_len);
+       if (ret)
+               goto out;
+ 
+       if (old_len >= new_len) {
+               ret = do_munmap(mm, addr+new_len, old_len - new_len);
+               if (ret && old_len != new_len)
+                       goto out;
+               old_len = new_len;
+       }
+ 
+       vma = vma_to_resize(addr, old_len, new_len, &charged);
+       if (IS_ERR(vma)) {
+               ret = PTR_ERR(vma);
+               goto out;
+       }
+ 
+       map_flags = MAP_FIXED;
+       if (vma->vm_flags & VM_MAYSHARE)
+               map_flags |= MAP_SHARED;
+ 
+       ret = get_unmapped_area(vma->vm_file, new_addr, new_len, vma->vm_pgoff +
+                               ((addr - vma->vm_start) >> PAGE_SHIFT),
+                               map_flags);
+       if (ret & ~PAGE_MASK)
+               goto out1;
+ 
+       ret = move_vma(vma, addr, old_len, new_len, new_addr);
+       if (!(ret & ~PAGE_MASK))
+               goto out;
+ out1:
+       vm_unacct_memory(charged);
+ 
+ out:
+       return ret;
+ }
+ 
+ static int vma_expandable(struct vm_area_struct *vma, unsigned long delta)
+ {
+       unsigned long end = vma->vm_end + delta;
+       if (end < vma->vm_end) /* overflow */
+               return 0;
+       if (vma->vm_next && vma->vm_next->vm_start < end) /* intersection */
+               return 0;
+       if (get_unmapped_area(NULL, vma->vm_start, end - vma->vm_start,
+                             0, MAP_FIXED) & ~PAGE_MASK)
+               return 0;
+       return 1;
+ }
+ 
  /*
   * Expand (or shrink) an existing mapping, potentially moving it at the
   * same time (controlled by the MREMAP_MAYMOVE flag and available VM space)

diff --cc net/sunrpc/svc_xprt.c
Simple merge