drm/vkms: Fix crc worker races
Subsystems (12)
Sasha Levin
maintainerPATCH 1/70 drm/vkms: Fix crc worker races
From: Daniel Vetter <[email protected]>
[ Upstream commit 18d0952a838ba559655b0cd9cf85097ad63d9bca ]
The issue we have is that the crc worker might fall behind. We've tried to handle this by tracking both the earliest frame for which it still needs to compute a crc, and the last one. Plus when the crtc_state changes, we have a new work item, which are all run in order due to the ordered workqueue we allocate for each vkms crtc.
Trouble is there's been a few small issues in the current code:
- we need to capture frame_end in the vblank hrtimer, not in the worker. The worker might run much later, and then we generate a lot of crc for which there's already a different worker queued up.
- frame number might be 0, so create a new crc_pending boolean to track this without confusion.
- we need to atomically grab frame_start/end and clear it, so do that all in one go. This is not going to create a new race, because if we race with the hrtimer then our work will be re-run.
- only race that can happen is the following:
1. worker starts
2. hrtimer runs and updates frame_end
3. worker grabs frame_start/end, already reading the new frame_end, and clears crc_pending
4. hrtimer calls queue_work()
5. worker completes
6. worker gets re-run, crc_pending is false
Explain this case a bit better by rewording the comment.
v2: Demote warning level output to debug when we fail to requeue, this is expected under high load when the crc worker can't quite keep up.
--- drivers/gpu/drm/vkms/vkms_crc.c | 27 +++++++++++++-------------- drivers/gpu/drm/vkms/vkms_crtc.c | 9 +++++++-- drivers/gpu/drm/vkms/vkms_drv.h | 2 ++ 3 files changed, 22 insertions(+), 16 deletions(-)
drivers/gpu/drm/vkms/vkms_crc.c +13 -14
@@ -166,16 +166,24 @@ void vkms_crc_work_handle(struct work_struct *work)struct drm_plane *plane;u32 crc32 =0 ;u64 frame_start, frame_end; +bool crc_pending;unsigned long flags;spin_lock_irqsave (&out->state_lock, flags); frame_start = crtc_state->frame_start; frame_end = crtc_state->frame_end; + crc_pending = crtc_state->crc_pending; + crtc_state->frame_start =0 ; + crtc_state->frame_end =0 ; + crtc_state->crc_pending = false;spin_unlock_irqrestore (&out->state_lock, flags); -/* _vblank_handle() hasn't updated frame_start yet */ -if (!frame_start || frame_start == frame_end) - goto out; +/* +* We raced with the vblank hrtimer and previous work already computed +* the crc, nothing to do. +*/ +if (!crc_pending) +return ;drm_for_each_plane (plane, &vdev->drm) {struct vkms_plane_state *vplane_state;
@@ -196,20 +204,11 @@ void vkms_crc_work_handle(struct work_struct *work)if (primary_crc) crc32 =_vkms_get_crc (primary_crc, cursor_crc); - frame_end =drm_crtc_accurate_vblank_count (crtc); - -/* queue_work can fail to schedule crc_work; add crc for -* missing frames +/* +* The worker can fall behind the vblank hrtimer, make sure we catch up. */ while (frame_start <= frame_end)drm_crtc_add_crc_entry (crtc, true, frame_start++, &crc32); - -out: -/* to avoid using the same value for frame number again */ -spin_lock_irqsave (&out->state_lock, flags); - crtc_state->frame_end = frame_end; - crtc_state->frame_start =0 ; -spin_unlock_irqrestore (&out->state_lock, flags); }static int vkms_crc_parse_source (const char *src_name,bool *enabled)
drivers/gpu/drm/vkms/vkms_crtc.c +7 -2
@@ -30,13 +30,18 @@ static enum hrtimer_restart vkms_vblank_simulate(struct hrtimer *timer)* has read the data */ spin_lock (&output->state_lock); -if (!state->frame_start) +if (!state->crc_pending) state->frame_start = frame; +else +DRM_DEBUG_DRIVER ("crc worker falling behind, frame_start: %llu, frame_end: %llu\n" , + state->frame_start, frame); + state->frame_end = frame; + state->crc_pending = true;spin_unlock (&output->state_lock); ret =queue_work (output->crc_workq, &state->crc_work);if (!ret) -DRM_WARN ("failed to queue vkms_crc_work_handle" ); +DRM_DEBUG_DRIVER ("vkms_crc_work_handle already queued\n" ); }spin_unlock (&output->lock);
drivers/gpu/drm/vkms/vkms_drv.h +2 -0
@@ -56,6 +56,8 @@ struct vkms_plane_state {struct vkms_crtc_state {struct drm_crtc_state base;struct work_struct crc_work; + +bool crc_pending;u64 frame_start;u64 frame_end; };
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 2/70 drm/bridge: tc358767: Increase AUX transfer length limit
From: Andrey Smirnov <[email protected]>
[ Upstream commit e0655feaec62d5139b6b13a7b1bbb1ab8f1c2d83 ]
According to the datasheet tc358767 can transfer up to 16 bytes via its AUX channel, so the artificial limit of 8 appears to be too low. However only up to 15-bytes seem to be actually supported and trying to use 16-byte transfers results in transfers failing sporadically (with bogus status in case of I2C transfers), so limit it to 15.
--- drivers/gpu/drm/bridge/tc358767.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/bridge/tc358767.c +1 -1
@@ -293,7 +293,7 @@ static ssize_t tc_aux_transfer(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg) {struct tc_data *tc =aux_to_tc (aux); -size_t size =min_t (size_t,8 , msg->size); +size_t size =min_t (size_t,DP_AUX_MAX_PAYLOAD_BYTES -1 , msg->size);u8 request = msg->request & ~DP_AUX_I2C_MOT ;u8 *buf = msg->buffer;u32 tmp =0 ;
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 3/70 drm/bridge: adv7511: Attach to DSI host at probe time
In reply to Sasha LevinFrom: Matt Redfearn <[email protected]>
[ Upstream commit 83f35bc3a852f1c3892c7474998c5cec707c7ba3 ]
In contrast to all of the DSI panel drivers in drivers/gpu/drm/panel which attach to the DSI host via mipi_dsi_attach() at probe time, the ADV7533 bridge device does not. Instead it defers this to the point that the upstream device connects to its bridge via drm_bridge_attach(). The generic Synopsys MIPI DSI host driver does not register it's own drm_bridge until the MIPI DSI has attached. But it does not call drm_bridge_attach() on the downstream device until the upstream device has attached. This leads to a chicken and the egg failure and the DRM pipeline does not complete.
Since all other mipi_dsi_device drivers call mipi_dsi_attach() in probe(), make the adv7533 mipi_dsi_device do the same. This ensures that the Synopsys MIPI DSI host registers it's bridge such that it is available for the upstream device to connect to.
--- drivers/gpu/drm/bridge/adv7511/adv7511_drv.c | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-)
drivers/gpu/drm/bridge/adv7511/adv7511_drv.c +9 -3
@@ -874,9 +874,6 @@ static int adv7511_bridge_attach(struct drm_bridge *bridge) &adv7511_connector_helper_funcs);drm_connector_attach_encoder (&adv->connector, bridge->encoder); -if (adv->type ==ADV7533 ) - ret =adv7533_attach_dsi (adv); -if (adv->i2c_main->irq)regmap_write (adv->regmap,ADV7511_REG_INT_ENABLE (0 ),ADV7511_INT0_HPD );
@@ -1222,8 +1219,17 @@ static int adv7511_probe(struct i2c_client *i2c, const struct i2c_device_id *id)drm_bridge_add (&adv7511->bridge);adv7511_audio_init (dev, adv7511); + +if (adv7511->type ==ADV7533 ) { + ret =adv7533_attach_dsi (adv7511); +if (ret) + goto err_remove_bridge; + } +return 0 ; +err_remove_bridge: +drm_bridge_remove (&adv7511->bridge); err_unregister_cec:i2c_unregister_device (adv7511->i2c_cec);if (adv7511->cec_clk)
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 4/70 drm/kms: Catch mode_object lifetime errors
In reply to Sasha LevinFrom: Daniel Vetter <[email protected]>
[ Upstream commit 4f5368b5541a902f6596558b05f5c21a9770dd32 ]
Only dynamic mode objects, i.e. those which are refcounted and have a free callback, can be added while the overall drm_device is visible to userspace. All others must be added before drm_dev_register and removed after drm_dev_unregister.
Small issue around drivers still using the load/unload callbacks, we need to make sure we set dev->registered so that load/unload code in these callbacks doesn't trigger false warnings. Only a small adjustement in drm_dev_register was needed.
Motivated by some irc discussions about object ids of dynamic objects like blobs become invalid, and me going on a bit an audit spree.
--- drivers/gpu/drm/drm_drv.c | 4 ++-- drivers/gpu/drm/drm_mode_object.c | 4 ++++ 2 files changed, 6 insertions(+), 2 deletions(-)
drivers/gpu/drm/drm_drv.c +2 -2
@@ -987,14 +987,14 @@ int drm_dev_register(struct drm_device *dev, unsigned long flags)if (ret) goto err_minors; - dev->registered = true; -if (dev->driver->load) { ret = dev->driver->load (dev, flags);if (ret) goto err_minors; } + dev->registered = true; +if (drm_core_check_feature (dev,DRIVER_MODESET ))drm_modeset_register_all (dev);
drivers/gpu/drm/drm_mode_object.c +4 -0
@@ -37,6 +37,8 @@ int __drm_mode_object_add(struct drm_device *dev, struct drm_mode_object *obj, {int ret; +WARN_ON (dev->registered && !obj_free_cb); +mutex_lock (&dev->mode_config.idr_mutex); ret =idr_alloc (&dev->mode_config.object_idr, register_obj ? obj :NULL ,1 ,0 ,GFP_KERNEL );
@@ -97,6 +99,8 @@ void drm_mode_object_register(struct drm_device *dev,void drm_mode_object_unregister (struct drm_device *dev,struct drm_mode_object *object) { +WARN_ON (dev->registered && !object->free_cb); +mutex_lock (&dev->mode_config.idr_mutex);if (object->id) {idr_remove (&dev->mode_config.object_idr, object->id);
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 5/70 drm/vkms: Avoid assigning 0 for possible_crtc
In reply to Sasha LevinFrom: Rodrigo Siqueira <[email protected]>
[ Upstream commit e9d85f731de06a35d2ae6cdcf7d0e037c98ef41a ]
When vkms invoke drm_universal_plane_init(), it sets 0 for possible_crtcs parameter which means that planes can't be attached to any CRTC. It currently works due to some safeguard in the drm_crtc file; however, it is possible to identify the problem by trying to append a second connector. This patch fixes this issue by modifying vkms_plane_init() to accept an index parameter which makes the code a little bit more flexible and avoid set zero to possible_crtcs.
--- drivers/gpu/drm/vkms/vkms_drv.c | 2 +- drivers/gpu/drm/vkms/vkms_drv.h | 4 ++-- drivers/gpu/drm/vkms/vkms_output.c | 6 +++--- drivers/gpu/drm/vkms/vkms_plane.c | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-)
drivers/gpu/drm/vkms/vkms_drv.c +1 -1
@@ -92,7 +92,7 @@ static int vkms_modeset_init(struct vkms_device *vkmsdev) dev->mode_config.max_height =YRES_MAX ; dev->mode_config.preferred_depth =24 ; -return vkms_output_init (vkmsdev); +return vkms_output_init (vkmsdev,0 ); }static int __init vkms_init (void )
drivers/gpu/drm/vkms/vkms_drv.h +2 -2
@@ -115,10 +115,10 @@ bool vkms_get_vblank_timestamp(struct drm_device *dev, unsigned int pipe, int *max_error, ktime_t *vblank_time, bool in_vblank_irq); -int vkms_output_init (struct vkms_device *vkmsdev); +int vkms_output_init (struct vkms_device *vkmsdev,int index);struct drm_plane *vkms_plane_init (struct vkms_device *vkmsdev, -enum drm_plane_type type); +enum drm_plane_type type,int index);/* Gem stuff */ struct drm_gem_object *vkms_gem_create(struct drm_device *dev,
drivers/gpu/drm/vkms/vkms_output.c +3 -3
@@ -36,7 +36,7 @@ static const struct drm_connector_helper_funcs vkms_conn_helper_funcs = { .get_modes = vkms_conn_get_modes, }; -int vkms_output_init (struct vkms_device *vkmsdev) +int vkms_output_init (struct vkms_device *vkmsdev,int index) {struct vkms_output *output = &vkmsdev->output;struct drm_device *dev = &vkmsdev->drm;
@@ -46,12 +46,12 @@ int vkms_output_init(struct vkms_device *vkmsdev)struct drm_plane *primary, *cursor =NULL ;int ret; - primary =vkms_plane_init (vkmsdev,DRM_PLANE_TYPE_PRIMARY ); + primary =vkms_plane_init (vkmsdev,DRM_PLANE_TYPE_PRIMARY , index);if (IS_ERR (primary))return PTR_ERR (primary);if (enable_cursor) { - cursor =vkms_plane_init (vkmsdev,DRM_PLANE_TYPE_CURSOR ); + cursor =vkms_plane_init (vkmsdev,DRM_PLANE_TYPE_CURSOR , index);if (IS_ERR (cursor)) { ret =PTR_ERR (cursor); goto err_cursor;
drivers/gpu/drm/vkms/vkms_plane.c +2 -2
@@ -168,7 +168,7 @@ static const struct drm_plane_helper_funcs vkms_primary_helper_funcs = { };struct drm_plane *vkms_plane_init (struct vkms_device *vkmsdev, -enum drm_plane_type type) +enum drm_plane_type type,int index) {struct drm_device *dev = &vkmsdev->drm;const struct drm_plane_helper_funcs *funcs;
@@ -190,7 +190,7 @@ struct drm_plane *vkms_plane_init(struct vkms_device *vkmsdev, funcs = &vkms_primary_helper_funcs; } - ret =drm_universal_plane_init (dev, plane,0 , + ret =drm_universal_plane_init (dev, plane,1 << index, &vkms_plane_funcs, formats, nformats,NULL , type,NULL );
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 6/70 drm/panel: simple: fix AUO g185han01 horizontal blanking
In reply to Sasha LevinFrom: Lucas Stach <[email protected]>
[ Upstream commit f8c6bfc612b56f02e1b8fae699dff12738aaf889 ]
The horizontal blanking periods are too short, as the values are specified for a single LVDS channel. Since this panel is dual LVDS they need to be doubled. With this change the panel reaches its nominal vrefresh rate of 60Fps, instead of the 64Fps with the current wrong blanking.
Philipp Zabel added:
The datasheet specifies 960 active clocks + 40/128/160 clocks blanking on each of the two LVDS channels (min/typical/max), so doubled this is now correct.
--- drivers/gpu/drm/panel/panel-simple.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/gpu/drm/panel/panel-simple.c +3 -3
@@ -723,9 +723,9 @@ static const struct panel_desc auo_g133han01 = {static const struct display_timing auo_g185han01_timings = { .pixelclock = {120000000 ,144000000 ,175000000 }, .hactive = {1920 ,1920 ,1920 }, - .hfront_porch = {18 ,60 ,74 }, - .hback_porch = {12 ,44 ,54 }, - .hsync_len = {10 ,24 ,32 }, + .hfront_porch = {36 ,120 ,148 }, + .hback_porch = {24 ,88 ,108 }, + .hsync_len = {20 ,48 ,64 }, .vactive = {1080 ,1080 ,1080 }, .vfront_porch = {6 ,10 ,40 }, .vback_porch = {2 ,5 ,20 },
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 7/70 drm/amd/display: add monitor patch to add T7 delay
In reply to Sasha LevinFrom: Anthony Koo <[email protected]>
[ Upstream commit 88eac241a1fc500ce5274a09ddc4bd5fc2b5adb6 ]
[Why]
Specifically to one panel,
TCON is able to accept active video signal quickly, but the Source Driver requires 2-3 frames of extra time.
It is a Panel issue since TCON needs to take care of all Sink requirements including Source Driver. But in this case it does not.
Customer is asking to add fixed T7 delay as panel workaround.
[How]
Add monitor specific patch to add T7 delay
--- drivers/gpu/drm/amd/display/dc/core/dc_link_hwss.c | 4 ++++ drivers/gpu/drm/amd/display/dc/dc_types.h | 1 + 2 files changed, 5 insertions(+)
drivers/gpu/drm/amd/display/dc/core/dc_link_hwss.c +4 -0
@@ -154,6 +154,10 @@ bool edp_receiver_ready_T7(struct dc_link *link)break ;udelay (25 );//MAx T7 is 50ms }while (++tries <300 ); + +if (link->local_sink->edid_caps.panel_patch.extra_t7_ms >0 ) +udelay (link->local_sink->edid_caps.panel_patch.extra_t7_ms *1000 ); +return result; }
drivers/gpu/drm/amd/display/dc/dc_types.h +1 -0
@@ -202,6 +202,7 @@ struct dc_panel_patch {unsigned int dppowerup_delay;unsigned int extra_t12_ms;unsigned int extra_delay_backlight_off; +unsigned int extra_t7_ms; };struct dc_edid_caps {
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 8/70 video: ssd1307fb: Start page range at page_offset
In reply to Sasha LevinFrom: Marko Kohtala <[email protected]>
[ Upstream commit dd9782834dd9dde3624ff1acea8859f3d3e792d4 ]
The page_offset was only applied to the end of the page range. This caused the display updates to cause a scrolling effect on the display because the amount of data written to the display did not match the range display expected.
--- drivers/video/fbdev/ssd1307fb.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/video/fbdev/ssd1307fb.c +1 -1
@@ -432,7 +432,7 @@ static int ssd1307fb_init(struct ssd1307fb_par *par)if (ret <0 )return ret; - ret =ssd1307fb_write_cmd (par->client,0x0 ); + ret =ssd1307fb_write_cmd (par->client, par->page_offset);if (ret <0 )return ret;
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 9/70 drm/tinydrm/Kconfig: drivers: Select BACKLIGHT_CLASS_DEVICE
In reply to Sasha LevinFrom: Noralf Trønnes <[email protected]>
[ Upstream commit 3389669ac5ea598562673c04971d7bb0fab0e9f1 ]
The mipi_dbi helper is missing a dependency on DRM_KMS_HELPER and putting that in revealed this problem:
drivers/video/fbdev/Kconfig:12:error: recursive dependency detected! drivers/video/fbdev/Kconfig:12: symbol FB is selected by DRM_KMS_FB_HELPERdrivers/gpu/drm/Kconfig:75: symbol DRM_KMS_FB_HELPER depends on DRM_KMS_HELPERdrivers/gpu/drm/Kconfig:69: symbol DRM_KMS_HELPER is selected by TINYDRM_MIPI_DBI
drivers/gpu/drm/tinydrm/Kconfig:11: symbol TINYDRM_MIPI_DBI is selected by TINYDRM_HX8357D drivers/gpu/drm/tinydrm/Kconfig:15: symbol TINYDRM_HX8357D depends on BACKLIGHT_CLASS_DEVICE drivers/video/backlight/Kconfig:144: symbol BACKLIGHT_CLASS_DEVICE is selected by FB_BACKLIGHT drivers/video/fbdev/Kconfig:187: symbol FB_BACKLIGHT depends on FB
A symbol that selects DRM_KMS_HELPER can not depend on BACKLIGHT_CLASS_DEVICE. The reason for this is that DRM_KMS_FB_HELPER selects FB instead of depending on it.
The tinydrm drivers have somehow gotten away with depending on BACKLIGHT_CLASS_DEVICE because DRM_TINYDRM selects DRM_KMS_HELPER and the drivers depend on that symbol.
An audit shows that all DRM drivers that select DRM_KMS_HELPER and use BACKLIGHT_CLASS_DEVICE, selects it:
DRM_TILCDC, DRM_GMA500, DRM_SHMOBILE, DRM_NOUVEAU, DRM_FSL_DCU, DRM_I915, DRM_RADEON, DRM_AMDGPU, DRM_PARADE_PS8622
Documentation/kbuild/kconfig-language.txt has a note regarding select:
1. 'select should be used with care since it doesn't visit dependencies.' This is not a problem since BACKLIGHT_CLASS_DEVICE doesn't have any dependencies.
2. 'In general use select only for non-visible symbols' BACKLIGHT_CLASS_DEVICE is user visible.
The real solution to this would be to have DRM_KMS_FB_HELPER depend on the user visible symbol FB. That is a can of worms I'm not willing to tackle. I fear that such a change will result in me handling difficult fallouts for the next weeks. So I'm following DRM suite here.
--- drivers/gpu/drm/tinydrm/Kconfig | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/gpu/drm/tinydrm/Kconfig +4 -4
@@ -14,8 +14,8 @@ config TINYDRM_MIPI_DBI config TINYDRM_HX8357D tristate "DRM support for HX8357D display panels" depends on DRM_TINYDRM && SPI - depends on BACKLIGHT_CLASS_DEVICE select TINYDRM_MIPI_DBI + select BACKLIGHT_CLASS_DEVICE help DRM driver for the following HX8357D panels: * YX350HV15-T 3.5" 340x350 TFT (Adafruit 3.5")
@@ -35,8 +35,8 @@ config TINYDRM_ILI9225 config TINYDRM_ILI9341 tristate "DRM support for ILI9341 display panels" depends on DRM_TINYDRM && SPI - depends on BACKLIGHT_CLASS_DEVICE select TINYDRM_MIPI_DBI + select BACKLIGHT_CLASS_DEVICE help DRM driver for the following Ilitek ILI9341 panels: * YX240QV29-T 2.4" 240x320 TFT (Adafruit 2.4")
@@ -46,8 +46,8 @@ config TINYDRM_ILI9341 config TINYDRM_MI0283QT tristate "DRM support for MI0283QT" depends on DRM_TINYDRM && SPI - depends on BACKLIGHT_CLASS_DEVICE select TINYDRM_MIPI_DBI + select BACKLIGHT_CLASS_DEVICE help DRM driver for the Multi-Inno MI0283QT display panel If M is selected the module will be called mi0283qt.
@@ -78,8 +78,8 @@ config TINYDRM_ST7586 config TINYDRM_ST7735R tristate "DRM support for Sitronix ST7735R display panels" depends on DRM_TINYDRM && SPI - depends on BACKLIGHT_CLASS_DEVICE select TINYDRM_MIPI_DBI + select BACKLIGHT_CLASS_DEVICE help DRM driver Sitronix ST7735R with one of the following LCDs: * JD-T18003-T01 1.8" 128x160 TFT
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 10/70 drm/stm: attach gem fence to atomic state
In reply to Sasha LevinFrom: Ahmad Fatoum <[email protected]>
[ Upstream commit 8fabc9c3109a71b3577959a05408153ae69ccd8d ]
To properly synchronize with other devices the fence from the GEM object backing the framebuffer needs to be attached to the atomic state, so the commit work can wait on fence signaling.
--- drivers/gpu/drm/stm/ltdc.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/gpu/drm/stm/ltdc.c +2 -0
@@ -25,6 +25,7 @@#include <drm/drm_fb_cma_helper.h> #include <drm/drm_fourcc.h> #include <drm/drm_gem_cma_helper.h> +#include <drm/drm_gem_framebuffer_helper.h> #include <drm/drm_of.h> #include <drm/drm_plane_helper.h> #include <drm/drm_probe_helper.h>
@@ -875,6 +876,7 @@ static const struct drm_plane_funcs ltdc_plane_funcs = { };static const struct drm_plane_helper_funcs ltdc_plane_helper_funcs = { + .prepare_fb = drm_gem_fb_prepare_fb, .atomic_check = ltdc_plane_atomic_check, .atomic_update = ltdc_plane_atomic_update, .atomic_disable = ltdc_plane_atomic_disable,
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 11/70 drm/panel: check failure cases in the probe func
In reply to Sasha LevinFrom: Navid Emamdoost <[email protected]>
[ Upstream commit afd6d4f5a52c16e1483328ac074abb1cde92c29f ]
The following function calls may fail and return NULL, so the null check is added.of_graph_get_next_endpointof_graph_get_remote_port_parentof_graph_get_remote_port
Update: Thanks to Sam Ravnborg, for suggession on the use of goto to avoid leaking endpoint.
--- .../gpu/drm/panel/panel-raspberrypi-touchscreen.c | 13 +++++++++++++ 1 file changed, 13 insertions(+)
drivers/gpu/drm/panel/panel-raspberrypi-touchscreen.c +13 -0
@@ -400,7 +400,13 @@ static int rpi_touchscreen_probe(struct i2c_client *i2c,/* Look up the DSI host. It needs to probe before we do. */ endpoint =of_graph_get_next_endpoint (dev->of_node,NULL ); +if (!endpoint) +return -ENODEV ; + dsi_host_node =of_graph_get_remote_port_parent (endpoint); +if (!dsi_host_node) + goto error; + host =of_find_mipi_dsi_host_by_node (dsi_host_node);of_node_put (dsi_host_node);if (!host) {
@@ -409,6 +415,9 @@ static int rpi_touchscreen_probe(struct i2c_client *i2c, } info.node =of_graph_get_remote_port (endpoint); +if (!info.node) + goto error; +of_node_put (endpoint); ts->dsi =mipi_dsi_device_register_full (host, &info);
@@ -429,6 +438,10 @@ static int rpi_touchscreen_probe(struct i2c_client *i2c,return ret;return 0 ; + +error: +of_node_put (endpoint); +return -ENODEV ; }static int rpi_touchscreen_remove (struct i2c_client *i2c)
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 12/70 drm/rockchip: Check for fast link training before enabling psr
In reply to Sasha LevinFrom: Sean Paul <[email protected]>
[ Upstream commit ad309284a52be47c8b3126c9376358bf381861bc ]
Once we start shutting off the link during PSR, we're going to want fast training to work. If the display doesn't support fast training, don't enable psr.
Changes in v2:
- None
Changes in v3:
- None
Changes in v4:
- None
Changes in v5:
- None
Link to v1: https://patchwork.freedesktop.org/patch/msgid/[email protected]
Link to v2: https://patchwork.freedesktop.org/patch/msgid/[email protected]
Link to v3: https://patchwork.freedesktop.org/patch/msgid/[email protected]
Link to v4: https://patchwork.freedesktop.org/patch/msgid/[email protected]
--- drivers/gpu/drm/bridge/analogix/analogix_dp_core.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
drivers/gpu/drm/bridge/analogix/analogix_dp_core.c +5 -4
@@ -1036,16 +1036,17 @@ static int analogix_dp_commit(struct analogix_dp_device *dp)if (ret)return ret; +/* Check whether panel supports fast training */ + ret =analogix_dp_fast_link_train_detection (dp); +if (ret) + dp->psr_enable = false; +if (dp->psr_enable) { ret =analogix_dp_enable_sink_psr (dp);if (ret)return ret; } -/* Check whether panel supports fast training */ - ret =analogix_dp_fast_link_train_detection (dp); -if (ret) - dp->psr_enable = false;return ret; }
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 13/70 drm/amdgpu: Fix hard hang for S/G display BOs.
In reply to Sasha LevinFrom: Andrey Grodzovsky <[email protected]>
[ Upstream commit e4c4073b0139d055d43a9568690fc560aab4fa5c ]
HW requires for caching to be unset for scanout BO mappings when the BO placement is in GTT memory. Usually the flag to unset is passed from user mode but for FB mode this was missing.
v2:
Keep all BO placement logic in amdgpu_display_supported_domains
--- drivers/gpu/drm/amd/amdgpu/amdgpu_fb.c | 7 +++---- drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c | 3 ++- 2 files changed, 5 insertions(+), 5 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_fb.c +3 -4
@@ -137,14 +137,14 @@ static int amdgpufb_create_pinned_object(struct amdgpu_fbdev *rfbdev, mode_cmd->pitches[0 ] =amdgpu_align_pitch (adev, mode_cmd->width, cpp, fb_tiled); domain =amdgpu_display_supported_domains (adev); - height =ALIGN (mode_cmd->height,8 ); size = mode_cmd->pitches[0 ] * height; aligned_size =ALIGN (size,PAGE_SIZE ); ret =amdgpu_gem_object_create (adev, aligned_size,0 , domain,AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | -AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS | -AMDGPU_GEM_CREATE_VRAM_CLEARED , +AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS | +AMDGPU_GEM_CREATE_VRAM_CLEARED | +AMDGPU_GEM_CREATE_CPU_GTT_USWC , ttm_bo_type_kernel,NULL , &gobj);if (ret) {pr_err ("failed to allocate framebuffer (%d)\n" , aligned_size);
@@ -166,7 +166,6 @@ static int amdgpufb_create_pinned_object(struct amdgpu_fbdev *rfbdev,dev_err (adev->dev,"FB failed to set tiling flags\n" ); } - ret =amdgpu_bo_pin (abo, domain);if (ret) {amdgpu_bo_unreserve (abo);
drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c +2 -1
@@ -746,7 +746,8 @@ int amdgpu_mode_dumb_create(struct drm_file *file_priv,struct amdgpu_device *adev = dev->dev_private;struct drm_gem_object *gobj;uint32_t handle; -u64 flags =AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED ; +u64 flags =AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED | +AMDGPU_GEM_CREATE_CPU_GTT_USWC ;u32 domain;int r;
Signature · 6 lines
2.20.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Sasha Levin
maintainerPATCH 14/70 drm/radeon: Fix EEH during kexec
In reply to Sasha LevinFrom: KyleMahlkuch <[email protected]>
[ Upstream commit 6f7fe9a93e6c09bf988c5059403f5f88e17e21e6 ]
During kexec some adapters hit an EEH since they are not properly shut down in the radeon_pci_shutdown() function. Adding radeon_suspend_kms() fixes this issue.
--- drivers/gpu/drm/radeon/radeon_drv.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/gpu/drm/radeon/radeon_drv.c +8 -0
@@ -344,11 +344,19 @@ radeon_pci_remove(struct pci_dev *pdev)static void radeon_pci_shutdown (struct pci_dev *pdev) { +struct drm_device *ddev =pci_get_drvdata (pdev); +/* if we are running in a VM, make sure the device * torn down properly on reboot/shutdown */ if (radeon_device_is_virtual ())radeon_pci_remove (pdev); + +/* Some adapters need to be suspended before a +* shutdown occurs in order to prevent an error +* during kexec. +*/ +radeon_suspend_kms (ddev, true, true, false); }static int radeon_pmops_suspend (struct device *dev)
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 15/70 gpu: drm: radeon: Fix a possible null-pointer dereference in radeon_connector_set_property()
In reply to Sasha LevinFrom: Jia-Ju Bai <[email protected]>
[ Upstream commit f3eb9b8f67bc28783eddc142ad805ebdc53d6339 ]
In radeon_connector_set_property(), there is an if statement on line 743 to check whether connector->encoder is NULL:
if (connector->encoder)
When connector->encoder is NULL, it is used on line 755:
if (connector->encoder->crtc)
Thus, a possible null-pointer dereference may occur.
To fix this bug, connector->encoder is checked before being used.
This bug is found by a static analysis tool STCheck written by us.
--- drivers/gpu/drm/radeon/radeon_connectors.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/radeon/radeon_connectors.c +1 -1
@@ -752,7 +752,7 @@ static int radeon_connector_set_property(struct drm_connector *connector, struct radeon_encoder->output_csc = val; -if (connector->encoder->crtc) { +if (connector->encoder && connector->encoder->crtc) {struct drm_crtc *crtc = connector->encoder->crtc;struct radeon_crtc *radeon_crtc =to_radeon_crtc (crtc);
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 16/70 clk: imx8mq: Mark AHB clock as critical
In reply to Sasha LevinFrom: Abel Vesa <[email protected]>
[ Upstream commit 9b9c60bed562c3718ae324a86f3f30a4ff983cf8 ]
Initially, the TMU_ROOT clock was marked as critical, which automatically made the AHB clock to stay always on. Since the TMU_ROOT clock is not marked as critical anymore, following commit:
"clk: imx8mq: Remove CLK_IS_CRITICAL flag for IMX8MQ_CLK_TMU_ROOT"
all the clocks that derive from ipg_root clock (and implicitly ahb clock) would also have to enable, along with their own gate, the AHB clock.
But considering that AHB is actually a bus that has to be always on, we mark it as critical in the clock provider driver and then all the clocks that derive from it can be controlled through the dedicated per IP gate which follows after the ipg_root clock.
--- drivers/clk/imx/clk-imx8mq.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/clk/imx/clk-imx8mq.c +2 -1
@@ -396,7 +396,8 @@ static int imx8mq_clocks_probe(struct platform_device *pdev) clks[IMX8MQ_CLK_NOC_APB ] =imx8m_clk_composite_critical ("noc_apb" , imx8mq_noc_apb_sels, base +0x8d80 );/* AHB */ - clks[IMX8MQ_CLK_AHB ] =imx8m_clk_composite ("ahb" , imx8mq_ahb_sels, base +0x9000 ); +/* AHB clock is used by the AHB bus therefore marked as critical */ + clks[IMX8MQ_CLK_AHB ] =imx8m_clk_composite_critical ("ahb" , imx8mq_ahb_sels, base +0x9000 ); clks[IMX8MQ_CLK_AUDIO_AHB ] =imx8m_clk_composite ("audio_ahb" , imx8mq_audio_ahb_sels, base +0x9100 );/* IPG */
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 17/70 PCI: rpaphp: Avoid a sometimes-uninitialized warning
In reply to Sasha LevinFrom: Nathan Chancellor <[email protected]>
[ Upstream commit 0df3e42167caaf9f8c7b64de3da40a459979afe8 ]
When building with -Wsometimes-uninitialized, clang warns:
drivers/pci/hotplug/rpaphp_core.c:243:14: warning: variable 'fndit' is used uninitialized whenever 'for' loop exits because its condition is false [-Wsometimes-uninitialized]
for (j = 0; j < entries; j++) {
^~~~~~~~~~~
drivers/pci/hotplug/rpaphp_core.c:256:6: note: uninitialized use occurs
here
if (fndit)
^~~~~
drivers/pci/hotplug/rpaphp_core.c:243:14: note: remove the condition if
it is always true
for (j = 0; j < entries; j++) {
^~~~~~~~~~~
drivers/pci/hotplug/rpaphp_core.c:233:14: note: initialize the variable
'fndit' to silence this warning
int j, fndit;
^
= 0fndit is only used to gate a sprintf call, which can be moved into the loop to simplify the code and eliminate the local variable, which will fix this warning.
--- drivers/pci/hotplug/rpaphp_core.c | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-)
drivers/pci/hotplug/rpaphp_core.c +7 -11
@@ -230,7 +230,7 @@ static int rpaphp_check_drc_props_v2(struct device_node *dn, char *drc_name,struct of_drc_info drc;const __be32 *value;char cell_drc_name[MAX_DRC_NAME_LEN ]; -int j, fndit; +int j; info =of_find_property (dn->parent,"ibm,drc-info" ,NULL );if (info ==NULL )
@@ -245,17 +245,13 @@ static int rpaphp_check_drc_props_v2(struct device_node *dn, char *drc_name,/* Should now know end of current entry */ -if (my_index > drc.last_drc_index) -continue ; - - fndit =1 ; -break ; +/* Found it */ +if (my_index <= drc.last_drc_index) { +sprintf (cell_drc_name,"%s%d" , drc.drc_name_prefix, + my_index); +break ; + } } -/* Found it */ - -if (fndit) -sprintf (cell_drc_name,"%s%d" , drc.drc_name_prefix, - my_index); if (((drc_name == NULL) || (drc_name && !strcmp(drc_name, cell_drc_name))) &&
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 18/70 pinctrl: stmfx: update pinconf settings
In reply to Sasha LevinFrom: Alexandre Torgue <[email protected]>
[ Upstream commit a502b343ebd0eab38f3cb33fbb84011847cf5aac ]
According to the following tab (coming from STMFX datasheet), updates have to done in stmfx_pinconf_set function:
-"type" has to be set when "bias" is configured as "pull-up or pull-down" -PIN_CONFIG_DRIVE_PUSH_PULL should only be used when gpio is configured as
output. There is so no need to check direction.
DIR | TYPE | PUPD | MFX GPIO configuration ----|------|------|--------------------------------------------------- 1 | 1 | 1 | OUTPUT open drain with internal pull-up resistor ----|------|------|--------------------------------------------------- 1 | 1 | 0 | OUTPUT open drain with internal pull-down resistor ----|------|------|--------------------------------------------------- 1 | 0 | 0/1 | OUTPUT push pull no pull ----|------|------|--------------------------------------------------- 0 | 1 | 1 | INPUT with internal pull-up resistor ----|------|------|--------------------------------------------------- 0 | 1 | 0 | INPUT with internal pull-down resistor ----|------|------|--------------------------------------------------- 0 | 0 | 1 | INPUT floating ----|------|------|--------------------------------------------------- 0 | 0 | 0 | analog (GPIO not used, default setting)
--- drivers/pinctrl/pinctrl-stmfx.c | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-)
drivers/pinctrl/pinctrl-stmfx.c +12 -12
@@ -296,29 +296,29 @@ static int stmfx_pinconf_set(struct pinctrl_dev *pctldev, unsigned int pin,switch (param) {case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT :case PIN_CONFIG_BIAS_DISABLE : +case PIN_CONFIG_DRIVE_PUSH_PULL : + ret =stmfx_pinconf_set_type (pctl, pin,0 ); +if (ret) +return ret; +break ;case PIN_CONFIG_BIAS_PULL_DOWN : + ret =stmfx_pinconf_set_type (pctl, pin,1 ); +if (ret) +return ret; ret =stmfx_pinconf_set_pupd (pctl, pin,0 );if (ret)return ret;break ;case PIN_CONFIG_BIAS_PULL_UP : - ret =stmfx_pinconf_set_pupd (pctl, pin,1 ); + ret =stmfx_pinconf_set_type (pctl, pin,1 );if (ret)return ret; -break ; -case PIN_CONFIG_DRIVE_OPEN_DRAIN : -if (!dir) - ret =stmfx_pinconf_set_type (pctl, pin,1 ); -else - ret =stmfx_pinconf_set_type (pctl, pin,0 ); + ret =stmfx_pinconf_set_pupd (pctl, pin,1 );if (ret)return ret;break ; -case PIN_CONFIG_DRIVE_PUSH_PULL : -if (!dir) - ret =stmfx_pinconf_set_type (pctl, pin,0 ); -else - ret =stmfx_pinconf_set_type (pctl, pin,1 ); +case PIN_CONFIG_DRIVE_OPEN_DRAIN : + ret =stmfx_pinconf_set_type (pctl, pin,1 );if (ret)return ret;break ;
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 19/70 ipmi_si: Only schedule continuously in the thread in maintenance mode
In reply to Sasha LevinFrom: Corey Minyard <[email protected]>
[ Upstream commit 340ff31ab00bca5c15915e70ad9ada3030c98cf8 ]
ipmi_thread() uses back-to-back schedule() to poll for command completion which, on some machines, can push up CPU consumption and heavily tax the scheduler locks leading to noticeable overall performance degradation.
This was originally added so firmware updates through IPMI would complete in a timely manner. But we can't kill the scheduler locks for that one use case.
Instead, only run schedule() continuously in maintenance mode, where firmware updates should run.
--- drivers/char/ipmi/ipmi_si_intf.c | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-)
drivers/char/ipmi/ipmi_si_intf.c +19 -5
@@ -221,6 +221,9 @@ struct smi_info {*/ bool irq_enable_broken; +/* Is the driver in maintenance mode? */ +bool in_maintenance_mode; +/* * Did we get an attention that we did not handle? */
@@ -1007,11 +1010,20 @@ static int ipmi_thread(void *data)spin_unlock_irqrestore (&(smi_info->si_lock), flags); busy_wait =ipmi_thread_busy_wait (smi_result, smi_info, &busy_until); -if (smi_result ==SI_SM_CALL_WITHOUT_DELAY ) +if (smi_result ==SI_SM_CALL_WITHOUT_DELAY ) { ;/* do nothing */ -else if (smi_result ==SI_SM_CALL_WITH_DELAY && busy_wait) -schedule (); -else if (smi_result ==SI_SM_IDLE ) { + }else if (smi_result ==SI_SM_CALL_WITH_DELAY && busy_wait) { +/* +* In maintenance mode we run as fast as +* possible to allow firmware updates to +* complete as fast as possible, but normally +* don't bang on the scheduler. +*/ +if (smi_info->in_maintenance_mode) +schedule (); +else +usleep_range (100 ,200 ); + }else if (smi_result ==SI_SM_IDLE ) {if (atomic_read (&smi_info->need_watch)) {schedule_timeout_interruptible (100 ); }else {
@@ -1019,8 +1031,9 @@ static int ipmi_thread(void *data)__set_current_state (TASK_INTERRUPTIBLE );schedule (); } - }else + }else {schedule_timeout_interruptible (1 ); + } }return 0 ; }
@@ -1198,6 +1211,7 @@ static void set_maintenance_mode(void *send_info, bool enable)if (!enable)atomic_set (&smi_info->req_events,0 ); + smi_info->in_maintenance_mode = enable; }static void shutdown_smi (void *send_info);
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 20/70 clk: qoriq: Fix -Wunused-const-variable
In reply to Sasha LevinFrom: Nathan Huckleberry <[email protected]>
[ Upstream commit a95fb581b144b5e73da382eaedb2e32027610597 ]
drivers/clk/clk-qoriq.c:138:38: warning: unused variable 'p5020_cmux_grp1' [-Wunused-const-variable] static const struct clockgen_muxinfo p5020_cmux_grp1
drivers/clk/clk-qoriq.c:146:38: warning: unused variable 'p5020_cmux_grp2' [-Wunused-const-variable] static const struct clockgen_muxinfo p5020_cmux_grp2
In the definition of the p5020 chip, the p2041 chip's info was used instead. The p5020 and p2041 chips have different info. This is most likely a typo.
--- drivers/clk/clk-qoriq.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/clk/clk-qoriq.c +1 -1
@@ -675,7 +675,7 @@ static const struct clockgen_chipinfo chipinfo[] = { .guts_compat = "fsl,qoriq-device-config-1.0", .init_periph = p5020_init_periph, .cmux_groups = { - &p2041_cmux_grp1, &p2041_cmux_grp2 + &p5020_cmux_grp1, &p5020_cmux_grp2 }, .cmux_to_group = {0 ,1 ,-1
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 21/70 clk: sunxi-ng: v3s: add missing clock slices for MMC2 module clocks
In reply to Sasha LevinFrom: Icenowy Zheng <[email protected]>
[ Upstream commit 720099603d1f62e37b789366d7e89824b009ca28 ]
The MMC2 clock slices are currently not defined in V3s CCU driver, which makes MMC2 not working.
Fix this issue.
--- drivers/clk/sunxi-ng/ccu-sun8i-v3s.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/clk/sunxi-ng/ccu-sun8i-v3s.c +3 -0
@@ -493,6 +493,9 @@ static struct clk_hw_onecell_data sun8i_v3s_hw_clks = { [CLK_MMC1] = &mmc1_clk.common.hw, [CLK_MMC1_SAMPLE] = &mmc1_sample_clk.common.hw, [CLK_MMC1_OUTPUT] = &mmc1_output_clk.common.hw, + [CLK_MMC2] = &mmc2_clk.common.hw, + [CLK_MMC2_SAMPLE] = &mmc2_sample_clk.common.hw, + [CLK_MMC2_OUTPUT] = &mmc2_output_clk.common.hw, [CLK_CE] = &ce_clk.common.hw, [CLK_SPI0] = &spi0_clk.common.hw, [CLK_USB_PHY0] = &usb_phy0_clk.common.hw,
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 22/70 drm/amd/display: fix issue where 252-255 values are clipped
In reply to Sasha LevinFrom: Anthony Koo <[email protected]>
[ Upstream commit 1cbcfc975164f397b449efb17f59d81a703090db ]
[Why]
When endpoint is at the boundary of a region, such as at 2^0=1 we find that the last segment has a sharp slope and some points are clipped at the top.
[How]
If end point is 1, which is exactly at the 2^0 region boundary, we need to program an additional region beyond this point.
--- drivers/gpu/drm/amd/display/dc/dcn10/dcn10_cm_common.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/gpu/drm/amd/display/dc/dcn10/dcn10_cm_common.c +2 -1
@@ -357,9 +357,10 @@ bool cm_helper_translate_curve_to_hw_format( seg_distr[7 ] =4 ; seg_distr[8 ] =4 ; seg_distr[9 ] =4 ; + seg_distr[10 ] =1 ; region_start =-10 ; - region_end =0 ; + region_end =1 ; }for (i = region_end - region_start; i <MAX_REGIONS_NUMBER ; i++)
Signature · 6 lines
2.20.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Sasha Levin
maintainerPATCH 23/70 drm/amd/display: Fix frames_to_insert math
In reply to Sasha LevinFrom: Bayan Zabihiyan <[email protected]>
[ Upstream commit a463b263032f7c98c5912207db43be1aa34a6438 ]
[Why]
The math on deciding on how many
"frames to insert" sometimes sent us over the max refresh rate. Also integer overflow can occur if we have high refresh rates.
[How]
Instead of clipping the frame duration such that it doesn’t go below the min, just remove a frame from the number of frames to insert. +
Use unsigned long long for intermediate calculations to prevent integer overflow.
--- .../amd/display/modules/freesync/freesync.c | 27 ++++++++++++------- 1 file changed, 17 insertions(+), 10 deletions(-)
drivers/gpu/drm/amd/display/modules/freesync/freesync.c +17 -10
@@ -433,6 +433,12 @@ static void apply_below_the_range(struct core_freesync *core_freesync,/* Either we've calculated the number of frames to insert, * or we need to insert min duration frames */ +if (last_render_time_in_us / frames_to_insert < + in_out_vrr->min_duration_in_us){ + frames_to_insert -= (frames_to_insert >1 ) ? +1 :0 ; + } +if (frames_to_insert >0 ) inserted_frame_duration_in_us = last_render_time_in_us / frames_to_insert;
@@ -885,8 +891,8 @@ void mod_freesync_build_vrr_params(struct mod_freesync *mod_freesync,struct core_freesync *core_freesync =NULL ;unsigned long long nominal_field_rate_in_uhz =0 ;unsigned int refresh_range =0 ; -unsigned int min_refresh_in_uhz =0 ; -unsigned int max_refresh_in_uhz =0 ; +unsigned long long min_refresh_in_uhz =0 ; +unsigned long long max_refresh_in_uhz =0 ;if (mod_freesync ==NULL )return ;
@@ -913,7 +919,7 @@ void mod_freesync_build_vrr_params(struct mod_freesync *mod_freesync, min_refresh_in_uhz = nominal_field_rate_in_uhz;if (!vrr_settings_require_update (core_freesync, - in_config, min_refresh_in_uhz, max_refresh_in_uhz, + in_config, (unsigned int )min_refresh_in_uhz, (unsigned int )max_refresh_in_uhz, in_out_vrr))return ;
@@ -929,15 +935,15 @@ void mod_freesync_build_vrr_params(struct mod_freesync *mod_freesync,return ; }else { - in_out_vrr->min_refresh_in_uhz = min_refresh_in_uhz; + in_out_vrr->min_refresh_in_uhz = (unsigned int )min_refresh_in_uhz; in_out_vrr->max_duration_in_us =calc_duration_in_us_from_refresh_in_uhz ( - min_refresh_in_uhz); + (unsigned int )min_refresh_in_uhz); - in_out_vrr->max_refresh_in_uhz = max_refresh_in_uhz; + in_out_vrr->max_refresh_in_uhz = (unsigned int )max_refresh_in_uhz; in_out_vrr->min_duration_in_us =calc_duration_in_us_from_refresh_in_uhz ( - max_refresh_in_uhz); + (unsigned int )max_refresh_in_uhz); refresh_range = in_out_vrr->max_refresh_in_uhz - in_out_vrr->min_refresh_in_uhz;
@@ -948,17 +954,18 @@ void mod_freesync_build_vrr_params(struct mod_freesync *mod_freesync, in_out_vrr->fixed.ramping_active = in_config->ramping; in_out_vrr->btr.btr_enabled = in_config->btr; +if (in_out_vrr->max_refresh_in_uhz <2 * in_out_vrr->min_refresh_in_uhz) in_out_vrr->btr.btr_enabled = false; + in_out_vrr->btr.btr_active = false; in_out_vrr->btr.inserted_duration_in_us =0 ; in_out_vrr->btr.frames_to_insert =0 ; in_out_vrr->btr.frame_counter =0 ; in_out_vrr->btr.mid_point_in_us = - in_out_vrr->min_duration_in_us + - (in_out_vrr->max_duration_in_us - - in_out_vrr->min_duration_in_us) /2 ; + (in_out_vrr->min_duration_in_us + + in_out_vrr->max_duration_in_us) /2 ;if (in_out_vrr->state ==VRR_STATE_UNSUPPORTED ) { in_out_vrr->adjust.v_total_min = stream->timing.v_total;
Signature · 6 lines
2.20.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Sasha Levin
maintainerPATCH 24/70 drm/amd/display: reprogram VM config when system resume
In reply to Sasha LevinFrom: Lewis Huang <[email protected]>
[ Upstream commit e5382701c3520b3ed66169a6e4aa6ce5df8c56e0 ]
[Why]
The vm config will be clear to 0 when system enter S4. It will cause hubbub didn't know how to fetch data when system resume. The flip always pending because earliest_inuse_address and request_address are different.
[How]
Reprogram VM config when system resume
--- drivers/gpu/drm/amd/display/dc/core/dc.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/gpu/drm/amd/display/dc/core/dc.c +8 -0
@@ -2016,6 +2016,14 @@ void dc_set_power_state(dc_resource_state_construct (dc, dc->current_state); dc->hwss.init_hw (dc); + +#ifdef CONFIG_DRM_AMD_DC_DCN2_0 +if (dc->hwss.init_sys_ctx !=NULL && + dc->vm_pa_config.valid) { + dc->hwss.init_sys_ctx (dc->hwseq, dc, &dc->vm_pa_config); + } +#endif +break ;default :ASSERT (dc->current_state->stream_count ==0 );
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 25/70 powerpc/powernv/ioda2: Allocate TCE table levels on demand for default DMA window
In reply to Sasha LevinFrom: Alexey Kardashevskiy <[email protected]>
[ Upstream commit c37c792dec0929dbb6360a609fb00fa20bb16fc2 ]
We allocate only the first level of multilevel TCE tables for KVM already (alloc_userspace_copy==true), and the rest is allocated on demand. This is not enabled though for bare metal.
This removes the KVM limitation (implicit, via the alloc_userspace_copy parameter) and always allocates just the first level. The on-demand allocation of missing levels is already implemented.
As from now on DMA map might happen with disabled interrupts, this allocates TCEs with GFP_ATOMIC; otherwise lockdep reports errors 1]. In practice just a single page is allocated there so chances for failure are quite low.
To save time when creating a new clean table, this skips non-allocated indirect TCE entries in pnv_tce_free just like we already do in the VFIO IOMMU TCE driver.
This changes the default level number from 1 to 2 to reduce the amount of memory required for the default 32bit DMA window at the boot time. The default window size is up to 2GB which requires 4MB of TCEs which is unlikely to be used entirely or at all as most devices these days are 64bit capable so by switching to 2 levels by default we save 4032KB of RAM per a device.
While at this, add __GFP_NOWARN to alloc_pages_node() as the userspace can trigger this path via VFIO, see the failure and try creating a table again with different parameters which might succeed.
[1]:
===
BUG: sleeping function called from invalid context at mm/page_alloc.c:4596
in_atomic(): 1, irqs_disabled(): 1, pid: 1038, name: scsi_eh_1
2 locks held by scsi_eh_1/1038:
#0: 000000005efd659a (&host->eh_mutex){+.+.}, at: ata_eh_acquire+0x34/0x80 #1: 0000000006cf56a6 (&(&host->lock)->rlock){....}, at: ata_exec_internal_sg+0xb0/0x5c0
irq event stamp: 500 hardirqs last enabled at (499): [<c000000000cb8a74>] _raw_spin_unlock_irqrestore+0x94/0xd0 hardirqs last disabled at (500): [<c000000000cb85c4>] _raw_spin_lock_irqsave+0x44/0x120 softirqs last enabled at (0): [<c000000000101120>] copy_process.isra.4.part.5+0x640/0x1a80 softirqs last disabled at (0): [<0000000000000000>] 0x0 CPU: 73 PID: 1038 Comm: scsi_eh_1 Not tainted 5.2.0-rc6-le_nv2_aikATfstn1-p1 #634 Call Trace: [c000003d064cef50] [c000000000c8e6c4] dump_stack+0xe8/0x164 (unreliable) [c000003d064cefa0] [c00000000014ed78] ___might_sleep+0x2f8/0x310 [c000003d064cf020] [c0000000003ca084] __alloc_pages_nodemask+0x2a4/0x1560 [c000003d064cf220] [c0000000000c2530] pnv_alloc_tce_level.isra.0+0x90/0x130 [c000003d064cf290] [c0000000000c2888] pnv_tce+0x128/0x3b0 [c000003d064cf360] [c0000000000c2c00] pnv_tce_build+0xb0/0xf0 [c000003d064cf3c0] [c0000000000bbd9c] pnv_ioda2_tce_build+0x3c/0xb0 [c000003d064cf400] [c00000000004cfe0] ppc_iommu_map_sg+0x210/0x550 [c000003d064cf510] [c00000000004b7a4] dma_iommu_map_sg+0x74/0xb0 [c000003d064cf530] [c000000000863944] ata_qc_issue+0x134/0x470 [c000003d064cf5b0] [c000000000863ec4] ata_exec_internal_sg+0x244/0x5c0 [c000003d064cf700] [c0000000008642d0] ata_exec_internal+0x90/0xe0 [c000003d064cf780] [c0000000008650ac] ata_dev_read_id+0x2ec/0x640 [c000003d064cf8d0] [c000000000878e28] ata_eh_recover+0x948/0x16d0 [c000003d064cfa10] [c00000000087d760] sata_pmp_error_handler+0x480/0xbf0 [c000003d064cfbc0] [c000000000884624] ahci_error_handler+0x74/0xe0 [c000003d064cfbf0] [c000000000879fa8] ata_scsi_port_error_handler+0x2d8/0x7c0 [c000003d064cfca0] [c00000000087a544] ata_scsi_error+0xb4/0x100 [c000003d064cfd00] [c000000000802450] scsi_error_handler+0x120/0x510 [c000003d064cfdb0] [c000000000140c48] kthread+0x1b8/0x1c0 [c000003d064cfe20] [c00000000000bd8c] ret_from_kernel_thread+0x5c/0x70 ata1: SATA link up 6.0 Gbps (SStatus 133 SControl 300) irq event stamp: 2305
========================================================
hardirqs last enabled at (2305): [<c00000000000e4c8>] fast_exc_return_irq+0x28/0x34 hardirqs last disabled at (2303): [<c000000000cb9fd0>] __do_softirq+0x4a0/0x654 WARNING: possible irq lock inversion dependency detected 5.2.0-rc6-le_nv2_aikATfstn1-p1 #634 Tainted: G W softirqs last enabled at (2304): [<c000000000cba054>] __do_softirq+0x524/0x654 softirqs last disabled at (2297): [<c00000000010f278>] irq_exit+0x128/0x180 --------------------------------------------------------
swapper/0/0 just changed the state of lock:0000000006cf56a6 (&(&host->lock)->rlock){-...}, at: ahci_single_level_irq_intr+0xac/0x120 but this lock took another, HARDIRQ-unsafe lock in the past:
(fs_reclaim){+.+.}
and interrupts could create inverse lock ordering between them.
other info that might help us debug this:
Possible interrupt unsafe locking scenario:
CPU0 CPU1
---- ----
lock(fs_reclaim);
local_irq_disable();
lock(&(&host->lock)->rlock);
lock(fs_reclaim);
<Interrupt>
lock(&(&host->lock)->rlock);*** DEADLOCK ***
no locks held by swapper/0/0.
the shortest dependencies between 2nd lock and 1st lock:
-> (fs_reclaim){+.+.} ops: 167579 {
HARDIRQ-ON-W at:
lock_acquire+0xf8/0x2a0
fs_reclaim_acquire.part.23+0x44/0x60
kmem_cache_alloc_node_trace+0x80/0x590
alloc_desc+0x64/0x270
__irq_alloc_descs+0x2e4/0x3a0
irq_domain_alloc_descs+0xb0/0x150
irq_create_mapping+0x168/0x2c0
xics_smp_probe+0x2c/0x98
pnv_smp_probe+0x40/0x9c
smp_prepare_cpus+0x524/0x6c4
kernel_init_freeable+0x1b4/0x650
kernel_init+0x2c/0x148
ret_from_kernel_thread+0x5c/0x70
SOFTIRQ-ON-W at:
lock_acquire+0xf8/0x2a0
fs_reclaim_acquire.part.23+0x44/0x60
kmem_cache_alloc_node_trace+0x80/0x590
alloc_desc+0x64/0x270
__irq_alloc_descs+0x2e4/0x3a0
irq_domain_alloc_descs+0xb0/0x150
irq_create_mapping+0x168/0x2c0
xics_smp_probe+0x2c/0x98
pnv_smp_probe+0x40/0x9c
smp_prepare_cpus+0x524/0x6c4
kernel_init_freeable+0x1b4/0x650
kernel_init+0x2c/0x148
ret_from_kernel_thread+0x5c/0x70
INITIAL USE at:
lock_acquire+0xf8/0x2a0
fs_reclaim_acquire.part.23+0x44/0x60
kmem_cache_alloc_node_trace+0x80/0x590
alloc_desc+0x64/0x270
__irq_alloc_descs+0x2e4/0x3a0
irq_domain_alloc_descs+0xb0/0x150
irq_create_mapping+0x168/0x2c0
xics_smp_probe+0x2c/0x98
pnv_smp_probe+0x40/0x9c
smp_prepare_cpus+0x524/0x6c4
kernel_init_freeable+0x1b4/0x650
kernel_init+0x2c/0x148
ret_from_kernel_thread+0x5c/0x70 }
===
--- arch/powerpc/platforms/powernv/pci-ioda-tce.c | 20 +++++++++---------- arch/powerpc/platforms/powernv/pci.h | 2 +- 2 files changed, 11 insertions(+), 11 deletions(-)
arch/powerpc/platforms/powernv/pci-ioda-tce.c +10 -10
@@ -36,7 +36,8 @@ static __be64 *pnv_alloc_tce_level(int nid, unsigned int shift)struct page *tce_mem =NULL ;__be64 *addr; - tce_mem =alloc_pages_node (nid,GFP_KERNEL , shift -PAGE_SHIFT ); + tce_mem =alloc_pages_node (nid,GFP_ATOMIC | __GFP_NOWARN, + shift -PAGE_SHIFT );if (!tce_mem) {pr_err ("Failed to allocate a TCE memory, level shift=%d\n" , shift);
@@ -161,6 +162,9 @@ void pnv_tce_free(struct iommu_table *tbl, long index, long npages)if (ptce) *ptce =cpu_to_be64 (0 ); +else +/* Skip the rest of the level */ + i |= tbl->it_level_size -1 ; } }
@@ -260,7 +264,6 @@ long pnv_pci_ioda2_table_alloc_pages(int nid, __u64 bus_offset, unsigned int table_shift = max_t(unsigned int, entries_shift + 3,PAGE_SHIFT );const unsigned long tce_table_size =1UL << table_shift; -unsigned int tmplevels = levels;if (!levels || (levels >POWERNV_IOMMU_MAX_LEVELS ))return -EINVAL ;
@@ -268,9 +271,6 @@ long pnv_pci_ioda2_table_alloc_pages(int nid, __u64 bus_offset,if (!is_power_of_2 (window_size))return -EINVAL ; -if (alloc_userspace_copy && (window_size > (1ULL <<32 ))) - tmplevels =1 ; -/* Adjust direct table size from window_size and levels */ entries_shift = (entries_shift + levels -1 ) / levels; level_shift = entries_shift +3 ;
@@ -281,7 +281,7 @@ long pnv_pci_ioda2_table_alloc_pages(int nid, __u64 bus_offset,/* Allocate TCE table */ addr =pnv_pci_ioda2_table_do_alloc_pages (nid, level_shift, - tmplevels, tce_table_size, &offset, &total_allocated); +1 , tce_table_size, &offset, &total_allocated);/* addr==NULL means that the first level allocation failed */ if (!addr)
@@ -292,18 +292,18 @@ long pnv_pci_ioda2_table_alloc_pages(int nid, __u64 bus_offset,* we did not allocate as much as we wanted, * release partially allocated table. */ -if (tmplevels == levels && offset < tce_table_size) +if (levels ==1 && offset < tce_table_size) goto free_tces_exit;/* Allocate userspace view of the TCE table */ if (alloc_userspace_copy) { offset =0 ; uas =pnv_pci_ioda2_table_do_alloc_pages (nid, level_shift, - tmplevels, tce_table_size, &offset, +1 , tce_table_size, &offset, &total_allocated_uas);if (!uas) goto free_tces_exit; -if (tmplevels == levels && (offset < tce_table_size || +if (levels ==1 && (offset < tce_table_size || total_allocated_uas != total_allocated)) goto free_uas_exit; }
@@ -318,7 +318,7 @@ long pnv_pci_ioda2_table_alloc_pages(int nid, __u64 bus_offset,pr_debug ("Created TCE table: ws=%08llx ts=%lx @%08llx base=%lx uas=%p levels=%d/%d\n" , window_size, tce_table_size, bus_offset, tbl->it_base, - tbl->it_userspace, tmplevels, levels); + tbl->it_userspace,1 , levels);return 0 ;
arch/powerpc/platforms/powernv/pci.h +1 -1
@@ -225,7 +225,7 @@ extern struct iommu_table_group *pnv_npu_compound_attach( struct pnv_ioda_pe *pe);/* pci-ioda-tce.c */ -#define POWERNV_IOMMU_DEFAULT_LEVELS 1 +#define POWERNV_IOMMU_DEFAULT_LEVELS 2#define POWERNV_IOMMU_MAX_LEVELS 5 extern int pnv_tce_build(struct iommu_table *tbl, long index, long npages,
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 26/70 drm/amd/powerplay/smu7: enforce minimal VBITimeout (v2)
In reply to Sasha LevinFrom: Ahzo <[email protected]>
[ Upstream commit f659bb6dae58c113805f92822e4c16ddd3156b79 ]
This fixes screen corruption/flickering on 75 Hz displays.
v2: make print statement debug only (Alex)
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=102646
--- drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c +5 -0
@@ -4064,6 +4064,11 @@ static int smu7_program_display_gap(struct pp_hwmgr *hwmgr) data->frame_time_x2 = frame_time_in_us *2 /100 ; +if (data->frame_time_x2 <280 ) { +pr_debug ("%s: enforce minimal VBITimeout: %d -> 280\n" , __func__, data->frame_time_x2); + data->frame_time_x2 =280 ; + } + display_gap2 = pre_vbi_time_in_us * (ref_clock /100 );cgs_write_ind_register (hwmgr->device,CGS_IND_REG__SMC , ixCG_DISPLAY_GAP_CNTL2, display_gap2);
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 27/70 clk: actions: Don't reference clk_init_data after registration
In reply to Sasha LevinFrom: Stephen Boyd <[email protected]>
[ Upstream commit cf9ec1fc6d7cceb73e7f1efd079d2eae173fdf57 ]
A future patch is going to change semantics of clk_register() so that clk_hw::init is guaranteed to be NULL after a clk is registered. Avoid referencing this member here so that we don't run into NULL pointer exceptions.
--- drivers/clk/actions/owl-common.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
drivers/clk/actions/owl-common.c +3 -2
@@ -68,16 +68,17 @@ int owl_clk_probe(struct device *dev, struct clk_hw_onecell_data *hw_clks)struct clk_hw *hw;for (i =0 ; i < hw_clks->num; i++) { +const char *name; hw = hw_clks->hws[i]; -if (IS_ERR_OR_NULL (hw))continue ; + name = hw->init->name; ret =devm_clk_hw_register (dev, hw);if (ret) {dev_err (dev,"Couldn't register clock %d - %s\n" , - i, hw->init->name); + i, name);return ret; } }
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 28/70 clk: sirf: Don't reference clk_init_data after registration
In reply to Sasha LevinFrom: Stephen Boyd <[email protected]>
[ Upstream commit af55dadfbce35b4f4c6247244ce3e44b2e242b84 ]
A future patch is going to change semantics of clk_register() so that clk_hw::init is guaranteed to be NULL after a clk is registered. Avoid referencing this member here so that we don't run into NULL pointer exceptions.
--- drivers/clk/sirf/clk-common.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-)
drivers/clk/sirf/clk-common.c +8 -4
@@ -297,9 +297,10 @@ static u8 dmn_clk_get_parent(struct clk_hw *hw) {struct clk_dmn *clk =to_dmnclk (hw);u32 cfg =clkc_readl (clk->regofs); +const char *name =clk_hw_get_name (hw);/* parent of io domain can only be pll3 */ -if (strcmp (hw->init->name,"io" ) ==0 ) +if (strcmp (name,"io" ) ==0 )return 4 ;WARN_ON ((cfg & (BIT (3 ) -1 )) >4 );
@@ -311,9 +312,10 @@ static int dmn_clk_set_parent(struct clk_hw *hw, u8 parent) {struct clk_dmn *clk =to_dmnclk (hw);u32 cfg =clkc_readl (clk->regofs); +const char *name =clk_hw_get_name (hw);/* parent of io domain can only be pll3 */ -if (strcmp (hw->init->name,"io" ) ==0 ) +if (strcmp (name,"io" ) ==0 )return -EINVAL ; cfg &= ~(BIT (3 ) -1 );
@@ -353,7 +355,8 @@ static long dmn_clk_round_rate(struct clk_hw *hw, unsigned long rate, {unsigned long fin;unsigned ratio, wait, hold; -unsigned bits = (strcmp (hw->init->name,"mem" ) ==0 ) ?3 :4 ; +const char *name =clk_hw_get_name (hw); +unsigned bits = (strcmp (name,"mem" ) ==0 ) ?3 :4 ; fin = *parent_rate; ratio = fin / rate;
@@ -375,7 +378,8 @@ static int dmn_clk_set_rate(struct clk_hw *hw, unsigned long rate,struct clk_dmn *clk =to_dmnclk (hw);unsigned long fin;unsigned ratio, wait, hold, reg; -unsigned bits = (strcmp (hw->init->name,"mem" ) ==0 ) ?3 :4 ; +const char *name =clk_hw_get_name (hw); +unsigned bits = (strcmp (name,"mem" ) ==0 ) ?3 :4 ; fin = parent_rate; ratio = fin / rate;
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 29/70 clk: meson: axg-audio: Don't reference clk_init_data after registration
In reply to Sasha LevinFrom: Stephen Boyd <[email protected]>
[ Upstream commit 1610dd79d0f6202c5c1a91122255fa598679c13a ]
A future patch is going to change semantics of clk_register() so that clk_hw::init is guaranteed to be NULL after a clk is registered. Avoid referencing this member here so that we don't run into NULL pointer exceptions.
--- drivers/clk/meson/axg-audio.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
drivers/clk/meson/axg-audio.c +5 -2
@@ -992,15 +992,18 @@ static int axg_audio_clkc_probe(struct platform_device *pdev)/* Take care to skip the registered input clocks */ for (i =AUD_CLKID_DDR_ARB ; i < data->hw_onecell_data->num; i++) { +const char *name; + hw = data->hw_onecell_data->hws[i];/* array might be sparse */ if (!hw)continue ; + name = hw->init->name; + ret =devm_clk_hw_register (dev, hw);if (ret) { -dev_err (dev,"failed to register clock %s\n" , - hw->init->name); +dev_err (dev,"failed to register clock %s\n" , name);return ret; } }
Signature · 7 lines
2.20.1 _______________________________________________ linux-amlogic mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-amlogic
Sasha Levin
maintainerPATCH 30/70 clk: sprd: Don't reference clk_init_data after registration
In reply to Sasha LevinFrom: Stephen Boyd <[email protected]>
[ Upstream commit f6c90df8e7e33c3dc33d4d7471bc42c232b0510e ]
A future patch is going to change semantics of clk_register() so that clk_hw::init is guaranteed to be NULL after a clk is registered. Avoid referencing this member here so that we don't run into NULL pointer exceptions.
--- drivers/clk/sprd/common.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
drivers/clk/sprd/common.c +3 -2
@@ -71,16 +71,17 @@ int sprd_clk_probe(struct device *dev, struct clk_hw_onecell_data *clkhw)struct clk_hw *hw;for (i =0 ; i < clkhw->num; i++) { +const char *name; hw = clkhw->hws[i]; -if (!hw)continue ; + name = hw->init->name; ret =devm_clk_hw_register (dev, hw);if (ret) {dev_err (dev,"Couldn't register clock %d - %s\n" , - i, hw->init->name); + i, name);return ret; } }
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 31/70 clk: zx296718: Don't reference clk_init_data after registration
In reply to Sasha LevinFrom: Stephen Boyd <[email protected]>
[ Upstream commit 1a4549c150e27dbc3aea762e879a88209df6d1a5 ]
A future patch is going to change semantics of clk_register() so that clk_hw::init is guaranteed to be NULL after a clk is registered. Avoid referencing this member here so that we don't run into NULL pointer exceptions.
--- drivers/clk/zte/clk-zx296718.c | 109 +++++++++++++++------------------ 1 file changed, 49 insertions(+), 60 deletions(-)
drivers/clk/zte/clk-zx296718.c +49 -60
@@ -564,6 +564,7 @@ static int __init top_clocks_init(struct device_node *np) {void __iomem *reg_base;int i, ret; +const char *name; reg_base =of_iomap (np,0 );if (!reg_base) {
@@ -573,11 +574,10 @@ static int __init top_clocks_init(struct device_node *np)for (i =0 ; i <ARRAY_SIZE (zx296718_pll_clk); i++) { zx296718_pll_clk[i].reg_base += (uintptr_t )reg_base; + name = zx296718_pll_clk[i].hw.init->name; ret =clk_hw_register (NULL , &zx296718_pll_clk[i].hw); -if (ret) { -pr_warn ("top clk %s init error!\n" , - zx296718_pll_clk[i].hw.init->name); - } +if (ret) +pr_warn ("top clk %s init error!\n" , name); }for (i =0 ; i <ARRAY_SIZE (top_ffactor_clk); i++) {
@@ -585,11 +585,10 @@ static int __init top_clocks_init(struct device_node *np) top_hw_onecell_data.hws[top_ffactor_clk[i].id] = &top_ffactor_clk[i].factor.hw; + name = top_ffactor_clk[i].factor.hw.init->name; ret =clk_hw_register (NULL , &top_ffactor_clk[i].factor.hw); -if (ret) { -pr_warn ("top clk %s init error!\n" , - top_ffactor_clk[i].factor.hw.init->name); - } +if (ret) +pr_warn ("top clk %s init error!\n" , name); }for (i =0 ; i <ARRAY_SIZE (top_mux_clk); i++) {
@@ -598,11 +597,10 @@ static int __init top_clocks_init(struct device_node *np) &top_mux_clk[i].mux.hw; top_mux_clk[i].mux.reg += (uintptr_t )reg_base; + name = top_mux_clk[i].mux.hw.init->name; ret =clk_hw_register (NULL , &top_mux_clk[i].mux.hw); -if (ret) { -pr_warn ("top clk %s init error!\n" , - top_mux_clk[i].mux.hw.init->name); - } +if (ret) +pr_warn ("top clk %s init error!\n" , name); }for (i =0 ; i <ARRAY_SIZE (top_gate_clk); i++) {
@@ -611,11 +609,10 @@ static int __init top_clocks_init(struct device_node *np) &top_gate_clk[i].gate.hw; top_gate_clk[i].gate.reg += (uintptr_t )reg_base; + name = top_gate_clk[i].gate.hw.init->name; ret =clk_hw_register (NULL , &top_gate_clk[i].gate.hw); -if (ret) { -pr_warn ("top clk %s init error!\n" , - top_gate_clk[i].gate.hw.init->name); - } +if (ret) +pr_warn ("top clk %s init error!\n" , name); }for (i =0 ; i <ARRAY_SIZE (top_div_clk); i++) {
@@ -624,11 +621,10 @@ static int __init top_clocks_init(struct device_node *np) &top_div_clk[i].div.hw; top_div_clk[i].div.reg += (uintptr_t )reg_base; + name = top_div_clk[i].div.hw.init->name; ret =clk_hw_register (NULL , &top_div_clk[i].div.hw); -if (ret) { -pr_warn ("top clk %s init error!\n" , - top_div_clk[i].div.hw.init->name); - } +if (ret) +pr_warn ("top clk %s init error!\n" , name); } ret = of_clk_add_hw_provider(np, of_clk_hw_onecell_get,
@@ -754,6 +750,7 @@ static int __init lsp0_clocks_init(struct device_node *np) {void __iomem *reg_base;int i, ret; +const char *name; reg_base =of_iomap (np,0 );if (!reg_base) {
@@ -767,11 +764,10 @@ static int __init lsp0_clocks_init(struct device_node *np) &lsp0_mux_clk[i].mux.hw; lsp0_mux_clk[i].mux.reg += (uintptr_t )reg_base; + name = lsp0_mux_clk[i].mux.hw.init->name; ret =clk_hw_register (NULL , &lsp0_mux_clk[i].mux.hw); -if (ret) { -pr_warn ("lsp0 clk %s init error!\n" , - lsp0_mux_clk[i].mux.hw.init->name); - } +if (ret) +pr_warn ("lsp0 clk %s init error!\n" , name); }for (i =0 ; i <ARRAY_SIZE (lsp0_gate_clk); i++) {
@@ -780,11 +776,10 @@ static int __init lsp0_clocks_init(struct device_node *np) &lsp0_gate_clk[i].gate.hw; lsp0_gate_clk[i].gate.reg += (uintptr_t )reg_base; + name = lsp0_gate_clk[i].gate.hw.init->name; ret =clk_hw_register (NULL , &lsp0_gate_clk[i].gate.hw); -if (ret) { -pr_warn ("lsp0 clk %s init error!\n" , - lsp0_gate_clk[i].gate.hw.init->name); - } +if (ret) +pr_warn ("lsp0 clk %s init error!\n" , name); }for (i =0 ; i <ARRAY_SIZE (lsp0_div_clk); i++) {
@@ -793,11 +788,10 @@ static int __init lsp0_clocks_init(struct device_node *np) &lsp0_div_clk[i].div.hw; lsp0_div_clk[i].div.reg += (uintptr_t )reg_base; + name = lsp0_div_clk[i].div.hw.init->name; ret =clk_hw_register (NULL , &lsp0_div_clk[i].div.hw); -if (ret) { -pr_warn ("lsp0 clk %s init error!\n" , - lsp0_div_clk[i].div.hw.init->name); - } +if (ret) +pr_warn ("lsp0 clk %s init error!\n" , name); } ret = of_clk_add_hw_provider(np, of_clk_hw_onecell_get,
@@ -862,6 +856,7 @@ static int __init lsp1_clocks_init(struct device_node *np) {void __iomem *reg_base;int i, ret; +const char *name; reg_base =of_iomap (np,0 );if (!reg_base) {
@@ -875,11 +870,10 @@ static int __init lsp1_clocks_init(struct device_node *np) &lsp0_mux_clk[i].mux.hw; lsp1_mux_clk[i].mux.reg += (uintptr_t )reg_base; + name = lsp1_mux_clk[i].mux.hw.init->name; ret =clk_hw_register (NULL , &lsp1_mux_clk[i].mux.hw); -if (ret) { -pr_warn ("lsp1 clk %s init error!\n" , - lsp1_mux_clk[i].mux.hw.init->name); - } +if (ret) +pr_warn ("lsp1 clk %s init error!\n" , name); }for (i =0 ; i <ARRAY_SIZE (lsp1_gate_clk); i++) {
@@ -888,11 +882,10 @@ static int __init lsp1_clocks_init(struct device_node *np) &lsp1_gate_clk[i].gate.hw; lsp1_gate_clk[i].gate.reg += (uintptr_t )reg_base; + name = lsp1_gate_clk[i].gate.hw.init->name; ret =clk_hw_register (NULL , &lsp1_gate_clk[i].gate.hw); -if (ret) { -pr_warn ("lsp1 clk %s init error!\n" , - lsp1_gate_clk[i].gate.hw.init->name); - } +if (ret) +pr_warn ("lsp1 clk %s init error!\n" , name); }for (i =0 ; i <ARRAY_SIZE (lsp1_div_clk); i++) {
@@ -901,11 +894,10 @@ static int __init lsp1_clocks_init(struct device_node *np) &lsp1_div_clk[i].div.hw; lsp1_div_clk[i].div.reg += (uintptr_t )reg_base; + name = lsp1_div_clk[i].div.hw.init->name; ret =clk_hw_register (NULL , &lsp1_div_clk[i].div.hw); -if (ret) { -pr_warn ("lsp1 clk %s init error!\n" , - lsp1_div_clk[i].div.hw.init->name); - } +if (ret) +pr_warn ("lsp1 clk %s init error!\n" , name); } ret = of_clk_add_hw_provider(np, of_clk_hw_onecell_get,
@@ -979,6 +971,7 @@ static int __init audio_clocks_init(struct device_node *np) {void __iomem *reg_base;int i, ret; +const char *name; reg_base =of_iomap (np,0 );if (!reg_base) {
@@ -992,11 +985,10 @@ static int __init audio_clocks_init(struct device_node *np) &audio_mux_clk[i].mux.hw; audio_mux_clk[i].mux.reg += (uintptr_t )reg_base; + name = audio_mux_clk[i].mux.hw.init->name; ret =clk_hw_register (NULL , &audio_mux_clk[i].mux.hw); -if (ret) { -pr_warn ("audio clk %s init error!\n" , - audio_mux_clk[i].mux.hw.init->name); - } +if (ret) +pr_warn ("audio clk %s init error!\n" , name); }for (i =0 ; i <ARRAY_SIZE (audio_adiv_clk); i++) {
@@ -1005,11 +997,10 @@ static int __init audio_clocks_init(struct device_node *np) &audio_adiv_clk[i].hw; audio_adiv_clk[i].reg_base += (uintptr_t )reg_base; + name = audio_adiv_clk[i].hw.init->name; ret =clk_hw_register (NULL , &audio_adiv_clk[i].hw); -if (ret) { -pr_warn ("audio clk %s init error!\n" , - audio_adiv_clk[i].hw.init->name); - } +if (ret) +pr_warn ("audio clk %s init error!\n" , name); }for (i =0 ; i <ARRAY_SIZE (audio_div_clk); i++) {
@@ -1018,11 +1009,10 @@ static int __init audio_clocks_init(struct device_node *np) &audio_div_clk[i].div.hw; audio_div_clk[i].div.reg += (uintptr_t )reg_base; + name = audio_div_clk[i].div.hw.init->name; ret =clk_hw_register (NULL , &audio_div_clk[i].div.hw); -if (ret) { -pr_warn ("audio clk %s init error!\n" , - audio_div_clk[i].div.hw.init->name); - } +if (ret) +pr_warn ("audio clk %s init error!\n" , name); }for (i =0 ; i <ARRAY_SIZE (audio_gate_clk); i++) {
@@ -1031,11 +1021,10 @@ static int __init audio_clocks_init(struct device_node *np) &audio_gate_clk[i].gate.hw; audio_gate_clk[i].gate.reg += (uintptr_t )reg_base; + name = audio_gate_clk[i].gate.hw.init->name; ret =clk_hw_register (NULL , &audio_gate_clk[i].gate.hw); -if (ret) { -pr_warn ("audio clk %s init error!\n" , - audio_gate_clk[i].gate.hw.init->name); - } +if (ret) +pr_warn ("audio clk %s init error!\n" , name); } ret = of_clk_add_hw_provider(np, of_clk_hw_onecell_get,
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 32/70 powerpc/xmon: Check for HV mode when dumping XIVE info from OPAL
In reply to Sasha LevinFrom: Cédric Le Goater <[email protected]>
[ Upstream commit c3e0dbd7f780a58c4695f1cd8fc8afde80376737 ]
Currently, the xmon 'dx' command calls OPAL to dump the XIVE state in the OPAL logs and also outputs some of the fields of the internal XIVE structures in Linux. The OPAL calls can only be done on baremetal (PowerNV) and they crash a pseries machine. Fix by checking the hypervisor feature of the CPU.
--- arch/powerpc/xmon/xmon.c | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-)
arch/powerpc/xmon/xmon.c +10 -7
@@ -2532,13 +2532,16 @@ static void dump_pacas(void)static void dump_one_xive (int cpu) {unsigned int hwid =get_hard_smp_processor_id (cpu); - -opal_xive_dump (XIVE_DUMP_TM_HYP , hwid); -opal_xive_dump (XIVE_DUMP_TM_POOL , hwid); -opal_xive_dump (XIVE_DUMP_TM_OS , hwid); -opal_xive_dump (XIVE_DUMP_TM_USER , hwid); -opal_xive_dump (XIVE_DUMP_VP , hwid); -opal_xive_dump (XIVE_DUMP_EMU_STATE , hwid); +bool hv =cpu_has_feature (CPU_FTR_HVMODE ); + +if (hv) { +opal_xive_dump (XIVE_DUMP_TM_HYP , hwid); +opal_xive_dump (XIVE_DUMP_TM_POOL , hwid); +opal_xive_dump (XIVE_DUMP_TM_OS , hwid); +opal_xive_dump (XIVE_DUMP_TM_USER , hwid); +opal_xive_dump (XIVE_DUMP_VP , hwid); +opal_xive_dump (XIVE_DUMP_EMU_STATE , hwid); + }if (setjmp (bus_error_jmp) !=0 ) { catch_memory_errors =0 ;
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 33/70 powerpc/rtas: use device model APIs and serialization during LPM
In reply to Sasha LevinFrom: Nathan Lynch <[email protected]>
[ Upstream commit a6717c01ddc259f6f73364779df058e2c67309f8 ]
The LPAR migration implementation and userspace-initiated cpu hotplug can interleave their executions like so:
1. Set cpu 7 offline via sysfs.
2. Begin a partition migration, whose implementation requires the OS to ensure all present cpus are online; cpu 7 is onlined:
rtas_ibm_suspend_me -> rtas_online_cpus_mask -> cpu_up
This sets cpu 7 online in all respects except for the cpu's corresponding struct device; dev->offline remains true.
3. Set cpu 7 online via sysfs. _cpu_up() determines that cpu 7 is already online and returns success. The driver core (device_online) sets dev->offline = false.
4. The migration completes and restores cpu 7 to offline state:
rtas_ibm_suspend_me -> rtas_offline_cpus_mask -> cpu_down
This leaves cpu7 in a state where the driver core considers the cpu device online, but in all other respects it is offline and unused. Attempts to online the cpu via sysfs appear to succeed but the driver core actually does not pass the request to the lower-level cpuhp support code. This makes the cpu unusable until the cpu device is manually set offline and then online again via sysfs.
Instead of directly calling cpu_up/cpu_down, the migration code should use the higher-level device core APIs to maintain consistent state and serialize operations.
--- arch/powerpc/kernel/rtas.c | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)
arch/powerpc/kernel/rtas.c +8 -3
@@ -871,15 +871,17 @@ static int rtas_cpu_state_change_mask(enum rtas_cpu_state state,return 0 ;for_each_cpu (cpu, cpus) { +struct device *dev =get_cpu_device (cpu); +switch (state) {case DOWN : - cpuret =cpu_down (cpu); + cpuret =device_offline (dev);break ;case UP : - cpuret =cpu_up (cpu); + cpuret =device_online (dev);break ; } -if (cpuret) { +if (cpuret <0 ) { pr_debug("%s: cpu_%s for cpu#%d returned %d.\n", __func__, ((state == UP) ? "up" : "down"),
@@ -968,6 +970,8 @@ int rtas_ibm_suspend_me(u64 handle) data.token =rtas_token ("ibm,suspend-me" ); data.complete = &done; +lock_device_hotplug (); +/* All present CPUs must be online */ cpumask_andnot (offline_mask, cpu_present_mask, cpu_online_mask); cpuret =rtas_online_cpus_mask (offline_mask);
@@ -1007,6 +1011,7 @@ int rtas_ibm_suspend_me(u64 handle) __func__); out: +unlock_device_hotplug ();free_cpumask_var (offline_mask);return atomic_read (&data.error); }
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 34/70 powerpc/futex: Fix warning: 'oldval' may be used uninitialized in this function
In reply to Sasha LevinFrom: Christophe Leroy <[email protected]>
[ Upstream commit 38a0d0cdb46d3f91534e5b9839ec2d67be14c59d ]
We see warnings such as:
kernel/futex.c: In function 'do_futex':
kernel/futex.c:1676:17: warning: 'oldval' may be used uninitialized in this function [-Wmaybe-uninitialized]
return oldval == cmparg;
^
kernel/futex.c:1651:6: note: 'oldval' was declared here
int oldval, ret;
^This is because arch_futex_atomic_op_inuser() only sets *oval if ret is 0 and GCC doesn't see that it will only use it when ret is 0.
Anyway, the non-zero ret path is an error path that won't suffer from setting *oval, and as *oval is a local var in futex_atomic_op_inuser() it will have no impact.
--- arch/powerpc/include/asm/futex.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
arch/powerpc/include/asm/futex.h +1 -2
@@ -60,8 +60,7 @@ static inline int arch_futex_atomic_op_inuser(int op, int oparg, int *oval,pagefault_enable (); -if (!ret) - *oval = oldval; + *oval = oldval;prevent_write_to_user (uaddr,sizeof (*uaddr));return ret;
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 35/70 powerpc/64s/radix: Remove redundant pfn_pte bitop, add VM_BUG_ON
In reply to Sasha LevinFrom: Nicholas Piggin <[email protected]>
[ Upstream commit 6bb25170d7a44ef0ed9677814600f0785e7421d1 ]
pfn_pte is never given a pte above the addressable physical memory limit, so the masking is redundant. In case of a software bug, it is not obviously better to silently truncate the pfn than to corrupt the pte (either one will result in memory corruption or crashes), so there is no reason to add this to the fast path.
Add VM_BUG_ON to catch cases where the pfn is invalid. These would catch the create_section_mapping bug fixed by a previous commit.
[16885.256466] ------------[ cut here ]------------
[16885.256492] kernel BUG at arch/powerpc/include/asm/book3s/64/pgtable.h:612!
cpu 0x0: Vector: 700 (Program Check) at [c0000000ee0a36d0]
pc: c000000000080738: __map_kernel_page+0x248/0x6f0
lr: c000000000080ac0: __map_kernel_page+0x5d0/0x6f0
sp: c0000000ee0a3960
msr: 9000000000029033
current = 0xc0000000ec63b400
paca = 0xc0000000017f0000 irqmask: 0x03 irq_happened: 0x01
pid = 85, comm = sh
kernel BUG at arch/powerpc/include/asm/book3s/64/pgtable.h:612!
Linux version 5.3.0-rc1-00001-g0fe93e5f3394
enter ? for help
[c0000000ee0a3a00] c000000000d37378 create_physical_mapping+0x260/0x360
[c0000000ee0a3b10] c000000000d370bc create_section_mapping+0x1c/0x3c
[c0000000ee0a3b30] c000000000071f54 arch_add_memory+0x74/0x130--- arch/powerpc/include/asm/book3s/64/pgtable.h | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
arch/powerpc/include/asm/book3s/64/pgtable.h +4 -2
@@ -602,8 +602,10 @@ static inline bool pte_access_permitted(pte_t pte, bool write)*/ static inline pte_t pfn_pte (unsigned long pfn,pgprot_t pgprot) { -return __pte ((((pte_basic_t)(pfn) <<PAGE_SHIFT ) &PTE_RPN_MASK ) | -pgprot_val (pgprot)); +VM_BUG_ON (pfn >> (64 -PAGE_SHIFT )); +VM_BUG_ON ((pfn <<PAGE_SHIFT ) & ~PTE_RPN_MASK ); + +return __pte (((pte_basic_t )pfn <<PAGE_SHIFT ) |pgprot_val (pgprot)); }static inline unsigned long pte_pfn (pte_t pte)
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 36/70 powerpc/64s/radix: Fix memory hotplug section page table creation
In reply to Sasha LevinFrom: Nicholas Piggin <[email protected]>
[ Upstream commit 8f51e3929470942e6a8744061254fdeef646cd36 ]
create_physical_mapping expects physical addresses, but creating and splitting these mappings after boot is supplying virtual (effective) addresses. This can be irritated by booting with mem= to limit memory then probing an unused physical memory range:
echo <addr> > /sys/devices/system/memory/probe
This mostly works by accident, firstly because __va(__va(x)) == __va(x) so the virtual address does not get corrupted. Secondly because pfn_pte masks out the upper bits of the pfn beyond the physical address limit, so a pfn constructed with a 0xc000000000000000 virtual linear address will be masked back to the correct physical address in the pte.
--- arch/powerpc/mm/book3s64/radix_pgtable.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/powerpc/mm/book3s64/radix_pgtable.c +1 -1
@@ -901,7 +901,7 @@ int __meminit radix__create_section_mapping(unsigned long start, unsigned long ereturn -1 ; } -return create_physical_mapping (start, end, nid); +return create_physical_mapping (__pa (start),__pa (end), nid); }int __meminit radix__remove_section_mapping (unsigned long start,unsigned long end)
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 37/70 powerpc/pseries/mobility: use cond_resched when updating device tree
In reply to Sasha LevinFrom: Nathan Lynch <[email protected]>
[ Upstream commit ccfb5bd71d3d1228090a8633800ae7cdf42a94ac ]
After a partition migration, pseries_devicetree_update() processes changes to the device tree communicated from the platform to Linux. This is a relatively heavyweight operation, with multiple device tree searches, memory allocations, and conversations with partition firmware.
There's a few levels of nested loops which are bounded only by decisions made by the platform, outside of Linux's control, and indeed we have seen RCU stalls on large systems while executing this call graph. Use cond_resched() in these loops so that the cpu is yielded when needed.
--- arch/powerpc/platforms/pseries/mobility.c | 9 +++++++++ 1 file changed, 9 insertions(+)
arch/powerpc/platforms/pseries/mobility.c +9 -0
@@ -9,6 +9,7 @@#include <linux/cpu.h> #include <linux/kernel.h> #include <linux/kobject.h> +#include <linux/sched.h> #include <linux/smp.h> #include <linux/stat.h> #include <linux/completion.h>
@@ -206,7 +207,11 @@ static int update_dt_node(__be32 phandle, s32 scope) prop_data += vd; } + +cond_resched (); } + +cond_resched (); }while (rtas_rc ==1 );of_node_put (dn);
@@ -309,8 +314,12 @@ int pseries_devicetree_update(s32 scope)add_dt_node (phandle, drc_index);break ; } + +cond_resched (); } } + +cond_resched (); }while (rc ==1 );kfree (rtas_buf);
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 38/70 powerpc/perf: fix imc allocation failure handling
In reply to Sasha LevinFrom: Nicholas Piggin <[email protected]>
[ Upstream commit 10c4bd7cd28e77aeb8cfa65b23cb3c632ede2a49 ]
The alloc_pages_node return value should be tested for failure before being passed to page_address.
--- arch/powerpc/perf/imc-pmu.c | 29 ++++++++++++++++++----------- 1 file changed, 18 insertions(+), 11 deletions(-)
arch/powerpc/perf/imc-pmu.c +18 -11
@@ -570,6 +570,7 @@ static int core_imc_mem_init(int cpu, int size) {int nid, rc =0 , core_id = (cpu / threads_per_core);struct imc_mem_info *mem_info; +struct page *page;/* * alloc_pages_node() will allocate memory for core in the
@@ -580,11 +581,12 @@ static int core_imc_mem_init(int cpu, int size) mem_info->id = core_id;/* We need only vbase for core counters */ - mem_info->vbase =page_address (alloc_pages_node (nid, -GFP_KERNEL | __GFP_ZERO | __GFP_THISNODE | - __GFP_NOWARN,get_order (size))); -if (!mem_info->vbase) + page =alloc_pages_node (nid, +GFP_KERNEL | __GFP_ZERO | __GFP_THISNODE | + __GFP_NOWARN,get_order (size)); +if (!page)return -ENOMEM ; + mem_info->vbase =page_address (page);/* Init the mutex */ core_imc_refc[core_id].id = core_id;
@@ -839,15 +841,17 @@ static int thread_imc_mem_alloc(int cpu_id, int size)int nid =cpu_to_node (cpu_id);if (!local_mem) { +struct page *page;/* * This case could happen only once at start, since we dont * free the memory in cpu offline path. */ - local_mem =page_address (alloc_pages_node (nid, + page =alloc_pages_node (nid,GFP_KERNEL | __GFP_ZERO | __GFP_THISNODE | - __GFP_NOWARN,get_order (size))); -if (!local_mem) + __GFP_NOWARN,get_order (size)); +if (!page)return -ENOMEM ; + local_mem =page_address (page);per_cpu (thread_imc_mem, cpu_id) = local_mem; }
@@ -1085,11 +1089,14 @@ static int trace_imc_mem_alloc(int cpu_id, int size)int core_id = (cpu_id / threads_per_core);if (!local_mem) { - local_mem =page_address (alloc_pages_node (phys_id, -GFP_KERNEL | __GFP_ZERO | __GFP_THISNODE | - __GFP_NOWARN,get_order (size))); -if (!local_mem) +struct page *page; + + page =alloc_pages_node (phys_id, +GFP_KERNEL | __GFP_ZERO | __GFP_THISNODE | + __GFP_NOWARN,get_order (size)); +if (!page)return -ENOMEM ; + local_mem =page_address (page);per_cpu (trace_imc_mem, cpu_id) = local_mem;/* Initialise the counters for trace mode */
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 39/70 pinctrl: tegra: Fix write barrier placement in pmx_writel
In reply to Sasha LevinFrom: Sowjanya Komatineni <[email protected]>
[ Upstream commit c2cf351eba2ff6002ce8eb178452219d2521e38e ]
pmx_writel uses writel which inserts write barrier before the register write.
This patch has fix to replace writel with writel_relaxed followed by a readback and memory barrier to ensure write operation is completed for successful pinctrl change.
--- drivers/pinctrl/tegra/pinctrl-tegra.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/pinctrl/tegra/pinctrl-tegra.c +3 -1
@@ -32,7 +32,9 @@ static inline u32 pmx_readl(struct tegra_pmx *pmx, u32 bank, u32 reg)static inline void pmx_writel (struct tegra_pmx *pmx,u32 val,u32 bank,u32 reg) { -writel (val, pmx->regs[bank] + reg); +writel_relaxed (val, pmx->regs[bank] + reg); +/* make sure pinmux register write completed */ +pmx_readl (pmx, bank, reg); }static int tegra_pinctrl_get_groups_count (struct pinctrl_dev *pctldev)
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 40/70 powerpc/eeh: Clear stale EEH_DEV_NO_HANDLER flag
In reply to Sasha LevinFrom: Sam Bobroff <[email protected]>
[ Upstream commit aa06e3d60e245284d1e55497eb3108828092818d ]
The EEH_DEV_NO_HANDLER flag is used by the EEH system to prevent the use of driver callbacks in drivers that have been bound part way through the recovery process. This is necessary to prevent later stage handlers from being called when the earlier stage handlers haven't, which can be confusing for drivers.
However, the flag is set for all devices that are added after boot time and only cleared at the end of the EEH recovery process. This results in hot plugged devices erroneously having the flag set during the first recovery after they are added (causing their driver's handlers to be incorrectly ignored).
To remedy this, clear the flag at the beginning of recovery processing. The flag is still cleared at the end of recovery processing, although it is no longer really necessary.
Also clear the flag during eeh_handle_special_event(), for the same reasons.
--- arch/powerpc/kernel/eeh_driver.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)
arch/powerpc/kernel/eeh_driver.c +10 -1
@@ -793,6 +793,10 @@ void eeh_handle_normal_event(struct eeh_pe *pe) result =PCI_ERS_RESULT_DISCONNECT ; } +eeh_for_each_pe (pe, tmp_pe) +eeh_pe_for_each_dev (tmp_pe, edev, tmp) + edev->mode &= ~EEH_DEV_NO_HANDLER ; +/* Walk the various device drivers attached to this slot through * a reset sequence, giving each an opportunity to do what it needs * to accomplish the reset. Each child gets a report of the
@@ -981,7 +985,8 @@ void eeh_handle_normal_event(struct eeh_pe *pe)*/ void eeh_handle_special_event (void ) { -struct eeh_pe *pe, *phb_pe; +struct eeh_pe *pe, *phb_pe, *tmp_pe; +struct eeh_dev *edev, *tmp_edev;struct pci_bus *bus;struct pci_controller *hose;unsigned long flags;
@@ -1050,6 +1055,10 @@ void eeh_handle_special_event(void) (phb_pe->state & EEH_PE_RECOVERING))continue ; +eeh_for_each_pe (pe, tmp_pe) +eeh_pe_for_each_dev (tmp_pe, edev, tmp_edev) + edev->mode &= ~EEH_DEV_NO_HANDLER ; +/* Notify all devices to be down */ eeh_pe_state_clear (pe,EEH_PE_PRI_BUS , true);eeh_set_channel_state (pe, pci_channel_io_perm_failure);
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 41/70 vfio_pci: Restore original state on release
In reply to Sasha LevinFrom: hexin <[email protected]>
[ Upstream commit 92c8026854c25093946e0d7fe536fd9eac440f06 ]
vfio_pci_enable() saves the device's initial configuration information with the intent that it is restored in vfio_pci_disable(). However, the commit referenced in Fixes: below replaced the call to __pci_reset_function_locked(), which is not wrapped in a state save and restore, with pci_try_reset_function(), which overwrites the restored device state with the current state before applying it to the device. Reinstate use of __pci_reset_function_locked() to return to the desired behavior.
--- drivers/vfio/pci/vfio_pci.c | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-)
drivers/vfio/pci/vfio_pci.c +13 -4
@@ -438,11 +438,20 @@ static void vfio_pci_disable(struct vfio_pci_device *vdev)pci_write_config_word (pdev,PCI_COMMAND ,PCI_COMMAND_INTX_DISABLE );/* -* Try to reset the device. The success of this is dependent on -* being able to lock the device, which is not always possible. +* Try to get the locks ourselves to prevent a deadlock. The +* success of this is dependent on being able to lock the device, +* which is not always possible. +* We can not use the "try" reset interface here, which will +* overwrite the previously restored configuration information. */ -if (vdev->reset_works && !pci_try_reset_function (pdev)) - vdev->needs_reset = false; +if (vdev->reset_works &&pci_cfg_access_trylock (pdev)) { +if (device_trylock (&pdev->dev)) { +if (!__pci_reset_function_locked (pdev)) + vdev->needs_reset = false; +device_unlock (&pdev->dev); + } +pci_cfg_access_unlock (pdev); + }pci_restore_state (pdev); out:
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 42/70 drm/nouveau/kms/tu102-: disable input lut when input is already FP16
In reply to Sasha LevinFrom: Ben Skeggs <[email protected]>
[ Upstream commit 1e339ab2ac3c769c1b06b9fb7d532f8495ebc56d ]
On Turing, an input LUT is required to transform inputs in fixed-point formats to FP16 for the internal display pipe. We provide an identity mapping whenever a window is enabled for this reason.
HW has error checks to ensure when the input is already FP16, that the input LUT is also disabled.
--- drivers/gpu/drm/nouveau/dispnv50/wndw.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/gpu/drm/nouveau/dispnv50/wndw.c +3 -1
@@ -320,7 +320,9 @@ nv50_wndw_atomic_check_lut(struct nv50_wndw *wndw, asyh->wndw.olut &= ~BIT (wndw->id); } -if (!ilut && wndw->func->ilut_identity) { +if (!ilut && wndw->func->ilut_identity && + asyw->state.fb->format->format !=DRM_FORMAT_XBGR16161616F && + asyw->state.fb->format->format !=DRM_FORMAT_ABGR16161616F ) {static struct drm_property_blob dummy = {}; ilut = &dummy; }
Signature · 6 lines
2.20.1 _______________________________________________ Nouveau mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/nouveau
Sasha Levin
maintainerPATCH 43/70 drm/nouveau/volt: Fix for some cards having 0 maximum voltage
In reply to Sasha LevinFrom: Mark Menzynski <[email protected]>
[ Upstream commit a1af2afbd244089560794c260b2d4326a86e39b6 ]
Some, mostly Fermi, vbioses appear to have zero max voltage. That causes Nouveau to not parse voltage entries, thus users not being able to set higher clocks.
When changing this value Nvidia driver still appeared to ignore it, and I wasn't able to find out why, thus the code is ignoring the value if it is zero.
--- drivers/gpu/drm/nouveau/nvkm/subdev/bios/volt.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/gpu/drm/nouveau/nvkm/subdev/bios/volt.c +2 -0
@@ -96,6 +96,8 @@ nvbios_volt_parse(struct nvkm_bios *bios, u8 *ver, u8 *hdr, u8 *cnt, u8 *len, info->min =min (info->base, info->base + info->step * info->vidmask); info->max =nvbios_rd32 (bios, volt +0x0e ); +if (!info->max) + info->max =max (info->base, info->base + info->step * info->vidmask);break ;case 0x50 : info->min =nvbios_rd32 (bios, volt +0x0a );
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 44/70 pinctrl: amd: disable spurious-firing GPIO IRQs
In reply to Sasha LevinFrom: Daniel Drake <[email protected]>
[ Upstream commit d21b8adbd475dba19ac2086d3306327b4a297418 ]
When cold-booting Asus X434DA, GPIO 7 is found to be already configured as an interrupt, and the GPIO level is found to be in a state that causes the interrupt to fire.
As soon as pinctrl-amd probes, this interrupt fires and invokes amd_gpio_irq_handler(). The IRQ is acked, but no GPIO-IRQ handler was invoked, so the GPIO level being unchanged just causes another interrupt to fire again immediately after.
This results in an interrupt storm causing this platform to hang during boot, right after pinctrl-amd is probed.
Detect this situation and disable the GPIO interrupt when this happens. This enables the affected platform to boot as normal. GPIO 7 actually is the I2C touchpad interrupt line, and later on, i2c-multitouch loads and re-enables this interrupt when it is ready to handle it.
Instead of this approach, I considered disabling all GPIO interrupts at probe time, however that seems a little risky, and I also confirmed that Windows does not seem to have this behaviour: the same 41 GPIO IRQs are enabled under both Linux and Windows, which is a far larger collection than the GPIOs referenced by the DSDT on this platform.
--- drivers/pinctrl/pinctrl-amd.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
drivers/pinctrl/pinctrl-amd.c +11 -1
@@ -565,15 +565,25 @@ static irqreturn_t amd_gpio_irq_handler(int irq, void *dev_id) !(regval & BIT(INTERRUPT_MASK_OFF)))continue ; irq =irq_find_mapping (gc->irq.domain, irqnr + i); -generic_handle_irq (irq); +if (irq !=0 ) +generic_handle_irq (irq);/* Clear interrupt. * We must read the pin register again, in case the * value was changed while executing * generic_handle_irq() above. +* If we didn't find a mapping for the interrupt, +* disable it in order to avoid a system hang caused +* by an interrupt storm. */ raw_spin_lock_irqsave (&gpio_dev->lock, flags); regval =readl (regs + i); +if (irq ==0 ) { + regval &= ~BIT (INTERRUPT_ENABLE_OFF ); +dev_dbg (&gpio_dev->pdev->dev, +"Disabling spurious GPIO IRQ %d\n" , + irqnr + i); + }writel (regval, regs + i);raw_spin_unlock_irqrestore (&gpio_dev->lock, flags); ret =IRQ_HANDLED ;
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 45/70 clk: renesas: mstp: Set GENPD_FLAG_ALWAYS_ON for clock domain
In reply to Sasha LevinFrom: Geert Uytterhoeven <[email protected]>
[ Upstream commit a459a184c978ca9ad538aab93aafdde873953f30 ]
The CPG/MSTP Clock Domain driver does not implement the generic_pm_domain.power_{on,off}() callbacks, as the domain itself cannot be powered down. Hence the domain should be marked as always-on by setting the GENPD_FLAG_ALWAYS_ON flag, to prevent the core PM Domain code from considering it for power-off, and doing unnessary processing.
This also gets rid of a boot warning when the Clock Domain contains an IRQ-safe device, e.g. on RZ/A1:
sh_mtu2 fcff0000.timer: PM domain cpg_clocks will not be powered off
--- drivers/clk/renesas/clk-mstp.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/clk/renesas/clk-mstp.c +2 -1
@@ -338,7 +338,8 @@ void __init cpg_mstp_add_clk_domain(struct device_node *np)return ; pd->name = np->name; - pd->flags =GENPD_FLAG_PM_CLK |GENPD_FLAG_ACTIVE_WAKEUP ; + pd->flags =GENPD_FLAG_PM_CLK |GENPD_FLAG_ALWAYS_ON | +GENPD_FLAG_ACTIVE_WAKEUP ; pd->attach_dev = cpg_mstp_attach_dev; pd->detach_dev = cpg_mstp_detach_dev;pm_genpd_init (pd, &pm_domain_always_on_gov, false);
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 46/70 clk: renesas: cpg-mssr: Set GENPD_FLAG_ALWAYS_ON for clock domain
In reply to Sasha LevinFrom: Geert Uytterhoeven <[email protected]>
[ Upstream commit f787216f33ce5b5a2567766398f44ab62157114c ]
The CPG/MSSR Clock Domain driver does not implement the generic_pm_domain.power_{on,off}() callbacks, as the domain itself cannot be powered down. Hence the domain should be marked as always-on by setting the GENPD_FLAG_ALWAYS_ON flag, to prevent the core PM Domain code from considering it for power-off, and doing unnessary processing.
Note that this only affects RZ/A2 SoCs. On R-Car Gen2 and Gen3 SoCs, the R-Car SYSC driver handles Clock Domain creation, and offloads only device attachment/detachment to the CPG/MSSR driver.
--- drivers/clk/renesas/renesas-cpg-mssr.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/clk/renesas/renesas-cpg-mssr.c +2 -1
@@ -555,7 +555,8 @@ static int __init cpg_mssr_add_clk_domain(struct device *dev, genpd = &pd->genpd; genpd->name = np->name; - genpd->flags =GENPD_FLAG_PM_CLK |GENPD_FLAG_ACTIVE_WAKEUP ; + genpd->flags =GENPD_FLAG_PM_CLK |GENPD_FLAG_ALWAYS_ON | +GENPD_FLAG_ACTIVE_WAKEUP ; genpd->attach_dev = cpg_mssr_attach_dev; genpd->detach_dev = cpg_mssr_detach_dev;pm_genpd_init (genpd, &pm_domain_always_on_gov, false);
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 47/70 drm/amd/display: support spdif
In reply to Sasha LevinFrom: Charlene Liu <[email protected]>
[ Upstream commit b5a41620bb88efb9fb31a4fa5e652e3d5bead7d4 ]
[Description]
port spdif fix to staging:
spdif hardwired to afmt inst 1.
spdif func pointer
spdif resource allocation (reserve last audio endpoint for spdif only)
--- .../gpu/drm/amd/display/dc/core/dc_resource.c | 17 ++++++++--------- drivers/gpu/drm/amd/display/dc/dce/dce_audio.c | 4 ++-- 2 files changed, 10 insertions(+), 11 deletions(-)
drivers/gpu/drm/amd/display/dc/core/dc_resource.c +8 -9
@@ -261,12 +261,10 @@ bool resource_construct(DC_ERR ("DC: failed to create audio!\n" );return false; } -if (!aud->funcs->endpoint_valid (aud)) { aud->funcs->destroy (&aud);break ; } - pool->audios[i] = aud; pool->audio_count++; }
@@ -1692,24 +1690,25 @@ static struct audio *find_first_free_audio(const struct resource_pool *pool, enum engine_id id) { - int i; -for (i =0 ; i < pool->audio_count; i++) { + int i, available_audio_count; + + available_audio_count = pool->audio_count; + +for (i =0 ; i < available_audio_count; i++) {if ((res_ctx->is_audio_acquired[i] == false) && (res_ctx->is_stream_enc_acquired[i] == true)) {/*we have enough audio endpoint, find the matching inst*/ if (id != i)continue ; -return pool->audios[i]; } } -/* use engine id to find free audio */ -if ((id < pool->audio_count) && (res_ctx->is_audio_acquired[id] == false)) { +/* use engine id to find free audio */ +if ((id < available_audio_count) && (res_ctx->is_audio_acquired[id] == false)) {return pool->audios[id]; } -/*not found the matching one, first come first serve*/ -for (i =0 ; i < pool->audio_count; i++) { +for (i =0 ; i < available_audio_count; i++) {if (res_ctx->is_audio_acquired[i] == false) {return pool->audios[i]; }
drivers/gpu/drm/amd/display/dc/dce/dce_audio.c +2 -2
@@ -611,6 +611,8 @@ void dce_aud_az_configure(AZ_REG_WRITE (AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO1 , value); +DC_LOG_HW_AUDIO ("\n\tAUDIO:az_configure: index: %u data, 0x%x, displayName %s: \n" , + audio->inst, value, audio_info->display_name);/* *write the port ID:
@@ -922,7 +924,6 @@ static const struct audio_funcs funcs = { .az_configure = dce_aud_az_configure, .destroy = dce_aud_destroy, }; -void dce_aud_destroy (struct audio **audio) {struct dce_audio *aud =DCE_AUD (*audio);
@@ -953,7 +954,6 @@ struct audio *dce_audio_create( audio->regs = reg; audio->shifts = shifts; audio->masks = masks; -return &audio->base; }
Signature · 6 lines
2.20.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Sasha Levin
maintainerPATCH 48/70 selftests/powerpc: Retry on host facility unavailable
In reply to Sasha LevinFrom: Gustavo Romero <[email protected]>
[ Upstream commit 6652bf6408895b09d31fd4128a1589a1a0672823 ]
TM test tm-unavailable must take into account aborts due to host aborting a transactin because of a facility unavailable exception, just like it already does for aborts on reschedules (TM_CAUSE_KVM_RESCHED).
--- tools/testing/selftests/powerpc/tm/tm.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
tools/testing/selftests/powerpc/tm/tm.h +2 -1
@@ -55,7 +55,8 @@ static inline bool failure_is_unavailable(void)static inline bool failure_is_reschedule (void ) {if ((failure_code () &TM_CAUSE_RESCHED ) ==TM_CAUSE_RESCHED || - (failure_code () &TM_CAUSE_KVM_RESCHED ) ==TM_CAUSE_KVM_RESCHED ) + (failure_code () &TM_CAUSE_KVM_RESCHED ) ==TM_CAUSE_KVM_RESCHED || + (failure_code () &TM_CAUSE_KVM_FAC_UNAV ) ==TM_CAUSE_KVM_FAC_UNAV )return true;return false;
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 49/70 drm/amdgpu/si: fix ASIC tests
In reply to Sasha LevinFrom: Jean Delvare <[email protected]>
[ Upstream commit 77efe48a729588527afb4d5811b9e0acb29f5e51 ]
Comparing adev->family with CHIP constants is not correct. adev->family can only be compared with AMDGPU_FAMILY constants and adev->asic_type is the struct member to compare with CHIP constants. They are separate identification spaces.
--- drivers/gpu/drm/amd/amdgpu/si.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/gpu/drm/amd/amdgpu/si.c +3 -3
@@ -1867,7 +1867,7 @@ static void si_program_aspm(struct amdgpu_device *adev)if (orig != data)si_pif_phy1_wreg (adev,PB1_PIF_PWRDOWN_1 , data); -if ((adev->family !=CHIP_OLAND ) && (adev->family !=CHIP_HAINAN )) { +if ((adev->asic_type !=CHIP_OLAND ) && (adev->asic_type !=CHIP_HAINAN )) { orig = data =si_pif_phy0_rreg (adev,PB0_PIF_PWRDOWN_0 ); data &= ~PLL_RAMP_UP_TIME_0_MASK ;if (orig != data)
@@ -1916,14 +1916,14 @@ static void si_program_aspm(struct amdgpu_device *adev) orig = data =si_pif_phy0_rreg (adev,PB0_PIF_CNTL ); data &= ~LS2_EXIT_TIME_MASK ; -if ((adev->family ==CHIP_OLAND ) || (adev->family ==CHIP_HAINAN )) +if ((adev->asic_type ==CHIP_OLAND ) || (adev->asic_type ==CHIP_HAINAN )) data |=LS2_EXIT_TIME (5 );if (orig != data)si_pif_phy0_wreg (adev,PB0_PIF_CNTL , data); orig = data =si_pif_phy1_rreg (adev,PB1_PIF_CNTL ); data &= ~LS2_EXIT_TIME_MASK ; -if ((adev->family ==CHIP_OLAND ) || (adev->family ==CHIP_HAINAN )) +if ((adev->asic_type ==CHIP_OLAND ) || (adev->asic_type ==CHIP_HAINAN )) data |=LS2_EXIT_TIME (5 );if (orig != data)si_pif_phy1_wreg (adev,PB1_PIF_CNTL , data);
Signature · 6 lines
2.20.1 _______________________________________________ amd-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/amd-gfx
Sasha Levin
maintainerPATCH 50/70 powerpc/64s/exception: machine check use correct cfar for late handler
In reply to Sasha LevinFrom: Nicholas Piggin <[email protected]>
[ Upstream commit 0b66370c61fcf5fcc1d6901013e110284da6e2bb ]
Bare metal machine checks run an "early" handler in real mode before running the main handler which reports the event.
The main handler runs exactly as a normal interrupt handler, after the "windup" which sets registers back as they were at interrupt entry. CFAR does not get restored by the windup code, so that will be wrong when the handler is run.
Restore the CFAR to the saved value before running the late handler.
--- arch/powerpc/kernel/exceptions-64s.S | 4 ++++ 1 file changed, 4 insertions(+)
arch/powerpc/kernel/exceptions-64s.S +4 -0
@@ -556,6 +556,10 @@ FTR_SECTION_ELSE ALT_FTR_SECTION_END_IFSET(CPU_FTR_HVMODE) 9: /* Deliver the machine check to host kernel in V mode. */ +BEGIN_FTR_SECTION + ld r10,ORIG_GPR3(r1) + mtspr SPRN_CFAR,r10 +END_FTR_SECTION_IFSET(CPU_FTR_CFAR) MACHINE_CHECK_HANDLER_WINDUP SET_SCRATCH0(r13) /* save r13 */ EXCEPTION_PROLOG_0(PACA_EXMC)
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 51/70 pstore: fs superblock limits
In reply to Sasha LevinFrom: Deepa Dinamani <[email protected]>
[ Upstream commit 83b8a3fbe3aa82ac3c253b698ae6a9be2dbdd5e0 ]
Leaving granularity at 1ns because it is dependent on the specific attached backing pstore module. ramoops has microsecond resolution.
Fix the readback of ramoops fractional timestamp microseconds, which has incorrectly been reporting the value as nanoseconds.
--- fs/pstore/ram.c | 2 ++ 1 file changed, 2 insertions(+)
fs/pstore/ram.c +2 -0
@@ -144,6 +144,7 @@ static int ramoops_read_kmsg_hdr(char *buffer, struct timespec64 *time,if (sscanf (buffer,RAMOOPS_KERNMSG_HDR "%lld.%lu-%c\n%n" , (time64_t *)&time->tv_sec, &time->tv_nsec, &data_type, &header_length) ==3 ) { + time->tv_nsec *=1000 ;if (data_type =='C' ) *compressed = true;else
@@ -151,6 +152,7 @@ static int ramoops_read_kmsg_hdr(char *buffer, struct timespec64 *time, }else if (sscanf (buffer,RAMOOPS_KERNMSG_HDR "%lld.%lu\n%n" , (time64_t *)&time->tv_sec, &time->tv_nsec, &header_length) ==2 ) { + time->tv_nsec *=1000 ; *compressed = false; }else { time->tv_sec =0 ;
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 52/70 powerpc/eeh: Clean up EEH PEs after recovery finishes
In reply to Sasha LevinFrom: Oliver O'Halloran <[email protected]>
[ Upstream commit 799abe283e5103d48e079149579b4f167c95ea0e ]
When the last device in an eeh_pe is removed the eeh_pe structure itself (and any empty parents) are freed since they are no longer needed. This results in a crash when a hotplug driver is involved since the following may occur:
1. Device is suprise removed.
2. Driver performs an MMIO, which fails and queues and eeh_event.
3. Hotplug driver receives a hotplug interrupt and removes any pci_devs that were under the slot.
4. pci_dev is torn down and the eeh_pe is freed.
5. The EEH event handler thread processes the eeh_event and crashes since the eeh_pe pointer in the eeh_event structure is no longer valid.
Crashing is generally considered poor form. Instead of doing that use the fact PEs are marked as EEH_PE_INVALID to keep them around until the end of the recovery cycle, at which point we can safely prune any empty PEs.
--- arch/powerpc/kernel/eeh_driver.c | 36 ++++++++++++++++++++++++++++++-- arch/powerpc/kernel/eeh_event.c | 8 +++++++ arch/powerpc/kernel/eeh_pe.c | 23 +++++++++++++++++++- 3 files changed, 64 insertions(+), 3 deletions(-)
arch/powerpc/kernel/eeh_driver.c +34 -2
@@ -744,6 +744,33 @@ static int eeh_reset_device(struct eeh_pe *pe, struct pci_bus *bus,*/ #define MAX_WAIT_FOR_RECOVERY 300 + +/* Walks the PE tree after processing an event to remove any stale PEs. +* +* NB: This needs to be recursive to ensure the leaf PEs get removed +* before their parents do. Although this is possible to do recursively +* we don't since this is easier to read and we need to garantee +* the leaf nodes will be handled first. +*/ +static void eeh_pe_cleanup (struct eeh_pe *pe) +{ +struct eeh_pe *child_pe, *tmp; + +list_for_each_entry_safe (child_pe, tmp, &pe->child_list, child) +eeh_pe_cleanup (child_pe); + +if (pe->state &EEH_PE_KEEP ) +return ; + +if (!(pe->state &EEH_PE_INVALID )) +return ; + +if (list_empty (&pe->edevs) &&list_empty (&pe->child_list)) { +list_del (&pe->child); +kfree (pe); + } +} +/** * eeh_handle_normal_event - Handle EEH events on a specific PE * @pe: EEH PE - which should not be used after we return, as it may
@@ -782,8 +809,6 @@ void eeh_handle_normal_event(struct eeh_pe *pe)return ; } -eeh_pe_state_mark (pe,EEH_PE_RECOVERING ); -eeh_pe_update_time_stamp (pe); pe->freeze_count++;if (pe->freeze_count > eeh_max_freezes) {
@@ -973,6 +998,12 @@ void eeh_handle_normal_event(struct eeh_pe *pe)return ; } } + +/* +* Clean up any PEs without devices. While marked as EEH_PE_RECOVERYING +* we don't want to modify the PE tree structure so we do it here. +*/ +eeh_pe_cleanup (pe);eeh_pe_state_clear (pe,EEH_PE_RECOVERING , true); }
@@ -1045,6 +1076,7 @@ void eeh_handle_special_event(void)*/ if (rc ==EEH_NEXT_ERR_FROZEN_PE || rc ==EEH_NEXT_ERR_FENCED_PHB ) { +eeh_pe_state_mark (pe,EEH_PE_RECOVERING );eeh_handle_normal_event (pe); }else {pci_lock_rescan_remove ();
arch/powerpc/kernel/eeh_event.c +8 -0
@@ -121,6 +121,14 @@ int __eeh_send_failure_event(struct eeh_pe *pe) } event->pe = pe; +/* +* Mark the PE as recovering before inserting it in the queue. +* This prevents the PE from being free()ed by a hotplug driver +* while the PE is sitting in the event queue. +*/ +if (pe) +eeh_pe_state_mark (pe,EEH_PE_RECOVERING ); +/* We may or may not be called in an interrupt context */ spin_lock_irqsave (&eeh_eventlist_lock, flags);list_add (&event->list, &eeh_eventlist);
arch/powerpc/kernel/eeh_pe.c +22 -1
@@ -491,6 +491,7 @@ int eeh_add_to_parent_pe(struct eeh_dev *edev)int eeh_rmv_from_parent_pe (struct eeh_dev *edev) {struct eeh_pe *pe, *parent, *child; +bool keep, recover;int cnt;struct pci_dn *pdn =eeh_dev_to_pdn (edev);
@@ -516,10 +517,21 @@ int eeh_rmv_from_parent_pe(struct eeh_dev *edev)*/ while (1 ) { parent = pe->parent; + +/* PHB PEs should never be removed */ if (pe->type &EEH_PE_PHB )break ; -if (!(pe->state &EEH_PE_KEEP )) { +/* +* XXX: KEEP is set while resetting a PE. I don't think it's +* ever set without RECOVERING also being set. I could +* be wrong though so catch that with a WARN. +*/ + keep = !!(pe->state &EEH_PE_KEEP ); + recover = !!(pe->state &EEH_PE_RECOVERING ); +WARN_ON (keep && !recover); + +if (!keep && !recover) {if (list_empty (&pe->edevs) &&list_empty (&pe->child_list)) {list_del (&pe->child);
@@ -528,6 +540,15 @@ int eeh_rmv_from_parent_pe(struct eeh_dev *edev)break ; } }else { +/* +* Mark the PE as invalid. At the end of the recovery +* process any invalid PEs will be garbage collected. +* +* We need to delay the free()ing of them since we can +* remove edev's while traversing the PE tree which +* might trigger the removal of a PE and we can't +* deal with that (yet). +*/ if (list_empty (&pe->edevs)) { cnt =0 ;list_for_each_entry (child, &pe->child_list, child) {
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 53/70 powerpc/imc: Dont create debugfs files for cpu-less nodes
In reply to Sasha LevinFrom: Madhavan Srinivasan <[email protected]>
[ Upstream commit 41ba17f20ea835c489e77bd54e2da73184e22060 ]
Commit <684d984038aa> ('powerpc/powernv: Add debugfs interface for imc-mode and imc') added debugfs interface for the nest imc pmu devices to support changing of different ucode modes. Primarily adding this capability for debug. But when doing so, the code did not consider the case of cpu-less nodes. So when reading the _cmd_ or _mode_ file of a cpu-less node will create this crash.
Faulting instruction address: 0xc0000000000d0d58
Oops: Kernel access of bad area, sig: 11 [#1]
...
CPU: 67 PID: 5301 Comm: cat Not tainted 5.2.0-rc6-next-20190627+ #19
NIP: c0000000000d0d58 LR: c00000000049aa18 CTR:c0000000000d0d50
REGS: c00020194548f9e0 TRAP: 0300 Not tainted (5.2.0-rc6-next-20190627+)
MSR: 9000000000009033 <SF,HV,EE,ME,IR,DR,RI,LE> CR:28022822 XER: 00000000
CFAR: c00000000049aa14 DAR: 000000000003fc08 DSISR:40000000 IRQMASK: 0
...
NIP imc_mem_get+0x8/0x20
LR simple_attr_read+0x118/0x170
Call Trace:
simple_attr_read+0x70/0x170 (unreliable)
debugfs_attr_read+0x6c/0xb0
__vfs_read+0x3c/0x70
vfs_read+0xbc/0x1a0
ksys_read+0x7c/0x140
system_call+0x5c/0x70Patch fixes the issue with a more robust check for vbase to NULL.
Before patch, ls output for the debugfs imc directory
# ls /sys/kernel/debug/powerpc/imc/ imc_cmd_0 imc_cmd_251 imc_cmd_253 imc_cmd_255 imc_mode_0 imc_mode_251 imc_mode_253 imc_mode_255 imc_cmd_250 imc_cmd_252 imc_cmd_254 imc_cmd_8 imc_mode_250 imc_mode_252 imc_mode_254 imc_mode_8
After patch, ls output for the debugfs imc directory
# ls /sys/kernel/debug/powerpc/imc/ imc_cmd_0 imc_cmd_8 imc_mode_0 imc_mode_8
Actual bug here is that, we have two loops with potentially different loop counts. That is, in imc_get_mem_addr_nest(), loop count is obtained from the dt entries. But in case of export_imc_mode_and_cmd(), loop was based on for_each_nid() count. Patch fixes the loop count in latter based on the struct mem_info. Ideally it would be better to have array size in struct imc_pmu.
--- arch/powerpc/platforms/powernv/opal-imc.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
arch/powerpc/platforms/powernv/opal-imc.c +6 -6
@@ -53,9 +53,9 @@ static void export_imc_mode_and_cmd(struct device_node *node, struct imc_pmu *pmu_ptr) {static u64 loc, *imc_mode_addr, *imc_cmd_addr; -int chip =0 , nid;char mode[16 ], cmd[16 ];u32 cb_offset; +struct imc_mem_info *ptr = pmu_ptr->mem_info; imc_debugfs_parent =debugfs_create_dir ("imc" , powerpc_debugfs_root);
@@ -69,20 +69,20 @@ static void export_imc_mode_and_cmd(struct device_node *node,if (of_property_read_u32 (node,"cb_offset" , &cb_offset)) cb_offset =IMC_CNTL_BLK_OFFSET ; -for_each_node (nid) { - loc = (u64)(pmu_ptr->mem_info[chip].vbase) + cb_offset; +while (ptr->vbase !=NULL ) { + loc = (u64)(ptr->vbase) + cb_offset; imc_mode_addr = (u64 *)(loc +IMC_CNTL_BLK_MODE_OFFSET ); -sprintf (mode,"imc_mode_%d" , nid); +sprintf (mode,"imc_mode_%d" , (u32)(ptr->id));if (!imc_debugfs_create_x64 (mode,0600 , imc_debugfs_parent, imc_mode_addr)) goto err; imc_cmd_addr = (u64 *)(loc +IMC_CNTL_BLK_CMD_OFFSET ); -sprintf (cmd,"imc_cmd_%d" , nid); +sprintf (cmd,"imc_cmd_%d" , (u32)(ptr->id));if (!imc_debugfs_create_x64 (cmd,0600 , imc_debugfs_parent, imc_cmd_addr)) goto err; - chip++; + ptr++; }return ;
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 54/70 clk: qcom: gcc-sdm845: Use floor ops for sdcc clks
In reply to Sasha LevinFrom: Stephen Boyd <[email protected]>
[ Upstream commit 5e4b7e82d497580bc430576c4c9bce157dd72512 ]
Some MMC cards fail to enumerate properly when inserted into an MMC slot on sdm845 devices. This is because the clk ops for qcom clks round the frequency up to the nearest rate instead of down to the nearest rate. For example, the MMC driver requests a frequency of 52MHz from clk_set_rate() but the qcom implementation for these clks rounds 52MHz up to the next supported frequency of 100MHz. The MMC driver could be modified to request clk rate ranges but for now we can fix this in the clk driver by changing the rounding policy for this clk to be round down instead of round up.
--- drivers/clk/qcom/gcc-sdm845.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/clk/qcom/gcc-sdm845.c +2 -2
@@ -685,7 +685,7 @@ static struct clk_rcg2 gcc_sdcc2_apps_clk_src = { .name = "gcc_sdcc2_apps_clk_src", .parent_names = gcc_parent_names_10, .num_parents = 5, - .ops = &clk_rcg2_ops, + .ops = &clk_rcg2_floor_ops, }, };
@@ -709,7 +709,7 @@ static struct clk_rcg2 gcc_sdcc4_apps_clk_src = { .name = "gcc_sdcc4_apps_clk_src", .parent_names = gcc_parent_names_0, .num_parents = 4, - .ops = &clk_rcg2_ops, + .ops = &clk_rcg2_floor_ops, }, };
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 55/70 powerpc/pseries: correctly track irq state in default idle
In reply to Sasha LevinFrom: Nathan Lynch <[email protected]>
[ Upstream commit 92c94dfb69e350471473fd3075c74bc68150879e ]
prep_irq_for_idle() is intended to be called before entering H_CEDE (and it is used by the pseries cpuidle driver). However the default pseries idle routine does not call it, leading to mismanaged lazy irq state when the cpuidle driver isn't in use. Manifestations of this include:
* Dropped IPIs in the time immediately after a cpu comes online (before it has installed the cpuidle handler), making the online operation block indefinitely waiting for the new cpu to respond.
* Hitting this WARN_ON in arch_local_irq_restore():
/* * We should already be hard disabled here. We had bugs * where that wasn't the case so let's dbl check it and * warn if we are wrong. Only do that when IRQ tracing * is enabled as mfmsr() can be costly. */ if (WARN_ON_ONCE(mfmsr() & MSR_EE)) __hard_irq_disable();
Call prep_irq_for_idle() from pseries_lpar_idle() and honor its result.
--- arch/powerpc/platforms/pseries/setup.c | 3 +++ 1 file changed, 3 insertions(+)
arch/powerpc/platforms/pseries/setup.c +3 -0
@@ -344,6 +344,9 @@ static void pseries_lpar_idle(void)* low power mode by ceding processor to hypervisor */ +if (!prep_irq_for_idle ()) +return ; +/* Indicate to hypervisor that we are idle. */ get_lppaca ()->idle =1 ;
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 56/70 pinctrl: meson-gxbb: Fix wrong pinning definition for uart_c
In reply to Sasha LevinFrom: Otto Meier <[email protected]>
[ Upstream commit cb0438e4436085d89706b5ccfce4d5da531253de ]
Hi i tried to use the uart_C of the the odroid-c2.
I enabled it in the dts file. During boot it crashed when the the sdcard slot is addressed.
After long search in the net i found this:
https://forum.odroid.com/viewtopic.php?f=139&t=25371&p=194370&hilit=uart_C#p177856
After changing the pin definitions accordingly erverything works. Uart_c is functioning and sdcard ist working.
--- drivers/pinctrl/meson/pinctrl-meson-gxbb.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
drivers/pinctrl/meson/pinctrl-meson-gxbb.c +6 -6
@@ -192,8 +192,8 @@ static const unsigned int uart_rts_b_pins[] = { GPIODV_27 };static const unsigned int uart_tx_c_pins[] = {GPIOY_13 };static const unsigned int uart_rx_c_pins[] = {GPIOY_14 }; -static const unsigned int uart_cts_c_pins[] = {GPIOX_11 }; -static const unsigned int uart_rts_c_pins[] = {GPIOX_12 }; +static const unsigned int uart_cts_c_pins[] = {GPIOY_11 }; +static const unsigned int uart_rts_c_pins[] = {GPIOY_12 };static const unsigned int i2c_sck_a_pins[] = {GPIODV_25 };static const unsigned int i2c_sda_a_pins[] = {GPIODV_24 };
@@ -439,10 +439,10 @@ static struct meson_pmx_group meson_gxbb_periphs_groups[] = {GROUP (pwm_f_x,3 ,18 ),/* Bank Y */ -GROUP (uart_cts_c,1 ,19 ), -GROUP (uart_rts_c,1 ,18 ), -GROUP (uart_tx_c,1 ,17 ), -GROUP (uart_rx_c,1 ,16 ), +GROUP (uart_cts_c,1 ,17 ), +GROUP (uart_rts_c,1 ,16 ), +GROUP (uart_tx_c,1 ,19 ), +GROUP (uart_rx_c,1 ,18 ),GROUP (pwm_a_y,1 ,21 ),GROUP (pwm_f_y,1 ,20 ), GROUP(i2s_out_ch23_y, 1, 5),
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 57/70 mailbox: mediatek: cmdq: clear the event in cmdq initial flow
In reply to Sasha LevinFrom: Bibby Hsieh <[email protected]>
[ Upstream commit 6058f11870b8e6d4f5cc7b591097c00bf69a000d ]
GCE hardware stored event information in own internal sysram, if the initial value in those sysram is not zero value it will cause a situation that gce can wait the event immediately after client ask gce to wait event but not really trigger the corresponding hardware.
In order to make sure that the wait event function is exactly correct, we need to clear the sysram value in cmdq initial flow.
--- drivers/mailbox/mtk-cmdq-mailbox.c | 5 +++++ include/linux/mailbox/mtk-cmdq-mailbox.h | 3 +++ include/linux/soc/mediatek/mtk-cmdq.h | 3 --- 3 files changed, 8 insertions(+), 3 deletions(-)
drivers/mailbox/mtk-cmdq-mailbox.c +5 -0
@@ -22,6 +22,7 @@#define CMDQ_NUM_CMD (t) (t->cmd_buf_size / CMDQ_INST_SIZE)#define CMDQ_CURR_IRQ_STATUS 0x10 +#define CMDQ_SYNC_TOKEN_UPDATE 0x68#define CMDQ_THR_SLOT_CYCLES 0x30#define CMDQ_THR_BASE 0x100#define CMDQ_THR_SIZE 0x80
@@ -104,8 +105,12 @@ static void cmdq_thread_resume(struct cmdq_thread *thread)static void cmdq_init (struct cmdq *cmdq) { +int i; +WARN_ON (clk_enable (cmdq->clock) <0 );writel (CMDQ_THR_ACTIVE_SLOT_CYCLES , cmdq->base +CMDQ_THR_SLOT_CYCLES ); +for (i =0 ; i <=CMDQ_MAX_EVENT ; i++) +writel (i, cmdq->base +CMDQ_SYNC_TOKEN_UPDATE );clk_disable (cmdq->clock); }
include/linux/mailbox/mtk-cmdq-mailbox.h +3 -0
@@ -20,6 +20,9 @@#define CMDQ_WFE_WAIT BIT(15)#define CMDQ_WFE_WAIT_VALUE 0x1 +/** cmdq event maximum */ +#define CMDQ_MAX_EVENT 0x3ff +/* * CMDQ_CODE_MASK: * set write mask
include/linux/soc/mediatek/mtk-cmdq.h +0 -3
@@ -13,9 +13,6 @@#define CMDQ_NO_TIMEOUT 0xffffffffu -/** cmdq event maximum */ -#define CMDQ_MAX_EVENT 0x3ff -struct cmdq_pkt ;struct cmdq_client {
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 58/70 arm64: fix unreachable code issue with cmpxchg
In reply to Sasha LevinFrom: Arnd Bergmann <[email protected]>
[ Upstream commit 920fdab7b3ce98c14c840261e364f490f3679a62 ]
On arm64 build with clang, sometimes the __cmpxchg_mb is not inlined when CONFIG_OPTIMIZE_INLINING is set.
Clang then fails a compile-time assertion, because it cannot tell at compile time what the size of the argument is:
mm/memcontrol.o: In function `__cmpxchg_mb':
memcontrol.c:(.text+0x1a4c): undefined reference to __compiletime_assert_175' memcontrol.c:(.text+0x1a4c): relocation truncated to fit: R_AARCH64_CALL26 against undefined symbol __compiletime_assert_175'
Mark all of the cmpxchg() style functions as __always_inline to ensure that the compiler can see the result.
--- arch/arm64/include/asm/cmpxchg.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
arch/arm64/include/asm/cmpxchg.h +3 -3
@@ -63,7 +63,7 @@ __XCHG_CASE( , , mb_, 64, dmb ish, nop, , a, l, "memory")#undef __XCHG_CASE#define __XCHG_GEN (sfx) \ -static inline unsigned long __xchg##sfx(unsigned long x, \ +static __always_inline unsigned long __xchg##sfx(unsigned long x, \ volatile void *ptr, \ int size) \ { \
@@ -105,7 +105,7 @@ __XCHG_GEN(_mb)#define arch_xchg (...) __xchg_wrapper( _mb, __VA_ARGS__)#define __CMPXCHG_GEN (sfx) \ -static inline unsigned long __cmpxchg##sfx(volatile void *ptr, \ +static __always_inline unsigned long __cmpxchg##sfx(volatile void *ptr, \ unsigned long old, \ unsigned long new, \ int size) \
@@ -212,7 +212,7 @@ __CMPWAIT_CASE( , , 64);#undef __CMPWAIT_CASE#define __CMPWAIT_GEN (sfx) \ -static inline void __cmpwait##sfx(volatile void *ptr, \ +static __always_inline void __cmpwait##sfx(volatile void *ptr, \ unsigned long val, \ int size) \ { \
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 59/70 clk: at91: select parent if main oscillator or bypass is enabled
In reply to Sasha LevinFrom: Eugen Hristev <[email protected]>
[ Upstream commit 69a6bcde7fd3fe6f3268ce26f31d9d9378384c98 ]
Selecting the right parent for the main clock is done using only main oscillator enabled bit.
In case we have this oscillator bypassed by an external signal (no driving on the XOUT line), we still use external clock, but with BYPASS bit set. So, in this case we must select the same parent as before. Create a macro that will select the right parent considering both bits from the MOR register.
Use this macro when looking for the right parent.
--- drivers/clk/at91/clk-main.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
drivers/clk/at91/clk-main.c +7 -3
@@ -21,6 +21,10 @@#define MOR_KEY_MASK (0xff << 16) +#define clk_main_parent_select (s) (((s) & \ + (AT91_PMC_MOSCEN | \ + AT91_PMC_OSCBYPASS)) ? 1 : 0) +struct clk_main_osc {struct clk_hw hw;struct regmap *regmap;
@@ -113,7 +117,7 @@ static int clk_main_osc_is_prepared(struct clk_hw *hw)regmap_read (regmap,AT91_PMC_SR , &status); -return (status &AT91_PMC_MOSCS ) && (tmp &AT91_PMC_MOSCEN ); +return (status &AT91_PMC_MOSCS ) &&clk_main_parent_select (tmp); }static const struct clk_ops main_osc_ops = {
@@ -450,7 +454,7 @@ static u8 clk_sam9x5_main_get_parent(struct clk_hw *hw)regmap_read (clkmain->regmap,AT91_CKGR_MOR , &status); -return status &AT91_PMC_MOSCEN ?1 :0 ; +return clk_main_parent_select (status); }static const struct clk_ops sam9x5_main_ops = {
@@ -492,7 +496,7 @@ at91_clk_register_sam9x5_main(struct regmap *regmap, clkmain->hw.init = &init; clkmain->regmap = regmap;regmap_read (clkmain->regmap,AT91_CKGR_MOR , &status); - clkmain->parent = status &AT91_PMC_MOSCEN ?1 :0 ; + clkmain->parent =clk_main_parent_select (status); hw = &clkmain->hw; ret =clk_hw_register (NULL , &clkmain->hw);
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 60/70 clk: imx: pll14xx: avoid glitch when set rate
In reply to Sasha LevinFrom: Peng Fan <[email protected]>
[ Upstream commit dee1bc9c23cd41fe32549c0adbe6cb57cab02282 ]
According to PLL1443XA and PLL1416X spec,
"When BYPASS is 0 and RESETB is changed from 0 to 1, FOUT starts to output unstable clock until lock time passes. PLL1416X/PLL1443XA may generate a glitch at FOUT."
So set BYPASS when RESETB is changed from 0 to 1 to avoid glitch. In the end of set rate, BYPASS will be cleared.
When prepare clock, also need to take care to avoid glitch. So we also follow Spec to set BYPASS before RESETB changed from 0 to 1. And add a check if the RESETB is already 0, directly return 0;
--- drivers/clk/imx/clk-pll14xx.c | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-)
drivers/clk/imx/clk-pll14xx.c +21 -1
@@ -191,6 +191,10 @@ static int clk_pll1416x_set_rate(struct clk_hw *hw, unsigned long drate, tmp &= ~RST_MASK ;writel_relaxed (tmp, pll->base); +/* Enable BYPASS */ + tmp |=BYPASS_MASK ; +writel (tmp, pll->base); + div_val = (rate->mdiv <<MDIV_SHIFT ) | (rate->pdiv <<PDIV_SHIFT ) | (rate->sdiv <<SDIV_SHIFT );writel_relaxed (div_val, pll->base +0x4 );
@@ -250,6 +254,10 @@ static int clk_pll1443x_set_rate(struct clk_hw *hw, unsigned long drate, tmp &= ~RST_MASK ;writel_relaxed (tmp, pll->base); +/* Enable BYPASS */ + tmp |=BYPASS_MASK ; +writel_relaxed (tmp, pll->base); + div_val = (rate->mdiv <<MDIV_SHIFT ) | (rate->pdiv <<PDIV_SHIFT ) | (rate->sdiv <<SDIV_SHIFT );writel_relaxed (div_val, pll->base +0x4 );
@@ -283,16 +291,28 @@ static int clk_pll14xx_prepare(struct clk_hw *hw) {struct clk_pll14xx *pll =to_clk_pll14xx (hw);u32 val; +int ret;/* * RESETB = 1 from 0, PLL starts its normal * operation after lock time */ val =readl_relaxed (pll->base +GNRL_CTL ); +if (val &RST_MASK ) +return 0 ; + val |=BYPASS_MASK ; +writel_relaxed (val, pll->base +GNRL_CTL ); val |=RST_MASK ;writel_relaxed (val, pll->base +GNRL_CTL ); -return clk_pll14xx_wait_lock (pll); + ret =clk_pll14xx_wait_lock (pll); +if (ret) +return ret; + + val &= ~BYPASS_MASK ; +writel_relaxed (val, pll->base +GNRL_CTL ); + +return 0 ; }static int clk_pll14xx_is_prepared (struct clk_hw *hw)
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 61/70 clk: imx: clk-pll14xx: unbypass PLL by default
In reply to Sasha LevinFrom: Peng Fan <[email protected]>
[ Upstream commit a9aa8306074d9519dd6e5fdf07240b01bac72e04 ]
When registering the PLL, unbypass the PLL.
The PLL has two bypass control bit, BYPASS and EXT_BYPASS. we will expose EXT_BYPASS to clk driver for mux usage, and keep BYPASS inside pll14xx usage. The PLL has a restriction that when M/P change, need to RESET/BYPASS pll to avoid glitch, so we could not expose BYPASS.
To make it easy for clk driver usage, unbypass PLL which does not hurt current function.
--- drivers/clk/imx/clk-pll14xx.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/clk/imx/clk-pll14xx.c +5 -0
@@ -368,6 +368,7 @@ struct clk *imx_clk_pll14xx(const char *name, const char *parent_name,struct clk_pll14xx *pll;struct clk *clk;struct clk_init_data init; +u32 val; pll =kzalloc (sizeof (*pll),GFP_KERNEL );if (!pll)
@@ -399,6 +400,10 @@ struct clk *imx_clk_pll14xx(const char *name, const char *parent_name, pll->rate_table = pll_clk->rate_table; pll->rate_count = pll_clk->rate_count; + val =readl_relaxed (pll->base +GNRL_CTL ); + val &= ~BYPASS_MASK ; +writel_relaxed (val, pll->base +GNRL_CTL ); + clk =clk_register (NULL , &pll->hw);if (IS_ERR (clk)) { pr_err("%s: failed to register pll %s %lu\n",
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 62/70 clk: Make clk_bulk_get_all() return a valid "id"
In reply to Sasha LevinFrom: Bjorn Andersson <[email protected]>
[ Upstream commit 7f81c2426587b34bf73e643c1a6d080dfa14cf8a ]
The adreno driver expects the "id" field of the returned clk_bulk_data to be filled in with strings from the clock-names property.
But due to the use of kmalloc_array() in of_clk_bulk_get_all() it receives a list of bogus pointers instead.
Zero-initialize the "id" field and attempt to populate with strings from the clock-names property to resolve both these issues.
--- drivers/clk/clk-bulk.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
drivers/clk/clk-bulk.c +4 -1
@@ -18,10 +18,13 @@ static int __must_check of_clk_bulk_get(struct device_node *np, int num_clks,int ret;int i; -for (i =0 ; i < num_clks; i++) +for (i =0 ; i < num_clks; i++) { + clks[i].id =NULL ; clks[i].clk =NULL ; + }for (i =0 ; i < num_clks; i++) { +of_property_read_string_index (np,"clock-names" , i, &clks[i].id); clks[i].clk =of_clk_get (np, i);if (IS_ERR (clks[i].clk)) { ret =PTR_ERR (clks[i].clk);
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 63/70 powerpc: dump kernel log before carrying out fadump or kdump
In reply to Sasha LevinFrom: Ganesh Goudar <[email protected]>
[ Upstream commit e7ca44ed3ba77fc26cf32650bb71584896662474 ]
Since commit 4388c9b3a6ee ("powerpc: Do not send system reset request through the oops path"), pstore dmesg file is not updated when dump is triggered from HMC. This commit modified system reset (sreset) handler to invoke fadump or kdump (if configured), without pushing dmesg to pstore. This leaves pstore to have old dmesg data which won't be much of a help if kdump fails to capture the dump. This patch fixes that by calling kmsg_dump() before heading to fadump ot kdump.
--- arch/powerpc/kernel/traps.c | 1 + 1 file changed, 1 insertion(+)
arch/powerpc/kernel/traps.c +1 -0
@@ -472,6 +472,7 @@ void system_reset_exception(struct pt_regs *regs)if (debugger (regs)) goto out; +kmsg_dump (KMSG_DUMP_OOPS );/* * A system reset is a request to dump, so we always send * it through the crashdump code (if fadump or kdump are
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 64/70 mbox: qcom: add APCS child device for QCS404
In reply to Sasha LevinFrom: Jorge Ramirez-Ortiz <[email protected]>
[ Upstream commit 78c86458a440ff356073c21b568cb58ddb67b82b ]
There is clock controller functionality in the APCS hardware block of qcs404 devices similar to msm8916.
--- drivers/mailbox/qcom-apcs-ipc-mailbox.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
drivers/mailbox/qcom-apcs-ipc-mailbox.c +6 -2
@@ -47,7 +47,6 @@ static const struct mbox_chan_ops qcom_apcs_ipc_ops = {static int qcom_apcs_ipc_probe (struct platform_device *pdev) { -struct device_node *np = pdev->dev.of_node;struct qcom_apcs_ipc *apcs;struct regmap *regmap;struct resource *res;
@@ -55,6 +54,11 @@ static int qcom_apcs_ipc_probe(struct platform_device *pdev)void __iomem *base;unsigned long i;int ret; +const struct of_device_id apcs_clk_match_table[] = { + { .compatible ="qcom,msm8916-apcs-kpss-global" , }, + { .compatible ="qcom,qcs404-apcs-apps-global" , }, + {} + }; apcs =devm_kzalloc (&pdev->dev,sizeof (*apcs),GFP_KERNEL );if (!apcs)
@@ -89,7 +93,7 @@ static int qcom_apcs_ipc_probe(struct platform_device *pdev)return ret; } -if (of_device_is_compatible (np,"qcom,msm8916-apcs-kpss-global" )) { +if (of_match_device (apcs_clk_match_table, &pdev->dev)) { apcs->clk =platform_device_register_data (&pdev->dev,"qcom-apcs-msm8916-clk" ,-1 ,NULL ,0 );
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 65/70 clk: sprd: add missing kfree
In reply to Sasha LevinFrom: Chunyan Zhang <[email protected]>
[ Upstream commit 5e75ea9c67433a065b0e8595ad3c91c7c0ca0d2d ]
The number of config registers for different pll clocks probably are not same, so we have to use malloc, and should free the memory before return.
--- drivers/clk/sprd/pll.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/clk/sprd/pll.c +2 -0
@@ -136,6 +136,7 @@ static unsigned long _sprd_pll_recalc_rate(const struct sprd_pll *pll, k2 + refin * nint *CLK_PLL_1M ; } +kfree (cfg);return rate; }
@@ -222,6 +223,7 @@ static int _sprd_pll_set_rate(const struct sprd_pll *pll,if (!ret)udelay (pll->udelay); +kfree (cfg);return ret; }
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 66/70 scsi: core: Reduce memory required for SCSI logging
In reply to Sasha LevinFrom: Bart Van Assche <[email protected]>
[ Upstream commit dccc96abfb21dc19d69e707c38c8ba439bba7160 ]
The data structure used for log messages is so large that it can cause a boot failure. Since allocations from that data structure can fail anyway, use kmalloc() / kfree() instead of that data structure.
See also https://bugzilla.kernel.org/show_bug.cgi?id=204119.
See also commit ded85c193a39 ("scsi: Implement per-cpu logging buffer") # v4.0.
--- drivers/scsi/scsi_logging.c | 48 +++---------------------------------- include/scsi/scsi_dbg.h | 2 -- 2 files changed, 3 insertions(+), 47 deletions(-)
drivers/scsi/scsi_logging.c +3 -45
@@ -15,57 +15,15 @@#include <scsi/scsi_eh.h> #include <scsi/scsi_dbg.h> -#define SCSI_LOG_SPOOLSIZE 4096 - -#if (SCSI_LOG_SPOOLSIZE /SCSI_LOG_BUFSIZE ) >BITS_PER_LONG -#warning SCSI logging bitmask too large -#endif - -struct scsi_log_buf { -char buffer[SCSI_LOG_SPOOLSIZE ]; -unsigned long map; -}; - -static DEFINE_PER_CPU(struct scsi_log_buf, scsi_format_log); -static char *scsi_log_reserve_buffer (size_t *len) { -struct scsi_log_buf *buf; -unsigned long map_bits =sizeof (buf->buffer) /SCSI_LOG_BUFSIZE ; -unsigned long idx =0 ; - -preempt_disable (); - buf =this_cpu_ptr (&scsi_format_log); - idx =find_first_zero_bit (&buf->map, map_bits); -if (likely (idx < map_bits)) { -while (test_and_set_bit (idx, &buf->map)) { - idx =find_next_zero_bit (&buf->map, map_bits, idx); -if (idx >= map_bits) -break ; - } - } -if (WARN_ON (idx >= map_bits)) { -preempt_enable (); -return NULL ; - } - *len =SCSI_LOG_BUFSIZE ; -return buf->buffer + idx *SCSI_LOG_BUFSIZE ; + *len =128 ; +return kmalloc (*len,GFP_ATOMIC ); }static void scsi_log_release_buffer (char *bufptr) { -struct scsi_log_buf *buf; -unsigned long idx; -int ret; - - buf =this_cpu_ptr (&scsi_format_log); -if (bufptr >= buf->buffer && - bufptr < buf->buffer +SCSI_LOG_SPOOLSIZE ) { - idx = (bufptr - buf->buffer) /SCSI_LOG_BUFSIZE ; - ret =test_and_clear_bit (idx, &buf->map); -WARN_ON (!ret); - } -preempt_enable (); +kfree (bufptr); }static inline const char *scmd_name (const struct scsi_cmnd *scmd)
include/scsi/scsi_dbg.h +0 -2
@@ -6,8 +6,6 @@ struct scsi_cmnd;struct scsi_device ;struct scsi_sense_hdr ; -#define SCSI_LOG_BUFSIZE 128 -extern void scsi_print_command (struct scsi_cmnd *);extern size_t __scsi_format_command (char *,size_t ,const unsigned char *,size_t );
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 67/70 dma-buf/sw_sync: Synchronize signal vs syncpt free
In reply to Sasha LevinFrom: Chris Wilson <[email protected]>
[ Upstream commit d3c6dd1fb30d3853c2012549affe75c930f4a2f9 ]
During release of the syncpt, we remove it from the list of syncpt and the tree, but only if it is not already been removed. However, during signaling, we first remove the syncpt from the list. So, if we concurrently free and signal the syncpt, the free may decide that it is not part of the tree and immediately free itself -- meanwhile the signaler goes on to use the now freed datastructure.
In particular, we get struck by commit 0e2f733addbf ("dma-buf: make dma_fence structure a bit smaller v2") as the cb_list is immediately clobbered by the kfree_rcu.
v2: Avoid calling into timeline_fence_release() from under the spinlock
Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=111381
References: 0e2f733addbf ("dma-buf: make dma_fence structure a bit smaller v2")
--- drivers/dma-buf/sw_sync.c | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-)
drivers/dma-buf/sw_sync.c +7 -9
@@ -132,17 +132,14 @@ static void timeline_fence_release(struct dma_fence *fence) {struct sync_pt *pt =dma_fence_to_sync_pt (fence);struct sync_timeline *parent =dma_fence_parent (fence); +unsigned long flags; +spin_lock_irqsave (fence->lock, flags);if (!list_empty (&pt->link)) { -unsigned long flags; - -spin_lock_irqsave (fence->lock, flags); -if (!list_empty (&pt->link)) { -list_del (&pt->link); -rb_erase (&pt->node, &parent->pt_tree); - } -spin_unlock_irqrestore (fence->lock, flags); +list_del (&pt->link); +rb_erase (&pt->node, &parent->pt_tree); } +spin_unlock_irqrestore (fence->lock, flags);sync_timeline_put (parent);dma_fence_free (fence);
@@ -265,7 +262,8 @@ static struct sync_pt *sync_pt_create(struct sync_timeline *obj, p = &parent->rb_left; }else {if (dma_fence_get_rcu (&other->base)) { -dma_fence_put (&pt->base); +sync_timeline_put (obj); +kfree (pt); pt = other; goto unlock; }
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 68/70 drm: fix module name in edid_firmware log message
In reply to Sasha LevinFrom: Jani Nikula <[email protected]>
[ Upstream commit ade925995b172f1d7410d1c665b2f47c5e99bef0 ]
The module is drm_kms_helper, not drm_kms_firmware.
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=204549
--- drivers/gpu/drm/drm_kms_helper_common.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/drm_kms_helper_common.c +1 -1
@@ -39,7 +39,7 @@ MODULE_LICENSE("GPL and additional rights");/* Backward compatibility for drm_kms_helper.edid_firmware */ static int edid_firmware_set (const char *val,const struct kernel_param *kp) { -DRM_NOTE ("drm_kms_firmware.edid_firmware is deprecated, please use drm.edid_firmware instead.\n" ); +DRM_NOTE ("drm_kms_helper.edid_firmware is deprecated, please use drm.edid_firmware instead.\n" );return __drm_set_edid_firmware_path (val); }
Signature · 6 lines
2.20.1 _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Sasha Levin
maintainerPATCH 69/70 f2fs: fix to drop meta/node pages during umount
In reply to Sasha LevinFrom: Chao Yu <[email protected]>
[ Upstream commit a8933b6b68f775b5774e7b075447fae13f4d01fe ]
As reported in bugzilla:
https://bugzilla.kernel.org/show_bug.cgi?id=204193
A null pointer dereference bug is triggered in f2fs under kernel-5.1.3.
kasan_report.cold+0x5/0x32 f2fs_write_end_io+0x215/0x650 bio_endio+0x26e/0x320 blk_update_request+0x209/0x5d0 blk_mq_end_request+0x2e/0x230 lo_complete_rq+0x12c/0x190 blk_done_softirq+0x14a/0x1a0 __do_softirq+0x119/0x3e5 irq_exit+0x94/0xe0 call_function_single_interrupt+0xf/0x20
During umount, we will access NULL sbi->node_inode pointer in f2fs_write_end_io():
f2fs_bug_on(sbi, page->mapping == NODE_MAPPING(sbi) && page->index != nid_of_node(page));
The reason is if disable_checkpoint mount option is on, meta dirty pages can remain during umount, and then be flushed by iput() of meta_inode, however node_inode has been iput()ed before meta_inode's iput().
Since checkpoint is disabled, all meta/node datas are useless and should be dropped in next mount, so in umount, let's adjust drop_inode() to give a hint to iput_final() to drop all those dirty datas correctly.
--- fs/f2fs/super.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
fs/f2fs/super.c +14 -0
@@ -894,7 +894,21 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb)static int f2fs_drop_inode (struct inode *inode) { +struct f2fs_sb_info *sbi =F2FS_I_SB (inode);int ret; + +/* +* during filesystem shutdown, if checkpoint is disabled, +* drop useless meta/node dirty pages. +*/ +if (unlikely (is_sbi_flag_set (sbi,SBI_CP_DISABLED ))) { +if (inode->i_ino ==F2FS_NODE_INO (sbi) || + inode->i_ino ==F2FS_META_INO (sbi)) { +trace_f2fs_drop_inode (inode,1 ); +return 1 ; + } + } +/* * This is to avoid a deadlock condition like below. * writeback_single_inode(inode)
Signature · 1 line
2.20.1
Sasha Levin
maintainerPATCH 70/70 ext4: fix potential use after free after remounting with noblock_validity
In reply to Sasha LevinFrom: "zhangyi (F)" <[email protected]>
[ Upstream commit 7727ae52975d4f4ef7ff69ed8e6e25f6a4168158 ]
Remount process will release system zone which was allocated before if "noblock_validity" is specified. If we mount an ext4 file system to two mountpoints with default mount options, and then remount one of them with "noblock_validity", it may trigger a use after free problem when someone accessing the other one.
# mount /dev/sda foo # mount /dev/sda bar
User access mountpoint "foo" | Remount mountpoint "bar"
|
ext4_map_blocks() | ext4_remount()
check_block_validity() | ext4_setup_system_zone()
ext4_data_block_valid() | ext4_release_system_zone()
| free system_blks rb nodes
access system_blks rb nodes |
trigger use after free |This problem can also be reproduced by one mountpint, At the same time, add_system_zone() can get called during remount as well so there can be racing ext4_data_block_valid() reading the rbtree at the same time.
This patch add RCU to protect system zone from releasing or building when doing a remount which inverse current "noblock_validity" mount option. It assign the rbtree after the whole tree was complete and do actual freeing after rcu grace period, avoid any intermediate state.
--- fs/ext4/block_validity.c | 189 ++++++++++++++++++++++++++++----------- fs/ext4/ext4.h | 10 ++- 2 files changed, 147 insertions(+), 52 deletions(-)
fs/ext4/block_validity.c +138 -51
@@ -38,6 +38,7 @@ int __init ext4_init_system_zone(void)void ext4_exit_system_zone (void ) { +rcu_barrier ();kmem_cache_destroy (ext4_system_zone_cachep); }
@@ -49,17 +50,26 @@ static inline int can_merge(struct ext4_system_zone *entry1,return 0 ; } +static void release_system_zone (struct ext4_system_blocks *system_blks) +{ +struct ext4_system_zone *entry, *n; + +rbtree_postorder_for_each_entry_safe (entry, n, + &system_blks->root, node) +kmem_cache_free (ext4_system_zone_cachep, entry); +} +/* * Mark a range of blocks as belonging to the "system zone" --- that * is, filesystem metadata blocks which should never be used by * inodes. */ -static int add_system_zone (struct ext4_sb_info *sbi, +static int add_system_zone (struct ext4_system_blocks *system_blks,ext4_fsblk_t start_blk,unsigned int count) {struct ext4_system_zone *new_entry =NULL , *entry; -struct rb_node **n = &sbi->system_blks.rb_node, *node; +struct rb_node **n = &system_blks->root.rb_node, *node;struct rb_node *parent =NULL , *new_node =NULL ;while (*n) {
@@ -91,7 +101,7 @@ static int add_system_zone(struct ext4_sb_info *sbi, new_node = &new_entry->node;rb_link_node (new_node, parent, n); -rb_insert_color (new_node, &sbi->system_blks); +rb_insert_color (new_node, &system_blks->root); }/* Can we merge to the left? */
@@ -101,7 +111,7 @@ static int add_system_zone(struct ext4_sb_info *sbi,if (can_merge (entry, new_entry)) { new_entry->start_blk = entry->start_blk; new_entry->count += entry->count; -rb_erase (node, &sbi->system_blks); +rb_erase (node, &system_blks->root);kmem_cache_free (ext4_system_zone_cachep, entry); } }
@@ -112,7 +122,7 @@ static int add_system_zone(struct ext4_sb_info *sbi, entry = rb_entry(node, struct ext4_system_zone, node);if (can_merge (new_entry, entry)) { new_entry->count += entry->count; -rb_erase (node, &sbi->system_blks); +rb_erase (node, &system_blks->root);kmem_cache_free (ext4_system_zone_cachep, entry); } }
@@ -126,7 +136,7 @@ static void debug_print_tree(struct ext4_sb_info *sbi)int first =1 ;printk (KERN_INFO "System zones: " ); - node =rb_first (&sbi->system_blks); + node =rb_first (&sbi->system_blks->root);while (node) { entry = rb_entry(node, struct ext4_system_zone, node); printk(KERN_CONT "%s%llu-%llu", first ? "" : ", ",
@@ -137,7 +147,47 @@ static void debug_print_tree(struct ext4_sb_info *sbi)printk (KERN_CONT "\n" ); } -static int ext4_protect_reserved_inode (struct super_block *sb,u32 ino) +/* +* Returns 1 if the passed-in block region (start_blk, +* start_blk+count) is valid; 0 if some part of the block region +* overlaps with filesystem metadata blocks. +*/ +static int ext4_data_block_valid_rcu (struct ext4_sb_info *sbi, +struct ext4_system_blocks *system_blks, +ext4_fsblk_t start_blk, +unsigned int count) +{ +struct ext4_system_zone *entry; +struct rb_node *n; + +if ((start_blk <=le32_to_cpu (sbi->s_es->s_first_data_block)) || + (start_blk + count < start_blk) || + (start_blk + count >ext4_blocks_count (sbi->s_es))) { + sbi->s_es->s_last_error_block =cpu_to_le64 (start_blk); +return 0 ; + } + +if (system_blks ==NULL ) +return 1 ; + + n = system_blks->root.rb_node; +while (n) { + entry = rb_entry(n, struct ext4_system_zone, node); +if (start_blk + count -1 < entry->start_blk) + n = n->rb_left; +else if (start_blk >= (entry->start_blk + entry->count)) + n = n->rb_right; +else { + sbi->s_es->s_last_error_block =cpu_to_le64 (start_blk); +return 0 ; + } + } +return 1 ; +} + +static int ext4_protect_reserved_inode (struct super_block *sb, +struct ext4_system_blocks *system_blks, +u32 ino) {struct inode *inode;struct ext4_sb_info *sbi =EXT4_SB (sb);
@@ -163,14 +213,15 @@ static int ext4_protect_reserved_inode(struct super_block *sb, u32 ino)if (n ==0 ) { i++; }else { -if (!ext4_data_block_valid (sbi, map.m_pblk, n)) { +if (!ext4_data_block_valid_rcu (sbi, system_blks, + map.m_pblk, n)) {ext4_error (sb,"blocks %llu-%llu from inode %u " "overlap system zone" , map.m_pblk, map.m_pblk + map.m_len -1 , ino); err = -EFSCORRUPTED ;break ; } - err =add_system_zone (sbi, map.m_pblk, n); + err =add_system_zone (system_blks, map.m_pblk, n);if (err <0 )break ; i += n;
@@ -180,94 +231,130 @@ static int ext4_protect_reserved_inode(struct super_block *sb, u32 ino)return err; } +static void ext4_destroy_system_zone (struct rcu_head *rcu) +{ +struct ext4_system_blocks *system_blks; + + system_blks = container_of(rcu, struct ext4_system_blocks, rcu); +release_system_zone (system_blks); +kfree (system_blks); +} + +/* +* Build system zone rbtree which is used for block validity checking. +* +* The update of system_blks pointer in this function is protected by +* sb->s_umount semaphore. However we have to be careful as we can be +* racing with ext4_data_block_valid() calls reading system_blks rbtree +* protected only by RCU. That's why we first build the rbtree and then +* swap it in place. +*/ int ext4_setup_system_zone (struct super_block *sb) {ext4_group_t ngroups =ext4_get_groups_count (sb);struct ext4_sb_info *sbi =EXT4_SB (sb); +struct ext4_system_blocks *system_blks;struct ext4_group_desc *gdp;ext4_group_t i;int flex_size =ext4_flex_bg_size (sbi);int ret;if (!test_opt (sb,BLOCK_VALIDITY )) { -if (sbi->system_blks.rb_node) +if (sbi->system_blks)ext4_release_system_zone (sb);return 0 ; } -if (sbi->system_blks.rb_node) +if (sbi->system_blks)return 0 ; + system_blks =kzalloc (sizeof (*system_blks),GFP_KERNEL ); +if (!system_blks) +return -ENOMEM ; +for (i=0 ; i < ngroups; i++) {cond_resched ();if (ext4_bg_has_super (sb, i) && ((i <5 ) || ((i % flex_size) ==0 ))) -add_system_zone (sbi,ext4_group_first_block_no (sb, i), +add_system_zone (system_blks, +ext4_group_first_block_no (sb, i),ext4_bg_num_gdb (sb, i) +1 ); gdp =ext4_get_group_desc (sb, i,NULL ); - ret =add_system_zone (sbi,ext4_block_bitmap (sb, gdp),1 ); + ret =add_system_zone (system_blks, +ext4_block_bitmap (sb, gdp),1 );if (ret) -return ret; - ret =add_system_zone (sbi,ext4_inode_bitmap (sb, gdp),1 ); + goto err; + ret =add_system_zone (system_blks, +ext4_inode_bitmap (sb, gdp),1 );if (ret) -return ret; - ret =add_system_zone (sbi,ext4_inode_table (sb, gdp), + goto err; + ret =add_system_zone (system_blks, +ext4_inode_table (sb, gdp), sbi->s_itb_per_group);if (ret) -return ret; + goto err; }if (ext4_has_feature_journal (sb) && sbi->s_es->s_journal_inum) { - ret =ext4_protect_reserved_inode (sb, + ret =ext4_protect_reserved_inode (sb, system_blks,le32_to_cpu (sbi->s_es->s_journal_inum));if (ret) -return ret; + goto err; } +/* +* System blks rbtree complete, announce it once to prevent racing +* with ext4_data_block_valid() accessing the rbtree at the same +* time. +*/ +rcu_assign_pointer (sbi->system_blks, system_blks); +if (test_opt (sb,DEBUG ))debug_print_tree (sbi);return 0 ; +err: +release_system_zone (system_blks); +kfree (system_blks); +return ret; } -/* Called when the filesystem is unmounted */ +/* +* Called when the filesystem is unmounted or when remounting it with +* noblock_validity specified. +* +* The update of system_blks pointer in this function is protected by +* sb->s_umount semaphore. However we have to be careful as we can be +* racing with ext4_data_block_valid() calls reading system_blks rbtree +* protected only by RCU. So we first clear the system_blks pointer and +* then free the rbtree only after RCU grace period expires. +*/ void ext4_release_system_zone (struct super_block *sb) { -struct ext4_system_zone *entry, *n; +struct ext4_system_blocks *system_blks; -rbtree_postorder_for_each_entry_safe (entry, n, - &EXT4_SB (sb)->system_blks, node) -kmem_cache_free (ext4_system_zone_cachep, entry); + system_blks =rcu_dereference_protected (EXT4_SB (sb)->system_blks, +lockdep_is_held (&sb->s_umount)); +rcu_assign_pointer (EXT4_SB (sb)->system_blks,NULL ); -EXT4_SB (sb)->system_blks =RB_ROOT ; +if (system_blks) +call_rcu (&system_blks->rcu, ext4_destroy_system_zone); } -/* -* Returns 1 if the passed-in block region (start_blk, -* start_blk+count) is valid; 0 if some part of the block region -* overlaps with filesystem metadata blocks. -*/ int ext4_data_block_valid (struct ext4_sb_info *sbi,ext4_fsblk_t start_blk,unsigned int count) { -struct ext4_system_zone *entry; -struct rb_node *n = sbi->system_blks.rb_node; +struct ext4_system_blocks *system_blks; +int ret; -if ((start_blk <=le32_to_cpu (sbi->s_es->s_first_data_block)) || - (start_blk + count < start_blk) || - (start_blk + count >ext4_blocks_count (sbi->s_es))) { - sbi->s_es->s_last_error_block =cpu_to_le64 (start_blk); -return 0 ; - } -while (n) { - entry = rb_entry(n, struct ext4_system_zone, node); -if (start_blk + count -1 < entry->start_blk) - n = n->rb_left; -else if (start_blk >= (entry->start_blk + entry->count)) - n = n->rb_right; -else { - sbi->s_es->s_last_error_block =cpu_to_le64 (start_blk); -return 0 ; - } - } -return 1 ; +/* +* Lock the system zone to prevent it being released concurrently +* when doing a remount which inverse current "[no]block_validity" +* mount option. +*/ +rcu_read_lock (); + system_blks =rcu_dereference (sbi->system_blks); + ret =ext4_data_block_valid_rcu (sbi, system_blks, start_blk, + count); +rcu_read_unlock (); +return ret; } int ext4_check_blockref(const char *function, unsigned int line,
fs/ext4/ext4.h +9 -1
@@ -184,6 +184,14 @@ struct ext4_map_blocks {unsigned int m_flags; }; +/* +* Block validity checking, system zone rbtree. +*/ +struct ext4_system_blocks { +struct rb_root root; +struct rcu_head rcu; +}; +/* * Flags for ext4_io_end->flags */
@@ -1420,7 +1428,7 @@ struct ext4_sb_info {int s_jquota_fmt;/* Format of quota to use */ #endif unsigned int s_want_extra_isize;/* New inodes should reserve # bytes */ -struct rb_root system_blks; +struct ext4_system_blocks __rcu *system_blks;#ifdef EXTENTS_STATS /* ext4 extents stats */
Signature · 1 line
2.20.1