int fsck_error_function(struct fsck_options *o, struct object *obj, int msg_type, const char *message) { if (msg_type == FSCK_WARN) { warning("object %s: %s", describe_object(o, obj), message); return 0; } error("object %s: %s", describe_object(o, obj), message); return 1; }
static int mark_object(struct object *obj, int type, void *data, struct fsck_options *options) { struct object *parent = data; /* * The only case data is NULL or type is OBJ_ANY is when * mark_object_reachable() calls us. All the callers of * that function has non-NULL obj hence ... */ if (!obj) { /* ... these references to parent->fld are safe here */ printf("broken link from %7s %s\n", printable_type(parent), describe_object(parent)); printf("broken link from %7s %s\n", (type == OBJ_ANY ? "unknown" : type_name(type)), "unknown"); errors_found |= ERROR_REACHABLE; return 1; } if (type != OBJ_ANY && obj->type != type) /* ... and the reference to parent is safe here */ objerror(parent, "wrong object type in link"); if (obj->flags & REACHABLE) return 0; obj->flags |= REACHABLE; if (is_promisor_object(&obj->oid)) /* * Further recursion does not need to be performed on this * object since it is a promisor object (so it does not need to * be added to "pending"). */ return 0; if (!(obj->flags & HAS_OBJ)) { if (parent && !has_object_file(&obj->oid)) { printf("broken link from %7s %s\n", printable_type(parent), describe_object(parent)); printf(" to %7s %s\n", printable_type(obj), describe_object(obj)); errors_found |= ERROR_REACHABLE; } return 1; } add_object_array(obj, NULL, &pending); return 0; }
void nh_describe_pos(int x, int y, struct nh_desc_buf *bufs) { int monid = dbuf_get_mon(x, y); bufs->bgdesc[0] = '\0'; bufs->trapdesc[0] = '\0'; bufs->objdesc[0] = '\0'; bufs->mondesc[0] = '\0'; bufs->invisdesc[0] = '\0'; bufs->effectdesc[0] = '\0'; bufs->objcount = -1; if (!program_state.game_running || !api_entry_checkpoint()) return; describe_bg(x, y, level->locations[x][y].mem_bg, bufs->bgdesc); if (level->locations[x][y].mem_trap) strcpy(bufs->trapdesc, trapexplain[level->locations[x][y].mem_trap - 1]); bufs->objcount = describe_object(x, y, level->locations[x][y].mem_obj - 1, bufs->objdesc); describe_mon(x, y, monid - 1, bufs->mondesc); if (level->locations[x][y].mem_invis) strcpy(bufs->invisdesc, invisexplain); if (u.uswallow && (x != u.ux || y != u.uy)) { /* all locations when swallowed other than the hero are the monster */ sprintf(bufs->effectdesc, "interior of %s", Blind ? "a monster" : a_monnam(u.ustuck)); } api_exit(); }
void nh_describe_pos(int x, int y, struct nh_desc_buf *bufs, int *is_in) { bufs->bgdesc[0] = '\0'; bufs->trapdesc[0] = '\0'; bufs->objdesc[0] = '\0'; bufs->mondesc[0] = '\0'; bufs->invisdesc[0] = '\0'; bufs->effectdesc[0] = '\0'; bufs->feature_described = FALSE; bufs->objcount = -1; if (is_in) *is_in = 0; if (!program_state.game_running || !isok(x, y)) return; API_ENTRY_CHECKPOINT_RETURN_VOID_ON_ERROR(); if (is_in) { if (IS_ROCK(level->locations[x][y].typ) || closed_door(level, x, y)) *is_in = 1; else *is_in = 0; } int monid = dbuf_get_mon(x, y); int mem_bg = level->locations[x][y].mem_bg; describe_bg(x, y, mem_bg, bufs->bgdesc); int tt = level->locations[x][y].mem_trap; if (tt) { strcpy(bufs->trapdesc, trapexplain[level->locations[x][y].mem_trap - 1]); if (tt != BEAR_TRAP && tt != WEB && tt != STATUE_TRAP && mem_bg && is_in) *is_in = 1; } bufs->objcount = describe_object(x, y, level->locations[x][y].mem_obj - 1, bufs->objdesc, mem_bg && is_in, &bufs->feature_described); describe_mon(x, y, monid - 1, bufs->mondesc); if (level->locations[x][y].mem_invis) strcpy(bufs->invisdesc, invisexplain); if (Engulfed && (x != u.ux || y != u.uy)) { /* all locations when swallowed other than the hero are the monster */ snprintf(bufs->effectdesc, SIZE(bufs->effectdesc), "interior of %s", Blind ? "a monster" : a_monnam(u.ustuck)); } API_EXIT(); }
static int fsck_obj(struct object *obj) { int err; if (obj->flags & SEEN) return 0; obj->flags |= SEEN; if (verbose) fprintf(stderr, "Checking %s %s\n", printable_type(obj), describe_object(obj)); if (fsck_walk(obj, NULL, &fsck_obj_options)) objerror(obj, "broken links"); err = fsck_object(obj, NULL, 0, &fsck_obj_options); if (err) goto out; if (obj->type == OBJ_COMMIT) { struct commit *commit = (struct commit *) obj; if (!commit->parents && show_root) printf("root %s\n", describe_object(&commit->object)); } if (obj->type == OBJ_TAG) { struct tag *tag = (struct tag *) obj; if (show_tags && tag->tagged) { printf("tagged %s %s", printable_type(tag->tagged), describe_object(tag->tagged)); printf(" (%s) in %s\n", tag->tag, describe_object(&tag->object)); } } out: if (obj->type == OBJ_TREE) free_tree_buffer((struct tree *)obj); if (obj->type == OBJ_COMMIT) free_commit_buffer((struct commit *)obj); return err; }
static void check_object(struct object *obj) { if (verbose) fprintf(stderr, "Checking %s\n", describe_object(obj)); if (obj->flags & REACHABLE) check_reachable_object(obj); else check_unreachable_object(obj); }
static int fsck_walk_tree(struct tree *tree, void *data, struct fsck_options *options) { struct tree_desc desc; struct name_entry entry; int res = 0; const char *name; if (parse_tree(tree)) return -1; name = get_object_name(options, &tree->object); if (init_tree_desc_gently(&desc, tree->buffer, tree->size)) return -1; while (tree_entry_gently(&desc, &entry)) { struct object *obj; int result; if (S_ISGITLINK(entry.mode)) continue; if (S_ISDIR(entry.mode)) { obj = (struct object *)lookup_tree(entry.oid); if (name && obj) put_object_name(options, obj, "%s%s/", name, entry.path); result = options->walk(obj, OBJ_TREE, data, options); } else if (S_ISREG(entry.mode) || S_ISLNK(entry.mode)) { obj = (struct object *)lookup_blob(entry.oid); if (name && obj) put_object_name(options, obj, "%s%s", name, entry.path); result = options->walk(obj, OBJ_BLOB, data, options); } else { result = error("in tree %s: entry %s has bad mode %.6o", describe_object(options, &tree->object), entry.path, entry.mode); } if (result < 0) return result; if (!res) res = result; } return res; }
static int mark_object(struct object *obj, int type, void *data, struct fsck_options *options) { struct object *parent = data; /* * The only case data is NULL or type is OBJ_ANY is when * mark_object_reachable() calls us. All the callers of * that function has non-NULL obj hence ... */ if (!obj) { /* ... these references to parent->fld are safe here */ printf("broken link from %7s %s\n", printable_type(parent), describe_object(parent)); printf("broken link from %7s %s\n", (type == OBJ_ANY ? "unknown" : typename(type)), "unknown"); errors_found |= ERROR_REACHABLE; return 1; }
/* * Check a single reachable object */ static void check_reachable_object(struct object *obj) { /* * We obviously want the object to be parsed, * except if it was in a pack-file and we didn't * do a full fsck */ if (!(obj->flags & HAS_OBJ)) { if (is_promisor_object(&obj->oid)) return; if (has_sha1_pack(obj->oid.hash)) return; /* it is in pack - forget about it */ printf("missing %s %s\n", printable_type(obj), describe_object(obj)); errors_found |= ERROR_REACHABLE; return; } }
int fsck_walk(struct object *obj, void *data, struct fsck_options *options) { if (!obj) return -1; if (obj->type == OBJ_NONE) parse_object(&obj->oid); switch (obj->type) { case OBJ_BLOB: return 0; case OBJ_TREE: return fsck_walk_tree((struct tree *)obj, data, options); case OBJ_COMMIT: return fsck_walk_commit((struct commit *)obj, data, options); case OBJ_TAG: return fsck_walk_tag((struct tag *)obj, data, options); default: error("Unknown object type for %s", describe_object(options, obj)); return -1; } }
static void print_address_description(void *addr) { struct page *page = addr_to_page(addr); dump_stack(); pr_err("\n"); if (page && PageSlab(page)) { struct kmem_cache *cache = page->slab_cache; void *object = nearest_obj(cache, page, addr); describe_object(cache, object, addr); } if (kernel_or_module_addr(addr) && !init_task_stack_addr(addr)) { pr_err("The buggy address belongs to the variable:\n"); pr_err(" %pS\n", addr); } if (page) { pr_err("The buggy address belongs to the page:\n"); dump_page(page, "kasan: bad access detected"); } }
static void objreport(struct object *obj, const char *msg_type, const char *err) { fprintf(stderr, "%s in %s %s: %s\n", msg_type, printable_type(obj), describe_object(obj), err); }
/* * Check a single unreachable object */ static void check_unreachable_object(struct object *obj) { /* * Missing unreachable object? Ignore it. It's not like * we miss it (since it can't be reached), nor do we want * to complain about it being unreachable (since it does * not exist). */ if (!(obj->flags & HAS_OBJ)) return; /* * Unreachable object that exists? Show it if asked to, * since this is something that is prunable. */ if (show_unreachable) { printf("unreachable %s %s\n", printable_type(obj), describe_object(obj)); return; } /* * "!USED" means that nothing at all points to it, including * other unreachable objects. In other words, it's the "tip" * of some set of unreachable objects, usually a commit that * got dropped. * * Such starting points are more interesting than some random * set of unreachable objects, so we show them even if the user * hasn't asked for _all_ unreachable objects. If you have * deleted a branch by mistake, this is a prime candidate to * start looking at, for example. */ if (!(obj->flags & USED)) { if (show_dangling) printf("dangling %s %s\n", printable_type(obj), describe_object(obj)); if (write_lost_and_found) { char *filename = git_pathdup("lost-found/%s/%s", obj->type == OBJ_COMMIT ? "commit" : "other", describe_object(obj)); FILE *f; if (safe_create_leading_directories_const(filename)) { error("Could not create lost-found"); free(filename); return; } f = xfopen(filename, "w"); if (obj->type == OBJ_BLOB) { if (stream_blob_to_fd(fileno(f), &obj->oid, NULL, 1)) die_errno("Could not write '%s'", filename); } else fprintf(f, "%s\n", describe_object(obj)); if (fclose(f)) die_errno("Could not finish '%s'", filename); free(filename); } return; } /* * Otherwise? It's there, it's unreachable, and some other unreachable * object points to it. Ignore it - it's not interesting, and we showed * all the interesting cases above. */ }