[gentoo-commits] linux-patches r2035 - genpatches-2.6/trunk/3.0

[Stratos Psomadakis (psomas)]

Author: psomas
Date: 2011-12-22 12:04:04 +0000 (Thu, 22 Dec 2011)
New Revision: 2035

Added:
   genpatches-2.6/trunk/3.0/1013_linux-3.0.14.patch
Modified:
   genpatches-2.6/trunk/3.0/0000_README
Log:
Linux patch 3.0.14

Modified: genpatches-2.6/trunk/3.0/0000_README
===================================================================
--- genpatches-2.6/trunk/3.0/0000_README	2011-12-22 12:03:42 UTC (rev 2034)
+++ genpatches-2.6/trunk/3.0/0000_README	2011-12-22 12:04:04 UTC (rev 2035)
@@ -91,6 +91,10 @@
 From:   http://www.kernel.org
 Desc:   Linux 3.0.13
 
+Patch:  1013_linux-3.0.14.patch
+From:   http://www.kernel.org
+Desc:   Linux 3.0.14
+
 Patch:  1800_fix-zcache-build.patch
 From:   http://bugs.gentoo.org/show_bug.cgi?id=376325
 Desc:   Fix zcache build error

Added: genpatches-2.6/trunk/3.0/1013_linux-3.0.14.patch
===================================================================
--- genpatches-2.6/trunk/3.0/1013_linux-3.0.14.patch	                        (rev 0)
+++ genpatches-2.6/trunk/3.0/1013_linux-3.0.14.patch	2011-12-22 12:04:04 UTC (rev 2035)
@@ -0,0 +1,1891 @@
+diff --git a/Makefile b/Makefile
+index 5ccc962..f4f577b 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,6 +1,6 @@
+ VERSION = 3
+ PATCHLEVEL = 0
+-SUBLEVEL = 13
++SUBLEVEL = 14
+ EXTRAVERSION =
+ NAME = Sneaky Weasel
+ 
+diff --git a/arch/arm/mach-at91/at91sam9260.c b/arch/arm/mach-at91/at91sam9260.c
+index 7d606b0..eeb9478 100644
+--- a/arch/arm/mach-at91/at91sam9260.c
++++ b/arch/arm/mach-at91/at91sam9260.c
+@@ -237,9 +237,9 @@ static struct clk_lookup periph_clocks_lookups[] = {
+ 	CLKDEV_CON_DEV_ID("t0_clk", "atmel_tcb.0", &tc0_clk),
+ 	CLKDEV_CON_DEV_ID("t1_clk", "atmel_tcb.0", &tc1_clk),
+ 	CLKDEV_CON_DEV_ID("t2_clk", "atmel_tcb.0", &tc2_clk),
+-	CLKDEV_CON_DEV_ID("t3_clk", "atmel_tcb.1", &tc3_clk),
+-	CLKDEV_CON_DEV_ID("t4_clk", "atmel_tcb.1", &tc4_clk),
+-	CLKDEV_CON_DEV_ID("t5_clk", "atmel_tcb.1", &tc5_clk),
++	CLKDEV_CON_DEV_ID("t0_clk", "atmel_tcb.1", &tc3_clk),
++	CLKDEV_CON_DEV_ID("t1_clk", "atmel_tcb.1", &tc4_clk),
++	CLKDEV_CON_DEV_ID("t2_clk", "atmel_tcb.1", &tc5_clk),
+ 	CLKDEV_CON_DEV_ID("pclk", "ssc.0", &ssc_clk),
+ };
+ 
+diff --git a/arch/arm/mach-davinci/board-da850-evm.c b/arch/arm/mach-davinci/board-da850-evm.c
+index e83cc86..f893617 100644
+--- a/arch/arm/mach-davinci/board-da850-evm.c
++++ b/arch/arm/mach-davinci/board-da850-evm.c
+@@ -748,7 +748,7 @@ static struct snd_platform_data da850_evm_snd_data = {
+ 	.num_serializer	= ARRAY_SIZE(da850_iis_serializer_direction),
+ 	.tdm_slots	= 2,
+ 	.serial_dir	= da850_iis_serializer_direction,
+-	.asp_chan_q	= EVENTQ_1,
++	.asp_chan_q	= EVENTQ_0,
+ 	.version	= MCASP_VERSION_2,
+ 	.txnumevt	= 1,
+ 	.rxnumevt	= 1,
+diff --git a/arch/arm/mach-davinci/board-dm646x-evm.c b/arch/arm/mach-davinci/board-dm646x-evm.c
+index f6ac9ba..3cdd237 100644
+--- a/arch/arm/mach-davinci/board-dm646x-evm.c
++++ b/arch/arm/mach-davinci/board-dm646x-evm.c
+@@ -563,7 +563,7 @@ static int setup_vpif_input_channel_mode(int mux_mode)
+ 	int val;
+ 	u32 value;
+ 
+-	if (!vpif_vsclkdis_reg || !cpld_client)
++	if (!vpif_vidclkctl_reg || !cpld_client)
+ 		return -ENXIO;
+ 
+ 	val = i2c_smbus_read_byte(cpld_client);
+@@ -571,7 +571,7 @@ static int setup_vpif_input_channel_mode(int mux_mode)
+ 		return val;
+ 
+ 	spin_lock_irqsave(&vpif_reg_lock, flags);
+-	value = __raw_readl(vpif_vsclkdis_reg);
++	value = __raw_readl(vpif_vidclkctl_reg);
+ 	if (mux_mode) {
+ 		val &= VPIF_INPUT_TWO_CHANNEL;
+ 		value |= VIDCH1CLK;
+@@ -579,7 +579,7 @@ static int setup_vpif_input_channel_mode(int mux_mode)
+ 		val |= VPIF_INPUT_ONE_CHANNEL;
+ 		value &= ~VIDCH1CLK;
+ 	}
+-	__raw_writel(value, vpif_vsclkdis_reg);
++	__raw_writel(value, vpif_vidclkctl_reg);
+ 	spin_unlock_irqrestore(&vpif_reg_lock, flags);
+ 
+ 	err = i2c_smbus_write_byte(cpld_client, val);
+diff --git a/arch/arm/mach-mxs/include/mach/mxs.h b/arch/arm/mach-mxs/include/mach/mxs.h
+index 35a89dd..1332f73 100644
+--- a/arch/arm/mach-mxs/include/mach/mxs.h
++++ b/arch/arm/mach-mxs/include/mach/mxs.h
+@@ -30,6 +30,7 @@
+  */
+ #define cpu_is_mx23()		(					\
+ 		machine_is_mx23evk() ||					\
++		machine_is_stmp378x() ||				\
+ 		0)
+ #define cpu_is_mx28()		(					\
+ 		machine_is_mx28evk() ||					\
+diff --git a/arch/x86/kernel/hpet.c b/arch/x86/kernel/hpet.c
+index 6781765..aa083d3 100644
+--- a/arch/x86/kernel/hpet.c
++++ b/arch/x86/kernel/hpet.c
+@@ -1054,6 +1054,14 @@ int hpet_rtc_timer_init(void)
+ }
+ EXPORT_SYMBOL_GPL(hpet_rtc_timer_init);
+ 
++static void hpet_disable_rtc_channel(void)
++{
++	unsigned long cfg;
++	cfg = hpet_readl(HPET_T1_CFG);
++	cfg &= ~HPET_TN_ENABLE;
++	hpet_writel(cfg, HPET_T1_CFG);
++}
++
+ /*
+  * The functions below are called from rtc driver.
+  * Return 0 if HPET is not being used.
+@@ -1065,6 +1073,9 @@ int hpet_mask_rtc_irq_bit(unsigned long bit_mask)
+ 		return 0;
+ 
+ 	hpet_rtc_flags &= ~bit_mask;
++	if (unlikely(!hpet_rtc_flags))
++		hpet_disable_rtc_channel();
++
+ 	return 1;
+ }
+ EXPORT_SYMBOL_GPL(hpet_mask_rtc_irq_bit);
+@@ -1130,15 +1141,11 @@ EXPORT_SYMBOL_GPL(hpet_rtc_dropped_irq);
+ 
+ static void hpet_rtc_timer_reinit(void)
+ {
+-	unsigned int cfg, delta;
++	unsigned int delta;
+ 	int lost_ints = -1;
+ 
+-	if (unlikely(!hpet_rtc_flags)) {
+-		cfg = hpet_readl(HPET_T1_CFG);
+-		cfg &= ~HPET_TN_ENABLE;
+-		hpet_writel(cfg, HPET_T1_CFG);
+-		return;
+-	}
++	if (unlikely(!hpet_rtc_flags))
++		hpet_disable_rtc_channel();
+ 
+ 	if (!(hpet_rtc_flags & RTC_PIE) || hpet_pie_limit)
+ 		delta = hpet_default_delta;
+diff --git a/arch/x86/mm/gup.c b/arch/x86/mm/gup.c
+index ea30585..dd74e46 100644
+--- a/arch/x86/mm/gup.c
++++ b/arch/x86/mm/gup.c
+@@ -201,6 +201,8 @@ static noinline int gup_huge_pud(pud_t pud, unsigned long addr,
+ 	do {
+ 		VM_BUG_ON(compound_head(page) != head);
+ 		pages[*nr] = page;
++		if (PageTail(page))
++			get_huge_page_tail(page);
+ 		(*nr)++;
+ 		page++;
+ 		refs++;
+diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c
+index acea42e..f8dcda4 100644
+--- a/arch/x86/xen/setup.c
++++ b/arch/x86/xen/setup.c
+@@ -192,9 +192,21 @@ static unsigned long __init xen_get_max_pages(void)
+ 	domid_t domid = DOMID_SELF;
+ 	int ret;
+ 
+-	ret = HYPERVISOR_memory_op(XENMEM_maximum_reservation, &domid);
+-	if (ret > 0)
+-		max_pages = ret;
++	/*
++	 * For the initial domain we use the maximum reservation as
++	 * the maximum page.
++	 *
++	 * For guest domains the current maximum reservation reflects
++	 * the current maximum rather than the static maximum. In this
++	 * case the e820 map provided to us will cover the static
++	 * maximum region.
++	 */
++	if (xen_initial_domain()) {
++		ret = HYPERVISOR_memory_op(XENMEM_maximum_reservation, &domid);
++		if (ret > 0)
++			max_pages = ret;
++	}
++
+ 	return min(max_pages, MAX_DOMAIN_PAGES);
+ }
+ 
+diff --git a/drivers/firmware/iscsi_ibft.c b/drivers/firmware/iscsi_ibft.c
+index ce33f46..2763643 100644
+--- a/drivers/firmware/iscsi_ibft.c
++++ b/drivers/firmware/iscsi_ibft.c
+@@ -738,6 +738,37 @@ static void __exit ibft_exit(void)
+ 	ibft_cleanup();
+ }
+ 
++#ifdef CONFIG_ACPI
++static const struct {
++	char *sign;
++} ibft_signs[] = {
++	/*
++	 * One spec says "IBFT", the other says "iBFT". We have to check
++	 * for both.
++	 */
++	{ ACPI_SIG_IBFT },
++	{ "iBFT" },
++};
++
++static void __init acpi_find_ibft_region(void)
++{
++	int i;
++	struct acpi_table_header *table = NULL;
++
++	if (acpi_disabled)
++		return;
++
++	for (i = 0; i < ARRAY_SIZE(ibft_signs) && !ibft_addr; i++) {
++		acpi_get_table(ibft_signs[i].sign, 0, &table);
++		ibft_addr = (struct acpi_table_ibft *)table;
++	}
++}
++#else
++static void __init acpi_find_ibft_region(void)
++{
++}
++#endif
++
+ /*
+  * ibft_init() - creates sysfs tree entries for the iBFT data.
+  */
+@@ -745,9 +776,16 @@ static int __init ibft_init(void)
+ {
+ 	int rc = 0;
+ 
++	/*
++	   As on UEFI systems the setup_arch()/find_ibft_region()
++	   is called before ACPI tables are parsed and it only does
++	   legacy finding.
++	*/
++	if (!ibft_addr)
++		acpi_find_ibft_region();
++
+ 	if (ibft_addr) {
+-		printk(KERN_INFO "iBFT detected at 0x%llx.\n",
+-		       (u64)isa_virt_to_bus(ibft_addr));
++		pr_info("iBFT detected.\n");
+ 
+ 		rc = ibft_check_device();
+ 		if (rc)
+diff --git a/drivers/firmware/iscsi_ibft_find.c b/drivers/firmware/iscsi_ibft_find.c
+index bfe7232..4da4eb9 100644
+--- a/drivers/firmware/iscsi_ibft_find.c
++++ b/drivers/firmware/iscsi_ibft_find.c
+@@ -45,13 +45,6 @@ EXPORT_SYMBOL_GPL(ibft_addr);
+ static const struct {
+ 	char *sign;
+ } ibft_signs[] = {
+-#ifdef CONFIG_ACPI
+-	/*
+-	 * One spec says "IBFT", the other says "iBFT". We have to check
+-	 * for both.
+-	 */
+-	{ ACPI_SIG_IBFT },
+-#endif
+ 	{ "iBFT" },
+ 	{ "BIFT" },	/* Broadcom iSCSI Offload */
+ };
+@@ -62,14 +55,6 @@ static const struct {
+ #define VGA_MEM 0xA0000 /* VGA buffer */
+ #define VGA_SIZE 0x20000 /* 128kB */
+ 
+-#ifdef CONFIG_ACPI
+-static int __init acpi_find_ibft(struct acpi_table_header *header)
+-{
+-	ibft_addr = (struct acpi_table_ibft *)header;
+-	return 0;
+-}
+-#endif /* CONFIG_ACPI */
+-
+ static int __init find_ibft_in_mem(void)
+ {
+ 	unsigned long pos;
+@@ -94,6 +79,7 @@ static int __init find_ibft_in_mem(void)
+ 				 * the table cannot be valid. */
+ 				if (pos + len <= (IBFT_END-1)) {
+ 					ibft_addr = (struct acpi_table_ibft *)virt;
++					pr_info("iBFT found at 0x%lx.\n", pos);
+ 					goto done;
+ 				}
+ 			}
+@@ -108,20 +94,12 @@ done:
+  */
+ unsigned long __init find_ibft_region(unsigned long *sizep)
+ {
+-#ifdef CONFIG_ACPI
+-	int i;
+-#endif
+ 	ibft_addr = NULL;
+ 
+-#ifdef CONFIG_ACPI
+-	for (i = 0; i < ARRAY_SIZE(ibft_signs) && !ibft_addr; i++)
+-		acpi_table_parse(ibft_signs[i].sign, acpi_find_ibft);
+-#endif /* CONFIG_ACPI */
+-
+ 	/* iBFT 1.03 section 1.4.3.1 mandates that UEFI machines will
+ 	 * only use ACPI for this */
+ 
+-	if (!ibft_addr && !efi_enabled)
++	if (!efi_enabled)
+ 		find_ibft_in_mem();
+ 
+ 	if (ibft_addr) {
+diff --git a/drivers/hwmon/coretemp.c b/drivers/hwmon/coretemp.c
+index 835ae42..6163cfa 100644
+--- a/drivers/hwmon/coretemp.c
++++ b/drivers/hwmon/coretemp.c
+@@ -747,6 +747,8 @@ static void __cpuinit put_core_offline(unsigned int cpu)
+ 		return;
+ 
+ 	pdata = platform_get_drvdata(pdev);
++	if (!pdata)
++		return;
+ 
+ 	indx = TO_ATTR_NO(cpu);
+ 
+diff --git a/drivers/hwmon/jz4740-hwmon.c b/drivers/hwmon/jz4740-hwmon.c
+index fea292d..b65a4da 100644
+--- a/drivers/hwmon/jz4740-hwmon.c
++++ b/drivers/hwmon/jz4740-hwmon.c
+@@ -59,7 +59,7 @@ static ssize_t jz4740_hwmon_read_adcin(struct device *dev,
+ {
+ 	struct jz4740_hwmon *hwmon = dev_get_drvdata(dev);
+ 	struct completion *completion = &hwmon->read_completion;
+-	unsigned long t;
++	long t;
+ 	unsigned long val;
+ 	int ret;
+ 
+diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
+index cbb50d3..1f6c68d 100644
+--- a/drivers/md/raid5.c
++++ b/drivers/md/raid5.c
+@@ -3078,7 +3078,7 @@ static void handle_stripe5(struct stripe_head *sh)
+ 			/* Not in-sync */;
+ 		else if (test_bit(In_sync, &rdev->flags))
+ 			set_bit(R5_Insync, &dev->flags);
+-		else {
++		else if (!test_bit(Faulty, &rdev->flags)) {
+ 			/* could be in-sync depending on recovery/reshape status */
+ 			if (sh->sector + STRIPE_SECTORS <= rdev->recovery_offset)
+ 				set_bit(R5_Insync, &dev->flags);
+diff --git a/drivers/mmc/host/mxcmmc.c b/drivers/mmc/host/mxcmmc.c
+index cc20e02..e12fbc5 100644
+--- a/drivers/mmc/host/mxcmmc.c
++++ b/drivers/mmc/host/mxcmmc.c
+@@ -731,6 +731,7 @@ static void mxcmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+ 				"failed to config DMA channel. Falling back to PIO\n");
+ 			dma_release_channel(host->dma);
+ 			host->do_dma = 0;
++			host->dma = NULL;
+ 		}
+ 	}
+ 
+diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-rxon.c b/drivers/net/wireless/iwlwifi/iwl-agn-rxon.c
+index 09f679d..b849ad7 100644
+--- a/drivers/net/wireless/iwlwifi/iwl-agn-rxon.c
++++ b/drivers/net/wireless/iwlwifi/iwl-agn-rxon.c
+@@ -411,6 +411,24 @@ int iwlagn_commit_rxon(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
+ 	return 0;
+ }
+ 
++void iwlagn_config_ht40(struct ieee80211_conf *conf,
++	struct iwl_rxon_context *ctx)
++{
++	if (conf_is_ht40_minus(conf)) {
++		ctx->ht.extension_chan_offset =
++			IEEE80211_HT_PARAM_CHA_SEC_BELOW;
++		ctx->ht.is_40mhz = true;
++	} else if (conf_is_ht40_plus(conf)) {
++		ctx->ht.extension_chan_offset =
++			IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
++		ctx->ht.is_40mhz = true;
++	} else {
++		ctx->ht.extension_chan_offset =
++			IEEE80211_HT_PARAM_CHA_SEC_NONE;
++		ctx->ht.is_40mhz = false;
++	}
++}
++
+ int iwlagn_mac_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	struct iwl_priv *priv = hw->priv;
+@@ -470,19 +488,11 @@ int iwlagn_mac_config(struct ieee80211_hw *hw, u32 changed)
+ 				ctx->ht.enabled = conf_is_ht(conf);
+ 
+ 			if (ctx->ht.enabled) {
+-				if (conf_is_ht40_minus(conf)) {
+-					ctx->ht.extension_chan_offset =
+-						IEEE80211_HT_PARAM_CHA_SEC_BELOW;
+-					ctx->ht.is_40mhz = true;
+-				} else if (conf_is_ht40_plus(conf)) {
+-					ctx->ht.extension_chan_offset =
+-						IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
+-					ctx->ht.is_40mhz = true;
+-				} else {
+-					ctx->ht.extension_chan_offset =
+-						IEEE80211_HT_PARAM_CHA_SEC_NONE;
+-					ctx->ht.is_40mhz = false;
+-				}
++				/* if HT40 is used, it should not change
++				 * after associated except channel switch */
++				if (iwl_is_associated_ctx(ctx) &&
++				     !ctx->ht.is_40mhz)
++					iwlagn_config_ht40(conf, ctx);
+ 			} else
+ 				ctx->ht.is_40mhz = false;
+ 
+diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
+index baec52d..67d4c2d 100644
+--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
++++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
+@@ -2872,21 +2872,9 @@ static void iwlagn_mac_channel_switch(struct ieee80211_hw *hw,
+ 
+ 			/* Configure HT40 channels */
+ 			ctx->ht.enabled = conf_is_ht(conf);
+-			if (ctx->ht.enabled) {
+-				if (conf_is_ht40_minus(conf)) {
+-					ctx->ht.extension_chan_offset =
+-						IEEE80211_HT_PARAM_CHA_SEC_BELOW;
+-					ctx->ht.is_40mhz = true;
+-				} else if (conf_is_ht40_plus(conf)) {
+-					ctx->ht.extension_chan_offset =
+-						IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
+-					ctx->ht.is_40mhz = true;
+-				} else {
+-					ctx->ht.extension_chan_offset =
+-						IEEE80211_HT_PARAM_CHA_SEC_NONE;
+-					ctx->ht.is_40mhz = false;
+-				}
+-			} else
++			if (ctx->ht.enabled)
++				iwlagn_config_ht40(conf, ctx);
++			else
+ 				ctx->ht.is_40mhz = false;
+ 
+ 			if ((le16_to_cpu(ctx->staging.channel) != ch))
+diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.h b/drivers/net/wireless/iwlwifi/iwl-agn.h
+index d171684..5a0acab 100644
+--- a/drivers/net/wireless/iwlwifi/iwl-agn.h
++++ b/drivers/net/wireless/iwlwifi/iwl-agn.h
+@@ -152,6 +152,8 @@ void iwlagn_bss_info_changed(struct ieee80211_hw *hw,
+ 			     struct ieee80211_vif *vif,
+ 			     struct ieee80211_bss_conf *bss_conf,
+ 			     u32 changes);
++void iwlagn_config_ht40(struct ieee80211_conf *conf,
++			struct iwl_rxon_context *ctx);
+ 
+ /* uCode */
+ void iwlagn_rx_calib_result(struct iwl_priv *priv,
+diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
+index f02c34d..0ec8930 100644
+--- a/drivers/pci/intel-iommu.c
++++ b/drivers/pci/intel-iommu.c
+@@ -307,6 +307,11 @@ static inline bool dma_pte_present(struct dma_pte *pte)
+ 	return (pte->val & 3) != 0;
+ }
+ 
++static inline bool dma_pte_superpage(struct dma_pte *pte)
++{
++	return (pte->val & (1 << 7));
++}
++
+ static inline int first_pte_in_page(struct dma_pte *pte)
+ {
+ 	return !((unsigned long)pte & ~VTD_PAGE_MASK);
+@@ -578,17 +583,18 @@ static void domain_update_iommu_snooping(struct dmar_domain *domain)
+ 
+ static void domain_update_iommu_superpage(struct dmar_domain *domain)
+ {
+-	int i, mask = 0xf;
++	struct dmar_drhd_unit *drhd;
++	struct intel_iommu *iommu = NULL;
++	int mask = 0xf;
+ 
+ 	if (!intel_iommu_superpage) {
+ 		domain->iommu_superpage = 0;
+ 		return;
+ 	}
+ 
+-	domain->iommu_superpage = 4; /* 1TiB */
+-
+-	for_each_set_bit(i, &domain->iommu_bmp, g_num_of_iommus) {
+-		mask |= cap_super_page_val(g_iommus[i]->cap);
++	/* set iommu_superpage to the smallest common denominator */
++	for_each_active_iommu(iommu, drhd) {
++		mask &= cap_super_page_val(iommu->cap);
+ 		if (!mask) {
+ 			break;
+ 		}
+@@ -731,29 +737,23 @@ out:
+ }
+ 
+ static struct dma_pte *pfn_to_dma_pte(struct dmar_domain *domain,
+-				      unsigned long pfn, int large_level)
++				      unsigned long pfn, int target_level)
+ {
+ 	int addr_width = agaw_to_width(domain->agaw) - VTD_PAGE_SHIFT;
+ 	struct dma_pte *parent, *pte = NULL;
+ 	int level = agaw_to_level(domain->agaw);
+-	int offset, target_level;
++	int offset;
+ 
+ 	BUG_ON(!domain->pgd);
+ 	BUG_ON(addr_width < BITS_PER_LONG && pfn >> addr_width);
+ 	parent = domain->pgd;
+ 
+-	/* Search pte */
+-	if (!large_level)
+-		target_level = 1;
+-	else
+-		target_level = large_level;
+-
+ 	while (level > 0) {
+ 		void *tmp_page;
+ 
+ 		offset = pfn_level_offset(pfn, level);
+ 		pte = &parent[offset];
+-		if (!large_level && (pte->val & DMA_PTE_LARGE_PAGE))
++		if (!target_level && (dma_pte_superpage(pte) || !dma_pte_present(pte)))
+ 			break;
+ 		if (level == target_level)
+ 			break;
+@@ -817,13 +817,14 @@ static struct dma_pte *dma_pfn_level_pte(struct dmar_domain *domain,
+ }
+ 
+ /* clear last level pte, a tlb flush should be followed */
+-static void dma_pte_clear_range(struct dmar_domain *domain,
++static int dma_pte_clear_range(struct dmar_domain *domain,
+ 				unsigned long start_pfn,
+ 				unsigned long last_pfn)
+ {
+ 	int addr_width = agaw_to_width(domain->agaw) - VTD_PAGE_SHIFT;
+ 	unsigned int large_page = 1;
+ 	struct dma_pte *first_pte, *pte;
++	int order;
+ 
+ 	BUG_ON(addr_width < BITS_PER_LONG && start_pfn >> addr_width);
+ 	BUG_ON(addr_width < BITS_PER_LONG && last_pfn >> addr_width);
+@@ -847,6 +848,9 @@ static void dma_pte_clear_range(struct dmar_domain *domain,
+ 				   (void *)pte - (void *)first_pte);
+ 
+ 	} while (start_pfn && start_pfn <= last_pfn);
++
++	order = (large_page - 1) * 9;
++	return order;
+ }
+ 
+ /* free page table pages. last level pte should already be cleared */
+@@ -3740,6 +3744,7 @@ static int intel_iommu_domain_init(struct iommu_domain *domain)
+ 		vm_domain_exit(dmar_domain);
+ 		return -ENOMEM;
+ 	}
++	domain_update_iommu_cap(dmar_domain);
+ 	domain->priv = dmar_domain;
+ 
+ 	return 0;
+@@ -3865,14 +3870,15 @@ static int intel_iommu_unmap(struct iommu_domain *domain,
+ {
+ 	struct dmar_domain *dmar_domain = domain->priv;
+ 	size_t size = PAGE_SIZE << gfp_order;
++	int order;
+ 
+-	dma_pte_clear_range(dmar_domain, iova >> VTD_PAGE_SHIFT,
++	order = dma_pte_clear_range(dmar_domain, iova >> VTD_PAGE_SHIFT,
+ 			    (iova + size - 1) >> VTD_PAGE_SHIFT);
+ 
+ 	if (dmar_domain->max_addr == iova + size)
+ 		dmar_domain->max_addr = iova;
+ 
+-	return gfp_order;
++	return order;
+ }
+ 
+ static phys_addr_t intel_iommu_iova_to_phys(struct iommu_domain *domain,
+diff --git a/drivers/ptp/ptp_clock.c b/drivers/ptp/ptp_clock.c
+index cf3f999..10451a1 100644
+--- a/drivers/ptp/ptp_clock.c
++++ b/drivers/ptp/ptp_clock.c
+@@ -101,7 +101,9 @@ static s32 scaled_ppm_to_ppb(long ppm)
+ 
+ static int ptp_clock_getres(struct posix_clock *pc, struct timespec *tp)
+ {
+-	return 1; /* always round timer functions to one nanosecond */
++	tp->tv_sec = 0;
++	tp->tv_nsec = 1;
++	return 0;
+ }
+ 
+ static int ptp_clock_settime(struct posix_clock *pc, const struct timespec *tp)
+diff --git a/drivers/staging/rtl8712/usb_intf.c b/drivers/staging/rtl8712/usb_intf.c
+index 21ce2af..6cb7e28 100644
+--- a/drivers/staging/rtl8712/usb_intf.c
++++ b/drivers/staging/rtl8712/usb_intf.c
+@@ -86,6 +86,7 @@ static struct usb_device_id rtl871x_usb_id_tbl[] = {
+ 	{USB_DEVICE(0x0DF6, 0x0045)},
+ 	{USB_DEVICE(0x0DF6, 0x0059)}, /* 11n mode disable */
+ 	{USB_DEVICE(0x0DF6, 0x004B)},
++	{USB_DEVICE(0x0DF6, 0x005D)},
+ 	{USB_DEVICE(0x0DF6, 0x0063)},
+ 	/* Sweex */
+ 	{USB_DEVICE(0x177F, 0x0154)},
+diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
+index 4b9b716..1340ffd 100644
+--- a/drivers/target/target_core_transport.c
++++ b/drivers/target/target_core_transport.c
+@@ -2777,10 +2777,15 @@ static inline u32 transport_get_sectors_6(
+ 
+ 	/*
+ 	 * Everything else assume TYPE_DISK Sector CDB location.
+-	 * Use 8-bit sector value.
++	 * Use 8-bit sector value.  SBC-3 says:
++	 *
++	 *   A TRANSFER LENGTH field set to zero specifies that 256
++	 *   logical blocks shall be written.  Any other value
++	 *   specifies the number of logical blocks that shall be
++	 *   written.
+ 	 */
+ type_disk:
+-	return (u32)cdb[4];
++	return cdb[4] ? : 256;
+ }
+ 
+ static inline u32 transport_get_sectors_10(
+diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
+index 2ffcaa0..8faa23c 100644
+--- a/drivers/usb/class/cdc-acm.c
++++ b/drivers/usb/class/cdc-acm.c
+@@ -1458,6 +1458,16 @@ static const struct usb_device_id acm_ids[] = {
+ 	},
+ 	{ USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
+ 	},
++	/* Motorola H24 HSPA module: */
++	{ USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
++	{ USB_DEVICE(0x22b8, 0x2d92) }, /* modem           + diagnostics        */
++	{ USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port                      */
++	{ USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics        */
++	{ USB_DEVICE(0x22b8, 0x2d96) }, /* modem                         + NMEA */
++	{ USB_DEVICE(0x22b8, 0x2d97) }, /* modem           + diagnostics + NMEA */
++	{ USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port               + NMEA */
++	{ USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
++
+ 	{ USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
+ 	.driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
+ 					   data interface instead of
+diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
+index e98a1e1..d2becb9 100644
+--- a/drivers/usb/serial/option.c
++++ b/drivers/usb/serial/option.c
+@@ -659,7 +659,12 @@ static const struct usb_device_id option_ids[] = {
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x01, 0x01) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x01, 0x02) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x01, 0x03) },
+-	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x01, 0x08) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x01, 0x10) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x01, 0x12) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x01, 0x13) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x02, 0x01) },  /* E398 3G Modem */
++	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x02, 0x02) },  /* E398 3G PC UI Interface */
++	{ USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E353, 0xff, 0x02, 0x03) },  /* E398 3G Application Interface */
+ 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V640) },
+ 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V620) },
+ 	{ USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V740) },
+diff --git a/fs/dcache.c b/fs/dcache.c
+index fbdcbca..d2f8feb 100644
+--- a/fs/dcache.c
++++ b/fs/dcache.c
+@@ -2487,16 +2487,14 @@ static int prepend_name(char **buffer, int *buflen, struct qstr *name)
+ /**
+  * prepend_path - Prepend path string to a buffer
+  * @path: the dentry/vfsmount to report
+- * @root: root vfsmnt/dentry (may be modified by this function)
++ * @root: root vfsmnt/dentry
+  * @buffer: pointer to the end of the buffer
+  * @buflen: pointer to buffer length
+  *
+  * Caller holds the rename_lock.
+- *
+- * If path is not reachable from the supplied root, then the value of
+- * root is changed (without modifying refcounts).
+  */
+-static int prepend_path(const struct path *path, struct path *root,
++static int prepend_path(const struct path *path,
++			const struct path *root,
+ 			char **buffer, int *buflen)
+ {
+ 	struct dentry *dentry = path->dentry;
+@@ -2531,10 +2529,10 @@ static int prepend_path(const struct path *path, struct path *root,
+ 		dentry = parent;
+ 	}
+ 
+-out:
+ 	if (!error && !slash)
+ 		error = prepend(buffer, buflen, "/", 1);
+ 
++out:
+ 	br_read_unlock(vfsmount_lock);
+ 	return error;
+ 
+@@ -2548,15 +2546,17 @@ global_root:
+ 		WARN(1, "Root dentry has weird name <%.*s>\n",
+ 		     (int) dentry->d_name.len, dentry->d_name.name);
+ 	}
+-	root->mnt = vfsmnt;
+-	root->dentry = dentry;
++	if (!slash)
++		error = prepend(buffer, buflen, "/", 1);
++	if (!error)
++		error = vfsmnt->mnt_ns ? 1 : 2;
+ 	goto out;
+ }
+ 
+ /**
+  * __d_path - return the path of a dentry
+  * @path: the dentry/vfsmount to report
+- * @root: root vfsmnt/dentry (may be modified by this function)
++ * @root: root vfsmnt/dentry
+  * @buf: buffer to return value in
+  * @buflen: buffer length
+  *
+@@ -2567,10 +2567,10 @@ global_root:
+  *
+  * "buflen" should be positive.
+  *
+- * If path is not reachable from the supplied root, then the value of
+- * root is changed (without modifying refcounts).
++ * If the path is not reachable from the supplied root, return %NULL.
+  */
+-char *__d_path(const struct path *path, struct path *root,
++char *__d_path(const struct path *path,
++	       const struct path *root,
+ 	       char *buf, int buflen)
+ {
+ 	char *res = buf + buflen;
+@@ -2581,7 +2581,28 @@ char *__d_path(const struct path *path, struct path *root,
+ 	error = prepend_path(path, root, &res, &buflen);
+ 	write_sequnlock(&rename_lock);
+ 
+-	if (error)
++	if (error < 0)
++		return ERR_PTR(error);
++	if (error > 0)
++		return NULL;
++	return res;
++}
++
++char *d_absolute_path(const struct path *path,
++	       char *buf, int buflen)
++{
++	struct path root = {};
++	char *res = buf + buflen;
++	int error;
++
++	prepend(&res, &buflen, "\0", 1);
++	write_seqlock(&rename_lock);
++	error = prepend_path(path, &root, &res, &buflen);
++	write_sequnlock(&rename_lock);
++
++	if (error > 1)
++		error = -EINVAL;
++	if (error < 0)
+ 		return ERR_PTR(error);
+ 	return res;
+ }
+@@ -2589,8 +2610,9 @@ char *__d_path(const struct path *path, struct path *root,
+ /*
+  * same as __d_path but appends "(deleted)" for unlinked files.
+  */
+-static int path_with_deleted(const struct path *path, struct path *root,
+-				 char **buf, int *buflen)
++static int path_with_deleted(const struct path *path,
++			     const struct path *root,
++			     char **buf, int *buflen)
+ {
+ 	prepend(buf, buflen, "\0", 1);
+ 	if (d_unlinked(path->dentry)) {
+@@ -2627,7 +2649,6 @@ char *d_path(const struct path *path, char *buf, int buflen)
+ {
+ 	char *res = buf + buflen;
+ 	struct path root;
+-	struct path tmp;
+ 	int error;
+ 
+ 	/*
+@@ -2642,9 +2663,8 @@ char *d_path(const struct path *path, char *buf, int buflen)
+ 
+ 	get_fs_root(current->fs, &root);
+ 	write_seqlock(&rename_lock);
+-	tmp = root;
+-	error = path_with_deleted(path, &tmp, &res, &buflen);
+-	if (error)
++	error = path_with_deleted(path, &root, &res, &buflen);
++	if (error < 0)
+ 		res = ERR_PTR(error);
+ 	write_sequnlock(&rename_lock);
+ 	path_put(&root);
+@@ -2665,7 +2685,6 @@ char *d_path_with_unreachable(const struct path *path, char *buf, int buflen)
+ {
+ 	char *res = buf + buflen;
+ 	struct path root;
+-	struct path tmp;
+ 	int error;
+ 
+ 	if (path->dentry->d_op && path->dentry->d_op->d_dname)
+@@ -2673,9 +2692,8 @@ char *d_path_with_unreachable(const struct path *path, char *buf, int buflen)
+ 
+ 	get_fs_root(current->fs, &root);
+ 	write_seqlock(&rename_lock);
+-	tmp = root;
+-	error = path_with_deleted(path, &tmp, &res, &buflen);
+-	if (!error && !path_equal(&tmp, &root))
++	error = path_with_deleted(path, &root, &res, &buflen);
++	if (error > 0)
+ 		error = prepend_unreachable(&res, &buflen);
+ 	write_sequnlock(&rename_lock);
+ 	path_put(&root);
+@@ -2806,19 +2824,18 @@ SYSCALL_DEFINE2(getcwd, char __user *, buf, unsigned long, size)
+ 	write_seqlock(&rename_lock);
+ 	if (!d_unlinked(pwd.dentry)) {
+ 		unsigned long len;
+-		struct path tmp = root;
+ 		char *cwd = page + PAGE_SIZE;
+ 		int buflen = PAGE_SIZE;
+ 
+ 		prepend(&cwd, &buflen, "\0", 1);
+-		error = prepend_path(&pwd, &tmp, &cwd, &buflen);
++		error = prepend_path(&pwd, &root, &cwd, &buflen);
+ 		write_sequnlock(&rename_lock);
+ 
+-		if (error)
++		if (error < 0)
+ 			goto out;
+ 
+ 		/* Unreachable from current root */
+-		if (!path_equal(&tmp, &root)) {
++		if (error > 0) {
+ 			error = prepend_unreachable(&cwd, &buflen);
+ 			if (error)
+ 				goto out;
+diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
+index 1265904..af09060 100644
+--- a/fs/ext4/inode.c
++++ b/fs/ext4/inode.c
+@@ -2126,8 +2126,11 @@ static int mpage_da_submit_io(struct mpage_da_data *mpd,
+ 					clear_buffer_unwritten(bh);
+ 				}
+ 
+-				/* skip page if block allocation undone */
+-				if (buffer_delay(bh) || buffer_unwritten(bh))
++				/*
++				 * skip page if block allocation undone and
++				 * block is dirty
++				 */
++				if (ext4_bh_delay_or_unwritten(NULL, bh))
+ 					skip_page = 1;
+ 				bh = bh->b_this_page;
+ 				block_start += bh->b_size;
+@@ -3231,7 +3234,7 @@ static int ext4_da_write_end(struct file *file,
+ 	 */
+ 
+ 	new_i_size = pos + copied;
+-	if (new_i_size > EXT4_I(inode)->i_disksize) {
++	if (copied && new_i_size > EXT4_I(inode)->i_disksize) {
+ 		if (ext4_da_should_update_i_disksize(page, end)) {
+ 			down_write(&EXT4_I(inode)->i_data_sem);
+ 			if (new_i_size > EXT4_I(inode)->i_disksize) {
+diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
+index bd6a85e..d99d74a 100644
+--- a/fs/ext4/page-io.c
++++ b/fs/ext4/page-io.c
+@@ -405,6 +405,18 @@ int ext4_bio_write_page(struct ext4_io_submit *io,
+ 
+ 		block_end = block_start + blocksize;
+ 		if (block_start >= len) {
++			/*
++			 * Comments copied from block_write_full_page_endio:
++			 *
++			 * The page straddles i_size.  It must be zeroed out on
++			 * each and every writepage invocation because it may
++			 * be mmapped.  "A file is mapped in multiples of the
++			 * page size.  For a file that is not a multiple of
++			 * the  page size, the remaining memory is zeroed when
++			 * mapped, and writes to that region are not written
++			 * out to the file."
++			 */
++			zero_user_segment(page, block_start, block_end);
+ 			clear_buffer_dirty(bh);
+ 			set_buffer_uptodate(bh);
+ 			continue;
+diff --git a/fs/ext4/super.c b/fs/ext4/super.c
+index 111ed9d..7aa77f0 100644
+--- a/fs/ext4/super.c
++++ b/fs/ext4/super.c
+@@ -1113,9 +1113,9 @@ static int ext4_show_options(struct seq_file *seq, struct vfsmount *vfs)
+ 		seq_puts(seq, ",block_validity");
+ 
+ 	if (!test_opt(sb, INIT_INODE_TABLE))
+-		seq_puts(seq, ",noinit_inode_table");
++		seq_puts(seq, ",noinit_itable");
+ 	else if (sbi->s_li_wait_mult != EXT4_DEF_LI_WAIT_MULT)
+-		seq_printf(seq, ",init_inode_table=%u",
++		seq_printf(seq, ",init_itable=%u",
+ 			   (unsigned) sbi->s_li_wait_mult);
+ 
+ 	ext4_show_quota_options(seq, sb);
+@@ -1291,8 +1291,7 @@ enum {
+ 	Opt_nomblk_io_submit, Opt_block_validity, Opt_noblock_validity,
+ 	Opt_inode_readahead_blks, Opt_journal_ioprio,
+ 	Opt_dioread_nolock, Opt_dioread_lock,
+-	Opt_discard, Opt_nodiscard,
+-	Opt_init_inode_table, Opt_noinit_inode_table,
++	Opt_discard, Opt_nodiscard, Opt_init_itable, Opt_noinit_itable,
+ };
+ 
+ static const match_table_t tokens = {
+@@ -1365,9 +1364,9 @@ static const match_table_t tokens = {
+ 	{Opt_dioread_lock, "dioread_lock"},
+ 	{Opt_discard, "discard"},
+ 	{Opt_nodiscard, "nodiscard"},
+-	{Opt_init_inode_table, "init_itable=%u"},
+-	{Opt_init_inode_table, "init_itable"},
+-	{Opt_noinit_inode_table, "noinit_itable"},
++	{Opt_init_itable, "init_itable=%u"},
++	{Opt_init_itable, "init_itable"},
++	{Opt_noinit_itable, "noinit_itable"},
+ 	{Opt_err, NULL},
+ };
+ 
+@@ -1844,7 +1843,7 @@ set_qf_format:
+ 		case Opt_dioread_lock:
+ 			clear_opt(sb, DIOREAD_NOLOCK);
+ 			break;
+-		case Opt_init_inode_table:
++		case Opt_init_itable:
+ 			set_opt(sb, INIT_INODE_TABLE);
+ 			if (args[0].from) {
+ 				if (match_int(&args[0], &option))
+@@ -1855,7 +1854,7 @@ set_qf_format:
+ 				return 0;
+ 			sbi->s_li_wait_mult = option;
+ 			break;
+-		case Opt_noinit_inode_table:
++		case Opt_noinit_itable:
+ 			clear_opt(sb, INIT_INODE_TABLE);
+ 			break;
+ 		default:
+diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
+index 5cb8614..2aaf3ea 100644
+--- a/fs/fuse/dev.c
++++ b/fs/fuse/dev.c
+@@ -1512,7 +1512,7 @@ static int fuse_retrieve(struct fuse_conn *fc, struct inode *inode,
+ 	else if (outarg->offset + num > file_size)
+ 		num = file_size - outarg->offset;
+ 
+-	while (num) {
++	while (num && req->num_pages < FUSE_MAX_PAGES_PER_REQ) {
+ 		struct page *page;
+ 		unsigned int this_num;
+ 
+@@ -1526,6 +1526,7 @@ static int fuse_retrieve(struct fuse_conn *fc, struct inode *inode,
+ 
+ 		num -= this_num;
+ 		total_len += this_num;
++		index++;
+ 	}
+ 	req->misc.retrieve_in.offset = outarg->offset;
+ 	req->misc.retrieve_in.size = total_len;
+diff --git a/fs/hfs/btree.c b/fs/hfs/btree.c
+index 3ebc437..1cbdeea 100644
+--- a/fs/hfs/btree.c
++++ b/fs/hfs/btree.c
+@@ -46,11 +46,26 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id, btree_keycmp ke
+ 	case HFS_EXT_CNID:
+ 		hfs_inode_read_fork(tree->inode, mdb->drXTExtRec, mdb->drXTFlSize,
+ 				    mdb->drXTFlSize, be32_to_cpu(mdb->drXTClpSiz));
++		if (HFS_I(tree->inode)->alloc_blocks >
++					HFS_I(tree->inode)->first_blocks) {
++			printk(KERN_ERR "hfs: invalid btree extent records\n");
++			unlock_new_inode(tree->inode);
++			goto free_inode;
++		}
++
+ 		tree->inode->i_mapping->a_ops = &hfs_btree_aops;
+ 		break;
+ 	case HFS_CAT_CNID:
+ 		hfs_inode_read_fork(tree->inode, mdb->drCTExtRec, mdb->drCTFlSize,
+ 				    mdb->drCTFlSize, be32_to_cpu(mdb->drCTClpSiz));
++
++		if (!HFS_I(tree->inode)->first_blocks) {
++			printk(KERN_ERR "hfs: invalid btree extent records "
++								"(0 size).\n");
++			unlock_new_inode(tree->inode);
++			goto free_inode;
++		}
++
+ 		tree->inode->i_mapping->a_ops = &hfs_btree_aops;
+ 		break;
+ 	default:
+@@ -59,11 +74,6 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id, btree_keycmp ke
+ 	}
+ 	unlock_new_inode(tree->inode);
+ 
+-	if (!HFS_I(tree->inode)->first_blocks) {
+-		printk(KERN_ERR "hfs: invalid btree extent records (0 size).\n");
+-		goto free_inode;
+-	}
+-
+ 	mapping = tree->inode->i_mapping;
+ 	page = read_mapping_page(mapping, 0, NULL);
+ 	if (IS_ERR(page))
+diff --git a/fs/jbd/journal.c b/fs/jbd/journal.c
+index e2d4285..9f36384 100644
+--- a/fs/jbd/journal.c
++++ b/fs/jbd/journal.c
+@@ -1131,6 +1131,14 @@ static int journal_get_superblock(journal_t *journal)
+ 		goto out;
+ 	}
+ 
++	if (be32_to_cpu(sb->s_first) == 0 ||
++	    be32_to_cpu(sb->s_first) >= journal->j_maxlen) {
++		printk(KERN_WARNING
++			"JBD: Invalid start block of journal: %u\n",
++			be32_to_cpu(sb->s_first));
++		goto out;
++	}
++
+ 	return 0;
+ 
+ out:
+diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
+index 0dfa5b5..40c5fb7 100644
+--- a/fs/jbd2/journal.c
++++ b/fs/jbd2/journal.c
+@@ -1251,6 +1251,14 @@ static int journal_get_superblock(journal_t *journal)
+ 		goto out;
+ 	}
+ 
++	if (be32_to_cpu(sb->s_first) == 0 ||
++	    be32_to_cpu(sb->s_first) >= journal->j_maxlen) {
++		printk(KERN_WARNING
++			"JBD2: Invalid start block of journal: %u\n",
++			be32_to_cpu(sb->s_first));
++		goto out;
++	}
++
+ 	return 0;
+ 
+ out:
+diff --git a/fs/namespace.c b/fs/namespace.c
+index 537dd96..edc1c4a 100644
+--- a/fs/namespace.c
++++ b/fs/namespace.c
+@@ -1048,15 +1048,12 @@ static int show_mountinfo(struct seq_file *m, void *v)
+ 	if (err)
+ 		goto out;
+ 	seq_putc(m, ' ');
+-	seq_path_root(m, &mnt_path, &root, " \t\n\\");
+-	if (root.mnt != p->root.mnt || root.dentry != p->root.dentry) {
+-		/*
+-		 * Mountpoint is outside root, discard that one.  Ugly,
+-		 * but less so than trying to do that in iterator in a
+-		 * race-free way (due to renames).
+-		 */
+-		return SEQ_SKIP;
+-	}
++
++	/* mountpoints outside of chroot jail will give SEQ_SKIP on this */
++	err = seq_path_root(m, &mnt_path, &root, " \t\n\\");
++	if (err)
++		goto out;
++
+ 	seq_puts(m, mnt->mnt_flags & MNT_READONLY ? " ro" : " rw");
+ 	show_mnt_opts(m, mnt);
+ 
+@@ -2725,3 +2722,8 @@ struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
+ 	return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
+ }
+ EXPORT_SYMBOL_GPL(kern_mount_data);
++
++bool our_mnt(struct vfsmount *mnt)
++{
++	return check_mnt(mnt);
++}
+diff --git a/fs/proc/meminfo.c b/fs/proc/meminfo.c
+index ed257d1..a962827 100644
+--- a/fs/proc/meminfo.c
++++ b/fs/proc/meminfo.c
+@@ -131,12 +131,13 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
+ 		K(i.freeswap),
+ 		K(global_page_state(NR_FILE_DIRTY)),
+ 		K(global_page_state(NR_WRITEBACK)),
+-		K(global_page_state(NR_ANON_PAGES)
+ #ifdef CONFIG_TRANSPARENT_HUGEPAGE
++		K(global_page_state(NR_ANON_PAGES)
+ 		  + global_page_state(NR_ANON_TRANSPARENT_HUGEPAGES) *
+-		  HPAGE_PMD_NR
++		  HPAGE_PMD_NR),
++#else
++		K(global_page_state(NR_ANON_PAGES)),
+ #endif
+-		  ),
+ 		K(global_page_state(NR_FILE_MAPPED)),
+ 		K(global_page_state(NR_SHMEM)),
+ 		K(global_page_state(NR_SLAB_RECLAIMABLE) +
+diff --git a/fs/seq_file.c b/fs/seq_file.c
+index 05d6b0e..dba43c3 100644
+--- a/fs/seq_file.c
++++ b/fs/seq_file.c
+@@ -449,8 +449,6 @@ EXPORT_SYMBOL(seq_path);
+ 
+ /*
+  * Same as seq_path, but relative to supplied root.
+- *
+- * root may be changed, see __d_path().
+  */
+ int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
+ 		  char *esc)
+@@ -463,6 +461,8 @@ int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
+ 		char *p;
+ 
+ 		p = __d_path(path, root, buf, size);
++		if (!p)
++			return SEQ_SKIP;
+ 		res = PTR_ERR(p);
+ 		if (!IS_ERR(p)) {
+ 			char *end = mangle_path(buf, p, esc);
+@@ -474,7 +474,7 @@ int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
+ 	}
+ 	seq_commit(m, res);
+ 
+-	return res < 0 ? res : 0;
++	return res < 0 && res != -ENAMETOOLONG ? res : 0;
+ }
+ 
+ /*
+diff --git a/fs/xfs/linux-2.6/xfs_export.c b/fs/xfs/linux-2.6/xfs_export.c
+index f4f878f..fed3f3c 100644
+--- a/fs/xfs/linux-2.6/xfs_export.c
++++ b/fs/xfs/linux-2.6/xfs_export.c
+@@ -98,22 +98,22 @@ xfs_fs_encode_fh(
+ 	switch (fileid_type) {
+ 	case FILEID_INO32_GEN_PARENT:
+ 		spin_lock(&dentry->d_lock);
+-		fid->i32.parent_ino = dentry->d_parent->d_inode->i_ino;
++		fid->i32.parent_ino = XFS_I(dentry->d_parent->d_inode)->i_ino;
+ 		fid->i32.parent_gen = dentry->d_parent->d_inode->i_generation;
+ 		spin_unlock(&dentry->d_lock);
+ 		/*FALLTHRU*/
+ 	case FILEID_INO32_GEN:
+-		fid->i32.ino = inode->i_ino;
++		fid->i32.ino = XFS_I(inode)->i_ino;
+ 		fid->i32.gen = inode->i_generation;
+ 		break;
+ 	case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG:
+ 		spin_lock(&dentry->d_lock);
+-		fid64->parent_ino = dentry->d_parent->d_inode->i_ino;
++		fid64->parent_ino = XFS_I(dentry->d_parent->d_inode)->i_ino;
+ 		fid64->parent_gen = dentry->d_parent->d_inode->i_generation;
+ 		spin_unlock(&dentry->d_lock);
+ 		/*FALLTHRU*/
+ 	case FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG:
+-		fid64->ino = inode->i_ino;
++		fid64->ino = XFS_I(inode)->i_ino;
+ 		fid64->gen = inode->i_generation;
+ 		break;
+ 	}
+diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
+index 01d2072..99d4011 100644
+--- a/fs/xfs/xfs_attr.c
++++ b/fs/xfs/xfs_attr.c
+@@ -822,17 +822,9 @@ xfs_attr_inactive(xfs_inode_t *dp)
+ 	error = xfs_attr_root_inactive(&trans, dp);
+ 	if (error)
+ 		goto out;
+-	/*
+-	 * signal synchronous inactive transactions unless this
+-	 * is a synchronous mount filesystem in which case we
+-	 * know that we're here because we've been called out of
+-	 * xfs_inactive which means that the last reference is gone
+-	 * and the unlink transaction has already hit the disk so
+-	 * async inactive transactions are safe.
+-	 */
+-	if ((error = xfs_itruncate_finish(&trans, dp, 0LL, XFS_ATTR_FORK,
+-				(!(mp->m_flags & XFS_MOUNT_WSYNC)
+-				 ? 1 : 0))))
++
++	error = xfs_itruncate_finish(&trans, dp, 0LL, XFS_ATTR_FORK, 0);
++	if (error)
+ 		goto out;
+ 
+ 	/*
+diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
+index e546a33..a175933 100644
+--- a/fs/xfs/xfs_bmap.c
++++ b/fs/xfs/xfs_bmap.c
+@@ -3785,19 +3785,11 @@ xfs_bmap_compute_maxlevels(
+  * Routine to be called at transaction's end by xfs_bmapi, xfs_bunmapi
+  * caller.  Frees all the extents that need freeing, which must be done
+  * last due to locking considerations.  We never free any extents in
+- * the first transaction.  This is to allow the caller to make the first
+- * transaction a synchronous one so that the pointers to the data being
+- * broken in this transaction will be permanent before the data is actually
+- * freed.  This is necessary to prevent blocks from being reallocated
+- * and written to before the free and reallocation are actually permanent.
+- * We do not just make the first transaction synchronous here, because
+- * there are more efficient ways to gain the same protection in some cases
+- * (see the file truncation code).
++ * the first transaction.
+  *
+  * Return 1 if the given transaction was committed and a new one
+  * started, and 0 otherwise in the committed parameter.
+  */
+-/*ARGSUSED*/
+ int						/* error */
+ xfs_bmap_finish(
+ 	xfs_trans_t		**tp,		/* transaction pointer addr */
+diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
+index c6888a4..5715279 100644
+--- a/fs/xfs/xfs_inode.c
++++ b/fs/xfs/xfs_inode.c
+@@ -1528,15 +1528,7 @@ xfs_itruncate_finish(
+ 				xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE);
+ 			}
+ 		}
+-	} else if (sync) {
+-		ASSERT(!(mp->m_flags & XFS_MOUNT_WSYNC));
+-		if (ip->i_d.di_anextents > 0)
+-			xfs_trans_set_sync(ntp);
+ 	}
+-	ASSERT(fork == XFS_DATA_FORK ||
+-		(fork == XFS_ATTR_FORK &&
+-			((sync && !(mp->m_flags & XFS_MOUNT_WSYNC)) ||
+-			 (sync == 0 && (mp->m_flags & XFS_MOUNT_WSYNC)))));
+ 
+ 	/*
+ 	 * Since it is possible for space to become allocated beyond
+diff --git a/include/drm/drm_pciids.h b/include/drm/drm_pciids.h
+index 4e4fbb8..14b6cd0 100644
+--- a/include/drm/drm_pciids.h
++++ b/include/drm/drm_pciids.h
+@@ -182,8 +182,11 @@
+ 	{0x1002, 0x6748, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6749, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6750, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \
++	{0x1002, 0x6751, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6758, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6759, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \
++	{0x1002, 0x675B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \
++	{0x1002, 0x675D, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x675F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6760, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6761, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+@@ -195,8 +198,10 @@
+ 	{0x1002, 0x6767, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6768, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6770, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \
++	{0x1002, 0x6772, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6778, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6779, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \
++	{0x1002, 0x677B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CAICOS|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6840, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6841, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x6842, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TURKS|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+@@ -246,6 +251,7 @@
+ 	{0x1002, 0x68f2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CEDAR|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x68f8, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CEDAR|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x68f9, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CEDAR|RADEON_NEW_MEMMAP}, \
++	{0x1002, 0x68fa, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CEDAR|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x68fe, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_CEDAR|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x7100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R520|RADEON_NEW_MEMMAP}, \
+ 	{0x1002, 0x7101, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R520|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+@@ -488,6 +494,8 @@
+ 	{0x1002, 0x9647, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SUMO|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP},\
+ 	{0x1002, 0x9648, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SUMO|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP},\
+ 	{0x1002, 0x964a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SUMO|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
++	{0x1002, 0x964b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SUMO|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
++	{0x1002, 0x964c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SUMO|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+ 	{0x1002, 0x964e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SUMO|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP},\
+ 	{0x1002, 0x964f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_SUMO|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP},\
+ 	{0x1002, 0x9710, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS880|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+@@ -502,6 +510,8 @@
+ 	{0x1002, 0x9805, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_PALM|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+ 	{0x1002, 0x9806, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_PALM|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+ 	{0x1002, 0x9807, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_PALM|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
++	{0x1002, 0x9808, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_PALM|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
++	{0x1002, 0x9809, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_PALM|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+ 	{0, 0, 0}
+ 
+ #define r128_PCI_IDS \
+diff --git a/include/linux/dcache.h b/include/linux/dcache.h
+index 19d90a5..8f848e4 100644
+--- a/include/linux/dcache.h
++++ b/include/linux/dcache.h
+@@ -340,7 +340,8 @@ extern int d_validate(struct dentry *, struct dentry *);
+  */
+ extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
+ 
+-extern char *__d_path(const struct path *path, struct path *root, char *, int);
++extern char *__d_path(const struct path *, const struct path *, char *, int);
++extern char *d_absolute_path(const struct path *, char *, int);
+ extern char *d_path(const struct path *, char *, int);
+ extern char *d_path_with_unreachable(const struct path *, char *, int);
+ extern char *dentry_path_raw(struct dentry *, char *, int);
+diff --git a/include/linux/fs.h b/include/linux/fs.h
+index b5b9792..7b17db7 100644
+--- a/include/linux/fs.h
++++ b/include/linux/fs.h
+@@ -1882,6 +1882,7 @@ extern int fd_statfs(int, struct kstatfs *);
+ extern int statfs_by_dentry(struct dentry *, struct kstatfs *);
+ extern int freeze_super(struct super_block *super);
+ extern int thaw_super(struct super_block *super);
++extern bool our_mnt(struct vfsmount *mnt);
+ 
+ extern int current_umask(void);
+ 
+diff --git a/include/linux/log2.h b/include/linux/log2.h
+index 25b8086..fd7ff3d 100644
+--- a/include/linux/log2.h
++++ b/include/linux/log2.h
+@@ -185,7 +185,6 @@ unsigned long __rounddown_pow_of_two(unsigned long n)
+ #define rounddown_pow_of_two(n)			\
+ (						\
+ 	__builtin_constant_p(n) ? (		\
+-		(n == 1) ? 0 :			\
+ 		(1UL << ilog2(n))) :		\
+ 	__rounddown_pow_of_two(n)		\
+  )
+diff --git a/kernel/taskstats.c b/kernel/taskstats.c
+index fc0f220..8d597b1 100644
+--- a/kernel/taskstats.c
++++ b/kernel/taskstats.c
+@@ -657,6 +657,7 @@ static struct genl_ops taskstats_ops = {
+ 	.cmd		= TASKSTATS_CMD_GET,
+ 	.doit		= taskstats_user_cmd,
+ 	.policy		= taskstats_cmd_get_policy,
++	.flags		= GENL_ADMIN_PERM,
+ };
+ 
+ static struct genl_ops cgroupstats_ops = {
+diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c
+index ea5e1a9..8b70c76 100644
+--- a/kernel/time/alarmtimer.c
++++ b/kernel/time/alarmtimer.c
+@@ -181,7 +181,7 @@ static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer)
+ 		struct alarm *alarm;
+ 		ktime_t expired = next->expires;
+ 
+-		if (expired.tv64 >= now.tv64)
++		if (expired.tv64 > now.tv64)
+ 			break;
+ 
+ 		alarm = container_of(next, struct alarm, node);
+diff --git a/mm/hugetlb.c b/mm/hugetlb.c
+index 2b57cd9..80936a1 100644
+--- a/mm/hugetlb.c
++++ b/mm/hugetlb.c
+@@ -575,6 +575,7 @@ static void prep_compound_gigantic_page(struct page *page, unsigned long order)
+ 	__SetPageHead(page);
+ 	for (i = 1; i < nr_pages; i++, p = mem_map_next(p, page, i)) {
+ 		__SetPageTail(p);
++		set_page_count(p, 0);
+ 		p->first_page = page;
+ 	}
+ }
+diff --git a/mm/page_alloc.c b/mm/page_alloc.c
+index 0f50cdb..8439d2a 100644
+--- a/mm/page_alloc.c
++++ b/mm/page_alloc.c
+@@ -355,8 +355,8 @@ void prep_compound_page(struct page *page, unsigned long order)
+ 	__SetPageHead(page);
+ 	for (i = 1; i < nr_pages; i++) {
+ 		struct page *p = page + i;
+-
+ 		__SetPageTail(p);
++		set_page_count(p, 0);
+ 		p->first_page = page;
+ 	}
+ }
+@@ -3388,9 +3388,15 @@ static void setup_zone_migrate_reserve(struct zone *zone)
+ 	unsigned long block_migratetype;
+ 	int reserve;
+ 
+-	/* Get the start pfn, end pfn and the number of blocks to reserve */
++	/*
++	 * Get the start pfn, end pfn and the number of blocks to reserve
++	 * We have to be careful to be aligned to pageblock_nr_pages to
++	 * make sure that we always check pfn_valid for the first page in
++	 * the block.
++	 */
+ 	start_pfn = zone->zone_start_pfn;
+ 	end_pfn = start_pfn + zone->spanned_pages;
++	start_pfn = roundup(start_pfn, pageblock_nr_pages);
+ 	reserve = roundup(min_wmark_pages(zone), pageblock_nr_pages) >>
+ 							pageblock_order;
+ 
+diff --git a/mm/percpu-vm.c b/mm/percpu-vm.c
+index ea53496..bfad724 100644
+--- a/mm/percpu-vm.c
++++ b/mm/percpu-vm.c
+@@ -143,8 +143,8 @@ static void pcpu_pre_unmap_flush(struct pcpu_chunk *chunk,
+ 				 int page_start, int page_end)
+ {
+ 	flush_cache_vunmap(
+-		pcpu_chunk_addr(chunk, pcpu_first_unit_cpu, page_start),
+-		pcpu_chunk_addr(chunk, pcpu_last_unit_cpu, page_end));
++		pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),
++		pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));
+ }
+ 
+ static void __pcpu_unmap_pages(unsigned long addr, int nr_pages)
+@@ -206,8 +206,8 @@ static void pcpu_post_unmap_tlb_flush(struct pcpu_chunk *chunk,
+ 				      int page_start, int page_end)
+ {
+ 	flush_tlb_kernel_range(
+-		pcpu_chunk_addr(chunk, pcpu_first_unit_cpu, page_start),
+-		pcpu_chunk_addr(chunk, pcpu_last_unit_cpu, page_end));
++		pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),
++		pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));
+ }
+ 
+ static int __pcpu_map_pages(unsigned long addr, struct page **pages,
+@@ -284,8 +284,8 @@ static void pcpu_post_map_flush(struct pcpu_chunk *chunk,
+ 				int page_start, int page_end)
+ {
+ 	flush_cache_vmap(
+-		pcpu_chunk_addr(chunk, pcpu_first_unit_cpu, page_start),
+-		pcpu_chunk_addr(chunk, pcpu_last_unit_cpu, page_end));
++		pcpu_chunk_addr(chunk, pcpu_low_unit_cpu, page_start),
++		pcpu_chunk_addr(chunk, pcpu_high_unit_cpu, page_end));
+ }
+ 
+ /**
+diff --git a/mm/percpu.c b/mm/percpu.c
+index bf80e55..93b5a7c 100644
+--- a/mm/percpu.c
++++ b/mm/percpu.c
+@@ -116,9 +116,9 @@ static int pcpu_atom_size __read_mostly;
+ static int pcpu_nr_slots __read_mostly;
+ static size_t pcpu_chunk_struct_size __read_mostly;
+ 
+-/* cpus with the lowest and highest unit numbers */
+-static unsigned int pcpu_first_unit_cpu __read_mostly;
+-static unsigned int pcpu_last_unit_cpu __read_mostly;
++/* cpus with the lowest and highest unit addresses */
++static unsigned int pcpu_low_unit_cpu __read_mostly;
++static unsigned int pcpu_high_unit_cpu __read_mostly;
+ 
+ /* the address of the first chunk which starts with the kernel static area */
+ void *pcpu_base_addr __read_mostly;
+@@ -984,19 +984,19 @@ phys_addr_t per_cpu_ptr_to_phys(void *addr)
+ {
+ 	void __percpu *base = __addr_to_pcpu_ptr(pcpu_base_addr);
+ 	bool in_first_chunk = false;
+-	unsigned long first_start, first_end;
++	unsigned long first_low, first_high;
+ 	unsigned int cpu;
+ 
+ 	/*
+-	 * The following test on first_start/end isn't strictly
++	 * The following test on unit_low/high isn't strictly
+ 	 * necessary but will speed up lookups of addresses which
+ 	 * aren't in the first chunk.
+ 	 */
+-	first_start = pcpu_chunk_addr(pcpu_first_chunk, pcpu_first_unit_cpu, 0);
+-	first_end = pcpu_chunk_addr(pcpu_first_chunk, pcpu_last_unit_cpu,
+-				    pcpu_unit_pages);
+-	if ((unsigned long)addr >= first_start &&
+-	    (unsigned long)addr < first_end) {
++	first_low = pcpu_chunk_addr(pcpu_first_chunk, pcpu_low_unit_cpu, 0);
++	first_high = pcpu_chunk_addr(pcpu_first_chunk, pcpu_high_unit_cpu,
++				     pcpu_unit_pages);
++	if ((unsigned long)addr >= first_low &&
++	    (unsigned long)addr < first_high) {
+ 		for_each_possible_cpu(cpu) {
+ 			void *start = per_cpu_ptr(base, cpu);
+ 
+@@ -1233,7 +1233,9 @@ int __init pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai,
+ 
+ 	for (cpu = 0; cpu < nr_cpu_ids; cpu++)
+ 		unit_map[cpu] = UINT_MAX;
+-	pcpu_first_unit_cpu = NR_CPUS;
++
++	pcpu_low_unit_cpu = NR_CPUS;
++	pcpu_high_unit_cpu = NR_CPUS;
+ 
+ 	for (group = 0, unit = 0; group < ai->nr_groups; group++, unit += i) {
+ 		const struct pcpu_group_info *gi = &ai->groups[group];
+@@ -1253,9 +1255,13 @@ int __init pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai,
+ 			unit_map[cpu] = unit + i;
+ 			unit_off[cpu] = gi->base_offset + i * ai->unit_size;
+ 
+-			if (pcpu_first_unit_cpu == NR_CPUS)
+-				pcpu_first_unit_cpu = cpu;
+-			pcpu_last_unit_cpu = cpu;
++			/* determine low/high unit_cpu */
++			if (pcpu_low_unit_cpu == NR_CPUS ||
++			    unit_off[cpu] < unit_off[pcpu_low_unit_cpu])
++				pcpu_low_unit_cpu = cpu;
++			if (pcpu_high_unit_cpu == NR_CPUS ||
++			    unit_off[cpu] > unit_off[pcpu_high_unit_cpu])
++				pcpu_high_unit_cpu = cpu;
+ 		}
+ 	}
+ 	pcpu_nr_units = unit;
+diff --git a/mm/vmalloc.c b/mm/vmalloc.c
+index 65d5fd2..43b44db 100644
+--- a/mm/vmalloc.c
++++ b/mm/vmalloc.c
+@@ -1648,6 +1648,8 @@ void *__vmalloc_node_range(unsigned long size, unsigned long align,
+ 		return NULL;
+ 
+ 	addr = __vmalloc_area_node(area, gfp_mask, prot, node, caller);
++	if (!addr)
++		return NULL;
+ 
+ 	/*
+ 	 * In this function, newly allocated vm_struct is not added
+diff --git a/net/mac80211/agg-tx.c b/net/mac80211/agg-tx.c
+index 42a59c2..db7db43 100644
+--- a/net/mac80211/agg-tx.c
++++ b/net/mac80211/agg-tx.c
+@@ -792,12 +792,27 @@ void ieee80211_process_addba_resp(struct ieee80211_local *local,
+ 		goto out;
+ 	}
+ 
+-	del_timer(&tid_tx->addba_resp_timer);
++	del_timer_sync(&tid_tx->addba_resp_timer);
+ 
+ #ifdef CONFIG_MAC80211_HT_DEBUG
+ 	printk(KERN_DEBUG "switched off addBA timer for tid %d\n", tid);
+ #endif
+ 
++	/*
++	 * addba_resp_timer may have fired before we got here, and
++	 * caused WANT_STOP to be set. If the stop then was already
++	 * processed further, STOPPING might be set.
++	 */
++	if (test_bit(HT_AGG_STATE_WANT_STOP, &tid_tx->state) ||
++	    test_bit(HT_AGG_STATE_STOPPING, &tid_tx->state)) {
++#ifdef CONFIG_MAC80211_HT_DEBUG
++		printk(KERN_DEBUG
++		       "got addBA resp for tid %d but we already gave up\n",
++		       tid);
++#endif
++		goto out;
++	}
++
+ 	if (le16_to_cpu(mgmt->u.action.u.addba_resp.status)
+ 			== WLAN_STATUS_SUCCESS) {
+ 		/*
+diff --git a/security/apparmor/path.c b/security/apparmor/path.c
+index 36cc0cc..b566eba 100644
+--- a/security/apparmor/path.c
++++ b/security/apparmor/path.c
+@@ -57,23 +57,44 @@ static int prepend(char **buffer, int buflen, const char *str, int namelen)
+ static int d_namespace_path(struct path *path, char *buf, int buflen,
+ 			    char **name, int flags)
+ {
+-	struct path root, tmp;
+ 	char *res;
+-	int connected, error = 0;
++	int error = 0;
++	int connected = 1;
++
++	if (path->mnt->mnt_flags & MNT_INTERNAL) {
++		/* it's not mounted anywhere */
++		res = dentry_path(path->dentry, buf, buflen);
++		*name = res;
++		if (IS_ERR(res)) {
++			*name = buf;
++			return PTR_ERR(res);
++		}
++		if (path->dentry->d_sb->s_magic == PROC_SUPER_MAGIC &&
++		    strncmp(*name, "/sys/", 5) == 0) {
++			/* TODO: convert over to using a per namespace
++			 * control instead of hard coded /proc
++			 */
++			return prepend(name, *name - buf, "/proc", 5);
++		}
++		return 0;
++	}
+ 
+-	/* Get the root we want to resolve too, released below */
++	/* resolve paths relative to chroot?*/
+ 	if (flags & PATH_CHROOT_REL) {
+-		/* resolve paths relative to chroot */
++		struct path root;
+ 		get_fs_root(current->fs, &root);
+-	} else {
+-		/* resolve paths relative to namespace */
+-		root.mnt = current->nsproxy->mnt_ns->root;
+-		root.dentry = root.mnt->mnt_root;
+-		path_get(&root);
++		res = __d_path(path, &root, buf, buflen);
++		if (res && !IS_ERR(res)) {
++			/* everything's fine */
++			*name = res;
++			path_put(&root);
++			goto ok;
++		}
++		path_put(&root);
++		connected = 0;
+ 	}
+ 
+-	tmp = root;
+-	res = __d_path(path, &tmp, buf, buflen);
++	res = d_absolute_path(path, buf, buflen);
+ 
+ 	*name = res;
+ 	/* handle error conditions - and still allow a partial path to
+@@ -84,7 +105,10 @@ static int d_namespace_path(struct path *path, char *buf, int buflen,
+ 		*name = buf;
+ 		goto out;
+ 	}
++	if (!our_mnt(path->mnt))
++		connected = 0;
+ 
++ok:
+ 	/* Handle two cases:
+ 	 * 1. A deleted dentry && profile is not allowing mediation of deleted
+ 	 * 2. On some filesystems, newly allocated dentries appear to the
+@@ -97,10 +121,7 @@ static int d_namespace_path(struct path *path, char *buf, int buflen,
+ 			goto out;
+ 	}
+ 
+-	/* Determine if the path is connected to the expected root */
+-	connected = tmp.dentry == root.dentry && tmp.mnt == root.mnt;
+-
+-	/* If the path is not connected,
++	/* If the path is not connected to the expected root,
+ 	 * check if it is a sysctl and handle specially else remove any
+ 	 * leading / that __d_path may have returned.
+ 	 * Unless
+@@ -112,17 +133,9 @@ static int d_namespace_path(struct path *path, char *buf, int buflen,
+ 	 *     namespace root.
+ 	 */
+ 	if (!connected) {
+-		/* is the disconnect path a sysctl? */
+-		if (tmp.dentry->d_sb->s_magic == PROC_SUPER_MAGIC &&
+-		    strncmp(*name, "/sys/", 5) == 0) {
+-			/* TODO: convert over to using a per namespace
+-			 * control instead of hard coded /proc
+-			 */
+-			error = prepend(name, *name - buf, "/proc", 5);
+-		} else if (!(flags & PATH_CONNECT_PATH) &&
++		if (!(flags & PATH_CONNECT_PATH) &&
+ 			   !(((flags & CHROOT_NSCONNECT) == CHROOT_NSCONNECT) &&
+-			     (tmp.mnt == current->nsproxy->mnt_ns->root &&
+-			      tmp.dentry == tmp.mnt->mnt_root))) {
++			     our_mnt(path->mnt))) {
+ 			/* disconnected path, don't return pathname starting
+ 			 * with '/'
+ 			 */
+@@ -133,8 +146,6 @@ static int d_namespace_path(struct path *path, char *buf, int buflen,
+ 	}
+ 
+ out:
+-	path_put(&root);
+-
+ 	return error;
+ }
+ 
+diff --git a/security/tomoyo/realpath.c b/security/tomoyo/realpath.c
+index d1e05b0..a339187 100644
+--- a/security/tomoyo/realpath.c
++++ b/security/tomoyo/realpath.c
+@@ -95,7 +95,6 @@ char *tomoyo_realpath_from_path(struct path *path)
+ 		return NULL;
+ 	is_dir = dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode);
+ 	while (1) {
+-		struct path ns_root = { .mnt = NULL, .dentry = NULL };
+ 		char *pos;
+ 		buf_len <<= 1;
+ 		kfree(buf);
+@@ -128,8 +127,12 @@ char *tomoyo_realpath_from_path(struct path *path)
+ 		/* If we don't have a vfsmount, we can't calculate. */
+ 		if (!path->mnt)
+ 			break;
+-		/* go to whatever namespace root we are under */
+-		pos = __d_path(path, &ns_root, buf, buf_len);
++		pos = d_absolute_path(path, buf, buf_len - 1);
++		/* If path is disconnected, use "[unknown]" instead. */
++		if (pos == ERR_PTR(-EINVAL)) {
++			name = tomoyo_encode("[unknown]");
++			break;
++		}
+ 		/* Prepend "/proc" prefix if using internal proc vfs mount. */
+ 		if (!IS_ERR(pos) && (path->mnt->mnt_flags & MNT_INTERNAL) &&
+ 		    (path->mnt->mnt_sb->s_magic == PROC_SUPER_MAGIC)) {
+diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
+index e7dc034..eb0a141 100644
+--- a/sound/pci/hda/patch_realtek.c
++++ b/sound/pci/hda/patch_realtek.c
+@@ -509,6 +509,8 @@ static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
+ 	imux = &spec->input_mux[mux_idx];
+ 	if (!imux->num_items && mux_idx > 0)
+ 		imux = &spec->input_mux[0];
++	if (!imux->num_items)
++		return 0;
+ 
+ 	type = get_wcaps_type(get_wcaps(codec, nid));
+ 	if (type == AC_WID_AUD_MIX) {
+diff --git a/sound/pci/sis7019.c b/sound/pci/sis7019.c
+index 2b5c7a95..5fe840b 100644
+--- a/sound/pci/sis7019.c
++++ b/sound/pci/sis7019.c
+@@ -41,6 +41,7 @@ MODULE_SUPPORTED_DEVICE("{{SiS,SiS7019 Audio Accelerator}}");
+ static int index = SNDRV_DEFAULT_IDX1;	/* Index 0-MAX */
+ static char *id = SNDRV_DEFAULT_STR1;	/* ID for this card */
+ static int enable = 1;
++static int codecs = 1;
+ 
+ module_param(index, int, 0444);
+ MODULE_PARM_DESC(index, "Index value for SiS7019 Audio Accelerator.");
+@@ -48,6 +49,8 @@ module_param(id, charp, 0444);
+ MODULE_PARM_DESC(id, "ID string for SiS7019 Audio Accelerator.");
+ module_param(enable, bool, 0444);
+ MODULE_PARM_DESC(enable, "Enable SiS7019 Audio Accelerator.");
++module_param(codecs, int, 0444);
++MODULE_PARM_DESC(codecs, "Set bit to indicate that codec number is expected to be present (default 1)");
+ 
+ static DEFINE_PCI_DEVICE_TABLE(snd_sis7019_ids) = {
+ 	{ PCI_DEVICE(PCI_VENDOR_ID_SI, 0x7019) },
+@@ -140,6 +143,9 @@ struct sis7019 {
+ 	dma_addr_t silence_dma_addr;
+ };
+ 
++/* These values are also used by the module param 'codecs' to indicate
++ * which codecs should be present.
++ */
+ #define SIS_PRIMARY_CODEC_PRESENT	0x0001
+ #define SIS_SECONDARY_CODEC_PRESENT	0x0002
+ #define SIS_TERTIARY_CODEC_PRESENT	0x0004
+@@ -1078,6 +1084,7 @@ static int sis_chip_init(struct sis7019 *sis)
+ {
+ 	unsigned long io = sis->ioport;
+ 	void __iomem *ioaddr = sis->ioaddr;
++	unsigned long timeout;
+ 	u16 status;
+ 	int count;
+ 	int i;
+@@ -1104,21 +1111,45 @@ static int sis_chip_init(struct sis7019 *sis)
+ 	while ((inw(io + SIS_AC97_STATUS) & SIS_AC97_STATUS_BUSY) && --count)
+ 		udelay(1);
+ 
++	/* Command complete, we can let go of the semaphore now.
++	 */
++	outl(SIS_AC97_SEMA_RELEASE, io + SIS_AC97_SEMA);
++	if (!count)
++		return -EIO;
++
+ 	/* Now that we've finished the reset, find out what's attached.
++	 * There are some codec/board combinations that take an extremely
++	 * long time to come up. 350+ ms has been observed in the field,
++	 * so we'll give them up to 500ms.
+ 	 */
+-	status = inl(io + SIS_AC97_STATUS);
+-	if (status & SIS_AC97_STATUS_CODEC_READY)
+-		sis->codecs_present |= SIS_PRIMARY_CODEC_PRESENT;
+-	if (status & SIS_AC97_STATUS_CODEC2_READY)
+-		sis->codecs_present |= SIS_SECONDARY_CODEC_PRESENT;
+-	if (status & SIS_AC97_STATUS_CODEC3_READY)
+-		sis->codecs_present |= SIS_TERTIARY_CODEC_PRESENT;
+-
+-	/* All done, let go of the semaphore, and check for errors
++	sis->codecs_present = 0;
++	timeout = msecs_to_jiffies(500) + jiffies;
++	while (time_before_eq(jiffies, timeout)) {
++		status = inl(io + SIS_AC97_STATUS);
++		if (status & SIS_AC97_STATUS_CODEC_READY)
++			sis->codecs_present |= SIS_PRIMARY_CODEC_PRESENT;
++		if (status & SIS_AC97_STATUS_CODEC2_READY)
++			sis->codecs_present |= SIS_SECONDARY_CODEC_PRESENT;
++		if (status & SIS_AC97_STATUS_CODEC3_READY)
++			sis->codecs_present |= SIS_TERTIARY_CODEC_PRESENT;
++
++		if (sis->codecs_present == codecs)
++			break;
++
++		msleep(1);
++	}
++
++	/* All done, check for errors.
+ 	 */
+-	outl(SIS_AC97_SEMA_RELEASE, io + SIS_AC97_SEMA);
+-	if (!sis->codecs_present || !count)
++	if (!sis->codecs_present) {
++		printk(KERN_ERR "sis7019: could not find any codecs\n");
+ 		return -EIO;
++	}
++
++	if (sis->codecs_present != codecs) {
++		printk(KERN_WARNING "sis7019: missing codecs, found %0x, expected %0x\n",
++		       sis->codecs_present, codecs);
++	}
+ 
+ 	/* Let the hardware know that the audio driver is alive,
+ 	 * and enable PCM slots on the AC-link for L/R playback (3 & 4) and
+@@ -1390,6 +1421,17 @@ static int __devinit snd_sis7019_probe(struct pci_dev *pci,
+ 	if (!enable)
+ 		goto error_out;
+ 
++	/* The user can specify which codecs should be present so that we
++	 * can wait for them to show up if they are slow to recover from
++	 * the AC97 cold reset. We default to a single codec, the primary.
++	 *
++	 * We assume that SIS_PRIMARY_*_PRESENT matches bits 0-2.
++	 */
++	codecs &= SIS_PRIMARY_CODEC_PRESENT | SIS_SECONDARY_CODEC_PRESENT |
++		  SIS_TERTIARY_CODEC_PRESENT;
++	if (!codecs)
++		codecs = SIS_PRIMARY_CODEC_PRESENT;
++
+ 	rc = snd_card_create(index, id, THIS_MODULE, sizeof(*sis), &card);
+ 	if (rc < 0)
+ 		goto error_out;
+diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
+index 59abd84..493ae7c 100644
+--- a/sound/soc/soc-core.c
++++ b/sound/soc/soc-core.c
+@@ -1257,7 +1257,7 @@ static void soc_resume_deferred(struct work_struct *work)
+ int snd_soc_resume(struct device *dev)
+ {
+ 	struct snd_soc_card *card = dev_get_drvdata(dev);
+-	int i;
++	int i, ac97_control = 0;
+ 
+ 	/* AC97 devices might have other drivers hanging off them so
+ 	 * need to resume immediately.  Other drivers don't have that
+@@ -1266,14 +1266,15 @@ int snd_soc_resume(struct device *dev)
+ 	 */
+ 	for (i = 0; i < card->num_rtd; i++) {
+ 		struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
+-		if (cpu_dai->driver->ac97_control) {
+-			dev_dbg(dev, "Resuming AC97 immediately\n");
+-			soc_resume_deferred(&card->deferred_resume_work);
+-		} else {
+-			dev_dbg(dev, "Scheduling resume work\n");
+-			if (!schedule_work(&card->deferred_resume_work))
+-				dev_err(dev, "resume work item may be lost\n");
+-		}
++		ac97_control |= cpu_dai->driver->ac97_control;
++	}
++	if (ac97_control) {
++		dev_dbg(dev, "Resuming AC97 immediately\n");
++		soc_resume_deferred(&card->deferred_resume_work);
++	} else {
++		dev_dbg(dev, "Scheduling resume work\n");
++		if (!schedule_work(&card->deferred_resume_work))
++			dev_err(dev, "resume work item may be lost\n");
+ 	}
+ 
+ 	return 0;
+diff --git a/sound/soc/soc-utils.c b/sound/soc/soc-utils.c
+index ec921ec..cd987de 100644
+--- a/sound/soc/soc-utils.c
++++ b/sound/soc/soc-utils.c
+@@ -57,7 +57,36 @@ int snd_soc_params_to_bclk(struct snd_pcm_hw_params *params)
+ }
+ EXPORT_SYMBOL_GPL(snd_soc_params_to_bclk);
+ 
+-static struct snd_soc_platform_driver dummy_platform;
++static const struct snd_pcm_hardware dummy_dma_hardware = {
++	.formats		= 0xffffffff,
++	.channels_min		= 1,
++	.channels_max		= UINT_MAX,
++
++	/* Random values to keep userspace happy when checking constraints */
++	.info			= SNDRV_PCM_INFO_INTERLEAVED |
++				  SNDRV_PCM_INFO_BLOCK_TRANSFER,
++	.buffer_bytes_max	= 128*1024,
++	.period_bytes_min	= PAGE_SIZE,
++	.period_bytes_max	= PAGE_SIZE*2,
++	.periods_min		= 2,
++	.periods_max		= 128,
++};
++
++static int dummy_dma_open(struct snd_pcm_substream *substream)
++{
++	snd_soc_set_runtime_hwparams(substream, &dummy_dma_hardware);
++
++	return 0;
++}
++
++static struct snd_pcm_ops dummy_dma_ops = {
++	.open		= dummy_dma_open,
++	.ioctl		= snd_pcm_lib_ioctl,
++};
++
++static struct snd_soc_platform_driver dummy_platform = {
++	.ops = &dummy_dma_ops,
++};
+ 
+ static __devinit int snd_soc_dummy_probe(struct platform_device *pdev)
+ {