From: Greg Kroah-Hartman Date: Thu, 29 Jul 2010 19:01:07 +0000 (-0700) Subject: .34 patches X-Git-Tag: v2.6.27.49~12 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=27cc43b6409973bffc5d41a8fde1add87e55e72a;p=thirdparty%2Fkernel%2Fstable-queue.git .34 patches --- diff --git a/queue-2.6.34/dm9000-fix-bug-spinlock-recursion.patch b/queue-2.6.34/dm9000-fix-bug-spinlock-recursion.patch new file mode 100644 index 00000000000..74e731224fa --- /dev/null +++ b/queue-2.6.34/dm9000-fix-bug-spinlock-recursion.patch @@ -0,0 +1,121 @@ +From 380fefb2ddabd4cd5f14dbe090481f0544e65078 Mon Sep 17 00:00:00 2001 +From: Baruch Siach +Date: Mon, 17 May 2010 17:45:48 -0700 +Subject: dm9000: fix "BUG: spinlock recursion" + +From: Baruch Siach + +commit 380fefb2ddabd4cd5f14dbe090481f0544e65078 upstream. + +dm9000_set_rx_csum and dm9000_hash_table are called from atomic context (in +dm9000_init_dm9000), and from non-atomic context (via ethtool_ops and +net_device_ops respectively). This causes a spinlock recursion BUG. Fix this by +renaming these functions to *_unlocked for the atomic context, and make the +original functions locking wrappers for use in the non-atomic context. + +Signed-off-by: Baruch Siach +Signed-off-by: David S. Miller +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/net/dm9000.c | 38 +++++++++++++++++++++++++++----------- + 1 file changed, 27 insertions(+), 11 deletions(-) + +--- a/drivers/net/dm9000.c ++++ b/drivers/net/dm9000.c +@@ -476,17 +476,13 @@ static uint32_t dm9000_get_rx_csum(struc + return dm->rx_csum; + } + +-static int dm9000_set_rx_csum(struct net_device *dev, uint32_t data) ++static int dm9000_set_rx_csum_unlocked(struct net_device *dev, uint32_t data) + { + board_info_t *dm = to_dm9000_board(dev); +- unsigned long flags; + + if (dm->can_csum) { + dm->rx_csum = data; +- +- spin_lock_irqsave(&dm->lock, flags); + iow(dm, DM9000_RCSR, dm->rx_csum ? RCSR_CSUM : 0); +- spin_unlock_irqrestore(&dm->lock, flags); + + return 0; + } +@@ -494,6 +490,19 @@ static int dm9000_set_rx_csum(struct net + return -EOPNOTSUPP; + } + ++static int dm9000_set_rx_csum(struct net_device *dev, uint32_t data) ++{ ++ board_info_t *dm = to_dm9000_board(dev); ++ unsigned long flags; ++ int ret; ++ ++ spin_lock_irqsave(&dm->lock, flags); ++ ret = dm9000_set_rx_csum_unlocked(dev, data); ++ spin_unlock_irqrestore(&dm->lock, flags); ++ ++ return ret; ++} ++ + static int dm9000_set_tx_csum(struct net_device *dev, uint32_t data) + { + board_info_t *dm = to_dm9000_board(dev); +@@ -722,7 +731,7 @@ static unsigned char dm9000_type_to_char + * Set DM9000 multicast address + */ + static void +-dm9000_hash_table(struct net_device *dev) ++dm9000_hash_table_unlocked(struct net_device *dev) + { + board_info_t *db = netdev_priv(dev); + struct dev_mc_list *mcptr; +@@ -730,12 +739,9 @@ dm9000_hash_table(struct net_device *dev + u32 hash_val; + u16 hash_table[4]; + u8 rcr = RCR_DIS_LONG | RCR_DIS_CRC | RCR_RXEN; +- unsigned long flags; + + dm9000_dbg(db, 1, "entering %s\n", __func__); + +- spin_lock_irqsave(&db->lock, flags); +- + for (i = 0, oft = DM9000_PAR; i < 6; i++, oft++) + iow(db, oft, dev->dev_addr[i]); + +@@ -765,6 +771,16 @@ dm9000_hash_table(struct net_device *dev + } + + iow(db, DM9000_RCR, rcr); ++} ++ ++static void ++dm9000_hash_table(struct net_device *dev) ++{ ++ board_info_t *db = netdev_priv(dev); ++ unsigned long flags; ++ ++ spin_lock_irqsave(&db->lock, flags); ++ dm9000_hash_table_unlocked(dev); + spin_unlock_irqrestore(&db->lock, flags); + } + +@@ -784,7 +800,7 @@ dm9000_init_dm9000(struct net_device *de + db->io_mode = ior(db, DM9000_ISR) >> 6; /* ISR bit7:6 keeps I/O mode */ + + /* Checksum mode */ +- dm9000_set_rx_csum(dev, db->rx_csum); ++ dm9000_set_rx_csum_unlocked(dev, db->rx_csum); + + /* GPIO0 on pre-activate PHY */ + iow(db, DM9000_GPR, 0); /* REG_1F bit0 activate phyxcer */ +@@ -811,7 +827,7 @@ dm9000_init_dm9000(struct net_device *de + iow(db, DM9000_ISR, ISR_CLR_STATUS); /* Clear interrupt status */ + + /* Set address filter table */ +- dm9000_hash_table(dev); ++ dm9000_hash_table_unlocked(dev); + + imr = IMR_PAR | IMR_PTM | IMR_PRM; + if (db->type != TYPE_DM9000E) diff --git a/queue-2.6.34/firmware_class-fix-memory-leak-free-allocated-pages.patch b/queue-2.6.34/firmware_class-fix-memory-leak-free-allocated-pages.patch new file mode 100644 index 00000000000..727a84cbd30 --- /dev/null +++ b/queue-2.6.34/firmware_class-fix-memory-leak-free-allocated-pages.patch @@ -0,0 +1,112 @@ +From dd336c554d8926c3348a2d5f2a5ef5597f6d1a06 Mon Sep 17 00:00:00 2001 +From: David Woodhouse +Date: Sun, 2 May 2010 11:21:21 +0300 +Subject: firmware_class: fix memory leak - free allocated pages + +From: David Woodhouse + +commit dd336c554d8926c3348a2d5f2a5ef5597f6d1a06 upstream. + +fix memory leak introduced by the patch 6e03a201bbe: +firmware: speed up request_firmware() + +1. vfree won't release pages there were allocated explicitly and mapped +using vmap. The memory has to be vunmap-ed and the pages needs +to be freed explicitly + +2. page array is moved into the 'struct +firmware' so that we can free it from release_firmware() +and not only in fw_dev_release() + +The fix doesn't break the firmware load speed. + +Cc: Johannes Berg +Cc: Ming Lei +Cc: Catalin Marinas +Singed-off-by: Kay Sievers +Signed-off-by: David Woodhouse +Signed-off-by: Tomas Winkler +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/base/firmware_class.c | 26 ++++++++++++++++++++------ + include/linux/firmware.h | 1 + + 2 files changed, 21 insertions(+), 6 deletions(-) + +--- a/drivers/base/firmware_class.c ++++ b/drivers/base/firmware_class.c +@@ -130,6 +130,17 @@ static ssize_t firmware_loading_show(str + return sprintf(buf, "%d\n", loading); + } + ++static void firmware_free_data(const struct firmware *fw) ++{ ++ int i; ++ vunmap(fw->data); ++ if (fw->pages) { ++ for (i = 0; i < PFN_UP(fw->size); i++) ++ __free_page(fw->pages[i]); ++ kfree(fw->pages); ++ } ++} ++ + /* Some architectures don't have PAGE_KERNEL_RO */ + #ifndef PAGE_KERNEL_RO + #define PAGE_KERNEL_RO PAGE_KERNEL +@@ -162,21 +173,21 @@ static ssize_t firmware_loading_store(st + mutex_unlock(&fw_lock); + break; + } +- vfree(fw_priv->fw->data); +- fw_priv->fw->data = NULL; ++ firmware_free_data(fw_priv->fw); ++ memset(fw_priv->fw, 0, sizeof(struct firmware)); ++ /* If the pages are not owned by 'struct firmware' */ + for (i = 0; i < fw_priv->nr_pages; i++) + __free_page(fw_priv->pages[i]); + kfree(fw_priv->pages); + fw_priv->pages = NULL; + fw_priv->page_array_size = 0; + fw_priv->nr_pages = 0; +- fw_priv->fw->size = 0; + set_bit(FW_STATUS_LOADING, &fw_priv->status); + mutex_unlock(&fw_lock); + break; + case 0: + if (test_bit(FW_STATUS_LOADING, &fw_priv->status)) { +- vfree(fw_priv->fw->data); ++ vunmap(fw_priv->fw->data); + fw_priv->fw->data = vmap(fw_priv->pages, + fw_priv->nr_pages, + 0, PAGE_KERNEL_RO); +@@ -184,7 +195,10 @@ static ssize_t firmware_loading_store(st + dev_err(dev, "%s: vmap() failed\n", __func__); + goto err; + } +- /* Pages will be freed by vfree() */ ++ /* Pages are now owned by 'struct firmware' */ ++ fw_priv->fw->pages = fw_priv->pages; ++ fw_priv->pages = NULL; ++ + fw_priv->page_array_size = 0; + fw_priv->nr_pages = 0; + complete(&fw_priv->completion); +@@ -578,7 +592,7 @@ release_firmware(const struct firmware * + if (fw->data == builtin->data) + goto free_fw; + } +- vfree(fw->data); ++ firmware_free_data(fw); + free_fw: + kfree(fw); + } +--- a/include/linux/firmware.h ++++ b/include/linux/firmware.h +@@ -12,6 +12,7 @@ + struct firmware { + size_t size; + const u8 *data; ++ struct page **pages; + }; + + struct device; diff --git a/queue-2.6.34/libertas-sdio-8686-set-ecsi-bit-for-1-bit-transfers.patch b/queue-2.6.34/libertas-sdio-8686-set-ecsi-bit-for-1-bit-transfers.patch new file mode 100644 index 00000000000..d083dece6b3 --- /dev/null +++ b/queue-2.6.34/libertas-sdio-8686-set-ecsi-bit-for-1-bit-transfers.patch @@ -0,0 +1,90 @@ +From 8a64c0f6b7ec7f758c4ef445e49f479e27fa2236 Mon Sep 17 00:00:00 2001 +From: Daniel Mack +Date: Tue, 6 Apr 2010 10:52:44 +0200 +Subject: libertas/sdio: 8686: set ECSI bit for 1-bit transfers + +From: Daniel Mack + +commit 8a64c0f6b7ec7f758c4ef445e49f479e27fa2236 upstream. + +When operating in 1-bit mode, SDAT1 is used as dedicated interrupt line. +However, the 8686 will only drive this line when the ECSI bit is set in +the CCCR_IF register. + +Thanks to Alagu Sankar for pointing me in the right direction. + +Signed-off-by: Daniel Mack +Cc: Alagu Sankar +Cc: Volker Ernst +Cc: Dan Williams +Cc: John W. Linville +Cc: Holger Schurig +Cc: Bing Zhao +Cc: libertas-dev@lists.infradead.org +Cc: linux-wireless@vger.kernel.org +Cc: linux-mmc@vger.kernel.org +Acked-by: Dan Williams +Signed-off-by: John W. Linville +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/net/wireless/libertas/if_sdio.c | 22 ++++++++++++++++++++++ + include/linux/mmc/sdio.h | 2 ++ + 2 files changed, 24 insertions(+) + +--- a/drivers/net/wireless/libertas/if_sdio.c ++++ b/drivers/net/wireless/libertas/if_sdio.c +@@ -35,6 +35,8 @@ + #include + #include + #include ++#include ++#include + + #include "host.h" + #include "decl.h" +@@ -943,6 +945,7 @@ static int if_sdio_probe(struct sdio_fun + int ret, i; + unsigned int model; + struct if_sdio_packet *packet; ++ struct mmc_host *host = func->card->host; + + lbs_deb_enter(LBS_DEB_SDIO); + +@@ -1023,6 +1026,25 @@ static int if_sdio_probe(struct sdio_fun + if (ret) + goto disable; + ++ /* For 1-bit transfers to the 8686 model, we need to enable the ++ * interrupt flag in the CCCR register. Set the MMC_QUIRK_LENIENT_FN0 ++ * bit to allow access to non-vendor registers. */ ++ if ((card->model == IF_SDIO_MODEL_8686) && ++ (host->caps & MMC_CAP_SDIO_IRQ) && ++ (host->ios.bus_width == MMC_BUS_WIDTH_1)) { ++ u8 reg; ++ ++ func->card->quirks |= MMC_QUIRK_LENIENT_FN0; ++ reg = sdio_f0_readb(func, SDIO_CCCR_IF, &ret); ++ if (ret) ++ goto release_int; ++ ++ reg |= SDIO_BUS_ECSI; ++ sdio_f0_writeb(func, reg, SDIO_CCCR_IF, &ret); ++ if (ret) ++ goto release_int; ++ } ++ + card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret); + if (ret) + goto release_int; +--- a/include/linux/mmc/sdio.h ++++ b/include/linux/mmc/sdio.h +@@ -94,6 +94,8 @@ + + #define SDIO_BUS_WIDTH_1BIT 0x00 + #define SDIO_BUS_WIDTH_4BIT 0x02 ++#define SDIO_BUS_ECSI 0x20 /* Enable continuous SPI interrupt */ ++#define SDIO_BUS_SCSI 0x40 /* Support continuous SPI interrupt */ + + #define SDIO_BUS_ASYNC_INT 0x20 + diff --git a/queue-2.6.34/mfd-remove-unneeded-and-dangerous-clearing-of-clientdata.patch b/queue-2.6.34/mfd-remove-unneeded-and-dangerous-clearing-of-clientdata.patch new file mode 100644 index 00000000000..766d97446ba --- /dev/null +++ b/queue-2.6.34/mfd-remove-unneeded-and-dangerous-clearing-of-clientdata.patch @@ -0,0 +1,46 @@ +From 28ade0f217a3a3ff992b01e06e6e425c250a8406 Mon Sep 17 00:00:00 2001 +From: Wolfram Sang +Date: Fri, 21 May 2010 00:50:17 +0200 +Subject: mfd: Remove unneeded and dangerous clearing of clientdata + +From: Wolfram Sang + +commit 28ade0f217a3a3ff992b01e06e6e425c250a8406 upstream. + +Unlike real i2c-devices which get detached from the driver, dummy-devices +get truly unregistered. So, there has never been a need to clear the +clientdata because the device will go away anyhow. For the occasions fixed +here, clearing clientdata was even dangerous as the structure was freed +already. + +Signed-off-by: Wolfram Sang +Acked-by: Jean Delvare +Signed-off-by: Samuel Ortiz +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/mfd/88pm860x-i2c.c | 1 - + drivers/mfd/max8925-i2c.c | 2 -- + 2 files changed, 3 deletions(-) + +--- a/drivers/mfd/88pm860x-i2c.c ++++ b/drivers/mfd/88pm860x-i2c.c +@@ -200,7 +200,6 @@ static int __devexit pm860x_remove(struc + + pm860x_device_exit(chip); + i2c_unregister_device(chip->companion); +- i2c_set_clientdata(chip->companion, NULL); + i2c_set_clientdata(chip->client, NULL); + kfree(chip); + return 0; +--- a/drivers/mfd/max8925-i2c.c ++++ b/drivers/mfd/max8925-i2c.c +@@ -173,8 +173,6 @@ static int __devexit max8925_remove(stru + max8925_device_exit(chip); + i2c_unregister_device(chip->adc); + i2c_unregister_device(chip->rtc); +- i2c_set_clientdata(chip->adc, NULL); +- i2c_set_clientdata(chip->rtc, NULL); + i2c_set_clientdata(chip->i2c, NULL); + kfree(chip); + return 0; diff --git a/queue-2.6.34/revert-remove-rwsem-lock-from-cpufreq_gov_stop-call-second-call-site.patch b/queue-2.6.34/revert-remove-rwsem-lock-from-cpufreq_gov_stop-call-second-call-site.patch new file mode 100644 index 00000000000..7381f07243b --- /dev/null +++ b/queue-2.6.34/revert-remove-rwsem-lock-from-cpufreq_gov_stop-call-second-call-site.patch @@ -0,0 +1,49 @@ +From accd846698439ba18250e8fd5681af280446b853 Mon Sep 17 00:00:00 2001 +From: Andrej Gelenberg +Date: Fri, 14 May 2010 15:15:58 -0700 +Subject: [CPUFREQ] revert "[CPUFREQ] remove rwsem lock from CPUFREQ_GOV_STOP call (second call site)" + +From: Andrej Gelenberg + +commit accd846698439ba18250e8fd5681af280446b853 upstream. + +395913d0b1db37092ea3d9d69b832183b1dd84c5 ("[CPUFREQ] remove rwsem lock +from CPUFREQ_GOV_STOP call (second call site)") is not needed, because +there is no rwsem lock in cpufreq_ondemand and cpufreq_conservative +anymore. Lock should not be released until the work done. + +Addresses https://bugzilla.kernel.org/show_bug.cgi?id=1594 + +Signed-off-by: Andrej Gelenberg +Cc: Mathieu Desnoyers +Cc: Venkatesh Pallipadi +Signed-off-by: Andrew Morton +Acked-by: Mathieu Desnoyers +Signed-off-by: Dave Jones +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/cpufreq/cpufreq.c | 11 +---------- + 1 file changed, 1 insertion(+), 10 deletions(-) + +--- a/drivers/cpufreq/cpufreq.c ++++ b/drivers/cpufreq/cpufreq.c +@@ -1774,17 +1774,8 @@ static int __cpufreq_set_policy(struct c + dprintk("governor switch\n"); + + /* end old governor */ +- if (data->governor) { +- /* +- * Need to release the rwsem around governor +- * stop due to lock dependency between +- * cancel_delayed_work_sync and the read lock +- * taken in the delayed work handler. +- */ +- unlock_policy_rwsem_write(data->cpu); ++ if (data->governor) + __cpufreq_governor(data, CPUFREQ_GOV_STOP); +- lock_policy_rwsem_write(data->cpu); +- } + + /* start new governor */ + data->governor = policy->governor; diff --git a/queue-2.6.34/series b/queue-2.6.34/series index a8af551c135..9a5982b2f3d 100644 --- a/queue-2.6.34/series +++ b/queue-2.6.34/series @@ -152,7 +152,6 @@ ethtool-fix-potential-user-buffer-overflow-for-ethtool_-g-s-rxfh.patch 0005-KVM-read-apic-irr-with-ioapic-lock-held.patch splice-direct_splice_actor-should-not-use-pos-in-sd.patch splice-check-f_mode-for-seekable-file.patch -writeback-remove-writeback_inodes_wbc.patch futex-futex_find_get_task-remove-credentails-check.patch pm-x86-save-restore-misc_enable-register.patch pci-pm-do-not-use-native-pcie-pme-by-default.patch @@ -166,3 +165,8 @@ isdn-gigaset-correct-capi-connection-state-storage.patch acpi-skip-checking-bm_sts-if-the-bios-doesn-t-ask-for-it.patch acpi-pm-do-not-enable-gpes-for-system-wakeup-in-advance.patch acpi-unconditionally-set-sci_en-on-resume.patch +libertas-sdio-8686-set-ecsi-bit-for-1-bit-transfers.patch +dm9000-fix-bug-spinlock-recursion.patch +mfd-remove-unneeded-and-dangerous-clearing-of-clientdata.patch +firmware_class-fix-memory-leak-free-allocated-pages.patch +revert-remove-rwsem-lock-from-cpufreq_gov_stop-call-second-call-site.patch diff --git a/queue-2.6.34/writeback-remove-writeback_inodes_wbc.patch b/queue-2.6.34/writeback-remove-writeback_inodes_wbc.patch deleted file mode 100644 index 503a3256a96..00000000000 --- a/queue-2.6.34/writeback-remove-writeback_inodes_wbc.patch +++ /dev/null @@ -1,147 +0,0 @@ -From 9c3a8ee8a1d72c5c0d7fbdf426d80e270ddfa54c Mon Sep 17 00:00:00 2001 -From: Christoph Hellwig -Date: Thu, 10 Jun 2010 12:07:27 +0200 -Subject: writeback: remove writeback_inodes_wbc - -From: Christoph Hellwig - -commit 9c3a8ee8a1d72c5c0d7fbdf426d80e270ddfa54c upstream. - -This was just an odd wrapper around writeback_inodes_wb. Removing this -also allows to get rid of the bdi member of struct writeback_control -which was rather out of place there. - -Signed-off-by: Christoph Hellwig -Signed-off-by: Jens Axboe -Signed-off-by: Greg Kroah-Hartman - ---- - fs/afs/write.c | 1 - - fs/btrfs/extent_io.c | 2 -- - fs/fs-writeback.c | 12 ++---------- - include/linux/writeback.h | 5 ++--- - mm/backing-dev.c | 3 +-- - mm/page-writeback.c | 3 +-- - 6 files changed, 6 insertions(+), 20 deletions(-) - ---- a/fs/afs/write.c -+++ b/fs/afs/write.c -@@ -680,7 +680,6 @@ int afs_writeback_all(struct afs_vnode * - { - struct address_space *mapping = vnode->vfs_inode.i_mapping; - struct writeback_control wbc = { -- .bdi = mapping->backing_dev_info, - .sync_mode = WB_SYNC_ALL, - .nr_to_write = LONG_MAX, - .range_cyclic = 1, ---- a/fs/btrfs/extent_io.c -+++ b/fs/btrfs/extent_io.c -@@ -2589,7 +2589,6 @@ int extent_write_full_page(struct extent - .sync_io = wbc->sync_mode == WB_SYNC_ALL, - }; - struct writeback_control wbc_writepages = { -- .bdi = wbc->bdi, - .sync_mode = wbc->sync_mode, - .older_than_this = NULL, - .nr_to_write = 64, -@@ -2623,7 +2622,6 @@ int extent_write_locked_range(struct ext - .sync_io = mode == WB_SYNC_ALL, - }; - struct writeback_control wbc_writepages = { -- .bdi = inode->i_mapping->backing_dev_info, - .sync_mode = mode, - .older_than_this = NULL, - .nr_to_write = nr_pages * 2, ---- a/fs/fs-writeback.c -+++ b/fs/fs-writeback.c -@@ -660,8 +660,8 @@ static int writeback_sb_inodes(struct su - return 1; - } - --static void writeback_inodes_wb(struct bdi_writeback *wb, -- struct writeback_control *wbc) -+void writeback_inodes_wb(struct bdi_writeback *wb, -+ struct writeback_control *wbc) - { - int ret = 0; - -@@ -699,13 +699,6 @@ static void writeback_inodes_wb(struct b - /* Leave any unwritten inodes on b_io */ - } - --void writeback_inodes_wbc(struct writeback_control *wbc) --{ -- struct backing_dev_info *bdi = wbc->bdi; -- -- writeback_inodes_wb(&bdi->wb, wbc); --} -- - /* - * The maximum number of pages to writeout in a single bdi flush/kupdate - * operation. We do this so we don't hold I_SYNC against an inode for -@@ -744,7 +737,6 @@ static long wb_writeback(struct bdi_writ - struct wb_writeback_args *args) - { - struct writeback_control wbc = { -- .bdi = wb->bdi, - .sb = args->sb, - .sync_mode = args->sync_mode, - .older_than_this = NULL, ---- a/include/linux/writeback.h -+++ b/include/linux/writeback.h -@@ -27,8 +27,6 @@ enum writeback_sync_modes { - * in a manner such that unspecified fields are set to zero. - */ - struct writeback_control { -- struct backing_dev_info *bdi; /* If !NULL, only write back this -- queue */ - struct super_block *sb; /* if !NULL, only write inodes from - this super_block */ - enum writeback_sync_modes sync_mode; -@@ -75,7 +73,8 @@ int inode_wait(void *); - void writeback_inodes_sb(struct super_block *); - int writeback_inodes_sb_if_idle(struct super_block *); - void sync_inodes_sb(struct super_block *); --void writeback_inodes_wbc(struct writeback_control *wbc); -+void writeback_inodes_wb(struct bdi_writeback *wb, -+ struct writeback_control *wbc); - long wb_do_writeback(struct bdi_writeback *wb, int force_wait); - void wakeup_flusher_threads(long nr_pages); - ---- a/mm/backing-dev.c -+++ b/mm/backing-dev.c -@@ -341,14 +341,13 @@ int bdi_has_dirty_io(struct backing_dev_ - static void bdi_flush_io(struct backing_dev_info *bdi) - { - struct writeback_control wbc = { -- .bdi = bdi, - .sync_mode = WB_SYNC_NONE, - .older_than_this = NULL, - .range_cyclic = 1, - .nr_to_write = 1024, - }; - -- writeback_inodes_wbc(&wbc); -+ writeback_inodes_wb(&bdi->wb, &wbc); - } - - /* ---- a/mm/page-writeback.c -+++ b/mm/page-writeback.c -@@ -495,7 +495,6 @@ static void balance_dirty_pages(struct a - - for (;;) { - struct writeback_control wbc = { -- .bdi = bdi, - .sync_mode = WB_SYNC_NONE, - .older_than_this = NULL, - .nr_to_write = write_chunk, -@@ -537,7 +536,7 @@ static void balance_dirty_pages(struct a - * up. - */ - if (bdi_nr_reclaimable > bdi_thresh) { -- writeback_inodes_wbc(&wbc); -+ writeback_inodes_wb(&bdi->wb, &wbc); - pages_written += write_chunk - wbc.nr_to_write; - get_dirty_limits(&background_thresh, &dirty_thresh, - &bdi_thresh, bdi);