regmap: Allocate buffers with GFP_ATOMIC when fast_io == true
Subsystems (2)
PATCH 1/1 regmap: Allocate buffers with GFP_ATOMIC when fast_io == true
If a regmap is using fast_io, allocate buffers in the write APIs with GFP_ATOMIC instead of GFP_KERNEL. Otherwise we may schedule while atomic.
--- drivers/base/regmap/internal.h | 1 + drivers/base/regmap/regmap.c | 16 +++++++++++----- 2 files changed, 12 insertions(+), 5 deletions(-)
drivers/base/regmap/internal.h +1 -0
@@ -59,6 +59,7 @@ struct regmap {regmap_lock lock;regmap_unlock unlock;void *lock_arg;/* This is passed to lock/unlock functions */ +gfp_t alloc_flags;struct device *dev;/* Device we do I/O on */ void *work_buf;/* Scratch buffer used to format I/O */
drivers/base/regmap/regmap.c +11 -5
@@ -563,6 +563,12 @@ struct regmap *regmap_init(struct device *dev, } map->lock_arg = map; } + +if ((bus && bus->fast_io) || config->fast_io) + map->alloc_flags =GFP_ATOMIC ; +else + map->alloc_flags =GFP_KERNEL ; + map->format.reg_bytes =DIV_ROUND_UP (config->reg_bits,8 ); map->format.pad_bytes = config->pad_bits /8 ; map->format.val_bytes =DIV_ROUND_UP (config->val_bits,8 );
@@ -1296,7 +1302,7 @@ int _regmap_raw_write(struct regmap *map, unsigned int reg,return -ENOMEM ; async->work_buf =kzalloc (map->format.buf_size, -GFP_KERNEL |GFP_DMA ); + map->alloc_flags |GFP_DMA );if (!async->work_buf) {kfree (async);return -ENOMEM ;
@@ -1358,7 +1364,7 @@ int _regmap_raw_write(struct regmap *map, unsigned int reg,/* If that didn't work fall back on linearising by hand. */ if (ret == -ENOTSUPP ) { len = map->format.reg_bytes + map->format.pad_bytes + val_len; - buf =kzalloc (len,GFP_KERNEL ); + buf =kzalloc (len, map->alloc_flags);if (!buf)return -ENOMEM ;
@@ -1729,7 +1735,7 @@ out:if (!val_count)return -EINVAL ; - wval =kmemdup (val, val_count * val_bytes,GFP_KERNEL ); + wval =kmemdup (val, val_count * val_bytes, map->alloc_flags);if (!wval) {dev_err (map->dev,"Error in memory allocation\n" );return -ENOMEM ;
@@ -1771,7 +1777,7 @@ static int _regmap_raw_multi_reg_write(struct regmap *map,if (!len)return -EINVAL ; - buf =kzalloc (len,GFP_KERNEL ); + buf =kzalloc (len, map->alloc_flags);if (!buf)return -ENOMEM ;
@@ -1909,7 +1915,7 @@ static int _regmap_multi_reg_write(struct regmap *map,if (range) {size_t len =sizeof (struct reg_sequence )*num_regs;struct reg_sequence *base =kmemdup (regs, len, -GFP_KERNEL ); + map->alloc_flags);if (!base)return -ENOMEM ; ret = _regmap_range_multi_paged_reg_write(map, base,
Signature · 2 lines
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Mark Brown
maintainerQuoted 3 lines · Stephen Boyd
If a regmap is using
fast_io, allocate buffers in the write APIs withGFP_ATOMICinstead ofGFP_KERNEL. Otherwise we may schedule while atomic.
Why is this needed? If something needs fast I/O it probably doesn't want to be going down any of the code paths that result in us doing allocations. I'd expect either no cache, a flat cache or setting up defaults at initialisation time.
Quoted 9 lines · Mark Brown
Quoted 3 lines · Stephen Boyd
If a regmap is using
fast_io, allocate buffers in the write APIs withGFP_ATOMICinstead ofGFP_KERNEL. Otherwise we may schedule while atomic.Why is this needed? If something needs fast I/O it probably doesn't want to be going down any of the code paths that result in us doing allocations. I'd expect either no cache, a flat cache or setting up defaults at initialisation time.
We tripped over this with regmap_bulk_write() users on the SPMI bus. How about going down the same paths as !map->can_multi_write and map->use_single_rw if fast_io == true? Something like this untested patch.
drivers/base/regmap/regmap.c +2 -2
@@ -573,8 +573,8 @@ struct regmap *regmap_init(struct device *dev, map->reg_stride = config->reg_stride; else map->reg_stride = 1; - map->use_single_rw = config->use_single_rw; - map->can_multi_write = config->can_multi_write; + map->use_single_rw = config->use_single_rw || config->fast_io; + map->can_multi_write = config->can_multi_write && !config->fast_io; map->dev = dev; map->bus = bus; map->bus_context = bus_context;
Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project
Mark Brown
maintainerQuoted 11 lines · Stephen Boyd
Quoted 4 lines · Mark Brown
Why is this needed? If something needs fast I/O it probably doesn't want to be going down any of the code paths that result in us doing allocations. I'd expect either no cache, a flat cache or setting up defaults at initialisation time.
We tripped over this with
regmap_bulk_write()users on the SPMI bus. How about going down the same paths as !map->can_multi_write andmap->use_single_rwiffast_io== true? Something like this untested patch.
Hrm, OK. Bulk writes are a reasonable use case here but we should be able to do better... if we had a cache we could bulk write directly from the cache but I don't think the SPMI devices tend to have caches so that won't help.
drivers/base/regmap/regmap.c struct regmap *regmap_init(struct device *dev, · line 577
Quoted 4 lines
drivers/base/regmap/regmap.c +2
-2- map->use_single_rw = config->use_single_rw; - map->can_multi_write = config->can_multi_write; + map->use_single_rw = config->use_single_rw || config->fast_io; + map->can_multi_write = config->can_multi_write && !config->fast_io;
The trouble with this is that you end up doing register at a time writes which isn't ideal for performance. Unless we can figure out a way to reliably allocate a bigger buffer ahead of time which I can't think of a way to do reliably without just putting a random number in the config (that we then end up either hitting or making too big) I think this is actually a reasonable use case.
Can you redo your patch to touch only the allocations in your data paths (I'm thinking particularly of the async changes as being unneeded, now I look again you didn't touch the cache code anyway) and put a comment in there about the alloc flags being used in fast path cases please?