1#ifndef REFS_REFS_INTERNAL_H 2#define REFS_REFS_INTERNAL_H 3 4#include"iterator.h" 5 6/* 7 * Data structures and functions for the internal use of the refs 8 * module. Code outside of the refs module should use only the public 9 * functions defined in "refs.h", and should *not* include this file. 10 */ 11 12/* 13 * The following flags can appear in `ref_update::flags`. Their 14 * numerical values must not conflict with those of REF_NO_DEREF and 15 * REF_FORCE_CREATE_REFLOG, which are also stored in 16 * `ref_update::flags`. 17 */ 18 19/* 20 * The reference should be updated to new_oid. 21 */ 22#define REF_HAVE_NEW (1 << 2) 23 24/* 25 * The current reference's value should be checked to make sure that 26 * it agrees with old_oid. 27 */ 28#define REF_HAVE_OLD (1 << 3) 29 30/* 31 * Return the length of time to retry acquiring a loose reference lock 32 * before giving up, in milliseconds: 33 */ 34longget_files_ref_lock_timeout_ms(void); 35 36/* 37 * Return true iff refname is minimally safe. "Safe" here means that 38 * deleting a loose reference by this name will not do any damage, for 39 * example by causing a file that is not a reference to be deleted. 40 * This function does not check that the reference name is legal; for 41 * that, use check_refname_format(). 42 * 43 * A refname that starts with "refs/" is considered safe iff it 44 * doesn't contain any "." or ".." components or consecutive '/' 45 * characters, end with '/', or (on Windows) contain any '\' 46 * characters. Names that do not start with "refs/" are considered 47 * safe iff they consist entirely of upper case characters and '_' 48 * (like "HEAD" and "MERGE_HEAD" but not "config" or "FOO/BAR"). 49 */ 50intrefname_is_safe(const char*refname); 51 52/* 53 * Helper function: return true if refname, which has the specified 54 * oid and flags, can be resolved to an object in the database. If the 55 * referred-to object does not exist, emit a warning and return false. 56 */ 57intref_resolves_to_object(const char*refname, 58const struct object_id *oid, 59unsigned int flags); 60 61enum peel_status { 62/* object was peeled successfully: */ 63 PEEL_PEELED =0, 64 65/* 66 * object cannot be peeled because the named object (or an 67 * object referred to by a tag in the peel chain), does not 68 * exist. 69 */ 70 PEEL_INVALID = -1, 71 72/* object cannot be peeled because it is not a tag: */ 73 PEEL_NON_TAG = -2, 74 75/* ref_entry contains no peeled value because it is a symref: */ 76 PEEL_IS_SYMREF = -3, 77 78/* 79 * ref_entry cannot be peeled because it is broken (i.e., the 80 * symbolic reference cannot even be resolved to an object 81 * name): 82 */ 83 PEEL_BROKEN = -4 84}; 85 86/* 87 * Peel the named object; i.e., if the object is a tag, resolve the 88 * tag recursively until a non-tag is found. If successful, store the 89 * result to oid and return PEEL_PEELED. If the object is not a tag 90 * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively, 91 * and leave oid unchanged. 92 */ 93enum peel_status peel_object(const struct object_id *name,struct object_id *oid); 94 95/* 96 * Copy the reflog message msg to buf, which has been allocated sufficiently 97 * large, while cleaning up the whitespaces. Especially, convert LF to space, 98 * because reflog file is one line per entry. 99 */ 100intcopy_reflog_msg(char*buf,const char*msg); 101 102/** 103 * Information needed for a single ref update. Set new_oid to the new 104 * value or to null_oid to delete the ref. To check the old value 105 * while the ref is locked, set (flags & REF_HAVE_OLD) and set old_oid 106 * to the old value, or to null_oid to ensure the ref does not exist 107 * before update. 108 */ 109struct ref_update { 110/* 111 * If (flags & REF_HAVE_NEW), set the reference to this value 112 * (or delete it, if `new_oid` is `null_oid`). 113 */ 114struct object_id new_oid; 115 116/* 117 * If (flags & REF_HAVE_OLD), check that the reference 118 * previously had this value (or didn't previously exist, if 119 * `old_oid` is `null_oid`). 120 */ 121struct object_id old_oid; 122 123/* 124 * One or more of REF_NO_DEREF, REF_FORCE_CREATE_REFLOG, 125 * REF_HAVE_NEW, REF_HAVE_OLD, or backend-specific flags. 126 */ 127unsigned int flags; 128 129void*backend_data; 130unsigned int type; 131char*msg; 132 133/* 134 * If this ref_update was split off of a symref update via 135 * split_symref_update(), then this member points at that 136 * update. This is used for two purposes: 137 * 1. When reporting errors, we report the refname under which 138 * the update was originally requested. 139 * 2. When we read the old value of this reference, we 140 * propagate it back to its parent update for recording in 141 * the latter's reflog. 142 */ 143struct ref_update *parent_update; 144 145const char refname[FLEX_ARRAY]; 146}; 147 148intrefs_read_raw_ref(struct ref_store *ref_store, 149const char*refname,struct object_id *oid, 150struct strbuf *referent,unsigned int*type); 151 152/* 153 * Write an error to `err` and return a nonzero value iff the same 154 * refname appears multiple times in `refnames`. `refnames` must be 155 * sorted on entry to this function. 156 */ 157intref_update_reject_duplicates(struct string_list *refnames, 158struct strbuf *err); 159 160/* 161 * Add a ref_update with the specified properties to transaction, and 162 * return a pointer to the new object. This function does not verify 163 * that refname is well-formed. new_oid and old_oid are only 164 * dereferenced if the REF_HAVE_NEW and REF_HAVE_OLD bits, 165 * respectively, are set in flags. 166 */ 167struct ref_update *ref_transaction_add_update( 168struct ref_transaction *transaction, 169const char*refname,unsigned int flags, 170const struct object_id *new_oid, 171const struct object_id *old_oid, 172const char*msg); 173 174/* 175 * Transaction states. 176 * 177 * OPEN: The transaction is initialized and new updates can still be 178 * added to it. An OPEN transaction can be prepared, 179 * committed, freed, or aborted (freeing and aborting an open 180 * transaction are equivalent). 181 * 182 * PREPARED: ref_transaction_prepare(), which locks all of the 183 * references involved in the update and checks that the 184 * update has no errors, has been called successfully for the 185 * transaction. A PREPARED transaction can be committed or 186 * aborted. 187 * 188 * CLOSED: The transaction is no longer active. A transaction becomes 189 * CLOSED if there is a failure while building the transaction 190 * or if a transaction is committed or aborted. A CLOSED 191 * transaction can only be freed. 192 */ 193enum ref_transaction_state { 194 REF_TRANSACTION_OPEN =0, 195 REF_TRANSACTION_PREPARED =1, 196 REF_TRANSACTION_CLOSED =2 197}; 198 199/* 200 * Data structure for holding a reference transaction, which can 201 * consist of checks and updates to multiple references, carried out 202 * as atomically as possible. This structure is opaque to callers. 203 */ 204struct ref_transaction { 205struct ref_store *ref_store; 206struct ref_update **updates; 207size_t alloc; 208size_t nr; 209enum ref_transaction_state state; 210void*backend_data; 211}; 212 213/* 214 * Check for entries in extras that are within the specified 215 * directory, where dirname is a reference directory name including 216 * the trailing slash (e.g., "refs/heads/foo/"). Ignore any 217 * conflicting references that are found in skip. If there is a 218 * conflicting reference, return its name. 219 * 220 * extras and skip must be sorted lists of reference names. Either one 221 * can be NULL, signifying the empty list. 222 */ 223const char*find_descendant_ref(const char*dirname, 224const struct string_list *extras, 225const struct string_list *skip); 226 227/* 228 * Check whether an attempt to rename old_refname to new_refname would 229 * cause a D/F conflict with any existing reference (other than 230 * possibly old_refname). If there would be a conflict, emit an error 231 * message and return false; otherwise, return true. 232 * 233 * Note that this function is not safe against all races with other 234 * processes (though rename_ref() catches some races that might get by 235 * this check). 236 */ 237intrefs_rename_ref_available(struct ref_store *refs, 238const char*old_refname, 239const char*new_refname); 240 241/* We allow "recursive" symbolic refs. Only within reason, though */ 242#define SYMREF_MAXDEPTH 5 243 244/* Include broken references in a do_for_each_ref*() iteration: */ 245#define DO_FOR_EACH_INCLUDE_BROKEN 0x01 246 247/* 248 * Reference iterators 249 * 250 * A reference iterator encapsulates the state of an in-progress 251 * iteration over references. Create an instance of `struct 252 * ref_iterator` via one of the functions in this module. 253 * 254 * A freshly-created ref_iterator doesn't yet point at a reference. To 255 * advance the iterator, call ref_iterator_advance(). If successful, 256 * this sets the iterator's refname, oid, and flags fields to describe 257 * the next reference and returns ITER_OK. The data pointed at by 258 * refname and oid belong to the iterator; if you want to retain them 259 * after calling ref_iterator_advance() again or calling 260 * ref_iterator_abort(), you must make a copy. When the iteration has 261 * been exhausted, ref_iterator_advance() releases any resources 262 * assocated with the iteration, frees the ref_iterator object, and 263 * returns ITER_DONE. If you want to abort the iteration early, call 264 * ref_iterator_abort(), which also frees the ref_iterator object and 265 * any associated resources. If there was an internal error advancing 266 * to the next entry, ref_iterator_advance() aborts the iteration, 267 * frees the ref_iterator, and returns ITER_ERROR. 268 * 269 * The reference currently being looked at can be peeled by calling 270 * ref_iterator_peel(). This function is often faster than peel_ref(), 271 * so it should be preferred when iterating over references. 272 * 273 * Putting it all together, a typical iteration looks like this: 274 * 275 * int ok; 276 * struct ref_iterator *iter = ...; 277 * 278 * while ((ok = ref_iterator_advance(iter)) == ITER_OK) { 279 * if (want_to_stop_iteration()) { 280 * ok = ref_iterator_abort(iter); 281 * break; 282 * } 283 * 284 * // Access information about the current reference: 285 * if (!(iter->flags & REF_ISSYMREF)) 286 * printf("%s is %s\n", iter->refname, oid_to_hex(&iter->oid)); 287 * 288 * // If you need to peel the reference: 289 * ref_iterator_peel(iter, &oid); 290 * } 291 * 292 * if (ok != ITER_DONE) 293 * handle_error(); 294 */ 295struct ref_iterator { 296struct ref_iterator_vtable *vtable; 297 298/* 299 * Does this `ref_iterator` iterate over references in order 300 * by refname? 301 */ 302unsigned int ordered :1; 303 304const char*refname; 305const struct object_id *oid; 306unsigned int flags; 307}; 308 309/* 310 * Advance the iterator to the first or next item and return ITER_OK. 311 * If the iteration is exhausted, free the resources associated with 312 * the ref_iterator and return ITER_DONE. On errors, free the iterator 313 * resources and return ITER_ERROR. It is a bug to use ref_iterator or 314 * call this function again after it has returned ITER_DONE or 315 * ITER_ERROR. 316 */ 317intref_iterator_advance(struct ref_iterator *ref_iterator); 318 319/* 320 * If possible, peel the reference currently being viewed by the 321 * iterator. Return 0 on success. 322 */ 323intref_iterator_peel(struct ref_iterator *ref_iterator, 324struct object_id *peeled); 325 326/* 327 * End the iteration before it has been exhausted, freeing the 328 * reference iterator and any associated resources and returning 329 * ITER_DONE. If the abort itself failed, return ITER_ERROR. 330 */ 331intref_iterator_abort(struct ref_iterator *ref_iterator); 332 333/* 334 * An iterator over nothing (its first ref_iterator_advance() call 335 * returns ITER_DONE). 336 */ 337struct ref_iterator *empty_ref_iterator_begin(void); 338 339/* 340 * Return true iff ref_iterator is an empty_ref_iterator. 341 */ 342intis_empty_ref_iterator(struct ref_iterator *ref_iterator); 343 344/* 345 * Return an iterator that goes over each reference in `refs` for 346 * which the refname begins with prefix. If trim is non-zero, then 347 * trim that many characters off the beginning of each refname. flags 348 * can be DO_FOR_EACH_INCLUDE_BROKEN to include broken references in 349 * the iteration. The output is ordered by refname. 350 */ 351struct ref_iterator *refs_ref_iterator_begin( 352struct ref_store *refs, 353const char*prefix,int trim,int flags); 354 355/* 356 * A callback function used to instruct merge_ref_iterator how to 357 * interleave the entries from iter0 and iter1. The function should 358 * return one of the constants defined in enum iterator_selection. It 359 * must not advance either of the iterators itself. 360 * 361 * The function must be prepared to handle the case that iter0 and/or 362 * iter1 is NULL, which indicates that the corresponding sub-iterator 363 * has been exhausted. Its return value must be consistent with the 364 * current states of the iterators; e.g., it must not return 365 * ITER_SKIP_1 if iter1 has already been exhausted. 366 */ 367typedefenum iterator_selection ref_iterator_select_fn( 368struct ref_iterator *iter0,struct ref_iterator *iter1, 369void*cb_data); 370 371/* 372 * Iterate over the entries from iter0 and iter1, with the values 373 * interleaved as directed by the select function. The iterator takes 374 * ownership of iter0 and iter1 and frees them when the iteration is 375 * over. A derived class should set `ordered` to 1 or 0 based on 376 * whether it generates its output in order by reference name. 377 */ 378struct ref_iterator *merge_ref_iterator_begin( 379int ordered, 380struct ref_iterator *iter0,struct ref_iterator *iter1, 381 ref_iterator_select_fn *select,void*cb_data); 382 383/* 384 * An iterator consisting of the union of the entries from front and 385 * back. If there are entries common to the two sub-iterators, use the 386 * one from front. Each iterator must iterate over its entries in 387 * strcmp() order by refname for this to work. 388 * 389 * The new iterator takes ownership of its arguments and frees them 390 * when the iteration is over. As a convenience to callers, if front 391 * or back is an empty_ref_iterator, then abort that one immediately 392 * and return the other iterator directly, without wrapping it. 393 */ 394struct ref_iterator *overlay_ref_iterator_begin( 395struct ref_iterator *front,struct ref_iterator *back); 396 397/* 398 * Wrap iter0, only letting through the references whose names start 399 * with prefix. If trim is set, set iter->refname to the name of the 400 * reference with that many characters trimmed off the front; 401 * otherwise set it to the full refname. The new iterator takes over 402 * ownership of iter0 and frees it when iteration is over. It makes 403 * its own copy of prefix. 404 * 405 * As an convenience to callers, if prefix is the empty string and 406 * trim is zero, this function returns iter0 directly, without 407 * wrapping it. 408 * 409 * The resulting ref_iterator is ordered if iter0 is. 410 */ 411struct ref_iterator *prefix_ref_iterator_begin(struct ref_iterator *iter0, 412const char*prefix, 413int trim); 414 415/* Internal implementation of reference iteration: */ 416 417/* 418 * Base class constructor for ref_iterators. Initialize the 419 * ref_iterator part of iter, setting its vtable pointer as specified. 420 * `ordered` should be set to 1 if the iterator will iterate over 421 * references in order by refname; otherwise it should be set to 0. 422 * This is meant to be called only by the initializers of derived 423 * classes. 424 */ 425voidbase_ref_iterator_init(struct ref_iterator *iter, 426struct ref_iterator_vtable *vtable, 427int ordered); 428 429/* 430 * Base class destructor for ref_iterators. Destroy the ref_iterator 431 * part of iter and shallow-free the object. This is meant to be 432 * called only by the destructors of derived classes. 433 */ 434voidbase_ref_iterator_free(struct ref_iterator *iter); 435 436/* Virtual function declarations for ref_iterators: */ 437 438typedefintref_iterator_advance_fn(struct ref_iterator *ref_iterator); 439 440typedefintref_iterator_peel_fn(struct ref_iterator *ref_iterator, 441struct object_id *peeled); 442 443/* 444 * Implementations of this function should free any resources specific 445 * to the derived class, then call base_ref_iterator_free() to clean 446 * up and free the ref_iterator object. 447 */ 448typedefintref_iterator_abort_fn(struct ref_iterator *ref_iterator); 449 450struct ref_iterator_vtable { 451 ref_iterator_advance_fn *advance; 452 ref_iterator_peel_fn *peel; 453 ref_iterator_abort_fn *abort; 454}; 455 456/* 457 * current_ref_iter is a performance hack: when iterating over 458 * references using the for_each_ref*() functions, current_ref_iter is 459 * set to the reference iterator before calling the callback function. 460 * If the callback function calls peel_ref(), then peel_ref() first 461 * checks whether the reference to be peeled is the one referred to by 462 * the iterator (it usually is) and if so, asks the iterator for the 463 * peeled version of the reference if it is available. This avoids a 464 * refname lookup in a common case. current_ref_iter is set to NULL 465 * when the iteration is over. 466 */ 467externstruct ref_iterator *current_ref_iter; 468 469/* 470 * The common backend for the for_each_*ref* functions. Call fn for 471 * each reference in iter. If the iterator itself ever returns 472 * ITER_ERROR, return -1. If fn ever returns a non-zero value, stop 473 * the iteration and return that value. Otherwise, return 0. In any 474 * case, free the iterator when done. This function is basically an 475 * adapter between the callback style of reference iteration and the 476 * iterator style. 477 */ 478intdo_for_each_ref_iterator(struct ref_iterator *iter, 479 each_ref_fn fn,void*cb_data); 480 481/* 482 * Only include per-worktree refs in a do_for_each_ref*() iteration. 483 * Normally this will be used with a files ref_store, since that's 484 * where all reference backends will presumably store their 485 * per-worktree refs. 486 */ 487#define DO_FOR_EACH_PER_WORKTREE_ONLY 0x02 488 489struct ref_store; 490 491/* refs backends */ 492 493/* ref_store_init flags */ 494#define REF_STORE_READ (1 << 0) 495#define REF_STORE_WRITE (1 << 1)/* can perform update operations */ 496#define REF_STORE_ODB (1 << 2)/* has access to object database */ 497#define REF_STORE_MAIN (1 << 3) 498#define REF_STORE_ALL_CAPS (REF_STORE_READ | \ 499 REF_STORE_WRITE | \ 500 REF_STORE_ODB | \ 501 REF_STORE_MAIN) 502 503/* 504 * Initialize the ref_store for the specified gitdir. These functions 505 * should call base_ref_store_init() to initialize the shared part of 506 * the ref_store and to record the ref_store for later lookup. 507 */ 508typedefstruct ref_store *ref_store_init_fn(const char*gitdir, 509unsigned int flags); 510 511typedefintref_init_db_fn(struct ref_store *refs,struct strbuf *err); 512 513typedefintref_transaction_prepare_fn(struct ref_store *refs, 514struct ref_transaction *transaction, 515struct strbuf *err); 516 517typedefintref_transaction_finish_fn(struct ref_store *refs, 518struct ref_transaction *transaction, 519struct strbuf *err); 520 521typedefintref_transaction_abort_fn(struct ref_store *refs, 522struct ref_transaction *transaction, 523struct strbuf *err); 524 525typedefintref_transaction_commit_fn(struct ref_store *refs, 526struct ref_transaction *transaction, 527struct strbuf *err); 528 529typedefintpack_refs_fn(struct ref_store *ref_store,unsigned int flags); 530typedefintcreate_symref_fn(struct ref_store *ref_store, 531const char*ref_target, 532const char*refs_heads_master, 533const char*logmsg); 534typedefintdelete_refs_fn(struct ref_store *ref_store,const char*msg, 535struct string_list *refnames,unsigned int flags); 536typedefintrename_ref_fn(struct ref_store *ref_store, 537const char*oldref,const char*newref, 538const char*logmsg); 539typedefintcopy_ref_fn(struct ref_store *ref_store, 540const char*oldref,const char*newref, 541const char*logmsg); 542 543/* 544 * Iterate over the references in `ref_store` whose names start with 545 * `prefix`. `prefix` is matched as a literal string, without regard 546 * for path separators. If prefix is NULL or the empty string, iterate 547 * over all references in `ref_store`. The output is ordered by 548 * refname. 549 */ 550typedefstruct ref_iterator *ref_iterator_begin_fn( 551struct ref_store *ref_store, 552const char*prefix,unsigned int flags); 553 554/* reflog functions */ 555 556/* 557 * Iterate over the references in the specified ref_store that have a 558 * reflog. The refs are iterated over in arbitrary order. 559 */ 560typedefstruct ref_iterator *reflog_iterator_begin_fn( 561struct ref_store *ref_store); 562 563typedefintfor_each_reflog_ent_fn(struct ref_store *ref_store, 564const char*refname, 565 each_reflog_ent_fn fn, 566void*cb_data); 567typedefintfor_each_reflog_ent_reverse_fn(struct ref_store *ref_store, 568const char*refname, 569 each_reflog_ent_fn fn, 570void*cb_data); 571typedefintreflog_exists_fn(struct ref_store *ref_store,const char*refname); 572typedefintcreate_reflog_fn(struct ref_store *ref_store,const char*refname, 573int force_create,struct strbuf *err); 574typedefintdelete_reflog_fn(struct ref_store *ref_store,const char*refname); 575typedefintreflog_expire_fn(struct ref_store *ref_store, 576const char*refname,const struct object_id *oid, 577unsigned int flags, 578 reflog_expiry_prepare_fn prepare_fn, 579 reflog_expiry_should_prune_fn should_prune_fn, 580 reflog_expiry_cleanup_fn cleanup_fn, 581void*policy_cb_data); 582 583/* 584 * Read a reference from the specified reference store, non-recursively. 585 * Set type to describe the reference, and: 586 * 587 * - If refname is the name of a normal reference, fill in oid 588 * (leaving referent unchanged). 589 * 590 * - If refname is the name of a symbolic reference, write the full 591 * name of the reference to which it refers (e.g. 592 * "refs/heads/master") to referent and set the REF_ISSYMREF bit in 593 * type (leaving oid unchanged). The caller is responsible for 594 * validating that referent is a valid reference name. 595 * 596 * WARNING: refname might be used as part of a filename, so it is 597 * important from a security standpoint that it be safe in the sense 598 * of refname_is_safe(). Moreover, for symrefs this function sets 599 * referent to whatever the repository says, which might not be a 600 * properly-formatted or even safe reference name. NEITHER INPUT NOR 601 * OUTPUT REFERENCE NAMES ARE VALIDATED WITHIN THIS FUNCTION. 602 * 603 * Return 0 on success. If the ref doesn't exist, set errno to ENOENT 604 * and return -1. If the ref exists but is neither a symbolic ref nor 605 * an object ID, it is broken; set REF_ISBROKEN in type, set errno to 606 * EINVAL, and return -1. If there is another error reading the ref, 607 * set errno appropriately and return -1. 608 * 609 * Backend-specific flags might be set in type as well, regardless of 610 * outcome. 611 * 612 * It is OK for refname to point into referent. If so: 613 * 614 * - if the function succeeds with REF_ISSYMREF, referent will be 615 * overwritten and the memory formerly pointed to by it might be 616 * changed or even freed. 617 * 618 * - in all other cases, referent will be untouched, and therefore 619 * refname will still be valid and unchanged. 620 */ 621typedefintread_raw_ref_fn(struct ref_store *ref_store, 622const char*refname,struct object_id *oid, 623struct strbuf *referent,unsigned int*type); 624 625struct ref_storage_be { 626struct ref_storage_be *next; 627const char*name; 628 ref_store_init_fn *init; 629 ref_init_db_fn *init_db; 630 631 ref_transaction_prepare_fn *transaction_prepare; 632 ref_transaction_finish_fn *transaction_finish; 633 ref_transaction_abort_fn *transaction_abort; 634 ref_transaction_commit_fn *initial_transaction_commit; 635 636 pack_refs_fn *pack_refs; 637 create_symref_fn *create_symref; 638 delete_refs_fn *delete_refs; 639 rename_ref_fn *rename_ref; 640 copy_ref_fn *copy_ref; 641 642 ref_iterator_begin_fn *iterator_begin; 643 read_raw_ref_fn *read_raw_ref; 644 645 reflog_iterator_begin_fn *reflog_iterator_begin; 646 for_each_reflog_ent_fn *for_each_reflog_ent; 647 for_each_reflog_ent_reverse_fn *for_each_reflog_ent_reverse; 648 reflog_exists_fn *reflog_exists; 649 create_reflog_fn *create_reflog; 650 delete_reflog_fn *delete_reflog; 651 reflog_expire_fn *reflog_expire; 652}; 653 654externstruct ref_storage_be refs_be_files; 655externstruct ref_storage_be refs_be_packed; 656 657/* 658 * A representation of the reference store for the main repository or 659 * a submodule. The ref_store instances for submodules are kept in a 660 * linked list. 661 */ 662struct ref_store { 663/* The backend describing this ref_store's storage scheme: */ 664const struct ref_storage_be *be; 665}; 666 667/* 668 * Fill in the generic part of refs and add it to our collection of 669 * reference stores. 670 */ 671voidbase_ref_store_init(struct ref_store *refs, 672const struct ref_storage_be *be); 673 674#endif/* REFS_REFS_INTERNAL_H */