►
From YouTube: CephFS Code Walkthrough: MDS path traversal
A
A
Let
us
get
to
know
the
data
structure
that
it
deals
with.
There
are
three
important
data
structure
that
it
deals
with.
First
being
the
c
I
node
seed
entry
and
the
series,
the
c.
The
c
here
refers
to
the
cache
so
c
I
node
is
per
file.
So,
as
we
all
know
that
an
inode
in
a
file
system
represents
the
file
and
it
contains
the
information
like
who
wants
the
file,
attributes
and
other
stuff.
So
it's
similar
here
as
well
and
seed
entry
is
the
short
form
of
directory
entry.
A
So
the
directory
entry,
glues,
the
inode
and
the
file
name
are
the
path
or
the
directory
name.
So
so,
as
yeah,
you
can
see
that
the
cdn
tree
links
at
most
one
ci,
node
and
and
inode
can
have
delete
the
multiple
entries
so
that
that
is
the
use
case
with
respect
to
the
hard
links.
So
when
our
links
are
involved,
we'll
have
a
single
inode,
a
linking
to
the
multiple
ad
entries
and
cdav
is
a
data
structure.
A
It
exists
only
for
the
directories,
so
it
is
used
to
link
the
entries
under
the
directory,
so
we'll
get
to
know
we'll
get
to
know
more
about
it.
When
we
look
into
the
code,
we'll
have
more
understanding
about
it.
So
these
are
the
three
important
data
structures,
and
also
we
have
the
concept
of
authoritative
mds,
so
any
particular
inode
is
should
be
if
it
is
being
changed
by
particular
mds.
So
it
should
be
authoritative
mds.
A
So
if
it
is
not
an
authority
to
mds
for
that
particular
inode,
usually
if
it
it
will
transfer
forward
the
request
to
the
authoritative
mds.
A
So
we
have
this
concept
so
and
now,
let's
get
into
the
I
thought
first,
we
will
go
through
the
path
diversely
code
and
after
that
I
thought,
we'll
discuss
three
use
cases,
one
being
the
what
happens
when
we
touch
a
file
in
a
particular
path
and
the
second,
if
the
second
use
case
being
what
happens
if
we,
if
the
path
involves
the
snap
directory
and
third
simple
use
case
where
if
the
some
identity
doesn't
exist
in
the
path,
so
there
are
other
complicated
use
cases
in
this
stock
I'll
be
considering
only
the
single
mbs
use
case,
but
there
are
other
complicated
use
cases
involving
multiple
mds
and
if
that
particular
directory
entry
falls
into
the
different
mds,
what
happens
and
all
the
stuff
I'll
be
touching
those
concepts
theoretically
but
I'll
not
be
going
through
them
with
the
gdp
and
stuff
in
these
three
use
cases
I'll
go
through
with
the
gdp
and
show
you
and
print
the
structures
and
how
does
the
code
flow
so
now,
let's
get
into
the
course.
A
So
the
md
cache
object
defines
the
path
drivers
routine,
so
the
path
traverse
basically
takes
the
file
path
and
the
return
values,
as
you
can
see,
would
be
the
vector
of
the
entries
and
the
inode
of
that
particular
base
base
name
component.
A
A
A
So,
as
you
can
see
the
flags
they
are
varied,
there
are
various
flags
that
it
uses
mostly
related
to
the
locks
and
stuff,
for
example,
if
you
want
to
traverse
this
path,
if
the
flag
is
set
to
travis
discover,
we
would
be
discovering
it
with
all
the
mdss
and
if
you
want
to
traverse
the
path
with
the
potluck
and
if
you,
if
the
travis
want
the
entry
flag
is
set,
that
means
the
caller
is
expecting
that
entry
and
similar
stuff.
A
So
I'm
not
touching
the
flags
related
to
the
lock
much
because
in
the
last
duck
I
think
twinkie
covered
that
part
a
bit
okay.
So
this
is
mostly
let's
get
into
the
code,
so
the
forward
is
usually
set
to
true
in
the
normal
in
most
of
the
use
cases.
The
other
thing
with
the
power
traverse
is
we
mostly
hit
the
part
drivers
with
when
the
client
sends
a
lookup
on
a
particular
path.
So
there
are
other
cases
where
we
get
the
path
we
hit.
A
The
client
and
the
attacker
also
invokes
the
power
traverse
without
the
path
component,
but
the
copper
component,
meaning
the
gata,
can
invoke
the
power
traverse
only
with
the
ilo
number
filled
with
inode
number,
but
not
the
path
component.
Where
has
the
lookup?
A
It
is
expected
that
the
base
name
has
to
be
filled
in
the
path
component,
so
the
forward
is
generally
set
to
true
because
most
of
the
cases
we
don't
do
discover
right
at
the
start.
So
if
you
can
see
the
forward,
it's
set
to
not
discover.
So
if
the
discover
flag
is
not
set
by
automatically
the
forward
is
set
to
true,
so
this
flag
is
used
if
the
forward
is
set,
meaning
if
it's
not
an
authoritative
mds.
A
In
such
cases,
we
use
this
flag
to
pass
it
to
the
to
open
that
entry
on
the
authority
to
mds
or
position
to
the
authoritative
mdss.
A
So
yeah
this
is,
we
initially
said
assume
that
the
path
is
not
the
snap
id,
so
it
is
set
to
the
no
snap
here
this
the
client
is
just
set
from
here
from.
It
is
fresh
from
the
mdr
request,
and
here
is
where
the
actual
thing
starts.
So
so,
as
you
can,
as
I
mentioned
in
the
file
path,
the
client
when
the
lookup
comes
on
a
component,
the
client
side
part
traversal
code,
for
example,
if
the
lookup
comes
on,
say
the
slash
on
the
path,
slash,
d1d2
and
f5.51.txt.
A
So
the
client
side
sends
a
lookup
on
first
the
root.
I
know
number.
That
is
one
slash
there,
one
so
in
the
so.
This
contains
path
that
that
I
know
number
will
search
the
inode
structure
for
the
root
I
node.
So
when
we
are
discussing
the
case
where
the
path
contains
the
inode
number
of
the
root
base,
name
being
the
one.
A
A
It's
simple,
so
it
fire,
it
maintains
a
inode
map,
so
it
calls
the
get.
I
know
constructing
the
vi
node.
So
if
you
go
to
the
get
I
know
with
the
vi
node
it
finds
it.
It
tries
to
find
it
in
the
inode
map
and
returns
if
it
is
present
in
the
map.
So
let's
assume,
for
the
sake
of
simplicity,
that
the
we'll
get
the
inode
structure
for
the
root.
So
that
is
so
I'm
assuming
that
it's
there.
A
A
So
if
the
directory
is
deleted
and
if
it,
if
the
state
of
that
is
straight,
then
I
think
it
does
traverse
with
the
discover
so
not
go
in
detail
with
with
these
cases.
Let's
talk
about
the
simple
case.
First,
so
we'll
get
a
hang
of
the
code
flow
and
then
we
can
handle
the
go
into
the
corner
cases,
so
we
have
the
inode
structure
for
the
root.
A
So
let's
assume
that
it's
not
purging,
so
we
don't
return.
Instead,
I'm
skipping
the
lock
cache
for
now
anything
related
to
log
cache.
Mostly
it
will
be
disabled
in
whatever
the
cases
I
have
tested.
A
So
it
comes
here,
so
it
will
just
clear
the
feed
entry
vector
if
for
this,
if
it
contains
any
state
and
it
will
fill
in
the
inode
the
root
I
node
as
the
current,
I
know
that
it
returns
but
yeah
for
now.
So
this
is
the
for
loop
that
where
it
traverses
the
base
name
component,
so
until
now
from
the
parent
inode
number,
we
got
the
inode
structure.
So
this
is
where
we
jump
into
the
path
component
and
traverse
each
path,
so
the
root
inode
is
a
directory.
A
A
So
this
is
interesting
here
yeah,
so
this
is
where
from
the
inode,
we
will
pick
the
fragment
related
to
that
path.
So
here
the
path
is
d1,
so
from
that
fragment,
we'll
get
the
ctr
structure.
A
Okay,
so
this
is
important,
because,
if
that
there
one
that
we
are
picking
up
the
fragment
of
the
dir
one
and
from
that
fragment
we
are
fetching
the
c
dip
of
that
current
directory.
A
Okay.
So
let's
assume
that
the
serial
structure,
we
have
no
problem
with
this
seeded
structure
and
we
are
good
with
it
I'll
just
skip
through
this
conditions.
A
Yeah
these
two
and
we
yeah
so
from
that
see
that
we
will
do
a
lookup
on
that
particular
path.
So
snap
id
is
first
to
head
here
because
the
snap
their
path
is
not
involved,
so
so
in
this
lookup
there
are
two
cases
one
we
might
hit
the.
A
Sorry
lookup
is
pretty
simple,
so
it
tries
to
look
up
for
that
particular
base.
Name
in
the
cd
structure
object
if
it
finds
it
that's
a
hit,
so
we
will
find
that
entry
for
that
particular
base
name
if
it
doesn't
hit
it.
It's
it's
a
miss
and
we'll
have
a
separate
workflow
for
that.
Let's
assume
that
we
get
the
entry,
the
lookup
is
successful
and
we
get
that
entry.
So
in
that
particular
case
again
we
have.
A
We
do
some
state
checks
if
it's
not
purging
and
the
stuff,
if
it's
all
good,
this
is
related
to
lock
keeping
here
yeah.
So
this
is
where
we
push
the
entry
back
into
that
return
structure,
vector
that
we
that
that
is
passed
to
the
path
drivers
and
the
other
thing
here
is
that
from
that
entry
we
also
have
to
fetch
the
inode
so
that
we
return
it
back
to
the
caller.
So
this
is
where,
from
that
entry
we
get
the
linkage
structure,
so
linkage
is
for
where
it
maintains,
for
example,
yeah.
A
So
linkage
structure
is
where
it
maintains,
whether
that
it
has
a
pointer
to
the
inode
and
also
whether
that
inode
is
primarily
remote
or
none.
All
this
stuff
is
maintained
in
the
linkage.
So
once
we
have
a
linkage
object
from
that,
there
are
a
couple
of
checks
whether
it
is
nonetheless
stuff
like
that.
So
from
that
linkage
we
get
the
inode
of
the
base
component.
So
this
is
where
we
get
that
I
know
so.
A
I'm
assuming
the
success
cases
here.
A
So
we
got
the
inode
so
that
I
node
is
treated
as
current,
so
in
in
usual
cases
in
the
look
up
there
on
there
only
be
a
parent,
I
know
number
and
a
base
component
being
a
single
path
name,
if
it's,
for
example,
if
it's
like
slash,
did
one
day
two
followed
by
something
the
client
side
only
sends
it
as
base
parent
inode
number
slash
a
single
component
of
the
base
name
again,
look
up
on
the
parent
or
inode
being
the
dear
one,
and
the
next
component
like
that
it
will
send.
A
So
that
is
a
general
case
with
the
lookup,
but
I
think
with
the
snap
there
for
traversal
and
in
some
other
cases
there
might
be
the
path
component
contains
the
entire
more
than
one
component.
So
in
those
cases
we
would
return
that
entry
for
all
of
the
path
components.
That's
why
the
that's?
Why
that
entry
is
a
vector.
A
A
This
is
the
inode
is
assigned
to
current
I'm
skipping
this
x
for
now
yeah.
So
this
is.
We
are
touching
the
I
node
this,
so
we
are
updating
the
lru
that
the
anode
is
being
attached
and
if
so
here
we
are
assigning
the
inode
of
the
base
name
component
to
the
return
value,
and
we
are
increasing
the
depth
to
check
whether
if
the
path
component
contains
anymore
in
most
of
the
lookup
cases,
it
is
not
so
when
it
gets
continued,
we
are
getting
out
of
the
for
loop.
A
So
if
we
get
out
of
the
for
loop,
it's
pretty
simple.
This
is
where
we
get
out
of
the
for
loop.
So
at
the
end
of
this
for
loop
in
the
success
cases,
we
have
a
identity
and
also
the
inode
for
that
particular
base
component.
A
So
again,
there
are
some
checks.
If,
if
if,
if
the
authoritative
mds
flag
is
set-
and
it
doesn't
want
an
identity,
then
there
are
some
cases
are
not
good
in
detail
to
this,
and
this
is
interesting
that
if
it
is
not
authoritative,
if
the
current
inode
is
not
authoritative,
then
it
is
forwarded
to
the
one
from
formula
to
authority
to
mds
so
and
the
return
values
are
like
that.
So
one
more
interesting
thing
is
that
in
the
success
case,
the
return
value
is
zero.
A
In
the,
if
the
return
value
is
one,
I
think
we
will
wait.
A
Waiting
queue
and
wait
for
the
result,
if
the
request,
if
the
return
value
is
two,
I
think
I
will
forward
the
request
to
the
authority
to
mds
I'll
confirm
that
once
we
go
to
the
caller
and
explore
that
so
yeah.
So
if
we,
if
the,
if
the
code
is
if
we
are
able
to
get
the
entry
and
the
inode,
it
is
treated
as
success
and
the
written
value
is
zero.
A
A
Yeah,
so
if
in
the
current
directory,
when
we
look
up
in
if
we
miss
that
entry,
if
that
lookup
is
a
miss,
we
reach
here
and
we
check
whether
the
seed
which
we
have
is
an
authoritative
is
from
the
authority
to
mds,
and
if
it
is
yes
and
if
it
is
in
the
complete
state
and
if
there
are,
if
it's
not
related
to
snap
and
it
will
check
in
its
bloom
filter
whether
if
it
has
the
path
component,
if
it
does
not
have
if
the
blue
petal
says
no,
then
obviously
it
is
the
case
of
you
know,
and
so,
if,
if
these
things,
if
these
so
then
this
is
the
inno
end
case.
A
So
there
is
other
case
that
if
it
is
not
authoritative,
so
we'll
finish
that
if
it's
not
authoritative,
then
we'll
do
a
couple
of
checks
with
the
forward
and
discover
and
based
on
that,
I'm
not
I'm
not
very
familiar
with
this
particular
check.
So
I'll
I'll.
Just
click
through
this
checks
so
yeah.
If,
if
it
finds
it
has
to
discover,
then
it
will
do
a
discover
on
that
path.
If
it
has
to
be
forward,
then
it
will
check
whether.
A
It's
an
ambiguous,
no
mds
is
having
the
authority
on
it.
If
that's
the
case,
then
it
will
add
it
to
the
waiter
list
and
return
-1,
and
if
there
is
an
authority
to
mds
it
will
forward
the
request
for
that.
A
So
this
is
if,
if
the
entry
is
not,
if
the
current
mds,
which
is
processing,
is
not
data
radiative
one,
it
will
go
to
this
code
path.
If
it
is
the
authoritative
one,
then
it
declares
it
as
that's
the
inno
end
case.
So
in
the
innovate
case
it
does
a
couple
of
checks.
So
if
the.
A
A
If
the
path
involves
the
snap,
their
path,
then,
will
not
add
a
null
identity
for
that
which
has
written
you
know
and
if
the
current
directory
is
frozen,
so
sometimes
the
directory
goes
in
the
frozen
state
in
the
situation
in
the
cases
where
the
balancing
happens
in
those
cases
like
yes,
so
in
those
cases
we
add
it
to
the
waiting
list
and
written
minus
one
else.
A
If
this
is
none
of
these
cases,
we
add
a
null
entry
into
the
seeder
so
and
we
give
necessary
steps
with
respect
to
locks
and
we
return
that
tree
to
the
collar,
if
it
that,
if,
if
the
one
identity
flag
is
set,
so
this
is
the
use
case,
I've
seen,
for
example,
when
you
do
a
touch
on
such
a
file
on
the
particular
directory
when
it
reaches
the
last
component
of
the
path
traversal.
A
It
generally
adds
a
null
entry
first
and
returns
that
entry
and
then
again
we
will
look
into
that
in
detail
when
we
go
through
the
actual,
when
we
attack
gdb
and
examine.
A
So
yeah,
if
the
one
delta
flag
is
set,
it
will
return
that
entry
here
if
it
is
not
set
yeah,
it
returns.
A
One
more
use
case
is
if
it
is
an
authoritative
mds
and
if
it
is
not
complete
or
any
of
that
state
we
will
reach
here.
In
that
case,
we
will
check
the
damaged
table.
So
mds
maintains
a
damaged.
I
know
damage
table,
so
if
it
is
part
of
it,
I
think
we'll
return.
Eio.
A
The
try
to
fetch
it
so
the
color
would
get
a
written
one,
so
the
color
would
behave
appropriately.
A
A
A
A
A
Okay,
so
this
is
what
I'm
showing
from
the
mount.
A
So,
let's
print
the
path
component,
so,
as
you
can
see,
let's
also
check,
as
you
can
see,
the
inode
number
is
one
that
is
the
root
inode
number
and
the
path
component
is.
C
A
One,
so
that's
what
I
was
explaining
in
the
code
walkthrough
so
in
the
lookup,
and
also
observe
this
part.
If
the
part
doesn't
involve
a
snapdragon,
this
vector,
will
the
zeroth
index
directly
will
have
the
base
name
if.
A
Followed
by
the
part
of
path
component,
we'll
we'll
see
that
later
so
check
the
back
crease.
A
Bt,
so
yeah
yeah,
so
it's
a
look
up,
so
the
lookup
in
mds
is
handled
by
the
handle
client
get
at
our
routines
by
having
a
boolean.
So
if
his
lookup
is
true,
it's
a
lookup
call.
If
it's
not
if
it's
a
data,
so
let's
go
through
it,
do
all
this
blacks
design,
so
forward
is
set
to
true.
So
it
is
checking
for
the
mdr
request
and
snap
id
is
assigned.
It
is
getting
the
client
yeah.
So
here,
let's
and
the
media.
A
As
of
now,
it's
null
similarly
pin
is
also
is
zero.
This
is
what
we
expect.
This
pattern
cell
is
expected
to
fill
so
now
that
we
got
the
current
inode
from
the
inode
number,
so
we
have
the.
A
This
is
the
inode
of
the
root,
so
it's
not
in
the
state
of
birth,
so
we
did
not
go
there
lock.
That
is
not
enabled.
A
We
did
not
go
there,
so
yeah,
so
we're
just
here,
clearing
the
pdm
by
character
still
and
if
we
are
assigning
the
I
node
of
the
root
into
the
pin
here
yeah.
So
we
are
now
traversing
the
path
component,
so
I
print
as
you
can
see
part
component
is
only
one
that
is
a
div
one.
B
A
There
yeah
it's
a
directory
yeah,
this
is,
is
not
equal
to
zero.
It's
not
a
snapdead
path,
so
we
don't
go
there.
Yeah
here
is
where
it
picks
the
directory
fragment
of
that
particular
path
from
the
inode
that
is
successful
from
the
directory
flag,
which
we
fetch
the
cd.
A
Yeah,
so
here
is
where
we
are
pushing
that
entry
into
the
vector
and
yeah.
So
from
that
entry
we
are
fetching
the
linkage
structure
from
that
linkage
structure.
We
get
the
inode
of
the
their
one
yeah
that
so
we
assign
that
into
the
current
variable.
So
we
are
updating
the
lru
yeah,
so
that
plus
plus
to
continue
the
for
loop
exits
here,
because
the
base
component
contains
only
one
path:
yeah,
we
exited
the
for
loop,
so
we
have
couple
of
checks.
A
We
written
zero
yeah,
so
if
I
hit
continue
again,
there
is
a
request
of
for
the
part
reversal
on
the
same
component,
probably
because
yeah,
if
this
is
from
another,
our
read,
lock
path,
pin
wrap
so
I'll
continue
that
because
it
will
pretty
much
written
pretty
much
the
same
thing.
A
Yeah
see
here,
the
inode
is
of
the
their
one.
The
path
component
is
null,
so
this
is
definitely
not
the
lookup.
So
if
we
check
it
should
be
get
adder
yeah,
so
it
should
be,
it
is
from
the
get
adder
and
it's
not
lookup.
So
in
this
particular
case
it
is
only
expecting
the
inode
structure
of
this
particular
inode
number
for
whatsoever.
Reason.
If
you
go
through
it,
it
will
just
much
follow
the
same
thing
that
we
saw.
It
gets
the
node.
A
A
Yeah
so
let's
see
what
is
this
yeah
so
now
the
client
sent
on
the
next
component,
that
is,
this
is
inode
of
the
tier
one,
and
the
path
component
is
del2.
I
will
hit
the
continue
button
because
it's
pretty
much
follows
the
same
thing
and
it
returns
that
entry.
A
Yeah
now
we
have
the
inode
for
the
d2
and
the
path
component
being
the
file2.txt.
Let's
get
in
here.
A
Yeah
we
got
the
inode
for
that
particular
there
too.
I
know
it
is
not
null.
A
A
From
the
cd
right
now,
the
next
step
is
to
look
up
for
the
file
to
text
yeah.
We
would
be
looking
up
so
in
this
case
it
is
not
present,
I'm
trying
to
create
it.
Let's
see
what
happens
yeah,
that
entry
is
not
present,
so
the
lookup
is
a
miss
on
that
particular
entry,
and
now
we
are
checking
whether
that
seed
is
an
authority
is
from
the
authoritative
mds
and
now
checking
whether
it
is
complete
and
all
that
stuff
and
now.
A
So
in,
if,
if
you
remember
this
check,
this
jack
also
contained
other
stuff
like
there
is
a
bloom
filter
chuck
where
it
guarantees
that
entry
is
not
present.
So
now
we
check
whether
the
is
requested
for
the
dentist.
The
caller
is
just
present
for
that
entry,
yeah
yeah.
We
are
checking
all
this
stuff,
that's
not
frozen
yeah.
In
this
particular
case,
we
are
adding
another
entry
added
another
entry.
A
For
that,
let's
see
and
we
are
pushing,
we
are
updating
that
entry
into
the
vector
the
want
entry
was
not
filled,
so
we
are
returning
a
you
know,
end.
A
Updating
the
entry
vector
we
are
trying
to
get
the
linkage
from
that
entry.
Now
we
have
the
check
yeah.
It's
found
out
that
that
entry
is
null
and
it
is
checking
whether
it's
the
last
component.
Yes,
it
is
begin
its
returning
moment.
A
Yeah
so
this,
but
when
the
open,
when
the
create
request
came
so
I
think
it
sets
the
want
entry
to
true.
So
in
this
case
it
added
the
null
entry
and
doesn't
return.
You
know
end
so
break
from
there.
A
A
And
again,
yeah,
so
now
at
least
we
have
this.
This
simple
use
case
does
not
did
not
involve
any
corner
cases,
but
at
least
it
gave
us
a
glimpse
of
how
the
client
modifies
the
complete
path
into
the
parent
time,
node
number
and
the
base
name
and
how
the
final
component
gets
created
when,
if
it's
a
create
of
a
file
which
does
not
exist,
we
will
also
do
a
simple
code
walkthrough,
which
involves
a
snap
directory
path.
I
already
have
a
snap
path
here.
A
A
Okay,
so
here,
since
I
had
some
of
the
component,
some
of
the
traversal
is
returned
from
the
client
cache.
I
guess,
because
I
did
not
remount
the
unmounted
remote
or
it's
not
from
a
new
mount,
so
I'm
directly
getting
a
path.
Traversal
request
on
the
mds,
for
this
particular
my
node
number.
I
think
this
is
of
their
one,
and
this
is
not.
This
is
a
definitely
not
a
lookup
yeah,
and
this
will
fetch
the
inode
of
that
particular
one.
So
I'll
just
do
a
continue
again
same
thing.
A
Yeah,
so
this
is
interesting,
so
the
client
found
out
that
that
snap
was
there
in
the
path
component
and
it
filled
in
the
file
path
structure
like
this.
So
this
is
the
inode
number
of
the
d1
and
the
path
of
the
snap
one
from
the
the
snap
one
is
the
snap
name.
So
this
was
what
I
was
mentioning.
If
it
involves
a
snap
directly
path,
the
zeroth
index
will
have
a
string
of
length
zero
and
the
next
component
will
have
the
snap
name,
and
now,
let's
go
through
this.
A
Assigns
it
to
that
for
loop
yeah.
This
is
where
we
enter
into
the
yeah
path
of
depth.
As
I
showed
here,
the
depth
of
zero,
the
length
is
zero,
so
it
will
go
there.
It
identifies
this
as
a
snap
there
and
assigns
a
snap
id
of
snap
there,
and
it
also
sends
the
snap
id
to
the
mdr
request
and
increments
it
and
continues
the
follow.
Now
it
has
reached
the
snap
one
and
that's
the
snap
name.
A
A
A
A
Current
directory,
we
are
trying
to
fetch
the
fragment
and
now
get
the
this
flag
from
that
fragment.
Current
directory
is
not
null.
A
Since
it
is
a
snap
rearm
and
the
file
one
doesn't
exist,
we
are
not
adding
an
alt
entry
for
that,
in
other
cases,
as
we
saw,
we
used
to
add
it.
A
So
here
we
are
returning,
you
know
yeah,
so
this
is
pretty
much
what
happens
when
the
snap
directory
is
involved
with
the
path
traversal
yeah,
that's
mostly
it.
I
think
I
also
covered
the
use
case
where
it
is
invented
with
the
same
thing
yeah.
This
is
a
basic
overview
of
what
happens
with
the
path
traversal,
I'm
not
digged
into
the
corner
cases
and
stuff.
Probably
I
will
have
better
understanding
and
give
one
more
session
on
it.
If
that's
required
yeah.
That's
all
I
had.
A
Thank
you
any
questions.
B
Katris
you
you're
talking
about
bloom
filter
so
which
part
of.
A
There
is
one
check
which
I
saw
yeah
here,
so
bloom
filter
is
a
data
sector.
If
you
have
a
it,
if
it
says
it's
a
data
structure,
if
it
when
you
try
to
find
it
in
the
bloom
filter,
something
if
it
says
no,
it's
a
definite.
No,
if
it
if
it
says
yes,
then
it
means
that
it
might
be
there.
It
might
not
be
there.
So
it's
a
data
structure,
that's
being
used
here.
A
I
did
not
dig
into
how
that
get
built
in
the
mds
and
stuff,
but
so
that's
the
general
idea
of
the
bloom
filter.
So
they
have
this
bloom
filter
implemented
on
when
you
try
to
look
up
a
path
name
on
the
current
cd
right,
so
I
think
they
populate
it
once
they
have
it.
So
they
use
that
to
surely
say
if
it's
a
you
know
enter.
So
this
is
where
they
do.
This
check.
B
Okay,
so
it's
it's
it's
in
the
seated
data
structure,
yeah,
yeah
and
and
its
purpose
is
to
find
if
the
path
definitely
does
not.
A
C
Well,
it's
an
optimization,
I
think
so
I
mean
you
don't
have
to
you.
You
do
the
underlying
check.
Only
if
bloom
filter
gives
you
know
says
that
you
know
either
the
file
is
there.
So
it's
an
optimization
case
where,
if
the,
if
the
underlying
object,
you're
trying
to
find
doesn't
exist,
so
bloomfield
says
it's
not
there,
so
you
can
trust
it.
Otherwise,
if
it
says
it
it's
there,
it's
like
you
need
to
double
check,
go
and
walk
a
structure
or
something
like
that.
B
A
I
did
not
dig
very
deep
into
it,
but
a
few
of
the
data
structures
a
few
of
the
objects
right.
If
you
check
the
definition
of
that
it's
inherited
from
the
lru,
there
is
a
base
lru
class
from
that
it
is
needed
to
inherit
it.
Let's
check
that,
so
this.
A
A
Okay,
I
think
yeah
thanks
for
your
time,
guys,
yeah
thanks,
bye,.