diff --git a/runtime/internal/rpc/reserved.go b/runtime/internal/rpc/reserved.go
index 2f63127..c82aaa0 100644
--- a/runtime/internal/rpc/reserved.go
+++ b/runtime/internal/rpc/reserved.go
@@ -278,65 +278,14 @@
 			}
 			continue
 		}
+		if gs.AllGlobberX != nil {
+			gs.AllGlobber = gs.AllGlobberX
+		}
+		if gs.ChildrenGlobberX != nil {
+			gs.ChildrenGlobber = gs.ChildrenGlobberX
+		}
 		if gs.AllGlobber != nil {
 			ctx.VI(3).Infof("rpc Glob: %q implements AllGlobber", suffix)
-			ch, err := gs.AllGlobber.Glob__(ctx, subcall, state.glob.String())
-			if err != nil {
-				ctx.VI(3).Infof("rpc Glob: %q.Glob(%q) failed: %v", suffix, state.glob, err)
-				subcall.Send(naming.GlobReplyError{naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrInternal, ctx, err)}})
-				continue
-			}
-			if ch == nil {
-				continue
-			}
-			for gr := range ch {
-				switch v := gr.(type) {
-				case naming.GlobReplyEntry:
-					v.Value.Name = naming.Join(state.name, v.Value.Name)
-					subcall.Send(v)
-				case naming.GlobReplyError:
-					v.Value.Name = naming.Join(state.name, v.Value.Name)
-					subcall.Send(v)
-				}
-			}
-			continue
-		}
-		if gs.ChildrenGlobber != nil {
-			ctx.VI(3).Infof("rpc Glob: %q implements ChildrenGlobber", suffix)
-			children, err := gs.ChildrenGlobber.GlobChildren__(ctx, subcall)
-			// The requested object doesn't exist.
-			if err != nil {
-				subcall.Send(naming.GlobReplyError{naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrInternal, ctx, err)}})
-				continue
-			}
-			// The glob pattern matches the current object.
-			if state.glob.Len() == 0 {
-				subcall.Send(naming.GlobReplyEntry{naming.MountEntry{Name: state.name}})
-			}
-			// The current object has no children.
-			if children == nil {
-				continue
-			}
-			depth := state.depth
-			// This is a recursive pattern. Make sure we don't recurse forever.
-			if state.glob.Len() == 0 {
-				depth++
-			}
-			matcher, left := state.glob.Head(), state.glob.Tail()
-			for child := range children {
-				if len(child) == 0 || strings.Contains(child, "/") {
-					ctx.Errorf("rpc Glob: %q.GlobChildren__() sent an invalid child name: %q", suffix, child)
-					continue
-				}
-				if matcher.Match(child) {
-					next := naming.Join(state.name, child)
-					queue = append(queue, gState{next, left, depth})
-				}
-			}
-			continue
-		}
-		if gs.AllGlobberX != nil {
-			ctx.VI(3).Infof("rpc Glob: %q implements AllGlobberX", suffix)
 			send := func(reply naming.GlobReply) error {
 				select {
 				case <-ctx.Done():
@@ -353,14 +302,14 @@
 				}
 				return nil
 			}
-			if err := gs.AllGlobberX.Glob__(ctx, &globServerCall{subcall, send}, state.glob); err != nil {
+			if err := gs.AllGlobber.Glob__(ctx, &globServerCall{subcall, send}, state.glob); err != nil {
 				ctx.VI(3).Infof("rpc Glob: %q.Glob(%q) failed: %v", suffix, state.glob, err)
 				subcall.Send(naming.GlobReplyError{naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrInternal, ctx, err)}})
 			}
 			continue
 		}
-		if gs.ChildrenGlobberX != nil {
-			ctx.VI(3).Infof("rpc Glob: %q implements ChildrenGlobberX", suffix)
+		if gs.ChildrenGlobber != nil {
+			ctx.VI(3).Infof("rpc Glob: %q implements ChildrenGlobber", suffix)
 			depth := state.depth
 			if state.glob.Len() == 0 {
 				// The glob pattern matches the current object.
@@ -397,7 +346,7 @@
 				}
 				return nil
 			}
-			if err := gs.ChildrenGlobberX.GlobChildren__(ctx, &globChildrenServerCall{subcall, send}, matcher); err != nil {
+			if err := gs.ChildrenGlobber.GlobChildren__(ctx, &globChildrenServerCall{subcall, send}, matcher); err != nil {
 				subcall.Send(naming.GlobReplyError{naming.GlobError{Name: state.name, Error: verror.Convert(verror.ErrInternal, ctx, err)}})
 			}
 			continue
diff --git a/runtime/internal/rpc/test/glob_test.go b/runtime/internal/rpc/test/glob_test.go
index d16e4bd..a60f0d4 100644
--- a/runtime/internal/rpc/test/glob_test.go
+++ b/runtime/internal/rpc/test/glob_test.go
@@ -35,7 +35,6 @@
 		"a/b/c2/d1",
 		"a/b/c2/d2",
 		"a/x/y/z",
-		"a/X/y/z",
 		"leaf",
 	}
 	tree := newNode()
@@ -63,9 +62,6 @@
 		{"", "...", []string{
 			"",
 			"a",
-			"a/X",
-			"a/X/y",
-			"a/X/y/z",
 			"a/b",
 			"a/b/c1",
 			"a/b/c1/d1",
@@ -80,9 +76,6 @@
 		}, nil},
 		{"a", "...", []string{
 			"",
-			"X",
-			"X/y",
-			"X/y/z",
 			"b",
 			"b/c1",
 			"b/c1/d1",
@@ -123,15 +116,10 @@
 		{"a/x/y/z", "...", []string{
 			"",
 		}, nil},
-		{"a/X", "...", []string{
-			"",
-			"y",
-			"y/z",
-		}, nil},
 		{"", "", []string{""}, nil},
 		{"", "*", []string{"a", "leaf"}, nil},
 		{"a", "", []string{""}, nil},
-		{"a", "*", []string{"X", "b", "x"}, nil},
+		{"a", "*", []string{"b", "x"}, nil},
 		{"a/b", "", []string{""}, nil},
 		{"a/b", "*", []string{"c1", "c2"}, nil},
 		{"a/b/c1", "", []string{""}, nil},
@@ -143,8 +131,8 @@
 		{"a/b/c2/d1", "*", []string{}, nil},
 		{"a/b/c2/d1", "", []string{""}, nil},
 		{"a", "*/c?", []string{"b/c1", "b/c2"}, nil},
-		{"a", "*/*", []string{"X/y", "b/c1", "b/c2", "x/y"}, nil},
-		{"a", "*/*/*", []string{"X/y/z", "b/c1/d1", "b/c1/d2", "b/c2/d1", "b/c2/d2", "x/y/z"}, nil},
+		{"a", "*/*", []string{"b/c1", "b/c2", "x/y"}, nil},
+		{"a", "*/*/*", []string{"b/c1/d1", "b/c1/d2", "b/c2/d1", "b/c2/d2", "x/y/z"}, nil},
 		{"a/x", "*/*", []string{"y/z"}, nil},
 		{"bad", "", []string{}, []naming.GlobError{{Name: "", Error: noExist}}},
 		{"bad/foo", "", []string{}, []naming.GlobError{{Name: "", Error: noExist}}},
@@ -266,13 +254,12 @@
 	tree *node
 }
 
-func (d *disp) Lookup(_ *context.T, suffix string) (interface{}, security.Authorizer, error) {
+func (d *disp) Lookup(ctx *context.T, suffix string) (interface{}, security.Authorizer, error) {
 	elems := strings.Split(suffix, "/")
 	var auth security.Authorizer
 	for _, e := range elems {
 		if e == "deny" {
-			auth = &denyAllAuthorizer{}
-			break
+			return &leafObject{}, &denyAllAuthorizer{}, nil
 		}
 	}
 	if len(elems) != 0 && elems[0] == "muah" {
@@ -281,18 +268,16 @@
 
 	}
 	if len(elems) != 0 && elems[len(elems)-1] == "leaf" {
-		return leafObject{}, auth, nil
+		return &leafObject{}, auth, nil
+	}
+	n := d.tree.find(elems, false)
+	if n == nil {
+		return nil, nil, verror.New(verror.ErrNoExist, ctx, suffix)
 	}
 	if len(elems) < 2 || (elems[0] == "a" && elems[1] == "x") {
-		return &vChildrenObject{d.tree, elems}, auth, nil
+		return &vChildrenObject{n}, auth, nil
 	}
-	if len(elems) < 2 || (elems[0] == "a" && elems[1] == "X") {
-		return &vChildrenXObject{d.tree, elems}, auth, nil
-	}
-	if len(elems) >= 3 && elems[0] == "a" && elems[1] == "b" && elems[2] == "c2" {
-		return &globXObject{d.tree, elems}, auth, nil
-	}
-	return &globObject{d.tree, elems}, auth, nil
+	return &globObject{n}, auth, nil
 }
 
 type denyAllAuthorizer struct{}
@@ -302,75 +287,15 @@
 }
 
 type globObject struct {
-	n      *node
-	suffix []string
+	n *node
 }
 
-func (o *globObject) Glob__(ctx *context.T, _ rpc.ServerCall, pattern string) (<-chan naming.GlobReply, error) {
-	g, err := glob.Parse(pattern)
-	if err != nil {
-		return nil, err
-	}
-	n := o.n.find(o.suffix, false)
-	if n == nil {
-		return nil, verror.New(verror.ErrNoExist, ctx, o.suffix)
-	}
-	ch := make(chan naming.GlobReply)
-	go func() {
-		o.globLoop(ch, "", g, n)
-		close(ch)
-	}()
-	return ch, nil
-}
-
-func (o *globObject) globLoop(ch chan<- naming.GlobReply, name string, g *glob.Glob, n *node) {
-	if g.Len() == 0 {
-		ch <- naming.GlobReplyEntry{naming.MountEntry{Name: name}}
-	}
-	if g.Empty() {
-		return
-	}
-	matcher, left := g.Head(), g.Tail()
-	for leaf, child := range n.children {
-		if matcher.Match(leaf) {
-			o.globLoop(ch, naming.Join(name, leaf), left, child)
-		}
-	}
-}
-
-type vChildrenObject struct {
-	n      *node
-	suffix []string
-}
-
-func (o *vChildrenObject) GlobChildren__(ctx *context.T, _ rpc.ServerCall) (<-chan string, error) {
-	n := o.n.find(o.suffix, false)
-	if n == nil {
-		return nil, verror.New(verror.ErrNoExist, ctx, o.suffix)
-	}
-	ch := make(chan string, len(n.children))
-	for child, _ := range n.children {
-		ch <- child
-	}
-	close(ch)
-	return ch, nil
-}
-
-type globXObject struct {
-	n      *node
-	suffix []string
-}
-
-func (o *globXObject) Glob__(ctx *context.T, call rpc.GlobServerCall, g *glob.Glob) error {
-	n := o.n.find(o.suffix, false)
-	if n == nil {
-		return verror.New(verror.ErrNoExist, ctx, o.suffix)
-	}
-	o.globLoop(call, "", g, n)
+func (o *globObject) Glob__(ctx *context.T, call rpc.GlobServerCall, g *glob.Glob) error {
+	o.globLoop(call, "", g, o.n)
 	return nil
 }
 
-func (o *globXObject) globLoop(call rpc.GlobServerCall, name string, g *glob.Glob, n *node) {
+func (o *globObject) globLoop(call rpc.GlobServerCall, name string, g *glob.Glob, n *node) {
 	if g.Len() == 0 {
 		call.SendStream().Send(naming.GlobReplyEntry{naming.MountEntry{Name: name}})
 	}
@@ -385,18 +310,13 @@
 	}
 }
 
-type vChildrenXObject struct {
-	n      *node
-	suffix []string
+type vChildrenObject struct {
+	n *node
 }
 
-func (o *vChildrenXObject) GlobChildren__(ctx *context.T, call rpc.GlobChildrenServerCall, m *glob.Element) error {
-	n := o.n.find(o.suffix, false)
-	if n == nil {
-		return verror.New(verror.ErrNoExist, ctx, o.suffix)
-	}
+func (o *vChildrenObject) GlobChildren__(ctx *context.T, call rpc.GlobChildrenServerCall, m *glob.Element) error {
 	sender := call.SendStream()
-	for child, _ := range n.children {
+	for child, _ := range o.n.children {
 		if m.Match(child) {
 			sender.Send(naming.GlobChildrenReplyName{child})
 		}
@@ -438,6 +358,6 @@
 
 type leafObject struct{}
 
-func (l leafObject) Func(*context.T, rpc.ServerCall) error {
+func (leafObject) Func(*context.T, rpc.ServerCall) error {
 	return nil
 }
diff --git a/services/binary/tidy/binaryd/mock.go b/services/binary/tidy/binaryd/mock.go
index 5e9daf0..a9c1db0 100644
--- a/services/binary/tidy/binaryd/mock.go
+++ b/services/binary/tidy/binaryd/mock.go
@@ -9,6 +9,7 @@
 	"testing"
 
 	"v.io/v23/context"
+	"v.io/v23/glob"
 	"v.io/v23/naming"
 	"v.io/v23/rpc"
 	"v.io/v23/security"
@@ -69,15 +70,13 @@
 	Err     error
 }
 
-func (mdi *MockBinarydInvoker) Glob__(p *context.T, _ rpc.ServerCall, pattern string) (<-chan naming.GlobReply, error) {
-	gs := GlobStimulus{pattern}
+func (mdi *MockBinarydInvoker) Glob__(p *context.T, call rpc.GlobServerCall, g *glob.Glob) error {
+	gs := GlobStimulus{g.String()}
 	gr := mdi.Tape.Record(gs).(GlobResponse)
-	ch := make(chan naming.GlobReply, len(gr.Results))
-	defer close(ch)
 	for _, r := range gr.Results {
-		ch <- naming.GlobReplyEntry{naming.MountEntry{Name: r}}
+		call.SendStream().Send(naming.GlobReplyEntry{naming.MountEntry{Name: r}})
 	}
-	return ch, gr.Err
+	return gr.Err
 }
 
 type dispatcher struct {