34 files changed, 312 insertions, 178 deletions

diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 123092d8a984..165a81843357 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -102,9 +102,13 @@ config RTC_INTF_DEV_UIE_EMUL
         depends on RTC_INTF_DEV
         help
           Provides an emulation for RTC_UIE if the underlying rtc chip
-          driver does not expose RTC_UIE ioctls.  Those requests generate
+          driver does not expose RTC_UIE ioctls. Those requests generate
           once-per-second update interrupts, used for synchronization.
 
+          The emulation code will read the time from the hardware
+          clock several times per second, please enable this option
+          only if you know that you really need it.
+
 config RTC_DRV_TEST
         tristate "Test driver/device"
         help
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index a04c1b6b1575..fd2c652504ff 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -307,6 +307,60 @@ int rtc_set_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm)
 }
 EXPORT_SYMBOL_GPL(rtc_set_alarm);
 
+int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled)
+{
+        int err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return err;
+
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (!rtc->ops->alarm_irq_enable)
+                err = -EINVAL;
+        else
+                err = rtc->ops->alarm_irq_enable(rtc->dev.parent, enabled);
+
+        mutex_unlock(&rtc->ops_lock);
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_alarm_irq_enable);
+
+int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled)
+{
+        int err = mutex_lock_interruptible(&rtc->ops_lock);
+        if (err)
+                return err;
+
+#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
+        if (enabled == 0 && rtc->uie_irq_active) {
+                mutex_unlock(&rtc->ops_lock);
+                return rtc_dev_update_irq_enable_emul(rtc, enabled);
+        }
+#endif
+
+        if (!rtc->ops)
+                err = -ENODEV;
+        else if (!rtc->ops->update_irq_enable)
+                err = -EINVAL;
+        else
+                err = rtc->ops->update_irq_enable(rtc->dev.parent, enabled);
+
+        mutex_unlock(&rtc->ops_lock);
+
+#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
+        /*
+         * Enable emulation if the driver did not provide
+         * the update_irq_enable function pointer or if returned
+         * -EINVAL to signal that it has been configured without
+         * interrupts or that are not available at the moment.
+         */
+        if (err == -EINVAL)
+                err = rtc_dev_update_irq_enable_emul(rtc, enabled);
+#endif
+        return err;
+}
+EXPORT_SYMBOL_GPL(rtc_update_irq_enable);
+
 /**
  * rtc_update_irq - report RTC periodic, alarm, and/or update irqs
  * @rtc: the rtc device
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
index ecdea44ae4e5..45152f4952d6 100644
--- a/drivers/rtc/rtc-dev.c
+++ b/drivers/rtc/rtc-dev.c
@@ -92,10 +92,10 @@ static void rtc_uie_timer(unsigned long data)
         spin_unlock_irqrestore(&rtc->irq_lock, flags);
 }
 
-static void clear_uie(struct rtc_device *rtc)
+static int clear_uie(struct rtc_device *rtc)
 {
         spin_lock_irq(&rtc->irq_lock);
-        if (rtc->irq_active) {
+        if (rtc->uie_irq_active) {
                 rtc->stop_uie_polling = 1;
                 if (rtc->uie_timer_active) {
                         spin_unlock_irq(&rtc->irq_lock);
@@ -108,9 +108,10 @@ static void clear_uie(struct rtc_device *rtc)
                         flush_scheduled_work();
                         spin_lock_irq(&rtc->irq_lock);
                 }
-                rtc->irq_active = 0;
+                rtc->uie_irq_active = 0;
         }
         spin_unlock_irq(&rtc->irq_lock);
+        return 0;
 }
 
 static int set_uie(struct rtc_device *rtc)
@@ -122,8 +123,8 @@ static int set_uie(struct rtc_device *rtc)
         if (err)
                 return err;
         spin_lock_irq(&rtc->irq_lock);
-        if (!rtc->irq_active) {
-                rtc->irq_active = 1;
+        if (!rtc->uie_irq_active) {
+                rtc->uie_irq_active = 1;
                 rtc->stop_uie_polling = 0;
                 rtc->oldsecs = tm.tm_sec;
                 rtc->uie_task_active = 1;
@@ -134,6 +135,16 @@ static int set_uie(struct rtc_device *rtc)
         spin_unlock_irq(&rtc->irq_lock);
         return 0;
 }
+
+int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc, unsigned int enabled)
+{
+        if (enabled)
+                return set_uie(rtc);
+        else
+                return clear_uie(rtc);
+}
+EXPORT_SYMBOL(rtc_dev_update_irq_enable_emul);
+
 #endif /* CONFIG_RTC_INTF_DEV_UIE_EMUL */
 
 static ssize_t
@@ -357,6 +368,22 @@ static long rtc_dev_ioctl(struct file *file,
                 err = rtc_irq_set_state(rtc, NULL, 0);
                 break;
 
+        case RTC_AIE_ON:
+                mutex_unlock(&rtc->ops_lock);
+                return rtc_alarm_irq_enable(rtc, 1);
+
+        case RTC_AIE_OFF:
+                mutex_unlock(&rtc->ops_lock);
+                return rtc_alarm_irq_enable(rtc, 0);
+
+        case RTC_UIE_ON:
+                mutex_unlock(&rtc->ops_lock);
+                return rtc_update_irq_enable(rtc, 1);
+
+        case RTC_UIE_OFF:
+                mutex_unlock(&rtc->ops_lock);
+                return rtc_update_irq_enable(rtc, 0);
+
         case RTC_IRQP_SET:
                 err = rtc_irq_set_freq(rtc, NULL, arg);
                 break;
@@ -401,17 +428,6 @@ static long rtc_dev_ioctl(struct file *file,
                         err = -EFAULT;
                 return err;
 
-#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
-        case RTC_UIE_OFF:
-                mutex_unlock(&rtc->ops_lock);
-                clear_uie(rtc);
-                return 0;
-
-        case RTC_UIE_ON:
-                mutex_unlock(&rtc->ops_lock);
-                err = set_uie(rtc);
-                return err;
-#endif
         default:
                 err = -ENOTTY;
                 break;
@@ -440,7 +456,10 @@ static int rtc_dev_release(struct inode *inode, struct file *file)
          * Leave the alarm alone; it may be set to trigger a system wakeup
          * later, or be used by kernel code, and is a one-shot event anyway.
          */
+
+        /* Keep ioctl until all drivers are converted */
         rtc_dev_ioctl(file, RTC_UIE_OFF, 0);
+        rtc_update_irq_enable(rtc, 0);
         rtc_irq_set_state(rtc, NULL, 0);
 
         if (rtc->ops->release)
diff --git a/drivers/video/via/viafbdev.c b/drivers/video/via/viafbdev.c
index 73ac754ad801..e21fe5b6f9ff 100644
--- a/drivers/video/via/viafbdev.c
+++ b/drivers/video/via/viafbdev.c
@@ -546,23 +546,25 @@ static int viafb_blank(int blank_mode, struct fb_info *info)
 
 static int viafb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
 {
-        struct viafb_ioctl_mode viamode;
-        struct viafb_ioctl_samm viasamm;
-        struct viafb_driver_version driver_version;
-        struct fb_var_screeninfo sec_var;
-        struct _panel_size_pos_info panel_pos_size_para;
+        union {
+                struct viafb_ioctl_mode viamode;
+                struct viafb_ioctl_samm viasamm;
+                struct viafb_driver_version driver_version;
+                struct fb_var_screeninfo sec_var;
+                struct _panel_size_pos_info panel_pos_size_para;
+                struct viafb_ioctl_setting viafb_setting;
+                struct device_t active_dev;
+        } u;
         u32 state_info = 0;
-        u32 viainfo_size = sizeof(struct viafb_ioctl_info);
         u32 *viafb_gamma_table;
         char driver_name[] = "viafb";
 
         u32 __user *argp = (u32 __user *) arg;
         u32 gpu32;
         u32 video_dev_info = 0;
-        struct viafb_ioctl_setting viafb_setting = {};
-        struct device_t active_dev = {};
 
         DEBUG_MSG(KERN_INFO "viafb_ioctl: 0x%X !!\n", cmd);
+        memset(&u, 0, sizeof(u));
 
         switch (cmd) {
         case VIAFB_GET_CHIP_INFO:
@@ -571,7 +573,7 @@ static int viafb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
                         return -EFAULT;
                 break;
         case VIAFB_GET_INFO_SIZE:
-                return put_user(viainfo_size, argp);
+                return put_user((u32)sizeof(struct viafb_ioctl_info), argp);
         case VIAFB_GET_INFO:
                 return viafb_ioctl_get_viafb_info(arg);
         case VIAFB_HOTPLUG:
@@ -584,60 +586,60 @@ static int viafb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
                 viafb_hotplug = (gpu32) ? 1 : 0;
                 break;
         case VIAFB_GET_RESOLUTION:
-                viamode.xres = (u32) viafb_hotplug_Xres;
-                viamode.yres = (u32) viafb_hotplug_Yres;
-                viamode.refresh = (u32) viafb_hotplug_refresh;
-                viamode.bpp = (u32) viafb_hotplug_bpp;
+                u.viamode.xres = (u32) viafb_hotplug_Xres;
+                u.viamode.yres = (u32) viafb_hotplug_Yres;
+                u.viamode.refresh = (u32) viafb_hotplug_refresh;
+                u.viamode.bpp = (u32) viafb_hotplug_bpp;
                 if (viafb_SAMM_ON == 1) {
-                        viamode.xres_sec = viafb_second_xres;
-                        viamode.yres_sec = viafb_second_yres;
-                        viamode.virtual_xres_sec = viafb_second_virtual_xres;
-                        viamode.virtual_yres_sec = viafb_second_virtual_yres;
-                        viamode.refresh_sec = viafb_refresh1;
-                        viamode.bpp_sec = viafb_bpp1;
+                        u.viamode.xres_sec = viafb_second_xres;
+                        u.viamode.yres_sec = viafb_second_yres;
+                        u.viamode.virtual_xres_sec = viafb_second_virtual_xres;
+                        u.viamode.virtual_yres_sec = viafb_second_virtual_yres;
+                        u.viamode.refresh_sec = viafb_refresh1;
+                        u.viamode.bpp_sec = viafb_bpp1;
                 } else {
-                        viamode.xres_sec = 0;
-                        viamode.yres_sec = 0;
-                        viamode.virtual_xres_sec = 0;
-                        viamode.virtual_yres_sec = 0;
-                        viamode.refresh_sec = 0;
-                        viamode.bpp_sec = 0;
+                        u.viamode.xres_sec = 0;
+                        u.viamode.yres_sec = 0;
+                        u.viamode.virtual_xres_sec = 0;
+                        u.viamode.virtual_yres_sec = 0;
+                        u.viamode.refresh_sec = 0;
+                        u.viamode.bpp_sec = 0;
                 }
-                if (copy_to_user(argp, &viamode, sizeof(viamode)))
+                if (copy_to_user(argp, &u.viamode, sizeof(u.viamode)))
                         return -EFAULT;
                 break;
         case VIAFB_GET_SAMM_INFO:
-                viasamm.samm_status = viafb_SAMM_ON;
+                u.viasamm.samm_status = viafb_SAMM_ON;
 
                 if (viafb_SAMM_ON == 1) {
                         if (viafb_dual_fb) {
-                                viasamm.size_prim = viaparinfo->fbmem_free;
-                                viasamm.size_sec = viaparinfo1->fbmem_free;
+                                u.viasamm.size_prim = viaparinfo->fbmem_free;
+                                u.viasamm.size_sec = viaparinfo1->fbmem_free;
                         } else {
                                 if (viafb_second_size) {
-                                        viasamm.size_prim =
+                                        u.viasamm.size_prim =
                                             viaparinfo->fbmem_free -
                                             viafb_second_size * 1024 * 1024;
-                                        viasamm.size_sec =
+                                        u.viasamm.size_sec =
                                             viafb_second_size * 1024 * 1024;
                                 } else {
-                                        viasamm.size_prim =
+                                        u.viasamm.size_prim =
                                             viaparinfo->fbmem_free >> 1;
-                                        viasamm.size_sec =
+                                        u.viasamm.size_sec =
                                             (viaparinfo->fbmem_free >> 1);
                                 }
                         }
-                        viasamm.mem_base = viaparinfo->fbmem;
-                        viasamm.offset_sec = viafb_second_offset;
+                        u.viasamm.mem_base = viaparinfo->fbmem;
+                        u.viasamm.offset_sec = viafb_second_offset;
                 } else {
-                        viasamm.size_prim =
+                        u.viasamm.size_prim =
                             viaparinfo->memsize - viaparinfo->fbmem_used;
-                        viasamm.size_sec = 0;
-                        viasamm.mem_base = viaparinfo->fbmem;
-                        viasamm.offset_sec = 0;
+                        u.viasamm.size_sec = 0;
+                        u.viasamm.mem_base = viaparinfo->fbmem;
+                        u.viasamm.offset_sec = 0;
                 }
 
-                if (copy_to_user(argp, &viasamm, sizeof(viasamm)))
+                if (copy_to_user(argp, &u.viasamm, sizeof(u.viasamm)))
                         return -EFAULT;
 
                 break;
@@ -662,74 +664,75 @@ static int viafb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
                         viafb_lcd_disable();
                 break;
         case VIAFB_SET_DEVICE:
-                if (copy_from_user(&active_dev, (void *)argp,
-                        sizeof(active_dev)))
+                if (copy_from_user(&u.active_dev, (void *)argp,
+                        sizeof(u.active_dev)))
                         return -EFAULT;
-                viafb_set_device(active_dev);
+                viafb_set_device(u.active_dev);
                 viafb_set_par(info);
                 break;
         case VIAFB_GET_DEVICE:
-                active_dev.crt = viafb_CRT_ON;
-                active_dev.dvi = viafb_DVI_ON;
-                active_dev.lcd = viafb_LCD_ON;
-                active_dev.samm = viafb_SAMM_ON;
-                active_dev.primary_dev = viafb_primary_dev;
+                u.active_dev.crt = viafb_CRT_ON;
+                u.active_dev.dvi = viafb_DVI_ON;
+                u.active_dev.lcd = viafb_LCD_ON;
+                u.active_dev.samm = viafb_SAMM_ON;
+                u.active_dev.primary_dev = viafb_primary_dev;
 
-                active_dev.lcd_dsp_cent = viafb_lcd_dsp_method;
-                active_dev.lcd_panel_id = viafb_lcd_panel_id;
-                active_dev.lcd_mode = viafb_lcd_mode;
+                u.active_dev.lcd_dsp_cent = viafb_lcd_dsp_method;
+                u.active_dev.lcd_panel_id = viafb_lcd_panel_id;
+                u.active_dev.lcd_mode = viafb_lcd_mode;
 
-                active_dev.xres = viafb_hotplug_Xres;
-                active_dev.yres = viafb_hotplug_Yres;
+                u.active_dev.xres = viafb_hotplug_Xres;
+                u.active_dev.yres = viafb_hotplug_Yres;
 
-                active_dev.xres1 = viafb_second_xres;
-                active_dev.yres1 = viafb_second_yres;
+                u.active_dev.xres1 = viafb_second_xres;
+                u.active_dev.yres1 = viafb_second_yres;
 
-                active_dev.bpp = viafb_bpp;
-                active_dev.bpp1 = viafb_bpp1;
-                active_dev.refresh = viafb_refresh;
-                active_dev.refresh1 = viafb_refresh1;
+                u.active_dev.bpp = viafb_bpp;
+                u.active_dev.bpp1 = viafb_bpp1;
+                u.active_dev.refresh = viafb_refresh;
+                u.active_dev.refresh1 = viafb_refresh1;
 
-                active_dev.epia_dvi = viafb_platform_epia_dvi;
-                active_dev.lcd_dual_edge = viafb_device_lcd_dualedge;
-                active_dev.bus_width = viafb_bus_width;
+                u.active_dev.epia_dvi = viafb_platform_epia_dvi;
+                u.active_dev.lcd_dual_edge = viafb_device_lcd_dualedge;
+                u.active_dev.bus_width = viafb_bus_width;
 
-                if (copy_to_user(argp, &active_dev, sizeof(active_dev)))
+                if (copy_to_user(argp, &u.active_dev, sizeof(u.active_dev)))
                         return -EFAULT;
                 break;
 
         case VIAFB_GET_DRIVER_VERSION:
-                driver_version.iMajorNum = VERSION_MAJOR;
-                driver_version.iKernelNum = VERSION_KERNEL;
-                driver_version.iOSNum = VERSION_OS;
-                driver_version.iMinorNum = VERSION_MINOR;
+                u.driver_version.iMajorNum = VERSION_MAJOR;
+                u.driver_version.iKernelNum = VERSION_KERNEL;
+                u.driver_version.iOSNum = VERSION_OS;
+                u.driver_version.iMinorNum = VERSION_MINOR;
 
-                if (copy_to_user(argp, &driver_version,
-                        sizeof(driver_version)))
+                if (copy_to_user(argp, &u.driver_version,
+                        sizeof(u.driver_version)))
                         return -EFAULT;
 
                 break;
 
         case VIAFB_SET_DEVICE_INFO:
-                if (copy_from_user(&viafb_setting,
-                        argp, sizeof(viafb_setting)))
+                if (copy_from_user(&u.viafb_setting,
+                        argp, sizeof(u.viafb_setting)))
                         return -EFAULT;
-                if (apply_device_setting(viafb_setting, info) < 0)
+                if (apply_device_setting(u.viafb_setting, info) < 0)
                         return -EINVAL;
 
                 break;
 
         case VIAFB_SET_SECOND_MODE:
-                if (copy_from_user(&sec_var, argp, sizeof(sec_var)))
+                if (copy_from_user(&u.sec_var, argp, sizeof(u.sec_var)))
                         return -EFAULT;
-                apply_second_mode_setting(&sec_var);
+                apply_second_mode_setting(&u.sec_var);
                 break;
 
         case VIAFB_GET_DEVICE_INFO:
 
-                retrieve_device_setting(&viafb_setting);
+                retrieve_device_setting(&u.viafb_setting);
 
-                if (copy_to_user(argp, &viafb_setting, sizeof(viafb_setting)))
+                if (copy_to_user(argp, &u.viafb_setting,
+                                 sizeof(u.viafb_setting)))
                         return -EFAULT;
 
                 break;
@@ -806,51 +809,51 @@ static int viafb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
                 break;
 
         case VIAFB_GET_PANEL_MAX_SIZE:
-                if (copy_from_user
-                    (&panel_pos_size_para, argp, sizeof(panel_pos_size_para)))
+                if (copy_from_user(&u.panel_pos_size_para, argp,
+                                   sizeof(u.panel_pos_size_para)))
                         return -EFAULT;
-                panel_pos_size_para.x = panel_pos_size_para.y = 0;
-                if (copy_to_user(argp, &panel_pos_size_para,
-                     sizeof(panel_pos_size_para)))
+                u.panel_pos_size_para.x = u.panel_pos_size_para.y = 0;
+                if (copy_to_user(argp, &u.panel_pos_size_para,
+                     sizeof(u.panel_pos_size_para)))
                         return -EFAULT;
                 break;
         case VIAFB_GET_PANEL_MAX_POSITION:
-                if (copy_from_user
-                    (&panel_pos_size_para, argp, sizeof(panel_pos_size_para)))
+                if (copy_from_user(&u.panel_pos_size_para, argp,
+                                   sizeof(u.panel_pos_size_para)))
                         return -EFAULT;
-                panel_pos_size_para.x = panel_pos_size_para.y = 0;
-                if (copy_to_user(argp, &panel_pos_size_para,
-                     sizeof(panel_pos_size_para)))
+                u.panel_pos_size_para.x = u.panel_pos_size_para.y = 0;
+                if (copy_to_user(argp, &u.panel_pos_size_para,
+                                 sizeof(u.panel_pos_size_para)))
                         return -EFAULT;
                 break;
 
         case VIAFB_GET_PANEL_POSITION:
-                if (copy_from_user
-                    (&panel_pos_size_para, argp, sizeof(panel_pos_size_para)))
+                if (copy_from_user(&u.panel_pos_size_para, argp,
+                                   sizeof(u.panel_pos_size_para)))
                         return -EFAULT;
-                panel_pos_size_para.x = panel_pos_size_para.y = 0;
-                if (copy_to_user(argp, &panel_pos_size_para,
-                     sizeof(panel_pos_size_para)))
+                u.panel_pos_size_para.x = u.panel_pos_size_para.y = 0;
+                if (copy_to_user(argp, &u.panel_pos_size_para,
+                                 sizeof(u.panel_pos_size_para)))
                         return -EFAULT;
                 break;
         case VIAFB_GET_PANEL_SIZE:
-                if (copy_from_user
-                    (&panel_pos_size_para, argp, sizeof(panel_pos_size_para)))
+                if (copy_from_user(&u.panel_pos_size_para, argp,
+                                   sizeof(u.panel_pos_size_para)))
                         return -EFAULT;
-                panel_pos_size_para.x = panel_pos_size_para.y = 0;
-                if (copy_to_user(argp, &panel_pos_size_para,
-                     sizeof(panel_pos_size_para)))
+                u.panel_pos_size_para.x = u.panel_pos_size_para.y = 0;
+                if (copy_to_user(argp, &u.panel_pos_size_para,
+                                 sizeof(u.panel_pos_size_para)))
                         return -EFAULT;
                 break;
 
         case VIAFB_SET_PANEL_POSITION:
-                if (copy_from_user
-                    (&panel_pos_size_para, argp, sizeof(panel_pos_size_para)))
+                if (copy_from_user(&u.panel_pos_size_para, argp,
+                                   sizeof(u.panel_pos_size_para)))
                         return -EFAULT;
                 break;
         case VIAFB_SET_PANEL_SIZE:
-                if (copy_from_user
-                    (&panel_pos_size_para, argp, sizeof(panel_pos_size_para)))
+                if (copy_from_user(&u.panel_pos_size_para, argp,
+                                   sizeof(u.panel_pos_size_para)))
                         return -EFAULT;
                 break;
 
@@ -1052,10 +1055,8 @@ static void viafb_imageblit(struct fb_info *info,
 
 static int viafb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 {
-        u8 data[CURSOR_SIZE / 8];
-        u32 data_bak[CURSOR_SIZE / 32];
         u32 temp, xx, yy, bg_col = 0, fg_col = 0;
-        int size, i, j = 0;
+        int i, j = 0;
         static int hw_cursor;
         struct viafb_par *p_viafb_par;
 
@@ -1178,22 +1179,29 @@ static int viafb_cursor(struct fb_info *info, struct fb_cursor *cursor)
         }
 
         if (cursor->set & FB_CUR_SETSHAPE) {
-                size =
+                struct {
+                        u8 data[CURSOR_SIZE / 8];
+                        u32 bak[CURSOR_SIZE / 32];
+                } *cr_data = kzalloc(sizeof(*cr_data), GFP_ATOMIC);
+                int size =
                     ((viacursor.image.width + 7) >> 3) *
                     viacursor.image.height;
 
+                if (cr_data == NULL)
+                        goto out;
+
                 if (MAX_CURS == 32) {
                         for (i = 0; i < (CURSOR_SIZE / 32); i++) {
-                                data_bak[i] = 0x0;
-                                data_bak[i + 1] = 0xFFFFFFFF;
+                                cr_data->bak[i] = 0x0;
+                                cr_data->bak[i + 1] = 0xFFFFFFFF;
                                 i += 1;
                         }
                 } else if (MAX_CURS == 64) {
                         for (i = 0; i < (CURSOR_SIZE / 32); i++) {
-                                data_bak[i] = 0x0;
-                                data_bak[i + 1] = 0x0;
-                                data_bak[i + 2] = 0xFFFFFFFF;
-                                data_bak[i + 3] = 0xFFFFFFFF;
+                                cr_data->bak[i] = 0x0;
+                                cr_data->bak[i + 1] = 0x0;
+                                cr_data->bak[i + 2] = 0xFFFFFFFF;
+                                cr_data->bak[i + 3] = 0xFFFFFFFF;
                                 i += 3;
                         }
                 }
@@ -1201,12 +1209,12 @@ static int viafb_cursor(struct fb_info *info, struct fb_cursor *cursor)
                 switch (viacursor.rop) {
                 case ROP_XOR:
                         for (i = 0; i < size; i++)
-                                data[i] = viacursor.mask[i];
+                                cr_data->data[i] = viacursor.mask[i];
                         break;
                 case ROP_COPY:
 
                         for (i = 0; i < size; i++)
-                                data[i] = viacursor.mask[i];
+                                cr_data->data[i] = viacursor.mask[i];
                         break;
                 default:
                         break;
@@ -1214,23 +1222,25 @@ static int viafb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 
                 if (MAX_CURS == 32) {
                         for (i = 0; i < size; i++) {
-                                data_bak[j] = (u32) data[i];
-                                data_bak[j + 1] = ~data_bak[j];
+                                cr_data->bak[j] = (u32) cr_data->data[i];
+                                cr_data->bak[j + 1] = ~cr_data->bak[j];
                                 j += 2;
                         }
                 } else if (MAX_CURS == 64) {
                         for (i = 0; i < size; i++) {
-                                data_bak[j] = (u32) data[i];
-                                data_bak[j + 1] = 0x0;
-                                data_bak[j + 2] = ~data_bak[j];
-                                data_bak[j + 3] = ~data_bak[j + 1];
+                                cr_data->bak[j] = (u32) cr_data->data[i];
+                                cr_data->bak[j + 1] = 0x0;
+                                cr_data->bak[j + 2] = ~cr_data->bak[j];
+                                cr_data->bak[j + 3] = ~cr_data->bak[j + 1];
                                 j += 4;
                         }
                 }
 
                 memcpy(((struct viafb_par *)(info->par))->fbmem_virt +
                        ((struct viafb_par *)(info->par))->cursor_start,
-                       data_bak, CURSOR_SIZE);
+                       cr_data->bak, CURSOR_SIZE);
+out:
+                kfree(cr_data);
         }
 
         if (viacursor.enable)
diff --git a/fs/affs/file.c b/fs/affs/file.c
index 1377b1240b6e..9246cb4aa018 100644
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -628,7 +628,7 @@ static int affs_write_begin_ofs(struct file *file, struct address_space *mapping
         }
 
         index = pos >> PAGE_CACHE_SHIFT;
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
                 return -ENOMEM;
         *pagep = page;
diff --git a/fs/afs/write.c b/fs/afs/write.c
index d6b85dab35fc..3fb36d433621 100644
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -144,7 +144,7 @@ int afs_write_begin(struct file *file, struct address_space *mapping,
         candidate->state = AFS_WBACK_PENDING;
         init_waitqueue_head(&candidate->waitq);
 
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page) {
                 kfree(candidate);
                 return -ENOMEM;
diff --git a/fs/buffer.c b/fs/buffer.c
index 776ae091d3b0..a13f09b696f7 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1996,7 +1996,7 @@ int block_write_begin(struct file *file, struct address_space *mapping,
         page = *pagep;
         if (page == NULL) {
                 ownpage = 1;
-                page = __grab_cache_page(mapping, index);
+                page = grab_cache_page_write_begin(mapping, index, flags);
                 if (!page) {
                         status = -ENOMEM;
                         goto out;
@@ -2502,7 +2502,7 @@ int nobh_write_begin(struct file *file, struct address_space *mapping,
         from = pos & (PAGE_CACHE_SIZE - 1);
         to = from + len;
 
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
                 return -ENOMEM;
         *pagep = page;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index b1e1fc6a6e6a..12bb656fbe75 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -2074,7 +2074,7 @@ static int cifs_write_begin(struct file *file, struct address_space *mapping,
 
         cFYI(1, ("write_begin from %lld len %d", (long long)pos, len));
 
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page) {
                 rc = -ENOMEM;
                 goto out;
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index 04d7b3fa1ac6..46cec2b69796 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -288,7 +288,7 @@ static int ecryptfs_write_begin(struct file *file,
         loff_t prev_page_end_size;
         int rc = 0;
 
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
                 return -ENOMEM;
         *pagep = page;
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index c4bdccf976b5..5fa453b49a64 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -1161,7 +1161,7 @@ static int ext3_write_begin(struct file *file, struct address_space *mapping,
         to = from + len;
 
 retry:
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
                 return -ENOMEM;
         *pagep = page;
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 297ea8dfac7c..1dd2abe6313e 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -2175,8 +2175,7 @@ retry:
                  * We have a transaction open.  All is sweetness.  It also sets
                  * i_size in generic_commit_write().
                  */
-                err = __page_symlink(inode, symname, l,
-                                mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS);
+                err = __page_symlink(inode, symname, l, 1);
                 if (err) {
                         drop_nlink(inode);
                         unlock_new_inode(inode);
diff --git a/fs/ext4/ext4_sb.h b/fs/ext4/ext4_sb.h
index 445fde603df8..b21f16713db0 100644
--- a/fs/ext4/ext4_sb.h
+++ b/fs/ext4/ext4_sb.h
@@ -146,4 +146,10 @@ struct ext4_sb_info {
         struct flex_groups *s_flex_groups;
 };
 
+static inline spinlock_t *
+sb_bgl_lock(struct ext4_sb_info *sbi, unsigned int block_group)
+{
+        return bgl_lock_ptr(&sbi->s_blockgroup_lock, block_group);
+}
+
 #endif  /* _EXT4_SB */
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 7c3325e0b005..6702a49992a6 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1346,7 +1346,7 @@ retry:
                 goto out;
         }
 
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page) {
                 ext4_journal_stop(handle);
                 ret = -ENOMEM;
@@ -2550,7 +2550,7 @@ retry:
                 goto out;
         }
 
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page) {
                 ext4_journal_stop(handle);
                 ret = -ENOMEM;
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index da98a9012fa5..9fd2a5e1be4d 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -2212,8 +2212,7 @@ retry:
                  * We have a transaction open.  All is sweetness.  It also sets
                  * i_size in generic_commit_write().
                  */
-                err = __page_symlink(inode, symname, l,
-                                mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS);
+                err = __page_symlink(inode, symname, l, 1);
                 if (err) {
                         clear_nlink(inode);
                         unlock_new_inode(inode);
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 34930a964b82..4c9ee7011265 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -646,7 +646,7 @@ static int fuse_write_begin(struct file *file, struct address_space *mapping,
 {
         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
 
-        *pagep = __grab_cache_page(mapping, index);
+        *pagep = grab_cache_page_write_begin(mapping, index, flags);
         if (!*pagep)
                 return -ENOMEM;
         return 0;
@@ -779,7 +779,7 @@ static ssize_t fuse_fill_write_pages(struct fuse_req *req,
                         break;
 
                 err = -ENOMEM;
-                page = __grab_cache_page(mapping, index);
+                page = grab_cache_page_write_begin(mapping, index, 0);
                 if (!page)
                         break;
 
diff --git a/fs/gfs2/ops_address.c b/fs/gfs2/ops_address.c
index 27563816e1c5..15f710f2d4da 100644
--- a/fs/gfs2/ops_address.c
+++ b/fs/gfs2/ops_address.c
@@ -675,7 +675,7 @@ static int gfs2_write_begin(struct file *file, struct address_space *mapping,
                 goto out_trans_fail;
 
         error = -ENOMEM;
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         *pagep = page;
         if (unlikely(!page))
                 goto out_endtrans;
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 3a31451ac170..5c538e0ec14b 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -501,7 +501,7 @@ int hostfs_write_begin(struct file *file, struct address_space *mapping,
 {
         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
 
-        *pagep = __grab_cache_page(mapping, index);
+        *pagep = grab_cache_page_write_begin(mapping, index, flags);
         if (!*pagep)
                 return -ENOMEM;
         return 0;
diff --git a/fs/jffs2/file.c b/fs/jffs2/file.c
index 5a98aa87c853..5edc2bf20581 100644
--- a/fs/jffs2/file.c
+++ b/fs/jffs2/file.c
@@ -132,7 +132,7 @@ static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
         uint32_t pageofs = index << PAGE_CACHE_SHIFT;
         int ret = 0;
 
-        pg = __grab_cache_page(mapping, index);
+        pg = grab_cache_page_write_begin(mapping, index, flags);
         if (!pg)
                 return -ENOMEM;
         *pagep = pg;
diff --git a/fs/libfs.c b/fs/libfs.c
index e960a8321902..bdaec17fa388 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -360,7 +360,7 @@ int simple_write_begin(struct file *file, struct address_space *mapping,
         index = pos >> PAGE_CACHE_SHIFT;
         from = pos & (PAGE_CACHE_SIZE - 1);
 
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
                 return -ENOMEM;
 
diff --git a/fs/namei.c b/fs/namei.c
index dd5c9f0bf829..df2d3df4f049 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2817,18 +2817,23 @@ void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
         }
 }
 
-int __page_symlink(struct inode *inode, const char *symname, int len,
-                gfp_t gfp_mask)
+/*
+ * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS
+ */
+int __page_symlink(struct inode *inode, const char *symname, int len, int nofs)
 {
         struct address_space *mapping = inode->i_mapping;
         struct page *page;
         void *fsdata;
         int err;
         char *kaddr;
+        unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE;
+        if (nofs)
+                flags |= AOP_FLAG_NOFS;
 
 retry:
         err = pagecache_write_begin(NULL, mapping, 0, len-1,
-                                AOP_FLAG_UNINTERRUPTIBLE, &page, &fsdata);
+                                flags, &page, &fsdata);
         if (err)
                 goto fail;
 
@@ -2852,7 +2857,7 @@ fail:
 int page_symlink(struct inode *inode, const char *symname, int len)
 {
         return __page_symlink(inode, symname, len,
-                        mapping_gfp_mask(inode->i_mapping));
+                        !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS));
 }
 
 const struct inode_operations page_symlink_inode_operations = {
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index d319b49f8f06..90f292b520d2 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -354,7 +354,7 @@ static int nfs_write_begin(struct file *file, struct address_space *mapping,
                 file->f_path.dentry->d_name.name,
                 mapping->host->i_ino, len, (long long) pos);
 
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
                 return -ENOMEM;
         *pagep = page;
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 145c2d3e5e01..ed04f47007f8 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -2561,7 +2561,7 @@ static int reiserfs_write_begin(struct file *file,
         }
 
         index = pos >> PAGE_CACHE_SHIFT;
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
                 return -ENOMEM;
         *pagep = page;
diff --git a/fs/smbfs/file.c b/fs/smbfs/file.c
index e4f8d51a5553..92d5e8ffb639 100644
--- a/fs/smbfs/file.c
+++ b/fs/smbfs/file.c
@@ -297,7 +297,7 @@ static int smb_write_begin(struct file *file, struct address_space *mapping,
                         struct page **pagep, void **fsdata)
 {
         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
-        *pagep = __grab_cache_page(mapping, index);
+        *pagep = grab_cache_page_write_begin(mapping, index, flags);
         if (!*pagep)
                 return -ENOMEM;
         return 0;
diff --git a/fs/ubifs/file.c b/fs/ubifs/file.c
index fe82d2464d46..bf37374567fa 100644
--- a/fs/ubifs/file.c
+++ b/fs/ubifs/file.c
@@ -219,7 +219,8 @@ static void release_existing_page_budget(struct ubifs_info *c)
 }
 
 static int write_begin_slow(struct address_space *mapping,
-                            loff_t pos, unsigned len, struct page **pagep)
+                            loff_t pos, unsigned len, struct page **pagep,
+                            unsigned flags)
 {
         struct inode *inode = mapping->host;
         struct ubifs_info *c = inode->i_sb->s_fs_info;
@@ -247,7 +248,7 @@ static int write_begin_slow(struct address_space *mapping,
         if (unlikely(err))
                 return err;
 
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (unlikely(!page)) {
                 ubifs_release_budget(c, &req);
                 return -ENOMEM;
@@ -438,7 +439,7 @@ static int ubifs_write_begin(struct file *file, struct address_space *mapping,
                 return -EROFS;
 
         /* Try out the fast-path part first */
-        page = __grab_cache_page(mapping, index);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (unlikely(!page))
                 return -ENOMEM;
 
@@ -483,7 +484,7 @@ static int ubifs_write_begin(struct file *file, struct address_space *mapping,
                 unlock_page(page);
                 page_cache_release(page);
 
-                return write_begin_slow(mapping, pos, len, pagep);
+                return write_begin_slow(mapping, pos, len, pagep, flags);
         }
 
         /*
diff --git a/include/linux/blockgroup_lock.h b/include/linux/blockgroup_lock.h
index 8607312983bd..e44b88ba552b 100644
--- a/include/linux/blockgroup_lock.h
+++ b/include/linux/blockgroup_lock.h
@@ -53,7 +53,10 @@ static inline void bgl_lock_init(struct blockgroup_lock *bgl)
  * The accessor is a macro so we can embed a blockgroup_lock into different
  * superblock types
  */
-#define sb_bgl_lock(sb, block_group) \
-        (&(sb)->s_blockgroup_lock.locks[(block_group) & (NR_BG_LOCKS-1)].lock)
+static inline spinlock_t *
+bgl_lock_ptr(struct blockgroup_lock *bgl, unsigned int block_group)
+{
+        return &bgl->locks[(block_group) & (NR_BG_LOCKS-1)].lock;
+}
 
 #endif
diff --git a/include/linux/ext2_fs_sb.h b/include/linux/ext2_fs_sb.h
index f273415ab6f1..dc541f3653d1 100644
--- a/include/linux/ext2_fs_sb.h
+++ b/include/linux/ext2_fs_sb.h
@@ -108,4 +108,10 @@ struct ext2_sb_info {
         struct ext2_reserve_window_node s_rsv_window_head;
 };
 
+static inline spinlock_t *
+sb_bgl_lock(struct ext2_sb_info *sbi, unsigned int block_group)
+{
+        return bgl_lock_ptr(&sbi->s_blockgroup_lock, block_group);
+}
+
 #endif  /* _LINUX_EXT2_FS_SB */
diff --git a/include/linux/ext3_fs_sb.h b/include/linux/ext3_fs_sb.h
index b65f0288b842..e024e38248ff 100644
--- a/include/linux/ext3_fs_sb.h
+++ b/include/linux/ext3_fs_sb.h
@@ -83,4 +83,10 @@ struct ext3_sb_info {
 #endif
 };
 
+static inline spinlock_t *
+sb_bgl_lock(struct ext3_sb_info *sbi, unsigned int block_group)
+{
+        return bgl_lock_ptr(&sbi->s_blockgroup_lock, block_group);
+}
+
 #endif  /* _LINUX_EXT3_FS_SB */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index e2170ee21e18..f2a3010140e3 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -423,6 +423,9 @@ enum positive_aop_returns {
 
 #define AOP_FLAG_UNINTERRUPTIBLE        0x0001 /* will not do a short write */
 #define AOP_FLAG_CONT_EXPAND            0x0002 /* called from cont_expand */
+#define AOP_FLAG_NOFS                   0x0004 /* used by filesystem to direct
+                                                * helper code (eg buffer layer)
+                                                * to clear GFP_FS from alloc */
 
 /*
  * oh the beauties of C type declarations.
@@ -2035,7 +2038,7 @@ extern int page_readlink(struct dentry *, char __user *, int);
 extern void *page_follow_link_light(struct dentry *, struct nameidata *);
 extern void page_put_link(struct dentry *, struct nameidata *, void *);
 extern int __page_symlink(struct inode *inode, const char *symname, int len,
-                gfp_t gfp_mask);
+                int nofs);
 extern int page_symlink(struct inode *inode, const char *symname, int len);
 extern const struct inode_operations page_symlink_inode_operations;
 extern int generic_readlink(struct dentry *, char __user *, int);
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 709742be02f0..01ca0856caff 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -241,7 +241,8 @@ unsigned find_get_pages_contig(struct address_space *mapping, pgoff_t start,
 unsigned find_get_pages_tag(struct address_space *mapping, pgoff_t *index,
                         int tag, unsigned int nr_pages, struct page **pages);
 
-struct page *__grab_cache_page(struct address_space *mapping, pgoff_t index);
+struct page *grab_cache_page_write_begin(struct address_space *mapping,
+                        pgoff_t index, unsigned flags);
 
 /*
  * Returns locked page at given index in given cache, creating it if needed.
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index 91f597ad6acc..4046b75563c1 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -145,6 +145,8 @@ struct rtc_class_ops {
         int (*irq_set_state)(struct device *, int enabled);
         int (*irq_set_freq)(struct device *, int freq);
         int (*read_callback)(struct device *, int data);
+        int (*alarm_irq_enable)(struct device *, unsigned int enabled);
+        int (*update_irq_enable)(struct device *, unsigned int enabled);
 };
 
 #define RTC_DEVICE_NAME_SIZE 20
@@ -181,7 +183,7 @@ struct rtc_device
         struct timer_list uie_timer;
         /* Those fields are protected by rtc->irq_lock */
         unsigned int oldsecs;
-        unsigned int irq_active:1;
+        unsigned int uie_irq_active:1;
         unsigned int stop_uie_polling:1;
         unsigned int uie_task_active:1;
         unsigned int uie_timer_active:1;
@@ -216,6 +218,10 @@ extern int rtc_irq_set_state(struct rtc_device *rtc,
                                 struct rtc_task *task, int enabled);
 extern int rtc_irq_set_freq(struct rtc_device *rtc,
                                 struct rtc_task *task, int freq);
+extern int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled);
+extern int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled);
+extern int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc,
+                                                unsigned int enabled);
 
 typedef struct rtc_task {
         void (*func)(void *private_data);
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index 4be01bb44377..82229317753d 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -19,6 +19,8 @@
 #ifndef __LINUX_SPI_H
 #define __LINUX_SPI_H
 
+#include <linux/device.h>
+
 /*
  * INTERFACES between SPI master-side drivers and SPI infrastructure.
  * (There's no SPI slave support for Linux yet...)
diff --git a/kernel/cgroup.c b/kernel/cgroup.c
index 48348dde6d81..891a84eb9d30 100644
--- a/kernel/cgroup.c
+++ b/kernel/cgroup.c
@@ -2945,7 +2945,11 @@ int cgroup_clone(struct task_struct *tsk, struct cgroup_subsys *subsys,
         parent = task_cgroup(tsk, subsys->subsys_id);
 
         /* Pin the hierarchy */
-        atomic_inc(&parent->root->sb->s_active);
+        if (!atomic_inc_not_zero(&parent->root->sb->s_active)) {
+                /* We race with the final deactivate_super() */
+                mutex_unlock(&cgroup_mutex);
+                return 0;
+        }
 
         /* Keep the cgroup alive */
         get_css_set(cg);
diff --git a/mm/filemap.c b/mm/filemap.c
index f3e5f8944d17..f8c69273c37f 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2140,19 +2140,24 @@ EXPORT_SYMBOL(generic_file_direct_write);
  * Find or create a page at the given pagecache position. Return the locked
  * page. This function is specifically for buffered writes.
  */
-struct page *__grab_cache_page(struct address_space *mapping, pgoff_t index)
+struct page *grab_cache_page_write_begin(struct address_space *mapping,
+                                        pgoff_t index, unsigned flags)
 {
         int status;
         struct page *page;
+        gfp_t gfp_notmask = 0;
+        if (flags & AOP_FLAG_NOFS)
+                gfp_notmask = __GFP_FS;
 repeat:
         page = find_lock_page(mapping, index);
         if (likely(page))
                 return page;
 
-        page = page_cache_alloc(mapping);
+        page = __page_cache_alloc(mapping_gfp_mask(mapping) & ~gfp_notmask);
         if (!page)
                 return NULL;
-        status = add_to_page_cache_lru(page, mapping, index, GFP_KERNEL);
+        status = add_to_page_cache_lru(page, mapping, index,
+                                                GFP_KERNEL & ~gfp_notmask);
         if (unlikely(status)) {
                 page_cache_release(page);
                 if (status == -EEXIST)
@@ -2161,7 +2166,7 @@ repeat:
         }
         return page;
 }
-EXPORT_SYMBOL(__grab_cache_page);
+EXPORT_SYMBOL(grab_cache_page_write_begin);
 
 static ssize_t generic_perform_write(struct file *file,
                                 struct iov_iter *i, loff_t pos)
diff --git a/mm/vmalloc.c b/mm/vmalloc.c
index 1ddb77ba3995..7465f22fec0c 100644
--- a/mm/vmalloc.c
+++ b/mm/vmalloc.c
@@ -151,11 +151,12 @@ static int vmap_pud_range(pgd_t *pgd, unsigned long addr,
  *
  * Ie. pte at addr+N*PAGE_SIZE shall point to pfn corresponding to pages[N]
  */
-static int vmap_page_range(unsigned long addr, unsigned long end,
+static int vmap_page_range(unsigned long start, unsigned long end,
                                 pgprot_t prot, struct page **pages)
 {
         pgd_t *pgd;
         unsigned long next;
+        unsigned long addr = start;
         int err = 0;
         int nr = 0;
 
@@ -167,7 +168,7 @@ static int vmap_page_range(unsigned long addr, unsigned long end,
                 if (err)
                         break;
         } while (pgd++, addr = next, addr != end);
-        flush_cache_vmap(addr, end);
+        flush_cache_vmap(start, end);
 
         if (unlikely(err))
                 return err;