106
$ git ls-tree fb3a8bdd0ce
100644 blob 63c918c667fa005ff12ad89437f2fdc80926e21c    .gitignore
100644 blob 5529b198e8d14decbe4ad99db3f7fb632de0439d    .mailmap
100644 blob 6ff87c4664981e4397625791c8ea3bbb5f2279a3    COPYING
040000 tree 2fb783e477100ce076f6bf57e4a6f026013dc745    Documentation
100755 blob 3c0032cec592a765692234f1cba47dfdcc3a9200    GIT-VERSION-GEN
100644 blob 289b046a443c0647624607d471289b2c7dcd470b    INSTALL
100644 blob 4eb463797adc693dc168b926b6932ff53f17d0b1    Makefile
100644 blob 548142c327a6790ff8821d67c2ee1eff7a656b52    README
...

I know the last 3 oct digits are file mode, but what are the first 3 digits for? I can't find it out in git user's manual.

hjpotter92
  • 71,576
  • 32
  • 131
  • 164
an0
  • 16,371
  • 11
  • 78
  • 132
  • 2
    Git is so broken... Try resetting permissions with something like a `chmod 0100755 ` to make Git happy. Or even more funny, git chmod ` because of Git's file modes (it does not exist)... Also see questions like [How do I remove files saying “old mode 100755 new mode 100644” from unstaged changes in Git?](http://stackoverflow.com/q/1257592/608639), [How to recover the file permissions to what git “thinks” the file should be?](http://stackoverflow.com/q/2517339). This tool is such a broken joke... – jww Dec 10 '16 at 04:08

2 Answers2

140

From the Git index-format.txt file, regarding the mode:

32-bit mode, split into (high to low bits)

    4-bit object type
      valid values in binary are 1000 (regular file), 1010 (symbolic link)
      and 1110 (gitlink)

    3-bit unused

    9-bit unix permission. Only 0755 and 0644 are valid for regular files.
    Symbolic links and gitlinks have value 0 in this field.

Also, a directory object type (binary 0100) and group-writeable (0664 permissions) regular file are allowed as indicated by the fsck.c fsck_tree method. The regular non-executable group-writeable file is a non-standard mode that was supported in earlier versions of Git.

This makes valid modes (as binary and octal):

  • 0100000000000000 (040000): Directory
  • 1000000110100100 (100644): Regular non-executable file
  • 1000000110110100 (100664): Regular non-executable group-writeable file
  • 1000000111101101 (100755): Regular executable file
  • 1010000000000000 (120000): Symbolic link
  • 1110000000000000 (160000): Gitlink
Dan Cruz
  • 14,336
  • 6
  • 39
  • 64
  • Weird... I just committed some `644` files in git and the commit message said they were created in the repo as `664` – MestreLion Dec 20 '12 at 07:50
  • 2
    The directory mode is not valid because it will never happen. Git doesn't track directories, because directories in Git exist only implicitly with un-*ignored* content. – nemesis Mar 24 '14 at 16:21
  • 2
    @nemesis Git indeed uses the directory (`040000`) mode to represent directories. Please see the linked `fsck.c` code, or just execute `git ls-tree HEAD` in a Git repository that contains directories. – Dan Cruz Mar 24 '14 at 17:53
  • Ok, my bad. I now see that you are talking about ls-tree which shows the files modes. I was thinking about the mode which shows up when you commit files (and directories don't really get committed). Sorry. – nemesis Mar 25 '14 at 07:45
  • 1
    Why is the group write permission kept, but not most other permissions? Is there an important use case? – Ciro Santilli新疆棉花TRUMP BAN BAD Aug 22 '14 at 08:30
  • 3
    @CiroSantilli巴拿馬文件六四事件法轮功: group write permission isn't actually *kept*. It's just that the `fsck` code won't claim that a tree entry with that mode is *bad*. The idea was to leave room for group permissions on files, if it turned out to be needed. It was never needed, hence never added, but the testing code was never changed to forbid it either. – torek Jul 23 '16 at 00:16
  • 2
    @Dan Cruz If there are only 16 base-2 digits, why they write 32-bit mode? – Sevastyan Savanyuk Aug 21 '18 at 04:25
  • 2
    @Sevastyan Git reserves 16 bits for internal usage; see [cache.h](https://github.com/git/git/blob/7e8bfb0412581daf8f3c89909f1d37844e8610dd/cache.h#L85). – Dan Cruz Aug 21 '18 at 18:10
  • 2
    Slight correction to my previous comment: at one point Git really *did* record group-write permission, and apparently there are some repositories that have `mode 100664` tree entries, so `git fsck` permits them to avoid claiming that these very old repositories are bad. But storing group-write turned out not to work well and the code was modified to stop doing so. – torek Jan 19 '19 at 03:51
63

The 6 digits show the file mode using the classical UNIX notations. First two digits show file type, the third one is about set-uid/set-gid/sticky bits, and you know the last three.

Here is how man 2 stat documents it on my GNU/Linux system:

   The following flags are defined for the st_mode field:

       S_IFMT     0170000   bit mask for the file type bit fields
       S_IFSOCK   0140000   socket
       S_IFLNK    0120000   symbolic link
       S_IFREG    0100000   regular file
       S_IFBLK    0060000   block device
       S_IFDIR    0040000   directory
       S_IFCHR    0020000   character device
       S_IFIFO    0010000   FIFO
       S_ISUID    0004000   set UID bit
       S_ISGID    0002000   set-group-ID bit (see below)
       S_ISVTX    0001000   sticky bit (see below)
       S_IRWXU    00700     mask for file owner permissions
       S_IRUSR    00400     owner has read permission
       S_IWUSR    00200     owner has write permission
       S_IXUSR    00100     owner has execute permission
       S_IRWXG    00070     mask for group permissions
       S_IRGRP    00040     group has read permission
       S_IWGRP    00020     group has write permission
       S_IXGRP    00010     group has execute permission
       S_IRWXO    00007     mask for permissions for others (not in group)
       S_IROTH    00004     others have read permission           
       S_IWOTH    00002     others have write permission
       S_IXOTH    00001     others have execute permission
gawi
  • 13,050
  • 7
  • 38
  • 74
adl
  • 14,456
  • 6
  • 45
  • 62