I'm nested deep in a file tree, and I'd like to find which parent directory contains a file.

E.g. I'm in a set of nested GIT repositories and want to find the .git directory controlling the files I'm currently at. I'd hope for something like

find -searchup -iname ".git"
  • 2
    I wish this was build in!
    – rds
    Commented Jan 1, 2021 at 11:00

12 Answers 12

git rev-parse --show-toplevel

will print out the top level directory of the current repository, if you are in one.

Other related options:

# `pwd` is inside a git-controlled repository
git rev-parse --is-inside-work-tree
# `pwd` is inside the .git directory
git rev-parse --is-inside-git-dir

# path to the .git directory (may be relative or absolute)
git rev-parse --git-dir

# inverses of each other:
# `pwd` relative to root of repository
git rev-parse --show-prefix
# root of repository relative to `pwd`
git rev-parse --show-cdup
  • 11
    This works only for git itself. The question is more generic.
    – alex
    Commented Jan 26, 2011 at 7:15
  • 1
    This will not work in a bare repo, Commented Sep 1, 2014 at 4:01
  • 1
    thanks great way to find file at root of git repo.e.g. user_file_path=$(realpath $(git rev-parse --show-toplevel)/$user_file)
    – Pieter
    Commented Dec 16, 2020 at 22:08

A generalized version of Gilles' answer, first parameter used to find match:

find-up () {
  while [[ "$path" != "" && ! -e "$path/$1" ]]; do
  echo "$path"

Keeps the use of sym-links.


An even more general version that allows using find options:

set -e
shift 1
while [[ $path != / ]];
    find "$path" -maxdepth 1 -mindepth 1 "$@"
    # Note: if you want to ignore symlinks, use "$(realpath -s "$path"/..)"
    path="$(readlink -f "$path"/..)"

For example (assuming the script is saved as find_up.sh)

find_up.sh some_dir -iname "foo*bar" -execdir pwd \;

...will print the names of all of some_dir's ancestors (including itself) up to / in which a file with the pattern is found.

When using readlink -f the above script will follow symlinks on the way up, as noted in the comments. You can use realpath -s instead, if you want to follow paths up by name ("/foo/bar" will go up to "foo" even if "bar" is a symlink) - however that requires installing realpath which isn't installed by default on most platforms.

  • the trouble with these is the way it resolves links. for example if i'm in ~/foo/bar , and bar is a symlink to /some/other/place, then ~/foo and ~/ will never be searched. Commented Jun 5, 2015 at 13:07
  • @ErikAronesty, you're right - updated the answer. You can use realpath -s to get the behaviour you want.
    – sinelaw
    Commented Jun 6, 2015 at 20:53
  • that works when you specify a full path to search. sadly, on centos 5.8, realpath -s <dir> has a bug where if <dir> is relative, then it resolves symlinks anyway... despite it's documentation. Commented Jun 8, 2015 at 20:17
  • readlink is not part of the standard. A portable script could be implemented with only POSIX shell features.
    – schily
    Commented Oct 24, 2018 at 14:22
  • 1
    FYI, this doesn't work in zsh because it redefines $path so the shell can't find find or readlink. I suggest changing it to something like $curpath instead so it doesn't shadow the shell variable.
    – Skyler
    Commented Apr 12, 2019 at 16:03

If you're using zsh with extended globbing enabled, you can do it with a oneliner:

(../)#.git(:h)   # relative path to containing directory, eg. '../../..', '.'
(../)#.git(:a)   # absolute path to actual file, eg. '/home/you/src/prj1/.git'
(../)#.git(:a:h) # absolute path to containing directory, eg. '/home/you/src/prj1'

Explanation (quoted from man zshexpn):

Recursive Globbing

A pathname component of the form (foo/)# matches a path consisting of zero or more directories matching the pattern foo. As a shorthand, **/ is equivalent to (*/)#.


After the optional word designator, you can add a sequence of one or more of the following modifiers, each preceded by a ':'. These modifiers also work on the result of filename generation and parameter expansion, except where noted.

  • a
    • Turn a file name into an absolute path: prepends the current directory, if necessary, and resolves any use of '..' and '.'
  • A
    • As 'a', but also resolve use of symbolic links where possible. Note that resolution of '..' occurs before resolution of symbolic links. This call is equivalent to a unless your system has the realpath system call (modern systems do).
  • h
    • Remove a trailing pathname component, leaving the head. This works like 'dirname'.

Credits: Faux on #zsh for the initial suggestion of using (../)#.git(:h).

  • This is amazing... If I could only figure out (hint: you should tell me) what (../) is doing... Oh, and who/what is Faux on #zsh?
    – alex gray
    Commented Mar 20, 2015 at 15:05
  • 1
    @alexgray (../) alone doesn't mean much, but (../)# means try to expand the pattern inside the parenthesis 0 or more times, and only use the ones that actually exist on the filesystem. Because we're expanding from 0 to n parent directories, we effectively search upwards to the root of the file system (note: you probably want to add something after the pattern to make it meaningful, but for enlightenment execute print -l (../)#). And #zsh is an IRC channel, Faux is a username on it. Faux suggested the solution, therefore the credit.
    – unthought
    Commented Mar 22, 2015 at 11:03
  • 2
    That will expand all of them. You may want: (../)#.git(/Y1:a:h) to stop at the first found one (with a recent version of zsh) Commented Jun 8, 2015 at 20:43
  • 4
    Very helpful, thanks. To enable extended globbing do setopt extended_glob
    – Shlomi
    Commented Sep 24, 2015 at 8:40

Find can't do it. I can't think of anything simpler than a shell loop. (Untested, assumes there is no /.git)

git_root=$(pwd -P 2>/dev/null || command pwd)
while [ ! -e "$git_root/.git" ]; do
  if [ "$git_root" = "" ]; then break; fi

For the specific case of a git repository, you can let git do the work for you.

git_root=$(GIT_EDITOR=echo git config -e)
  • 1
    Cool, this puts me on a path for a general solution - which I post as another answer here. Commented Oct 7, 2011 at 0:56

Recursion can result in a quite concise solution.

#!/usr/bin/env bash

parent-find() {
  local file="$1"
  local dir="$2"

  test -e "$dir/$file" && echo "$dir" && return 0
  [ '/' = "$dir" ] && return 1

  parent-find "$file" "$(dirname "$dir")"

# Example
parent-find .bashrc "/home/user/projects/parent-find" 
# should respond with "/home/user"
  • This is actually really good! Thanks
    – Tek
    Commented Jul 13, 2021 at 5:59
  • 1
    Similar trick: local file="$1?Usage $0 <target> [start-directory]" will bomb out without at least one arg with a hint to the user. Commented Jan 13, 2022 at 14:20
  • 1
    @DanGarthwaite, I did not know that was possible. Thanks for sharing that!
    – bas080
    Commented Jan 15, 2022 at 12:32
  • 1
    I noticed $0 doesn't work right in a function. So instead use the function name. Commented Jan 16, 2022 at 17:02
  • 1
    This doesn't work when the directory to be searched is . Commented Aug 24, 2023 at 12:02


Since there's a zsh one-liner here's a more general unix oneish-liner to search the 3 parent directories:

$ name=fileOrDirName
$ eval find ./$(printf "{$(echo %{1..4}q,)}" | sed 's/ /\.\.\//g')/ -maxdepth 1 -name $name


I'll admit it's not the prettiest command, but it's one line. To search 4 directories up replace echo %{1..4}q, with echo %{1..5}q,. Specify the file or directory's name with the name variable.

In short $(printf ... | sed ...) is substituted for its output using command substitution which is then expanded with find using brace expansion. Broken into two commands it looks like this (with a copy and paste in the middle):

$ printf "{$(echo %{1..4}q,)}" | sed 's/ /\.\.\//g'
$ #copy and paste the output

$ find ./{'',../'',../../'',../../../'',} -maxdepth 1 -name $name

You can learn more about shell expansions with man bash or in the resources below on the gnu website


This version of findup supports "find" syntax, like @sinelaw's answer, but also support symlinks without needing realpath. It also supports an optional "stop at" feature, so this works: findup .:~ -name foo ... searches for foo without passing the home dir.


set -e

# get optional root dir
IFS=":" && arg=($1)
shift 1
[[ $root ]] || root=/
# resolve home dir
eval root=$root

# use "cd" to prevent symlinks from resolving
cd $path
while [[ "$cur" != "$root" && "$cur" != "/" ]];
    find  "$cur/"  -maxdepth 1 -mindepth 1 "$@"
    cd ..

Vincent Scheib's solution doesn't work for files that reside in the root directory.

The following version does, and also lets you pass the starting dir as the 1st argument.

find-up() {
    path="$(realpath -s "$1")"

    while ! [ -e "$path"/"$2" ] && [ -n "$path" ]; do

    [ -e "$path"/"$2" ] && echo "$path"/"$2"

Here's my one-liner tested only on bash. It stops before it looks in the root though, so you'd have to look there manually. But hey, it's rare to put files in the root, right?

until [ $p == "/" ]; do
    if [ -f "$p/$f" ]; then
        echo $f is in $p;
    p=$(dirname $p);
  • Note that you need dirname "$p" with quotes for the same reasons you have quotes in [ -f "$p/$f" ]. You could also just do while true; do ... if [ "$p" = / ]; then break; fi; done to test the condition in the end. (Also that's rather too complex for one line, esp. since you have to scroll horizontally to view it.)
    – ilkkachu
    Commented Oct 28, 2022 at 16:57

I've found that working with symlinks kill some of the other options. Especially the git specific answers. I've halfway created my own favorite out of this original answer that's pretty effecient.

#!/usr/bin/env bash

# usage: upsearch .git

function upsearch () {
    test / == "$PWD" && cd "$origdir" && return || \
    test -e "$1" && echo "$PWD" && cd "$origdir" && return || \
    cd .. && upsearch "$1" "$origdir"

I'm using symlinks for my go projects because go wants source code in a certain location and I like to keep my projects under ~/projects. I create the project in $GOPATH/src and symlink them to ~/projects. So running git rev-parse --show-toplevel prints out the $GOPATH directory, not the ~/projects directory. This solution solves that problem.

I realize this is a very specific situation, but I think the solution is valuable.


I modified sinelaw's solution to be POSIX. It doesn't follow symlinks and includes searching the root directory by using a do while loop.

#!/usr/bin/env sh

set -e # exit on error
# Use cd and pwd to not follow symlinks.
# Unlike find, default to current directory if no arguments given.
directory="$(cd "${1:-.}"; pwd)"

shift 1 # shift off the first argument, so only options remain

while :; do
  # POSIX, but gets "Permission denied" on private directories.
  # Use || true to allow errors without exiting on error.
  find "$directory" -path "${directory%/}/*/*" -prune -o ! -path "$directory" "$@" -print || true

  # Equivalent, but -mindepth and -maxdepth aren't POSIX.
  # find "$directory" -mindepth 1 -maxdepth 1 "$@"

  if [ "$directory" = '/' ]; then
    break # End do while loop
    directory=$(dirname "$directory")

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .