Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Nondescriptive "bad address" error #303

Closed
md-5 opened this issue Aug 22, 2015 · 35 comments
Closed

Nondescriptive "bad address" error #303

md-5 opened this issue Aug 22, 2015 · 35 comments
Assignees

Comments

@md-5
Copy link

md-5 commented Aug 22, 2015

Using both the 32 bit and 64bit 2.5.0 portable installs on Windows 7:

Michael@michael-pc MINGW32 ~
$ git
bash: /mingw32/bin/git: Bad address

Not sure how to debug further

@dscho
Copy link
Member

dscho commented Aug 22, 2015

Obviously I cannot reproduce that... Any more details on your setup? Like: did you install as admin, but run as non-admin? Or do you have a virus scanner that quarantines files first?

Also: where do you install the portable Git? The default location? If so, is your home directory in an unmapped Windows share?

@md-5
Copy link
Author

md-5 commented Aug 22, 2015

Portable install, non admin, in my C:/Users/Michael folder. It's just a
normal ntfs drive.
On 22 Aug 2015 23:42, "dscho" [email protected] wrote:

Obviously I cannot reproduce that... Any more details on your setup? Like:
did you install as admin, but run as non-admin? Or do you have a virus
scanner that quarantines files first?

Also: where do you install the portable Git? The default location? If so,
is your home directory in an unmapped Windows share?


Reply to this email directly or view it on GitHub
#303 (comment)
.

@md-5
Copy link
Author

md-5 commented Aug 23, 2015

Disabling Windows defender didn't help.

@dscho
Copy link
Member

dscho commented Aug 24, 2015

Do you have a /mingw32/bin/git.exe file? If so, can you call it from cmd.exe using the absolute path?

@md-5
Copy link
Author

md-5 commented Aug 24, 2015

Works fine from cmd.

Seems to be limited to bash, and not just git:

Michael@michael-pc MINGW64 ~
$ openssl
bash: /mingw64/bin/openssl: Bad address

@dscho
Copy link
Member

dscho commented Aug 24, 2015

You mean, all MinGW programs fail with said "Bad address"? Are there maybe some entries in the system logs?

@md-5
Copy link
Author

md-5 commented Aug 24, 2015

They don't always fail, sometimes they work.
Unclear as to reproduction steps.

Nothing useful in the system logs.

@md-5
Copy link
Author

md-5 commented Aug 24, 2015

Michael@michael-pc MINGW64 ~
$ while true; do git --version ; done;
git version 2.5.0.windows.1
bash: /mingw64/bin/git: Bad address
git version 2.5.0.windows.1
Aborted (core dumped)
bash: /mingw64/bin/git: Bad address
Aborted (core dumped)
git version 2.5.0.windows.1
git version 2.5.0.windows.1
git version 2.5.0.windows.1
git version 2.5.0.windows.1
git version 2.5.0.windows.1
bash: /mingw64/bin/git: Bad address
bash: /mingw64/bin/git: Bad address
bash: /mingw64/bin/git: Bad address
bash: /mingw64/bin/git: Bad address
bash: /mingw64/bin/git: Bad address
Aborted (core dumped)
git version 2.5.0.windows.1
bash: /mingw64/bin/git: Bad address
Aborted (core dumped)
Aborted (core dumped)
Aborted (core dumped)
Aborted (core dumped)
git version 2.5.0.windows.1

@md-5
Copy link
Author

md-5 commented Aug 24, 2015

Stackdump seems useless:

Stack trace:
Frame        Function    Args
0000023AA90  00180071EC3 (00000000000, 00000000000, 00000000000, 00000000000)
00000000002  00180073574 (00000000064, FFFFE00100000000, 000000002E8, 00000000000)
0000023B180  0018012DB4F (7FFE87941E40, 00000000000, 00000000000, 0018030D728)
0000023B470  0018012A870 (00000000000, 00000000000, 00000000000, 00000000000)
0000023B660  0018012AD39 (00180312958, 00180313418, 00000000000, 00000000006)
0000023B660  0018012AF0C (000000009F5, 0000023B750, 00000000000, 101010101010101)
0000023B660  0018012B36F (000FFFFFFFF, 0000023B660, 0060016D3D0, 0060016D3D0)
0000023B660  0018015FAEA (001800F0D5E, 00000000000, 00000000C20, 00600047FA0)
0000023B660  001800CCC83 (0000023B700, 00180311468, 00180311ECF, 00000000000)
0000023B660  00180131A76 (00000000000, 0060016D3B0, 00600047FA0, 00600000003)
0060016D3B0  00180133459 (0018012681B, 00000000014, 001005E6C44, 00100438BD0)
00600047FA0  0018012681B (0018012681B, 00000000014, 001005E6C44, 00100438BD0)
00600047FA0  0010041307C (00000000001, 0010045FF80, 0060016D260, 00000000000)
0060016D2B0  00100414BAF (00000000002, 006FFFFFFFF, 00000000000, 00600168470)
00000000000  00100415669 (00000000025, 00000000025, 0060004B150, 00600168470)
001005E7460  00100417994 (00000000000, 00600161C60, 00000000000, 0000004B150)
End of stack trace (more stack frames may be present)

@md-5
Copy link
Author

md-5 commented Aug 24, 2015

Seems changing dirs makes the issue a lot more prevelant, ie: just changing to cd ~/Music then running:
while true; do git --version ; done;
64bit portable install

@dscho
Copy link
Member

dscho commented Aug 24, 2015

Hmm. This is funny. It works without problems here...

How did you install portable Git BTW? Did you unpack it with 7-Zip, or did you run it as self-extracting installer?

@dscho
Copy link
Member

dscho commented Aug 24, 2015

Or maybe you have an application running in the background which is in Cygwin's Big List Of Dodgy Applications?

@md-5
Copy link
Author

md-5 commented Aug 24, 2015

Self extracting installer.
On 24 Aug 2015 20:53, "dscho" [email protected] wrote:

Hmm. This is funny. It works without problems here...

How did you install portable Git BTW? Did you unpack it with 7-Zip, or did
you run it as self-extracting installer?


Reply to this email directly or view it on GitHub
#303 (comment)
.

@dscho
Copy link
Member

dscho commented Aug 24, 2015

Self extracting installer.

I asked because sometimes similar problems occur when the executables and DLLs have not been rebased (see https://github.com/git-for-windows/git/wiki/32-bit-issues for details). In those cases, closing all Git for Windows terminals and running the following from cmd.exe often helps:

cd \path\to\Git\usr\bin
dash rebaseall

But I really would suggest comparing the list of running applications/services against Cygwin's Big List Of Dodgy Applications.

@dscho
Copy link
Member

dscho commented Aug 27, 2015

I really would suggest comparing the list of running applications/services against Cygwin's Big List Of Dodgy Applications.

@md-5 could you do that, please?

@md-5
Copy link
Author

md-5 commented Aug 27, 2015

Already did.
Only Windows defender, which I disabled.
Older msysgit works flawlessly.
On 27 Aug 2015 19:51, "dscho" [email protected] wrote:

I really would suggest comparing the list of running applications/services
against Cygwin's Big List Of Dodgy Applications.

@md-5 https://github.com/md-5 could you do that, please?


Reply to this email directly or view it on GitHub
#303 (comment)
.

@dscho
Copy link
Member

dscho commented Aug 27, 2015

You do not happen to have a Logitech webcam running, do you? Running out of ideas...

@md-5
Copy link
Author

md-5 commented Aug 27, 2015

Nope.

I haven't tried the rebase stuff yet, so I'm gonna give that a shot. The only issue with that is the article claims it only affects 32bit, but I'm 64bit.

Heck I might try safe mode just to see what happens.

Really I just need a more descriptive error than "bad address".

@dscho
Copy link
Member

dscho commented Aug 27, 2015

Really I just need a more descriptive error than "bad address".

That makes two of us.

If you're in a 64-bit setup, could you try the 32-bit portable Git?

@dscho
Copy link
Member

dscho commented Aug 27, 2015

Woops, I meant the 32-bit installer?

@dscho
Copy link
Member

dscho commented Aug 27, 2015

And another stab in the dark: where do you install your portable Git? On a network drive?

@md-5
Copy link
Author

md-5 commented Aug 27, 2015

I'll try the 32bit installer, as mentioned above, portable doesn't work.

No it's just on C;\

@dscho
Copy link
Member

dscho commented Aug 28, 2015

The real odd thing is that it is intermittent. Otherwise I would have suggested a PATH problem. But no, that would kick in all the time. So it looks more like some process is grabbing a hold on the executables or their .dll files from time to time.

Any chance to resolve this via Skype or some such?

@md-5
Copy link
Author

md-5 commented Aug 28, 2015

Just reproduced it via safe mode, so yeah...
I'm on IRC (freenode et al) as md_5

@dscho
Copy link
Member

dscho commented Aug 28, 2015

@md-5 Just tried to ping you, but you seem to be in UTC+? Could you ping me here when you are available (not this weekend, but I will be online for a couple more hours today, and of course again on Monday)?

@md-5
Copy link
Author

md-5 commented Aug 28, 2015

@dscho Melbourne, so UTC+10 at the moment. How about Monday morning?
Feel free to chuck me an email ([email protected]) if you wanna set an exact time.

@md-5
Copy link
Author

md-5 commented Aug 31, 2015

@dscho
I think I have it!

  1. Install PortableGit in C:\AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
  2. cd ~/Music - I think any directory should work, but I use that one
  3. Run while true; do git --version; done; (or any other cygwin command)
  4. Observe crashes
  5. Rename install to C:\AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
  6. Observe no crashes

You will notice that the path length is 65 characters, and removing it by one stops the crash. I'm guessing the cygwin / bash code somewhere flips out on a 64byte array overflow.
nb: my folder name wasn't 64 chars long, but once you added all the folders from C:\ it exceeded that.

@dscho
Copy link
Member

dscho commented Aug 31, 2015

I just tried that, on Windows Server 2012 R2 and it does not crash...

Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Feb 2, 2017
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Feb 13, 2017
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to git-for-windows/msys2-runtime that referenced this issue Feb 14, 2017
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to git-for-windows/msys2-runtime that referenced this issue Mar 21, 2017
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to dscho/msys2-runtime that referenced this issue Apr 2, 2017
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to git-for-windows/msys2-runtime that referenced this issue May 19, 2017
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to dscho/msys2-runtime that referenced this issue Jul 3, 2017
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to git-for-windows/msys2-runtime that referenced this issue Jul 12, 2017
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to git-for-windows/msys2-runtime that referenced this issue Sep 7, 2017
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Sep 11, 2017
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Jan 22, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to git-for-windows/msys2-runtime that referenced this issue Feb 12, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Jun 3, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Jun 21, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Jun 25, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Jul 2, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Jul 6, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Jul 12, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Jul 30, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Aug 31, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Alexpux pushed a commit to Alexpux/Cygwin that referenced this issue Oct 2, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to git-for-windows/msys2-runtime that referenced this issue Nov 9, 2018
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to git-for-windows/msys2-runtime that referenced this issue Feb 16, 2019
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to git-for-windows/msys2-runtime that referenced this issue Feb 20, 2019
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
dscho added a commit to git-for-windows/msys2-runtime that referenced this issue Feb 20, 2019
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
git-for-windows-ci pushed a commit to git-for-windows/msys2-runtime that referenced this issue Mar 5, 2019
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
git-for-windows-ci pushed a commit to git-for-windows/msys2-runtime that referenced this issue Mar 9, 2019
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
git-for-windows-ci pushed a commit to git-for-windows/msys2-runtime that referenced this issue Mar 16, 2019
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
git-for-windows-ci pushed a commit to git-for-windows/msys2-runtime that referenced this issue Mar 31, 2019
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
git-for-windows-ci pushed a commit to git-for-windows/msys2-runtime that referenced this issue Apr 6, 2019
If we were to handle only single paths, the buffer really would only
need to fit a single one, but arg_heuristic is also used to convert e.g.
INFO_PATH and MAN_PATH (which can contain multiple absolute POSIX-style
paths that need to be converted to Windows-style paths).

This is only really relevant if the POSIX root directory's path is
already pretty long. Such a beast has been spotted in the wild, in the
Git for Windows project:

	git-for-windows/git#303

Of course, this patch is only a work-around that helps in many, but not
all cases. Obviously this patch will wait patiently until a real fix
comes around the corner, and then readily retire.

Signed-off-by: Johannes Schindelin <[email protected]>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Development

No branches or pull requests

2 participants