►
Description
Videos from Ceph Developer Summit: Infernalis (Day 1)
03 March 2015
https://wiki.ceph.com/Planning/CDS/Infernalis_(Mar_2015)
A
B
B
So
the
the
change
that
I've
been
working
on
is
to
have
the
Conn
a
new
kernel
side
x,
io
messenger
that
can
talk
to
a
safe
cluster
that
hand
that
is
listening
on
xio
messenger.
The
current
colonel
client
uses
kernel-based
socket
mechanism
to
talk
to
a
safe
cluster
so
other
than
the
x
io
messenger
changed.
I
made
some
changes
in
the
on
the
current
colonel
messenger
side.
B
The
the
main
change
is
to
add
support
for
loading
new
messengers
dynamically,
and
so,
whenever
there's
a
new
messenger,
it
would
just
register
with
the
current
messenger
and
with
with
a
unique
name
and
a
set
of
interfaces,
and
so
some
of
these
interfaces
are
to
open
a
new
connection.
Close
connections
send
messages,
send
keep-alive
messages
and
cancel
messages,
so
these
interfaces
would
be
registered
on
the
messenger
layer
and
then
a
rbd
images
mapped
a
user.
B
I
have
added
a
new
option
for
the
user
to
specify
what
sort
of
a
messenger
to
use
for
that
map
request
and
based
on
that
mapping.
The
messenger
layer
would,
you
know,
go
through
the
list
of
registered
messenger,
pick
up
the
correct
one
and
use
that
so
and
what
I
have
done
is
I
have
made
the
existing
TCP
socket
based
messengers,
the
default.
B
So
the
new
option
that
I
have
added
for
mapping
as
ms
type,
where
which
you
can
specify
the
messenger
name.
In
addition,
there
have
been
some
minor
changes
to
the
safe
message
and
the
safe
connection
structures
to
take
some
additional
parameters
which
are
like
messenger,
private
data
structures
and.
B
The
colonel
side,
xio
messenger,
is
pretty
straightforward.
It
is
mostly
just
mapping
the
safe
side
request
to
the
xio
site
request,
so
an
open
connection
from
the
SEF
would
result
on
a
xio
connection
stock
and
similarly,
a
send
message
from
self
would
result
in
a
chain
of
sio
messages
that
are
sent
or
using
the
xiao
interfaces
so
forth,
and
so.
C
One
question
one
question
before
you
yeah
we
actually,
this
is
about
the
when
you're
saying
that
the
messenger
obviously
there's
the
existing
TCP
implementation
and
then
there's
the
xio
one.
When
you
said
it's
a
loadable
module,
do
you
mean
it's
like
it's
a
separate
kernel
module?
That's
dynamically
loaded,
or
do
you
mean
just
that?
There's
a
switch
that
instantiates
either
a
different
implementation
of
the
same
messenger
interface.
B
C
B
You
know
they
have
a
whole
bunch
of
dependency,
so
I
made
it
a
dynamic
module,
go
and
that
my
module
depends
on
those
two
modules
and
as
long
as
they
are
loaded,
you
just
have
to
load
this
module.
It
took
go
ahead
and
register
itself
as
a
messenger,
and
then
you
pass
it
in
the
map
and
start
using
the
new
messenger.
Okay.
B
Yeah,
so
that
way,
yeah
so
some
some
of
those
functions
that
that
the
quiz
declined
or
the
Mon
client
in
the
kernel
mix
they
make
some.
You
know
messenger
calls
they
kind
of
assume
that
they're
just
talking
to
in
TCP
kind
of
an
interface.
So
some
of
those
I
had
to
refactor
move
some
code
into
tcp,
specific
functions
and
program
and
ok
and
that
that
messenger
is
registered
by
default.
So
new
ones
just
keep
getting
added
to
that.
Ok,
ok,.
B
C
I
did
I
think
that
I
mean
as
always.
The
first
step
is
to
look
at
the
ones
that
are
refactoring
interface,
to
just
isolate
the
TCP
stuffs
and
behind
a
nice,
clean
interface,
yeah
and
so
as
soon
as
those
already
feel
free
to
post
them,
and
we
can
make
sure
that
that
makes
sense
before
getting
too
far
grip.
Yeah
yeah.
A
B
A
B
And-
and
there
is
some
some
performance
investigations
that
we
are
doing
on
the
x,
ì
óù
side,
so
currently
xio
kind
of
mandates,
a
one
kernel
thread
for
every
connection,
so
that
I
don't
know
how
well
that
scales.
So
we
are
actually
investigating
to
see
if
we
can
use
work
use
in
the
kernel
side
to
to
avoid
the
overhead
open
thread.
I
sing.
B
They
have
most
of
the
changes
are
identical
to
the
user
space
code,
but
some
of
these
things,
like
you,
know
how
new
messages
or
how
a
synchronous
events
are
handle
this
kind
of
different
than
it
Morris
internal
space,
okay,
okay,
and
so
the
sum
of
the
thing
is
currently
we
don't
support.
You
know
mixed
curve
plus
test,
like
you
can't
have
some
some
nodes
in
the
cluster
running,
TCP
and
others
running,
exile
and
and.
C
That's,
that's
that's
fault
and
they're.
Definitely
not
your
fault.
We
need
to
figure
out
a
we
need
to
figure
out
and
how
we
want
to
mark
the
addresses
so
that
you
can
tell
what
type
of
address
it
is
and
then
also
hack
it
so
that
ideally
make
it
so
that
you
can
have
multiple
endpoints
for
different
I
guess
as
a
separate
problem,
but
stay
down.
Multi-Protocol
support,
obey
adam.
That's
all
precocious.
B
The
Mon
address
that
we
put
in
the
safe
gone
for
the
rbd
CLI
to
use
it
needs
to
be
running
so
that
I
think
we
may
need
to
put
an
option
over
there.
That
says
that
this
interface
is
actually
a
xio
interface
or
currently
it's
just
my
PA
dress
and
I
assume
that
that
is
running
on
xio
interface,
with
there's
no
way
for
the
client
to
know
that.
C
Yeah,
so
if
we
talked
about
this
maybe
to
see
DSS
ago,
but
there
are
their
fields
in
the
entity
a
dirty
in
the
address
structure
that
aren't
really
used
for
anything
that
are
always
type
1
or
something
that
we
could
actually
just
Rev,
that
type
so
type
2
is
x,
io
and
then
the
rest
of
the
structure
is
the
same.
It's
an
IP
address,
but
then
you
can
tell
it's
an
x,
io
IP
and
not
a
tcp/ip.
Oh.
B
C
You
could
just
make
the
monitor
one.
A
regular
TCP
one
just
by
default,
might
have
some
special
option,
but
then,
when
you
get
like
the
listing
map
or
something
all
the
addresses,
you
can
tell
whether
it's
a
NX
I,
oh
I,
PDR
a
regular
tcp/ip
yeah
yeah
there,
but
I
think
that's,
that's
probably
something
that
would
have
to
happen
in
the
other
frame
for
malice
or
for
we
could
do
/
in
front
us
if
you
wanted
to
or
for
j
okay.
However,
that
is
there's
like
there's
an
old
branch.
C
That's
sort
of
half
done
that
that
tries
to
solve
both
that
problem
and
the
problem
where
you
can
have
either
a
single
IP
or
a
set
of
ip's.
So
you
could
have
an
OST
listening
on
both
types
of
interfaces
at
the
same
time
right,
great
yeah,
but
it's
it's
like
it
didn't
build
because
I'd
never
finished
it,
but
it
also
needs
to
be
rebased.
So
that's
sort
of
a
took
a
tedious
project,
but
at
some
point,
when
one
tackle
okay,
when
we
have
already
my
support
in
there
yeah
okay
how's
help.
C
C
So
that
I
mean
that
the
I
guess
it
all
sort
of
falls
in
the
category
of
all
the
failure,
handling
and
I'm,
actually
not
sure
what
state
that's
in
on
the
on
the
user
space
side
either,
but
that's
the
main
place
where
you'll
see
that
it's
different
widths,
ffs
versus
the
US
DS
on
the
other
STIs.
If
you
lose
a
connection-
and
just
you
forget
everything,
you
reopen
a
new
connection
and
you
resend
everything
that
hasn't
been
active
on
the
MDS
sessions.
C
There's
all
this
complicated
state
with
sequence
numbers
that,
like
preserve
the
ordering
and
flow
of
messages
in
both
directions
and
so
it'll
be
more
complicated
there.
So
I
would
probably
focus
just
on
the
rbd
case
and
make
sure
all
the
failure
and
Link
stuff
works,
because
that's
going
to
be
more
important
to
get
this
actually
in
users,
hands
and
then
way
about
the
reconnect
behavior
later.
Okay,.
C
C
C
B
C
B
D
C
The
the
what
what
we
want
to
aim
for,
and
what
hopefully
will
happen,
is
that
lib
xio
gets
merged
in
its
own
right
as
a
as
a
library
available
to
any
colonel
user
and
steph
is,
you
know,
initially
the
only
colonel
user,
and
given
that
it's
a
network
protocol
effectively,
it
presumably
goes
in,
should
go
in
net.
Xio
would
be
my
guess
them.
Okay,
it's
not
it's
not
really
a
driver,
it
doesn't
it'll
sit
on
top
of
any
IP
verbs
driver
right,
an
event
driver
right.
C
So
I
may
ultimately
want
this
to
go
upstream
into
the
mainline
linux
kernel.
The
way
to
make
that
happen,
I
think,
is
to
make
sure
that
is
to
have
a
set
of
patches
that
cleanly
add
you
know,
live
xio
or
whatever.
It
is
as
a
generic
kernel
module
that's
in
the
tree
and
then
also
and
then
have
SEF
have
an
option
that
enables
xio
support.
That
depends
on
that
with
all
the
module
all
the
stuff
in
the
cave,
Kate
build
files
were
ever
to
make
that
work.
C
Ya
know
it
really
just
structure
that
you
really
should
just
try
to
start
for
the
kernel
source
that
way
and
the
paps
it
that
way,
and
maybe
that
module
gets
distributed
out
of
tree,
but
but
the
den
goal
should
be
to
make
this
go
all
the
way
upstream.
So,
okay,
I,
don't
know
what
the
what
the
I'm
not
sure
what
the
path
would
be.
C
I,
don't
know
if
it
goes
through
the
network
sub
tree
or
since
I
phaseolus
or
maybe
would
go
through
the
SEF
tree,
but
would
probably
need
a
knack
from
the
network
ice
or
something,
but
it
might
be
when
you,
when
you
post
this
code,
you
should
also
post
the
the
patches
that
actually
just
add
xio
itself
for
the
tree
because
of
the
wall.
Those
will
eventually
need
to
be
yeah.
C
C
That's
what
I
don't
know,
I
think
I
think
they're
going
to
have
to.
I
think
we
can
help
make
sure
they
sort
of
follow
the
right
process,
but
ultimately
they're
going
to
have
to
do
some
of
the
durgon
v1's.
Maintaining
it
right,
they'll
need
to
be
involved,
so
maybe
we
need
to
add
a
separate
conversation
with
them
and
make
sure
they
have
their
you're
doing
it
in
the
right
fashion.
I.
C
D
C
A
C
D
B
Xio
has
an
option
that
you
know
you
can
send
a
request
and
they
have
a
request-response
kind
of
mechanism
message
mechanism,
but
the
current
safe
for
xio
messenger
doesn't
support
that,
so
it
works
in
like
a
one-way,
same
message
fashion.
So
this
was
you
know
when
I
have
been
I
had
returned
this.
They
had
support
for
that,
but
right
now
the
con,
the
safe
messenger
doesn't
or
that.
So
it
is
just
one
way.
The
request
and
response
both
are
one
way
message
is
currently
I.
Think.
C
That
makes
both
the
client
and
the
server
realize
that
the
reply
isn't
needed,
and
so
they
just
don't
bother
so
I'm,
pretty
sure,
there's
a
way
that
the
xio,
the
user
space
xio
messenger
is
implemented,
is
also
in
this
one
way,
just
messaged
back
in
fashion,
and
so
we
just
we
just
don't
use
the
the
special
request.
Reply:
xio
yep,
the
building
yeah,
so
I
guess
in
your
case
I,
wouldn't
worry
about
it
until
there's
sort
of
a
an
overall
strategy
that
we
want
to
somehow
change
things
around
to
take
advantage
of
it.