<feed xmlns='http://www.w3.org/2005/Atom'>
<title>kernel.git/fs/pstore, branch linux-4.4.y</title>
<subtitle>Hosts the 0x221E linux distro kernel.
</subtitle>
<id>https://git.0xinfinity.dev/distro/kernel.git/atom?h=linux-4.4.y</id>
<link rel='self' href='https://git.0xinfinity.dev/distro/kernel.git/atom?h=linux-4.4.y'/>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/'/>
<updated>2020-01-12T10:22:46Z</updated>
<entry>
<title>pstore/ram: Write new dumps to start of recycled zones</title>
<updated>2020-01-12T10:22:46Z</updated>
<author>
<name>Aleksandr Yashkin</name>
</author>
<published>2020-01-07T18:26:55Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=0f367dae495f437b7b39f2577b34e74012248e8f'/>
<id>urn:sha1:0f367dae495f437b7b39f2577b34e74012248e8f</id>
<content type='text'>
[ Upstream commit 9e5f1c19800b808a37fb9815a26d382132c26c3d ]

The ram_core.c routines treat przs as circular buffers. When writing a
new crash dump, the old buffer needs to be cleared so that the new dump
doesn't end up in the wrong place (i.e. at the end).

The solution to this problem is to reset the circular buffer state before
writing a new Oops dump.

Signed-off-by: Aleksandr Yashkin &lt;a.yashkin@inango-systems.com&gt;
Signed-off-by: Nikolay Merinov &lt;n.merinov@inango-systems.com&gt;
Signed-off-by: Ariel Gilman &lt;a.gilman@inango-systems.com&gt;
Link: https://lore.kernel.org/r/20191223133816.28155-1-n.merinov@inango-systems.com
Fixes: 896fc1f0c4c6 ("pstore/ram: Switch to persistent_ram routines")
[kees: backport to v4.9]
Signed-off-by: Kees Cook &lt;keescook@chromium.org&gt;
Signed-off-by: Sasha Levin &lt;sashal@kernel.org&gt;
</content>
</entry>
<entry>
<title>pstore/ram: Do not treat empty buffers as valid</title>
<updated>2019-01-26T08:42:53Z</updated>
<author>
<name>Joel Fernandes (Google)</name>
</author>
<published>2018-11-03T23:38:18Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=f250e4c562a3bd106575032666e9ef46f31231f8'/>
<id>urn:sha1:f250e4c562a3bd106575032666e9ef46f31231f8</id>
<content type='text'>
[ Upstream commit 30696378f68a9e3dad6bfe55938b112e72af00c2 ]

The ramoops backend currently calls persistent_ram_save_old() even
if a buffer is empty. While this appears to work, it is does not seem
like the right thing to do and could lead to future bugs so lets avoid
that. It also prevents misleading prints in the logs which claim the
buffer is valid.

I got something like:

	found existing buffer, size 0, start 0

When I was expecting:

	no valid data in buffer (sig = ...)

This bails out early (and reports with pr_debug()), since it's an
acceptable state.

Signed-off-by: Joel Fernandes (Google) &lt;joel@joelfernandes.org&gt;
Co-developed-by: Kees Cook &lt;keescook@chromium.org&gt;
Signed-off-by: Kees Cook &lt;keescook@chromium.org&gt;
Signed-off-by: Sasha Levin &lt;sashal@kernel.org&gt;
</content>
</entry>
<entry>
<title>pstore: Convert console write to use -&gt;write_buf</title>
<updated>2018-12-17T20:55:12Z</updated>
<author>
<name>Namhyung Kim</name>
</author>
<published>2016-10-19T01:23:41Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=7f0324fb34c4736bf12ae8a5137e6913772749cc'/>
<id>urn:sha1:7f0324fb34c4736bf12ae8a5137e6913772749cc</id>
<content type='text'>
[ Upstream commit 70ad35db3321a6d129245979de4ac9d06eed897c ]

Maybe I'm missing something, but I don't know why it needs to copy the
input buffer to psinfo-&gt;buf and then write.  Instead we can write the
input buffer directly.  The only implementation that supports console
message (i.e. ramoops) already does it for ftrace messages.

For the upcoming virtio backend driver, it needs to protect psinfo-&gt;buf
overwritten from console messages.  If it could use -&gt;write_buf method
instead of -&gt;write, the problem will be solved easily.

Cc: Stefan Hajnoczi &lt;stefanha@redhat.com&gt;
Signed-off-by: Namhyung Kim &lt;namhyung@kernel.org&gt;
Signed-off-by: Kees Cook &lt;keescook@chromium.org&gt;
Signed-off-by: Sasha Levin &lt;sashal@kernel.org&gt;
</content>
</entry>
<entry>
<title>pstore: Fix incorrect persistent ram buffer mapping</title>
<updated>2018-09-26T06:35:07Z</updated>
<author>
<name>Bin Yang</name>
</author>
<published>2018-09-12T03:36:34Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=1cd01dba1355e291f636555b1920625ed58c1623'/>
<id>urn:sha1:1cd01dba1355e291f636555b1920625ed58c1623</id>
<content type='text'>
commit 831b624df1b420c8f9281ed1307a8db23afb72df upstream.

persistent_ram_vmap() returns the page start vaddr.
persistent_ram_iomap() supports non-page-aligned mapping.

persistent_ram_buffer_map() always adds offset-in-page to the vaddr
returned from these two functions, which causes incorrect mapping of
non-page-aligned persistent ram buffer.

By default ftrace_size is 4096 and max_ftrace_cnt is nr_cpu_ids. Without
this patch, the zone_sz in ramoops_init_przs() is 4096/nr_cpu_ids which
might not be page aligned. If the offset-in-page &gt; 2048, the vaddr will be
in next page. If the next page is not mapped, it will cause kernel panic:

[    0.074231] BUG: unable to handle kernel paging request at ffffa19e0081b000
...
[    0.075000] RIP: 0010:persistent_ram_new+0x1f8/0x39f
...
[    0.075000] Call Trace:
[    0.075000]  ramoops_init_przs.part.10.constprop.15+0x105/0x260
[    0.075000]  ramoops_probe+0x232/0x3a0
[    0.075000]  platform_drv_probe+0x3e/0xa0
[    0.075000]  driver_probe_device+0x2cd/0x400
[    0.075000]  __driver_attach+0xe4/0x110
[    0.075000]  ? driver_probe_device+0x400/0x400
[    0.075000]  bus_for_each_dev+0x70/0xa0
[    0.075000]  driver_attach+0x1e/0x20
[    0.075000]  bus_add_driver+0x159/0x230
[    0.075000]  ? do_early_param+0x95/0x95
[    0.075000]  driver_register+0x70/0xc0
[    0.075000]  ? init_pstore_fs+0x4d/0x4d
[    0.075000]  __platform_driver_register+0x36/0x40
[    0.075000]  ramoops_init+0x12f/0x131
[    0.075000]  do_one_initcall+0x4d/0x12c
[    0.075000]  ? do_early_param+0x95/0x95
[    0.075000]  kernel_init_freeable+0x19b/0x222
[    0.075000]  ? rest_init+0xbb/0xbb
[    0.075000]  kernel_init+0xe/0xfc
[    0.075000]  ret_from_fork+0x3a/0x50

Signed-off-by: Bin Yang &lt;bin.yang@intel.com&gt;
[kees: add comments describing the mapping differences, updated commit log]
Fixes: 24c3d2f342ed ("staging: android: persistent_ram: Make it possible to use memory outside of bootmem")
Cc: stable@vger.kernel.org
Signed-off-by: Kees Cook &lt;keescook@chromium.org&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>pstore: Use dynamic spinlock initializer</title>
<updated>2017-08-07T02:19:43Z</updated>
<author>
<name>Kees Cook</name>
</author>
<published>2017-03-06T06:08:58Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=fa7773191046237079dd88ac89b527bb4138aaea'/>
<id>urn:sha1:fa7773191046237079dd88ac89b527bb4138aaea</id>
<content type='text'>
commit e9a330c4289f2ba1ca4bf98c2b430ab165a8931b upstream.

The per-prz spinlock should be using the dynamic initializer so that
lockdep can correctly track it. Without this, under lockdep, we get a
warning at boot that the lock is in non-static memory.

Fixes: 109704492ef6 ("pstore: Make spinlock per zone instead of global")
Fixes: 76d5692a5803 ("pstore: Correctly initialize spinlock and flags")
Signed-off-by: Kees Cook &lt;keescook@chromium.org&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>pstore: Correctly initialize spinlock and flags</title>
<updated>2017-08-07T02:19:43Z</updated>
<author>
<name>Kees Cook</name>
</author>
<published>2017-02-09T23:43:44Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=9ece74e1006e1706a7c239fd158f93f126c04c2e'/>
<id>urn:sha1:9ece74e1006e1706a7c239fd158f93f126c04c2e</id>
<content type='text'>
commit 76d5692a58031696e282384cbd893832bc92bd76 upstream.

The ram backend wasn't always initializing its spinlock correctly. Since
it was coming from kzalloc memory, though, it was harmless on
architectures that initialize unlocked spinlocks to 0 (at least x86 and
ARM). This also fixes a possibly ignored flag setting too.

When running under CONFIG_DEBUG_SPINLOCK, the following Oops was visible:

[    0.760836] persistent_ram: found existing buffer, size 29988, start 29988
[    0.765112] persistent_ram: found existing buffer, size 30105, start 30105
[    0.769435] persistent_ram: found existing buffer, size 118542, start 118542
[    0.785960] persistent_ram: found existing buffer, size 0, start 0
[    0.786098] persistent_ram: found existing buffer, size 0, start 0
[    0.786131] pstore: using zlib compression
[    0.790716] BUG: spinlock bad magic on CPU#0, swapper/0/1
[    0.790729]  lock: 0xffffffc0d1ca9bb0, .magic: 00000000, .owner: &lt;none&gt;/-1, .owner_cpu: 0
[    0.790742] CPU: 0 PID: 1 Comm: swapper/0 Not tainted 4.10.0-rc2+ #913
[    0.790747] Hardware name: Google Kevin (DT)
[    0.790750] Call trace:
[    0.790768] [&lt;ffffff900808ae88&gt;] dump_backtrace+0x0/0x2bc
[    0.790780] [&lt;ffffff900808b164&gt;] show_stack+0x20/0x28
[    0.790794] [&lt;ffffff9008460ee0&gt;] dump_stack+0xa4/0xcc
[    0.790809] [&lt;ffffff9008113cfc&gt;] spin_dump+0xe0/0xf0
[    0.790821] [&lt;ffffff9008113d3c&gt;] spin_bug+0x30/0x3c
[    0.790834] [&lt;ffffff9008113e28&gt;] do_raw_spin_lock+0x50/0x1b8
[    0.790846] [&lt;ffffff9008a2d2ec&gt;] _raw_spin_lock_irqsave+0x54/0x6c
[    0.790862] [&lt;ffffff90083ac3b4&gt;] buffer_size_add+0x48/0xcc
[    0.790875] [&lt;ffffff90083acb34&gt;] persistent_ram_write+0x60/0x11c
[    0.790888] [&lt;ffffff90083aab1c&gt;] ramoops_pstore_write_buf+0xd4/0x2a4
[    0.790900] [&lt;ffffff90083a9d3c&gt;] pstore_console_write+0xf0/0x134
[    0.790912] [&lt;ffffff900811c304&gt;] console_unlock+0x48c/0x5e8
[    0.790923] [&lt;ffffff900811da18&gt;] register_console+0x3b0/0x4d4
[    0.790935] [&lt;ffffff90083aa7d0&gt;] pstore_register+0x1a8/0x234
[    0.790947] [&lt;ffffff90083ac250&gt;] ramoops_probe+0x6b8/0x7d4
[    0.790961] [&lt;ffffff90085ca548&gt;] platform_drv_probe+0x7c/0xd0
[    0.790972] [&lt;ffffff90085c76ac&gt;] driver_probe_device+0x1b4/0x3bc
[    0.790982] [&lt;ffffff90085c7ac8&gt;] __device_attach_driver+0xc8/0xf4
[    0.790996] [&lt;ffffff90085c4bfc&gt;] bus_for_each_drv+0xb4/0xe4
[    0.791006] [&lt;ffffff90085c7414&gt;] __device_attach+0xd0/0x158
[    0.791016] [&lt;ffffff90085c7b18&gt;] device_initial_probe+0x24/0x30
[    0.791026] [&lt;ffffff90085c648c&gt;] bus_probe_device+0x50/0xe4
[    0.791038] [&lt;ffffff90085c35b8&gt;] device_add+0x3a4/0x76c
[    0.791051] [&lt;ffffff90087d0e84&gt;] of_device_add+0x74/0x84
[    0.791062] [&lt;ffffff90087d19b8&gt;] of_platform_device_create_pdata+0xc0/0x100
[    0.791073] [&lt;ffffff90087d1a2c&gt;] of_platform_device_create+0x34/0x40
[    0.791086] [&lt;ffffff900903c910&gt;] of_platform_default_populate_init+0x58/0x78
[    0.791097] [&lt;ffffff90080831fc&gt;] do_one_initcall+0x88/0x160
[    0.791109] [&lt;ffffff90090010ac&gt;] kernel_init_freeable+0x264/0x31c
[    0.791123] [&lt;ffffff9008a25bd0&gt;] kernel_init+0x18/0x11c
[    0.791133] [&lt;ffffff9008082ec0&gt;] ret_from_fork+0x10/0x50
[    0.793717] console [pstore-1] enabled
[    0.797845] pstore: Registered ramoops as persistent store backend
[    0.804647] ramoops: attached 0x100000@0xf7edc000, ecc: 0/0

Fixes: 663deb47880f ("pstore: Allow prz to control need for locking")
Fixes: 109704492ef6 ("pstore: Make spinlock per zone instead of global")
Reported-by: Brian Norris &lt;briannorris@chromium.org&gt;
Signed-off-by: Kees Cook &lt;keescook@chromium.org&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>pstore: Allow prz to control need for locking</title>
<updated>2017-08-07T02:19:43Z</updated>
<author>
<name>Joel Fernandes</name>
</author>
<published>2016-10-20T07:34:01Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=aca5b1e3c5b7e73f20b686ca712cb4cf9fccb219'/>
<id>urn:sha1:aca5b1e3c5b7e73f20b686ca712cb4cf9fccb219</id>
<content type='text'>
commit 663deb47880f2283809669563c5a52ac7c6aef1a upstream.

In preparation of not locking at all for certain buffers depending on if
there's contention, make locking optional depending on the initialization
of the prz.

Signed-off-by: Joel Fernandes &lt;joelaf@google.com&gt;
[kees: moved locking flag into prz instead of via caller arguments]
Signed-off-by: Kees Cook &lt;keescook@chromium.org&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>pstore: Make spinlock per zone instead of global</title>
<updated>2017-08-07T02:19:38Z</updated>
<author>
<name>Joel Fernandes</name>
</author>
<published>2016-10-20T07:34:00Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=08408f7ae5cdc7b8ef439f29b8d3dff9f1389c25'/>
<id>urn:sha1:08408f7ae5cdc7b8ef439f29b8d3dff9f1389c25</id>
<content type='text'>
commit 109704492ef637956265ec2eb72ae7b3b39eb6f4 upstream.

Currently pstore has a global spinlock for all zones. Since the zones
are independent and modify different areas of memory, there's no need
to have a global lock, so we should use a per-zone lock as introduced
here. Also, when ramoops's ftrace use-case has a FTRACE_PER_CPU flag
introduced later, which splits the ftrace memory area into a single zone
per CPU, it will eliminate the need for locking. In preparation for this,
make the locking optional.

Signed-off-by: Joel Fernandes &lt;joelaf@google.com&gt;
[kees: updated commit message]
Signed-off-by: Kees Cook &lt;keescook@chromium.org&gt;
Cc: Leo Yan &lt;leo.yan@linaro.org&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>pstore/ram: Use memcpy_fromio() to save old buffer</title>
<updated>2016-10-28T07:01:27Z</updated>
<author>
<name>Andrew Bresticker</name>
</author>
<published>2016-02-15T08:19:49Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=987ec3eb8f6360d43be358ebb9e350114bc78a32'/>
<id>urn:sha1:987ec3eb8f6360d43be358ebb9e350114bc78a32</id>
<content type='text'>
commit d771fdf94180de2bd811ac90cba75f0f346abf8d upstream.

The ramoops buffer may be mapped as either I/O memory or uncached
memory.  On ARM64, this results in a device-type (strongly-ordered)
mapping.  Since unnaligned accesses to device-type memory will
generate an alignment fault (regardless of whether or not strict
alignment checking is enabled), it is not safe to use memcpy().
memcpy_fromio() is guaranteed to only use aligned accesses, so use
that instead.

Signed-off-by: Andrew Bresticker &lt;abrestic@chromium.org&gt;
Signed-off-by: Enric Balletbo Serra &lt;enric.balletbo@collabora.com&gt;
Reviewed-by: Puneet Kumar &lt;puneetster@chromium.org&gt;
Signed-off-by: Kees Cook &lt;keescook@chromium.org&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
<entry>
<title>pstore/ram: Use memcpy_toio instead of memcpy</title>
<updated>2016-10-28T07:01:27Z</updated>
<author>
<name>Furquan Shaikh</name>
</author>
<published>2016-02-15T08:19:48Z</published>
<link rel='alternate' type='text/html' href='https://git.0xinfinity.dev/distro/kernel.git/commit/?id=93a6ca7f6d02c7ffd49af699c874977872000e18'/>
<id>urn:sha1:93a6ca7f6d02c7ffd49af699c874977872000e18</id>
<content type='text'>
commit 7e75678d23167c2527e655658a8ef36a36c8b4d9 upstream.

persistent_ram_update uses vmap / iomap based on whether the buffer is in
memory region or reserved region. However, both map it as non-cacheable
memory. For armv8 specifically, non-cacheable mapping requests use a
memory type that has to be accessed aligned to the request size. memcpy()
doesn't guarantee that.

Signed-off-by: Furquan Shaikh &lt;furquan@google.com&gt;
Signed-off-by: Enric Balletbo Serra &lt;enric.balletbo@collabora.com&gt;
Reviewed-by: Aaron Durbin &lt;adurbin@chromium.org&gt;
Reviewed-by: Olof Johansson &lt;olofj@chromium.org&gt;
Tested-by: Furquan Shaikh &lt;furquan@chromium.org&gt;
Signed-off-by: Kees Cook &lt;keescook@chromium.org&gt;
Signed-off-by: Greg Kroah-Hartman &lt;gregkh@linuxfoundation.org&gt;

</content>
</entry>
</feed>
