Sync with 2.15.4
[git] / list-objects-filter.c
1 #include "cache.h"
2 #include "dir.h"
3 #include "tag.h"
4 #include "commit.h"
5 #include "tree.h"
6 #include "blob.h"
7 #include "diff.h"
8 #include "tree-walk.h"
9 #include "revision.h"
10 #include "list-objects.h"
11 #include "list-objects-filter.h"
12 #include "list-objects-filter-options.h"
13 #include "oidset.h"
14
15 /* Remember to update object flag allocation in object.h */
16 /*
17  * FILTER_SHOWN_BUT_REVISIT -- we set this bit on tree objects
18  * that have been shown, but should be revisited if they appear
19  * in the traversal (until we mark it SEEN).  This is a way to
20  * let us silently de-dup calls to show() in the caller.  This
21  * is subtly different from the "revision.h:SHOWN" and the
22  * "sha1_name.c:ONELINE_SEEN" bits.  And also different from
23  * the non-de-dup usage in pack-bitmap.c
24  */
25 #define FILTER_SHOWN_BUT_REVISIT (1<<21)
26
27 /*
28  * A filter for list-objects to omit ALL blobs from the traversal.
29  * And to OPTIONALLY collect a list of the omitted OIDs.
30  */
31 struct filter_blobs_none_data {
32         struct oidset *omits;
33 };
34
35 static enum list_objects_filter_result filter_blobs_none(
36         enum list_objects_filter_situation filter_situation,
37         struct object *obj,
38         const char *pathname,
39         const char *filename,
40         void *filter_data_)
41 {
42         struct filter_blobs_none_data *filter_data = filter_data_;
43
44         switch (filter_situation) {
45         default:
46                 die("unknown filter_situation");
47                 return LOFR_ZERO;
48
49         case LOFS_BEGIN_TREE:
50                 assert(obj->type == OBJ_TREE);
51                 /* always include all tree objects */
52                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
53
54         case LOFS_END_TREE:
55                 assert(obj->type == OBJ_TREE);
56                 return LOFR_ZERO;
57
58         case LOFS_BLOB:
59                 assert(obj->type == OBJ_BLOB);
60                 assert((obj->flags & SEEN) == 0);
61
62                 if (filter_data->omits)
63                         oidset_insert(filter_data->omits, &obj->oid);
64                 return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
65         }
66 }
67
68 static void *filter_blobs_none__init(
69         struct oidset *omitted,
70         struct list_objects_filter_options *filter_options,
71         filter_object_fn *filter_fn,
72         filter_free_fn *filter_free_fn)
73 {
74         struct filter_blobs_none_data *d = xcalloc(1, sizeof(*d));
75         d->omits = omitted;
76
77         *filter_fn = filter_blobs_none;
78         *filter_free_fn = free;
79         return d;
80 }
81
82 /*
83  * A filter for list-objects to omit large blobs.
84  * And to OPTIONALLY collect a list of the omitted OIDs.
85  */
86 struct filter_blobs_limit_data {
87         struct oidset *omits;
88         unsigned long max_bytes;
89 };
90
91 static enum list_objects_filter_result filter_blobs_limit(
92         enum list_objects_filter_situation filter_situation,
93         struct object *obj,
94         const char *pathname,
95         const char *filename,
96         void *filter_data_)
97 {
98         struct filter_blobs_limit_data *filter_data = filter_data_;
99         unsigned long object_length;
100         enum object_type t;
101
102         switch (filter_situation) {
103         default:
104                 die("unknown filter_situation");
105                 return LOFR_ZERO;
106
107         case LOFS_BEGIN_TREE:
108                 assert(obj->type == OBJ_TREE);
109                 /* always include all tree objects */
110                 return LOFR_MARK_SEEN | LOFR_DO_SHOW;
111
112         case LOFS_END_TREE:
113                 assert(obj->type == OBJ_TREE);
114                 return LOFR_ZERO;
115
116         case LOFS_BLOB:
117                 assert(obj->type == OBJ_BLOB);
118                 assert((obj->flags & SEEN) == 0);
119
120                 t = sha1_object_info(obj->oid.hash, &object_length);
121                 if (t != OBJ_BLOB) { /* probably OBJ_NONE */
122                         /*
123                          * We DO NOT have the blob locally, so we cannot
124                          * apply the size filter criteria.  Be conservative
125                          * and force show it (and let the caller deal with
126                          * the ambiguity).
127                          */
128                         goto include_it;
129                 }
130
131                 if (object_length < filter_data->max_bytes)
132                         goto include_it;
133
134                 if (filter_data->omits)
135                         oidset_insert(filter_data->omits, &obj->oid);
136                 return LOFR_MARK_SEEN; /* but not LOFR_DO_SHOW (hard omit) */
137         }
138
139 include_it:
140         if (filter_data->omits)
141                 oidset_remove(filter_data->omits, &obj->oid);
142         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
143 }
144
145 static void *filter_blobs_limit__init(
146         struct oidset *omitted,
147         struct list_objects_filter_options *filter_options,
148         filter_object_fn *filter_fn,
149         filter_free_fn *filter_free_fn)
150 {
151         struct filter_blobs_limit_data *d = xcalloc(1, sizeof(*d));
152         d->omits = omitted;
153         d->max_bytes = filter_options->blob_limit_value;
154
155         *filter_fn = filter_blobs_limit;
156         *filter_free_fn = free;
157         return d;
158 }
159
160 /*
161  * A filter driven by a sparse-checkout specification to only
162  * include blobs that a sparse checkout would populate.
163  *
164  * The sparse-checkout spec can be loaded from a blob with the
165  * given OID or from a local pathname.  We allow an OID because
166  * the repo may be bare or we may be doing the filtering on the
167  * server.
168  */
169 struct frame {
170         /*
171          * defval is the usual default include/exclude value that
172          * should be inherited as we recurse into directories based
173          * upon pattern matching of the directory itself or of a
174          * containing directory.
175          */
176         int defval;
177
178         /*
179          * 1 if the directory (recursively) contains any provisionally
180          * omitted objects.
181          *
182          * 0 if everything (recursively) contained in this directory
183          * has been explicitly included (SHOWN) in the result and
184          * the directory may be short-cut later in the traversal.
185          */
186         unsigned child_prov_omit : 1;
187 };
188
189 struct filter_sparse_data {
190         struct oidset *omits;
191         struct exclude_list el;
192
193         size_t nr, alloc;
194         struct frame *array_frame;
195 };
196
197 static enum list_objects_filter_result filter_sparse(
198         enum list_objects_filter_situation filter_situation,
199         struct object *obj,
200         const char *pathname,
201         const char *filename,
202         void *filter_data_)
203 {
204         struct filter_sparse_data *filter_data = filter_data_;
205         int val, dtype;
206         struct frame *frame;
207
208         switch (filter_situation) {
209         default:
210                 die("unknown filter_situation");
211                 return LOFR_ZERO;
212
213         case LOFS_BEGIN_TREE:
214                 assert(obj->type == OBJ_TREE);
215                 dtype = DT_DIR;
216                 val = is_excluded_from_list(pathname, strlen(pathname),
217                                             filename, &dtype, &filter_data->el,
218                                             &the_index);
219                 if (val < 0)
220                         val = filter_data->array_frame[filter_data->nr].defval;
221
222                 ALLOC_GROW(filter_data->array_frame, filter_data->nr + 1,
223                            filter_data->alloc);
224                 filter_data->nr++;
225                 filter_data->array_frame[filter_data->nr].defval = val;
226                 filter_data->array_frame[filter_data->nr].child_prov_omit = 0;
227
228                 /*
229                  * A directory with this tree OID may appear in multiple
230                  * places in the tree. (Think of a directory move or copy,
231                  * with no other changes, so the OID is the same, but the
232                  * full pathnames of objects within this directory are new
233                  * and may match is_excluded() patterns differently.)
234                  * So we cannot mark this directory as SEEN (yet), since
235                  * that will prevent process_tree() from revisiting this
236                  * tree object with other pathname prefixes.
237                  *
238                  * Only _DO_SHOW the tree object the first time we visit
239                  * this tree object.
240                  *
241                  * We always show all tree objects.  A future optimization
242                  * may want to attempt to narrow this.
243                  */
244                 if (obj->flags & FILTER_SHOWN_BUT_REVISIT)
245                         return LOFR_ZERO;
246                 obj->flags |= FILTER_SHOWN_BUT_REVISIT;
247                 return LOFR_DO_SHOW;
248
249         case LOFS_END_TREE:
250                 assert(obj->type == OBJ_TREE);
251                 assert(filter_data->nr > 0);
252
253                 frame = &filter_data->array_frame[filter_data->nr];
254                 filter_data->nr--;
255
256                 /*
257                  * Tell our parent directory if any of our children were
258                  * provisionally omitted.
259                  */
260                 filter_data->array_frame[filter_data->nr].child_prov_omit |=
261                         frame->child_prov_omit;
262
263                 /*
264                  * If there are NO provisionally omitted child objects (ALL child
265                  * objects in this folder were INCLUDED), then we can mark the
266                  * folder as SEEN (so we will not have to revisit it again).
267                  */
268                 if (!frame->child_prov_omit)
269                         return LOFR_MARK_SEEN;
270                 return LOFR_ZERO;
271
272         case LOFS_BLOB:
273                 assert(obj->type == OBJ_BLOB);
274                 assert((obj->flags & SEEN) == 0);
275
276                 frame = &filter_data->array_frame[filter_data->nr];
277
278                 dtype = DT_REG;
279                 val = is_excluded_from_list(pathname, strlen(pathname),
280                                             filename, &dtype, &filter_data->el,
281                                             &the_index);
282                 if (val < 0)
283                         val = frame->defval;
284                 if (val > 0) {
285                         if (filter_data->omits)
286                                 oidset_remove(filter_data->omits, &obj->oid);
287                         return LOFR_MARK_SEEN | LOFR_DO_SHOW;
288                 }
289
290                 /*
291                  * Provisionally omit it.  We've already established that
292                  * this pathname is not in the sparse-checkout specification
293                  * with the CURRENT pathname, so we *WANT* to omit this blob.
294                  *
295                  * However, a pathname elsewhere in the tree may also
296                  * reference this same blob, so we cannot reject it yet.
297                  * Leave the LOFR_ bits unset so that if the blob appears
298                  * again in the traversal, we will be asked again.
299                  */
300                 if (filter_data->omits)
301                         oidset_insert(filter_data->omits, &obj->oid);
302
303                 /*
304                  * Remember that at least 1 blob in this tree was
305                  * provisionally omitted.  This prevents us from short
306                  * cutting the tree in future iterations.
307                  */
308                 frame->child_prov_omit = 1;
309                 return LOFR_ZERO;
310         }
311 }
312
313
314 static void filter_sparse_free(void *filter_data)
315 {
316         struct filter_sparse_data *d = filter_data;
317         /* TODO free contents of 'd' */
318         free(d);
319 }
320
321 static void *filter_sparse_oid__init(
322         struct oidset *omitted,
323         struct list_objects_filter_options *filter_options,
324         filter_object_fn *filter_fn,
325         filter_free_fn *filter_free_fn)
326 {
327         struct filter_sparse_data *d = xcalloc(1, sizeof(*d));
328         d->omits = omitted;
329         if (add_excludes_from_blob_to_list(filter_options->sparse_oid_value,
330                                            NULL, 0, &d->el) < 0)
331                 die("could not load filter specification");
332
333         ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc);
334         d->array_frame[d->nr].defval = 0; /* default to include */
335         d->array_frame[d->nr].child_prov_omit = 0;
336
337         *filter_fn = filter_sparse;
338         *filter_free_fn = filter_sparse_free;
339         return d;
340 }
341
342 static void *filter_sparse_path__init(
343         struct oidset *omitted,
344         struct list_objects_filter_options *filter_options,
345         filter_object_fn *filter_fn,
346         filter_free_fn *filter_free_fn)
347 {
348         struct filter_sparse_data *d = xcalloc(1, sizeof(*d));
349         d->omits = omitted;
350         if (add_excludes_from_file_to_list(filter_options->sparse_path_value,
351                                            NULL, 0, &d->el, NULL) < 0)
352                 die("could not load filter specification");
353
354         ALLOC_GROW(d->array_frame, d->nr + 1, d->alloc);
355         d->array_frame[d->nr].defval = 0; /* default to include */
356         d->array_frame[d->nr].child_prov_omit = 0;
357
358         *filter_fn = filter_sparse;
359         *filter_free_fn = filter_sparse_free;
360         return d;
361 }
362
363 typedef void *(*filter_init_fn)(
364         struct oidset *omitted,
365         struct list_objects_filter_options *filter_options,
366         filter_object_fn *filter_fn,
367         filter_free_fn *filter_free_fn);
368
369 /*
370  * Must match "enum list_objects_filter_choice".
371  */
372 static filter_init_fn s_filters[] = {
373         NULL,
374         filter_blobs_none__init,
375         filter_blobs_limit__init,
376         filter_sparse_oid__init,
377         filter_sparse_path__init,
378 };
379
380 void *list_objects_filter__init(
381         struct oidset *omitted,
382         struct list_objects_filter_options *filter_options,
383         filter_object_fn *filter_fn,
384         filter_free_fn *filter_free_fn)
385 {
386         filter_init_fn init_fn;
387
388         assert((sizeof(s_filters) / sizeof(s_filters[0])) == LOFC__COUNT);
389
390         if (filter_options->choice >= LOFC__COUNT)
391                 die("invalid list-objects filter choice: %d",
392                     filter_options->choice);
393
394         init_fn = s_filters[filter_options->choice];
395         if (init_fn)
396                 return init_fn(omitted, filter_options,
397                                filter_fn, filter_free_fn);
398         *filter_fn = NULL;
399         *filter_free_fn = NULL;
400         return NULL;
401 }