git index.lock File exists when I try to commit, but cannot delete the file

When I do 'git commit', I'm getting the following:

fatal: Unable to create 'project_path/.git/index.lock': File exists.

However, when I do ls project_path/.git/index.lock it's saying the file doesn't exist. Any thoughts on what I should do? I've also noticed that project_path/.git is owned by root, not sure if that has anything to do with the problem I'm encountering.

git version is 1.7.5.4

edit: It seems that the problem most likely was another process I had running, that was writing (unbeknownst to me) to the project directory. I restarted my machine and then I had no problem committing.

This may be an old reply but I'm hoping this is more useful on next who need this solution.

On linux/unix/gitbash/cygwin, try

rm -f .git/index.lock

On Windows Command Prompt, try:

del .git\index.lock

For Windows:

• From a powershell console opened as admin, try

> > rm -Force ./.git/index.lock

• If that does not work, you must kill all git.exe processes

> > taskkill /F /IM git.exe > SUCCESS: The process "git.exe" with PID 20448 has been terminated. > SUCCESS: The process "git.exe" with PID 11312 has been terminated. > SUCCESS: The process "git.exe" with PID 23868 has been terminated. > SUCCESS: The process "git.exe" with PID 27496 has been terminated. > SUCCESS: The process "git.exe" with PID 33480 has been terminated. > SUCCESS: The process "git.exe" with PID 28036 has been terminated. > > rm -Force ./.git/index.lock

On a Windows platform running Visual Studio 2015 RC (v4.6.00057) in combination with SourceTree (v1.6.14.0) will give this error as well.

Solution: Assuming you want to use source tree as source code manager, simply disable the source control provider inside Visual Studio like this:

1. Go to: Tools > Options > Source Control
2. Select Current source control plug-in as: None

try

rm -f ./.git/index.lock

if you have no other git process running, then just delete the index.lock file of the respective project.

1. check if the git still running (ps -ef | grep git)
2. if not, remove the locked file
3. if yes, kill the git process at first.

1. Close every window that is potentially affecting this .git/index.lock file
2. Delete the .git/index.lock file.
3. Open your command line editor and cd to the location of your git files.

( If the file is created, simply from cd into that location, then the problem is your editor. Close your editor. Do not use this editor again for this task. Open a different kind of editor - windows power shell or simply cmd. Now you can use git commands to continue)

Just had this issue... Gitbox was at fault. So maybe you had a GUI running that was causing problems.

This is happening when you are do cancel pulling from origin in the middle.

so what you can do is manually delete index.lock file from your .git directory.

rm -f ./.git/index.lock

cd into you project directory and run this command.

del .git\index.lock worked for me.

I was facing this issue while checkout a new branch from master branch.

Checkout easily happened after deleting the index.lock file.

Probably (it has happened to me), ls command is saying it doesn't exist because current user doesn't have permissions to reach that directory or file.

Remove the lock and make sure you are executing git with the right user in order to avoid permission problems.

If you are in a GNU/Linux box with sudo command:

> sudo rm project_path/.git/index.lock

Sometimes Git creates a lock file associated with your repo while you are making any changes or most probably when you are using sub modules. The error message will show you the path of the lock file. Fix: Just manually go to the path in terminal and delete the lock file by $ rm index.lock

It should help.

I had this problem with SourceTree when switching branch by double-click on it. The problem is not very common and Atlassian knows about it but they decided not to fix it.

Fortunately, there is a solution. Instead of double-clicking on branch you want to switch, just right click and choose "Checkout [branch name]". It should succeed now.

I have come across the very same scenario. I even haven't done any changes in my local code. I have just edited a file and revert it. I have simply deleted the below file in hidden .git folder. It worked!

> project_path/.git/index.lock

Unless you actually intended for root to own your repo, this sounds like you accidentally ran a Git command as root (maybe even the initial clone/init). If you meant to do that, then you'll have to live with running all Git commands in the repo as root. If you didn't, run sudo chown your-user[:your-group] -R .git to take ownership of it, and then see if things work.

Ran into this problem today where SourceTree had spawned several git processes that kept running even after closing SourceTree. Here is how I fixed it.

1. Press Ctrl-Alt-Esc or type "Task Manager" in windows start to start Task Manager.
2. Look for all processes named "git", "git-lfs", etc. as shown in the screenshot below. Right click and select "End process" to kill each of them.
3. Delete the .git/index.lock file.

I also have this question in windows 10.

when I try del ./.git/index.lock ,it told me cannot remove 'index.lock': Device or resource busy

I finally got the reason:

the computer have two process to use git:

• git bash
• cmder

so I use cmder.exe to git commit it will occur errors.

so the solution is use git bash or Terminate the git bash then use cmder.exe

Multiple git clients working on same local repository compete for that lock. Each client should wait until the lock is released by the other party to be a good citizen. For us, SourceTree or MSVS appear to be be doing some maintenance in the background while we were are running large commit scripts.

Perhaps 'git' itself should support a '--retriesWhenLocked 5' argument to support retries. or even default to this when run manually.

Here is a PowerShell wrapper around git named "gitr" that retries until index.lock disappears, using default 5 tries, 3 seconds between each. It never removes the index.lock, assuming user should intervene. It was extracted from a larger commit script. It only has minimal testing with simple arguments.

• Copy script to C:\bin and add C:\bin to $PATH.
• From PS1> gitr --help
• From DOS %> powershell gitr --help

gitr.ps1

	#requires -version 2
	<#
	.SYNOPSIS
		gitr
	.DESCRIPTION
		Run "git" as an external process with retry and capturing stdout stderr.
	.NOTES  
	  2017/05/16 crokusek: Initial version
	#>
	
	#---------------------------------------------------------[Initializations]--------------------------------------------------------
	
	#Set Error Action 
	$ErrorActionPreference = "Stop";
	
	#----------------------------------------------------------[Declarations]----------------------------------------------------------
	
	$scriptDir = Split-Path $script:MyInvocation.MyCommand.Path
	#Set-Location $scriptDir
	
	## Disabled logging
	# Log File 
	# $logFile = "$($scriptDir)\getr.log"
	# If (Test-Path $logFile) { Clear-Content $logFile }
	
	#-----------------------------------------------------------[Functions]------------------------------------------------------------
	
	Function Log([string]$msg, [bool]$echo = $true)
	{
		$timestamp = "$(get-date -Format 'yyyy/MM/dd HH:mm:ss'):  "	
		$fullmsg = $msg -replace '(?ms)^', $timestamp  # the (?ms) enables multiline mode

		## Disabled Logging 
		# Add-content $LogFile -value $fullmsg

		if ($echo)
		{
			Write-Host $msg
		}
	}
	
	Function ExecSimple([string]$command, [bool]$echo=$true, [bool]$stopOnNonZeroExitCode=$true)
	{
		$command, $args = $command -split " "
		return Exec $command $args $echo $stopOnNonZeroExitCode
	}
	
	Function Exec([string]$exe, [string[]]$arguments, [bool]$echo=$true, [bool]$stopOnNonZeroExitCode=$true)
	{	
		# Passing $args (list) as a single parameter is the most flexible, it supports spaces and double quotes
			
		$orgErrorActionPreference = $ErrorActionPreference 
		Try
		{			
			$error.clear()  # this apparently catches all the stderr pipe lines
	
			if ($false -and $exe -eq 'git')  # todo make this a generic flag
			{
				$exe = "$($exe) 2>&1"
			}
	
			$output = ""
	
			$argflattened = $arguments -join ' '
			Log "`n% $($exe) $($arguments)`n"
	
			# This way some advantages over Invoke-Expressions or Start-Process for some cases:
			#      - merges stdout/stderr line by line properly, 
			#      - echoes the output live as it is streamed to the current window,
			#      - waits for completion
			#      - works when calling both console and windows executables.
			#		
			$ErrorActionPreference = "Continue"  # required in order to catch more than 1 stderr line in the exception
	
			if ($echo)
			{
				# Using "cmd.exe" allows the stderr -> stdout redirection to work properly.  Otherwise the 2>&1 runs after PS for 
				# some reason.  When a command such as "git" writes to stderr, powershell was terminating on the first stderr 
				# line (and stops capturing additional lines).
				#
				# but unfortuantely cmd has some bizarre de-quoting rules that weren't working for all cases. 
				#& cmd /c "`"" $exe $arguments "`"" | Tee-Object -variable output | Write-Host | out-null			
				
				# This is simplest but has some issues with stderr/stdout (stderr caught as exception below)
				#
				& $exe $arguments 2>&1 | tee -variable output | Write-Host | out-null 
			}
			else
			{			
				& $exe $arguments 2>&1 | tee -variable output | out-null 
			}
		
			$output = $output -join "`r`n"					
	
			if ($stopOnNonZeroExitCode -and !$LASTEXITCODE -eq 0)
			{			
				throw [System.Exception] "Exit code ($($LASTEXITCODE)) was non-zero. Output:`n$($output)"
			}		
		}
		catch [System.Management.Automation.RemoteException]
		{
			$output = $_.Exception.ToString().Replace("System.Management.Automation.RemoteException:", "").Trim()
					
			if ($output.Contains("fatal")) 
			{
				throw 
			}
	
			if ($echo)
			{
				Log $output
			}
		}
		finally
		{
			$ErrorActionPreference = $orgErrorActionPreference;
		}
	
		if (-not $output -eq "")
		{
			Log $output $false  # don't echo to screen as the pipe above did	
		}
	
		return $output
	}
	
	Function ExecWithRetry([string]$exe, [string[]]$arguments, [bool]$echo=$true, [bool]$stopOnNonZeroExitCode=$true, 
						  [int]$maxRetries = 5, [int]$msDelay = 3000, [AllowNull()][string]$exceptionMustContain = $null)
	{
		for ($i = 0; $i -lt $maxRetries; $i++)
		{
			try
			{
				Exec $exe $arguments $echo $stopOnNonZeroExitCode
				return
			}
			catch
			{
				if (-not [string]::IsNullOrEmpty($exceptionMustContain) -and $_.Exception.ToString().Contains($exceptionMustContain))
				{
					Log "Last Error from $($exe) is retryable ($($i + 1) of $($maxRetries))" $true
					Start-Sleep -Milliseconds ($msDelay);
					continue
				}
	
				throw
			}
		}
	
		throw [System.Exception] "Unable to successfully exec '$($exe)' within $($maxRetries) attempts."
	}
	
	Function GitWithRetry([string[]]$arguments, [bool]$echo=$true)
	{
		ExecWithRetry "git" $arguments $echo -exceptionMustContain "Another git process seems to be running"
	}

#-----------------------------------------------------------[Main]------------------------------------------------------------

function Main([string[]]$arguments)
{	
	GitWithRetry @($arguments)
}


#-------------------------------------- Startup ------------------------------------
try 
{
	Main $args
	Exit 0
} 	 
catch
{
	#Log "*** A fatal error occured: $($_.Exception)"
	#Read-Host -Prompt "`nA fatal error occurred, press enter to close."	
	exit 1
}

Is your code in a directory that Dropbox is syncing? Try pausing Dropbox.

I kept getting the same condition, but once I paused Dropbox (the interface gives you the option to pause for 30 minutes, 1 hour, ...), it never happened again.

In My Case Simply go to project_path/.git and delete the index.lock file. try to push your code it will work.

I had this exact same error, but the issue was not the lock file. Instead the issue was that I had copied the contents of another git repo into this repo, including the .git invisible folder. So, SourceTree was confused about which repo I wanted to stage files to (there being a mismatch between the repo SourceTree thought I was in, and the one that the contents of my embedded .git dir said I should be in).

I had this problem with TortoiseGit with Cygwin on Windows. I wasn't able to delete remove ./.git/index.lock even with administrative privileges, I tried both Cygwin and command prompt, it said the file was in use by another process.

I found that I had 2 instances of TortoiseProc.exe running. I killed one of them, and closed all of my windows explorer windows, and then was able to delete the file. I don't know if killing an instance of TortoiseProc.exe was the solution or closing windows explorer windows.

The solution for me was to delete the .index file and allow Git to rebuild another.

I didn't have an inex.lock file to delete, but what worked for me was removing the Read-Only check from the Attributes window of the folder Properties dialog.

I created an empty index.lock file, deleted it using windows command

Starting git 2.8.4 (June 2016), this should not happen anymore.

See issue 755 which should also alleviate the issue (commit 2db0641):

> ## Make sure temporary file handles are not inherited by child processes > > Prevent child processes from inheriting a handle to index.lock.

In my sourceTree application i am not able to do commit or switch to any other commit/brach. That time shows error like

fatal: Unable to create blah blah blah..

I simply resolve this by goto .git folder(in project Explorer Dir). And delete the Index ----- [file type: LOCK file].Now i get back all access in sourceTree..

please make sure Index lock file.. suppose you dont get file type, change fileview settings in computer. Note: .git folder is normally hidden type of folder.

What did it for me was:

git rebase --abort and restart the rebase.

As Andrew mentioned I was also using PHPStorm when this happened. Didn't have to close it though.

First you have to navigate to the specific folder of your project.. Like if your project name is Firstproject then first go to the directory of the project.. then type cd .git then after navigating to the git folder type del index.lock After the deletion of the file index.lock..You will be able to commit and push as before

In my case there was no index.lock file to delete. I was trying to commit 109 files after formatting with prettier. Committing less files at the time is what finally "resolved" the issue.

In my case, it was windows, not shut down completely.

Windows is hibernated, refused to mount

Chances are that Windows really is hibernated. Windows does this automatically when you tell it to shutdown normally. The benefit is that you get a faster apparent start-up time.

To shutdown Windows without hybernating, issue the following at a command-prompt (in Windows):

shutdown /s

You might also want include /t 0 for immediate shutdown.

I found a nice tutorial to set up a launcher for this: How to Do a Full Shutdown in Windows 8 Without Disabling Hybrid Boot.

The simpler approach to actually shutting down Windows is to 'restart' (rather than 'shutdown'), but then intercept the boot process and boot Linux instead of letting it boot Windows.

credit: nobar

This can also happen if you're using an alternate command line git client, like hub.

I've been using hub as an aliased replacement for git for a couple of years, but recently wrote a bash script that does a bunch of git work in it, and started to get this index lock issue.

I couldn't find the fix until I remembered I was running hub instead of git. I removed that and the problem went away!

Getting the error:

Using index info to reconstruct a base tree...
Falling back to patching base and 3-way merge...
fatal: Unable to create '/home/user/project/.git/index.lock': File exists.

If no other git process is currently running, this probably means a
git process crashed in this repository earlier. Make sure no other git
process is running and remove the file manually to continue.

But I couldn't find (nor delete) that .git/index.lock file.

In my case, git-cola was running!

It obviously creates that .git/index.lock every once in a while, or caused by the rebase I was doing on the command line and during which I received that error - so git-cola obviously "disturbs" the command line run of Git (or some Git CLI operations).

This is solved by closing git-cola during a command line git rebase.

Sometimes another Git client may interfere when there are multiple installed.

Ie. make sure with the Task Manager or Get-Process that TGitCache from TortoiseGit is not active in the background.

I had the same issue recently. If you will check the whole error message it also says that there are some process that are using the git process that blocks you from deleting index.lock. You may have IDE open like Visual Studio or related software that git is integrated into. Close it and try re-stashing your file. Hope it helps.

In tasks manager :

1. develop all process
2. Kill all git process
3. Delete locked file

• The problem was solved for me by deleting the repo you are trying to commit the changes and clone the latest version from the remote(If using remote git server).
• If it's local copy the data from directory and initialize a new git repository.

For me the culprit was windows security, it was blocking git.exe from running, you can check the notifications tab on the bottom right of your screen.

The message will show like this

Virus and threat protection 
unauthorized changes blocked
controlled folder access blocked git.exe from running

If you are using Visual Studio (such as Visual Studio 2019) you can see this error occur when trying to commit changes with Git.

It can happen when you don't have a connection with Team Server. To correct it,

1. Inside Visual Studio, from the Team menu, select the command Manage Connections.
2. Look in the Solution Explorer -- you should see Team Explorer - Connect.
3. Connect to the project you are working on by clicking it in the tree listed. (This step works if you have previously worked on the project.)
4. Once connected, try your commit again.

i did

1. removed project.git\index file manually
2. in terminal git reset
3. synup project

If you are using GIT BASH For Windows :-

Run these two commands

1. cd .git
2. rm index.lock