Dropbox fs.inotify error [closed]

Question

I frequently get the following Dropbox error. The error message's proposal fixes the error, but I'm trying to figure out what it's doing to my system, and perhaps if there is a root cause at play.

Unable to monitor entire Dropbox folder hierarchy. Please run

echo fs.inotify.max_user_watches=100000 | sudo tee -a /etc/sysctl.conf; sudo sysctl -p` 

and restart Dropbox to fix the problem.

Answer 1

Note: I strongly encourage you to actually DO the steps and not just read them if you want to learn about Linux!

---

If I type apropos inotify in a shell to see which manpage are about "inotify" I get these results:

$ apropos inotify
inotify (7)          - monitoring filesystem events
inotify_add_watch (2) - add a watch to an initialized inotify instance
inotify_init (2)     - initialize an inotify instance
inotify_init1 (2)    - initialize an inotify instance
inotify_rm_watch (2) - remove an existing watch from an inotify instance
upstart-file-bridge (8) - Bridge between Upstart and inotify

apropos finds manpages. apropos is your friend. Remember apropos.

The first one looks promising, so lets try opening that with man inotify. You should now get the documentation of ifnotify. It says:

NAME
    inotify - monitoring filesystem events

DESCRIPTION
    The  inotify API provides a mechanism for monitoring filesystem events.
    Inotify can be used to monitor individual files, or to monitor directo‐
    ries.   When  a  directory is monitored, inotify will return events for
    the directory itself, and for files inside the directory.

So now we've learned what inotify roughly does. Let's see if it also has something useful to say about your error.

We can search in manpages by pressing /<term><enter>. So lets try: /max_user_watches<enter> That brings us to this section:

   /proc/sys/fs/inotify/max_user_watches
          This specifies an upper limit on the number of watches that  can
          be created per real user ID.

The /proc/sys/fs/inotify/max_user_watches file is the same as the fs.inotify.max_user_watches setting in /etc/sysctl.conf. They're just two different ways to access the same Linux kernel parameter.

You can press q to exit.

I can see what the current value is by using:

$ cat /proc/sys/fs/inotify/max_user_watches
524288

or:

$ sysctl fs.inotify.max_user_watches
fs.inotify.max_user_watches = 524288

They both use the same underlying value in the Linux kernel.

Note that this value is actually five times larger than what Dropbox recommends! This is on my Ubuntu 15.10 system.

So now we have learned that:

1. inotify is a Linux system to monitor changes to files and directories.
2. That we can set how many files or directories a user is allowed to watch simultaneously.
3. That Dropbox gives the error "Unable to monitor entire Dropbox folder hierarchy".

From this information, It seems to be the case that Dropbox is unable to watch enough files and directories for changes because the fs.inotify.max_user_watches is too low.

What I recommend is:

1. Check the /etc/sysctl.conf with any text editor as root. Make sure there are no fs.inotify.max_user_watches=100000 lines here. If there are, remove them.
2. Reboot the system to restore the default value.
3. Check what the value of fs.inotify.max_user_watches is as described above.
4. Double that by running sudo echo 'fs.inotify.max_user_watches=XXX' >> /etc/sysctl.conf && sudo sysctl -p /etc/sysctl.conf. You don't need to reboot after this change.
5. Hope this error is now fixed. Time will tell. If not, try doubling the value again.
   • If that doesn't fix it, there may be another problem, or maybe you just need to increase it even more. It depends a bit on what the default value is for your system.

Note: Newer versions of systemd no longer load the /etc/sysctl.conf file, it will only load files from the /etc/sysctl.d/ directory. Using a file in the /etc/sysctl.d directory should already be supported by most Linux distros, so I recommend you use that for future-proofing.

---

If you're wondering "why is there a limit in the first place?" then consider what would happen if a program would watch a million files. Would that still work? And what about a billion? 10 billion? 10 trillion? etc.

At some point, your system will run out of resources and crash. See here on some "fun" ways to do that ;-)