►
Description
A show that features the people and technology that make Red Hat® Enterprise Linux® into the world’s leading enterprise Linux platform.
A
Good
morning,
good
afternoon,
good
evening,
wherever
you're
handling
from
welcome
to
another
edition
of
red
hat
enterprise,
linux
presents-
I
am
here
with
the
one
and
only
scott
mcbryan.
We
were
just
talking
about
what
we're
gonna
do
on
the
show
today,
scott,
and
it
seems
like
a
lot
of
fun
to
me,
but
I
am
an
old-school.
Linux
is
admin
so.
B
Well-
and
I
mean
honestly,
we
talk
a
lot
about
things
like
performance
and
tuning
and
there's
been
a
lot
of
technologies
that
have
come
into
our
lexicon
for
doing
those
things
yeah
and
like
what
three
months
ago,
I
think
we
had
carl
abaddon
who's
the
experienced
product
manager
for
for
operating
system
performance
for
rel,
and
we
talked
about
performance,
co-pilot
and
grafana
and
visualizations
and
that's
all
great
and
in
fact,
like
the
next
version
row
will
have
even
more
cool
like
that.
But
nice.
B
You
know
when
I
start
looking
at
what
what's
out
there,
that's
not
what
people
find
right
so
like
visualizations
and
and
those
types
of
things
are
really
good
for
stuff
like
troubleshooting
right.
But
let's
say
that,
like
you,
are
a
database
server,
there's
stuff
that
you
should
be
doing
to
that
to
adjust
the
system
parameters
to
optimize
it
for
that
database
workload
and
so
like
visualizations
and
and
data
collection
and
those
types
of
things.
B
Don't
help
you
with
that,
and
so
I
thought
we'd
start
today
by
just
kind
of
doing
a
quick
round
of
the
contents
of
slash
proc
yeah
and
then,
when
we
were
talking
before
the
show.
I
found
a
couple
of
tuning
guides
specifically
for
database
things,
one
that
I
thought
was
really
good
for
for
from
microsoft,
sql
server
running
on
linux
and
another
one.
That
is
like
less
good,
and
we
could
talk
about
like
why.
I
think
it's
less
good
for
just
kind
of
general
database
server.
But
I.
B
Right
out
of
the
box
right,
like
yeah,
well
like
when
you
turn
those
knobs,
and
this
is
the
thing
that
people
don't
understand
so
like
read
the
article
and
be
like
okay
I'll
I'll
put
these
in
my
2g
bam
there
we
go
cool,
optimized,
you're,
actually
making
choices
that
make
this
system
less
good.
For
other
things,
that's.
B
B
B
B
Right
right,
all
right,
so
this
is
I'm
just
ssh
into
a
box
and
we're
currently
in
slash
proc,
and
this
is
what
it
looks
like
yeah
and
you'll
recall
that
proc
is
really
a
virtual
file
system
yep.
So
it's
not
stored
on
disk
we're
actually
looking
at
space
within
the
kernel's
memory,
and
the
first
thing
I
noticed
about
this
is
all
those
numeric
directories.
What.
B
That
is
the
oh.
This
guy
right
here
is
broken
and
that's
what
it's
complaining
about
that
normally
is
a
symbolic
link
to
the
executable
that
was
used
to
create
process
id
610
right
but
process
id
610
is
apparently
this
kernel
thread
yeah
and
that's
why
it
doesn't
have
an
executable
because
it's
not
executed
from
the
file
system.
That's
part
of
the
kernel.
So
maybe
I
let's
look
at
a
different
one.
How
about.
B
C
C
B
B
A
C
B
B
B
B
A
B
B
Do
right
the
the
lower
the
score,
the
more
likely
it
will
be
killed
in
an
out-of-memory
situation
in
the
box,
the
higher
the
score,
the
less
likely
it
is
to
be
killed,
and
I
know
that
the
the
inclination
would
be
like.
Oh,
this
is
a
database
box.
I
should
make
the
database
super
resilient
killing.
No,
no,
that's
not
what
you
want.
B
B
Modules
right,
so
these
are
all
of
the
kernel
modules
that
are
loaded
into
the
running
kernel
right
and
we
would
normally
access
this
data
with
something
like
ls1
right
to
show
it
to
you
and
so
you're,
looking
at
kind
of
the
same
data
just
formatted
more
nicely.
So,
for
example,
this
guy
right
here,
the
intel
gdt
module
is
loaded.
This
is
how
much
memory
it's
using.
B
A
B
And
we
can
also
look
at
stuff
like
actually
I
use
this
one
all
the
time
partitions.
So
these
are
all
of
the
file
system.
Sorry
not
file
system,
all
of
the
device
ids
of
disk
devices.
So
we
can
see
that
on
this
machine,
I've
got
an
nvme
drive
and
that
has
two
physical
partitions
on
it.
And
then
I've
got
three
device:
mapper
devices
for
my
logical
volume
configuration,
and
so
when
I
like,
plug
a
usb
thumb
drive
into
it.
I
want
to
know
what
device
that
is
well
I'll.
B
B
B
B
We're
looking
oops
over
here,
we're
looking
at
the
actual
thing
that
goes
with
this
device
and
you'll
see
that
there's
like
three
four
columns
for
cpu,
because
this
is
a
quad
core
box
and
the
numbers
underneath
each
of
those
each
of
those
columns
is
how
many
times
this
cpu
is
handled
an
interrupt
to
this
device
and
a
lot
of
times
it
will
be
either
a
cpu
gets
assigned
management
of
this
interrupt.
So
anything
that
gets
sent
to
this
device
or
interrupted
occurs
on
this
device.
B
A
specific
cpu
handles-
and
you
can
see
that
that's
the
case
here
with
interrupt
nine
right.
The
other
cpus
aren't
handling
interrupt
nine,
but
in
other
cases
like
this
one,
it
gets
kind
of
spread
across
the
cpus.
So
the
handling
for
this
interrupt
is
more
equally
handled
and
this
one
happens
to
be
for
the
ethernet
card.
B
And
so
again,
this
is
like
troubleshooting
type
of
data
where
you're
interested
to
see.
If
something
is
going
crazy
or
you
know,
is
there
one
of
these
that
has
like
a
really
high
number
associated
with
it.
So
you
can
see
like
my
system.
Performance
is
degraded,
but
look
I'm
getting
like
a
lot
of
interrupts
on
my
ethernet
device
or
my
graphics
card
or
my
wi-fi
interface,
and
so
you
can
kind
of
get
a
little
bit
data
on
what's
happening.
There.
B
B
The
difference
between
them
is
what
information
goes
there,
and
so,
if
we
look
at
cis,
cis
is
more
organized
around
the
devices
attached
to
the
kernel
or
to
the
machine
rather
right,
and
so
this
is
where
you'd
go
to
like
set
the
scheduling
algorithm
on
a
specific
block
device
right.
So
I
would
say
that
cis
is
more
for
interacting
with
system
connected
devices,
whereas
proc
is
for
system
information
and
then
in
just
a
bit
we'll
start
talking
about
the
tunables,
but
those
tunables
apply
system-wide.
B
B
Info
is
like
all
this
memory
information
and
we
usually
interact
with
things
like
dm
stat
or
free
or
maybe
top,
and
we'll
actually
show
you
some
of
this
information.
But
there's
a
lot
more
in
here
than
what
those
tools
are
showing
you
so,
for
example,
near
huge
page
allotments.
These
are
typically
not
shown
by
a
lot
of
the
other
memory
reporting
applications
and
if
you're
not
familiar
a
huge
page,
is
a
hunk
of
memory
that
is
larger
in
size
than
the
normal
pay
size
on
the
system.
A
B
Okay,
so
we
often
operate
in
memory
over
commitment
mode
on
linux
and
the
reason
that
we
do.
That
is
because,
when
we
start
up
a
process,
it
often
will
share
a
lot
of
its
overhead
with
other
processes.
So,
for
example,
if
you're
running
a
web
server
and
you've
got
30,
apache,
threads
or
nginx
instances
running
each
one
of
those
loads,
shared
memory
like
shared
libraries
and
that
kind
of
thing.
Well,
how
many
of
those
do
you
really
need
loaded?
Do
you
need
one
instance
of
that
library
for
every
single
thread
that
you
have
going?
B
So
the
commit
limit
is
how
much
I
will
allow
processes
to
ask
for
across
the
entirety
of
the
system.
So
this
box,
I
think,
has
eight
gig
of
ram
and
you
can
see
that
we're
committed
our
commit
limit
is
like
almost
12
gig
of
ram
okay.
So
normally
you
see
us
commit
to
about
50
more
memory
than
we've
got
committed,
as
is
how
much
we're
currently
committed
to
delivery.
B
B
A
B
B
B
It
turns
out
it's
given
the
same
memory
table,
so
it
thinks
that
it's
memory
starts
at
like
all
zeros
and
goes
until
some
other
hex
number.
But
if
you
looked
at
every
single
process,
every
single
process
starts
at
that
all
zero
memory
address,
but
they
can't
all
start
there,
because
that
would
mean
that
they're
all
stored
in
the
same
actual
physical
ram,
and
so
what
you
may
have
noticed
if
you
do
s
trace
and
look
at
the
system
calls
that
are
being
made
by
applications.
B
A
Cool,
so
there
is
a
question
from
mr
rapscallion
reeves,
according
to
the
gentoo
handbook,
so
take
that
with
a
grain
of
salt,
special
care
needs
to
be
made
when
mounting
or
special
gear
needs
to
be
taken
when
mounting
proc
and
sys
directories.
Obviously
they
suggest
using
the
dash
dash
r
bind
and
dash
dash
make
our
slave
options.
Could
you
speak
on
that?
Maybe
why
they're
needed?
I
don't
know
to
be
honest,.
B
A
B
A
Sorry
that
was
for
when
mounting
the
base,
croc
and
cyst
directories
into
a
true,
maybe
it's
just
because
those
directories
are
needed
for
the
host
and
troop,
probably
I
mean
this
is
all
done
automatically
right
like
this.
Is
the
value
add
of
rel
like
you're,
not
building
it?
You
know
basically
from
scratch.
A
B
So
I
wanted
to
go
like
super
deep
for
just
a
second.
I
know
that
mmu
was
like
also
deep,
all
right,
so
there's
so
much
data
here
and
a
lot
of
it
like
we
get
through
other
tools,
but
then
there's
like
a
bunch
of
just
like
random
how
the
operating
system
works,
stuff
and
buddy
info
as
an
example,
one
of
those
so
buddy
info
is
broken
up
into
the
different
zones
of
memory.
B
B
So
no
single
individual
pages,
but
lots
of
like
hunks
of
memory,
whereas
down
here
in
dma,
32,
there's
a
whole
bunch
of
individual
pages,
but
very
few
giant
hunks
of
buddies
together
and
same
thing
in
zone
normal,
and
so
like
do
you
need
to
know
this
information?
Probably
not,
but
if
you're
running
on
a
system-
and
it's
been
up
for
a
really
long
time-
you
could
use
something
like
this
to
ask
yourself.
The
question:
am
I
dealing
with
fragmented
memory
right?
B
So
if
you
have
like
groups
of
contiguous
free
buddies,
then
you
have
groups
of
contiguous
memory,
you're
not
fragmented.
But
if
you
have
like
onesies
in
each
one
of
these
categories,
then
that
tells
you
that
you
have
very
limited
amount
of
memory
in
each
of
these
groups
of
continuous
blocks
of
memory
or,
if
you
had,
like
all
single
page,
reported
buddies
right
where
they're
just
one
page
standing
there
by
themselves.
B
B
C
B
Right,
but
there
are
a
couple
places
where
you
can
make
changes.
We
saw
one
of
those
earlier
when
we
were
messing
around
with
loom
adjust,
and
that
was
changing
score
right.
So
that
was
a
an
example.
Those
changes
are
not
persistent,
because
everything
in
this
directory
is
in
memory.
So,
if
you
read
with
the
machine,
it
goes
back
to
whatever
the
value
was
originally.
B
That
is
the
older
method
of
making
these
changes.
Persistent
the
newer
method
is
2d,
so
2d
profiles
will
actually
adjust
data
here
in
process.
It
can
also
adjust
things
in
slash
cis,
so
sony
was
asking
earlier
about
the
difference
between
the
two
file
systems.
Tunde
can
actually
handle
both
sys
ctl
only
does
process
right
all
right.
B
B
Sure
why
don't
we
make
that
one
of
our
first
things
that
we
mess
around
with
in
process?
So
let's
hold
this
like
database
thing
for
a
second
okay
and
talk
about
the
mechanics
of
making
changes
to
process
all
right.
So
if
I
remember
correctly,
drop
caches
is
in
vm,
because
it's
a
virtual
memory
thing.
B
B
B
And
then
it's
broken
down
by
that
top
level
directory
hierarchy
underneath
proxis,
so
for
looking
at
drop
caches,
which
is
in
proxies
vm.
I'm
going
to
take
a
look
at
em.txt
and
I'm
going
to
look
for
drop
connections
all
right.
So
that's
in
the
list
of
tunables
covered
by
this
document
and
then,
when
I
look
down
into
it,
it
says
this
is
going
to
cause
the
kernel
to
drop
caches,
but
depending
on
what
number
you
shove
into
it,
tells
it
what
caches
you're
interested
in
dropping.
B
B
B
Right
so
the
reason
that
we
cache
data,
in
fact
you'll
notice,
that
when
you
look
at
free
memory
using
the
free
command
that
the
lettuce
kernel
almost
always
like,
gobbles
up
whatever
it
can
in
cached
memory.
So,
like
you
see
the
used
and
you'll
see
a
very
small
free
and
you'll
see
a
whole
bunch
of
stuff
over
in
cash,
and
you
saw
that
originally
right.
I
have
about
eight
gigs
of
total
memory.
I
was
using
about
two.
B
B
B
B
B
I
may
not
have
noticed
that
it
has
sped
up,
but
it
actually
was
sped
up
because
it
was
pulling
that
information
out
of
cache
instead
of
actually
having
to
go
and
spin
the
disk
and
or
in
my
case,
look
in
the
memory
register
on
the
nvme
to
figure
out
what
entries
are
in
that
directory
and
then
here
we
were
over
here
in
this,
and
I
looked
in
the
vm
text
and
it's
like
oh
wait,
the
the
tunable
wasn't
in
there.
Well,
let
me
check
here.
B
B
It
is
now
hitting
the
cache
instead
of
pulling
that
up
from
disk,
and
so
that's
the
kind
of
stuff
that
we're
storing
in
cache
and
the
same
thing
for
things
like
application
stuff
when
applications
open
files
or
applications
write
files.
What's
the
likelihood
that
it's
going
to
access
that
same
file
again,
so
we'll
keep
it
in
cash
to
try
and
speed
those
accesses
up?
B
So
when
you
drop
cache,
you're
ditching,
all
of
those
saved
bits
of
data
and
then
the
next
time
we
need
to
open
that
file,
we
actually
have
to
spin
the
disk
up,
navigate
the
directory
structure,
find
it
make
sure
permissions
are
correct,
allocate
it
and
show
it
to
you.
So
that's
that's.
What
you're
doing
by
dropping
the
cache
you're
just
making
us
do
all
of
those
activities
on
the
native
operating
system,
instead
of
being
able
to
review
the
data
that
we've
already
loaded
once
in
the
memory
for
something
we
used,
it.
A
B
B
If
there's
not
enough
free
memory
to
service
it
and
free,
then
it
looks
to
see
whether,
if
we
combine
some
stuff
from
free
and
cash,
if
that
would
be
enough
memory
and
if
so
then,
the
kernel
embarks
on
the
journey
of
like
removing
data
from
cash
flushing
data
out
of
cash.
Returning
that
memory
to
the
free
and
then
performing
the
malik
request
that
was
made
right
so.
B
B
All
right
so
when
it's
zero,
the
kernel
attempts
to
estimate
the
amount
of
free
memory
left
on
user
space
when
it
allocates
more
memory
when
it's
one,
the
kernel
pretends,
there's
always
enough
memory,
it'll
never
run
out.
So
whatever
is
requested,
that's
what
it's
going
to
give
as
an
address
space
right
realize
the
address
space
doesn't
actually
equate
to
real
ram
used
by
the
process
and
then
two
is
never
over
commit
so
currently
on
this
system.
By
default,
we
use
setting
zero.
B
There
are
certain
very
conservative
entities
that
don't
want
to
get
in
a
situation
where
they
need
the
memory
and
because
they're
out
of
memory
boom
killer,
starts
and
starts
killing
off
their
processes.
Because
that's
what,
if
you're
over
committing
memory?
That's
what
could
potentially
be
the
case.
And
so
there
are
certain
uses
where
the
architects
of
those
applications
have
said
we're
never
going
to
over
commit
memory,
because
I
don't
want
to
risk
having
loom
killer
startup,
to
kill
off
processes
on
my
box
right.
A
B
B
B
Yes,
yeah,
yes,
and
in
fact
it's
it's,
I
think
one
of
the
most
commonly
tuned
things
yeah
all
right.
So
it's
a
value
between
0
and
100.,
which
sets
the
kernel's
affinity
for
utilizing
swap
space.
So
it
will
always
utilize
swap
space
right.
It's
just
how
aggressive
should
it
be
at
filling
up
that
swap
space,
so
at
100
it
should
try
to
swap
whenever
it
can,
whatever
data
it
can
right
and
at
zero.
It
should
try
to
never
swap
as
much
as
possible,
but
it
will
still
swap
and
there's
actually
been.
B
B
B
B
B
The
kernel
won't
swap,
however,
that
number
is
very
small,
and
so
it
it
was
put
in
there
to
effectively
disable
swap
space.
But
that's
not
what
this
parameter
does
this
parameter
sets
your
set,
your
affinity
for
using
it.
So
really
it's
like
setting
a
rule
that
says
until
you've
gotten
to
this,
like
really
tiny
amount
of
free
ram.
That's
left,
don't
swap
don't,
but
once
you
hit
this
really
tiny
amount,
then
swap
away
right.
B
The
other
thing
is
like:
oh
such
a
zero.
The
kernel
will
almost
never
swap
okay.
That's
that's
pretty
true,
however.
Now
because
of
that
change,
it
doesn't
swap
up
until
this,
like
very
tiny
sliver
of
rain
is
left,
and
there
are
now
cases
where,
if
memory
usage
is
going
up
a
lot,
then
what
will
happen
is
the
kernel
will
realize
that
it
needs
to
start
swapping,
because
it's
crossed
that
threshold.
B
Oh,
I
need
to
swap
but
you've
crossed
over
it,
because
you
just
allocated
the
last
bit
of
ram
that
you
had
on
the
system,
so
you're
done
and
the
system
will
essentially
like
hang
it's.
I
think
those
use
cases
are
extraordinarily
rare,
but
what
you'll
see
is
when
someone
recommends
the
youtube
swappiness
and
they
want
you
to
be
really
conservative
with
swappiness.
B
They
will
now
have
you
set
it
to
one
instead
of
having
you
set
it
to
zero,
because
at
swapping
this
one
you're
equally
unlikely
to
utilize
swab's,
face
pretty
darn
close
to
equally
unlikely
using
smiley
face.
But
there's
not
this
like
artificial
boundary
at
which
you
can
cross
to
utilize,
swap
space
so
that
boundary
limitation
is
removed,
so
you're
unlikely
to
use
it.
Unless
you're
very
memory
constrained,
there's
no
actual
listed
amount
of
memory
that
you
have
to
have
in
order
to
start
using
swap.
A
All
right
there's
a
ton
of
questions
here:
okay,
there's
two
of
them
all
right
from
the
same
person.
I
shouldn't
say
sorry:
how
does
overcommit
affect
swappiness
if
we
set
swappiness
to
a
high
value
and
have
set
the
over
commit?
Would
it
fail
to
swap
because,
theoretically,
all
the
memory
could
be
committed.
B
Okay,
so
overcommitment
of
memory
means
that
processes
ask
for
more
than
they're
going
to
use
right
right.
So
now
we're
not
actually
using
that
memory.
It's
just.
We
told
the
process
that
if
it
wanted
it
because
I
asked
for
it,
it
had
it,
and
so
it's
like
I'll
explain
over
commitment
like
this
when
you're
when
you're
dealing
with
a
child,
it's
like
daddy,
I
want
to
go
to
disney
world.
B
One
day,
one
day
we'll
go
to
disney
world
right.
Did
you
actually
commit
to
a
date
on
which
you
are
attending
disney
world?
No,
but
you've
told
them
that
one
day
that'll
happen,
and
so
at
some
point
in
the
future
they're
going
to
be
like.
Are
we
going
to
disney
world
now
we're
doing
this
now
right
and
then
you
can
decide
whether
you're
going
to
do
it
or
not
going
to
do
it
and
over
committing
memory
is
the
same
right.
B
B
37
million
gigs
of
ram
there
you
go
process
right
and
really.
The
process
then
uses
like
the
first
400k
right
and
that's
that's
what
you're
actually
committed
as
yeah
and
at
some
point
in
the
future
when
that
process
goes,
I
need
my
other
400
gig
of
ram
blam,
400
million
gig
of
ram
and
it
actually
tries
to
store
stuff
there.
That's
when
you
actually
have
to
deal
with
that
over
commitment
right.
So,
okay,
so
I
don't
think
there's
a
a
relationship
between
over
commitment
and
swappiness,
because
swapping
is
actual
memory.
B
That's
been
stored,
is
now
being
paged
out
to
the
swap
spaces
and
there's
actually
a
very
specific
list
of
things
that
will
be
eligible
for
swap
so
things
like
anonymous
process.
Data
is
eligible.
Wait,
yes,
is
eligible
for
swap,
but
things
like
shared
shared
libraries
are
not
allowable
for
swamp
because
other
things
might
be
using
it
too.
C
A
A
A
B
So
I
think
that
microsoft
did
a
pretty
good
job
on
this
article
about
how
to
configure
linux
and
starts
talking
about
things
like
software,
which
you
may
or
may
not
be
using
partitioning
recommendations,
battle
system
tuning,
but
the
stuff
that
we're
interested
in
talking
about
proc
today
is
down
a
little
bit
further,
where
it
starts
talking
about
okay
in
your
tunde
profile.
This
is
what
you
want
to
have
in
there,
and
specifically,
all
this
stuff
is
in
process.
B
A
B
Yeah
it
granted
so
what
they
want
to
do
is
they
want
to
avoid
swappiness
as
much
as
as
possible.
That's
why
they're
saying
it
to
have
the
affinity
very
low
for
utilizing
it,
because
a
lot
of
the
data
that
is
stored
by
the
sql
processes
is
cached
data
which
is
stored
in
anonymous
process
data
which
normally
would
be
eligible
for
swapping,
and
so,
if
you
swapped
that
data
out
now,
the
database
process
is
trying
to
hit
its
cache
thinking,
it's
going
to
be
fast.
A
B
Sap
hana,
where
that's
absolutely
true,
all
the
database
is
in
memory
for
sap,
hana
yeah
for
others
like
sql
server,
that's
not
always
the
case,
but
they
prefer
to
have
that
be
the
case
yeah
and
then
there's
sometimes
where
that's
just
not
possible
right.
You
have
this
enormous
database
on
disk,
but
you
want
the
parts
that
you
use
a
lot
to
be
in
memory.
B
B
B
C
B
B
Right
and
so
there's
a
lot
a
lot,
a
lot
of
tuning
guides.
Don't
do
things
like
this
and,
like
you
want
to
be
really
wary
of
those
because
clearly
they're
not
saying
if
you
have
this
much
memory,
you
need
to
set
these
value
to
this.
If
you
have
this
much
more
memory,
you
need
to
be
setting
it
to
something
different,
so
they're,
not
accounting
for
the
actual
memory
you
have
on
systems.
B
B
A
A
B
A
A
Yeah,
oh
speaking,
of
summit
yeah,
please
you
know.
Summit
is
gonna,
be
an
awesome
like
three-part
event
this
year
and
we're
hoping.
The
third
part
is
somewhat
physical,
so
check
out
the
the
summit
page
or
just
drop
a
link
in
chat.
If
you're
interested
sign
up
to
attend.
You
know
we'd
greatly
appreciate
it.
If
you
did
but
yeah
summit
is
our
big
annual
event
and
we're
kind
of
splitting
it
up
for
2021
to
make
it
a
little
bit
more
consumable.
B
A
Just
can't
right
now
yeah,
it's
I've
gotten
to
the
point
where
it's
like
yeah,
it's
cool
to
do
like
a
group
call
every
once
in
a
while,
but
I'm
really
not
looking
forward
to
sitting
in
this
chair,
24
7
right.
That's
not
the
goal
of
me
working
right
like
I
want
to
use
zoom
for
work
and
very
little
else.
You.
A
A
A
It's
already
happened
here,
so
we're
in
that
wonky,
the
rest
of
the
world
is
turning
over
yeah
all
right.
So
that's
all
for
the
channel
today
tune
in
tomorrow
morning.
First
thing:
we're
gonna,
be
talking
about
storage,
talking
about
live
migrations
from
openshift
container
storage
three
to
four
and
do
that
on
the
fly
we'll
see
how
well
that
goes
in.