From: Greg Kroah-Hartman Date: Mon, 27 Oct 2025 08:04:44 +0000 (+0100) Subject: 6.17-stable patches X-Git-Tag: v5.4.301~19 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=12ad5c25bd56095a8bfc7a7382294fa6abd9b8f6;p=thirdparty%2Fkernel%2Fstable-queue.git 6.17-stable patches added patches: gpio-idio-16-define-fixed-direction-of-the-gpio-lines.patch gpio-regmap-add-the-.fixed_direction_output-configuration-parameter.patch gpio-regmap-allow-to-allocate-regmap-irq-device.patch mm-migrate-remove-migratepage_unmap.patch treewide-remove-migratepage_success.patch vmw_balloon-indicate-success-when-effectively-deflating-during-migration.patch xfs-always-warn-about-deprecated-mount-options.patch --- diff --git a/queue-6.17/gpio-idio-16-define-fixed-direction-of-the-gpio-lines.patch b/queue-6.17/gpio-idio-16-define-fixed-direction-of-the-gpio-lines.patch new file mode 100644 index 0000000000..38330c20eb --- /dev/null +++ b/queue-6.17/gpio-idio-16-define-fixed-direction-of-the-gpio-lines.patch @@ -0,0 +1,62 @@ +From stable+bounces-189875-greg=kroah.com@vger.kernel.org Sun Oct 26 17:25:43 2025 +From: Sasha Levin +Date: Sun, 26 Oct 2025 12:25:28 -0400 +Subject: gpio: idio-16: Define fixed direction of the GPIO lines +To: stable@vger.kernel.org +Cc: William Breathitt Gray , Mark Cave-Ayland , Michael Walle , Andy Shevchenko , Linus Walleij , Bartosz Golaszewski , Sasha Levin +Message-ID: <20251026162528.110183-3-sashal@kernel.org> + +From: William Breathitt Gray + +[ Upstream commit 2ba5772e530f73eb847fb96ce6c4017894869552 ] + +The direction of the IDIO-16 GPIO lines is fixed with the first 16 lines +as output and the remaining 16 lines as input. Set the gpio_config +fixed_direction_output member to represent the fixed direction of the +GPIO lines. + +Fixes: db02247827ef ("gpio: idio-16: Migrate to the regmap API") +Reported-by: Mark Cave-Ayland +Closes: https://lore.kernel.org/r/9b0375fd-235f-4ee1-a7fa-daca296ef6bf@nutanix.com +Suggested-by: Michael Walle +Cc: stable@vger.kernel.org # ae495810cffe: gpio: regmap: add the .fixed_direction_output configuration parameter +Cc: stable@vger.kernel.org +Reviewed-by: Andy Shevchenko +Signed-off-by: William Breathitt Gray +Reviewed-by: Linus Walleij +Link: https://lore.kernel.org/r/20251020-fix-gpio-idio-16-regmap-v2-3-ebeb50e93c33@kernel.org +Signed-off-by: Bartosz Golaszewski +Signed-off-by: Sasha Levin +Signed-off-by: Greg Kroah-Hartman +--- + drivers/gpio/gpio-idio-16.c | 5 +++++ + 1 file changed, 5 insertions(+) + +--- a/drivers/gpio/gpio-idio-16.c ++++ b/drivers/gpio/gpio-idio-16.c +@@ -6,6 +6,7 @@ + + #define DEFAULT_SYMBOL_NAMESPACE "GPIO_IDIO_16" + ++#include + #include + #include + #include +@@ -107,6 +108,7 @@ int devm_idio_16_regmap_register(struct + struct idio_16_data *data; + struct regmap_irq_chip *chip; + struct regmap_irq_chip_data *chip_data; ++ DECLARE_BITMAP(fixed_direction_output, IDIO_16_NGPIO); + + if (!config->parent) + return -EINVAL; +@@ -164,6 +166,9 @@ int devm_idio_16_regmap_register(struct + gpio_config.irq_domain = regmap_irq_get_domain(chip_data); + gpio_config.reg_mask_xlate = idio_16_reg_mask_xlate; + ++ bitmap_from_u64(fixed_direction_output, GENMASK_U64(15, 0)); ++ gpio_config.fixed_direction_output = fixed_direction_output; ++ + return PTR_ERR_OR_ZERO(devm_gpio_regmap_register(dev, &gpio_config)); + } + EXPORT_SYMBOL_GPL(devm_idio_16_regmap_register); diff --git a/queue-6.17/gpio-regmap-add-the-.fixed_direction_output-configuration-parameter.patch b/queue-6.17/gpio-regmap-add-the-.fixed_direction_output-configuration-parameter.patch new file mode 100644 index 0000000000..d017187700 --- /dev/null +++ b/queue-6.17/gpio-regmap-add-the-.fixed_direction_output-configuration-parameter.patch @@ -0,0 +1,133 @@ +From stable+bounces-189873-greg=kroah.com@vger.kernel.org Sun Oct 26 17:25:45 2025 +From: Sasha Levin +Date: Sun, 26 Oct 2025 12:25:27 -0400 +Subject: gpio: regmap: add the .fixed_direction_output configuration parameter +To: stable@vger.kernel.org +Cc: Ioana Ciornei , Bartosz Golaszewski , Michael Walle , Sasha Levin +Message-ID: <20251026162528.110183-2-sashal@kernel.org> + +From: Ioana Ciornei + +[ Upstream commit 00aaae60faf554c27c95e93d47f200a93ff266ef ] + +There are GPIO controllers such as the one present in the LX2160ARDB +QIXIS FPGA which have fixed-direction input and output GPIO lines mixed +together in a single register. This cannot be modeled using the +gpio-regmap as-is since there is no way to present the true direction of +a GPIO line. + +In order to make this use case possible, add a new configuration +parameter - fixed_direction_output - into the gpio_regmap_config +structure. This will enable user drivers to provide a bitmap that +represents the fixed direction of the GPIO lines. + +Signed-off-by: Ioana Ciornei +Acked-by: Bartosz Golaszewski +Reviewed-by: Michael Walle +Signed-off-by: Bartosz Golaszewski +Stable-dep-of: 2ba5772e530f ("gpio: idio-16: Define fixed direction of the GPIO lines") +Signed-off-by: Sasha Levin +Signed-off-by: Greg Kroah-Hartman +--- + drivers/gpio/gpio-regmap.c | 26 ++++++++++++++++++++++++-- + include/linux/gpio/regmap.h | 5 +++++ + 2 files changed, 29 insertions(+), 2 deletions(-) + +--- a/drivers/gpio/gpio-regmap.c ++++ b/drivers/gpio/gpio-regmap.c +@@ -31,6 +31,7 @@ struct gpio_regmap { + unsigned int reg_clr_base; + unsigned int reg_dir_in_base; + unsigned int reg_dir_out_base; ++ unsigned long *fixed_direction_output; + + #ifdef CONFIG_REGMAP_IRQ + int regmap_irq_line; +@@ -134,6 +135,13 @@ static int gpio_regmap_get_direction(str + unsigned int base, val, reg, mask; + int invert, ret; + ++ if (gpio->fixed_direction_output) { ++ if (test_bit(offset, gpio->fixed_direction_output)) ++ return GPIO_LINE_DIRECTION_OUT; ++ else ++ return GPIO_LINE_DIRECTION_IN; ++ } ++ + if (gpio->reg_dat_base && !gpio->reg_set_base) + return GPIO_LINE_DIRECTION_IN; + if (gpio->reg_set_base && !gpio->reg_dat_base) +@@ -283,6 +291,17 @@ struct gpio_regmap *gpio_regmap_register + goto err_free_gpio; + } + ++ if (config->fixed_direction_output) { ++ gpio->fixed_direction_output = bitmap_alloc(chip->ngpio, ++ GFP_KERNEL); ++ if (!gpio->fixed_direction_output) { ++ ret = -ENOMEM; ++ goto err_free_gpio; ++ } ++ bitmap_copy(gpio->fixed_direction_output, ++ config->fixed_direction_output, chip->ngpio); ++ } ++ + /* if not set, assume there is only one register */ + gpio->ngpio_per_reg = config->ngpio_per_reg; + if (!gpio->ngpio_per_reg) +@@ -299,7 +318,7 @@ struct gpio_regmap *gpio_regmap_register + + ret = gpiochip_add_data(chip, gpio); + if (ret < 0) +- goto err_free_gpio; ++ goto err_free_bitmap; + + #ifdef CONFIG_REGMAP_IRQ + if (config->regmap_irq_chip) { +@@ -308,7 +327,7 @@ struct gpio_regmap *gpio_regmap_register + config->regmap_irq_line, config->regmap_irq_flags, + 0, config->regmap_irq_chip, &gpio->irq_chip_data); + if (ret) +- goto err_free_gpio; ++ goto err_free_bitmap; + + irq_domain = regmap_irq_get_domain(gpio->irq_chip_data); + } else +@@ -325,6 +344,8 @@ struct gpio_regmap *gpio_regmap_register + + err_remove_gpiochip: + gpiochip_remove(chip); ++err_free_bitmap: ++ bitmap_free(gpio->fixed_direction_output); + err_free_gpio: + kfree(gpio); + return ERR_PTR(ret); +@@ -343,6 +364,7 @@ void gpio_regmap_unregister(struct gpio_ + #endif + + gpiochip_remove(&gpio->gpio_chip); ++ bitmap_free(gpio->fixed_direction_output); + kfree(gpio); + } + EXPORT_SYMBOL_GPL(gpio_regmap_unregister); +--- a/include/linux/gpio/regmap.h ++++ b/include/linux/gpio/regmap.h +@@ -37,6 +37,10 @@ struct regmap; + * offset to a register/bitmask pair. If not + * given the default gpio_regmap_simple_xlate() + * is used. ++ * @fixed_direction_output: ++ * (Optional) Bitmap representing the fixed direction of ++ * the GPIO lines. Useful when there are GPIO lines with a ++ * fixed direction mixed together in the same register. + * @drvdata: (Optional) Pointer to driver specific data which is + * not used by gpio-remap but is provided "as is" to the + * driver callback(s). +@@ -82,6 +86,7 @@ struct gpio_regmap_config { + int reg_stride; + int ngpio_per_reg; + struct irq_domain *irq_domain; ++ unsigned long *fixed_direction_output; + + #ifdef CONFIG_REGMAP_IRQ + struct regmap_irq_chip *regmap_irq_chip; diff --git a/queue-6.17/gpio-regmap-allow-to-allocate-regmap-irq-device.patch b/queue-6.17/gpio-regmap-allow-to-allocate-regmap-irq-device.patch new file mode 100644 index 0000000000..15cc2aa944 --- /dev/null +++ b/queue-6.17/gpio-regmap-allow-to-allocate-regmap-irq-device.patch @@ -0,0 +1,114 @@ +From stable+bounces-189874-greg=kroah.com@vger.kernel.org Sun Oct 26 17:25:40 2025 +From: Sasha Levin +Date: Sun, 26 Oct 2025 12:25:26 -0400 +Subject: gpio: regmap: Allow to allocate regmap-irq device +To: stable@vger.kernel.org +Cc: Mathieu Dubois-Briand , Andy Shevchenko , Bartosz Golaszewski , Lee Jones , Sasha Levin +Message-ID: <20251026162528.110183-1-sashal@kernel.org> + +From: Mathieu Dubois-Briand + +[ Upstream commit 553b75d4bfe9264f631d459fe9996744e0672b0e ] + +GPIO controller often have support for IRQ: allow to easily allocate +both gpio-regmap and regmap-irq in one operation. + +Reviewed-by: Andy Shevchenko +Acked-by: Bartosz Golaszewski +Signed-off-by: Mathieu Dubois-Briand +Link: https://lore.kernel.org/r/20250824-mdb-max7360-support-v14-5-435cfda2b1ea@bootlin.com +Signed-off-by: Lee Jones +Stable-dep-of: 2ba5772e530f ("gpio: idio-16: Define fixed direction of the GPIO lines") +Signed-off-by: Sasha Levin +Signed-off-by: Greg Kroah-Hartman +--- + drivers/gpio/gpio-regmap.c | 29 +++++++++++++++++++++++++++-- + include/linux/gpio/regmap.h | 11 +++++++++++ + 2 files changed, 38 insertions(+), 2 deletions(-) + +--- a/drivers/gpio/gpio-regmap.c ++++ b/drivers/gpio/gpio-regmap.c +@@ -32,6 +32,11 @@ struct gpio_regmap { + unsigned int reg_dir_in_base; + unsigned int reg_dir_out_base; + ++#ifdef CONFIG_REGMAP_IRQ ++ int regmap_irq_line; ++ struct regmap_irq_chip_data *irq_chip_data; ++#endif ++ + int (*reg_mask_xlate)(struct gpio_regmap *gpio, unsigned int base, + unsigned int offset, unsigned int *reg, + unsigned int *mask); +@@ -215,6 +220,7 @@ EXPORT_SYMBOL_GPL(gpio_regmap_get_drvdat + */ + struct gpio_regmap *gpio_regmap_register(const struct gpio_regmap_config *config) + { ++ struct irq_domain *irq_domain; + struct gpio_regmap *gpio; + struct gpio_chip *chip; + int ret; +@@ -295,8 +301,22 @@ struct gpio_regmap *gpio_regmap_register + if (ret < 0) + goto err_free_gpio; + +- if (config->irq_domain) { +- ret = gpiochip_irqchip_add_domain(chip, config->irq_domain); ++#ifdef CONFIG_REGMAP_IRQ ++ if (config->regmap_irq_chip) { ++ gpio->regmap_irq_line = config->regmap_irq_line; ++ ret = regmap_add_irq_chip_fwnode(dev_fwnode(config->parent), config->regmap, ++ config->regmap_irq_line, config->regmap_irq_flags, ++ 0, config->regmap_irq_chip, &gpio->irq_chip_data); ++ if (ret) ++ goto err_free_gpio; ++ ++ irq_domain = regmap_irq_get_domain(gpio->irq_chip_data); ++ } else ++#endif ++ irq_domain = config->irq_domain; ++ ++ if (irq_domain) { ++ ret = gpiochip_irqchip_add_domain(chip, irq_domain); + if (ret) + goto err_remove_gpiochip; + } +@@ -317,6 +337,11 @@ EXPORT_SYMBOL_GPL(gpio_regmap_register); + */ + void gpio_regmap_unregister(struct gpio_regmap *gpio) + { ++#ifdef CONFIG_REGMAP_IRQ ++ if (gpio->irq_chip_data) ++ regmap_del_irq_chip(gpio->regmap_irq_line, gpio->irq_chip_data); ++#endif ++ + gpiochip_remove(&gpio->gpio_chip); + kfree(gpio); + } +--- a/include/linux/gpio/regmap.h ++++ b/include/linux/gpio/regmap.h +@@ -40,6 +40,11 @@ struct regmap; + * @drvdata: (Optional) Pointer to driver specific data which is + * not used by gpio-remap but is provided "as is" to the + * driver callback(s). ++ * @regmap_irq_chip: (Optional) Pointer on an regmap_irq_chip structure. If ++ * set, a regmap-irq device will be created and the IRQ ++ * domain will be set accordingly. ++ * @regmap_irq_line (Optional) The IRQ the device uses to signal interrupts. ++ * @regmap_irq_flags (Optional) The IRQF_ flags to use for the interrupt. + * + * The ->reg_mask_xlate translates a given base address and GPIO offset to + * register and mask pair. The base address is one of the given register +@@ -78,6 +83,12 @@ struct gpio_regmap_config { + int ngpio_per_reg; + struct irq_domain *irq_domain; + ++#ifdef CONFIG_REGMAP_IRQ ++ struct regmap_irq_chip *regmap_irq_chip; ++ int regmap_irq_line; ++ unsigned long regmap_irq_flags; ++#endif ++ + int (*reg_mask_xlate)(struct gpio_regmap *gpio, unsigned int base, + unsigned int offset, unsigned int *reg, + unsigned int *mask); diff --git a/queue-6.17/mm-migrate-remove-migratepage_unmap.patch b/queue-6.17/mm-migrate-remove-migratepage_unmap.patch new file mode 100644 index 0000000000..6009db6dbd --- /dev/null +++ b/queue-6.17/mm-migrate-remove-migratepage_unmap.patch @@ -0,0 +1,180 @@ +From stable+bounces-189898-greg=kroah.com@vger.kernel.org Mon Oct 27 00:52:49 2025 +From: Sasha Levin +Date: Sun, 26 Oct 2025 19:50:26 -0400 +Subject: mm/migrate: remove MIGRATEPAGE_UNMAP +To: stable@vger.kernel.org +Cc: "David Hildenbrand" , "Zi Yan" , "Lance Yang" , "Alistair Popple" , "Al Viro" , "Arnd Bergmann" , "Benjamin LaHaise" , "Byungchul Park" , "Chris Mason" , "Christian Brauner" , "Christophe Leroy" , "Dave Kleikamp" , "David Sterba" , "Eugenio Pé rez" , "Greg Kroah-Hartman" , "Gregory Price" , "Huang, Ying" , "Jan Kara" , "Jason Wang" , "Jerrin Shaji George" , "Josef Bacik" , "Joshua Hahn" , "Madhavan Srinivasan" , "Mathew Brost" , "Michael Ellerman" , "Michael S. Tsirkin" , "Minchan Kim" , "Muchun Song" , "Nicholas Piggin" , "Oscar Salvador" , "Rakie Kim" , "Sergey Senozhatsky" , "Xuan Zhuo" , "Dave Kleikamp" , "Andrew Morton" , "Sasha Levin" +Message-ID: <20251026235028.289288-1-sashal@kernel.org> + +From: David Hildenbrand + +[ Upstream commit 95c2908f1a4fd608b1cdbb5acef3572e5d769e1c ] + +migrate_folio_unmap() is the only user of MIGRATEPAGE_UNMAP. We want to +remove MIGRATEPAGE_* completely. + +It's rather weird to have a generic MIGRATEPAGE_UNMAP, documented to be +returned from address-space callbacks, when it's only used for an internal +helper. + +Let's start by having only a single "success" return value for +migrate_folio_unmap() -- 0 -- by moving the "folio was already freed" +check into the single caller. + +There is a remaining comment for PG_isolated, which we renamed to +PG_movable_ops_isolated recently and forgot to update. + +While we might still run into that case with zsmalloc, it's something we +want to get rid of soon. So let's just focus that optimization on real +folios only for now by excluding movable_ops pages. Note that concurrent +freeing can happen at any time and this "already freed" check is not +relevant for correctness. + +[david@redhat.com: no need to pass "reason" to migrate_folio_unmap(), per Lance] + Link: https://lkml.kernel.org/r/3bb725f8-28d7-4aa2-b75f-af40d5cab280@redhat.com +Link: https://lkml.kernel.org/r/20250811143949.1117439-2-david@redhat.com +Signed-off-by: David Hildenbrand +Reviewed-by: Zi Yan +Reviewed-by: Lance Yang +Cc: Alistair Popple +Cc: Al Viro +Cc: Arnd Bergmann +Cc: Benjamin LaHaise +Cc: Byungchul Park +Cc: Chris Mason +Cc: Christian Brauner +Cc: Christophe Leroy +Cc: Dave Kleikamp +Cc: David Sterba +Cc: Eugenio Pé rez +Cc: Greg Kroah-Hartman +Cc: Gregory Price +Cc: "Huang, Ying" +Cc: Jan Kara +Cc: Jason Wang +Cc: Jerrin Shaji George +Cc: Josef Bacik +Cc: Joshua Hahn +Cc: Madhavan Srinivasan +Cc: Mathew Brost +Cc: Michael Ellerman +Cc: "Michael S. Tsirkin" +Cc: Minchan Kim +Cc: Muchun Song +Cc: Nicholas Piggin +Cc: Oscar Salvador +Cc: Rakie Kim +Cc: Sergey Senozhatsky +Cc: Xuan Zhuo +Cc: Dave Kleikamp +Signed-off-by: Andrew Morton +Stable-dep-of: 4ba5a8a7faa6 ("vmw_balloon: indicate success when effectively deflating during migration") +Signed-off-by: Sasha Levin +Signed-off-by: Greg Kroah-Hartman +--- + include/linux/migrate.h | 1 - + mm/migrate.c | 45 ++++++++++++++++++++++----------------------- + 2 files changed, 22 insertions(+), 24 deletions(-) + +--- a/include/linux/migrate.h ++++ b/include/linux/migrate.h +@@ -18,7 +18,6 @@ struct migration_target_control; + * - zero on page migration success; + */ + #define MIGRATEPAGE_SUCCESS 0 +-#define MIGRATEPAGE_UNMAP 1 + + /** + * struct movable_operations - Driver page migration +--- a/mm/migrate.c ++++ b/mm/migrate.c +@@ -1189,7 +1189,7 @@ static void migrate_folio_done(struct fo + static int migrate_folio_unmap(new_folio_t get_new_folio, + free_folio_t put_new_folio, unsigned long private, + struct folio *src, struct folio **dstp, enum migrate_mode mode, +- enum migrate_reason reason, struct list_head *ret) ++ struct list_head *ret) + { + struct folio *dst; + int rc = -EAGAIN; +@@ -1198,16 +1198,6 @@ static int migrate_folio_unmap(new_folio + bool locked = false; + bool dst_locked = false; + +- if (folio_ref_count(src) == 1) { +- /* Folio was freed from under us. So we are done. */ +- folio_clear_active(src); +- folio_clear_unevictable(src); +- /* free_pages_prepare() will clear PG_isolated. */ +- list_del(&src->lru); +- migrate_folio_done(src, reason); +- return MIGRATEPAGE_SUCCESS; +- } +- + dst = get_new_folio(src, private); + if (!dst) + return -ENOMEM; +@@ -1297,7 +1287,7 @@ static int migrate_folio_unmap(new_folio + + if (unlikely(page_has_movable_ops(&src->page))) { + __migrate_folio_record(dst, old_page_state, anon_vma); +- return MIGRATEPAGE_UNMAP; ++ return 0; + } + + /* +@@ -1327,7 +1317,7 @@ static int migrate_folio_unmap(new_folio + + if (!folio_mapped(src)) { + __migrate_folio_record(dst, old_page_state, anon_vma); +- return MIGRATEPAGE_UNMAP; ++ return 0; + } + + out: +@@ -1870,14 +1860,27 @@ static int migrate_pages_batch(struct li + continue; + } + ++ /* ++ * If we are holding the last folio reference, the folio ++ * was freed from under us, so just drop our reference. ++ */ ++ if (likely(!page_has_movable_ops(&folio->page)) && ++ folio_ref_count(folio) == 1) { ++ folio_clear_active(folio); ++ folio_clear_unevictable(folio); ++ list_del(&folio->lru); ++ migrate_folio_done(folio, reason); ++ stats->nr_succeeded += nr_pages; ++ stats->nr_thp_succeeded += is_thp; ++ continue; ++ } ++ + rc = migrate_folio_unmap(get_new_folio, put_new_folio, +- private, folio, &dst, mode, reason, +- ret_folios); ++ private, folio, &dst, mode, ret_folios); + /* + * The rules are: +- * Success: folio will be freed +- * Unmap: folio will be put on unmap_folios list, +- * dst folio put on dst_folios list ++ * 0: folio will be put on unmap_folios list, ++ * dst folio put on dst_folios list + * -EAGAIN: stay on the from list + * -ENOMEM: stay on the from list + * Other errno: put on ret_folios list +@@ -1927,11 +1930,7 @@ static int migrate_pages_batch(struct li + thp_retry += is_thp; + nr_retry_pages += nr_pages; + break; +- case MIGRATEPAGE_SUCCESS: +- stats->nr_succeeded += nr_pages; +- stats->nr_thp_succeeded += is_thp; +- break; +- case MIGRATEPAGE_UNMAP: ++ case 0: + list_move_tail(&folio->lru, &unmap_folios); + list_add_tail(&dst->lru, &dst_folios); + break; diff --git a/queue-6.17/series b/queue-6.17/series index 44480507fe..948766ad0d 100644 --- a/queue-6.17/series +++ b/queue-6.17/series @@ -175,3 +175,10 @@ staging-gpib-fix-device-reference-leak-in-fmh_gpib-driver.patch staging-gpib-fix-no-eoi-on-1-and-2-byte-writes.patch staging-gpib-return-eintr-on-device-clear.patch staging-gpib-fix-sending-clear-and-trigger-events.patch +mm-migrate-remove-migratepage_unmap.patch +treewide-remove-migratepage_success.patch +vmw_balloon-indicate-success-when-effectively-deflating-during-migration.patch +xfs-always-warn-about-deprecated-mount-options.patch +gpio-regmap-allow-to-allocate-regmap-irq-device.patch +gpio-regmap-add-the-.fixed_direction_output-configuration-parameter.patch +gpio-idio-16-define-fixed-direction-of-the-gpio-lines.patch diff --git a/queue-6.17/treewide-remove-migratepage_success.patch b/queue-6.17/treewide-remove-migratepage_success.patch new file mode 100644 index 0000000000..529069eb0e --- /dev/null +++ b/queue-6.17/treewide-remove-migratepage_success.patch @@ -0,0 +1,428 @@ +From stable+bounces-189899-greg=kroah.com@vger.kernel.org Mon Oct 27 00:50:43 2025 +From: Sasha Levin +Date: Sun, 26 Oct 2025 19:50:27 -0400 +Subject: treewide: remove MIGRATEPAGE_SUCCESS +To: stable@vger.kernel.org +Cc: "David Hildenbrand" , "Zi Yan" , "Dave Kleikamp" , "David Sterba" , "Greg Kroah-Hartman" , "Byungchul Park" , "Alistair Popple" , "Al Viro" , "Arnd Bergmann" , "Benjamin LaHaise" , "Chris Mason" , "Christian Brauner" , "Christophe Leroy" , "Dave Kleikamp" , "Eugenio Pé rez" , "Gregory Price" , "Huang, Ying" , "Jan Kara" , "Jason Wang" , "Jerrin Shaji George" , "Josef Bacik" , "Joshua Hahn" , "Madhavan Srinivasan" , "Mathew Brost" , "Michael Ellerman" , "Michael S. Tsirkin" , "Minchan Kim" , "Muchun Song" , "Nicholas Piggin" , "Oscar Salvador" , "Rakie Kim" , "Sergey Senozhatsky" , "Xuan Zhuo" , "Lance Yang" , "Andrew Morton" , "Sasha Levin" +Message-ID: <20251026235028.289288-2-sashal@kernel.org> + +From: David Hildenbrand + +[ Upstream commit fb49a4425cfa163faccd91f913773d3401d3a7d4 ] + +At this point MIGRATEPAGE_SUCCESS is misnamed for all folio users, +and now that we remove MIGRATEPAGE_UNMAP, it's really the only "success" +return value that the code uses and expects. + +Let's just get rid of MIGRATEPAGE_SUCCESS completely and just use "0" +for success. + +Link: https://lkml.kernel.org/r/20250811143949.1117439-3-david@redhat.com +Signed-off-by: David Hildenbrand +Reviewed-by: Zi Yan [mm] +Acked-by: Dave Kleikamp [jfs] +Acked-by: David Sterba [btrfs] +Acked-by: Greg Kroah-Hartman +Reviewed-by: Byungchul Park +Cc: Alistair Popple +Cc: Al Viro +Cc: Arnd Bergmann +Cc: Benjamin LaHaise +Cc: Chris Mason +Cc: Christian Brauner +Cc: Christophe Leroy +Cc: Dave Kleikamp +Cc: Eugenio Pé rez +Cc: Gregory Price +Cc: "Huang, Ying" +Cc: Jan Kara +Cc: Jason Wang +Cc: Jerrin Shaji George +Cc: Josef Bacik +Cc: Joshua Hahn +Cc: Madhavan Srinivasan +Cc: Mathew Brost +Cc: Michael Ellerman +Cc: "Michael S. Tsirkin" +Cc: Minchan Kim +Cc: Muchun Song +Cc: Nicholas Piggin +Cc: Oscar Salvador +Cc: Rakie Kim +Cc: Sergey Senozhatsky +Cc: Xuan Zhuo +Cc: Lance Yang +Signed-off-by: Andrew Morton +Stable-dep-of: 4ba5a8a7faa6 ("vmw_balloon: indicate success when effectively deflating during migration") +Signed-off-by: Sasha Levin +Signed-off-by: Greg Kroah-Hartman +--- + arch/powerpc/platforms/pseries/cmm.c | 2 - + drivers/misc/vmw_balloon.c | 4 +-- + drivers/virtio/virtio_balloon.c | 2 - + fs/aio.c | 2 - + fs/btrfs/inode.c | 4 +-- + fs/hugetlbfs/inode.c | 4 +-- + fs/jfs/jfs_metapage.c | 8 +++---- + include/linux/migrate.h | 10 -------- + mm/migrate.c | 40 ++++++++++++++++------------------- + mm/migrate_device.c | 2 - + mm/zsmalloc.c | 4 +-- + 11 files changed, 36 insertions(+), 46 deletions(-) + +--- a/arch/powerpc/platforms/pseries/cmm.c ++++ b/arch/powerpc/platforms/pseries/cmm.c +@@ -545,7 +545,7 @@ static int cmm_migratepage(struct balloo + /* balloon page list reference */ + put_page(page); + +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + + static void cmm_balloon_compaction_init(void) +--- a/drivers/misc/vmw_balloon.c ++++ b/drivers/misc/vmw_balloon.c +@@ -1806,7 +1806,7 @@ static int vmballoon_migratepage(struct + * the list after acquiring the lock. + */ + get_page(newpage); +- ret = MIGRATEPAGE_SUCCESS; ++ ret = 0; + } + + /* Update the balloon list under the @pages_lock */ +@@ -1817,7 +1817,7 @@ static int vmballoon_migratepage(struct + * If we succeed just insert it to the list and update the statistics + * under the lock. + */ +- if (ret == MIGRATEPAGE_SUCCESS) { ++ if (!ret) { + balloon_page_insert(&b->b_dev_info, newpage); + __count_vm_event(BALLOON_MIGRATE); + } +--- a/drivers/virtio/virtio_balloon.c ++++ b/drivers/virtio/virtio_balloon.c +@@ -875,7 +875,7 @@ static int virtballoon_migratepage(struc + balloon_page_finalize(page); + put_page(page); /* balloon reference */ + +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + #endif /* CONFIG_BALLOON_COMPACTION */ + +--- a/fs/aio.c ++++ b/fs/aio.c +@@ -445,7 +445,7 @@ static int aio_migrate_folio(struct addr + folio_get(dst); + + rc = folio_migrate_mapping(mapping, dst, src, 1); +- if (rc != MIGRATEPAGE_SUCCESS) { ++ if (rc) { + folio_put(dst); + goto out_unlock; + } +--- a/fs/btrfs/inode.c ++++ b/fs/btrfs/inode.c +@@ -7430,7 +7430,7 @@ static int btrfs_migrate_folio(struct ad + { + int ret = filemap_migrate_folio(mapping, dst, src, mode); + +- if (ret != MIGRATEPAGE_SUCCESS) ++ if (ret) + return ret; + + if (folio_test_ordered(src)) { +@@ -7438,7 +7438,7 @@ static int btrfs_migrate_folio(struct ad + folio_set_ordered(dst); + } + +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + #else + #define btrfs_migrate_folio NULL +--- a/fs/hugetlbfs/inode.c ++++ b/fs/hugetlbfs/inode.c +@@ -1054,7 +1054,7 @@ static int hugetlbfs_migrate_folio(struc + int rc; + + rc = migrate_huge_page_move_mapping(mapping, dst, src); +- if (rc != MIGRATEPAGE_SUCCESS) ++ if (rc) + return rc; + + if (hugetlb_folio_subpool(src)) { +@@ -1065,7 +1065,7 @@ static int hugetlbfs_migrate_folio(struc + + folio_migrate_flags(dst, src); + +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + #else + #define hugetlbfs_migrate_folio NULL +--- a/fs/jfs/jfs_metapage.c ++++ b/fs/jfs/jfs_metapage.c +@@ -169,7 +169,7 @@ static int __metapage_migrate_folio(stru + } + + rc = filemap_migrate_folio(mapping, dst, src, mode); +- if (rc != MIGRATEPAGE_SUCCESS) ++ if (rc) + return rc; + + for (i = 0; i < MPS_PER_PAGE; i++) { +@@ -199,7 +199,7 @@ static int __metapage_migrate_folio(stru + } + } + +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + #endif /* CONFIG_MIGRATION */ + +@@ -242,7 +242,7 @@ static int __metapage_migrate_folio(stru + return -EAGAIN; + + rc = filemap_migrate_folio(mapping, dst, src, mode); +- if (rc != MIGRATEPAGE_SUCCESS) ++ if (rc) + return rc; + + if (unlikely(insert_metapage(dst, mp))) +@@ -253,7 +253,7 @@ static int __metapage_migrate_folio(stru + mp->folio = dst; + remove_metapage(src, mp); + +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + #endif /* CONFIG_MIGRATION */ + +--- a/include/linux/migrate.h ++++ b/include/linux/migrate.h +@@ -12,13 +12,6 @@ typedef void free_folio_t(struct folio * + + struct migration_target_control; + +-/* +- * Return values from addresss_space_operations.migratepage(): +- * - negative errno on page migration failure; +- * - zero on page migration success; +- */ +-#define MIGRATEPAGE_SUCCESS 0 +- + /** + * struct movable_operations - Driver page migration + * @isolate_page: +@@ -34,8 +27,7 @@ struct migration_target_control; + * @src page. The driver should copy the contents of the + * @src page to the @dst page and set up the fields of @dst page. + * Both pages are locked. +- * If page migration is successful, the driver should +- * return MIGRATEPAGE_SUCCESS. ++ * If page migration is successful, the driver should return 0. + * If the driver cannot migrate the page at the moment, it can return + * -EAGAIN. The VM interprets this as a temporary migration failure and + * will retry it later. Any other error value is a permanent migration +--- a/mm/migrate.c ++++ b/mm/migrate.c +@@ -231,18 +231,17 @@ static void putback_movable_ops_page(str + * src and dst are also released by migration core. These pages will not be + * folios in the future, so that must be reworked. + * +- * Returns MIGRATEPAGE_SUCCESS on success, otherwise a negative error +- * code. ++ * Returns 0 on success, otherwise a negative error code. + */ + static int migrate_movable_ops_page(struct page *dst, struct page *src, + enum migrate_mode mode) + { +- int rc = MIGRATEPAGE_SUCCESS; ++ int rc; + + VM_WARN_ON_ONCE_PAGE(!page_has_movable_ops(src), src); + VM_WARN_ON_ONCE_PAGE(!PageMovableOpsIsolated(src), src); + rc = page_movable_ops(src)->migrate_page(dst, src, mode); +- if (rc == MIGRATEPAGE_SUCCESS) ++ if (!rc) + ClearPageMovableOpsIsolated(src); + return rc; + } +@@ -587,7 +586,7 @@ static int __folio_migrate_mapping(struc + if (folio_test_swapbacked(folio)) + __folio_set_swapbacked(newfolio); + +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + + oldzone = folio_zone(folio); +@@ -688,7 +687,7 @@ static int __folio_migrate_mapping(struc + } + local_irq_enable(); + +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + + int folio_migrate_mapping(struct address_space *mapping, +@@ -737,7 +736,7 @@ int migrate_huge_page_move_mapping(struc + + xas_unlock_irq(&xas); + +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + + /* +@@ -853,14 +852,14 @@ static int __migrate_folio(struct addres + return rc; + + rc = __folio_migrate_mapping(mapping, dst, src, expected_count); +- if (rc != MIGRATEPAGE_SUCCESS) ++ if (rc) + return rc; + + if (src_private) + folio_attach_private(dst, folio_detach_private(src)); + + folio_migrate_flags(dst, src); +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + + /** +@@ -967,7 +966,7 @@ recheck_buffers: + } + + rc = filemap_migrate_folio(mapping, dst, src, mode); +- if (rc != MIGRATEPAGE_SUCCESS) ++ if (rc) + goto unlock_buffers; + + bh = head; +@@ -1071,7 +1070,7 @@ static int fallback_migrate_folio(struct + * + * Return value: + * < 0 - error code +- * MIGRATEPAGE_SUCCESS - success ++ * 0 - success + */ + static int move_to_new_folio(struct folio *dst, struct folio *src, + enum migrate_mode mode) +@@ -1099,7 +1098,7 @@ static int move_to_new_folio(struct foli + else + rc = fallback_migrate_folio(mapping, dst, src, mode); + +- if (rc == MIGRATEPAGE_SUCCESS) { ++ if (!rc) { + /* + * For pagecache folios, src->mapping must be cleared before src + * is freed. Anonymous folios must stay anonymous until freed. +@@ -1449,7 +1448,7 @@ static int unmap_and_move_huge_page(new_ + if (folio_ref_count(src) == 1) { + /* page was freed from under us. So we are done. */ + folio_putback_hugetlb(src); +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + + dst = get_new_folio(src, private); +@@ -1512,8 +1511,7 @@ static int unmap_and_move_huge_page(new_ + rc = move_to_new_folio(dst, src, mode); + + if (page_was_mapped) +- remove_migration_ptes(src, +- rc == MIGRATEPAGE_SUCCESS ? dst : src, 0); ++ remove_migration_ptes(src, !rc ? dst : src, 0); + + unlock_put_anon: + folio_unlock(dst); +@@ -1522,7 +1520,7 @@ put_anon: + if (anon_vma) + put_anon_vma(anon_vma); + +- if (rc == MIGRATEPAGE_SUCCESS) { ++ if (!rc) { + move_hugetlb_state(src, dst, reason); + put_new_folio = NULL; + } +@@ -1530,7 +1528,7 @@ put_anon: + out_unlock: + folio_unlock(src); + out: +- if (rc == MIGRATEPAGE_SUCCESS) ++ if (!rc) + folio_putback_hugetlb(src); + else if (rc != -EAGAIN) + list_move_tail(&src->lru, ret); +@@ -1640,7 +1638,7 @@ static int migrate_hugetlbs(struct list_ + reason, ret_folios); + /* + * The rules are: +- * Success: hugetlb folio will be put back ++ * 0: hugetlb folio will be put back + * -EAGAIN: stay on the from list + * -ENOMEM: stay on the from list + * Other errno: put on ret_folios list +@@ -1657,7 +1655,7 @@ static int migrate_hugetlbs(struct list_ + retry++; + nr_retry_pages += nr_pages; + break; +- case MIGRATEPAGE_SUCCESS: ++ case 0: + stats->nr_succeeded += nr_pages; + break; + default: +@@ -1711,7 +1709,7 @@ static void migrate_folios_move(struct l + reason, ret_folios); + /* + * The rules are: +- * Success: folio will be freed ++ * 0: folio will be freed + * -EAGAIN: stay on the unmap_folios list + * Other errno: put on ret_folios list + */ +@@ -1721,7 +1719,7 @@ static void migrate_folios_move(struct l + *thp_retry += is_thp; + *nr_retry_pages += nr_pages; + break; +- case MIGRATEPAGE_SUCCESS: ++ case 0: + stats->nr_succeeded += nr_pages; + stats->nr_thp_succeeded += is_thp; + break; +--- a/mm/migrate_device.c ++++ b/mm/migrate_device.c +@@ -778,7 +778,7 @@ static void __migrate_device_pages(unsig + if (migrate && migrate->fault_page == page) + extra_cnt = 1; + r = folio_migrate_mapping(mapping, newfolio, folio, extra_cnt); +- if (r != MIGRATEPAGE_SUCCESS) ++ if (r) + src_pfns[i] &= ~MIGRATE_PFN_MIGRATE; + else + folio_migrate_flags(newfolio, folio); +--- a/mm/zsmalloc.c ++++ b/mm/zsmalloc.c +@@ -1746,7 +1746,7 @@ static int zs_page_migrate(struct page * + * instead. + */ + if (!zpdesc->zspage) +- return MIGRATEPAGE_SUCCESS; ++ return 0; + + /* The page is locked, so this pointer must remain valid */ + zspage = get_zspage(zpdesc); +@@ -1813,7 +1813,7 @@ static int zs_page_migrate(struct page * + reset_zpdesc(zpdesc); + zpdesc_put(zpdesc); + +- return MIGRATEPAGE_SUCCESS; ++ return 0; + } + + static void zs_page_putback(struct page *page) diff --git a/queue-6.17/vmw_balloon-indicate-success-when-effectively-deflating-during-migration.patch b/queue-6.17/vmw_balloon-indicate-success-when-effectively-deflating-during-migration.patch new file mode 100644 index 0000000000..de35054d3b --- /dev/null +++ b/queue-6.17/vmw_balloon-indicate-success-when-effectively-deflating-during-migration.patch @@ -0,0 +1,95 @@ +From stable+bounces-189900-greg=kroah.com@vger.kernel.org Mon Oct 27 00:50:43 2025 +From: Sasha Levin +Date: Sun, 26 Oct 2025 19:50:28 -0400 +Subject: vmw_balloon: indicate success when effectively deflating during migration +To: stable@vger.kernel.org +Cc: David Hildenbrand , Jerrin Shaji George , Broadcom internal kernel review list , Arnd Bergmann , Greg Kroah-Hartman , Andrew Morton , Sasha Levin +Message-ID: <20251026235028.289288-3-sashal@kernel.org> + +From: David Hildenbrand + +[ Upstream commit 4ba5a8a7faa647ada8eae61a36517cf369f5bbe4 ] + +When migrating a balloon page, we first deflate the old page to then +inflate the new page. + +However, if inflating the new page succeeded, we effectively deflated the +old page, reducing the balloon size. + +In that case, the migration actually worked: similar to migrating+ +immediately deflating the new page. The old page will be freed back to +the buddy. + +Right now, the core will leave the page be marked as isolated (as we +returned an error). When later trying to putback that page, we will run +into the WARN_ON_ONCE() in balloon_page_putback(). + +That handling was changed in commit 3544c4faccb8 ("mm/balloon_compaction: +stop using __ClearPageMovable()"); before that change, we would have +tolerated that way of handling it. + +To fix it, let's just return 0 in that case, making the core effectively +just clear the "isolated" flag + freeing it back to the buddy as if the +migration succeeded. Note that the new page will also get freed when the +core puts the last reference. + +Note that this also makes it all be more consistent: we will no longer +unisolate the page in the balloon driver while keeping it marked as being +isolated in migration core. + +This was found by code inspection. + +Link: https://lkml.kernel.org/r/20251014124455.478345-1-david@redhat.com +Fixes: 3544c4faccb8 ("mm/balloon_compaction: stop using __ClearPageMovable()") +Signed-off-by: David Hildenbrand +Cc: Jerrin Shaji George +Cc: Broadcom internal kernel review list +Cc: Arnd Bergmann +Cc: Greg Kroah-Hartman +Cc: +Signed-off-by: Andrew Morton +Signed-off-by: Sasha Levin +Signed-off-by: Greg Kroah-Hartman +--- + drivers/misc/vmw_balloon.c | 8 +++----- + 1 file changed, 3 insertions(+), 5 deletions(-) + +--- a/drivers/misc/vmw_balloon.c ++++ b/drivers/misc/vmw_balloon.c +@@ -1737,7 +1737,7 @@ static int vmballoon_migratepage(struct + { + unsigned long status, flags; + struct vmballoon *b; +- int ret; ++ int ret = 0; + + b = container_of(b_dev_info, struct vmballoon, b_dev_info); + +@@ -1796,17 +1796,15 @@ static int vmballoon_migratepage(struct + * A failure happened. While we can deflate the page we just + * inflated, this deflation can also encounter an error. Instead + * we will decrease the size of the balloon to reflect the +- * change and report failure. ++ * change. + */ + atomic64_dec(&b->size); +- ret = -EBUSY; + } else { + /* + * Success. Take a reference for the page, and we will add it to + * the list after acquiring the lock. + */ + get_page(newpage); +- ret = 0; + } + + /* Update the balloon list under the @pages_lock */ +@@ -1817,7 +1815,7 @@ static int vmballoon_migratepage(struct + * If we succeed just insert it to the list and update the statistics + * under the lock. + */ +- if (!ret) { ++ if (status == VMW_BALLOON_SUCCESS) { + balloon_page_insert(&b->b_dev_info, newpage); + __count_vm_event(BALLOON_MIGRATE); + } diff --git a/queue-6.17/xfs-always-warn-about-deprecated-mount-options.patch b/queue-6.17/xfs-always-warn-about-deprecated-mount-options.patch new file mode 100644 index 0000000000..543bf4b7a4 --- /dev/null +++ b/queue-6.17/xfs-always-warn-about-deprecated-mount-options.patch @@ -0,0 +1,93 @@ +From stable+bounces-189879-greg=kroah.com@vger.kernel.org Sun Oct 26 18:40:13 2025 +From: Sasha Levin +Date: Sun, 26 Oct 2025 13:40:05 -0400 +Subject: xfs: always warn about deprecated mount options +To: stable@vger.kernel.org +Cc: "Darrick J. Wong" , Christoph Hellwig , Carlos Maiolino , Carlos Maiolino , Sasha Levin +Message-ID: <20251026174005.165056-1-sashal@kernel.org> + +From: "Darrick J. Wong" + +[ Upstream commit 630785bfbe12c3ee3ebccd8b530a98d632b7e39d ] + +The deprecation of the 'attr2' mount option in 6.18 wasn't entirely +successful because nobody noticed that the kernel never printed a +warning about attr2 being set in fstab if the only xfs filesystem is the +root fs; the initramfs mounts the root fs with no mount options; and the +init scripts only conveyed the fstab options by remounting the root fs. + +Fix this by making it complain all the time. + +Cc: stable@vger.kernel.org # v5.13 +Fixes: 92cf7d36384b99 ("xfs: Skip repetitive warnings about mount options") +Signed-off-by: Darrick J. Wong +Reviewed-by: Christoph Hellwig +Reviewed-by: Carlos Maiolino +Signed-off-by: Carlos Maiolino +[ Update existing xfs_fs_warn_deprecated() callers ] +Signed-off-by: Sasha Levin +Signed-off-by: Greg Kroah-Hartman +--- + fs/xfs/xfs_super.c | 33 +++++++++++++++++++++------------ + 1 file changed, 21 insertions(+), 12 deletions(-) + +--- a/fs/xfs/xfs_super.c ++++ b/fs/xfs/xfs_super.c +@@ -1386,16 +1386,25 @@ suffix_kstrtoull( + static inline void + xfs_fs_warn_deprecated( + struct fs_context *fc, +- struct fs_parameter *param, +- uint64_t flag, +- bool value) ++ struct fs_parameter *param) + { +- /* Don't print the warning if reconfiguring and current mount point +- * already had the flag set ++ /* ++ * Always warn about someone passing in a deprecated mount option. ++ * Previously we wouldn't print the warning if we were reconfiguring ++ * and current mount point already had the flag set, but that was not ++ * the right thing to do. ++ * ++ * Many distributions mount the root filesystem with no options in the ++ * initramfs and rely on mount -a to remount the root fs with the ++ * options in fstab. However, the old behavior meant that there would ++ * never be a warning about deprecated mount options for the root fs in ++ * /etc/fstab. On a single-fs system, that means no warning at all. ++ * ++ * Compounding this problem are distribution scripts that copy ++ * /proc/mounts to fstab, which means that we can't remove mount ++ * options unless we're 100% sure they have only ever been advertised ++ * in /proc/mounts in response to explicitly provided mount options. + */ +- if ((fc->purpose & FS_CONTEXT_FOR_RECONFIGURE) && +- !!(XFS_M(fc->root->d_sb)->m_features & flag) == value) +- return; + xfs_warn(fc->s_fs_info, "%s mount option is deprecated.", param->key); + } + +@@ -1543,19 +1552,19 @@ xfs_fs_parse_param( + #endif + /* Following mount options will be removed in September 2025 */ + case Opt_ikeep: +- xfs_fs_warn_deprecated(fc, param, XFS_FEAT_IKEEP, true); ++ xfs_fs_warn_deprecated(fc, param); + parsing_mp->m_features |= XFS_FEAT_IKEEP; + return 0; + case Opt_noikeep: +- xfs_fs_warn_deprecated(fc, param, XFS_FEAT_IKEEP, false); ++ xfs_fs_warn_deprecated(fc, param); + parsing_mp->m_features &= ~XFS_FEAT_IKEEP; + return 0; + case Opt_attr2: +- xfs_fs_warn_deprecated(fc, param, XFS_FEAT_ATTR2, true); ++ xfs_fs_warn_deprecated(fc, param); + parsing_mp->m_features |= XFS_FEAT_ATTR2; + return 0; + case Opt_noattr2: +- xfs_fs_warn_deprecated(fc, param, XFS_FEAT_NOATTR2, true); ++ xfs_fs_warn_deprecated(fc, param); + parsing_mp->m_features |= XFS_FEAT_NOATTR2; + return 0; + case Opt_max_open_zones: