* Re: What's in git.git
From: Johannes Schindelin @ 2006-11-19 15:17 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7v1wo0bb4z.fsf@assigned-by-dhcp.cox.net>
Hi,
On Sat, 18 Nov 2006, Junio C Hamano wrote:
> Junio C Hamano <junkio@cox.net> writes:
>
> > - 'pu' has the shallow clone WIP and a half-finished rewrite of
> > git branch in C, both by Johannes. Both needs a bit more
> > polishing and confidence building before going into 'next',
> > and given the recent discussion of enhancing branch
> > management for pulls/pushes, it might be easier to drop the
> > latter for now.
>
> OOPS; sorry but the latter half is entirely untrue. What's
> there is half-done git-shortlog. Scratch everything about
> branch management please.
IMHO -shortlog needs support to read .mailmap, and maybe nods to throw out
the built-in mailmap which is totally specific to the Linux kernel
development.
As for shallow clone support: I am a bit underwhelmed by the enthusiasm
to test this thing by the people I thought would be most interested. It
really could be the case that it is not needed at all.
Just for the record, though: AFAICT the shallow stuff is lacking support
for at least pushing from/into shallow repos and it should avoid making a
commit shallow unnecessarily. And quite likely there are a few thinkos in
it, so it would not hurt having more test cases (notably of things I did
not think of), and some bad-ass testing with huge amounts of commits and
files which were added/modified identically in different commits.
Ciao,
Dscho
^ permalink raw reply
* [PATCH 2/2] gitweb: Refactor feed generation, make output prettier, add Atom feed
From: Jakub Narebski @ 2006-11-19 14:05 UTC (permalink / raw)
To: git; +Cc: Jakub Narebski, Andreas Fuchs
In-Reply-To: <11639451221153-git-send-email-jnareb@gmail.com>
Add support for more modern Atom web feed format. Both RSS and Atom
feeds are generated by git_feed subroutine to avoid code duplication;
git_rss and git_atom are thin wrappers around git_feed. Add links to
Atom feed in HTML header and in page footer (but not in OPML; we
should use APP, Atom Publishing Proptocol instead).
Allow for feed generation for branches other than current (HEAD)
branch, and for generation of feeds for file or directory history.
Do not use "pre ${\sub_returning_scalar(...)} post" trick, but join
strings instead: "pre " . sub_returning_scalar(...) . " post".
Use href(-full=>1, ...) instead of hand-crafting gitweb urls.
Make output prettier:
* Use title similar to the title of web page
* Use project description (if exists) for description/subtitle
* Do not add anything (committer name, commit date) to feed entry title
* Wrap the commit message in <pre>
* Make file names into an unordered list
* Add links (diff, conditional blame, history) to the file list.
In addition to the above points, the attached patch emits a
Last-Changed: HTTP response header field, and doesn't compute the feed
body if the HTTP request type was HEAD. This helps keep the web server
load down for well-behaved feed readers that check if the feed needs
updating.
If browser (feed reader) sent Accept: header, and it prefers 'text/xml' type
to 'application/rss+xml' (in the case of RSS feed) or 'application/atom+xml'
(in the case of Atom feed), then use 'text/xml' as content type.
Both RSS and Atom feeds validate at http://feedvalidator.org
and at http://validator.w3.org/feed/
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
Signed-off-by: Andreas Fuchs <asf@boinkor.net>
---
Compared to implementation by Andreas Fuchs (antifuchs on #git) in
Message-ID: <ejim5q$31b$1@sea.gmane.org>
http://permalink.gmane.org/gmane.comp.version-control.git/31624
this consolidates generation of RSS and Atom feeds, cleans up feed
generation code, and uses 'text/xml' as content type if browser prefers
this (for Mozilla).
This requires:
"gitweb: Add an option to href() to return full URL"
(sent just in case before this one), which is last patch in my previous
gitweb patches series.
This patch DOES NOT add feed links for branches (in "heads" view), nor
feed links for files (as alternate representation of "history" view).
Neither it adds Atom links to "OPML" view (we should use APP for that,
I think).
gitweb/gitweb.perl | 255 ++++++++++++++++++++++++++++++++++++++++++---------
1 files changed, 210 insertions(+), 45 deletions(-)
diff --git a/gitweb/gitweb.perl b/gitweb/gitweb.perl
index 8739501..a32a6b7 100755
--- a/gitweb/gitweb.perl
+++ b/gitweb/gitweb.perl
@@ -425,6 +425,7 @@ my %actions = (
"history" => \&git_history,
"log" => \&git_log,
"rss" => \&git_rss,
+ "atom" => \&git_atom,
"search" => \&git_search,
"search_help" => \&git_search_help,
"shortlog" => \&git_shortlog,
@@ -1198,10 +1199,12 @@ sub parse_date {
$date{'mday'} = $mday;
$date{'day'} = $days[$wday];
$date{'month'} = $months[$mon];
- $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
- $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
+ $date{'rfc2822'} = sprintf "%s, %d %s %4d %02d:%02d:%02d +0000",
+ $days[$wday], $mday, $months[$mon], 1900+$year, $hour ,$min, $sec;
$date{'mday-time'} = sprintf "%d %s %02d:%02d",
$mday, $months[$mon], $hour ,$min;
+ $date{'iso-8601'} = sprintf "%04d-%02d-%02dT%02d:%02d:%02dZ",
+ 1900+$year, $mon, $mday, $hour ,$min, $sec;
$tz =~ m/^([+\-][0-9][0-9])([0-9][0-9])$/;
my $local = $epoch + ((int $1 + ($2/60)) * 3600);
@@ -1209,9 +1212,9 @@ sub parse_date {
$date{'hour_local'} = $hour;
$date{'minute_local'} = $min;
$date{'tz_local'} = $tz;
- $date{'iso-tz'} = sprintf ("%04d-%02d-%02d %02d:%02d:%02d %s",
- 1900+$year, $mon+1, $mday,
- $hour, $min, $sec, $tz);
+ $date{'iso-tz'} = sprintf("%04d-%02d-%02d %02d:%02d:%02d %s",
+ 1900+$year, $mon+1, $mday,
+ $hour, $min, $sec, $tz);
return %date;
}
@@ -1672,14 +1675,17 @@ EOF
}
}
if (defined $project) {
- printf('<link rel="alternate" title="%s log" '.
- 'href="%s" type="application/rss+xml"/>'."\n",
+ printf('<link rel="alternate" title="%s log RSS feed" '.
+ 'href="%s" type="application/rss+xml" />'."\n",
esc_param($project), href(action=>"rss"));
+ printf('<link rel="alternate" title="%s log Atom feed" '.
+ 'href="%s" type="application/atom+xml" />'."\n",
+ esc_param($project), href(action=>"atom"));
} else {
printf('<link rel="alternate" title="%s projects list" '.
'href="%s" type="text/plain; charset=utf-8"/>'."\n",
$site_name, href(project=>undef, action=>"project_index"));
- printf('<link rel="alternate" title="%s projects logs" '.
+ printf('<link rel="alternate" title="%s projects feeds" '.
'href="%s" type="text/x-opml"/>'."\n",
$site_name, href(project=>undef, action=>"opml"));
}
@@ -1745,7 +1751,9 @@ sub git_footer_html {
print "<div class=\"page_footer_text\">" . esc_html($descr) . "</div>\n";
}
print $cgi->a({-href => href(action=>"rss"),
- -class => "rss_logo"}, "RSS") . "\n";
+ -class => "rss_logo"}, "RSS") . " ";
+ print $cgi->a({-href => href(action=>"atom"),
+ -class => "rss_logo"}, "Atom") . "\n";
} else {
print $cgi->a({-href => href(project=>undef, action=>"opml"),
-class => "rss_logo"}, "OPML") . " ";
@@ -4150,26 +4158,125 @@ sub git_shortlog {
}
## ......................................................................
-## feeds (RSS, OPML)
+## feeds (RSS, Atom; OPML)
-sub git_rss {
- # http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
+sub git_feed {
+ my $format = shift || 'atom';
+ my ($have_blame) = gitweb_check_feature('blame');
+
+ # Atom: http://www.atomenabled.org/developers/syndication/
+ # RSS: http://www.notestips.com/80256B3A007F2692/1/NAMO5P9UPQ
+ if ($format ne 'rss' && $format ne 'atom') {
+ die_error(undef, "Unknown web feed format");
+ }
+
+ # log/feed of current (HEAD) branch, log of given branch, history of file/directory
+ my $head = $hash || 'HEAD';
open my $fd, "-|", git_cmd(), "rev-list", "--max-count=150",
- git_get_head_hash($project), "--"
+ $head, "--", (defined $file_name ? $file_name : ())
or die_error(undef, "Open git-rev-list failed");
my @revlist = map { chomp; $_ } <$fd>;
close $fd or die_error(undef, "Reading git-rev-list failed");
- print $cgi->header(-type => 'text/xml', -charset => 'utf-8');
- print <<XML;
-<?xml version="1.0" encoding="utf-8"?>
+
+ my %latest_commit;
+ my %latest_date;
+ my $content_type = "application/$format+xml";
+ if (defined $cgi->http('HTTP_ACCEPT') &&
+ $cgi->Accept('text/xml') > $cgi->Accept($content_type)) {
+ # browser (feed reader) prefers text/xml
+ $content_type = 'text/xml';
+ }
+ if (defined($revlist[0])) {
+ %latest_commit = parse_commit($revlist[0]);
+ %latest_date = parse_date($latest_commit{'committer_epoch'});
+ print $cgi->header(
+ -type => $content_type,
+ -charset => 'utf-8',
+ -last_modified => $latest_date{'rfc2822'});
+ } else {
+ print $cgi->header(
+ -type => $content_type,
+ -charset => 'utf-8');
+ }
+
+ # Optimization: skip generating the body if client asks only
+ # for Last-Modified date.
+ return if ($cgi->request_method() eq 'HEAD');
+
+ # header variables
+ my $title = "$site_name - $project/$action";
+ my $feed_type = 'log';
+ if (defined $hash) {
+ $title .= " - '$hash'";
+ $feed_type = 'branch log';
+ if (defined $file_name) {
+ $title .= " :: $file_name";
+ $feed_type = 'history';
+ }
+ } elsif (defined $file_name) {
+ $title .= " - $file_name";
+ $feed_type = 'history';
+ }
+ $title .= " $feed_type";
+ my $descr = git_get_project_description($project);
+ if (defined $descr) {
+ $descr = esc_html($descr);
+ } else {
+ $descr = "$project " .
+ ($format eq 'rss' ? 'RSS' : 'Atom') .
+ " feed";
+ }
+ my $owner = git_get_project_owner($project);
+ $owner = esc_html($owner);
+
+ #header
+ my $alt_url;
+ if (defined $file_name) {
+ $alt_url = href(-full=>1, action=>"history", hash=>$hash, file_name=>$file_name);
+ } elsif (defined $hash) {
+ $alt_url = href(-full=>1, action=>"log", hash=>$hash);
+ } else {
+ $alt_url = href(-full=>1, action=>"summary");
+ }
+ print qq!<?xml version="1.0" encoding="utf-8"?>\n!;
+ if ($format eq 'rss') {
+ print <<XML;
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
<channel>
-<title>$project $my_uri $my_url</title>
-<link>${\esc_html("$my_url?p=$project;a=summary")}</link>
-<description>$project log</description>
-<language>en</language>
XML
+ print "<title>$title</title>\n" .
+ "<link>$alt_url</link>\n" .
+ "<description>$descr</description>\n" .
+ "<language>en</language>\n";
+ } elsif ($format eq 'atom') {
+ print <<XML;
+<feed xmlns="http://www.w3.org/2005/Atom">
+XML
+ print "<title>$title</title>\n" .
+ "<subtitle>$descr</subtitle>\n" .
+ '<link rel="alternate" type="text/html" href="' .
+ $alt_url . '" />' . "\n" .
+ '<link rel="self" type="' . $content_type . '" href="' .
+ $cgi->self_url() . '" />' . "\n" .
+ "<id>" . href(-full=>1) . "</id>\n" .
+ # use project owner for feed author
+ "<author><name>$owner</name></author>\n";
+ if (defined $favicon) {
+ print "<icon>" . esc_url($favicon) . "</icon>\n";
+ }
+ if (defined $logo_url) {
+ # not twice as wide as tall: 72 x 27 pixels
+ print "<logo>" . esc_url($logo_url) . "</logo>\n";
+ }
+ if (! %latest_date) {
+ # dummy date to keep the feed valid until commits trickle in:
+ print "<updated>1970-01-01T00:00:00Z</updated>\n";
+ } else {
+ print "<updated>$latest_date{'iso-8601'}</updated>\n";
+ }
+ }
+ # contents
for (my $i = 0; $i <= $#revlist; $i++) {
my $commit = $revlist[$i];
my %co = parse_commit($commit);
@@ -4178,42 +4285,100 @@ XML
last;
}
my %cd = parse_date($co{'committer_epoch'});
+
+ # get list of changed files
open $fd, "-|", git_cmd(), "diff-tree", '-r', @diff_opts,
- $co{'parent'}, $co{'id'}, "--"
+ $co{'parent'}, $co{'id'}, "--", (defined $file_name ? $file_name : ())
or next;
my @difftree = map { chomp; $_ } <$fd>;
close $fd
or next;
- print "<item>\n" .
- "<title>" .
- sprintf("%d %s %02d:%02d", $cd{'mday'}, $cd{'month'}, $cd{'hour'}, $cd{'minute'}) . " - " . esc_html($co{'title'}) .
- "</title>\n" .
- "<author>" . esc_html($co{'author'}) . "</author>\n" .
- "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
- "<guid isPermaLink=\"true\">" . esc_html("$my_url?p=$project;a=commit;h=$commit") . "</guid>\n" .
- "<link>" . esc_html("$my_url?p=$project;a=commit;h=$commit") . "</link>\n" .
- "<description>" . esc_html($co{'title'}) . "</description>\n" .
- "<content:encoded>" .
- "<![CDATA[\n";
+
+ # print element (entry, item)
+ my $co_url = href(-full=>1, action=>"commit", hash=>$commit);
+ if ($format eq 'rss') {
+ print "<item>\n" .
+ "<title>" . esc_html($co{'title'}) . "</title>\n" .
+ "<author>" . esc_html($co{'author'}) . "</author>\n" .
+ "<pubDate>$cd{'rfc2822'}</pubDate>\n" .
+ "<guid isPermaLink=\"true\">$co_url</guid>\n" .
+ "<link>$co_url</link>\n" .
+ "<description>" . esc_html($co{'title'}) . "</description>\n" .
+ "<content:encoded>" .
+ "<![CDATA[\n";
+ } elsif ($format eq 'atom') {
+ print "<entry>\n" .
+ "<title type=\"html\">" . esc_html($co{'title'}) . "</title>\n" .
+ "<updated>$cd{'iso-8601'}</updated>\n" .
+ "<author><name>" . esc_html($co{'author_name'}) . "</name></author>\n" .
+ # use committer for contributor
+ "<contributor><name>" . esc_html($co{'committer_name'}) . "</name></contributor>\n" .
+ "<published>$cd{'iso-8601'}</published>\n" .
+ "<link rel=\"alternate\" type=\"text/html\" href=\"$co_url\" />\n" .
+ "<id>$co_url</id>\n" .
+ "<content type=\"xhtml\" xml:base=\"" . esc_url($my_url) . "\">\n" .
+ "<div xmlns=\"http://www.w3.org/1999/xhtml\">\n";
+ }
my $comment = $co{'comment'};
+ print "<pre>\n";
foreach my $line (@$comment) {
- $line = to_utf8($line);
- print "$line<br/>\n";
+ $line = esc_html($line);
+ print "$line\n";
}
- print "<br/>\n";
- foreach my $line (@difftree) {
- if (!($line =~ m/^:([0-7]{6}) ([0-7]{6}) ([0-9a-fA-F]{40}) ([0-9a-fA-F]{40}) (.)([0-9]{0,3})\t(.*)$/)) {
- next;
+ print "</pre><ul>\n";
+ foreach my $difftree_line (@difftree) {
+ my %difftree = parse_difftree_raw_line($difftree_line);
+ next if !$difftree{'from_id'};
+
+ my $file = $difftree{'file'} || $difftree{'to_file'};
+
+ print "<li>" .
+ "[" .
+ $cgi->a({-href => href(-full=>1, action=>"blobdiff",
+ hash=>$difftree{'to_id'}, hash_parent=>$difftree{'from_id'},
+ hash_base=>$co{'id'}, hash_parent_base=>$co{'parent'},
+ file_name=>$file, file_parent=>$difftree{'from_file'}),
+ -title => "diff"}, 'D');
+ if ($have_blame) {
+ print $cgi->a({-href => href(-full=>1, action=>"blame",
+ file_name=>$file, hash_base=>$commit),
+ -title => "blame"}, 'B');
}
- my $file = esc_path(unquote($7));
- $file = to_utf8($file);
- print "$file<br/>\n";
+ # if this is not a feed of a file history
+ if (!defined $file_name || $file_name ne $file) {
+ print $cgi->a({-href => href(-full=>1, action=>"history",
+ file_name=>$file, hash=>$commit),
+ -title => "history"}, 'H');
+ }
+ $file = esc_path($file);
+ print "] ".
+ "$file</li>\n";
+ }
+ if ($format eq 'rss') {
+ print "</ul>]]>\n" .
+ "</content:encoded>\n" .
+ "</item>\n";
+ } elsif ($format eq 'atom') {
+ print "</ul>\n</div>\n" .
+ "</content>\n" .
+ "</entry>\n";
}
- print "]]>\n" .
- "</content:encoded>\n" .
- "</item>\n";
}
- print "</channel></rss>";
+
+ # end of feed
+ if ($format eq 'rss') {
+ print "</channel>\n</rss>\n";
+ } elsif ($format eq 'atom') {
+ print "</feed>\n";
+ }
+}
+
+sub git_rss {
+ git_feed('rss');
+}
+
+sub git_atom {
+ git_feed('atom');
}
sub git_opml {
--
1.4.3.4
^ permalink raw reply related
* [PATCH 1/2] gitweb: Add an option to href() to return full URL
From: Jakub Narebski @ 2006-11-19 14:05 UTC (permalink / raw)
To: git; +Cc: Jakub Narebski
In-Reply-To: <200611171236.19030.jnareb@gmail.com>
href subroutine by default generates absolute URL (generated using
CGI::url(-absolute=>1), and saved in $my_uri) using $my_uri as base;
add an option to generate full URL using $my_url as base.
New feature usage: href(..., -full=>1)
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
---
gitweb/gitweb.perl | 3 ++-
1 files changed, 2 insertions(+), 1 deletions(-)
diff --git a/gitweb/gitweb.perl b/gitweb/gitweb.perl
index 5875ba0..8739501 100755
--- a/gitweb/gitweb.perl
+++ b/gitweb/gitweb.perl
@@ -459,7 +459,8 @@ exit;
sub href(%) {
my %params = @_;
- my $href = $my_uri;
+ # default is to use -absolute url() i.e. $my_uri
+ my $href = $params{-full} ? $my_url : $my_uri;
# XXX: Warning: If you touch this, check the search form for updating,
# too.
--
1.4.3.4
^ permalink raw reply related
* Shouldn't git-ls-files --others use $GIT_DIR?
From: Nikolai Weibull @ 2006-11-19 13:37 UTC (permalink / raw)
To: git
If I do
GIT_DIR=$HOME/projects/<project>/.git git ls-files --others
from, e.g., $HOME, I get a list of all the files in $HOME and its
subdirectories that aren't in said git repository. Shouldn't --others
use $GIT_DIR, instead of ".", or am I missing something here?
^ permalink raw reply
* Re: [WISH] Store also tag dereferences in packed-refs
From: Marco Costalba @ 2006-11-19 9:40 UTC (permalink / raw)
To: Linus Torvalds; +Cc: Junio C Hamano, git
In-Reply-To: <Pine.LNX.4.64.0611181706250.3692@woody.osdl.org>
[-- Attachment #1: Type: text/plain, Size: 1167 bytes --]
>
> Can you do
>
> strace -o tracefile -Ttt git show-ref
>
> and send out the tracefile?
>
Sure. File ran against git tree attached.
> What I _suspect_ is going on is that when you packed your refs, you either
> didn't prune them (which means that packing didn't actually help you), or
> if you did prune them, since we don't seem to remove the refs
> _directories_ when packing, you still have an old and big directory for
> .git/refs/tags, and just reading that (empty, but non-shrunken) directory
> takes time.
Indeed it is not empty, it has 4 refs, all the remaining are in packed-refs:
$ ls .git/refs/tags
v1.4.3.4 v1.4.3.5 v1.4.4 v1.4.4-rc1 v1.4.4-rc2
$ ls -l .git/packed-refs
-rw-r--r-- 1 marco marco 6469 nov 3 21:03 .git/packed-refs
$ cat .git/packed-refs |wc
109 218 6469
If you want I can repack and prune, but for now I just wait to avoid
to corrupt this test case.
IMHO if just 4 entry in a directory out of 109 could slow down in this
way, at least should be documented/warned in some place. Also because
this it seems to me, perhaps wrongly, a quite common scenario of an
user that repacks the tags seldom.
Marco
[-- Attachment #2: tracefile_git_tree.txt --]
[-- Type: text/plain, Size: 37982 bytes --]
10:19:02.935227 execve("/home/marco/bin/git", ["git", "show-ref"], [/* 75 vars */]) = 0 <0.045394>
10:19:02.981333 brk(0) = 0x80de000 <0.000011>
10:19:02.981498 mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7fcb000 <0.000014>
10:19:02.981618 access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory) <0.000015>
10:19:02.981760 open("/etc/ld.so.cache", O_RDONLY) = 3 <0.000020>
10:19:02.981849 fstat64(3, {st_mode=S_IFREG|0644, st_size=79652, ...}) = 0 <0.000011>
10:19:02.981975 mmap2(NULL, 79652, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fb7000 <0.000016>
10:19:02.982056 close(3) = 0 <0.000011>
10:19:02.982166 open("/lib/libz.so.1", O_RDONLY) = 3 <0.000019>
10:19:02.982253 read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0\20\27\0"..., 512) = 512 <0.000015>
10:19:02.982368 fstat64(3, {st_mode=S_IFREG|0755, st_size=73156, ...}) = 0 <0.000011>
10:19:02.982474 mmap2(NULL, 75980, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xb7fa4000 <0.000014>
10:19:02.982558 mmap2(0xb7fb6000, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x11) = 0xb7fb6000 <0.000025>
10:19:02.982666 close(3) = 0 <0.000010>
10:19:02.982762 open("/usr/lib/libcrypto.so.0.9.8", O_RDONLY) = 3 <0.000017>
10:19:02.982851 read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0@U\3\000"..., 512) = 512 <0.000014>
10:19:02.982958 fstat64(3, {st_mode=S_IFREG|0755, st_size=1353744, ...}) = 0 <0.000011>
10:19:02.983062 mmap2(NULL, 1370456, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xb7e55000 <0.000014>
10:19:02.983146 mmap2(0xb7f8c000, 86016, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x136) = 0xb7f8c000 <0.000020>
10:19:02.983254 mmap2(0xb7fa1000, 10584, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0xb7fa1000 <0.000015>
10:19:02.983354 close(3) = 0 <0.000011>
10:19:02.983441 open("/lib/i686/libc.so.6", O_RDONLY) = 3 <0.000019>
10:19:02.983530 read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0\240X\1"..., 512) = 512 <0.000013>
10:19:02.983635 fstat64(3, {st_mode=S_IFREG|0644, st_size=1220244, ...}) = 0 <0.000011>
10:19:02.983745 mmap2(NULL, 1230204, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xb7d28000 <0.000014>
10:19:02.983828 mmap2(0xb7e4f000, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x126) = 0xb7e4f000 <0.000022>
10:19:02.983936 mmap2(0xb7e52000, 9596, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0xb7e52000 <0.000015>
10:19:02.984161 close(3) = 0 <0.000012>
10:19:02.984261 open("/lib/libdl.so.2", O_RDONLY) = 3 <0.000020>
10:19:02.984350 read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0p\f\0\000"..., 512) = 512 <0.000014>
10:19:02.984457 fstat64(3, {st_mode=S_IFREG|0755, st_size=9700, ...}) = 0 <0.000011>
10:19:02.984562 mmap2(NULL, 12412, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xb7d24000 <0.000016>
10:19:02.984647 mmap2(0xb7d26000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1) = 0xb7d26000 <0.000020>
10:19:02.984766 close(3) = 0 <0.000011>
10:19:02.984883 mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7d23000 <0.000016>
10:19:02.984995 mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7d22000 <0.000012>
10:19:02.985086 set_thread_area({entry_number:-1 -> 6, base_addr:0xb7d226c0, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0 <0.000011>
10:19:02.985642 mprotect(0xb7e4f000, 4096, PROT_READ) = 0 <0.000019>
10:19:02.986216 mprotect(0xb7fe5000, 4096, PROT_READ) = 0 <0.000021>
10:19:02.986324 munmap(0xb7fb7000, 79652) = 0 <0.000027>
10:19:02.988091 brk(0) = 0x80de000 <0.000012>
10:19:02.988180 brk(0x80ff000) = 0x80ff000 <0.000015>
10:19:02.988343 getcwd("/home/marco/programmi/git", 4097) = 26 <0.000025>
10:19:02.988456 access(".git/refs/", X_OK) = 0 <0.016158>
10:19:03.004751 access(".git/objects/", X_OK) = 0 <0.008759>
10:19:03.013670 lstat64(".git/HEAD", {st_mode=S_IFREG|0644, st_size=23, ...}) = 0 <0.000023>
10:19:03.013812 open(".git/HEAD", O_RDONLY) = 3 <0.000021>
10:19:03.013910 read(3, "ref: refs/heads/origin\n", 255) = 23 <0.008989>
10:19:03.023027 close(3) = 0 <0.000015>
10:19:03.023257 access("/home/marco/.gitconfig", R_OK) = -1 ENOENT (No such file or directory) <0.000030>
10:19:03.023401 open(".git/config", O_RDONLY) = 3 <0.000027>
10:19:03.023527 fstat64(3, {st_mode=S_IFREG|0664, st_size=84, ...}) = 0 <0.000012>
10:19:03.023639 mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7fca000 <0.000019>
10:19:03.023730 read(3, "[core]\n\trepositoryformatversion "..., 4096) = 84 <0.004629>
10:19:03.028488 read(3, "", 4096) = 0 <0.000012>
10:19:03.028583 close(3) = 0 <0.000014>
10:19:03.028659 munmap(0xb7fca000, 4096) = 0 <0.000023>
10:19:03.029585 open(".git/packed-refs", O_RDONLY) = 3 <0.000031>
10:19:03.029711 fstat64(3, {st_mode=S_IFREG|0644, st_size=6469, ...}) = 0 <0.000011>
10:19:03.029818 mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7fca000 <0.000015>
10:19:03.029903 read(3, "dcc22ee22803fe091761047d69d92529"..., 4096) = 4096 <0.013330>
10:19:03.043674 read(3, "f416f8f2bc74d6d0a refs/tags/v1.1"..., 4096) = 2373 <0.003832>
10:19:03.047952 read(3, "", 4096) = 0 <0.000012>
10:19:03.048142 close(3) = 0 <0.000013>
10:19:03.048221 munmap(0xb7fca000, 4096) = 0 <0.000022>
10:19:03.048343 open(".git/refs", O_RDONLY|O_NONBLOCK|O_LARGEFILE|O_DIRECTORY) = 3 <0.000018>
10:19:03.048436 fstat64(3, {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0 <0.000011>
10:19:03.048541 fcntl64(3, F_SETFD, FD_CLOEXEC) = 0 <0.000012>
10:19:03.048641 getdents(3, /* 4 entries */, 4096) = 68 <0.011642>
10:19:03.060486 stat64(".git/refs/heads", {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0 <0.000034>
10:19:03.060658 open(".git/refs/heads", O_RDONLY|O_NONBLOCK|O_LARGEFILE|O_DIRECTORY) = 4 <0.000021>
10:19:03.060752 fstat64(4, {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0 <0.000011>
10:19:03.060854 fcntl64(4, F_SETFD, FD_CLOEXEC) = 0 <0.000012>
10:19:03.060946 getdents(4, /* 10 entries */, 4096) = 172 <0.000179>
10:19:03.061242 stat64(".git/refs/heads/pu", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.006570>
10:19:03.067925 lstat64(".git/refs/heads/pu", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000015>
10:19:03.068152 open(".git/refs/heads/pu", O_RDONLY) = 5 <0.000019>
10:19:03.068248 read(5, "69e98b538aeb47f1a5602b00f1972bfd"..., 255) = 41 <0.007676>
10:19:03.076003 close(5) = 0 <0.000541>
10:19:03.076680 stat64(".git/refs/heads/man", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000030>
10:19:03.076831 lstat64(".git/refs/heads/man", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000015>
10:19:03.076944 open(".git/refs/heads/man", O_RDONLY) = 5 <0.000019>
10:19:03.077031 read(5, "d0f877fb601ac0076fd69ec4f48f71f9"..., 255) = 41 <0.009018>
10:19:03.086137 close(5) = 0 <0.000013>
10:19:03.086232 stat64(".git/refs/heads/todo", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000025>
10:19:03.086361 lstat64(".git/refs/heads/todo", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000015>
10:19:03.086475 open(".git/refs/heads/todo", O_RDONLY) = 5 <0.000017>
10:19:03.086562 read(5, "16a4568a8292605cb688d0e26c65aea8"..., 255) = 41 <0.008006>
10:19:03.094684 close(5) = 0 <0.000013>
10:19:03.094782 stat64(".git/refs/heads/maint", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000028>
10:19:03.094916 lstat64(".git/refs/heads/maint", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000016>
10:19:03.095030 open(".git/refs/heads/maint", O_RDONLY) = 5 <0.000017>
10:19:03.095118 read(5, "fe142b3a4577a6692a39e2386ed64966"..., 255) = 41 <0.006822>
10:19:03.102017 close(5) = 0 <0.000013>
10:19:03.102103 stat64(".git/refs/heads/next", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000031>
10:19:03.102236 lstat64(".git/refs/heads/next", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000015>
10:19:03.102382 open(".git/refs/heads/next", O_RDONLY) = 5 <0.000017>
10:19:03.102471 read(5, "8f89a06b2529346f2b05bd44bd6a61a7"..., 255) = 41 <0.008473>
10:19:03.111052 close(5) = 0 <0.000013>
10:19:03.111150 stat64(".git/refs/heads/v1.4.0", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000029>
10:19:03.111284 lstat64(".git/refs/heads/v1.4.0", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000015>
10:19:03.111398 open(".git/refs/heads/v1.4.0", O_RDONLY) = 5 <0.000018>
10:19:03.111485 read(5, "41292ddd37202ff6dce34986c87a6000"..., 255) = 41 <0.008847>
10:19:03.120410 close(5) = 0 <0.000012>
10:19:03.120495 stat64(".git/refs/heads/html", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000023>
10:19:03.120621 lstat64(".git/refs/heads/html", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000015>
10:19:03.120734 open(".git/refs/heads/html", O_RDONLY) = 5 <0.000017>
10:19:03.120821 read(5, "fb2ead308920336d55720031034442c1"..., 255) = 41 <0.015274>
10:19:03.136258 close(5) = 0 <0.000016>
10:19:03.136383 stat64(".git/refs/heads/origin", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000033>
10:19:03.136524 lstat64(".git/refs/heads/origin", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000015>
10:19:03.136638 open(".git/refs/heads/origin", O_RDONLY) = 5 <0.000020>
10:19:03.136728 read(5, "e267c2f6f0784e242883b7d3fe5f36ef"..., 255) = 41 <0.000725>
10:19:03.137529 close(5) = 0 <0.000013>
10:19:03.137611 getdents(4, /* 0 entries */, 4096) = 0 <0.000013>
10:19:03.137702 close(4) = 0 <0.000012>
10:19:03.137781 stat64(".git/refs/tags", {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0 <0.000025>
10:19:03.137909 open(".git/refs/tags", O_RDONLY|O_NONBLOCK|O_LARGEFILE|O_DIRECTORY) = 4 <0.000016>
10:19:03.137997 fstat64(4, {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0 <0.000012>
10:19:03.138098 fcntl64(4, F_SETFD, FD_CLOEXEC) = 0 <0.000013>
10:19:03.138177 getdents(4, /* 7 entries */, 4096) = 140 <0.010973>
10:19:03.149276 stat64(".git/refs/tags/v1.4.3.4", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.004994>
10:19:03.154448 lstat64(".git/refs/tags/v1.4.3.4", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000017>
10:19:03.154585 open(".git/refs/tags/v1.4.3.4", O_RDONLY) = 5 <0.000022>
10:19:03.154677 read(5, "100490cfcd50d0f9ddadeb90cf5d95b2"..., 255) = 41 <0.005124>
10:19:03.159877 close(5) = 0 <0.000015>
10:19:03.159966 stat64(".git/refs/tags/v1.4.4-rc1", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.006757>
10:19:03.166861 lstat64(".git/refs/tags/v1.4.4-rc1", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000017>
10:19:03.166995 open(".git/refs/tags/v1.4.4-rc1", O_RDONLY) = 5 <0.000019>
10:19:03.167085 read(5, "3a41a48d139d1425c1d27e3fbe4f511f"..., 255) = 41 <0.005877>
10:19:03.173113 close(5) = 0 <0.000015>
10:19:03.173236 stat64(".git/refs/tags/v1.4.3.5", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.006382>
10:19:03.179730 lstat64(".git/refs/tags/v1.4.3.5", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000015>
10:19:03.179846 open(".git/refs/tags/v1.4.3.5", O_RDONLY) = 5 <0.000019>
10:19:03.179936 read(5, "a8d8dc4c6cd6d4681746fd6919318640"..., 255) = 41 <0.007536>
10:19:03.187558 close(5) = 0 <0.000013>
10:19:03.187655 stat64(".git/refs/tags/v1.4.4-rc2", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000026>
10:19:03.187785 lstat64(".git/refs/tags/v1.4.4-rc2", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000015>
10:19:03.187899 open(".git/refs/tags/v1.4.4-rc2", O_RDONLY) = 5 <0.000018>
10:19:03.187988 read(5, "b9b0b3d0020c3559d4d9e6d07e3316c3"..., 255) = 41 <0.010095>
10:19:03.198218 close(5) = 0 <0.000015>
10:19:03.198330 stat64(".git/refs/tags/v1.4.4", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.003882>
10:19:03.202322 lstat64(".git/refs/tags/v1.4.4", {st_mode=S_IFREG|0644, st_size=41, ...}) = 0 <0.000015>
10:19:03.202437 open(".git/refs/tags/v1.4.4", O_RDONLY) = 5 <0.000019>
10:19:03.202527 read(5, "fab4f17015ccb2c6ea978b45386d45dd"..., 255) = 41 <0.014246>
10:19:03.216949 close(5) = 0 <0.000014>
10:19:03.217063 getdents(4, /* 0 entries */, 4096) = 0 <0.000013>
10:19:03.217140 close(4) = 0 <0.000012>
10:19:03.217213 getdents(3, /* 0 entries */, 4096) = 0 <0.000011>
10:19:03.217287 close(3) = 0 <0.000011>
10:19:03.217397 open(".git/objects/pack", O_RDONLY|O_NONBLOCK|O_LARGEFILE|O_DIRECTORY) = 3 <0.015266>
10:19:03.232796 fstat64(3, {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0 <0.000011>
10:19:03.232928 fcntl64(3, F_SETFD, FD_CLOEXEC) = 0 <0.000012>
10:19:03.233009 getdents(3, /* 4 entries */, 4096) = 160 <0.000216>
10:19:03.233356 open(".git/objects/pack/pack-a587adeec6a06edc539cc73c0a526e93b2982022.idx", O_RDONLY) = 4 <0.000032>
10:19:03.233486 fstat64(4, {st_mode=S_IFREG|0444, st_size=431864, ...}) = 0 <0.000011>
10:19:03.233598 mmap2(NULL, 431864, PROT_READ, MAP_PRIVATE, 4, 0) = 0xb7cb8000 <0.000022>
10:19:03.233687 close(4) = 0 <0.000012>
10:19:03.252324 stat64(".git/objects/pack/pack-a587adeec6a06edc539cc73c0a526e93b2982022.pack", {st_mode=S_IFREG|0444, st_size=7118252, ...}) = 0 <0.000057>
10:19:03.252570 getdents(3, /* 0 entries */, 4096) = 0 <0.000013>
10:19:03.252652 close(3) = 0 <0.000014>
10:19:03.252741 open(".git/objects/info/alternates", O_RDONLY) = -1 ENOENT (No such file or directory) <0.006948>
10:19:03.271644 stat64(".git/objects/fb/2ead308920336d55720031034442c1ff3a2088", {st_mode=S_IFREG|0444, st_size=193, ...}) = 0 <0.029404>
10:19:03.301358 stat64(".git/objects/fb/2ead308920336d55720031034442c1ff3a2088", {st_mode=S_IFREG|0444, st_size=193, ...}) = 0 <0.000018>
10:19:03.301514 open(".git/objects/fb/2ead308920336d55720031034442c1ff3a2088", O_RDONLY|O_NOATIME) = 3 <0.000023>
10:19:03.301620 mmap2(NULL, 193, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fca000 <0.000019>
10:19:03.301706 close(3) = 0 <0.000012>
10:19:03.310337 munmap(0xb7fca000, 193) = 0 <0.000030>
10:19:03.310740 open(".git/info/grafts", O_RDONLY) = -1 ENOENT (No such file or directory) <0.008295>
10:19:03.319252 fstat64(1, {st_mode=S_IFREG|0644, st_size=0, ...}) = 0 <0.000013>
10:19:03.319386 mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7fca000 <0.000018>
10:19:03.319500 stat64(".git/objects/fe/142b3a4577a6692a39e2386ed649664ad8bd20", {st_mode=S_IFREG|0444, st_size=316, ...}) = 0 <0.010379>
10:19:03.330019 stat64(".git/objects/fe/142b3a4577a6692a39e2386ed649664ad8bd20", {st_mode=S_IFREG|0444, st_size=316, ...}) = 0 <0.000016>
10:19:03.330156 open(".git/objects/fe/142b3a4577a6692a39e2386ed649664ad8bd20", O_RDONLY|O_NOATIME) = 3 <0.000022>
10:19:03.330260 mmap2(NULL, 316, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000018>
10:19:03.330344 close(3) = 0 <0.000011>
10:19:03.342077 munmap(0xb7fc9000, 316) = 0 <0.000058>
10:19:03.355754 stat64(".git/objects/d0/f877fb601ac0076fd69ec4f48f71f9247771c8", {st_mode=S_IFREG|0444, st_size=190, ...}) = 0 <0.046244>
10:19:03.402234 stat64(".git/objects/d0/f877fb601ac0076fd69ec4f48f71f9247771c8", {st_mode=S_IFREG|0444, st_size=190, ...}) = 0 <0.000019>
10:19:03.402392 open(".git/objects/d0/f877fb601ac0076fd69ec4f48f71f9247771c8", O_RDONLY|O_NOATIME) = 3 <0.000023>
10:19:03.402498 mmap2(NULL, 190, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000021>
10:19:03.402586 close(3) = 0 <0.000012>
10:19:03.408581 munmap(0xb7fc9000, 190) = 0 <0.000022>
10:19:03.427950 stat64(".git/objects/8f/89a06b2529346f2b05bd44bd6a61a76898c639", {st_mode=S_IFREG|0444, st_size=262, ...}) = 0 <0.018769>
10:19:03.446963 stat64(".git/objects/8f/89a06b2529346f2b05bd44bd6a61a76898c639", {st_mode=S_IFREG|0444, st_size=262, ...}) = 0 <0.000017>
10:19:03.447109 open(".git/objects/8f/89a06b2529346f2b05bd44bd6a61a76898c639", O_RDONLY|O_NOATIME) = 3 <0.000018>
10:19:03.447209 mmap2(NULL, 262, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000020>
10:19:03.447297 close(3) = 0 <0.000010>
10:19:03.455682 munmap(0xb7fc9000, 262) = 0 <0.000023>
10:19:03.455835 stat64(".git/objects/e2/67c2f6f0784e242883b7d3fe5f36ef63d6950d", {st_mode=S_IFREG|0444, st_size=179, ...}) = 0 <0.033849>
10:19:03.489904 stat64(".git/objects/e2/67c2f6f0784e242883b7d3fe5f36ef63d6950d", {st_mode=S_IFREG|0444, st_size=179, ...}) = 0 <0.000018>
10:19:03.490059 open(".git/objects/e2/67c2f6f0784e242883b7d3fe5f36ef63d6950d", O_RDONLY|O_NOATIME) = 3 <0.000022>
10:19:03.490162 mmap2(NULL, 179, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:03.490249 close(3) = 0 <0.000011>
10:19:03.504780 munmap(0xb7fc9000, 179) = 0 <0.000023>
10:19:03.504931 stat64(".git/objects/69/e98b538aeb47f1a5602b00f1972bfd05ac27cc", {st_mode=S_IFREG|0444, st_size=517, ...}) = 0 <0.026898>
10:19:03.531966 stat64(".git/objects/69/e98b538aeb47f1a5602b00f1972bfd05ac27cc", {st_mode=S_IFREG|0444, st_size=517, ...}) = 0 <0.000016>
10:19:03.532337 open(".git/objects/69/e98b538aeb47f1a5602b00f1972bfd05ac27cc", O_RDONLY|O_NOATIME) = 3 <0.000022>
10:19:03.532458 mmap2(NULL, 517, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:03.532542 close(3) = 0 <0.000012>
10:19:03.542325 munmap(0xb7fc9000, 517) = 0 <0.000022>
10:19:03.542485 stat64(".git/objects/16/a4568a8292605cb688d0e26c65aea8850f22d4", {st_mode=S_IFREG|0444, st_size=184, ...}) = 0 <0.015860>
10:19:03.558508 stat64(".git/objects/16/a4568a8292605cb688d0e26c65aea8850f22d4", {st_mode=S_IFREG|0444, st_size=184, ...}) = 0 <0.000017>
10:19:03.558654 open(".git/objects/16/a4568a8292605cb688d0e26c65aea8850f22d4", O_RDONLY|O_NOATIME) = 3 <0.000019>
10:19:03.558755 mmap2(NULL, 184, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000018>
10:19:03.558839 close(3) = 0 <0.000012>
10:19:03.566339 munmap(0xb7fc9000, 184) = 0 <0.000024>
10:19:03.566511 stat64(".git/objects/41/292ddd37202ff6dce34986c87a6000c5d3fbfa", {st_mode=S_IFREG|0444, st_size=180, ...}) = 0 <0.020396>
10:19:03.587058 stat64(".git/objects/41/292ddd37202ff6dce34986c87a6000c5d3fbfa", {st_mode=S_IFREG|0444, st_size=180, ...}) = 0 <0.000016>
10:19:03.587197 open(".git/objects/41/292ddd37202ff6dce34986c87a6000c5d3fbfa", O_RDONLY|O_NOATIME) = 3 <0.000021>
10:19:03.587299 mmap2(NULL, 180, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:03.587383 close(3) = 0 <0.000012>
10:19:03.600927 munmap(0xb7fc9000, 180) = 0 <0.000022>
10:19:03.601072 open(".git/objects/pack/pack-a587adeec6a06edc539cc73c0a526e93b2982022.pack", O_RDONLY) = 3 <0.000022>
10:19:03.601180 fstat64(3, {st_mode=S_IFREG|0444, st_size=7118252, ...}) = 0 <0.000011>
10:19:03.601284 mmap2(NULL, 7118252, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb75ee000 <0.000018>
10:19:03.601365 close(3) = 0 <0.000011>
10:19:03.645053 brk(0x8124000) = 0x8124000 <0.000019>
10:19:03.662737 write(1, "fb2ead308920336d55720031034442c1"..., 4096) = 4096 <0.000054>
10:19:03.663479 stat64(".git/objects/b0/517166ae2ad92f3b17638cbdee0f04b8170d99", {st_mode=S_IFREG|0444, st_size=277, ...}) = 0 <0.022552>
10:19:03.686177 stat64(".git/objects/b0/517166ae2ad92f3b17638cbdee0f04b8170d99", {st_mode=S_IFREG|0444, st_size=277, ...}) = 0 <0.000017>
10:19:03.686315 open(".git/objects/b0/517166ae2ad92f3b17638cbdee0f04b8170d99", O_RDONLY|O_NOATIME) = 3 <0.000022>
10:19:03.686418 mmap2(NULL, 277, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000021>
10:19:03.686504 close(3) = 0 <0.000012>
10:19:03.690535 munmap(0xb7fc9000, 277) = 0 <0.000026>
10:19:03.690897 stat64(".git/objects/86/a9bf69164090c91474bb7bcdde7d76966b7d40", {st_mode=S_IFREG|0444, st_size=282, ...}) = 0 <0.015918>
10:19:03.706991 stat64(".git/objects/86/a9bf69164090c91474bb7bcdde7d76966b7d40", {st_mode=S_IFREG|0444, st_size=282, ...}) = 0 <0.000017>
10:19:03.707140 open(".git/objects/86/a9bf69164090c91474bb7bcdde7d76966b7d40", O_RDONLY|O_NOATIME) = 3 <0.000021>
10:19:03.707243 mmap2(NULL, 282, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000020>
10:19:03.707328 close(3) = 0 <0.000012>
10:19:03.721897 munmap(0xb7fc9000, 282) = 0 <0.000026>
10:19:03.722067 stat64(".git/objects/fa/7bd724f61bcdcd71ef579f7b94b72bda1298cf", {st_mode=S_IFREG|0444, st_size=279, ...}) = 0 <0.007090>
10:19:03.729292 stat64(".git/objects/fa/7bd724f61bcdcd71ef579f7b94b72bda1298cf", {st_mode=S_IFREG|0444, st_size=279, ...}) = 0 <0.000017>
10:19:03.729456 open(".git/objects/fa/7bd724f61bcdcd71ef579f7b94b72bda1298cf", O_RDONLY|O_NOATIME) = 3 <0.000022>
10:19:03.729560 mmap2(NULL, 279, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:03.729645 close(3) = 0 <0.000012>
10:19:03.730857 munmap(0xb7fc9000, 279) = 0 <0.000019>
10:19:03.730979 stat64(".git/objects/43/2567e79be81bc91f4af5bcfe5ac51330d2d349", {st_mode=S_IFREG|0444, st_size=281, ...}) = 0 <0.035298>
10:19:03.766440 stat64(".git/objects/43/2567e79be81bc91f4af5bcfe5ac51330d2d349", {st_mode=S_IFREG|0444, st_size=281, ...}) = 0 <0.000018>
10:19:03.766586 open(".git/objects/43/2567e79be81bc91f4af5bcfe5ac51330d2d349", O_RDONLY|O_NOATIME) = 3 <0.000020>
10:19:03.766687 mmap2(NULL, 281, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:03.766771 close(3) = 0 <0.000012>
10:19:03.780679 munmap(0xb7fc9000, 281) = 0 <0.000023>
10:19:03.780829 stat64(".git/objects/ff/a22c1601a782de4f54c7667d772936da123ef0", {st_mode=S_IFREG|0444, st_size=279, ...}) = 0 <0.020505>
10:19:03.801496 stat64(".git/objects/ff/a22c1601a782de4f54c7667d772936da123ef0", {st_mode=S_IFREG|0444, st_size=279, ...}) = 0 <0.000017>
10:19:03.801642 open(".git/objects/ff/a22c1601a782de4f54c7667d772936da123ef0", O_RDONLY|O_NOATIME) = 3 <0.000022>
10:19:03.801744 mmap2(NULL, 279, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000020>
10:19:03.801829 close(3) = 0 <0.000011>
10:19:03.811789 munmap(0xb7fc9000, 279) = 0 <0.000022>
10:19:03.811920 stat64(".git/objects/12/0530fb2e10679d9095e278c95c0e98c96f3080", {st_mode=S_IFREG|0444, st_size=277, ...}) = 0 <0.008756>
10:19:03.820801 stat64(".git/objects/12/0530fb2e10679d9095e278c95c0e98c96f3080", {st_mode=S_IFREG|0444, st_size=277, ...}) = 0 <0.000015>
10:19:03.820927 open(".git/objects/12/0530fb2e10679d9095e278c95c0e98c96f3080", O_RDONLY|O_NOATIME) = 3 <0.000019>
10:19:03.821027 mmap2(NULL, 277, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000017>
10:19:03.821109 close(3) = 0 <0.000011>
10:19:03.838061 munmap(0xb7fc9000, 277) = 0 <0.000029>
10:19:03.838263 stat64(".git/objects/92/d7605b6d9312a29efa30b1baa4d7c880a0be41", {st_mode=S_IFREG|0444, st_size=280, ...}) = 0 <0.032662>
10:19:03.871093 stat64(".git/objects/92/d7605b6d9312a29efa30b1baa4d7c880a0be41", {st_mode=S_IFREG|0444, st_size=280, ...}) = 0 <0.000017>
10:19:03.871238 open(".git/objects/92/d7605b6d9312a29efa30b1baa4d7c880a0be41", O_RDONLY|O_NOATIME) = 3 <0.000020>
10:19:03.871339 mmap2(NULL, 280, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000021>
10:19:03.871426 close(3) = 0 <0.000012>
10:19:03.885472 munmap(0xb7fc9000, 280) = 0 <0.000046>
10:19:03.885707 stat64(".git/objects/58/9ee4d580d34a76238e90795a070a7372de18a2", {st_mode=S_IFREG|0444, st_size=279, ...}) = 0 <0.021423>
10:19:03.907288 stat64(".git/objects/58/9ee4d580d34a76238e90795a070a7372de18a2", {st_mode=S_IFREG|0444, st_size=279, ...}) = 0 <0.000017>
10:19:03.907429 open(".git/objects/58/9ee4d580d34a76238e90795a070a7372de18a2", O_RDONLY|O_NOATIME) = 3 <0.000021>
10:19:03.907531 mmap2(NULL, 279, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000020>
10:19:03.907617 close(3) = 0 <0.000012>
10:19:03.912980 munmap(0xb7fc9000, 279) = 0 <0.000020>
10:19:03.913107 stat64(".git/objects/4c/e643674c24dbda1d0fa0a0da60163ff9ea666f", {st_mode=S_IFREG|0444, st_size=275, ...}) = 0 <0.013600>
10:19:03.926830 stat64(".git/objects/4c/e643674c24dbda1d0fa0a0da60163ff9ea666f", {st_mode=S_IFREG|0444, st_size=275, ...}) = 0 <0.000016>
10:19:03.926958 open(".git/objects/4c/e643674c24dbda1d0fa0a0da60163ff9ea666f", O_RDONLY|O_NOATIME) = 3 <0.000019>
10:19:03.927056 mmap2(NULL, 275, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000016>
10:19:03.927137 close(3) = 0 <0.000011>
10:19:03.939741 munmap(0xb7fc9000, 275) = 0 <0.000023>
10:19:03.939895 stat64(".git/objects/73/8dec0ead6a96f87cf71989a1dad7bb5d1faba4", {st_mode=S_IFREG|0444, st_size=747, ...}) = 0 <0.020027>
10:19:03.960098 stat64(".git/objects/73/8dec0ead6a96f87cf71989a1dad7bb5d1faba4", {st_mode=S_IFREG|0444, st_size=747, ...}) = 0 <0.000292>
10:19:03.960542 open(".git/objects/73/8dec0ead6a96f87cf71989a1dad7bb5d1faba4", O_RDONLY|O_NOATIME) = 3 <0.000020>
10:19:03.960649 mmap2(NULL, 747, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:03.960734 close(3) = 0 <0.000012>
10:19:03.965837 munmap(0xb7fc9000, 747) = 0 <0.000027>
10:19:03.966016 stat64(".git/objects/33/c9db007159db11c1ad5fa7101ea95853740acf", {st_mode=S_IFREG|0444, st_size=469, ...}) = 0 <0.015332>
10:19:03.981493 stat64(".git/objects/33/c9db007159db11c1ad5fa7101ea95853740acf", {st_mode=S_IFREG|0444, st_size=469, ...}) = 0 <0.000016>
10:19:03.981629 open(".git/objects/33/c9db007159db11c1ad5fa7101ea95853740acf", O_RDONLY|O_NOATIME) = 3 <0.000021>
10:19:03.981730 mmap2(NULL, 469, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:03.981815 close(3) = 0 <0.000012>
10:19:03.988857 munmap(0xb7fc9000, 469) = 0 <0.000023>
10:19:03.989010 stat64(".git/objects/84/19a453dc088b25b63ab1746d3d7e679caf686d", {st_mode=S_IFREG|0444, st_size=382, ...}) = 0 <0.020436>
10:19:04.009621 stat64(".git/objects/84/19a453dc088b25b63ab1746d3d7e679caf686d", {st_mode=S_IFREG|0444, st_size=382, ...}) = 0 <0.000016>
10:19:04.009759 open(".git/objects/84/19a453dc088b25b63ab1746d3d7e679caf686d", O_RDONLY|O_NOATIME) = 3 <0.000020>
10:19:04.009860 mmap2(NULL, 382, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:04.009944 close(3) = 0 <0.000012>
10:19:04.017654 munmap(0xb7fc9000, 382) = 0 <0.000021>
10:19:04.017786 stat64(".git/objects/85/ba32e27db65314ad4ea25f5afcaad684d68811", {st_mode=S_IFREG|0444, st_size=275, ...}) = 0 <0.013548>
10:19:04.031456 stat64(".git/objects/85/ba32e27db65314ad4ea25f5afcaad684d68811", {st_mode=S_IFREG|0444, st_size=275, ...}) = 0 <0.000015>
10:19:04.031583 open(".git/objects/85/ba32e27db65314ad4ea25f5afcaad684d68811", O_RDONLY|O_NOATIME) = 3 <0.000020>
10:19:04.031681 mmap2(NULL, 275, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000016>
10:19:04.031763 close(3) = 0 <0.000011>
10:19:04.043476 munmap(0xb7fc9000, 275) = 0 <0.000022>
10:19:04.043619 stat64(".git/objects/91/82013b4241fefc455f07fc78a922c9c149a38b", {st_mode=S_IFREG|0444, st_size=280, ...}) = 0 <0.008078>
10:19:04.051857 stat64(".git/objects/91/82013b4241fefc455f07fc78a922c9c149a38b", {st_mode=S_IFREG|0444, st_size=280, ...}) = 0 <0.000017>
10:19:04.052001 open(".git/objects/91/82013b4241fefc455f07fc78a922c9c149a38b", O_RDONLY|O_NOATIME) = 3 <0.000019>
10:19:04.052102 mmap2(NULL, 280, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000097>
10:19:04.052284 close(3) = 0 <0.000011>
10:19:04.058917 munmap(0xb7fc9000, 280) = 0 <0.000022>
10:19:04.059041 stat64(".git/objects/d2/d79edaf81ec78ad11c8daeb91ee3e82a4aaa19", {st_mode=S_IFREG|0444, st_size=282, ...}) = 0 <0.013396>
10:19:04.072584 stat64(".git/objects/d2/d79edaf81ec78ad11c8daeb91ee3e82a4aaa19", {st_mode=S_IFREG|0444, st_size=282, ...}) = 0 <0.000016>
10:19:04.072725 open(".git/objects/d2/d79edaf81ec78ad11c8daeb91ee3e82a4aaa19", O_RDONLY|O_NOATIME) = 3 <0.000021>
10:19:04.072827 mmap2(NULL, 282, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:04.072911 close(3) = 0 <0.000012>
10:19:04.084973 munmap(0xb7fc9000, 282) = 0 <0.000024>
10:19:04.085140 stat64(".git/objects/bc/3aec1567d09218d319e8053d58fd740e3f6d4a", {st_mode=S_IFREG|0444, st_size=281, ...}) = 0 <0.005028>
10:19:04.090289 stat64(".git/objects/bc/3aec1567d09218d319e8053d58fd740e3f6d4a", {st_mode=S_IFREG|0444, st_size=281, ...}) = 0 <0.000016>
10:19:04.090414 open(".git/objects/bc/3aec1567d09218d319e8053d58fd740e3f6d4a", O_RDONLY|O_NOATIME) = 3 <0.000021>
10:19:04.090515 mmap2(NULL, 281, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000017>
10:19:04.090597 close(3) = 0 <0.000011>
10:19:04.101560 munmap(0xb7fc9000, 281) = 0 <0.000019>
10:19:04.101683 stat64(".git/objects/8c/7a107d8eeba18ae56befb6142daaba91aa3ecf", {st_mode=S_IFREG|0444, st_size=378, ...}) = 0 <0.014772>
10:19:04.116612 stat64(".git/objects/8c/7a107d8eeba18ae56befb6142daaba91aa3ecf", {st_mode=S_IFREG|0444, st_size=378, ...}) = 0 <0.000016>
10:19:04.116745 open(".git/objects/8c/7a107d8eeba18ae56befb6142daaba91aa3ecf", O_RDONLY|O_NOATIME) = 3 <0.000019>
10:19:04.116845 mmap2(NULL, 378, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:04.116928 close(3) = 0 <0.000011>
10:19:04.117185 munmap(0xb7fc9000, 378) = 0 <0.000019>
10:19:04.117305 stat64(".git/objects/ad/86a7fc13a820a56957f41f81c4763f734676f4", {st_mode=S_IFREG|0444, st_size=324, ...}) = 0 <0.029156>
10:19:04.146625 stat64(".git/objects/ad/86a7fc13a820a56957f41f81c4763f734676f4", {st_mode=S_IFREG|0444, st_size=324, ...}) = 0 <0.000017>
10:19:04.146769 open(".git/objects/ad/86a7fc13a820a56957f41f81c4763f734676f4", O_RDONLY|O_NOATIME) = 3 <0.000018>
10:19:04.146868 mmap2(NULL, 324, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:04.146952 close(3) = 0 <0.000011>
10:19:04.156903 munmap(0xb7fc9000, 324) = 0 <0.000023>
10:19:04.157043 stat64(".git/objects/27/da5785a8fec4e462aeee4dc41281ac89233675", {st_mode=S_IFREG|0444, st_size=397, ...}) = 0 <0.027180>
10:19:04.184386 stat64(".git/objects/27/da5785a8fec4e462aeee4dc41281ac89233675", {st_mode=S_IFREG|0444, st_size=397, ...}) = 0 <0.000017>
10:19:04.184532 open(".git/objects/27/da5785a8fec4e462aeee4dc41281ac89233675", O_RDONLY|O_NOATIME) = 3 <0.000022>
10:19:04.184635 mmap2(NULL, 397, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:04.184720 close(3) = 0 <0.000011>
10:19:04.189421 munmap(0xb7fc9000, 397) = 0 <0.000025>
10:19:04.189583 stat64(".git/objects/32/578a62ce8469465504509360aed5f1a6dc5b2b", {st_mode=S_IFREG|0444, st_size=319, ...}) = 0 <0.011685>
10:19:04.201394 stat64(".git/objects/32/578a62ce8469465504509360aed5f1a6dc5b2b", {st_mode=S_IFREG|0444, st_size=319, ...}) = 0 <0.000016>
10:19:04.201521 open(".git/objects/32/578a62ce8469465504509360aed5f1a6dc5b2b", O_RDONLY|O_NOATIME) = 3 <0.000020>
10:19:04.201621 mmap2(NULL, 319, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000018>
10:19:04.201702 close(3) = 0 <0.000012>
10:19:04.216765 munmap(0xb7fc9000, 319) = 0 <0.000027>
10:19:04.216944 stat64(".git/objects/ab/71dde01e310ed582e86446d216531f792468bf", {st_mode=S_IFREG|0444, st_size=325, ...}) = 0 <0.004873>
10:19:04.221941 stat64(".git/objects/ab/71dde01e310ed582e86446d216531f792468bf", {st_mode=S_IFREG|0444, st_size=325, ...}) = 0 <0.000016>
10:19:04.222067 open(".git/objects/ab/71dde01e310ed582e86446d216531f792468bf", O_RDONLY|O_NOATIME) = 3 <0.000021>
10:19:04.222169 mmap2(NULL, 325, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000018>
10:19:04.222253 close(3) = 0 <0.000012>
10:19:04.230433 munmap(0xb7fc9000, 325) = 0 <0.000019>
10:19:04.230556 stat64(".git/objects/d9/b0f913ce0508fcc83e642e0241f373428368e5", {st_mode=S_IFREG|0444, st_size=275, ...}) = 0 <0.014431>
10:19:04.245143 stat64(".git/objects/d9/b0f913ce0508fcc83e642e0241f373428368e5", {st_mode=S_IFREG|0444, st_size=275, ...}) = 0 <0.000017>
10:19:04.245282 open(".git/objects/d9/b0f913ce0508fcc83e642e0241f373428368e5", O_RDONLY|O_NOATIME) = 3 <0.000018>
10:19:04.245380 mmap2(NULL, 275, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:04.245464 close(3) = 0 <0.000011>
10:19:04.259086 munmap(0xb7fc9000, 275) = 0 <0.000021>
10:19:04.259218 stat64(".git/objects/43/14f5982d2aac08001a977fc0b1b611e858e025", {st_mode=S_IFREG|0444, st_size=280, ...}) = 0 <0.012914>
10:19:04.272282 stat64(".git/objects/43/14f5982d2aac08001a977fc0b1b611e858e025", {st_mode=S_IFREG|0444, st_size=280, ...}) = 0 <0.000017>
10:19:04.272425 open(".git/objects/43/14f5982d2aac08001a977fc0b1b611e858e025", O_RDONLY|O_NOATIME) = 3 <0.000022>
10:19:04.272528 mmap2(NULL, 280, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000018>
10:19:04.272611 close(3) = 0 <0.000011>
10:19:04.284930 munmap(0xb7fc9000, 280) = 0 <0.000028>
10:19:04.285142 stat64(".git/objects/87/30a82b9f00b8debab717ec384eedbd0f36a54f", {st_mode=S_IFREG|0444, st_size=294, ...}) = 0 <0.006320>
10:19:04.291672 stat64(".git/objects/87/30a82b9f00b8debab717ec384eedbd0f36a54f", {st_mode=S_IFREG|0444, st_size=294, ...}) = 0 <0.000017>
10:19:04.291825 open(".git/objects/87/30a82b9f00b8debab717ec384eedbd0f36a54f", O_RDONLY|O_NOATIME) = 3 <0.000023>
10:19:04.291929 mmap2(NULL, 294, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000020>
10:19:04.292015 close(3) = 0 <0.000012>
10:19:04.303292 munmap(0xb7fc9000, 294) = 0 <0.000023>
10:19:04.303442 stat64(".git/objects/a4/97d102d6961ded91b60dc3524eb63679d7dc08", {st_mode=S_IFREG|0444, st_size=282, ...}) = 0 <0.012219>
10:19:04.315813 stat64(".git/objects/a4/97d102d6961ded91b60dc3524eb63679d7dc08", {st_mode=S_IFREG|0444, st_size=282, ...}) = 0 <0.000016>
10:19:04.315955 open(".git/objects/a4/97d102d6961ded91b60dc3524eb63679d7dc08", O_RDONLY|O_NOATIME) = 3 <0.000021>
10:19:04.316057 mmap2(NULL, 282, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:04.316141 close(3) = 0 <0.000082>
10:19:04.316530 munmap(0xb7fc9000, 282) = 0 <0.000021>
10:19:04.316655 stat64(".git/objects/95/f1e36cc34e8738e5c431aac47d6fea18913db0", {st_mode=S_IFREG|0444, st_size=395, ...}) = 0 <0.023411>
10:19:04.340297 stat64(".git/objects/95/f1e36cc34e8738e5c431aac47d6fea18913db0", {st_mode=S_IFREG|0444, st_size=395, ...}) = 0 <0.000017>
10:19:04.340444 open(".git/objects/95/f1e36cc34e8738e5c431aac47d6fea18913db0", O_RDONLY|O_NOATIME) = 3 <0.000022>
10:19:04.340547 mmap2(NULL, 395, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:04.340632 close(3) = 0 <0.000012>
10:19:04.349413 munmap(0xb7fc9000, 395) = 0 <0.000024>
10:19:04.349568 stat64(".git/objects/84/13d9ffefd1fde6d8a04f9e22503ab910fc36de", {st_mode=S_IFREG|0444, st_size=1061, ...}) = 0 <0.015285>
10:19:04.365008 stat64(".git/objects/84/13d9ffefd1fde6d8a04f9e22503ab910fc36de", {st_mode=S_IFREG|0444, st_size=1061, ...}) = 0 <0.000017>
10:19:04.365150 open(".git/objects/84/13d9ffefd1fde6d8a04f9e22503ab910fc36de", O_RDONLY|O_NOATIME) = 3 <0.000021>
10:19:04.365252 mmap2(NULL, 1061, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000018>
10:19:04.365335 close(3) = 0 <0.000012>
10:19:04.369839 munmap(0xb7fc9000, 1061) = 0 <0.000021>
10:19:04.369984 stat64(".git/objects/d1/eebeecb839749b1559ec7d44b9a31b2513cfb3", {st_mode=S_IFREG|0444, st_size=279, ...}) = 0 <0.011146>
10:19:04.381282 stat64(".git/objects/d1/eebeecb839749b1559ec7d44b9a31b2513cfb3", {st_mode=S_IFREG|0444, st_size=279, ...}) = 0 <0.000017>
10:19:04.381422 open(".git/objects/d1/eebeecb839749b1559ec7d44b9a31b2513cfb3", O_RDONLY|O_NOATIME) = 3 <0.000020>
10:19:04.381523 mmap2(NULL, 279, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000018>
10:19:04.381607 close(3) = 0 <0.000011>
10:19:04.381899 munmap(0xb7fc9000, 279) = 0 <0.000020>
10:19:04.382020 stat64(".git/objects/10/0490cfcd50d0f9ddadeb90cf5d95b28e2397ce", {st_mode=S_IFREG|0444, st_size=1641, ...}) = 0 <0.023306>
10:19:04.405476 open(".git/objects/10/0490cfcd50d0f9ddadeb90cf5d95b28e2397ce", O_RDONLY|O_NOATIME) = 3 <0.000023>
10:19:04.405599 mmap2(NULL, 1641, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000020>
10:19:04.405684 close(3) = 0 <0.000012>
10:19:04.420508 munmap(0xb7fc9000, 1641) = 0 <0.000025>
10:19:04.420725 stat64(".git/objects/a8/d8dc4c6cd6d4681746fd6919318640ee97a059", {st_mode=S_IFREG|0444, st_size=279, ...}) = 0 <0.007644>
10:19:04.428492 open(".git/objects/a8/d8dc4c6cd6d4681746fd6919318640ee97a059", O_RDONLY|O_NOATIME) = 3 <0.000020>
10:19:04.428599 mmap2(NULL, 279, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000017>
10:19:04.428681 close(3) = 0 <0.000011>
10:19:04.439591 munmap(0xb7fc9000, 279) = 0 <0.000022>
10:19:04.439727 stat64(".git/objects/fa/b4f17015ccb2c6ea978b45386d45dd008df42d", {st_mode=S_IFREG|0444, st_size=278, ...}) = 0 <0.000039>
10:19:04.439879 open(".git/objects/fa/b4f17015ccb2c6ea978b45386d45dd008df42d", O_RDONLY|O_NOATIME) = 3 <0.000020>
10:19:04.439978 mmap2(NULL, 278, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000016>
10:19:04.440060 close(3) = 0 <0.000012>
10:19:04.449022 munmap(0xb7fc9000, 278) = 0 <0.000028>
10:19:04.449236 stat64(".git/objects/3a/41a48d139d1425c1d27e3fbe4f511fb7e09e94", {st_mode=S_IFREG|0444, st_size=278, ...}) = 0 <0.817989>
10:19:05.267499 open(".git/objects/3a/41a48d139d1425c1d27e3fbe4f511fb7e09e94", O_RDONLY|O_NOATIME) = 3 <0.000027>
10:19:05.267643 mmap2(NULL, 278, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000019>
10:19:05.267730 close(3) = 0 <0.000012>
10:19:05.298154 munmap(0xb7fc9000, 278) = 0 <0.000024>
10:19:05.298362 stat64(".git/objects/b9/b0b3d0020c3559d4d9e6d07e3316c3ebcd6e85", {st_mode=S_IFREG|0444, st_size=280, ...}) = 0 <0.025652>
10:19:05.324191 open(".git/objects/b9/b0b3d0020c3559d4d9e6d07e3316c3ebcd6e85", O_RDONLY|O_NOATIME) = 3 <0.000095>
10:19:05.324395 mmap2(NULL, 280, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fc9000 <0.000020>
10:19:05.324483 close(3) = 0 <0.000011>
10:19:05.336149 munmap(0xb7fc9000, 280) = 0 <0.000025>
10:19:05.336371 write(1, "f416f8f2bc74d6d0a refs/tags/v1.1"..., 2675) = 2675 <0.000049>
10:19:05.336516 exit_group(0) = ?
^ permalink raw reply
* Re: git-PS1 bash prompt setting
From: Junio C Hamano @ 2006-11-19 6:28 UTC (permalink / raw)
To: Sean; +Cc: git
In-Reply-To: <BAYC1-PASMTP0635A081EAC964E03599B4AEE80@CEZ.ICE>
Sean <seanlkml@sympatico.ca> writes:
> On Fri, 17 Nov 2006 09:38:02 +0100
> Nicolas Vilz <niv@iaglans.de> wrote:
>
>> Just a note:
>>
>> this doesn't work with bash 3.2. I think they altered the way of
>> trimming variables in this version.
>>
>> on systems with bash 3.2 installed, i get
>> [master!linus-2.6/vm/vm]$
>> with the example above.
>>
>> on systems with bash 3.1, it works properly.
>
> Sorry bout that, I knew it was a bit fragile. Was rather
> comical reading Junio's recent message about all the things not
> to do if you want portable shell code and noticing my 6 line script
> did 90% of them ;o)
Maybe I should have been more explicit when I said "${paremeter##word}
and friends". Might not have been obvious, but I only meant the
following four: %, %%, # and ##.
${parameter/pattern/string} and ${parameter//pattern/string} are
not even in POSIX.
^ permalink raw reply
* Re: [PATCH] do_for_each_ref: perform the same sanity check for leftovers.
From: Junio C Hamano @ 2006-11-19 6:22 UTC (permalink / raw)
To: Shawn Pearce; +Cc: git
In-Reply-To: <20061119061905.GB26670@spearce.org>
Shawn Pearce <spearce@spearce.org> writes:
> Junio C Hamano <junkio@cox.net> wrote:
>> * "pickaxe -L'/^static int do_for_each_ref/,+40' refs.c" turns
>
> What's this pickaxe you speak of? Last I read you deleted it when
> you renamed git-pickaxe to git-blame.
>
> Have you reinvented git-pickaxe so soon? Maybe we could try using
> git-longblade next time a new comamnd is being developed? :-)
Oh, no, I meant "blame".
^ permalink raw reply
* Re: [PATCH] do_for_each_ref: perform the same sanity check for leftovers.
From: Shawn Pearce @ 2006-11-19 6:19 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git, Linus Torvalds
In-Reply-To: <7vr6w07ylu.fsf@assigned-by-dhcp.cox.net>
Junio C Hamano <junkio@cox.net> wrote:
> * "pickaxe -L'/^static int do_for_each_ref/,+40' refs.c" turns
What's this pickaxe you speak of? Last I read you deleted it when
you renamed git-pickaxe to git-blame.
Have you reinvented git-pickaxe so soon? Maybe we could try using
git-longblade next time a new comamnd is being developed? :-)
--
^ permalink raw reply
* [PATCH] do_for_each_ref: perform the same sanity check for leftovers.
From: Junio C Hamano @ 2006-11-19 6:13 UTC (permalink / raw)
To: git; +Cc: Linus Torvalds
An earlier commit b37a562a added a check to see if the ref
points at a valid object (as a part of 'negative ref' support
which we currently do not use), but did so only while iterating
over both packed and loose refs, and forgot to apply the same
check while iterating over the remaining ones.
We might want to replace the "if null then omit it" check with
"eh --- what business does a 0{40} value have here?" complaint
later since we currently do not use negative refs, but that is
a separate issue.
Signed-off-by: Junio C Hamano <junkio@cox.net>
---
* "pickaxe -L'/^static int do_for_each_ref/,+40' refs.c" turns
out to be a very handy way to find out why a line I am
interested in is in that shape.
But it might be even better if it allowed us to say
'-L/^static int do_for_each_ref/+20,+20'.
diff --git a/refs.c b/refs.c
index f003a0b..6abd12f 100644
--- a/refs.c
+++ b/refs.c
@@ -322,6 +322,20 @@ int read_ref(const char *ref, unsigned c
return -1;
}
+static inline int do_one_ref(const char *base, each_ref_fn fn, int trim,
+ void *cb_data, struct ref_list *entry)
+{
+ if (strncmp(base, entry->name, trim))
+ return 0;
+ if (is_null_sha1(entry->sha1))
+ return 0;
+ if (!has_sha1_file(entry->sha1)) {
+ error("%s does not point to a valid object!", entry->name);
+ return 0;
+ }
+ return fn(entry->name + trim, entry->sha1, entry->flag, cb_data);
+}
+
static int do_for_each_ref(const char *base, each_ref_fn fn, int trim,
void *cb_data)
{
@@ -343,29 +357,15 @@ static int do_for_each_ref(const char *b
entry = packed;
packed = packed->next;
}
- if (strncmp(base, entry->name, trim))
- continue;
- if (is_null_sha1(entry->sha1))
- continue;
- if (!has_sha1_file(entry->sha1)) {
- error("%s does not point to a valid object!", entry->name);
- continue;
- }
- retval = fn(entry->name + trim, entry->sha1,
- entry->flag, cb_data);
+ retval = do_one_ref(base, fn, trim, cb_data, entry);
if (retval)
return retval;
}
- packed = packed ? packed : loose;
- while (packed) {
- if (!strncmp(base, packed->name, trim)) {
- retval = fn(packed->name + trim, packed->sha1,
- packed->flag, cb_data);
- if (retval)
- return retval;
- }
- packed = packed->next;
+ for (packed = packed ? packed : loose; packed; packed = packed->next) {
+ retval = do_one_ref(base, fn, trim, cb_data, packed);
+ if (retval)
+ return retval;
}
return 0;
}
^ permalink raw reply related
* gitk feature request: --goto
From: linux @ 2006-11-19 3:32 UTC (permalink / raw)
To: git, paulus; +Cc: linux
I was just writing beginner-level instructions for looking at a specific
commit in gitk ('double-click on the "SHA1 ID" box to selet the contents,
type "5401f304" in its place, and click "goto"'), and it dawned on me that
it would be easier to look at a given commit in context if there was a
--goto <commit-ish> option as well as the usual filtering options.
It might be a nice feature for "git bisect visualize" to preselect the
currently-being-tested commit, for example, rather than making the user
look for the "bisect" head.
And it seems like such a trivial thing to add, I figured I'd ask.
(You can add some highlight options as well, if you feel ambitious,
although I can't think of a use for them right now.)
Oh... when we add the option to have HEAD point to a non-head, it might
be nice to add a green box or other symbol for HEAD, too. Just one more
^ permalink raw reply
* [PATCH] git-fetch.sh: fix fetching of tags that point directly to commits
From: Petr 'Patch Proxy' Baudis @ 2006-11-19 2:59 UTC (permalink / raw)
To: git
git-fetch used to fetch only tags that pointed to tag objects,
because it required a ^{} suffix from git-ls-remote's output.
Not signed off.
---
For similar issue in Cogito, please see
http://news.gmane.org/find-root.php?message_id=<20060427105251.AA4B2353DAC@atlas.denx.de>
Curiously enough, Junio himself posted a patch. Perhaps given his state
as of then he forgot to fix Git as well. ;-)
I did not write this patch. One fellow IRCer did, but for personal
reasons he does not wish to disclose his realname. I think the patch is
trivial enough that copyright problems should not be a issue.
git-fetch.sh | 8 ++++++--
1 files changed, 6 insertions(+), 2 deletions(-)
diff --git a/git-fetch.sh b/git-fetch.sh
index 7442dd2..9074b3f 100755
--- a/git-fetch.sh
+++ b/git-fetch.sh
@@ -430,9 +430,13 @@ case "$no_tags$tags" in
*:refs/*)
# effective only when we are following remote branch
# using local tracking branch.
- taglist=$(IFS=" " &&
+ # If we get both refs/tags/foo and refs/tags/foo^{},
+ # use only the latter and strip the ^{} suffix.
+ taglist=$(
+ IFS=" "; export LC_COLLATE=C
git-ls-remote $upload_pack --tags "$remote" |
- sed -ne 's|^\([0-9a-f]*\)[ ]\(refs/tags/.*\)^{}$|\1 \2|p' |
+ sed -ne 's|^\([0-9a-f]*\)[ \t]\(refs/tags/.*\)$|\1 \2|p' |
+ sort -k2 -r | sed -e 's/\^{}$//' | uniq -f1 |
while read sha1 name
do
git-show-ref --verify --quiet -- $name && continue
--
Petr "Pasky" Baudis
Stuff: http://pasky.or.cz/
The meaning of Stonehenge in Traflamadorian, when viewed from above, is:
"Replacement part being rushed with all possible speed."
^ permalink raw reply related
* Re: [WISH] Store also tag dereferences in packed-refs
From: Linus Torvalds @ 2006-11-19 1:59 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vac2o9pln.fsf@assigned-by-dhcp.cox.net>
On Sat, 18 Nov 2006, Junio C Hamano wrote:
>
> There is something seriously wrong about Marco's number with or
> without my patch. I am getting something like this from
> linux-2.6 with fully packed and pruned refs;
Well, Marco is testing cold-cache numbers. But I agree, even with
cold-cache, it shouldn't be anywhere close to that bad.
^ permalink raw reply
* Re: [WISH] Store also tag dereferences in packed-refs
From: Junio C Hamano @ 2006-11-19 1:45 UTC (permalink / raw)
To: Linus Torvalds; +Cc: git
In-Reply-To: <7vfycg9pu5.fsf@assigned-by-dhcp.cox.net>
Junio C Hamano <junkio@cox.net> writes:
> Linus Torvalds <torvalds@osdl.org> writes:
>
>> On Sun, 19 Nov 2006, Marco Costalba wrote:
>>>
>>> Tested also with show-ref only, not useful to me, but just as a comparison.
>>>
>>> - git tree 1420ms
>>> - linux tree 1021ms
>>>
>>> Better, but still slower then what I would expected.
>>
>> MUCH slower than expected.
There is something seriously wrong about Marco's number with or
without my patch. I am getting something like this from
linux-2.6 with fully packed and pruned refs;
$ /usr/bin/time git-show-ref -d >/dev/null
0.08user 0.00system 0:00.08elapsed 97%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+3314minor)pagefaults 0swaps
$ /usr/bin/time ../git.junio/git-show-ref -d >/dev/null
0.05user 0.01system 0:00.06elapsed 98%CPU (0avgtext+0avgdata 0maxresident)k
0inputs+0outputs (0major+2724minor)pagefaults 0swaps
The second one is with the patch, the first one is from
yesterday's master.
^ permalink raw reply
* Re: [WISH] Store also tag dereferences in packed-refs
From: Junio C Hamano @ 2006-11-19 1:40 UTC (permalink / raw)
To: Linus Torvalds; +Cc: git
In-Reply-To: <Pine.LNX.4.64.0611181706250.3692@woody.osdl.org>
Linus Torvalds <torvalds@osdl.org> writes:
> On Sun, 19 Nov 2006, Marco Costalba wrote:
>>
>> Tested also with show-ref only, not useful to me, but just as a comparison.
>>
>> - git tree 1420ms
>> - linux tree 1021ms
>>
>> Better, but still slower then what I would expected.
>
> MUCH slower than expected.
This is still a WIP and for discussion only (I have to leave to
pick up my wife now so I won't be making any further progress
tonight), but I think parse_object() in show-ref is costing us.
One worry is that existing git will misinterpret packed-refs
file prepared with this version.
If you say "git show-ref -d --tags" to this version, it takes
the fast path which seems to shave about 1/3 of the runtime.
---
diff --git a/builtin-pack-refs.c b/builtin-pack-refs.c
index 042d271..0c770f5 100644
--- a/builtin-pack-refs.c
+++ b/builtin-pack-refs.c
@@ -1,5 +1,7 @@
#include "cache.h"
#include "refs.h"
+#include "object.h"
+#include "tag.h"
static const char builtin_pack_refs_usage[] =
"git-pack-refs [--all] [--prune]";
@@ -29,12 +31,24 @@ static int handle_one_ref(const char *pa
int flags, void *cb_data)
{
struct pack_refs_cb_data *cb = cb_data;
+ int is_tag_ref;
- if (!cb->all && strncmp(path, "refs/tags/", 10))
- return 0;
/* Do not pack the symbolic refs */
- if (!(flags & REF_ISSYMREF))
- fprintf(cb->refs_file, "%s %s\n", sha1_to_hex(sha1), path);
+ if ((flags & REF_ISSYMREF))
+ return 0;
+ is_tag_ref = !strncmp(path, "refs/tags/", 10);
+ if (!cb->all && !is_tag_ref)
+ return 0;
+
+ fprintf(cb->refs_file, "%s %s\n", sha1_to_hex(sha1), path);
+ if (is_tag_ref) {
+ struct object *o = parse_object(sha1);
+ o = deref_tag(o, path, 0);
+ if (o)
+ fprintf(cb->refs_file, "%s %s^{}\n",
+ sha1_to_hex(o->sha1), path);
+ }
+
if (cb->prune && !do_not_prune(flags)) {
int namelen = strlen(path) + 1;
struct ref_to_prune *n = xcalloc(1, sizeof(*n) + namelen);
diff --git a/builtin-show-ref.c b/builtin-show-ref.c
index 06ec400..32cbcb8 100644
--- a/builtin-show-ref.c
+++ b/builtin-show-ref.c
@@ -13,6 +13,7 @@ static int show_ref(const char *refname,
{
struct object *obj;
const char *hex;
+ unsigned char peeled[20];
if (tags_only || heads_only) {
int match;
@@ -44,6 +45,17 @@ static int show_ref(const char *refname,
match:
found_match++;
+
+ /* Fastpath for demonstration only */
+ if (deref_tags && (flag & REF_ISPACKED) &&
+ !peel_ref(refname, peeled) && !quiet && !hash_only) {
+ hex = find_unique_abbrev(sha1, abbrev);
+ printf("%s %s\n", hex, refname);
+ hex = find_unique_abbrev(peeled, abbrev);
+ printf("%s %s^{}\n", hex, refname);
+ return 0;
+ }
+
obj = parse_object(sha1);
if (!obj) {
if (quiet)
@@ -59,8 +71,13 @@ match:
else
printf("%s %s\n", hex, refname);
if (deref_tags && obj->type == OBJ_TAG) {
- obj = deref_tag(obj, refname, 0);
- hex = find_unique_abbrev(obj->sha1, abbrev);
+ unsigned char sha1[20];
+ if ((flag & REF_ISPACKED) && !peel_ref(refname, sha1))
+ hex = find_unique_abbrev(sha1, abbrev);
+ else {
+ obj = deref_tag(obj, refname, 0);
+ hex = find_unique_abbrev(obj->sha1, abbrev);
+ }
printf("%s %s^{}\n", hex, refname);
}
return 0;
diff --git a/refs.c b/refs.c
index f003a0b..347c9b7 100644
--- a/refs.c
+++ b/refs.c
@@ -1,16 +1,18 @@
#include "refs.h"
#include "cache.h"
+#include "object.h"
+#include "tag.h"
#include <errno.h>
struct ref_list {
struct ref_list *next;
- unsigned char flag; /* ISSYMREF? ISPACKED? */
+ unsigned char flag; /* ISSYMREF? ISPACKED? ISPEELED? */
unsigned char sha1[20];
char name[FLEX_ARRAY];
};
-static const char *parse_ref_line(char *line, unsigned char *sha1)
+static const char *parse_ref_line(char *line, unsigned char *sha1, int *flag)
{
/*
* 42: the answer to everything.
@@ -34,6 +36,10 @@ static const char *parse_ref_line(char *
if (line[len] != '\n')
return NULL;
line[len] = 0;
+ if (len < 3 || strcmp(line + len - 3, "^{}"))
+ *flag &= ~REF_ISPEELED;
+ else
+ *flag |= REF_ISPEELED;
return line;
}
@@ -108,10 +114,12 @@ static struct ref_list *get_packed_refs(
char refline[PATH_MAX];
while (fgets(refline, sizeof(refline), f)) {
unsigned char sha1[20];
- const char *name = parse_ref_line(refline, sha1);
+ int flag = REF_ISPACKED;
+ const char *name =
+ parse_ref_line(refline, sha1, &flag);
if (!name)
continue;
- list = add_ref(name, sha1, REF_ISPACKED, list);
+ list = add_ref(name, sha1, flag, list);
}
fclose(f);
refs = list;
@@ -207,7 +215,8 @@ const char *resolve_ref(const char *ref,
if (lstat(path, &st) < 0) {
struct ref_list *list = get_packed_refs();
while (list) {
- if (!strcmp(ref, list->name)) {
+ if (!(list->flag & REF_ISPEELED) &&
+ !strcmp(ref, list->name)) {
hashcpy(sha1, list->sha1);
if (flag)
*flag |= REF_ISPACKED;
@@ -322,6 +331,41 @@ int read_ref(const char *ref, unsigned c
return -1;
}
+int peel_ref(const char *ref, unsigned char *sha1)
+{
+ int flag;
+ unsigned char base[20];
+ struct object *o;
+
+ if (!resolve_ref(ref, base, 1, &flag))
+ return -1;
+
+ if ((flag & REF_ISPACKED)) {
+ struct ref_list *list = get_packed_refs();
+ int len = strlen(ref);
+ while (list) {
+ if ((list->flag & REF_ISPEELED) &&
+ !strncmp(list->name, ref, len) &&
+ strlen(list->name) == len + 3 &&
+ !strcmp(list->name + len, "^{}")) {
+ hashcpy(sha1, list->sha1);
+ return 0;
+ }
+ list = list->next;
+ }
+ /* older pack-refs did not leave peeled ones in */
+ }
+
+ /* otherwise ... */
+ o = parse_object(sha1);
+ o = deref_tag(o, ref, 0);
+ if (o) {
+ hashcpy(sha1, o->sha1);
+ return 0;
+ }
+ return -1;
+}
+
static int do_for_each_ref(const char *base, each_ref_fn fn, int trim,
void *cb_data)
{
@@ -347,6 +391,8 @@ static int do_for_each_ref(const char *b
continue;
if (is_null_sha1(entry->sha1))
continue;
+ if (entry->flag & REF_ISPEELED)
+ continue;
if (!has_sha1_file(entry->sha1)) {
error("%s does not point to a valid object!", entry->name);
continue;
@@ -357,15 +403,22 @@ static int do_for_each_ref(const char *b
return retval;
}
- packed = packed ? packed : loose;
- while (packed) {
- if (!strncmp(base, packed->name, trim)) {
- retval = fn(packed->name + trim, packed->sha1,
- packed->flag, cb_data);
- if (retval)
- return retval;
+ for (packed = packed ? packed : loose; packed; packed = packed->next) {
+ if (strncmp(base, packed->name, trim))
+ continue;
+ if (is_null_sha1(packed->sha1))
+ continue;
+ if (packed->flag & REF_ISPEELED)
+ continue;
+ if (!has_sha1_file(packed->sha1)) {
+ error("%s does not point to a valid object!",
+ packed->name);
+ continue;
}
- packed = packed->next;
+ retval = fn(packed->name + trim, packed->sha1,
+ packed->flag, cb_data);
+ if (retval)
+ return retval;
}
return 0;
}
diff --git a/refs.h b/refs.h
index a57d437..40048a6 100644
--- a/refs.h
+++ b/refs.h
@@ -16,6 +16,8 @@ struct ref_lock {
*/
#define REF_ISSYMREF 01
#define REF_ISPACKED 02
+#define REF_ISPEELED 04 /* internal use */
+
typedef int each_ref_fn(const char *refname, const unsigned char *sha1, int flags, void *cb_data);
extern int head_ref(each_ref_fn, void *);
extern int for_each_ref(each_ref_fn, void *);
@@ -23,6 +25,8 @@ extern int for_each_tag_ref(each_ref_fn,
extern int for_each_branch_ref(each_ref_fn, void *);
extern int for_each_remote_ref(each_ref_fn, void *);
+extern int peel_ref(const char *, unsigned char *);
+
/** Reads the refs file specified into sha1 **/
extern int get_ref_sha1(const char *ref, unsigned char *sha1);
^ permalink raw reply related
* Re: [WISH] Store also tag dereferences in packed-refs
From: Linus Torvalds @ 2006-11-19 1:11 UTC (permalink / raw)
To: Marco Costalba; +Cc: Junio C Hamano, git
In-Reply-To: <e5bfff550611181628o41e11652ycd17ddad5dd21225@mail.gmail.com>
On Sun, 19 Nov 2006, Marco Costalba wrote:
>
> Tested also with show-ref only, not useful to me, but just as a comparison.
>
> - git tree 1420ms
> - linux tree 1021ms
>
> Better, but still slower then what I would expected.
MUCH slower than expected.
Can you do
strace -o tracefile -Ttt git show-ref
and send out the tracefile?
What I _suspect_ is going on is that when you packed your refs, you either
didn't prune them (which means that packing didn't actually help you), or
if you did prune them, since we don't seem to remove the refs
_directories_ when packing, you still have an old and big directory for
.git/refs/tags, and just reading that (empty, but non-shrunken) directory
takes time.
The -Ttt thing should show quite clearly what takes time.
(This, btw, is one _huge_ reason why the old shell script things with
piping sucked. Doing things like performance analysis is so much easier
with a builtin thing and really shows what's going on).
^ permalink raw reply
* Re: [PATCH] Do not ignore hidden refs
From: Petr Baudis @ 2006-11-19 0:48 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vmz6o9t3s.fsf@assigned-by-dhcp.cox.net>
On Sun, Nov 19, 2006 at 01:29:27AM CET, Junio C Hamano wrote:
> My understanding of your original plan was to use ".foo" as
> a private thing for Cogito to use to implement some cleverness
> when the user talks about the branch "foo" (just like StGIT
> uses "refs/bases/foo" to keep track of its private stuff related
> to user branch "foo"). When the user says "my 'foo' branch",
> you were going to munge that name into ".foo" and use both to
> implement that cleverness (just like StGIT uses "refs/bases/foo"
> in addition to "refs/heads/foo" when the user is talking about
> his branch "foo").
(Not a plan, that's what I do now. ;-)
Yes, that's correct, but it's not what I'm talking about anymore - sorry
for the confusion. The proper solution for this is of course to move
this around in the refs/ hierarchy out of heads to a more suitable
place. I'm going to do that in few moments.
What I'm talking about now are _real_ user-visible and user-created
refs, which should however stay local to the repository the user created
them in.
> I would rather think that it would actively be a bad thing to
> make the core level to consider heads/private/foo and heads/foo
> ambiguous. When the user says "my 'foo' branch" that should
> mean the "foo" branch not the "private/foo" branch.
>
> Which certainly suggests that heads/private/, as a user visible
> convention to keep developer-repository private stuff for local
> use, is too verbose.
I don't think the automatic lookup of the branch with private/ prepended
is too bad a thing, but if you have a better solution...
> StGIT's use of refs/bases (i.e. outside refs/heads) is probably
> sensible because it is not something the end user should
> directly muck with nor check out. If Porcelains want some
> "special branch" for their own use to do their magic, however,
> the ref cannot be outside refs/heads for it to be pointed at by
> HEAD to become the "current branch" ("bisect" command comes to
> mind, and I suspect "cg-seek" would have similar issues). But
> that kind of use is all under controll of the Porcelain, and I
> would imagine "too long to type" objection would not apply.
Yes, but what I have on mind are branches the _user_ wants to declare as
local.
--
Petr "Pasky" Baudis
Stuff: http://pasky.or.cz/
The meaning of Stonehenge in Traflamadorian, when viewed from above, is:
"Replacement part being rushed with all possible speed."
^ permalink raw reply
* Re: how to authenticate with git-svn on a subversion repository
From: Anand Kumria @ 2006-11-19 0:43 UTC (permalink / raw)
To: git
In-Reply-To: <m24pszbede.fsf@ziti.local>
On Thu, 16 Nov 2006 07:27:57 -0800, Seth Falcon wrote:
> Comète <comete@archlinuxfr.org> writes:
>
>> hello !
>>
>> i would like to use git-svn to commit some modifications to a
>> Subversion repository but i don't know where i can enter my username
>> and password to commit to the repository ? Is there any special file
>> to put them.
>> For now i get an error:
>
> There may be a better way, but if you just use the svn command line
> client to create a small working copy from the repository, you will
Or, even simpler, use: svn info <url> which will cache the credentials and
not require a working copy.
Anand
^ permalink raw reply
* Re: [PATCH] Do not ignore hidden refs
From: Junio C Hamano @ 2006-11-19 0:29 UTC (permalink / raw)
To: Petr Baudis; +Cc: git
In-Reply-To: <20061118231842.GS7201@pasky.or.cz>
Petr Baudis <pasky@suse.cz> writes:
> On Sat, Nov 18, 2006 at 09:05:12PM CET, Junio C Hamano wrote:
>> use heads/private/ for your own stuff. And have
>> configuration that says "heads/private/" are private
>> branches that are not subject to default
>> pushing/pulling.
>>
>> The real instruction from the project would say what the syntax
>> for telling that to git but I think you got the idea...
>
> Yes, I fully agree that being able to have this configurable is cool,
> but I'm still interested in providing a sensible out-of-the-box default
> configuration for Cogito to use. But if we can agree that heads/private/
> and tags/private/ are good BCP candidates, that's great. (The only
> possible problem is a lot of typing incurred. Perhaps the default refs
> search order should become configurable first.)
It is not clear from the discussion so far why it is necessary
(or even is a good change), and I suspect a confusion to mix up
two different things has slipped in somewhere in the discussion.
My understanding of your original plan was to use ".foo" as
a private thing for Cogito to use to implement some cleverness
when the user talks about the branch "foo" (just like StGIT
uses "refs/bases/foo" to keep track of its private stuff related
to user branch "foo"). When the user says "my 'foo' branch",
you were going to munge that name into ".foo" and use both to
implement that cleverness (just like StGIT uses "refs/bases/foo"
in addition to "refs/heads/foo" when the user is talking about
his branch "foo").
I would rather think that it would actively be a bad thing to
make the core level to consider heads/private/foo and heads/foo
ambiguous. When the user says "my 'foo' branch" that should
mean the "foo" branch not the "private/foo" branch.
Which certainly suggests that heads/private/, as a user visible
convention to keep developer-repository private stuff for local
use, is too verbose.
StGIT's use of refs/bases (i.e. outside refs/heads) is probably
sensible because it is not something the end user should
directly muck with nor check out. If Porcelains want some
"special branch" for their own use to do their magic, however,
the ref cannot be outside refs/heads for it to be pointed at by
HEAD to become the "current branch" ("bisect" command comes to
mind, and I suspect "cg-seek" would have similar issues). But
that kind of use is all under controll of the Porcelain, and I
would imagine "too long to type" objection would not apply.
^ permalink raw reply
* Re: [WISH] Store also tag dereferences in packed-refs
From: Marco Costalba @ 2006-11-19 0:28 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vac2oefuz.fsf@assigned-by-dhcp.cox.net>
>
> A quick one that is to the point to solve "your" problem.
>
> show-ref -d
>
I was out for dinner, just come back home.
Some quick tests with show-ref -d instead of peek-remote:
- git tree 2374ms
- linux tree 2225ms
Not a big change. I reboot before each test to have a guaranteed cold cache.
Tested also with show-ref only, not useful to me, but just as a comparison.
- git tree 1420ms
- linux tree 1021ms
Better, but still slower then what I would expected.
In both case CPU load is low, processes are heavily I/O bound, so
avoiding some fork does not save the day.
Please, tell me if you want me to run some kind of additional test.
> I wonder how fast update-server-info is under the same condition
> with your earlier timing.
>
> I am not suggesting you to use update-server-info. The reason I
> am wondering about it are:
>
> (1) traditionally, "peek-remote ." has been the only way to get
> to that information, so you have every right to keep doing
> so;
>
> (2) however, even with presense of packed-refs, upload-pack
> that is invoked by peek-remote needs to consult unpacked
> refs first and then fall back to packed-refs, and only
> using the ^{} information "cached" in packed-refs file and
> computing ^{} itself when dealing with unpacked refs means
> more code, which we need to assess the pros-and-cons.
>
> (3) another inefficiency of using "peek-remote ." is that it
> spawns another process in the "remote" repo and talks with
> it.
>
> So storing this information making upload-pack to reuse it when
> it can might make things go faster for other applications but
> first I wanted to know how much overhead is incurred in the
> extra upload-pack process, and time update-server-info needs to
> prepare the info in .git/info/refs would be a way to get a rough
> estimate for that (you subtract that from "peek-remote ." time).
>
It's to late to understand this part of your e-mail ;-) I will read
better tomorrow.
Thanks
^ permalink raw reply
* [PATCH] Documentation: Correct alternates documentation, document http-alternates
From: Petr Baudis @ 2006-11-18 23:30 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
For one, the documentation invalidly claimed that the paths have to be
absolute when that's not the case and in fact there is a very valid reason
not to use absolute paths (documented the reason as well).
Signed-off-by: Petr Baudis <pasky@suse.cz>
---
Documentation/repository-layout.txt | 17 ++++++++++++++---
1 files changed, 14 insertions(+), 3 deletions(-)
diff --git a/Documentation/repository-layout.txt b/Documentation/repository-layout.txt
index fd9f406..73a025b 100644
--- a/Documentation/repository-layout.txt
+++ b/Documentation/repository-layout.txt
@@ -52,9 +52,20 @@ objects/info/packs::
by default.
objects/info/alternates::
- This file records absolute filesystem paths of alternate
- object stores that this object store borrows objects
- from, one pathname per line.
+ This file records paths to alternate object stores that
+ this object store borrows objects from, one pathname per
+ line. Note that not only native Git tools use it locally,
+ but the HTTP fetcher also tries to use it remotely; this
+ will usually work if you have relative paths (relative
+ to the object database, not to the repository!) in your
+ alternates file, but it will not work if you use absolute
+ paths unless the absolute path in filesystem and web URL
+ is the same. See also 'objects/info/http-alternates'.
+
+objects/info/http-alternates::
+ This file records URLs to alternate object stores that
+ this object store borrows objects from, to be used when
+ the repository is fetched over HTTP.
refs::
^ permalink raw reply related
* Re: [PATCH] Do not ignore hidden refs
From: Petr Baudis @ 2006-11-18 23:18 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vy7q8bjwn.fsf@assigned-by-dhcp.cox.net>
On Sat, Nov 18, 2006 at 09:05:12PM CET, Junio C Hamano wrote:
> use heads/private/ for your own stuff. And have
> configuration that says "heads/private/" are private
> branches that are not subject to default
> pushing/pulling.
>
> The real instruction from the project would say what the syntax
> for telling that to git but I think you got the idea...
Yes, I fully agree that being able to have this configurable is cool,
but I'm still interested in providing a sensible out-of-the-box default
configuration for Cogito to use. But if we can agree that heads/private/
and tags/private/ are good BCP candidates, that's great. (The only
possible problem is a lot of typing incurred. Perhaps the default refs
search order should become configurable first.)
--
Petr "Pasky" Baudis
Stuff: http://pasky.or.cz/
The meaning of Stonehenge in Traflamadorian, when viewed from above, is:
"Replacement part being rushed with all possible speed."
^ permalink raw reply
* [BUG] gitk: fails while unfolding dir in tree-view
From: Yann Dirson @ 2006-11-18 23:17 UTC (permalink / raw)
To: GIT list
When using the "tree" view and trying to unfold a particular dir, I got
the following error:
can't read "treeheight(lib/)": no such element in array
can't read "treeheight(lib/)": no such element in array
(reading value of variable to increment)
invoked from within
"incr treeheight($x) $n"
(procedure "treeopendir" line 15)
invoked from within
"treeopendir $w $e"
(procedure "treeclick" line 20)
invoked from within
"treeclick .ctop.cdet.right.cfiles 18 233"
(command bound to event)
This occurs with 1.4.3.3 as well as current master. The tree exhibiting
the problem is from http://git.debian.org/git/deps/deps.git - select any
revision, switch to tree view, and attempt to unfold "lib" (the last
entry in the list).
Best regards,
--
Yann.
^ permalink raw reply
* Re: What's in git.git
From: Junio C Hamano @ 2006-11-18 23:14 UTC (permalink / raw)
To: git
In-Reply-To: <7v64dcbdgb.fsf@assigned-by-dhcp.cox.net>
Junio C Hamano <junkio@cox.net> writes:
> - 'pu' has the shallow clone WIP and a half-finished rewrite of
> git branch in C, both by Johannes. Both needs a bit more
> polishing and confidence building before going into 'next',
> and given the recent discussion of enhancing branch
> management for pulls/pushes, it might be easier to drop the
> latter for now.
OOPS; sorry but the latter half is entirely untrue. What's
there is half-done git-shortlog. Scratch everything about
branch management please.
^ permalink raw reply
* Re: [PATCH 1/5] gitweb: Protect against possible warning in git_commitdiff
From: Jakub Narebski @ 2006-11-18 22:38 UTC (permalink / raw)
To: git
In-Reply-To: <11638893431855-git-send-email-jnareb@gmail.com>
Possible _undefined value_ warning.
--
Jakub Narebski
Warsaw, Poland
ShadeHawk on #git
^ permalink raw reply
* [PATCH 4/5] gitweb: Default to $hash_base or HEAD for $hash in "commit" and "commitdiff"
From: Jakub Narebski @ 2006-11-18 22:35 UTC (permalink / raw)
To: git; +Cc: Jakub Narebski
In-Reply-To: <1163889342877-git-send-email-jnareb@gmail.com>
Set $hash parameter to $hash_base || "HEAD" if it is not set (if it is
not true to be more exact). This allows [hand-edited] URLs with 'action'
"commit" or "commitdiff" but without 'hash' parameter.
If there is 'h' (hash) parameter provided, then gitweb tries
to use this. HEAD is used _only_ if nether hash, nor hash_base
are provided, i.e. for URL like below
URL?p=project.git;a=commit
i.e. without neither 'h' nor 'hb'.
Signed-off-by: Jakub Narebski <jnareb@gmail.com>
---
gitweb/gitweb.perl | 2 ++
1 files changed, 2 insertions(+), 0 deletions(-)
diff --git a/gitweb/gitweb.perl b/gitweb/gitweb.perl
index eadaa31..5875ba0 100755
--- a/gitweb/gitweb.perl
+++ b/gitweb/gitweb.perl
@@ -3450,6 +3450,7 @@ sub git_log {
}
sub git_commit {
+ $hash ||= $hash_base || "HEAD";
my %co = parse_commit($hash);
if (!%co) {
die_error(undef, "Unknown commit object");
@@ -3727,6 +3728,7 @@ sub git_blobdiff_plain {
sub git_commitdiff {
my $format = shift || 'html';
+ $hash ||= $hash_base || "HEAD";
my %co = parse_commit($hash);
if (!%co) {
die_error(undef, "Unknown commit object");
--
1.4.3.4
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox