git

1
#define USE_THE_REPOSITORY_VARIABLE
2

3
#include "git-compat-util.h"
4
#include "diagnose.h"
5
#include "compat/disk.h"
6
#include "archive.h"
7
#include "dir.h"
8
#include "help.h"
9
#include "gettext.h"
10
#include "hex.h"
11
#include "strvec.h"
12
#include "object-store-ll.h"
13
#include "packfile.h"
14
#include "parse-options.h"
15
#include "write-or-die.h"
16

17
struct archive_dir {
18
	const char *path;
19
	int recursive;
20
};
21

22
struct diagnose_option {
23
	enum diagnose_mode mode;
24
	const char *option_name;
25
};
26

27
static struct diagnose_option diagnose_options[] = {
28
	{ DIAGNOSE_STATS, "stats" },
29
	{ DIAGNOSE_ALL, "all" },
30
};
31

32
int option_parse_diagnose(const struct option *opt, const char *arg, int unset)
33
{
34
	int i;
35
	enum diagnose_mode *diagnose = opt->value;
36

37
	if (!arg) {
38
		*diagnose = unset ? DIAGNOSE_NONE : DIAGNOSE_STATS;
39
		return 0;
40
	}
41

42
	for (i = 0; i < ARRAY_SIZE(diagnose_options); i++) {
43
		if (!strcmp(arg, diagnose_options[i].option_name)) {
44
			*diagnose = diagnose_options[i].mode;
45
			return 0;
46
		}
47
	}
48

49
	return error(_("invalid --%s value '%s'"), opt->long_name, arg);
50
}
51

52
static void dir_file_stats_objects(const char *full_path,
53
				   size_t full_path_len UNUSED,
54
				   const char *file_name, void *data)
55
{
56
	struct strbuf *buf = data;
57
	struct stat st;
58

59
	if (!stat(full_path, &st))
60
		strbuf_addf(buf, "%-70s %16" PRIuMAX "\n", file_name,
61
			    (uintmax_t)st.st_size);
62
}
63

64
static int dir_file_stats(struct object_directory *object_dir, void *data)
65
{
66
	struct strbuf *buf = data;
67

68
	strbuf_addf(buf, "Contents of %s:\n", object_dir->path);
69

70
	for_each_file_in_pack_dir(object_dir->path, dir_file_stats_objects,
71
				  data);
72

73
	return 0;
74
}
75

76
static int count_files(struct strbuf *path)
77
{
78
	DIR *dir = opendir(path->buf);
79
	struct dirent *e;
80
	int count = 0;
81

82
	if (!dir)
83
		return 0;
84

85
	while ((e = readdir_skip_dot_and_dotdot(dir)) != NULL)
86
		if (get_dtype(e, path, 0) == DT_REG)
87
			count++;
88

89
	closedir(dir);
90
	return count;
91
}
92

93
static void loose_objs_stats(struct strbuf *buf, const char *path)
94
{
95
	DIR *dir = opendir(path);
96
	struct dirent *e;
97
	int count;
98
	int total = 0;
99
	unsigned char c;
100
	struct strbuf count_path = STRBUF_INIT;
101
	size_t base_path_len;
102

103
	if (!dir)
104
		return;
105

106
	strbuf_addstr(buf, "Object directory stats for ");
107
	strbuf_add_absolute_path(buf, path);
108
	strbuf_addstr(buf, ":\n");
109

110
	strbuf_add_absolute_path(&count_path, path);
111
	strbuf_addch(&count_path, '/');
112
	base_path_len = count_path.len;
113

114
	while ((e = readdir_skip_dot_and_dotdot(dir)) != NULL)
115
		if (get_dtype(e, &count_path, 0) == DT_DIR &&
116
		    strlen(e->d_name) == 2 &&
117
		    !hex_to_bytes(&c, e->d_name, 1)) {
118
			strbuf_setlen(&count_path, base_path_len);
119
			strbuf_addf(&count_path, "%s/", e->d_name);
120
			total += (count = count_files(&count_path));
121
			strbuf_addf(buf, "%s : %7d files\n", e->d_name, count);
122
		}
123

124
	strbuf_addf(buf, "Total: %d loose objects", total);
125

126
	strbuf_release(&count_path);
127
	closedir(dir);
128
}
129

130
static int add_directory_to_archiver(struct strvec *archiver_args,
131
				     const char *path, int recurse)
132
{
133
	int at_root = !*path;
134
	DIR *dir;
135
	struct dirent *e;
136
	struct strbuf buf = STRBUF_INIT;
137
	size_t len;
138
	int res = 0;
139

140
	dir = opendir(at_root ? "." : path);
141
	if (!dir) {
142
		if (errno == ENOENT) {
143
			warning(_("could not archive missing directory '%s'"), path);
144
			return 0;
145
		}
146
		return error_errno(_("could not open directory '%s'"), path);
147
	}
148

149
	if (!at_root)
150
		strbuf_addf(&buf, "%s/", path);
151
	len = buf.len;
152
	strvec_pushf(archiver_args, "--prefix=%s", buf.buf);
153

154
	while (!res && (e = readdir_skip_dot_and_dotdot(dir))) {
155
		struct strbuf abspath = STRBUF_INIT;
156
		unsigned char dtype;
157

158
		strbuf_add_absolute_path(&abspath, at_root ? "." : path);
159
		strbuf_addch(&abspath, '/');
160
		dtype = get_dtype(e, &abspath, 0);
161

162
		strbuf_setlen(&buf, len);
163
		strbuf_addstr(&buf, e->d_name);
164

165
		if (dtype == DT_REG)
166
			strvec_pushf(archiver_args, "--add-file=%s", buf.buf);
167
		else if (dtype != DT_DIR)
168
			warning(_("skipping '%s', which is neither file nor "
169
				  "directory"), buf.buf);
170
		else if (recurse &&
171
			 add_directory_to_archiver(archiver_args,
172
						   buf.buf, recurse) < 0)
173
			res = -1;
174

175
		strbuf_release(&abspath);
176
	}
177

178
	closedir(dir);
179
	strbuf_release(&buf);
180
	return res;
181
}
182

183
int create_diagnostics_archive(struct strbuf *zip_path, enum diagnose_mode mode)
184
{
185
	struct strvec archiver_args = STRVEC_INIT;
186
	char **argv_copy = NULL;
187
	int stdout_fd = -1, archiver_fd = -1;
188
	struct strbuf buf = STRBUF_INIT;
189
	int res, i;
190
	struct archive_dir archive_dirs[] = {
191
		{ ".git", 0 },
192
		{ ".git/hooks", 0 },
193
		{ ".git/info", 0 },
194
		{ ".git/logs", 1 },
195
		{ ".git/objects/info", 0 }
196
	};
197

198
	if (mode == DIAGNOSE_NONE) {
199
		res = 0;
200
		goto diagnose_cleanup;
201
	}
202

203
	stdout_fd = dup(STDOUT_FILENO);
204
	if (stdout_fd < 0) {
205
		res = error_errno(_("could not duplicate stdout"));
206
		goto diagnose_cleanup;
207
	}
208

209
	archiver_fd = xopen(zip_path->buf, O_CREAT | O_WRONLY | O_TRUNC, 0666);
210
	if (dup2(archiver_fd, STDOUT_FILENO) < 0) {
211
		res = error_errno(_("could not redirect output"));
212
		goto diagnose_cleanup;
213
	}
214

215
	init_zip_archiver();
216
	strvec_pushl(&archiver_args, "git-diagnose", "--format=zip", NULL);
217

218
	strbuf_reset(&buf);
219
	strbuf_addstr(&buf, "Collecting diagnostic info\n\n");
220
	get_version_info(&buf, 1);
221

222
	strbuf_addf(&buf, "Repository root: %s\n", the_repository->worktree);
223
	get_disk_info(&buf);
224
	write_or_die(stdout_fd, buf.buf, buf.len);
225
	strvec_pushf(&archiver_args,
226
		     "--add-virtual-file=diagnostics.log:%.*s",
227
		     (int)buf.len, buf.buf);
228

229
	strbuf_reset(&buf);
230
	strbuf_addstr(&buf, "--add-virtual-file=packs-local.txt:");
231
	dir_file_stats(the_repository->objects->odb, &buf);
232
	foreach_alt_odb(dir_file_stats, &buf);
233
	strvec_push(&archiver_args, buf.buf);
234

235
	strbuf_reset(&buf);
236
	strbuf_addstr(&buf, "--add-virtual-file=objects-local.txt:");
237
	loose_objs_stats(&buf, ".git/objects");
238
	strvec_push(&archiver_args, buf.buf);
239

240
	/* Only include this if explicitly requested */
241
	if (mode == DIAGNOSE_ALL) {
242
		for (i = 0; i < ARRAY_SIZE(archive_dirs); i++) {
243
			if (add_directory_to_archiver(&archiver_args,
244
						      archive_dirs[i].path,
245
						      archive_dirs[i].recursive)) {
246
				res = error_errno(_("could not add directory '%s' to archiver"),
247
						  archive_dirs[i].path);
248
				goto diagnose_cleanup;
249
			}
250
		}
251
	}
252

253
	strvec_pushl(&archiver_args, "--prefix=",
254
		     oid_to_hex(the_hash_algo->empty_tree), "--", NULL);
255

256
	/* `write_archive()` modifies the `argv` passed to it. Let it. */
257
	argv_copy = xmemdupz(archiver_args.v,
258
			     sizeof(char *) * archiver_args.nr);
259
	res = write_archive(archiver_args.nr, (const char **)argv_copy, NULL,
260
			    the_repository, NULL, 0);
261
	if (res) {
262
		error(_("failed to write archive"));
263
		goto diagnose_cleanup;
264
	}
265

266
	fprintf(stderr, "\n"
267
		"Diagnostics complete.\n"
268
		"All of the gathered info is captured in '%s'\n",
269
		zip_path->buf);
270

271
diagnose_cleanup:
272
	if (archiver_fd >= 0) {
273
		dup2(stdout_fd, STDOUT_FILENO);
274
		close(stdout_fd);
275
		close(archiver_fd);
276
	}
277
	free(argv_copy);
278
	strvec_clear(&archiver_args);
279
	strbuf_release(&buf);
280

281
	return res;
282
}
283