Re: Privilege Levels Below User

On Tue, 11 Jun 2024 00:27:02 +0000, mitchalsup@aol.com (MitchAlsup1)
wrote:

ALL I have DONE is to not have the MB write into the cache until the
causing instruction retires !!

I suppose that depends on how you define "write".

If by "write" you mean store data in the cache, for eventual writing
out into RAM, well, since RAM doesn't contain "rename locations" to
play with, it seems to me that any CPU designer had better do that.

At least, I'm not imaginative enough to think of doing it any other
way.

However, if by "write" you mean to change the state of the cache in
any way, such as by reading data from memory... now, _then_ you would
indeed have done what is necessary to combat Spectre.

Obviously, though, a "load" instruction will _never_ retire unless it
can read the data from memory it is trying to put in a register.

So apparently WHAT you have REALLY DONE is to modify how memory reads
work...

if the data a load instruction requires is not already in the cache,
then a direct read from memory is performed which *completely
bypasses* the cache; this data (and its associated address) are
retained by the CPU to be placed in the cache _if_ the instruction is
actually executed and when it retires.

And, in fact, the various cache levels have to work this way too. You
have an L1 cache miss, but an L2 cache hit? Fine, you take your data
directly from L2, and don't promote the data into L2 until instruction
retirement.

So now the process of fetching data from memory is _not_ done by
fetching always from L1 and going _throughl_ L1 to access L2, and
going _through_ L2 to access RAM, which seems to be the usual way
these days.

That certainly can be done. But it isn't quite as simple and obvious
as you seem to claim.

My 66000 is also insensitive to RowHammer and derivatives.....

When I first read that sentence, I was completely incredulous. DRAM is
sensitive to RowHammer because it's gone to feature sizes which are
beyond the state-of-the-art to do properly... so corners have been
cut.

How a CPU can be "insensitive" to it was mysterious.

After all, RowHammer is caused by multiple rapid-fire accesses to the
same address, or to related addresses, in memory.

But given that you are now explicitly passing accesses to DRAM around
the caches, instead of having the caches access DRAM as needed,
perhaps that also makes it possible for the CPU to detect suspicious
behavior more easily. (Since _relateld_ accesses may be used in a
RowHammer attack, simply pruning redundant memory accesses from the
operation stream won't be enough. I could see you doing _that_ as part
of "doing it right".)

If the "row" that was "hammered" just consisted of the 16 consecutive
locations that can be accessed speedily after the first one is ready,
then pruning reduntant accesses _would_ be enough, since to "hammer" a
row one has to access it hundreds of times, not at most 32 times; but
I'm afraid that isn't the case.

John Savard